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

main
ts 267 lines 11.3 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import {
4 AuthTokenExchangeGrantType,
5 AuthEnvironmentBootstrapTokenType,
6 AuthAccessTokenType,
7 EnvironmentHttpApi,
8 } from "@t3tools/contracts";
9 import { expect, it } from "@effect/vitest";
10 import * as Context from "effect/Context";
11 import * as DateTime from "effect/DateTime";
12 import * as SecureRandom from "effect/crypto/SecureRandom";
13 import * as Effect from "effect/Effect";
14 import * as Layer from "effect/Layer";
15 import * as Redacted from "effect/Redacted";
16 import * as Schema from "effect/Schema";
17 import * as Etag from "effect/http/Etag";
18 import * as HttpPlatform from "effect/http/HttpPlatform";
19 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
20 import * as HttpApi from "effect/http-api/HttpApi";
21 import * as HttpRouter from "effect/http/HttpRouter";
22
23 import * as ServerConfig from "../config.ts";
24 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
25 import * as SqlitePersistence from "../persistence/Sqlite.ts";
26 import * as EnvironmentAuth from "./EnvironmentAuth.ts";
27 import { makeDpopKey } from "./dpop.testkit.ts";
28 import * as ServerSecretStore from "./ServerSecretStore.ts";
29 import * as AuthHttp from "./http.ts";
30 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
31
32 const DEV_TOKEN = "reusable-dev-auth-token-that-is-long-enough";
33 class AuthTestApi extends HttpApi.make("environment").add(EnvironmentHttpApi.groups.auth) {}
34
35 const layerConfig = Layer.effect(
36 ServerConfig.ServerConfig,
37 Effect.gen(function* () {
38 const config = yield* ServerConfig.ServerConfig;
39 return {
40 ...config,
41 mode: "web",
42 devUrl: new URL("http://127.0.0.1:5173"),
43 devAuthToken: Redacted.make(DEV_TOKEN),
44 } satisfies ServerConfig.ServerConfig["Service"];
45 }),
46 ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-http-test-" })));
47
48 const layerEnvironmentAuth = EnvironmentAuth.layer.pipe(
49 Layer.provide(ManagedPolicy.layerTest()),
50 Layer.provide(SqlitePersistence.layerMemory),
51 Layer.provide(ServerSecretStore.layer),
52 Layer.provide(ServerEnvironment.layerIdentity),
53 Layer.provide(layerConfig),
54 );
55 const layerRoutes = HttpApiBuilder.layer(AuthTestApi).pipe(
56 Layer.provide(AuthHttp.layer),
57 Layer.provide(AuthHttp.layerAuthenticatedAuth),
58 Layer.provideMerge(layerEnvironmentAuth),
59 Layer.provide(layerConfig),
60 Layer.provideMerge(
61 HttpPlatform.layer.pipe(
62 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
63 Layer.provideMerge(Etag.layerWeak),
64 ),
65 ),
66 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
67 );
68
69 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
70 const postJson = (path: string, body: unknown, headers?: Readonly<Record<string, string>>) =>
71 new Request(`http://127.0.0.1${path}`, {
72 method: "POST",
73 headers: { "content-type": "application/json", ...headers },
74 body: encodeJson(body),
75 });
76
77 it.effect("sets the selected browser session cookies through the HTTP route", () =>
78 Effect.gen(function* () {
79 const random = yield* SecureRandom.SecureRandom;
80 const unusedSecretStore = ServerSecretStore.ServerSecretStore.of({
81 get: () => Effect.succeedNone,
82 set: () => Effect.void,
83 create: () => Effect.void,
84 getOrCreateRandom: () => Effect.die("Not used by these routes."),
85 remove: () => Effect.void,
86 });
87 const requestContext = Context.make(SecureRandom.SecureRandom, random).pipe(
88 Context.add(ServerSecretStore.ServerSecretStore, unusedSecretStore),
89 );
90 return yield* Effect.acquireUseRelease(
91 Effect.sync(
92 () =>
93 [
94 HttpRouter.toWebHandler(layerRoutes, { disableLogger: true }),
95 HttpRouter.toWebHandler(layerRoutes, { disableLogger: true }),
96 ] as const,
97 ),
98 ([environmentA, environmentB]) =>
99 Effect.promise(async () => {
100 const devResponse = await environmentA.handler(
101 postJson("/api/auth/browser-session", { credential: DEV_TOKEN }),
102 requestContext,
103 );
104 expect(devResponse.status).toBe(200);
105 const retiredScopeResponse = await environmentA.handler(
106 new Request("http://127.0.0.1/oauth/token", {
107 method: "POST",
108 body: new URLSearchParams({
109 grant_type: AuthTokenExchangeGrantType,
110 subject_token: DEV_TOKEN,
111 subject_token_type: AuthEnvironmentBootstrapTokenType,
112 requested_token_type: AuthAccessTokenType,
113 scope: "review:write",
114 }),
115 }),
116 requestContext,
117 );
118 expect(retiredScopeResponse.status).toBe(400);
119 expect(await retiredScopeResponse.json()).toMatchObject({ reason: "invalid_scope" });
120
121 const devCookies = devResponse.headers.getSetCookie();
122 const devCookie = devCookies.find((cookie) => cookie.startsWith("t3_dev_session_"));
123 expect(devCookie).toContain("HttpOnly");
124 expect(devCookie).toContain(`=${DEV_TOKEN};`);
125 expect(devCookies).toContainEqual(
126 expect.stringMatching(/^t3_session_[^=]*=;.*Max-Age=0/),
127 );
128 expect(devCookies.filter((cookie) => /;\s*Secure/i.test(cookie))).toEqual([]);
129 const httpsResponse = await environmentA.handler(
130 postJson(
131 "/api/auth/browser-session",
132 { credential: DEV_TOKEN },
133 { "x-forwarded-proto": "https" },
134 ),
135 requestContext,
136 );
137 const httpsCookies = httpsResponse.headers.getSetCookie();
138 expect(httpsCookies).toHaveLength(2);
139 for (const cookie of httpsCookies) expect(cookie).toMatch(/;\s*Secure/i);
140 const devCookieHeader = devCookie?.split(";", 1)[0] ?? "";
141 const environmentBSession = await environmentB.handler(
142 new Request("http://127.0.0.1/api/auth/session", {
143 headers: { cookie: devCookieHeader },
144 }),
145 requestContext,
146 );
147 expect(environmentBSession.status).toBe(200);
148 expect(await environmentBSession.json()).toMatchObject({ authenticated: true });
149
150 const pairingResponse = await environmentA.handler(
151 postJson(
152 "/api/auth/pairing-token",
153 { scopes: ["orchestration:read"] },
154 { cookie: devCookieHeader },
155 ),
156 requestContext,
157 );
158 expect(pairingResponse.status).toBe(200);
159 const pairing = (await pairingResponse.json()) as { credential: string };
160 const restrictedResponse = await environmentA.handler(
161 postJson("/api/auth/browser-session", { credential: pairing.credential }),
162 requestContext,
163 );
164 expect(restrictedResponse.status).toBe(200);
165 const restrictedCookies = restrictedResponse.headers.getSetCookie();
166 expect(restrictedCookies).toHaveLength(1);
167 expect(restrictedCookies[0]).toMatch(/^t3_session_/);
168 expect(restrictedCookies[0]).not.toContain("t3_dev_session_");
169 }),
170 ([environmentA, environmentB]) =>
171 Effect.promise(() => Promise.all([environmentA.dispose(), environmentB.dispose()])),
172 );
173 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
174 );
175
176 it.effect.each(["DPoP", "dpop"])("challenges a refused %s request with DPoP", (scheme) =>
177 Effect.gen(function* () {
178 const random = yield* SecureRandom.SecureRandom;
179 const unusedSecretStore = ServerSecretStore.ServerSecretStore.of({
180 get: () => Effect.succeedNone,
181 set: () => Effect.void,
182 create: () => Effect.void,
183 getOrCreateRandom: () => Effect.die("Not used by these routes."),
184 remove: () => Effect.void,
185 });
186 const requestContext = Context.make(SecureRandom.SecureRandom, random).pipe(
187 Context.add(ServerSecretStore.ServerSecretStore, unusedSecretStore),
188 );
189 return yield* Effect.acquireUseRelease(
190 Effect.sync(() => HttpRouter.toWebHandler(layerRoutes, { disableLogger: true })),
191 (environment) =>
192 Effect.promise(async () => {
193 const refused = await environment.handler(
194 postJson(
195 "/api/auth/pairing-token",
196 { scopes: ["orchestration:read"] },
197 { authorization: `${scheme} not-a-valid-token` },
198 ),
199 requestContext,
200 );
201 expect(refused.status).toBe(401);
202 expect(refused.headers.get("www-authenticate")).toBe("DPoP");
203 }),
204 (environment) => Effect.promise(() => environment.dispose()),
205 );
206 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
207 );
208
209 // The web handler runs on its own runtime, so proofs need wall-clock time.
210 it.live("checks token-endpoint DPoP proofs without writing replay state", () =>
211 Effect.gen(function* () {
212 const random = yield* SecureRandom.SecureRandom;
213 const written: Array<string> = [];
214 const recordingSecretStore = ServerSecretStore.ServerSecretStore.of({
215 get: () => Effect.succeedNone,
216 set: () => Effect.void,
217 create: (name) => Effect.sync(() => void written.push(name)),
218 getOrCreateRandom: () => Effect.die("Not used by these routes."),
219 remove: () => Effect.void,
220 });
221 const requestContext = Context.make(SecureRandom.SecureRandom, random).pipe(
222 Context.add(ServerSecretStore.ServerSecretStore, recordingSecretStore),
223 );
224 const url = "http://127.0.0.1/oauth/token";
225 const key = makeDpopKey();
226 const iat = Math.floor((yield* DateTime.now).epochMilliseconds / 1_000);
227 const tokenRequest = (subjectToken: string, proof: string) =>
228 new Request(url, {
229 method: "POST",
230 headers: { host: "127.0.0.1", dpop: proof },
231 body: new URLSearchParams({
232 grant_type: AuthTokenExchangeGrantType,
233 subject_token: subjectToken,
234 subject_token_type: AuthEnvironmentBootstrapTokenType,
235 requested_token_type: AuthAccessTokenType,
236 }),
237 });
238 return yield* Effect.acquireUseRelease(
239 Effect.sync(() => HttpRouter.toWebHandler(layerRoutes, { disableLogger: true })),
240 (environment) =>
241 Effect.promise(async () => {
242 const unknownToken = await environment.handler(
243 tokenRequest("not-a-pairing-token", key.sign({ method: "POST", url, token: "", iat })),
244 requestContext,
245 );
246 expect(unknownToken.status).toBe(401);
247 expect(await unknownToken.json()).not.toHaveProperty("dpopFailureReason");
248
249 const accepted = await environment.handler(
250 tokenRequest(DEV_TOKEN, key.sign({ method: "POST", url, token: "", iat })),
251 requestContext,
252 );
253 expect(accepted.status).toBe(200);
254 expect(await accepted.json()).toMatchObject({ token_type: "DPoP" });
255
256 const badProof = await environment.handler(
257 tokenRequest(DEV_TOKEN, "not-a-proof"),
258 requestContext,
259 );
260 expect(badProof.status).toBe(401);
261 expect(badProof.headers.get("www-authenticate")).toBe("DPoP");
262 expect(written).toEqual([]);
263 }),
264 (environment) => Effect.promise(() => environment.dispose()),
265 );
266 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
267 );