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