The best way to control Claude Code, Codex and more from any computer or phone

main
ts 275 lines 10.4 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { DurableObjectState } from "@alchemy.run/cloudflare/Workers/DurableObjectState";
3 import type * as cf from "@cloudflare/workers-types";
4 import * as Effect from "effect/Effect";
5 import * as Result from "effect/Result";
6 import * as Stream from "effect/Stream";
7 import { NativeImages } from "./images.ts";
8
9 /** The Durable Object's first image. */
10 export class NativeShell extends Cloudflare.Container<NativeShell>()(
11 "NativeShell",
12 Effect.map(NativeImages, ({ shell }) => ({
13 schedulingPolicy: "durable_object" as const,
14 image: shell,
15 })),
16 ) {}
17
18 /** The Durable Object's second image; without one, the class has only Shell's. */
19 export class NativeTools extends Cloudflare.Container<NativeTools>()(
20 "NativeTools",
21 Effect.map(NativeImages, ({ tools }) => ({
22 schedulingPolicy: "durable_object" as const,
23 image: tools,
24 })),
25 ) {}
26
27 /** The reviewer's own image; NativeShell is shared by both classes. */
28 export class NativeLint extends Cloudflare.Container<NativeLint>()("NativeLint", {
29 schedulingPolicy: "durable_object",
30 image: "alpine:3.19",
31 }) {}
32
33 /** Route names for the two images. */
34 export type ImageName = "shell" | "tools";
35
36 const SLEEP_FOREVER = ["sleep", "infinity"];
37 const SEED_FILE = ["sh", "-c", "printf writable > /redeploy-marker"];
38 const READ_RELEASE_AND_SEED = [
39 "sh",
40 "-c",
41 "cat /etc/alpine-release; cat /redeploy-marker 2>/dev/null || true",
42 ];
43
44 const decode = (bytes: ArrayBuffer) => new TextDecoder().decode(bytes);
45
46 /** Only the registered interception answers this host (see worker.ts). */
47 export const INTERCEPT_HOST = "intercept.internal";
48
49 /** `ctx.exports` entrypoints; workers-types does not type them on DurableObjectState. */
50 interface InterceptExports {
51 default(options: { props: Record<string, never> }): cf.Fetcher;
52 }
53
54 export class NativeObject extends Cloudflare.DurableObject<NativeObject>()(
55 "NativeObject",
56 Effect.gen(function* () {
57 // Both Containers share this object's one container instance; each
58 // handle's start() starts its own image.
59 const handles = { shell: yield* NativeShell, tools: yield* NativeTools };
60 const container = handles.shell;
61 const state = yield* DurableObjectState;
62 /** The image map Cloudflare exposes to this object, keyed by Container id. */
63 const imageMap = Effect.sync(() => state.container?.images ?? {});
64 /** Changes whenever the runtime re-creates this object. */
65 let incarnation: string | undefined;
66
67 const storedMarker = Effect.map(
68 state.storage.get<string>("marker"),
69 (marker) => marker ?? null,
70 );
71
72 /** Run a command in the started container and collect its output. */
73 const run = (cmd: string[]) =>
74 Effect.scoped(Effect.flatMap(container.exec(cmd), (child) => child.output()));
75
76 const startImage = Effect.fn(function* (name: ImageName) {
77 yield* handles[name].start({ entrypoint: SLEEP_FOREVER, enableInternet: false });
78 });
79
80 /** Snapshot a file, prove a fresh start lacks it, then restore it. */
81 const snapshotRoundTrip = Effect.gen(function* () {
82 yield* run(["sh", "-c", "printf persisted > /workspace-file"]);
83 const snapshot = yield* container.snapshotContainer();
84 yield* container.destroy();
85
86 yield* startImage("shell");
87 const fresh = yield* run(["test", "!", "-e", "/workspace-file"]);
88 if (fresh.exitCode !== 0) {
89 return yield* Effect.die("Fresh container retained snapshot file");
90 }
91 yield* container.destroy();
92
93 yield* container.start({
94 containerSnapshot: snapshot,
95 entrypoint: SLEEP_FOREVER,
96 enableInternet: false,
97 });
98 return yield* run(["cat", "/workspace-file"]);
99 });
100
101 /** Pipe "native stdin" through `cat` while collecting its output. */
102 const stdinRoundTrip = Effect.scoped(
103 Effect.gen(function* () {
104 const child = yield* container.exec(["cat"], { stdin: "pipe" });
105 const writeStdin = Stream.make(new TextEncoder().encode("native stdin")).pipe(
106 Stream.run(child.stdin!),
107 );
108 const [, output] = yield* Effect.all([writeStdin, child.output()], {
109 concurrency: "unbounded",
110 });
111 return output;
112 }),
113 );
114
115 const ensureShell = Effect.gen(function* () {
116 if (!(yield* container.running)) yield* startImage("shell");
117 });
118
119 /** Process lifecycle against the real runtime (workerd + Docker or Cloudflare). */
120 const lifecycle = Effect.fn(function* (mode: "interrupt" | "stream" | "monitor" | "intercept") {
121 if (mode === "intercept") {
122 // Started without internet: only this object's interception can answer.
123 yield* ensureShell;
124 // Cloudflare routes intercepted traffic only to a Worker entrypoint or
125 // service binding, so register this Worker's default entrypoint.
126 const exports = (state.raw as unknown as { exports: InterceptExports }).exports;
127 const entrypoint = Cloudflare.fromCloudflareFetcher(exports.default({ props: {} }));
128 yield* container.interceptOutboundHttp(INTERCEPT_HOST, entrypoint);
129 const output = yield* run(["wget", "-qO-", `http://${INTERCEPT_HOST}/hello`]);
130 return {
131 exitCode: output.exitCode,
132 stdout: decode(output.stdout),
133 stderr: decode(output.stderr),
134 };
135 }
136 if (mode === "interrupt") {
137 yield* ensureShell;
138 // Closing the exec scope (here via timeout) must SIGKILL the process.
139 yield* Effect.scoped(
140 Effect.flatMap(container.exec(["sleep", "301"]), (child) => child.exitCode),
141 ).pipe(Effect.timeout("1 second"), Effect.ignore);
142 // `30[1]` keeps pgrep from matching this shell's own command line.
143 // Poll briefly: the kill is delivered asynchronously.
144 const check = yield* run([
145 "sh",
146 "-c",
147 "for i in 1 2 3 4 5 6; do pgrep -f 'sleep 30[1]' >/dev/null || exit 0; sleep 0.5; done; pgrep -f 'sleep 30[1]'",
148 ]);
149 return { remaining: decode(check.stdout).trim() };
150 }
151 if (mode === "stream") {
152 yield* ensureShell;
153 const chunks = yield* Effect.scoped(
154 Effect.gen(function* () {
155 const child = yield* container.exec(["sh", "-c", "printf a; sleep 0.2; printf b"]);
156 return yield* Stream.runCollect(child.stdout!);
157 }),
158 );
159 return { stdout: chunks.map((chunk) => new TextDecoder().decode(chunk)).join("") };
160 }
161 if (yield* container.running) yield* container.destroy();
162 yield* container.start({
163 entrypoint: ["sh", "-c", "exit 3"],
164 enableInternet: false,
165 });
166 const result = yield* container.monitor().pipe(Effect.result);
167 return Result.isFailure(result)
168 ? { failed: true, tag: result.failure._tag }
169 : { failed: false, tag: undefined };
170 });
171
172 return Effect.succeed({
173 lifecycle,
174 metadata: Effect.fn(function* () {
175 incarnation ??= crypto.randomUUID();
176 return {
177 id: state.id.toString(),
178 incarnation,
179 images: yield* imageMap,
180 stored: yield* storedMarker,
181 };
182 }),
183 evict: () => state.abort("container image eviction probe", { retryAlarm: false }),
184 revision: () =>
185 Effect.promise(async () => {
186 const { env } = await import("cloudflare:workers");
187 return (env as { IMAGE_REVISION: string }).IMAGE_REVISION;
188 }),
189 /** Report which image is running and whether the seeded file survived. */
190 probe: Effect.fn(function* (options: { seed: boolean; restart: boolean; image: ImageName }) {
191 if (options.restart) yield* container.destroy();
192
193 const wasRunning = yield* container.running;
194 if (!wasRunning) yield* startImage(options.image);
195 if (options.seed) {
196 yield* state.storage.put("marker", "durable");
197 yield* run(SEED_FILE);
198 }
199
200 const output = yield* run(READ_RELEASE_AND_SEED);
201 const [release, file] = decode(output.stdout).split("\n");
202 return {
203 wasRunning,
204 configured: yield* handles[options.image].image,
205 inspected: (yield* container.inspect())?.image,
206 release,
207 file,
208 stored: yield* storedMarker,
209 };
210 }),
211 // The Durable Object's own RPC can be named exec; it is separate from
212 // the container handle's exec.
213 exec: Effect.fn(function* (
214 mode: "exec" | "stdin" | "snapshot" = "exec",
215 image: ImageName = "shell",
216 ) {
217 if (!(yield* container.running)) {
218 yield* handles[image].start({
219 entrypoint: SLEEP_FOREVER,
220 enableInternet: false,
221 instance: "lite",
222 });
223 }
224
225 let output: Cloudflare.Containers.ContainerExecOutput;
226 if (mode === "snapshot") {
227 output = yield* snapshotRoundTrip;
228 } else if (mode === "stdin") {
229 output = yield* stdinRoundTrip;
230 } else {
231 output = yield* run(["sh", "-c", "printf native; exit 7"]);
232 }
233 const release = yield* run(["cat", "/etc/alpine-release"]);
234
235 return {
236 stdout: decode(output.stdout),
237 exitCode: output.exitCode,
238 release: decode(release.stdout).trim(),
239 images: Object.keys(yield* imageMap).sort(),
240 };
241 }),
242 });
243 }),
244 ) {}
245
246 /**
247 * A second class on the same Worker. It shares `NativeShell` with
248 * `NativeObject` and adds `NativeLint`, so each class has its own container
249 * application and image map.
250 */
251 export class NativeReviewer extends Cloudflare.DurableObject<NativeReviewer>()(
252 "NativeReviewer",
253 Effect.gen(function* () {
254 const handles = { shell: yield* NativeShell, lint: yield* NativeLint };
255 const state = yield* DurableObjectState;
256 const run = (cmd: string[]) =>
257 Effect.scoped(Effect.flatMap(handles.shell.exec(cmd), (child) => child.output()));
258
259 return Effect.succeed({
260 exec: Effect.fn(function* (image: "shell" | "lint") {
261 if (!(yield* handles.shell.running)) {
262 yield* handles[image].start({ entrypoint: SLEEP_FOREVER, enableInternet: false });
263 }
264 const output = yield* run(["sh", "-c", "printf native; exit 7"]);
265 const release = yield* run(["cat", "/etc/alpine-release"]);
266 return {
267 stdout: decode(output.stdout),
268 exitCode: output.exitCode,
269 release: decode(release.stdout).trim(),
270 images: Object.keys(state.container?.images ?? {}).sort(),
271 };
272 }),
273 });
274 }),
275 ) {}