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

main
ts 306 lines 12.3 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { describe, expect, it } from "@effect/vitest";
4 import {
5 AuthAccessTokenType,
6 AuthEnvironmentBootstrapTokenType,
7 AuthTokenExchangeGrantType,
8 EnvironmentHttpApi,
9 EnvironmentId,
10 } from "@t3tools/contracts";
11 import {
12 RelayEnvironmentLinkProofPayload,
13 type RelayLinkProofRequest,
14 } from "@t3tools/contracts/relay";
15 import * as Effect from "effect/Effect";
16 import * as TestClock from "effect/testing/TestClock";
17 import * as Layer from "effect/Layer";
18 import * as Schema from "effect/Schema";
19 import { HttpClient, HttpServer } from "effect/http";
20 import * as Etag from "effect/http/Etag";
21 import * as HttpPlatform from "effect/http/HttpPlatform";
22 import * as HttpRouter from "effect/http/HttpRouter";
23 import * as HttpApi from "effect/http-api/HttpApi";
24 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
25 import * as NetAddress from "effect/net/NetAddress";
26 import { decodeRelayJwt, RELAY_LINK_PROOF_TYP, verifyRelayJwt } from "@t3tools/shared/relayJwt";
27
28 import * as EnvironmentKeys from "./environmentKeys.ts";
29 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
30 import * as AuthHttp from "../auth/http.ts";
31 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
32 import * as ServerConfig from "../config.ts";
33 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
34 import * as SqlitePersistence from "../persistence/Sqlite.ts";
35 import * as AgentAwarenessRelay from "../relay/AgentAwarenessRelay.ts";
36 import * as CliTokenManager from "./CliTokenManager.ts";
37 import * as CloudLink from "./CloudLink.ts";
38 import * as ConnectHttp from "./http.ts";
39 import * as ConnectReachability from "./ConnectReachability.ts";
40 import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts";
41 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
42 import * as ServerSettings from "../serverSettings.ts";
43
44 const DESKTOP_BOOTSTRAP_TOKEN = "test-desktop-bootstrap-token";
45 const NON_LOOPBACK_ORIGIN = "http://172.24.162.233:3773";
46 const proofRequest: RelayLinkProofRequest = {
47 challenge: "test-challenge",
48 relayIssuer: "https://relay.example.test",
49 endpoint: {
50 providerKind: "cloudflare_tunnel",
51 httpBaseUrl: "https://environment.example.test",
52 wsBaseUrl: "wss://environment.example.test",
53 },
54 origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
55 };
56 const decodeLinkProofPayload = Schema.decodeUnknownEffect(RelayEnvironmentLinkProofPayload);
57
58 class LinkProofTestApi extends HttpApi.make("environment").add(
59 EnvironmentHttpApi.groups.auth,
60 EnvironmentHttpApi.groups.connect,
61 ) {}
62
63 const layerConfig = Layer.effect(
64 ServerConfig.ServerConfig,
65 Effect.gen(function* () {
66 const config = yield* ServerConfig.ServerConfig;
67 return {
68 ...config,
69 mode: "desktop" as const,
70 host: "0.0.0.0",
71 port: 3773,
72 desktopBootstrapToken: DESKTOP_BOOTSTRAP_TOKEN,
73 };
74 }),
75 ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-link-proof-test-" })));
76
77 // Real credential issuance, verification, origin checks and signing; no relay or tunnel is started.
78 const layerLinkProofRoutes = HttpApiBuilder.layer(LinkProofTestApi).pipe(
79 Layer.provide([AuthHttp.layer, ConnectHttp.layer]),
80 Layer.provide(AuthHttp.layerAuthenticatedAuth),
81 Layer.provide(CloudLink.layer),
82 Layer.provide(ServerSettings.ServerSettingsService.layerTest()),
83 Layer.provide(EnvironmentKeys.layer),
84 Layer.provide(
85 Layer.mock(ConnectReachability.ConnectReachability)({ latest: Effect.succeedNone }),
86 ),
87 Layer.provide(EnvironmentAuth.layer),
88 Layer.provide([
89 ManagedPolicy.layerTest(),
90 SqlitePersistence.layerMemory,
91 ServerEnvironment.layerIdentity,
92 Layer.mock(ServerEnvironment.ServerEnvironment)({
93 getDescriptor: Effect.succeed({
94 environmentId: EnvironmentId.make("wsl-environment"),
95 label: "WSL",
96 platform: { os: "linux", arch: "x64" },
97 serverVersion: "0.0.0-test",
98 capabilities: { repositoryIdentity: false },
99 }),
100 }),
101 Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({
102 withLinkStateLock: (effect) => effect,
103 }),
104 Layer.mock(CliTokenManager.CloudCliTokenManager)({}),
105 Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({}),
106 Layer.mock(HttpServer.HttpServer)({
107 address: NetAddress.inetAddressFromIpStringUnsafe("0.0.0.0", 3773),
108 }),
109 Layer.succeed(
110 HttpClient.HttpClient,
111 HttpClient.make(() => Effect.die("Unexpected relay call")),
112 ),
113 ]),
114 Layer.provideMerge(ServerSecretStore.layer),
115 Layer.provide(layerConfig),
116 Layer.provideMerge(HttpPlatform.layer.pipe(Layer.provideMerge(Etag.layerWeak))),
117 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
118 );
119
120 const responseJson = (response: Response) => Effect.promise(() => response.json());
121
122 // Scoped: the web handler and its layer are disposed when the test's scope closes.
123 const linkProofClient = Effect.gen(function* () {
124 const { handler } = yield* Effect.acquireRelease(
125 Effect.sync(() => HttpRouter.toWebHandler(layerLinkProofRoutes, { disableLogger: true })),
126 (web) => Effect.promise(() => web.dispose()),
127 );
128 const post = (
129 path: string,
130 payload: unknown,
131 headers?: Record<string, string>,
132 origin = NON_LOOPBACK_ORIGIN,
133 ) =>
134 Effect.promise(() =>
135 handler(
136 new Request(`${origin}${path}`, {
137 method: "POST",
138 headers: { "content-type": "application/json", ...headers },
139 body: JSON.stringify(payload),
140 }),
141 ),
142 );
143 const exchange = Effect.fnUntraced(function* (credential: string, scope?: string) {
144 const response = yield* Effect.promise(() =>
145 handler(
146 new Request(`${NON_LOOPBACK_ORIGIN}/oauth/token`, {
147 method: "POST",
148 body: new URLSearchParams({
149 grant_type: AuthTokenExchangeGrantType,
150 subject_token: credential,
151 subject_token_type: AuthEnvironmentBootstrapTokenType,
152 requested_token_type: AuthAccessTokenType,
153 ...(scope ? { scope } : {}),
154 }),
155 }),
156 ),
157 );
158 expect(response.status).toBe(200);
159 const payload = (yield* responseJson(response)) as { access_token: string };
160 return payload.access_token;
161 });
162 const linkableHere = (token: string) =>
163 Effect.promise(() =>
164 handler(
165 new Request(`${NON_LOOPBACK_ORIGIN}/api/connect/link-state`, {
166 headers: { authorization: `Bearer ${token}` },
167 }),
168 ),
169 ).pipe(
170 Effect.flatMap(responseJson),
171 Effect.map((state) => (state as { linkableHere?: boolean }).linkableHere),
172 );
173 return { post, exchange, linkableHere };
174 });
175
176 describe("link proof over a non-loopback transport", () => {
177 it.effect(
178 "signs this server's loopback origin for a remote client allowed to configure the relay",
179 () =>
180 Effect.gen(function* () {
181 const { post, exchange } = yield* linkProofClient;
182 const admin = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN);
183 const paired = yield* post(
184 "/api/auth/pairing-token",
185 { scopes: ["relay:read", "relay:configure"] },
186 { authorization: `Bearer ${admin}` },
187 );
188 expect(paired.status).toBe(200);
189 const { credential } = (yield* responseJson(paired)) as { credential: string };
190 const token = yield* exchange(credential);
191 // The caller's origin and forwarding headers must not steer the tunnel elsewhere.
192 const response = yield* post(
193 "/api/connect/link-proof",
194 { ...proofRequest, origin: { localHttpHost: "172.24.162.233", localHttpPort: 5432 } },
195 { authorization: `Bearer ${token}`, "x-forwarded-host": "evil.example.test" },
196 );
197 expect(response.status).toBe(200);
198 expect(response.headers.get("cache-control")).toBe("no-store");
199 const proof = (yield* responseJson(response)) as string;
200 const unverified = yield* decodeRelayJwt(proof).pipe(
201 Effect.flatMap(decodeLinkProofPayload),
202 );
203 yield* TestClock.setTime(unverified.iat * 1_000);
204 const verified = yield* verifyRelayJwt(RelayEnvironmentLinkProofPayload, {
205 publicKey: unverified.environmentPublicKey,
206 token: proof,
207 typ: RELAY_LINK_PROOF_TYP,
208 issuer: "t3-env:wsl-environment",
209 audience: proofRequest.relayIssuer,
210 });
211 expect(verified).toMatchObject({
212 origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
213 endpoint: proofRequest.endpoint,
214 challenge: proofRequest.challenge,
215 });
216 }).pipe(Effect.provide(NodeCrypto.layerSignature)),
217 );
218
219 it.effect("offers Turn on to any session allowed to configure the relay", () =>
220 Effect.gen(function* () {
221 const { post, exchange, linkableHere } = yield* linkProofClient;
222 const desktop = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN);
223 const pair = (scopes: ReadonlyArray<string>) =>
224 post("/api/auth/pairing-token", { scopes }, { authorization: `Bearer ${desktop}` }).pipe(
225 Effect.flatMap(responseJson),
226 Effect.flatMap((paired) => exchange((paired as { credential: string }).credential)),
227 );
228 expect(yield* linkableHere(desktop)).toBe(true);
229 const remote = yield* pair(["relay:read", "relay:write", "relay:configure"]);
230 expect(yield* linkableHere(remote)).toBe(true);
231 expect(yield* linkableHere(yield* pair(["relay:read", "relay:write"]))).toBe(false);
232 expect(yield* linkableHere(yield* pair(["relay:read", "relay:configure"]))).toBe(false);
233 }),
234 );
235
236 it.effect("requires relay configuration permission even for desktop bootstrap", () =>
237 Effect.gen(function* () {
238 const { post, exchange } = yield* linkProofClient;
239 const token = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:write");
240 const response = yield* post("/api/connect/link-proof", proofRequest, {
241 authorization: `Bearer ${token}`,
242 });
243 expect(response.status).toBe(403);
244 expect(yield* responseJson(response)).toMatchObject({
245 code: "insufficient_scope",
246 requiredScope: "relay:write",
247 requiredPermission: "relay:configure",
248 });
249 }),
250 );
251
252 it.effect("allows relay writers to set preferences without creating a link", () =>
253 Effect.gen(function* () {
254 const { post, exchange } = yield* linkProofClient;
255 const path = "/api/connect/live-activity-preference";
256 const payload = { liveActivitiesEnabled: true };
257 const readToken = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:read");
258 const denied = yield* post(path, payload, { authorization: `Bearer ${readToken}` });
259 expect(denied.status).toBe(403);
260
261 const writeToken = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:write");
262 const unlinked = yield* post(path, payload, { authorization: `Bearer ${writeToken}` });
263 expect(unlinked.status).toBe(200);
264 expect(yield* responseJson(unlinked)).toEqual({ ok: false });
265 }),
266 );
267
268 it.effect("requires explicit permission to configure the relay", () =>
269 Effect.gen(function* () {
270 const { post, exchange } = yield* linkProofClient;
271 const admin = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN);
272 const paired = yield* post(
273 "/api/auth/pairing-token",
274 {},
275 { authorization: `Bearer ${admin}` },
276 );
277 expect(paired.status).toBe(200);
278 const { credential } = (yield* responseJson(paired)) as { credential: string };
279 const token = yield* exchange(credential);
280 const response = yield* post(
281 "/api/connect/relay-config",
282 {
283 relayUrl: "https://relay.example.test",
284 cloudUserId: "test-link-owner",
285 environmentCredential: "test-environment-credential",
286 cloudMintPublicKey: "test-public-key",
287 endpointRuntime: null,
288 },
289 { authorization: `Bearer ${token}` },
290 );
291 expect(response.status).toBe(403);
292 expect(yield* responseJson(response)).toMatchObject({
293 code: "insufficient_scope",
294 requiredPermission: "relay:configure",
295 });
296 }),
297 );
298
299 it.effect("rejects unauthenticated requests", () =>
300 Effect.gen(function* () {
301 const { post } = yield* linkProofClient;
302 const response = yield* post("/api/connect/link-proof", proofRequest);
303 expect(response.status).toBe(401);
304 }),
305 );
306 });