The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import http from "node:http"; |
| 2 | |
| 3 | const machine = process.env.FLY_MACHINE_ID; |
| 4 | const version = process.env.VERSION; |
| 5 | const mode = process.env.MODE || "drain"; |
| 6 | const afterSignal = Number(process.env.AFTER_SIGNAL_MS || "1000"); |
| 7 | const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); |
| 8 | const call = async (operation, args = []) => { |
| 9 | const response = await fetch(process.env.LEDGER_URL, { |
| 10 | method: "POST", |
| 11 | headers: { |
| 12 | authorization: `Bearer ${process.env.LEDGER_TOKEN}`, |
| 13 | "content-type": "application/json", |
| 14 | }, |
| 15 | body: JSON.stringify({ operation, args }), |
| 16 | signal: AbortSignal.timeout(5000), |
| 17 | }); |
| 18 | if (!response.ok) throw new Error(`ledger HTTP ${response.status}`); |
| 19 | return (await response.json()).result; |
| 20 | }; |
| 21 | const event = (name, fields = {}) => |
| 22 | call("event", [JSON.stringify({ event: name, machine, version, ...fields })]); |
| 23 | let resolveStop; |
| 24 | const stopping = new Promise((resolve) => { |
| 25 | resolveStop = resolve; |
| 26 | }); |
| 27 | const jobs = new Set(); |
| 28 | let workerClientOpen = true; |
| 29 | const workerCall = (operation, args) => { |
| 30 | if (!workerClientOpen) throw new Error("worker queue client already released"); |
| 31 | return call(operation, args); |
| 32 | }; |
| 33 | const requestFinalizers = []; |
| 34 | let accepting = true; |
| 35 | let poll; |
| 36 | let started = false; |
| 37 | const server = http.createServer(async (request, response) => { |
| 38 | try { |
| 39 | if (request.url === "/health") return response.end("ready"); |
| 40 | if (request.url === "/") return response.end(JSON.stringify({ machine, version })); |
| 41 | await event("request-started"); |
| 42 | response.once("finish", () => requestFinalizers.push(event("request-finalized"))); |
| 43 | // Fly's proxy may close a connection that moves no bytes for 60s; heartbeat with |
| 44 | // whitespace (JSON padding / blank stream lines) until the post-stop tail is ready. |
| 45 | const beat = request.url === "/stream" ? "\n" : " "; |
| 46 | response.write(request.url === "/stream" ? "first\n".repeat(32768) : beat); |
| 47 | const heartbeat = setInterval(() => response.write(beat), 10_000); |
| 48 | try { |
| 49 | await stopping; |
| 50 | await sleep(afterSignal); |
| 51 | await event("response-finished"); |
| 52 | } finally { |
| 53 | clearInterval(heartbeat); |
| 54 | } |
| 55 | response.end( |
| 56 | request.url === "/stream" ? "last\n".repeat(32768) : JSON.stringify({ machine, version }), |
| 57 | ); |
| 58 | } catch (error) { |
| 59 | console.error(error); |
| 60 | response.destroy(); |
| 61 | } |
| 62 | }); |
| 63 | const processJob = async (job) => { |
| 64 | if (!job.checkpoint && job.kind !== "quick") { |
| 65 | await stopping; |
| 66 | if (job.kind === "checkpoint") { |
| 67 | await workerCall("checkpoint", [job.id, job.job, machine]); |
| 68 | return; |
| 69 | } |
| 70 | await sleep(afterSignal); |
| 71 | } else await sleep(100); |
| 72 | await workerCall("finish", [job.id, job.job, machine]); |
| 73 | }; |
| 74 | const acquire = async () => { |
| 75 | if (!accepting) return; |
| 76 | await workerCall("tick", [machine, version]); |
| 77 | const result = await workerCall("claim", [machine, version]); |
| 78 | if (!result) return; |
| 79 | const job = JSON.parse(result); |
| 80 | const running = processJob(job) |
| 81 | .catch(async (error) => { |
| 82 | process.exitCode = 1; |
| 83 | console.error(error); |
| 84 | await workerCall("checkpoint", [job.id, job.job, machine]); |
| 85 | }) |
| 86 | .finally(() => { |
| 87 | jobs.delete(running); |
| 88 | }); |
| 89 | jobs.add(running); |
| 90 | }; |
| 91 | const timer = setInterval(() => { |
| 92 | if (poll || !accepting) return; |
| 93 | poll = acquire() |
| 94 | .catch((error) => { |
| 95 | console.error(error); |
| 96 | process.exitCode = 1; |
| 97 | }) |
| 98 | .finally(() => { |
| 99 | poll = undefined; |
| 100 | }); |
| 101 | }, 250); |
| 102 | const shutdown = async (signal) => { |
| 103 | if (started) return; |
| 104 | started = true; |
| 105 | setTimeout(() => process.exit(1), Number(process.env.SHUTDOWN_MS || "30000") * 0.9); |
| 106 | const httpClosed = new Promise((resolve) => server.close(resolve)); |
| 107 | await event("stop-started", { worker: "a", signal }); |
| 108 | if (mode === "stop-delay") await sleep(1000); |
| 109 | accepting = false; |
| 110 | clearInterval(timer); |
| 111 | await poll; |
| 112 | await event("stopped", { worker: "a" }); |
| 113 | resolveStop(); |
| 114 | await Promise.all([...jobs]); |
| 115 | await event("drained", { worker: "a" }); |
| 116 | await event("work-closed", { worker: "a" }); |
| 117 | await event("client-released", { worker: "a" }); |
| 118 | workerClientOpen = false; |
| 119 | await httpClosed; |
| 120 | await Promise.all(requestFinalizers); |
| 121 | await event("shared-closed"); |
| 122 | process.exit(process.exitCode || 0); |
| 123 | }; |
| 124 | for (const signal of ["SIGTERM", "SIGINT", "SIGQUIT"]) |
| 125 | process.on(signal, () => { |
| 126 | void shutdown(signal).catch((error) => { |
| 127 | console.error(error); |
| 128 | process.exit(1); |
| 129 | }); |
| 130 | }); |
| 131 | await event("worker-ready", { worker: "a" }); |
| 132 | server.listen(3000, "::"); |