The best way to control Claude Code, Codex and more from any computer or phone
| 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 | ); |