@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 517 lines 19.5 KB
Raw
1 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
2 import * as NodeWS from "@effect/platform-node/NodeWS";
3 import { EnvironmentId } from "@t3tools/contracts";
4 import * as HostProcess from "@t3tools/shared/HostProcess";
5 import { expect, it } from "@effect/vitest";
6 import * as NodeNet from "node:net";
7 import * as Context from "effect/Context";
8 import * as Effect from "effect/Effect";
9 import * as FileSystem from "effect/FileSystem";
10 import * as Layer from "effect/Layer";
11 import * as Queue from "effect/Queue";
12 import * as Result from "effect/Result";
13 import * as SecureRandom from "effect/crypto/SecureRandom";
14
15 import * as ElectronWindow from "../electron/ElectronWindow.ts";
16 import * as LoopbackTunnel from "./LoopbackTunnel.ts";
17
18 const addressPort = (server: NodeNet.Server | NodeWS.WebSocketServer) =>
19 (server.address() as NodeNet.AddressInfo).port;
20
21 const closeServer = (server: NodeNet.Server | NodeWS.WebSocketServer) =>
22 Effect.promise(
23 () =>
24 new Promise<void>((resolve) => {
25 if (server instanceof NodeWS.WebSocketServer) {
26 for (const client of server.clients) client.terminate();
27 }
28 server.close(() => resolve());
29 }),
30 );
31
32 /** A local listener that must never see a connection: the reviewer's own localhost server. */
33 const listenDecoy = Effect.acquireRelease(
34 Effect.promise(
35 () =>
36 new Promise<{ server: NodeNet.Server; connections: () => number }>((resolve) => {
37 let connections = 0;
38 const server = NodeNet.createServer((socket) => {
39 connections++;
40 socket.destroy();
41 });
42 server.listen(0, "127.0.0.1", () => resolve({ server, connections: () => connections }));
43 }),
44 ),
45 ({ server }) => closeServer(server),
46 );
47
48 /** Stands in for the environment's /api/preview/tunnel: echoes each frame behind a 0xee byte. */
49 const listenEndpoint = Effect.acquireRelease(
50 Effect.promise(
51 () =>
52 new Promise<{ server: NodeWS.WebSocketServer; requests: string[] }>((resolve) => {
53 const requests: string[] = [];
54 const server: NodeWS.WebSocketServer = new NodeWS.WebSocketServer(
55 { port: 0, host: "127.0.0.1" },
56 () => resolve({ server, requests }),
57 );
58 server.on("connection", (socket: NodeWS.WebSocket, request: { url?: string }) => {
59 requests.push(request.url ?? "");
60 socket.on("message", (data: Buffer) =>
61 socket.send(Buffer.concat([Uint8Array.of(0xee), data])),
62 );
63 });
64 }),
65 ),
66 ({ server }) => closeServer(server),
67 );
68
69 const unusedPort = Effect.promise(
70 () =>
71 new Promise<number>((resolve) => {
72 const server = NodeNet.createServer();
73 server.listen(0, "127.0.0.1", () => {
74 const port = addressPort(server);
75 server.close(() => resolve(port));
76 });
77 }),
78 );
79
80 /** The tunnel service, with every access request answered with `tunnelUrl`. */
81 const makeTunnel = (
82 /** A function answers each access request with its current value. */
83 tunnelUrl: string | null | (() => string | null),
84 host?: Layer.Layer<FileSystem.FileSystem> | Layer.Layer<never>,
85 ) =>
86 Effect.gen(function* () {
87 const accessRequests = yield* Queue.unbounded<string>();
88 const window = {
89 isDestroyed: () => false,
90 webContents: {
91 send: (_channel: string, request: { readonly requestId: string }) =>
92 Queue.offerUnsafe(accessRequests, request.requestId),
93 },
94 };
95 const services = yield* Layer.build(
96 LoopbackTunnel.layer.pipe(
97 Layer.provide(
98 Layer.mergeAll(
99 Layer.mock(ElectronWindow.ElectronWindow, {
100 currentMainOrFirst: Effect.succeedSome(window as unknown as Electron.BrowserWindow),
101 }),
102 NodeFileSystem.layer,
103 SecureRandom.layerWebCrypto,
104 host ?? Layer.empty,
105 ),
106 ),
107 ),
108 );
109 const tunnel = Context.get(services, LoopbackTunnel.LoopbackTunnel);
110 yield* Queue.take(accessRequests).pipe(
111 Effect.flatMap((requestId) =>
112 tunnel.resolveAccess({
113 requestId,
114 url: typeof tunnelUrl === "function" ? tunnelUrl() : tunnelUrl,
115 }),
116 ),
117 Effect.forever,
118 Effect.forkScoped,
119 );
120 return tunnel;
121 });
122
123 /** Routes a stand-in session through the tunnel and returns its SOCKS listener port. */
124 const routeThroughTunnel = (
125 tunnelUrl: string | null,
126 host?: Layer.Layer<FileSystem.FileSystem> | Layer.Layer<never>,
127 ) =>
128 Effect.gen(function* () {
129 const tunnel = yield* makeTunnel(tunnelUrl, host);
130 let proxyRules = "";
131 const session = {
132 setProxy: async (config: Electron.ProxyConfig) => {
133 proxyRules = config.proxyRules ?? "";
134 },
135 closeAllConnections: async () => undefined,
136 webRequest: { onBeforeRequest: () => undefined },
137 };
138 yield* tunnel.route({
139 environmentId: "remote",
140 session: session as unknown as Electron.Session,
141 tunnelled: true,
142 });
143 return Number(/socks5:\/\/127\.0\.0\.1:(\d+)/.exec(proxyRules)![1]);
144 });
145
146 /**
147 * The real TCP tables with 127.0.0.1 in one column rewritten to 127.0.0.2. The rows keep their
148 * ports and owner, so only an address mismatch can refuse them.
149 */
150 const tcpTablesWithMovedAddress = (column: 1 | 2) =>
151 Layer.effect(
152 FileSystem.FileSystem,
153 Effect.gen(function* () {
154 const fileSystem = yield* FileSystem.FileSystem;
155 const moveAddress = (line: string) => {
156 const columns = line.trim().split(/\s+/);
157 const address = columns[column];
158 if (address === undefined || !/0100007F:/i.test(address)) return line;
159 columns[column] = address.replace(/0100007F:/i, "0200007F:");
160 return columns.join(" ");
161 };
162 return FileSystem.FileSystem.of({
163 ...fileSystem,
164 readFileString: (path, encoding) =>
165 fileSystem
166 .readFileString(path, encoding)
167 .pipe(Effect.map((table) => table.split("\n").map(moveAddress).join("\n"))),
168 });
169 }),
170 ).pipe(Layer.provide(NodeFileSystem.layer));
171
172 /** Greets the SOCKS listener and sends a CONNECT for `host:port`; resolves with the reply. */
173 const socksConnect = (proxyPort: number, host: string, port: number) =>
174 Effect.acquireRelease(
175 Effect.promise(
176 () =>
177 new Promise<{ socket: NodeNet.Socket; reply: Buffer }>((resolve, reject) => {
178 const socket = NodeNet.connect(proxyPort, "127.0.0.1", () =>
179 socket.write(Uint8Array.of(5, 1, 0)),
180 );
181 let received = Buffer.alloc(0);
182 let greeted = false;
183 const onData = (chunk: Buffer) => {
184 received = Buffer.concat([received, chunk]);
185 if (!greeted && received.length >= 2) {
186 // A refused greeting is the whole answer.
187 if (received[1] !== 0) return resolve({ socket, reply: received.subarray(0, 2) });
188 greeted = true;
189 received = received.subarray(2);
190 const destination = Buffer.alloc(2);
191 destination.writeUInt16BE(port);
192 socket.write(
193 Buffer.concat([
194 Uint8Array.of(5, 1, 0, 3, host.length),
195 Buffer.from(host, "latin1"),
196 destination,
197 ]),
198 );
199 }
200 if (greeted && received.length >= 10) {
201 socket.off("data", onData);
202 resolve({ socket, reply: received.subarray(0, 10) });
203 }
204 };
205 socket.on("data", onData);
206 socket.on("error", reject);
207 }),
208 ),
209 ({ socket }) => Effect.sync(() => socket.destroy()),
210 );
211
212 it.effect.each(["localhost", "localhost."])(
213 "carries a loopback CONNECT for %s over the tunnel WebSocket, not to local listeners",
214 (host) =>
215 Effect.gen(function* () {
216 const decoy = yield* listenDecoy;
217 const endpoint = yield* listenEndpoint;
218 const proxyPort = yield* routeThroughTunnel(
219 `ws://127.0.0.1:${addressPort(endpoint.server)}/api/preview/tunnel?wsTicket=t`,
220 );
221 const { socket, reply } = yield* socksConnect(proxyPort, host, addressPort(decoy.server));
222 expect(reply[1]).toBe(0);
223 const echoed = yield* Effect.promise(
224 () =>
225 new Promise<number[]>((resolve) => {
226 socket.once("data", (chunk) => resolve([...chunk]));
227 socket.write(Uint8Array.of(1, 2, 3));
228 }),
229 );
230 expect(echoed).toEqual([0xee, 1, 2, 3]);
231 expect(endpoint.requests).toEqual([
232 `/api/preview/tunnel?wsTicket=t&port=${addressPort(decoy.server)}`,
233 ]);
234 expect(decoy.connections()).toBe(0);
235 }),
236 );
237
238 it.effect.each([
239 { case: "a non-loopback destination", host: "192.168.1.20", tunnel: "endpoint" },
240 { case: "no tunnel URL", host: "127.0.0.1", tunnel: "none" },
241 { case: "an unreachable tunnel endpoint", host: "localhost", tunnel: "unreachable" },
242 { case: "another OS user's client", host: "localhost", tunnel: "other-user" },
243 { case: "a TCP row whose client address differs", host: "localhost", tunnel: "moved-client" },
244 { case: "a TCP row whose listener address differs", host: "localhost", tunnel: "moved-listener" },
245 ] as const)("fails the SOCKS request for $case without dialling locally", ({ host, tunnel }) =>
246 Effect.gen(function* () {
247 const decoy = yield* listenDecoy;
248 const endpoint = yield* listenEndpoint;
249 const endpointPort =
250 tunnel === "unreachable" ? yield* unusedPort : addressPort(endpoint.server);
251 const proxyPort = yield* routeThroughTunnel(
252 tunnel === "none" ? null : `ws://127.0.0.1:${endpointPort}/api/preview/tunnel`,
253 // This process owns the client, so a different user id here makes it another user's.
254 tunnel === "other-user"
255 ? Layer.mergeAll(
256 Layer.succeed(HostProcess.Platform, "linux"),
257 Layer.succeed(HostProcess.UserId, (process.getuid?.() ?? 0) + 1),
258 )
259 : tunnel === "moved-client" || tunnel === "moved-listener"
260 ? Layer.mergeAll(
261 Layer.succeed(HostProcess.Platform, "linux"),
262 tcpTablesWithMovedAddress(tunnel === "moved-client" ? 1 : 2),
263 )
264 : undefined,
265 );
266 const { reply } = yield* socksConnect(proxyPort, host, addressPort(decoy.server));
267 expect(reply[1]).not.toBe(0);
268 expect(endpoint.requests).toEqual([]);
269 expect(decoy.connections()).toBe(0);
270 }),
271 );
272
273 it.effect("connects straight to the environment's own forwarded origin port", () =>
274 Effect.gen(function* () {
275 // Over SSH the origin is a local forward, and signed file previews load from it.
276 const received: number[] = [];
277 const origin = yield* Effect.acquireRelease(
278 Effect.promise(
279 () =>
280 new Promise<NodeNet.Server>((resolve) => {
281 const server = NodeNet.createServer((socket) =>
282 socket.on("data", (chunk) => {
283 received.push(...chunk);
284 socket.write(chunk);
285 }),
286 );
287 server.listen(0, "127.0.0.1", () => resolve(server));
288 }),
289 ),
290 closeServer,
291 );
292 const port = addressPort(origin);
293 const proxyPort = yield* routeThroughTunnel(`ws://127.0.0.1:${port}/api/preview/tunnel`);
294 const { socket, reply } = yield* socksConnect(proxyPort, "127.0.0.1", port);
295 expect(reply[1]).toBe(0);
296 const echoed = yield* Effect.promise(
297 () =>
298 new Promise<number[]>((resolve) => {
299 socket.once("data", (chunk) => resolve([...chunk]));
300 socket.write(Uint8Array.of(7, 8));
301 }),
302 );
303 expect(echoed).toEqual([7, 8]);
304 expect(received).toEqual([7, 8]);
305 }),
306 );
307
308 /** Connects to a local port, sends `bytes`, and resolves with the first chunk back. */
309 const exchange = (port: number, bytes: Uint8Array) =>
310 Effect.promise(
311 () =>
312 new Promise<number[]>((resolve, reject) => {
313 const socket = NodeNet.connect(port, "127.0.0.1", () => socket.write(bytes));
314 socket.once("data", (chunk) => {
315 resolve([...chunk]);
316 socket.destroy();
317 });
318 socket.on("error", reject);
319 }),
320 );
321
322 const refusesConnections = (port: number) =>
323 Effect.promise(
324 () =>
325 new Promise<boolean>((resolve) => {
326 const socket = NodeNet.connect(port, "127.0.0.1", () => {
327 socket.destroy();
328 resolve(false);
329 });
330 socket.on("error", () => resolve(true));
331 }),
332 );
333
334 it.effect("forwards a port over the tunnel on the same local port until stopped", () =>
335 Effect.gen(function* () {
336 const endpoint = yield* listenEndpoint;
337 const remotePort = yield* unusedPort;
338 const tunnel = yield* makeTunnel(
339 `ws://127.0.0.1:${addressPort(endpoint.server)}/api/preview/tunnel?wsTicket=t`,
340 );
341 const announced: number[][] = [];
342 yield* tunnel.subscribeForwards((forwards) =>
343 Effect.sync(() => announced.push(forwards.map((forward) => forward.localPort))),
344 );
345 const environmentId = EnvironmentId.make("remote");
346 const forward = yield* tunnel.forward({ environmentId, remotePort });
347 expect(forward).toEqual({ environmentId, remotePort, localPort: remotePort });
348
349 expect(yield* exchange(remotePort, Uint8Array.of(4, 5))).toEqual([0xee, 4, 5]);
350 // The first request is the same-machine probe.
351 expect(endpoint.requests.at(-1)).toBe(`/api/preview/tunnel?wsTicket=t&port=${remotePort}`);
352
353 yield* tunnel.stopForward({ environmentId, remotePort });
354 expect(yield* refusesConnections(remotePort)).toBe(true);
355 expect(yield* tunnel.forwards).toEqual([]);
356 expect(announced).toEqual([[remotePort], []]);
357 }),
358 );
359
360 it.effect("moves a forward to a free port when its own is taken here", () =>
361 Effect.gen(function* () {
362 const decoy = yield* listenDecoy;
363 const endpoint = yield* listenEndpoint;
364 const remotePort = addressPort(decoy.server);
365 const tunnel = yield* makeTunnel(
366 `ws://127.0.0.1:${addressPort(endpoint.server)}/api/preview/tunnel`,
367 );
368 const forward = yield* tunnel.forward({
369 environmentId: EnvironmentId.make("remote"),
370 remotePort,
371 });
372 expect(forward.localPort).not.toBe(remotePort);
373
374 expect(yield* exchange(forward.localPort, Uint8Array.of(6))).toEqual([0xee, 6]);
375 expect(endpoint.requests.at(-1)).toBe(`/api/preview/tunnel?port=${remotePort}`);
376 expect(decoy.connections()).toBe(0);
377 }),
378 );
379
380 /** An environment on this machine: each tunnel connection dials the requested local port. */
381 const listenSameMachineEndpoint = Effect.acquireRelease(
382 Effect.promise(
383 () =>
384 new Promise<NodeWS.WebSocketServer>((resolve) => {
385 const server: NodeWS.WebSocketServer = new NodeWS.WebSocketServer(
386 { port: 0, host: "127.0.0.1" },
387 () => resolve(server),
388 );
389 server.on("connection", (socket: NodeWS.WebSocket, request: { url?: string }) => {
390 const port = Number(new URL(request.url ?? "", "ws://x").searchParams.get("port"));
391 const local = NodeNet.connect(port, "127.0.0.1");
392 local.on("data", (chunk) => socket.send(chunk));
393 local.on("error", () => socket.close());
394 socket.on("message", (data: Buffer) => local.write(data));
395 socket.on("close", () => local.destroy());
396 });
397 }),
398 ),
399 closeServer,
400 );
401
402 it.effect("refuses to forward from an environment that shares this machine's loopback", () =>
403 Effect.gen(function* () {
404 const endpoint = yield* listenSameMachineEndpoint;
405 const remotePort = yield* unusedPort;
406 const tunnel = yield* makeTunnel(`ws://127.0.0.1:${addressPort(endpoint)}/api/preview/tunnel`);
407 const error = yield* tunnel
408 .forward({ environmentId: EnvironmentId.make("remote"), remotePort })
409 .pipe(Effect.flip);
410 expect(error._tag).toBe("LoopbackTunnelSameMachineError");
411 expect(yield* refusesConnections(remotePort)).toBe(true);
412 expect(yield* tunnel.forwards).toEqual([]);
413 }),
414 );
415
416 it.effect(
417 "forwards nothing while the environment is out of reach, then forwards once it is back",
418 () =>
419 Effect.gen(function* () {
420 const endpoint = yield* listenEndpoint;
421 const remotePort = yield* unusedPort;
422 let access: string | null = null;
423 const tunnel = yield* makeTunnel(() => access);
424 const environmentId = EnvironmentId.make("remote");
425
426 const unavailable = yield* tunnel.forward({ environmentId, remotePort }).pipe(Effect.flip);
427 expect(unavailable._tag).toBe("LoopbackTunnelUnavailableError");
428 expect(yield* refusesConnections(remotePort)).toBe(true);
429 expect(yield* tunnel.forwards).toEqual([]);
430
431 access = `ws://127.0.0.1:${addressPort(endpoint.server)}/api/preview/tunnel`;
432 const forward = yield* tunnel.forward({ environmentId, remotePort });
433 expect(yield* exchange(forward.localPort, Uint8Array.of(9))).toEqual([0xee, 9]);
434 }),
435 );
436
437 /** The environment's tunnel route refusing every port with a 502, as for a port nothing listens on. */
438 const listenRefusingEndpoint = (headers: Record<string, string>) =>
439 Effect.acquireRelease(
440 Effect.promise(
441 () =>
442 new Promise<NodeWS.WebSocketServer>((resolve) => {
443 const server: NodeWS.WebSocketServer = new NodeWS.WebSocketServer(
444 {
445 port: 0,
446 host: "127.0.0.1",
447 verifyClient: (_info, done) => done(false, 502, "Bad Gateway", headers),
448 },
449 () => resolve(server),
450 );
451 }),
452 ),
453 closeServer,
454 );
455
456 it.effect.each([
457 { case: "the environment reports nothing on the probe port", refused: true },
458 { case: "the tunnel fails for another reason", refused: false },
459 ])("decides a forward's machine only on proof: $case", ({ refused }) =>
460 Effect.gen(function* () {
461 const endpoint = yield* listenRefusingEndpoint(
462 refused ? { "x-t3-tunnel-port-refused": "1" } : {},
463 );
464 const remotePort = yield* unusedPort;
465 const tunnel = yield* makeTunnel(`ws://127.0.0.1:${addressPort(endpoint)}/api/preview/tunnel`);
466 const result = yield* tunnel
467 .forward({ environmentId: EnvironmentId.make("remote"), remotePort })
468 .pipe(Effect.result);
469 if (refused) {
470 expect(Result.isSuccess(result)).toBe(true);
471 } else {
472 expect(Result.isFailure(result) && result.failure._tag).toBe(
473 "LoopbackTunnelUnavailableError",
474 );
475 expect(yield* refusesConnections(remotePort)).toBe(true);
476 }
477 }),
478 );
479
480 it.effect("closes connections beyond a forward's limit without tunnelling them", () =>
481 Effect.gen(function* () {
482 const endpoint = yield* listenEndpoint;
483 const tunnel = yield* makeTunnel(
484 `ws://127.0.0.1:${addressPort(endpoint.server)}/api/preview/tunnel`,
485 );
486 const forward = yield* tunnel.forward({
487 environmentId: EnvironmentId.make("remote"),
488 remotePort: yield* unusedPort,
489 });
490 const open = () =>
491 Effect.acquireRelease(
492 Effect.promise(
493 () =>
494 new Promise<NodeNet.Socket>((resolve) => {
495 const socket = NodeNet.connect(forward.localPort, "127.0.0.1", () => {
496 socket.once("data", () => resolve(socket));
497 socket.write(Uint8Array.of(1));
498 });
499 }),
500 ),
501 (socket) => Effect.sync(() => socket.destroy()),
502 );
503 yield* Effect.forEach(Array.from({ length: 64 }), open, { concurrency: "unbounded" });
504 const tunnelled = endpoint.requests.length;
505 const closed = yield* Effect.promise(
506 () =>
507 new Promise<boolean>((resolve) => {
508 const socket = NodeNet.connect(forward.localPort, "127.0.0.1");
509 socket.on("close", () => resolve(true));
510 socket.on("data", () => resolve(false));
511 socket.write(Uint8Array.of(2));
512 }),
513 );
514 expect(closed).toBe(true);
515 expect(endpoint.requests.length).toBe(tunnelled);
516 }),
517 );