diff --git a/apps/server/src/provider/CodexChatGptAuth.test.ts b/apps/server/src/provider/CodexChatGptAuth.test.ts index 7bcb7413a1578..3e521103d56cf 100644 --- a/apps/server/src/provider/CodexChatGptAuth.test.ts +++ b/apps/server/src/provider/CodexChatGptAuth.test.ts @@ -1,4 +1,9 @@ // @effect-diagnostics nodeBuiltinImport:off globalFetchInEffect:off - Local mock OAuth server validates the browser callback boundary. +import * as NodeNet from "node:net"; +import * as Context from "effect/Context"; +import * as Scope from "effect/Scope"; +import * as ServerConfig from "../config.ts"; +import * as CodexManagedTokenBroker from "./CodexManagedTokenBroker.ts"; import * as NodeHttp from "node:http"; import * as NodeCrypto from "node:crypto"; import * as NodeServices from "@effect/platform-node/NodeServices"; @@ -11,7 +16,7 @@ import * as Stream from "effect/Stream"; import * as Fiber from "effect/Fiber"; import * as Deferred from "effect/Deferred"; import { subscribeChatGptHandoff } from "./CodexChatGptHandoff.ts"; -import { FetchHttpClient } from "effect/http"; +import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/http"; import { exportJWK, generateKeyPair, SignJWT } from "jose"; import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; @@ -320,6 +325,16 @@ const makeHarnessFor = Effect.fnUntraced(function* ( ); return { auth: destination, bytes: destinationBytes }; }), + bindProfile: (expectedProfileKey: string) => + makeCodexChatGptAuth({ + instanceId, + expectedProfileKey, + discoveryUrl: `${origin}/discovery`, + resource: `${origin}/v1`, + }).pipe( + Effect.provideService(ServerSecretStore.ServerSecretStore, secrets), + Effect.provideService(ServerEnvironment.ServerEnvironmentIdentity, environment), + ), recreateAuth: makeCodexChatGptAuth({ instanceId, discoveryUrl: `${origin}/discovery`, @@ -1604,3 +1619,205 @@ it.effect("telemetry failures do not fail a verified ChatGPT sign-in", () => }), ), ); +it.effect("a running session renews its bound profile but refuses a replacement sign-in", () => + provision( + Effect.gen(function* () { + const h = yield* makeHarness; + yield* h.signIn; + yield* h.phase("succeeded"); + const profileKey = yield* h.auth.profileKey(Option.getOrThrow(yield* h.auth.read)); + const first = yield* h.bindProfile(profileKey); + const second = yield* h.bindProfile(profileKey); + yield* h.seedExpired; + const renewed = yield* Effect.all([first.access, second.access], { + concurrency: "unbounded", + }); + assert.equal(h.refreshes(), 1); + assert.equal(renewed[0].accessToken, "access-1"); + assert.deepEqual(renewed[0], renewed[1]); + assert.equal(yield* h.auth.profileKey(renewed[0]), profileKey); + + // Reconnecting the same account replaces its sign-in identity, too. + yield* h.reconnectProfile("oaiapp_test"); + yield* h.phase("succeeded"); + const replacement = Option.getOrThrow(yield* h.auth.read); + assert.equal(replacement.clientId, renewed[0].clientId); + assert.equal(replacement.subject, renewed[0].subject); + yield* h.seedExpired; + assert.equal((yield* first.access.pipe(Effect.flip)).operation, "access"); + assert.equal(h.refreshes(), 1); + yield* h.auth.revoke; + assert.equal((yield* second.access.pipe(Effect.flip)).operation, "access"); + assert.isTrue(Option.isNone(yield* h.auth.read)); + }), + ), +); + +const makeRenewalBroker = Effect.gen(function* () { + const oauthEntered = yield* Deferred.make(); + const oauthRelease = yield* Deferred.make(); + let pauseOAuth = false; + const refreshTokens: string[] = []; + const credentials = { + clientId: "oaiapp_broker", + subject: "broker-user", + idToken: "broker-sign-in", + email: null, + accessToken: "expired-access", + refreshToken: "single-use-refresh", + expiresAt: 0, + earliestRefreshAt: null, + scopes: ["chatgpt.tokens.use.direct"], + }; + const environmentId = EnvironmentId.make("00000000-0000-4000-8000-000000000001"); + const http = HttpClient.make((request) => + Effect.gen(function* () { + if (request.url.endsWith("openid-configuration")) { + return HttpClientResponse.fromWeb( + request, + Response.json({ + issuer: "https://auth.openai.com", + authorization_endpoint: "https://auth.openai.com/authorize", + token_endpoint: "https://auth.openai.com/token", + jwks_uri: "https://auth.openai.com/jwks", + }), + ); + } + assert.equal(request.url, "https://auth.openai.com/token"); + assert.equal(request.body._tag, "Uint8Array"); + if (request.body._tag !== "Uint8Array") return yield* Effect.die("Missing refresh body"); + const body = new URLSearchParams(new TextDecoder().decode(request.body.body)); + refreshTokens.push(body.get("refresh_token")!); + yield* Deferred.succeed(oauthEntered, undefined); + if (pauseOAuth) yield* Deferred.await(oauthRelease); + return HttpClientResponse.fromWeb( + request, + Response.json({ + access_token: "renewed-access", + refresh_token: "rotated-refresh", + expires_in: 3600, + token_type: "Bearer", + scope: "chatgpt.tokens.use.direct", + }), + ); + }), + ); + return yield* Effect.gen(function* () { + const store = yield* ProviderCredentialStore.make("codex-chatgpt", instanceId); + yield* store.set(new TextEncoder().encode(JSON.stringify(credentials))); + const auth = yield* makeCodexChatGptAuth({ instanceId }); + const profileKey = yield* auth.profileKey(credentials); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer((exit) => Scope.close(scope, exit)); + const context = yield* Layer.buildWithScope(CodexManagedTokenBroker.layer, scope); + const broker = Context.get(context, CodexManagedTokenBroker.CodexManagedTokenBroker); + const endpoint = yield* broker.endpoint; + yield* Effect.addFinalizer(() => Deferred.succeed(oauthRelease, undefined)); + return { + auth, + store, + broker, + endpoint, + refreshTokens, + request: { version: 1, instanceId, environmentId, profileKey }, + oauthEntered, + oauthRelease, + pause: () => { + pauseOAuth = true; + }, + }; + }).pipe( + Effect.provide(ServerSecretStore.layer), + Effect.provideService(HttpClient.HttpClient, http), + Effect.provideService(ServerEnvironment.ServerEnvironmentIdentity, { + getEnvironmentId: Effect.succeed(environmentId), + }), + ); +}); + +const brokerClient = (endpoint: string, request: unknown) => + Effect.acquireRelease( + Effect.callback<{ socket: NodeNet.Socket; response: Promise }, Error>((resume) => { + const socket = NodeNet.createConnection(endpoint); + let text = ""; + socket.setEncoding("utf8"); + socket.on("data", (chunk) => { + text += chunk; + }); + const response = new Promise((resolve) => socket.once("close", () => resolve(text))); + socket.on("error", () => {}); + socket.once("error", (error) => resume(Effect.fail(error))); + socket.once("connect", () => { + socket.write(JSON.stringify(request) + "\n"); + resume(Effect.succeed({ socket, response })); + }); + return Effect.sync(() => { + if (socket.connecting) socket.destroy(); + }); + }), + ({ socket }) => Effect.sync(() => socket.destroy()), + ); +const provideBroker = (effect: Effect.Effect) => + effect.pipe( + Effect.scoped, + Effect.provide( + ServerConfig.layerTest(process.cwd(), { prefix: "t3-renewal-test-" }).pipe( + Layer.provideMerge(NodeServices.layer), + ), + ), + ); + +// regression: #16132 a renewal must outlive the Codex helper that asked for it, because the +// refresh token it spends is single-use. +it.effect("server-owned renewal persists rotated credentials after the helper disconnects", () => + provideBroker( + Effect.gen(function* () { + const h = yield* makeRenewalBroker; + h.pause(); + const client = yield* brokerClient(h.endpoint, h.request); + yield* Deferred.await(h.oauthEntered); + client.socket.destroy(); + yield* Effect.promise(() => client.response); + assert.equal(Option.getOrThrow(yield* h.auth.read).refreshToken, "single-use-refresh"); + yield* Deferred.succeed(h.oauthRelease, undefined); + yield* h.broker.awaitIdle; + const persisted = Option.getOrThrow(yield* h.auth.read); + assert.equal(persisted.refreshToken, "rotated-refresh"); + assert.equal((yield* h.auth.access).accessToken, "renewed-access"); + assert.deepEqual(h.refreshTokens, ["single-use-refresh"]); + }), + ), +); + +it.live("the private broker refuses another environment, instance, or sign-in profile", () => + provideBroker( + Effect.gen(function* () { + const h = yield* makeRenewalBroker; + yield* Effect.forEach( + [ + { + ...h.request, + environmentId: EnvironmentId.make("00000000-0000-4000-8000-000000000002"), + }, + { ...h.request, instanceId: ProviderInstanceId.make("another-instance") }, + { ...h.request, profileKey: "0".repeat(64) }, + ], + (request) => + Effect.scoped( + Effect.gen(function* () { + const client = yield* brokerClient(h.endpoint, request); + assert.equal(yield* Effect.promise(() => client.response), ""); + }), + ), + ); + yield* h.broker.awaitIdle; + assert.deepEqual(h.refreshTokens, []); + const client = yield* brokerClient(h.endpoint, h.request); + assert.deepEqual(JSON.parse(yield* Effect.promise(() => client.response)), { + token: "renewed-access", + }); + yield* h.broker.awaitIdle; + assert.deepEqual(h.refreshTokens, ["single-use-refresh"]); + }), + ), +); diff --git a/apps/server/src/provider/CodexChatGptAuth.ts b/apps/server/src/provider/CodexChatGptAuth.ts index 8b9190c40d18e..20cc69cac391e 100644 --- a/apps/server/src/provider/CodexChatGptAuth.ts +++ b/apps/server/src/provider/CodexChatGptAuth.ts @@ -15,6 +15,7 @@ import * as Cause from "effect/Cause"; import * as AnalyticsService from "../telemetry/AnalyticsService.ts"; import { openAiUserId } from "../telemetry/Identify.ts"; import * as Crypto from "effect/Crypto"; +import * as Hex from "effect/encoding/Hex"; import * as Exit from "effect/Exit"; import { codexAuthCallbackPage, codexAuthReturnUrl } from "./CodexAuthCallbackPage.ts"; import * as Effect from "effect/Effect"; @@ -108,6 +109,7 @@ export const makeCodexChatGptAuth = Effect.fn("makeCodexChatGptAuth")(function* readonly defaultReturnUrl?: string; readonly reconnectProfile?: ChatGptReconnectProfile | null; readonly telemetryFlow?: "direct" | "primary_handoff"; + readonly expectedProfileKey?: string; }) { const analytics = yield* Effect.serviceOption(AnalyticsService.AnalyticsService); const settings = yield* Effect.serviceOption(ServerSettings.ServerSettingsService); @@ -726,6 +728,17 @@ export const makeCodexChatGptAuth = Effect.fn("makeCodexChatGptAuth")(function* ), ); }); + // ID tokens survive renewal but change on sign-in. Bind active children to the + // launch profile without putting an identity token or subject in their argv. + const profileKey = (record: CodexChatGptCredentials) => + crypto + .digest( + "SHA-256", + new TextEncoder().encode( + JSON.stringify([record.clientId, record.subject, record.idToken ?? null]), + ), + ) + .pipe(Effect.map(Hex.encode), Effect.orDie); const access = lock.withPermit( withSessionLock( Effect.uninterruptible( @@ -734,6 +747,11 @@ export const makeCodexChatGptAuth = Effect.fn("makeCodexChatGptAuth")(function* if (Option.isNone(saved)) return yield* failure("access", "Sign in with ChatGPT to use managed Codex."); let record = saved.value; + if ( + options.expectedProfileKey !== undefined && + (yield* profileKey(record)) !== options.expectedProfileKey + ) + return yield* failure("access", "The ChatGPT connection changed. Start a new session."); if (!record.scopes.includes(REQUIRED_SCOPE)) return yield* failure( "sharing", @@ -991,6 +1009,7 @@ export const makeCodexChatGptAuth = Effect.fn("makeCodexChatGptAuth")(function* controller: { ...controller, reconnectProfile, importProfile }, read, access, + profileKey, exportProfile, revoke: lock.withPermit(withSessionLock(remove)), }; diff --git a/apps/server/src/provider/CodexManagedTokenBroker.ts b/apps/server/src/provider/CodexManagedTokenBroker.ts new file mode 100644 index 0000000000000..4a1e861827142 --- /dev/null +++ b/apps/server/src/provider/CodexManagedTokenBroker.ts @@ -0,0 +1,225 @@ +// @effect-diagnostics nodeBuiltinImport:off - Server-owned private pipe/Unix socket, never a public listener. +import * as NodeFSP from "node:fs/promises"; +import * as NodeNet from "node:net"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import * as NodeCrypto from "node:crypto"; +import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as FiberSet from "effect/FiberSet"; +import * as Layer from "effect/Layer"; +import * as Exit from "effect/Exit"; +import * as Scope from "effect/Scope"; +import * as Schema from "effect/Schema"; +import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; +import { makeCodexChatGptAuth } from "./CodexChatGptAuth.ts"; +import * as Protocol from "./CodexManagedTokenProtocol.ts"; + +const MAX_CONNECTIONS = 32; +const MAX_JOBS = 16; +// Stay below macOS's 104-byte and Linux's 108-byte sockaddr_un limits, including NUL. +const UNIX_SOCKET_PATH_BYTES = 100; +const encodeResponse = Schema.encodeSync(Schema.fromJsonString(Protocol.Response)); +class BrokerStartError extends Schema.TaggedError()( + "ManagedTokenBrokerStartError", + { + cause: Schema.Defect(), + }, +) { + override get message() { + return "Could not start the private managed token listener."; + } +} +export class CodexManagedTokenBroker extends Context.Service< + CodexManagedTokenBroker, + { + readonly endpoint: Effect.Effect; + readonly awaitIdle: Effect.Effect; + } +>()("t3/provider/CodexManagedTokenBroker") {} + +const io = (f: () => Promise) => + Effect.tryPromise({ try: f, catch: (cause) => new BrokerStartError({ cause }) }); +const acquireListener = Effect.gen(function* () { + const identity = yield* ServerEnvironment.ServerEnvironmentIdentity; + const environmentId = yield* identity.getEnvironmentId; + const platform = yield* HostProcess.Platform; + const uid = yield* HostProcess.UserId; + const owned = yield* Effect.acquireRelease( + io(async () => { + if (platform === "win32") + return { endpoint: `\\\\.\\pipe\\t3-token-${NodeCrypto.randomUUID()}` }; + if (uid === undefined) throw new Error("Missing IPC owner"); + const acquireDirectory = async (candidate: string) => { + const parent = await NodeFSP.realpath(candidate); + const stat = await NodeFSP.lstat(parent); + if ( + !stat.isDirectory() || + stat.isSymbolicLink() || + !( + (stat.uid === uid && (stat.mode & 0o022) === 0) || + (stat.uid === 0 && ((stat.mode & 0o022) === 0 || (stat.mode & 0o1000) !== 0)) + ) + ) + throw new Error("Untrusted IPC parent"); + const directory = await NodeFSP.mkdtemp(NodePath.join(parent, "t3-token-")); + try { + await NodeFSP.chmod(directory, 0o700); + const created = await NodeFSP.lstat(directory); + if ( + !created.isDirectory() || + created.isSymbolicLink() || + created.uid !== uid || + (created.mode & 0o777) !== 0o700 + ) + throw new Error("Unprotected IPC directory"); + const endpoint = NodePath.join(directory, "s"); + if (Buffer.byteLength(endpoint) > UNIX_SOCKET_PATH_BYTES) + throw new Error("IPC path too long"); + return { endpoint, directory, created }; + } catch (error) { + await NodeFSP.rmdir(directory); + throw error; + } + }; + return acquireDirectory(NodeOS.tmpdir()).catch(() => acquireDirectory("/tmp")); + }), + (owned) => + Effect.promise(async () => { + if (!("directory" in owned)) return; + // Never recursively remove a replaced directory or another process's files. + const current = await NodeFSP.lstat(owned.directory).catch(() => undefined); + if ( + current && + current.dev === owned.created.dev && + current.ino === owned.created.ino && + !current.isSymbolicLink() + ) + await NodeFSP.rmdir(owned.directory).catch(() => undefined); + }), + ); + const jobs = yield* FiberSet.make(); + const runJob = + yield* FiberSet.runtime(jobs)< + Exclude< + Effect.Services>, + import("effect/Scope").Scope + > + >(); + const connections = yield* FiberSet.make(); + const runConnection = yield* FiberSet.runtime(connections)(); + const sockets = new Set(); + let closing = false; + let admitted = 0; + // Keep branded validation here so the helper need not load the contracts graph. + const decode = Schema.decodeUnknownEffect( + Schema.fromJsonString( + Schema.Struct({ + ...Protocol.Request.fields, + instanceId: ProviderInstanceId, + environmentId: EnvironmentId, + }), + ), + { + onExcessProperty: "error", + }, + ); + const server = NodeNet.createServer((socket) => { + socket.on("error", () => {}); + if (closing || sockets.size >= MAX_CONNECTIONS) { + socket.destroy(); + return; + } + sockets.add(socket); + socket.once("close", () => sockets.delete(socket)); + let transferred = false; + runConnection( + Effect.gen(function* () { + // Windows pipes permit read-only peers by default; send no bytes until a complete request. + const request = yield* Protocol.readFrame( + socket, + Protocol.REQUEST_BYTES, + Protocol.SOCKET_IDLE_MS, + ).pipe(Effect.flatMap(decode)); + if (closing || admitted >= MAX_JOBS || request.environmentId !== environmentId) return; + admitted++; + transferred = true; + runJob( + Effect.scoped( + Effect.gen(function* () { + const auth = yield* makeCodexChatGptAuth({ + instanceId: request.instanceId, + expectedProfileKey: request.profileKey, + }); + // Retire abandoned permit waits; access saves a started rotation before honoring interruption. + const credentials = yield* auth.access.pipe( + Effect.timeout(Protocol.COMMAND_TIMEOUT_MS), + ); + yield* Protocol.writeFrame( + socket, + encodeResponse({ token: credentials.accessToken }), + Protocol.RESPONSE_BYTES, + ); + }), + ).pipe( + Effect.ignoreCause, + Effect.ensuring( + Effect.sync(() => { + admitted--; + socket.destroy(); + }), + ), + ), + ); + }).pipe( + Effect.ignoreCause, + Effect.ensuring( + Effect.sync(() => { + if (!transferred) socket.destroy(); + }), + ), + ), + ); + }); + server.on("error", () => {}); + // Drain accepted rotations before the FiberSet finalizers interrupt their fibers. + yield* Effect.addFinalizer(() => + Effect.gen(function* () { + closing = true; + for (const socket of sockets) socket.destroy(); + yield* Effect.promise(() => new Promise((resolve) => server.close(() => resolve()))); + yield* FiberSet.awaitEmpty(connections); + yield* FiberSet.awaitEmpty(jobs); + }), + ); + yield* Effect.callback((resume) => { + const onError = (cause: Error) => resume(Effect.fail(new BrokerStartError({ cause }))); + server.once("error", onError); + try { + server.listen(owned.endpoint, () => resume(Effect.void)); + } catch (cause) { + resume(Effect.fail(new BrokerStartError({ cause }))); + } + return Effect.sync(() => server.off("error", onError)); + }); + if (platform !== "win32") yield* io(() => NodeFSP.chmod(owned.endpoint, 0o600)); + return { endpoint: owned.endpoint, awaitIdle: FiberSet.awaitEmpty(jobs) }; +}); +const make = Effect.gen(function* () { + const scope = yield* Scope.fork(yield* Effect.scope); + const acquired = yield* acquireListener.pipe(Scope.provide(scope), Effect.result); + if (acquired._tag === "Failure") { + yield* Scope.close(scope, Exit.fail(acquired.failure)); + return CodexManagedTokenBroker.of({ + endpoint: Effect.fail(acquired.failure), + awaitIdle: Effect.void, + }); + } + return CodexManagedTokenBroker.of({ + endpoint: Effect.succeed(acquired.success.endpoint), + awaitIdle: acquired.success.awaitIdle, + }); +}); +export const layer = Layer.effect(CodexManagedTokenBroker, make); diff --git a/apps/server/src/provider/CodexManagedTokenProtocol.ts b/apps/server/src/provider/CodexManagedTokenProtocol.ts new file mode 100644 index 0000000000000..d5f9e610d2188 --- /dev/null +++ b/apps/server/src/provider/CodexManagedTokenProtocol.ts @@ -0,0 +1,72 @@ +// @effect-diagnostics nodeBuiltinImport:off - Private local IPC framing, shared by server and lean CLI. +import type * as NodeNet from "node:net"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +export const Request = Schema.Struct({ + version: Schema.Literal(1), + instanceId: Schema.NonEmptyString, + environmentId: Schema.NonEmptyString, + profileKey: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u)), +}); +export const Response = Schema.Struct({ token: Schema.NonEmptyString }); +// Selectors are small; tokens can be larger JWTs. Never truncate either frame +// into something that could be accepted. +export const REQUEST_BYTES = 1024; +export const RESPONSE_BYTES = 64 * 1024; +// Idle/incomplete peers and blocked response consumers must not retain sockets. +export const SOCKET_IDLE_MS = 5_000; +// Existing lock retry (40s), OAuth (20s), plus startup/store headroom (20s). +export const COMMAND_TIMEOUT_MS = 80_000; +class ProtocolError extends Schema.TaggedError()("ManagedTokenProtocolError", {}) { + override get message(): string { + return "The managed token frame was invalid or incomplete."; + } +} + +export const readFrame = (socket: NodeNet.Socket, maxBytes: number, timeoutMs: number) => + Effect.callback((resume) => { + let bytes = Buffer.alloc(0); + const fail = () => resume(Effect.fail(new ProtocolError())); + const onData = (chunk: Buffer) => { + if (bytes.length + chunk.length > maxBytes) return fail(); + bytes = Buffer.concat([bytes, chunk]); + const end = bytes.indexOf(10); + if (end < 0) return; + if (end !== bytes.length - 1) return fail(); + resume(Effect.succeed(bytes.subarray(0, end).toString("utf8"))); + }; + socket.on("data", onData); + socket.once("error", fail); + socket.once("close", fail); + socket.once("end", fail); + return Effect.sync(() => { + socket.off("data", onData); + socket.off("error", fail); + socket.off("close", fail); + socket.off("end", fail); + }); + }).pipe( + Effect.timeoutOrElse({ duration: timeoutMs, orElse: () => Effect.fail(new ProtocolError()) }), + ); + +export const writeFrame = (socket: NodeNet.Socket, frame: string, maxBytes: number) => + Effect.callback((resume) => { + if (socket.destroyed || Buffer.byteLength(frame) + 1 > maxBytes) { + resume(Effect.fail(new ProtocolError())); + return; + } + const fail = () => resume(Effect.fail(new ProtocolError())); + socket.once("error", fail); + socket.once("close", fail); + socket.end(`${frame}\n`, () => resume(Effect.void)); + return Effect.sync(() => { + socket.off("error", fail); + socket.off("close", fail); + }); + }).pipe( + Effect.timeoutOrElse({ + duration: SOCKET_IDLE_MS, + orElse: () => Effect.fail(new ProtocolError()), + }), + );