@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, 04:45 UTC

main
ts 296 lines 11.6 KB
Raw
1 import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
2 import * as NodeWS from "@effect/platform-node/NodeWS";
3 import { expect, it } from "@effect/vitest";
4 import {
5 AuthOrchestrationReadScope,
6 AuthSessionId,
7 AuthTerminalOperateScope,
8 DEFAULT_SERVER_SETTINGS,
9 type ManagedPolicySummary,
10 type ServerSettings,
11 } from "@t3tools/contracts";
12 import * as NodeNet from "node:net";
13 import * as Context from "effect/Context";
14 import * as Deferred from "effect/Deferred";
15 import * as Effect from "effect/Effect";
16 import * as Layer from "effect/Layer";
17 import * as PubSub from "effect/PubSub";
18 import * as Ref from "effect/Ref";
19 import * as Stream from "effect/Stream";
20 import { HttpRouter, HttpServer } from "effect/http";
21
22 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
23 import * as SessionStore from "../auth/SessionStore.ts";
24 import { ServerSettingsService } from "../serverSettings.ts";
25 import * as PreviewTunnel from "./PreviewTunnel.ts";
26
27 const listen = (onConnection: (socket: NodeNet.Socket) => void) =>
28 Effect.acquireRelease(
29 Effect.promise(
30 () =>
31 new Promise<{ server: NodeNet.Server; sockets: Set<NodeNet.Socket> }>((resolve) => {
32 const sockets = new Set<NodeNet.Socket>();
33 const server = NodeNet.createServer((socket) => {
34 sockets.add(socket);
35 onConnection(socket);
36 });
37 server.listen(0, "127.0.0.1", () => resolve({ server, sockets }));
38 }),
39 ),
40 ({ server, sockets }) =>
41 Effect.promise(
42 () =>
43 new Promise<void>((resolve) => {
44 for (const socket of sockets) socket.destroy();
45 server.close(() => resolve());
46 }),
47 ),
48 ).pipe(Effect.map(({ server }) => ({ port: (server.address() as NodeNet.AddressInfo).port })));
49
50 /** Settings the route reads; `set` publishes a change as the real service does. */
51 const makeSettings = Effect.fn(function* (
52 enablePreviewTunnel = true,
53 managedPolicy?: ManagedPolicySummary,
54 /** Applied right after the first read, as a change landing while a tunnel dials. */
55 afterFirstRead?: Partial<ServerSettings>,
56 ) {
57 const current = yield* Ref.make<ServerSettings>({
58 ...DEFAULT_SERVER_SETTINGS,
59 enablePreviewTunnel,
60 });
61 const changes = yield* PubSub.unbounded<ServerSettings>();
62 const set = (patch: Partial<ServerSettings>) =>
63 Ref.updateAndGet(current, (settings) => ({ ...settings, ...patch })).pipe(
64 Effect.flatMap((settings) => PubSub.publish(changes, settings)),
65 );
66 let pendingChange = afterFirstRead;
67 return {
68 set,
69 layer: Layer.mock(ServerSettingsService, {
70 managedPolicy,
71 getSettings: Ref.get(current).pipe(
72 Effect.tap(() => {
73 const change = pendingChange;
74 pendingChange = undefined;
75 return change ? set(change) : Effect.void;
76 }),
77 ),
78 streamChanges: Stream.fromPubSub(changes),
79 subscribeChanges: PubSub.subscribe(changes).pipe(Effect.map(Stream.fromSubscription)),
80 }),
81 };
82 });
83
84 /** Serves the tunnel route; `wsTicket=reader` authenticates without terminal:operate. */
85 const serveTunnel = (
86 sessionInvalidated: Effect.Effect<void> = Effect.never,
87 settings?: Layer.Layer<ServerSettingsService>,
88 ) =>
89 Effect.gen(function* () {
90 const settingsLayer = settings ?? (yield* makeSettings()).layer;
91 const services = yield* Layer.build(
92 HttpRouter.serve(PreviewTunnel.routeLayer, { disableListenLog: true }).pipe(
93 Layer.provideMerge(NodeHttpServer.layerTest),
94 Layer.provide(PreviewTunnel.layer.pipe(Layer.provide(settingsLayer))),
95 Layer.provide(
96 Layer.mock(SessionStore.SessionStore, {
97 cookieName: "t3_session",
98 legacyCookieName: undefined,
99 awaitInvalidation: () => sessionInvalidated,
100 }),
101 ),
102 Layer.provide(
103 Layer.mock(EnvironmentAuth.EnvironmentAuth, {
104 authenticateWebSocketUpgrade: (request) =>
105 Effect.succeed({
106 sessionId: AuthSessionId.make("tunnel-test"),
107 subject: "tunnel-test",
108 method: "bearer-access-token",
109 scopes: request.url.includes("wsTicket=reader")
110 ? [AuthOrchestrationReadScope]
111 : [AuthOrchestrationReadScope, AuthTerminalOperateScope],
112 }),
113 }),
114 ),
115 ),
116 );
117 const origin = new URL(
118 HttpServer.formatAddress(Context.get(services, HttpServer.HttpServer).address),
119 );
120 return { origin: `ws://${origin.host}`, port: Number(origin.port) };
121 });
122
123 const openTunnel = (url: string) =>
124 Effect.acquireRelease(
125 Effect.sync(() => new NodeWS.WebSocket(url)),
126 (socket) => Effect.sync(() => socket.terminate()),
127 );
128
129 /** How the route turned down a tunnel: its status, and whether it marked the port as the reason. */
130 const refusal = (client: NodeWS.WebSocket) =>
131 Effect.promise(
132 () =>
133 new Promise<{ status: number | undefined; portRefused: boolean }>((resolve, reject) => {
134 client.on("unexpected-response", (_request, response) =>
135 resolve({
136 status: response.statusCode,
137 portRefused:
138 response.headers[PreviewTunnel.PREVIEW_TUNNEL_PORT_REFUSED_HEADER] !== undefined,
139 }),
140 );
141 client.on("open", () => reject(new Error("tunnel opened")));
142 client.on("error", reject);
143 }),
144 );
145
146 it.effect("pipes bytes both ways between the WebSocket and the loopback port", () =>
147 Effect.gen(function* () {
148 const upstreamReceived: number[] = [];
149 const upstream = yield* listen((socket) => {
150 socket.write(Uint8Array.of(0x10, 0x11));
151 socket.on("data", (chunk) => {
152 upstreamReceived.push(...chunk);
153 socket.write(Buffer.concat([Uint8Array.of(0xee), chunk]));
154 });
155 });
156 const tunnel = yield* serveTunnel();
157 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${upstream.port}`);
158 const clientReceived: number[] = [];
159 const done = Promise.withResolvers<void>();
160 client.on("error", done.reject);
161 client.on("message", (data: Buffer) => {
162 clientReceived.push(...data);
163 if (clientReceived.length === 2) client.send(Uint8Array.of(0x01, 0x02, 0x03));
164 if (clientReceived.length === 6) done.resolve();
165 });
166 yield* Effect.promise(() => done.promise);
167 expect(upstreamReceived).toEqual([0x01, 0x02, 0x03]);
168 expect(clientReceived).toEqual([0x10, 0x11, 0xee, 0x01, 0x02, 0x03]);
169 }),
170 );
171
172 it.effect.each([
173 { case: "the server's own port", target: "self", ticket: "operator", portRefused: true },
174 {
175 case: "a session without terminal:operate",
176 target: "listed",
177 ticket: "reader",
178 portRefused: false,
179 },
180 ] as const)("refuses $case with 403 before dialling", ({ target, ticket, portRefused }) =>
181 Effect.gen(function* () {
182 let dialled = 0;
183 const countDial = (socket: NodeNet.Socket) => {
184 dialled++;
185 socket.destroy();
186 };
187 const listed = yield* listen(countDial);
188 const tunnel = yield* serveTunnel();
189 const port = { listed: listed.port, self: tunnel.port }[target];
190 const client = yield* openTunnel(
191 `${tunnel.origin}/api/preview/tunnel?port=${port}&wsTicket=${ticket}`,
192 );
193 const response = yield* refusal(client);
194 expect(response).toEqual({ status: 403, portRefused });
195 expect(dialled).toBe(0);
196 }),
197 );
198
199 it.effect("answers a port nothing listens on with 403, marked as about the port", () =>
200 Effect.gen(function* () {
201 const closed = yield* Effect.promise(
202 () =>
203 new Promise<number>((resolve) => {
204 const server = NodeNet.createServer();
205 server.listen(0, "127.0.0.1", () => {
206 const { port } = server.address() as NodeNet.AddressInfo;
207 server.close(() => resolve(port));
208 });
209 }),
210 );
211 const tunnel = yield* serveTunnel();
212 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${closed}`);
213 const response = yield* refusal(client);
214 expect(response).toEqual({ status: 403, portRefused: true });
215 }),
216 );
217
218 it.effect("closes an open tunnel when its session is revoked", () =>
219 Effect.gen(function* () {
220 const upstreamClosed = Promise.withResolvers<void>();
221 const upstream = yield* listen((socket) => socket.on("close", () => upstreamClosed.resolve()));
222 const revoked = yield* Deferred.make<void>();
223 const tunnel = yield* serveTunnel(Deferred.await(revoked));
224 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${upstream.port}`);
225 yield* Effect.promise(() => new Promise((resolve) => client.once("open", resolve)));
226 const clientClosed = new Promise((resolve) => client.once("close", resolve));
227 yield* Deferred.succeed(revoked, undefined);
228 yield* Effect.promise(() => Promise.all([clientClosed, upstreamClosed.promise]));
229 }),
230 );
231
232 it.effect.each([
233 { case: "the setting", enabled: false, policy: undefined },
234 {
235 case: "a policy, whatever the setting",
236 enabled: true,
237 policy: {
238 organization: "Example Corp",
239 lockedSettings: [],
240 limits: { previewTunnel: false },
241 } satisfies ManagedPolicySummary,
242 },
243 ])("refuses every tunnel with 403 when $case turns it off", ({ enabled, policy }) =>
244 Effect.gen(function* () {
245 let dialled = 0;
246 const listed = yield* listen((socket) => {
247 dialled++;
248 socket.destroy();
249 });
250 const settings = yield* makeSettings(enabled, policy);
251 const tunnel = yield* serveTunnel(Effect.never, settings.layer);
252 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${listed.port}`);
253 const status = yield* Effect.promise(
254 () =>
255 new Promise<{ status: number | undefined; disabled: boolean }>((resolve, reject) => {
256 client.on("unexpected-response", (_request, response) =>
257 resolve({
258 status: response.statusCode,
259 disabled:
260 response.headers[PreviewTunnel.PREVIEW_TUNNEL_DISABLED_HEADER] !== undefined,
261 }),
262 );
263 client.on("open", () => reject(new Error("tunnel opened")));
264 client.on("error", reject);
265 }),
266 );
267 expect(status).toEqual({ status: 403, disabled: true });
268 expect(dialled).toBe(0);
269 }),
270 );
271
272 it.effect("closes an open tunnel when the setting turns it off", () =>
273 Effect.gen(function* () {
274 const upstreamClosed = Promise.withResolvers<void>();
275 const upstream = yield* listen((socket) => socket.on("close", () => upstreamClosed.resolve()));
276 const settings = yield* makeSettings();
277 const tunnel = yield* serveTunnel(Effect.never, settings.layer);
278 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${upstream.port}`);
279 yield* Effect.promise(() => new Promise((resolve) => client.once("open", resolve)));
280 const clientClosed = new Promise((resolve) => client.once("close", resolve));
281 yield* settings.set({ enablePreviewTunnel: false });
282 yield* Effect.promise(() => Promise.all([clientClosed, upstreamClosed.promise]));
283 }),
284 );
285
286 it.effect("closes a tunnel the setting turns off while it is still dialling", () =>
287 Effect.gen(function* () {
288 const settings = yield* makeSettings(true, undefined, { enablePreviewTunnel: false });
289 const upstreamClosed = Promise.withResolvers<void>();
290 const upstream = yield* listen((socket) => socket.on("close", () => upstreamClosed.resolve()));
291 const tunnel = yield* serveTunnel(Effect.never, settings.layer);
292 const client = yield* openTunnel(`${tunnel.origin}/api/preview/tunnel?port=${upstream.port}`);
293 const clientClosed = new Promise((resolve) => client.once("close", resolve));
294 yield* Effect.promise(() => Promise.all([clientClosed, upstreamClosed.promise]));
295 }),
296 );