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

main
ts 207 lines 6.97 KB
Raw
1 // @effect-diagnostics nodeBuiltinImport:off
2 // @effect-diagnostics globalTimers:off
3 // @effect-diagnostics globalDateInEffect:off
4 import * as NodeFS from "node:fs";
5 import * as NodeHttp from "node:http";
6 import * as NodeNet from "node:net";
7
8 import * as Effect from "effect/Effect";
9 import * as Option from "effect/Option";
10 import * as Schema from "effect/Schema";
11 import { Argument, Command } from "effect/cli";
12
13 import packageJson from "../../package.json" with { type: "json" };
14 import { compareExactServiceVersions, isExactServiceVersion } from "../cloud/serviceProtocol.ts";
15 import * as DesktopUpdateMarker from "../desktopUpdate/DesktopUpdateMarker.ts";
16 import { serviceLauncherIsServing, stateDirOwned } from "../serviceLauncher.ts";
17
18 const canBind = (port: number) =>
19 new Promise<boolean>((resolve) => {
20 const server = NodeNet.createServer();
21 server.unref();
22 server.once("error", () => resolve(false));
23 server.listen(port, "127.0.0.1", () => {
24 server.close((error) => resolve(!error));
25 });
26 });
27
28 // macOS permits this bind over a wildcard listener, so also check loopback connectivity.
29 const answersOnLoopback = (port: number) =>
30 new Promise<boolean>((resolve) => {
31 const socket = NodeNet.connect({ port, host: "127.0.0.1" });
32 socket.setTimeout(1000);
33 socket.once("connect", () => {
34 socket.destroy();
35 resolve(true);
36 });
37 socket.once("timeout", () => {
38 socket.destroy();
39 resolve(true);
40 });
41 socket.once("error", () => resolve(false));
42 });
43
44 const pickPort = Command.make("pick-port", {
45 portFile: Argument.String("port-file"),
46 defaultPort: Argument.Int("default-port"),
47 scanWindow: Argument.Int("scan-window"),
48 }).pipe(
49 Command.withHandler(({ portFile, defaultPort, scanWindow }) =>
50 Effect.promise(async () => {
51 const raw = NodeFS.existsSync(portFile) ? NodeFS.readFileSync(portFile, "utf8").trim() : "";
52 const preferred = Number.parseInt(raw, 10);
53 const start = Number.isInteger(preferred) ? preferred : defaultPort;
54 for (let port = start; port < start + scanWindow; port += 1) {
55 if ((await canBind(port)) && !(await answersOnLoopback(port))) {
56 process.stdout.write(String(port));
57 return;
58 }
59 }
60 process.exitCode = 1;
61 }),
62 ),
63 );
64
65 const probe = (port: number, probeTimeoutMs: number) =>
66 new Promise<"ready" | "refused" | "not-ready">((resolve) => {
67 const request = NodeHttp.get(
68 { hostname: "127.0.0.1", port, path: "/", timeout: probeTimeoutMs },
69 (response) => {
70 response.resume();
71 response.once("end", () => {
72 const status = response.statusCode ?? 0;
73 resolve(status >= 200 && status < 300 ? "ready" : "not-ready");
74 });
75 },
76 );
77 request.once("timeout", () => {
78 request.destroy();
79 resolve("not-ready");
80 });
81 request.once("error", (error: NodeJS.ErrnoException) =>
82 resolve(error.code === "ECONNREFUSED" ? "refused" : "not-ready"),
83 );
84 });
85
86 const waitReady = Command.make("wait-ready", {
87 port: Argument.Int("port"),
88 timeoutMs: Argument.Int("timeout-ms"),
89 probeTimeoutMs: Argument.Int("probe-timeout-ms"),
90 }).pipe(
91 Command.withHandler(({ port, timeoutMs, probeTimeoutMs }) =>
92 Effect.promise(async () => {
93 const deadline = Date.now() + timeoutMs;
94 let refusedOnly = true;
95 while (Date.now() < deadline) {
96 const result = await probe(port, probeTimeoutMs);
97 if (result === "ready") return;
98 refusedOnly &&= result === "refused";
99 await new Promise((resolve) => setTimeout(resolve, 100));
100 }
101 // The launcher reads 2 as "nothing listens on this port".
102 process.exitCode = refusedOnly ? 2 : 1;
103 }),
104 ),
105 );
106
107 /** Prints `<pid> <port>` for a live default-home server, or exits 1. */
108 const runtimePort = Command.make("runtime-port", {
109 runtimeFile: Argument.String("runtime-file"),
110 }).pipe(
111 Command.withHandler(({ runtimeFile }) =>
112 Effect.sync(() => {
113 try {
114 // @effect-diagnostics-next-line globalJsonInEffect:off - mirrors the shell snippet's loose parse.
115 const runtime = JSON.parse(NodeFS.readFileSync(runtimeFile, "utf8")) as {
116 pid?: unknown;
117 port?: unknown;
118 origin?: unknown;
119 };
120 const pid = Number(runtime.pid);
121 const port = Number(runtime.port);
122 if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(port)) {
123 process.exitCode = 1;
124 return;
125 }
126 const origin = new URL(String(runtime.origin ?? ""));
127 if (origin.protocol !== "http:" || !["127.0.0.1", "localhost"].includes(origin.hostname)) {
128 process.exitCode = 1;
129 return;
130 }
131 process.kill(pid, 0);
132 process.stdout.write(`${pid} ${port}`);
133 } catch {
134 process.exitCode = 1;
135 }
136 }),
137 ),
138 );
139
140 const decodeRunningServer = Schema.decodeUnknownOption(
141 Schema.fromJsonString(Schema.Struct({ pid: Schema.Number, serverVersion: Schema.String })),
142 );
143
144 /** True when the runtime file names `pid` and a server version at or above `ownVersion`. */
145 export const keepsRunningServer = (runtimeJson: string, pid: number, ownVersion: string) =>
146 Option.match(decodeRunningServer(runtimeJson), {
147 onNone: () => false,
148 onSome: (runtime) =>
149 runtime.pid === pid &&
150 isExactServiceVersion(runtime.serverVersion) &&
151 compareExactServiceVersions(runtime.serverVersion, ownVersion) >= 0,
152 });
153
154 /** Exits 0 when the managed server `pid` runs this version or a newer one, else 1. */
155 const keepServer = Command.make("keep-server", {
156 runtimeFile: Argument.String("runtime-file"),
157 pid: Argument.Int("pid"),
158 }).pipe(
159 Command.withHandler(({ runtimeFile, pid }) =>
160 Effect.sync(() => {
161 const runtimeJson = NodeFS.existsSync(runtimeFile)
162 ? NodeFS.readFileSync(runtimeFile, "utf8")
163 : "";
164 if (!keepsRunningServer(runtimeJson, pid, packageJson.version)) process.exitCode = 1;
165 }),
166 ),
167 );
168
169 const updateRemaining = Command.make("update-remaining", {
170 markerFile: Argument.String("marker-file"),
171 }).pipe(
172 Command.withHandler(({ markerFile }) =>
173 DesktopUpdateMarker.DesktopUpdateMarker.use((marker) => marker.remainingWait(markerFile)).pipe(
174 Effect.flatMap((remaining) =>
175 Effect.sync(() => {
176 process.stdout.write(Option.match(remaining, { onNone: () => "", onSome: String }));
177 }),
178 ),
179 ),
180 ),
181 Command.provide(DesktopUpdateMarker.layer),
182 );
183
184 /** Exits 0 while a server holds this home or a boot service is about to start one. */
185 const homeOwned = Command.make("home-owned", {
186 baseDir: Argument.String("base-dir"),
187 }).pipe(
188 Command.withHandler(({ baseDir }) =>
189 Effect.promise(async () => {
190 if (!((await serviceLauncherIsServing(baseDir)) || (await stateDirOwned(baseDir)))) {
191 process.exitCode = 1;
192 }
193 }),
194 ),
195 );
196
197 export const sshHelperCommand = Command.make("__ssh-helper").pipe(
198 Command.unlisted,
199 Command.withSubcommands([
200 pickPort,
201 waitReady,
202 runtimePort,
203 updateRemaining,
204 homeOwned,
205 keepServer,
206 ]),
207 );