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

main
ts 229 lines 7.89 KB
Raw
1 import { bootstrap } from "@alchemy.run/fly/Bootstrap";
2 import { HttpServer, NodeHttpServer } from "alchemy/Http";
3 import { runProcess } from "alchemy/Runtime/Bootstrap";
4 import { createContainerRuntimeContext } from "alchemy/Runtime/Process";
5 import * as Data from "effect/Data";
6 import * as Effect from "effect/Effect";
7 import * as Exit from "effect/Exit";
8 import * as Fiber from "effect/Fiber";
9 import { HttpServerRequest } from "effect/http/HttpServerRequest";
10 import * as HttpServerResponse from "effect/http/HttpServerResponse";
11 import * as Scope from "effect/Scope";
12 import * as Stream from "effect/Stream";
13
14 Effect.runSync(
15 Effect.sync(() => {
16 if (process.env.RECORD_SHUTDOWN_TIMING !== "1") return;
17 let started: number | undefined;
18 const onSignal = () => {
19 started ??= performance.now();
20 };
21 process.prependOnceListener("SIGTERM", onSignal);
22 process.prependOnceListener("SIGINT", onSignal);
23 process.once("exit", () => {
24 if (started !== undefined) {
25 console.error(`shutdown elapsed ms: ${performance.now() - started}`);
26 }
27 });
28 }),
29 );
30
31 const event = (message: string) => Effect.sync(() => console.log(message));
32 let dependencyOpen = true;
33 const useDependency = Effect.sync(() => {
34 if (!dependencyOpen) throw new Error("dependency already closed");
35 });
36
37 const handler = Effect.gen(function* () {
38 const request = yield* HttpServerRequest;
39 if (request.url === "/health") return HttpServerResponse.text("ok");
40 yield* Effect.addFinalizer(() =>
41 useDependency.pipe(Effect.andThen(event("request dependency released"))),
42 );
43 yield* Effect.addFinalizer(() =>
44 useDependency.pipe(
45 Effect.andThen(event("request finalized")),
46 Effect.andThen(
47 process.env.FAIL_REQUEST_FINALIZER === "1"
48 ? Effect.sleep("100 millis").pipe(
49 Effect.andThen(Effect.die(new Error("request cleanup defect"))),
50 )
51 : Effect.void,
52 ),
53 ),
54 );
55 yield* event("request started");
56 if (request.url === "/handler-error") {
57 return yield* Effect.die(new Error("ordinary handler defect"));
58 }
59 if (request.url === "/hang") return yield* Effect.never;
60 if (request.url === "/stream-large") {
61 return HttpServerResponse.stream(
62 Stream.range(0, 15).pipe(
63 Stream.mapEffect((index) =>
64 Effect.sleep("60 millis").pipe(
65 Effect.andThen(useDependency),
66 Effect.andThen(event(index === 15 ? "chunk last" : `chunk ${index}`)),
67 Effect.andThen(
68 Effect.sync(() =>
69 new TextEncoder().encode(String(index).padStart(2, "0").repeat(8192)),
70 ),
71 ),
72 ),
73 ),
74 ),
75 );
76 }
77 if (request.url === "/stream" || request.url === "/stream-hang") {
78 const body = Stream.fromArray(["first\n", "second\n", "last\n"]).pipe(
79 Stream.mapEffect((chunk) =>
80 Effect.sleep("300 millis").pipe(
81 Effect.andThen(useDependency),
82 Effect.andThen(event(`chunk ${chunk.trim()}`)),
83 Effect.andThen(Effect.sync(() => new TextEncoder().encode(chunk))),
84 ),
85 ),
86 );
87 return HttpServerResponse.stream(
88 request.url === "/stream-hang"
89 ? body.pipe(Stream.concat(Stream.fromEffect(Effect.never)))
90 : body,
91 );
92 }
93 yield* Effect.sleep("900 millis");
94 yield* useDependency;
95 yield* event("response ready");
96 return HttpServerResponse.text("completed");
97 });
98
99 class StopFailed extends Data.TaggedError("StopFailed") {}
100
101 const worker = (name: string, mode: string) =>
102 Effect.gen(function* () {
103 let clientOpen = true;
104 yield* Effect.addFinalizer(() =>
105 useDependency.pipe(
106 Effect.andThen(
107 Effect.sync(() => {
108 clientOpen = false;
109 }),
110 ),
111 Effect.andThen(event(`${name} client released`)),
112 ),
113 );
114 const workScope = yield* Scope.make();
115 yield* Effect.addFinalizer((exit) =>
116 Scope.close(workScope, exit).pipe(Effect.andThen(event(`${name} work scope closed`))),
117 );
118 const pollScope = yield* Scope.make();
119 yield* Effect.addFinalizer((exit) => Scope.close(pollScope, exit));
120 const jobs: Fiber.Fiber<void, never>[] = [];
121 let accepting = true;
122 let claims = 0;
123 const claim = Effect.gen(function* () {
124 if (!accepting) return;
125 const id = ++claims;
126 yield* event(`${name} claim ${id}`);
127 const job = Effect.gen(function* () {
128 yield* Effect.addFinalizer(() => event(`${name} job ${id} finalized`));
129 yield* mode === "job-hang" ? Effect.never : Effect.sleep("900 millis");
130 yield* useDependency;
131 yield* Effect.sync(() => {
132 if (!clientOpen) throw new Error("client already closed");
133 });
134 yield* event(`${name} job ${id} completed`);
135 }).pipe(Effect.scoped, Effect.forkIn(workScope));
136 jobs.push(yield* job);
137 });
138 if (mode !== "stop-delay-empty") yield* claim;
139 const poller = yield* Effect.sleep("150 millis").pipe(
140 Effect.andThen(claim),
141 Effect.forever,
142 Effect.forkIn(pollScope),
143 );
144 const stop = Effect.gen(function* () {
145 yield* event(`${name} stop started`);
146 if (mode === "stop-hang") yield* Effect.never;
147 if (mode === "stop-delay" || mode === "stop-delay-empty") {
148 yield* Effect.sleep("700 millis");
149 }
150 if (mode === "stop-fail") return yield* Effect.fail(new StopFailed());
151 accepting = false;
152 yield* Fiber.interrupt(poller);
153 yield* event(`${name} stopped ${claims}`);
154 });
155 yield* Effect.addFinalizer(() =>
156 stop.pipe(
157 Effect.andThen(
158 Effect.gen(function* () {
159 yield* event(`${name} drain started`);
160 yield* Effect.forEach(jobs, Fiber.join, {
161 concurrency: "unbounded",
162 });
163 yield* useDependency;
164 yield* event(`${name} drained`);
165 }),
166 ),
167 Effect.catchTag("StopFailed", (error) =>
168 Effect.gen(function* () {
169 accepting = false;
170 yield* Fiber.interrupt(poller);
171 yield* event(`${name} checkpoint`);
172 yield* Scope.close(workScope, Exit.void);
173 return yield* Effect.die(error);
174 }),
175 ),
176 ),
177 );
178 yield* event(`${name} ready`);
179 const requestedExit = name === "worker1" ? process.env.RUN_EXIT : undefined;
180 if (mode === "normal" || requestedExit === "normal") return;
181 if (mode === "error-delay") yield* Effect.sleep("600 millis");
182 if (mode === "error" || mode === "error-delay" || requestedExit === "error") {
183 return yield* Effect.die(new Error("worker failed"));
184 }
185 yield* Effect.never;
186 });
187
188 const host = createContainerRuntimeContext("Fly.Service")("fixture");
189 const httpProgram = Effect.gen(function* () {
190 const server = yield* HttpServer;
191 yield* server.serve(handler);
192 yield* event("http ready");
193 yield* Effect.never;
194 });
195
196 const entrypoint = Effect.gen(function* () {
197 yield* Effect.addFinalizer(() =>
198 event("instance finalizing").pipe(
199 Effect.andThen(process.env.HANG_FINALIZER === "1" ? Effect.never : Effect.sleep("40 millis")),
200 Effect.andThen(
201 Effect.sync(() => {
202 dependencyOpen = false;
203 }),
204 ),
205 Effect.andThen(event("instance finalized")),
206 Effect.andThen(
207 process.env.FAIL_FINALIZER === "1"
208 ? Effect.die(new Error("dependency finalizer failed"))
209 : Effect.void,
210 ),
211 ),
212 );
213 if (process.env.WORKERS) {
214 const first = worker("worker1", process.env.WORKER_MODE ?? "drain");
215 yield* host.run(process.env.NESTED_WORKER === "1" ? Effect.scoped(first) : first);
216 if (process.env.WORKERS === "2") yield* host.run(worker("worker2", "drain"));
217 }
218 if (process.env.RUN_ONLY !== "1") yield* host.run(httpProgram);
219 return { RuntimeContext: host };
220 });
221
222 if (process.env.UNMANAGED_HOST === "1") {
223 await runProcess(
224 "Unmanaged service",
225 httpProgram.pipe(Effect.provide(NodeHttpServer()), Effect.scoped),
226 );
227 } else {
228 await bootstrap(entrypoint);
229 }