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

main
ts 215 lines 7.73 KB
Raw
1 import { assert, describe, it } from "@effect/vitest";
2 import * as NetService from "@t3tools/shared/Net";
3 import * as Effect from "effect/Effect";
4 import * as Layer from "effect/Layer";
5 import * as Sink from "effect/Sink";
6 import * as Stream from "effect/Stream";
7 import { ChildProcessSpawner } from "effect/process";
8
9 import {
10 type DevShareError,
11 DevServeFailedError,
12 DevServePortTakenError,
13 shareDevServer,
14 unshareDevServer,
15 } from "./dev-share.ts";
16
17 const TAILNET_STATUS = JSON.stringify({ Self: { DNSName: "host.example.ts.net." } });
18 const NO_HANDLER_STDERR = "error: failed to remove web serve: handler does not exist";
19
20 interface CallResult {
21 readonly exitCode: number;
22 readonly stderr?: string;
23 }
24
25 const encode = (value: string) => Stream.make(new TextEncoder().encode(value));
26
27 const serveStatusWithRoot = (webPort: number, proxy: string) =>
28 JSON.stringify({
29 Web: { [`host.example.ts.net:${String(webPort)}`]: { Handlers: { "/": { Proxy: proxy } } } },
30 });
31
32 const spawnerLayer = (input: {
33 readonly off?: CallResult;
34 readonly serve?: CallResult;
35 readonly serveStatus?: CallResult & { readonly stdout?: string };
36 readonly liveLoopbackPorts?: ReadonlyArray<number>;
37 readonly calls?: Array<ReadonlyArray<string>>;
38 }) => {
39 const live = new Set(input.liveLoopbackPorts ?? []);
40 const unused = Effect.die("unused in dev-share tests");
41 const net = Layer.succeed(NetService.NetService, {
42 hasListenerOnHost: (port: number) => Effect.succeed(live.has(port)),
43 canListenOnHost: () => unused,
44 isPortAvailableOnLoopback: () => unused,
45 reserveLoopbackPort: () => unused,
46 findAvailablePort: () => unused,
47 });
48 const spawner = Layer.succeed(
49 ChildProcessSpawner.ChildProcessSpawner,
50 ChildProcessSpawner.make((command) => {
51 const args = "args" in command ? (command.args as ReadonlyArray<string>) : [];
52 input.calls?.push(args);
53 const isServeStatus = args[0] === "serve" && args.includes("status");
54 const result: CallResult & { readonly stdout?: string } = isServeStatus
55 ? (input.serveStatus ?? { exitCode: 0, stdout: "{}" })
56 : args.includes("status")
57 ? { exitCode: 0, stdout: TAILNET_STATUS }
58 : args.includes("off")
59 ? (input.off ?? { exitCode: 0 })
60 : (input.serve ?? { exitCode: 0 });
61
62 return Effect.succeed(
63 ChildProcessSpawner.makeHandle({
64 pid: ChildProcessSpawner.ProcessId(1),
65 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(result.exitCode)),
66 isRunning: Effect.succeed(false),
67 kill: () => Effect.void,
68 unref: Effect.succeed(Effect.void),
69 stdin: Sink.drain,
70 stdout: result.stdout !== undefined ? encode(result.stdout) : Stream.empty,
71 stderr: result.stderr ? encode(result.stderr) : Stream.empty,
72 all: Stream.empty,
73 getInputFd: () => Sink.drain,
74 getOutputFd: () => Stream.empty,
75 }),
76 );
77 }),
78 );
79 return Layer.merge(spawner, net);
80 };
81
82 describe("unshareDevServer", () => {
83 // `tailscale serve … off` exits 1 when the port had no mapping, which is the
84 // normal first-share case — the port is clear, so this must not be an error.
85 it.effect("treats a missing handler as cleared", () =>
86 Effect.gen(function* () {
87 const result = yield* unshareDevServer(5788).pipe(
88 Effect.provide(spawnerLayer({ off: { exitCode: 1, stderr: NO_HANDLER_STDERR } })),
89 );
90 assert.isTrue(result.cleared);
91 }),
92 );
93
94 it.effect("reports a genuine removal failure as not cleared", () =>
95 Effect.gen(function* () {
96 const result = yield* unshareDevServer(5788).pipe(
97 Effect.provide(spawnerLayer({ off: { exitCode: 1, stderr: "permission denied" } })),
98 );
99 assert.isFalse(result.cleared);
100 assert.include(result.explanation, "permission denied");
101 assert.equal(result.cause?._tag, "TailscaleCommandExitError");
102 }),
103 );
104 });
105
106 describe("shareDevServer", () => {
107 // Vite binds `localhost`, which modern Node resolves to `::1` first, so a
108 // 127.0.0.1 target would proxy to a loopback nothing listens on.
109 it.effect("proxies to the localhost name Vite binds, not 127.0.0.1", () =>
110 Effect.gen(function* () {
111 const calls: Array<ReadonlyArray<string>> = [];
112 yield* shareDevServer({ webPort: 5788 }).pipe(
113 Effect.provide(spawnerLayer({ off: { exitCode: 0 }, calls })),
114 );
115
116 const serveCall = calls.find((args) => args.includes("--bg"));
117 assert.deepEqual(serveCall, ["serve", "--bg", "--https=5788", "http://localhost:5788"]);
118 }),
119 );
120
121 it.effect("explains a recognized serve failure without quoting stderr", () =>
122 Effect.gen(function* () {
123 const error: DevShareError = yield* shareDevServer({ webPort: 5788 }).pipe(
124 Effect.provide(
125 spawnerLayer({
126 off: { exitCode: 0 },
127 serve: {
128 exitCode: 1,
129 stderr: "permission denied for tskey-auth-secret-token-value",
130 },
131 }),
132 ),
133 Effect.flip,
134 );
135
136 assert.instanceOf(error, DevServeFailedError);
137 assert.equal(error.stage, "serve");
138 assert.include(error.message, "permission denied");
139 assert.include(error.message, "elevated privileges");
140 assert.notInclude(error.message, "tskey-auth-secret-token-value");
141 }),
142 );
143
144 it.effect("refuses to serve when the existing mapping could not be cleared", () =>
145 Effect.gen(function* () {
146 const error: DevShareError = yield* shareDevServer({ webPort: 5788 }).pipe(
147 Effect.provide(spawnerLayer({ off: { exitCode: 1, stderr: "permission denied" } })),
148 Effect.flip,
149 );
150
151 assert.instanceOf(error, DevServeFailedError);
152 assert.equal(error.stage, "clear-existing");
153 assert.include(error.message, "could not clear the existing mapping");
154 assert.include(error.message, "permission denied");
155 }),
156 );
157
158 it.effect("leaves a mapping that another running server holds alone", () =>
159 Effect.gen(function* () {
160 const calls: Array<ReadonlyArray<string>> = [];
161 const error: DevShareError = yield* shareDevServer({ webPort: 5788 }).pipe(
162 Effect.provide(
163 spawnerLayer({
164 serveStatus: {
165 exitCode: 0,
166 stdout: serveStatusWithRoot(5788, "http://127.0.0.1:9555"),
167 },
168 liveLoopbackPorts: [9555],
169 calls,
170 }),
171 ),
172 Effect.flip,
173 );
174
175 assert.instanceOf(error, DevServePortTakenError);
176 assert.isUndefined(calls.find((args) => args.includes("off") || args.includes("--bg")));
177 }),
178 );
179
180 it.effect("replaces a mapping that dials a port nothing listens on", () =>
181 Effect.gen(function* () {
182 const calls: Array<ReadonlyArray<string>> = [];
183 yield* shareDevServer({ webPort: 5788 }).pipe(
184 Effect.provide(
185 spawnerLayer({
186 serveStatus: {
187 exitCode: 0,
188 stdout: serveStatusWithRoot(5788, "http://127.0.0.1:9555"),
189 },
190 calls,
191 }),
192 ),
193 );
194
195 assert.isDefined(calls.find((args) => args.includes("off")));
196 assert.isDefined(calls.find((args) => args.includes("--bg")));
197 }),
198 );
199
200 it.effect("leaves the port alone when its mapping cannot be read", () =>
201 Effect.gen(function* () {
202 const calls: Array<ReadonlyArray<string>> = [];
203 const error: DevShareError = yield* shareDevServer({ webPort: 5788 }).pipe(
204 Effect.provide(
205 spawnerLayer({ serveStatus: { exitCode: 1, stderr: "permission denied" }, calls }),
206 ),
207 Effect.flip,
208 );
209
210 assert.instanceOf(error, DevServeFailedError);
211 assert.equal(error.stage, "read-existing");
212 assert.isUndefined(calls.find((args) => args.includes("off") || args.includes("--bg")));
213 }),
214 );
215 });