From 124d6700c00fe64d5f99e5aca4bce01fb692e858 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 14:58:42 +0000 Subject: [PATCH 1/5] test(server): specify durable managed Codex token renewal --- .../src/provider/CodexChatGptAuth.test.ts | 263 +++++++++++++++++- 1 file changed, 262 insertions(+), 1 deletion(-) diff --git a/apps/server/src/provider/CodexChatGptAuth.test.ts b/apps/server/src/provider/CodexChatGptAuth.test.ts index 7bcb7413a1578..18bc2eb4d10e3 100644 --- a/apps/server/src/provider/CodexChatGptAuth.test.ts +++ b/apps/server/src/provider/CodexChatGptAuth.test.ts @@ -1,4 +1,11 @@ // @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 Exit from "effect/Exit"; +import * as FileSystem from "effect/FileSystem"; +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 +18,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 +327,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 +1621,247 @@ 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 fs = yield* FileSystem.FileSystem; + const oauthEntered = yield* Deferred.make(); + const oauthRelease = yield* Deferred.make(); + const commitEntered = yield* Deferred.make(); + const commitRelease = yield* Deferred.make(); + let pauseOAuth = false; + let pauseCommit = 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", + }), + ); + }), + ); + const fileSystem = FileSystem.FileSystem.of({ + ...fs, + rename: (from, to) => + Effect.gen(function* () { + if (pauseCommit && from.endsWith(".tmp") && to.includes("provider-auth-")) { + const pending = yield* fs.readFileString(from); + if (pending.includes("rotated-refresh")) { + yield* Deferred.succeed(commitEntered, undefined); + yield* Deferred.await(commitRelease); + } + } + yield* fs.rename(from, to); + }), + }); + 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).pipe( + Effect.andThen(Deferred.succeed(commitRelease, undefined)), + ), + ); + return { + auth, + store, + broker, + scope, + endpoint, + refreshTokens, + request: { version: 1, instanceId, environmentId, profileKey }, + oauthEntered, + oauthRelease, + commitEntered, + commitRelease, + pause: (stage: "oauth" | "commit") => { + pauseOAuth = stage === "oauth"; + pauseCommit = stage === "commit"; + }, + }; + }).pipe( + Effect.provide(ServerSecretStore.layer), + Effect.provideService(FileSystem.FileSystem, fileSystem), + 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), + ), + ), + ); + +it.live.each(["oauth-disconnect", "commit-disconnect", "commit-shutdown"] as const)( + "server-owned renewal persists rotated credentials after %s", + (stage) => + provideBroker( + Effect.gen(function* () { + const h = yield* makeRenewalBroker; + h.pause(stage === "oauth-disconnect" ? "oauth" : "commit"); + const client = yield* brokerClient(h.endpoint, h.request); + yield* Deferred.await(stage === "oauth-disconnect" ? h.oauthEntered : h.commitEntered); + const closing = + stage === "commit-shutdown" + ? yield* Scope.close(h.scope, Exit.void).pipe(Effect.forkChild) + : undefined; + if (!closing) 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* Deferred.succeed(h.commitRelease, undefined); + if (closing) yield* Fiber.join(closing); + else yield* h.broker.awaitIdle; + const persisted = Option.getOrThrow(yield* h.auth.read); + assert.equal(persisted.refreshToken, "rotated-refresh"); + assert.equal(persisted.accessToken, "renewed-access"); + assert.equal((yield* h.auth.access).accessToken, "renewed-access"); + assert.deepEqual(h.refreshTokens, ["single-use-refresh"]); + const fs = yield* FileSystem.FileSystem; + const config = yield* ServerConfig.ServerConfig; + assert.deepEqual( + (yield* fs.readDirectory(config.secretsDir)).filter( + (name) => name.endsWith(".tmp") || name.endsWith(".lock"), + ), + [], + ); + }), + ), +); + +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"]); + }), + ), +); From bf485094685e6f8c8d87a4d9464e455fbe12f859 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 15:12:20 +0000 Subject: [PATCH 2/5] fix(server): broker managed Codex tokens in the server scope --- apps/server/src/provider/CodexChatGptAuth.ts | 19 ++ .../src/provider/CodexManagedTokenBroker.ts | 211 ++++++++++++++++++ .../src/provider/CodexManagedTokenProtocol.ts | 72 ++++++ 3 files changed, 302 insertions(+) create mode 100644 apps/server/src/provider/CodexManagedTokenBroker.ts create mode 100644 apps/server/src/provider/CodexManagedTokenProtocol.ts 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..2d6d6706f6d08 --- /dev/null +++ b/apps/server/src/provider/CodexManagedTokenBroker.ts @@ -0,0 +1,211 @@ +// @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 * 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; + const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Protocol.Request), { + 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, + }); + const credentials = yield* auth.access; + 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..9f7686b73aaeb --- /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 { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +export const Request = Schema.Struct({ + version: Schema.Literal(1), + instanceId: ProviderInstanceId, + environmentId: EnvironmentId, + profileKey: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u)), +}); +export const Response = Schema.Struct({ token: Schema.NonEmptyString }); +// A request contains only a slug, UUID and SHA-256 binding. 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; +export class ProtocolError extends Schema.TaggedError()( + "ManagedTokenProtocolError", + {}, +) {} + +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()), + }), + ); From 24c01b2cc6441aaeb6e7c001d4893317b7e67544 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 15:39:50 +0000 Subject: [PATCH 3/5] perf(server): keep managed token helper imports lean --- .../src/provider/CodexManagedTokenBroker.ts | 17 ++++++++++++++--- .../src/provider/CodexManagedTokenProtocol.ts | 9 ++++----- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/apps/server/src/provider/CodexManagedTokenBroker.ts b/apps/server/src/provider/CodexManagedTokenBroker.ts index 2d6d6706f6d08..01ef51b6b1d07 100644 --- a/apps/server/src/provider/CodexManagedTokenBroker.ts +++ b/apps/server/src/provider/CodexManagedTokenBroker.ts @@ -4,6 +4,7 @@ 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"; @@ -112,9 +113,19 @@ const acquireListener = Effect.gen(function* () { const sockets = new Set(); let closing = false; let admitted = 0; - const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Protocol.Request), { - onExcessProperty: "error", - }); + // 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) { diff --git a/apps/server/src/provider/CodexManagedTokenProtocol.ts b/apps/server/src/provider/CodexManagedTokenProtocol.ts index 9f7686b73aaeb..924c32df81808 100644 --- a/apps/server/src/provider/CodexManagedTokenProtocol.ts +++ b/apps/server/src/provider/CodexManagedTokenProtocol.ts @@ -1,18 +1,17 @@ // @effect-diagnostics nodeBuiltinImport:off - Private local IPC framing, shared by server and lean CLI. import type * as NodeNet from "node:net"; -import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; export const Request = Schema.Struct({ version: Schema.Literal(1), - instanceId: ProviderInstanceId, - environmentId: EnvironmentId, + 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 }); -// A request contains only a slug, UUID and SHA-256 binding. Tokens can be larger -// JWTs. Never truncate either frame into something that could be accepted. +// 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. From 405f90bf46e4f7f04dca74ecfead503454f8a92d Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 16:16:48 +0000 Subject: [PATCH 4/5] fix(server): keep unused managed token declarations private --- apps/server/src/provider/CodexManagedTokenProtocol.ts | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/apps/server/src/provider/CodexManagedTokenProtocol.ts b/apps/server/src/provider/CodexManagedTokenProtocol.ts index 924c32df81808..bb51eeaf1cc3a 100644 --- a/apps/server/src/provider/CodexManagedTokenProtocol.ts +++ b/apps/server/src/provider/CodexManagedTokenProtocol.ts @@ -16,12 +16,11 @@ 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; -export class ProtocolError extends Schema.TaggedError()( - "ManagedTokenProtocolError", - {}, -) {} +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) => { From 5ba449432854a849627bf617a55540714154be05 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 16:34:23 +0000 Subject: [PATCH 5/5] fix(server): retire abandoned managed token permit waits --- .../src/provider/CodexChatGptAuth.test.ts | 90 +++++-------------- .../src/provider/CodexManagedTokenBroker.ts | 5 +- .../src/provider/CodexManagedTokenProtocol.ts | 2 + 3 files changed, 29 insertions(+), 68 deletions(-) diff --git a/apps/server/src/provider/CodexChatGptAuth.test.ts b/apps/server/src/provider/CodexChatGptAuth.test.ts index 18bc2eb4d10e3..3e521103d56cf 100644 --- a/apps/server/src/provider/CodexChatGptAuth.test.ts +++ b/apps/server/src/provider/CodexChatGptAuth.test.ts @@ -1,8 +1,6 @@ // @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 Exit from "effect/Exit"; -import * as FileSystem from "effect/FileSystem"; import * as Scope from "effect/Scope"; import * as ServerConfig from "../config.ts"; import * as CodexManagedTokenBroker from "./CodexManagedTokenBroker.ts"; @@ -1656,13 +1654,9 @@ it.effect("a running session renews its bound profile but refuses a replacement ); const makeRenewalBroker = Effect.gen(function* () { - const fs = yield* FileSystem.FileSystem; const oauthEntered = yield* Deferred.make(); const oauthRelease = yield* Deferred.make(); - const commitEntered = yield* Deferred.make(); - const commitRelease = yield* Deferred.make(); let pauseOAuth = false; - let pauseCommit = false; const refreshTokens: string[] = []; const credentials = { clientId: "oaiapp_broker", @@ -1708,20 +1702,6 @@ const makeRenewalBroker = Effect.gen(function* () { ); }), ); - const fileSystem = FileSystem.FileSystem.of({ - ...fs, - rename: (from, to) => - Effect.gen(function* () { - if (pauseCommit && from.endsWith(".tmp") && to.includes("provider-auth-")) { - const pending = yield* fs.readFileString(from); - if (pending.includes("rotated-refresh")) { - yield* Deferred.succeed(commitEntered, undefined); - yield* Deferred.await(commitRelease); - } - } - yield* fs.rename(from, to); - }), - }); return yield* Effect.gen(function* () { const store = yield* ProviderCredentialStore.make("codex-chatgpt", instanceId); yield* store.set(new TextEncoder().encode(JSON.stringify(credentials))); @@ -1732,31 +1712,22 @@ const makeRenewalBroker = Effect.gen(function* () { 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).pipe( - Effect.andThen(Deferred.succeed(commitRelease, undefined)), - ), - ); + yield* Effect.addFinalizer(() => Deferred.succeed(oauthRelease, undefined)); return { auth, store, broker, - scope, endpoint, refreshTokens, request: { version: 1, instanceId, environmentId, profileKey }, oauthEntered, oauthRelease, - commitEntered, - commitRelease, - pause: (stage: "oauth" | "commit") => { - pauseOAuth = stage === "oauth"; - pauseCommit = stage === "commit"; + pause: () => { + pauseOAuth = true; }, }; }).pipe( Effect.provide(ServerSecretStore.layer), - Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(HttpClient.HttpClient, http), Effect.provideService(ServerEnvironment.ServerEnvironmentIdentity, { getEnvironmentId: Effect.succeed(environmentId), @@ -1796,41 +1767,26 @@ const provideBroker = (effect: Effect.Effect) => ), ); -it.live.each(["oauth-disconnect", "commit-disconnect", "commit-shutdown"] as const)( - "server-owned renewal persists rotated credentials after %s", - (stage) => - provideBroker( - Effect.gen(function* () { - const h = yield* makeRenewalBroker; - h.pause(stage === "oauth-disconnect" ? "oauth" : "commit"); - const client = yield* brokerClient(h.endpoint, h.request); - yield* Deferred.await(stage === "oauth-disconnect" ? h.oauthEntered : h.commitEntered); - const closing = - stage === "commit-shutdown" - ? yield* Scope.close(h.scope, Exit.void).pipe(Effect.forkChild) - : undefined; - if (!closing) 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* Deferred.succeed(h.commitRelease, undefined); - if (closing) yield* Fiber.join(closing); - else yield* h.broker.awaitIdle; - const persisted = Option.getOrThrow(yield* h.auth.read); - assert.equal(persisted.refreshToken, "rotated-refresh"); - assert.equal(persisted.accessToken, "renewed-access"); - assert.equal((yield* h.auth.access).accessToken, "renewed-access"); - assert.deepEqual(h.refreshTokens, ["single-use-refresh"]); - const fs = yield* FileSystem.FileSystem; - const config = yield* ServerConfig.ServerConfig; - assert.deepEqual( - (yield* fs.readDirectory(config.secretsDir)).filter( - (name) => name.endsWith(".tmp") || name.endsWith(".lock"), - ), - [], - ); - }), - ), +// 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", () => diff --git a/apps/server/src/provider/CodexManagedTokenBroker.ts b/apps/server/src/provider/CodexManagedTokenBroker.ts index 01ef51b6b1d07..4a1e861827142 100644 --- a/apps/server/src/provider/CodexManagedTokenBroker.ts +++ b/apps/server/src/provider/CodexManagedTokenBroker.ts @@ -153,7 +153,10 @@ const acquireListener = Effect.gen(function* () { instanceId: request.instanceId, expectedProfileKey: request.profileKey, }); - const credentials = yield* auth.access; + // 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 }), diff --git a/apps/server/src/provider/CodexManagedTokenProtocol.ts b/apps/server/src/provider/CodexManagedTokenProtocol.ts index bb51eeaf1cc3a..d5f9e610d2188 100644 --- a/apps/server/src/provider/CodexManagedTokenProtocol.ts +++ b/apps/server/src/provider/CodexManagedTokenProtocol.ts @@ -16,6 +16,8 @@ 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.";