Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): prefer Codex app-server for ChatGPT credentials (#3132)

vercel-gh-bot-3[bot]da8f4fdba6d3
diff --git a/.changeset/calm-wolves-share.md b/.changeset/calm-wolves-share.md
new file mode 100644
index 000000000..7b18e7c93
--- /dev/null
+++ b/.changeset/calm-wolves-share.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Use an installed Codex CLI's app-server for ChatGPT subscription credentials, while retaining eve's direct sign-in and owned credential store as a fallback only when the `codex` binary is not found. Codex login output remains inside the model setup panel instead of writing directly over the TUI.
diff --git a/docs/reference/typescript-api.md b/docs/reference/typescript-api.md
index 303a0db07..f0fbe0ba0 100644
--- a/docs/reference/typescript-api.md
+++ b/docs/reference/typescript-api.md
@@ -186,26 +186,29 @@ Pass another bare OpenAI model slug to override the default. `experimental_chatg
`chatgpt()` uses stateless requests (`store: false`). eve retains reasoning summaries and encrypted reasoning in session history and replays them after tool calls and on later turns. You do not need to configure `reasoning.encrypted_content` explicitly.
-Sign in directly from eve; the Codex CLI is not required:
+eve uses one local authentication path with two credential owners:
1. Run `eve dev`, open `/model`, and select **Provider** → **ChatGPT subscription**.
-2. Complete sign-in in the browser. If the browser does not open, use the URL printed in the terminal.
-3. Return to eve after the terminal confirms that your subscription is connected. Normal token expiry is refreshed automatically.
+2. If `codex` is on `PATH`, eve uses `codex app-server` and launches `codex login` when sign-in is needed. Codex owns credential storage and refresh.
+3. If the Codex binary is not found, eve falls back to direct browser sign-in and owns the saved session and refresh. If the browser does not open, use the URL printed in the terminal.
-eve stores your refresh token and account details in your operating system's credential store through [just-secrets](https://github.com/vercel-labs/just-secrets): the login Keychain on macOS, Credential Manager on Windows, or Secret Service on Linux. Access tokens stay in process memory; a new eve process refreshes the saved session when it first needs a token. The login is separate from Codex and is never written to your project.
+When Codex is available, eve asks app-server for tokens and does not read or write Codex login files. App-server errors other than a missing binary are reported instead of silently switching credential owners.
-If you previously signed in through Codex or used eve's `~/.eve/auth/chatgpt.json` file, sign in once through eve after upgrading. eve removes the old plaintext file after successfully saving the new session. It does not fall back to file storage if the OS credential store is unavailable.
+For the eve-owned fallback, eve stores your refresh token and account details in your operating system's credential store through [just-secrets](https://github.com/vercel-labs/just-secrets): the login Keychain on macOS, Credential Manager on Windows, or Secret Service on Linux. Access tokens stay in process memory; a new eve process refreshes the saved session when it first needs a token. The fallback login is separate from Codex and is never written to your project.
+
+If you previously used eve's `~/.eve/auth/chatgpt.json` file, sign in once through the eve-owned fallback after upgrading. A successful save removes the old plaintext session file. eve does not fall back to file storage if the OS credential store is unavailable.
Linux, including WSL, requires `/usr/bin/secret-tool` (commonly provided by `libsecret-tools`), a session D-Bus, and an unlocked Secret Service keyring. On macOS, unlock your login keychain and allow credential access if prompted. On Windows, PowerShell and Credential Manager must be available in your user session. OS credential storage protects secrets at rest; it does not guarantee isolation from malicious processes running as your OS user.
-Over SSH, or if localhost port 1455 is occupied, eve shows a device code instead. Open the displayed link in a browser and enter the code. Device sign-in requires enabling device code authorization in **ChatGPT Settings → Security**, or having a workspace admin enable it in workspace permissions. Sign-in times out after five minutes; press **Ctrl+C** to cancel sooner. Device sign-in still requires an available OS credential store; use an API-key model in headless environments without one.
+For the eve-owned fallback, SSH sessions or a busy localhost port 1455 use a device code. Open the displayed link in a browser and enter the code. Device sign-in requires enabling device code authorization in **ChatGPT Settings → Security**, or having a workspace admin enable it in workspace permissions. Sign-in times out after five minutes; press **Ctrl+C** to cancel sooner. Device sign-in still requires an available OS credential store; use an API-key model in headless environments without one.
ChatGPT subscription credentials are local user credentials. `eve deploy` blocks agents whose active model is `chatgpt()` because those credentials are not uploaded to a deployment. Use an environment branch with a deployable model, or switch to an AI Gateway model before deploying.
Troubleshooting:
-- **`chatgpt-sub login`**: open `/model` and select **Provider** → **ChatGPT subscription** to sign in again. The running dev session picks up the new login.
-- **`chatgpt-sub unavailable`**: follow the reported OS credential-store recovery steps, or check your network connection if token refresh failed. Retry from `/model`. If eve reports an invalid stored session, sign in again to replace it.
+- **`chatgpt-sub login`**: open `/model` and select **Provider** → **ChatGPT subscription** to sign in again. eve launches `codex login` when Codex is available, or its direct sign-in flow when it is not.
+- **`chatgpt-sub unavailable` with Codex installed**: update or restart Codex and retry. eve does not mask app-server failures by switching to a different saved session.
+- **`chatgpt-sub unavailable` without Codex**: follow the reported OS credential-store recovery steps, or check your network connection if token refresh failed. Retry from `/model`. If eve reports an invalid stored session, sign in again to replace it.
- **Model rejected by the backend**: model availability depends on the signed-in ChatGPT account. Pick another supported OpenAI model.
- **Device sign-in unavailable**: enable device code authorization in ChatGPT security settings, or sign in from a local terminal with port 1455 available.
diff --git a/packages/eve/src/public/models/openai/chatgpt/codex-app-server.test.ts b/packages/eve/src/public/models/openai/chatgpt/codex-app-server.test.ts
new file mode 100644
index 000000000..420a46f96
--- /dev/null
+++ b/packages/eve/src/public/models/openai/chatgpt/codex-app-server.test.ts
@@ -0,0 +1,172 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { ChatGptSignInRequiredError } from "./oauth.js";
+import { ChatGptSignedOutError } from "./token.js";
+import {
+ CodexAppServerClient,
+ CodexBinaryNotFoundError,
+ type CodexAppServerProcess,
+ type CodexAuthStatus,
+} from "./codex-app-server.js";
+
+const NOW = 1_800_000_000_000;
+
+function jwt(claims: Record<string, unknown>): string {
+ return `${Buffer.from("{}").toString("base64url")}.${Buffer.from(JSON.stringify(claims)).toString("base64url")}.signature`;
+}
+
+describe("Codex app-server client", () => {
+ it("initializes once and resolves an app-server token", async () => {
+ const token = jwt({
+ exp: NOW / 1000 + 3600,
+ chatgpt_account_id: "acct-1",
+ email: "[email protected]",
+ });
+ const child = new FakeChild({
+ statuses: [{ authMethod: "chatgpt", authToken: token, requiresOpenaiAuth: true }],
+ });
+ const spawnProcess = vi.fn(() => child.asChildProcess());
+ const client = new CodexAppServerClient({ spawnProcess });
+
+ await expect(client.resolveToken({ forceRefresh: true, now: () => NOW })).resolves.toEqual({
+ token,
+ expiresAt: NOW + 3600_000,
+ accountId: "acct-1",
+ accountLabel: "[email protected]",
+ });
+ expect(spawnProcess).toHaveBeenCalledWith("codex", ["app-server", "--stdio"], {
+ env: undefined,
+ stdio: ["pipe", "pipe", "pipe"],
+ });
+ expect(child.requests.map((request) => request.method)).toEqual([
+ "initialize",
+ "initialized",
+ "getAuthStatus",
+ ]);
+ expect(child.requests[2]?.params).toEqual({ includeToken: true, refreshToken: true });
+ });
+
+ it("refreshes an app-server token within five minutes of expiry", async () => {
+ const expiring = jwt({ exp: NOW / 1000 + 60 });
+ const refreshed = jwt({ exp: NOW / 1000 + 3600 });
+ const child = new FakeChild({
+ statuses: [
+ { authMethod: "chatgpt", authToken: expiring },
+ { authMethod: "chatgpt", authToken: refreshed },
+ ],
+ });
+ const client = new CodexAppServerClient({
+ spawnProcess: vi.fn(() => child.asChildProcess()),
+ });
+
+ await expect(
+ client.resolveToken({ forceRefresh: false, now: () => NOW }),
+ ).resolves.toMatchObject({ token: refreshed, expiresAt: NOW + 3600_000 });
+ expect(child.requests.filter((request) => request.method === "getAuthStatus")).toEqual([
+ expect.objectContaining({ params: { includeToken: true, refreshToken: false } }),
+ expect.objectContaining({ params: { includeToken: true, refreshToken: true } }),
+ ]);
+ });
+
+ it("distinguishes signed-out and rejected-token states", async () => {
+ const ordinary = new CodexAppServerClient({
+ spawnProcess: vi.fn(() => new FakeChild().asChildProcess()),
+ });
+ await expect(
+ ordinary.resolveToken({ forceRefresh: false, now: () => NOW }),
+ ).rejects.toBeInstanceOf(ChatGptSignedOutError);
+
+ const rejected = new CodexAppServerClient({
+ spawnProcess: vi.fn(() => new FakeChild().asChildProcess()),
+ });
+ await expect(
+ rejected.resolveToken({ forceRefresh: true, now: () => NOW }),
+ ).rejects.toBeInstanceOf(ChatGptSignInRequiredError);
+ });
+
+ it("marks only a missing Codex binary as eligible for fallback", async () => {
+ const child = new FakeChild({
+ failWith: Object.assign(new Error("spawn codex ENOENT"), { code: "ENOENT" }),
+ });
+ const client = new CodexAppServerClient({
+ spawnProcess: vi.fn(() => child.asChildProcess()),
+ });
+
+ await expect(
+ client.resolveToken({ forceRefresh: false, now: () => NOW }),
+ ).rejects.toBeInstanceOf(CodexBinaryNotFoundError);
+ });
+
+ it("preserves other app-server failures as hard errors", async () => {
+ const child = new FakeChild({ failWith: new Error("permission denied") });
+ const client = new CodexAppServerClient({
+ spawnProcess: vi.fn(() => child.asChildProcess()),
+ });
+
+ const result = client.resolveToken({ forceRefresh: false, now: () => NOW });
+ await expect(result).rejects.toThrow("Codex app-server is unavailable: permission denied");
+ await expect(result).rejects.not.toBeInstanceOf(CodexBinaryNotFoundError);
+ });
+});
+
+interface RpcRequest {
+ readonly id?: number;
+ readonly method: string;
+ readonly params?: unknown;
+}
+
+class FakeChild extends EventEmitter {
+ readonly stdin = new PassThrough();
+ readonly stdout = new PassThrough();
+ readonly stderr = new PassThrough();
+ readonly requests: RpcRequest[] = [];
+ readonly #failWith?: Error;
+ readonly #statuses: CodexAuthStatus[];
+ #input = "";
+
+ constructor(
+ options: {
+ readonly failWith?: Error;
+ readonly statuses?: readonly CodexAuthStatus[];
+ } = {},
+ ) {
+ super();
+ this.#failWith = options.failWith;
+ this.#statuses = [...(options.statuses ?? [])];
+ this.stdin.on("data", (chunk: Buffer) => this.#receive(chunk.toString()));
+ queueMicrotask(() => {
+ if (this.#failWith !== undefined) this.emit("error", this.#failWith);
+ });
+ }
+
+ asChildProcess(): CodexAppServerProcess {
+ return this;
+ }
+
+ kill(): boolean {
+ return true;
+ }
+
+ unref(): void {}
+
+ #receive(chunk: string): void {
+ this.#input += chunk;
+ while (true) {
+ const newline = this.#input.indexOf("\n");
+ if (newline < 0) return;
+ const line = this.#input.slice(0, newline);
+ this.#input = this.#input.slice(newline + 1);
+ const request = JSON.parse(line) as RpcRequest;
+ this.requests.push(request);
+ if (request.id === undefined) continue;
+ const result =
+ request.method === "initialize"
+ ? { codexHome: "/tmp/codex" }
+ : (this.#statuses.shift() ?? { authMethod: "chatgpt" });
+ this.stdout.write(`${JSON.stringify({ id: request.id, result })}\n`);
+ }
+ }
+}
diff --git a/packages/eve/src/public/models/openai/chatgpt/codex-app-server.ts b/packages/eve/src/public/models/openai/chatgpt/codex-app-server.ts
new file mode 100644
index 000000000..01644e6ab
--- /dev/null
+++ b/packages/eve/src/public/models/openai/chatgpt/codex-app-server.ts
@@ -0,0 +1,305 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { createInterface, type Interface } from "node:readline";
+
+import { resolveInstalledPackageInfo } from "#internal/application/package.js";
+import { isErrnoCode, isObject } from "#shared/guards.js";
+import {
+ extractCodexAccountIdFromToken,
+ extractCodexAccountLabelFromToken,
+ readCodexJwtExpirationMs,
+} from "./auth.js";
+import { ChatGptSignInRequiredError } from "./oauth.js";
+import {
+ ChatGptSignedOutError,
+ isChatGptTokenFresh,
+ type ChatGptToken,
+ type ChatGptTokenResolutionInput,
+} from "./token.js";
+
+interface RpcError {
+ readonly code?: number;
+ readonly message?: string;
+}
+
+interface RpcResponse {
+ readonly error?: RpcError;
+ readonly id?: number;
+ readonly result?: unknown;
+}
+
+export interface CodexAuthStatus {
+ readonly authMethod?: string;
+ readonly authToken?: string;
+ readonly requiresOpenaiAuth?: boolean;
+}
+
+export interface CodexAppServer {
+ resolveToken(input: ChatGptTokenResolutionInput): Promise<ChatGptToken>;
+ restart?(): void;
+}
+
+export interface CodexAppServerProcess {
+ readonly stderr: ChildProcessWithoutNullStreams["stderr"];
+ readonly stdin: ChildProcessWithoutNullStreams["stdin"];
+ readonly stdout: ChildProcessWithoutNullStreams["stdout"];
+ kill(): boolean;
+ once(event: "error", listener: (error: Error) => void): this;
+ once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+ unref(): void;
+}
+
+type SpawnCodexAppServer = (
+ command: string,
+ args: readonly string[],
+ options: {
+ readonly env?: NodeJS.ProcessEnv;
+ stdio: ["pipe", "pipe", "pipe"];
+ },
+) => CodexAppServerProcess;
+
+export interface CodexAppServerOptions {
+ readonly command?: string;
+ readonly env?: NodeJS.ProcessEnv;
+ readonly spawnProcess?: SpawnCodexAppServer;
+}
+
+/** Raised only when the `codex` executable cannot be found. */
+export class CodexBinaryNotFoundError extends Error {
+ constructor(cause?: unknown) {
+ super("The `codex` CLI was not found.", { cause });
+ this.name = "CodexBinaryNotFoundError";
+ }
+}
+
+/** Minimal authenticated subset of Codex's JSONL app-server protocol. */
+export class CodexAppServerClient implements CodexAppServer {
+ readonly #command: string;
+ readonly #env: NodeJS.ProcessEnv | undefined;
+ readonly #spawnProcess: SpawnCodexAppServer;
+ #connection: Promise<CodexAppServerConnection> | undefined;
+
+ constructor(options: CodexAppServerOptions = {}) {
+ this.#command = options.command ?? "codex";
+ this.#env = options.env;
+ this.#spawnProcess = options.spawnProcess ?? spawnCodexAppServer;
+ }
+
+ async resolveToken(input: ChatGptTokenResolutionInput): Promise<ChatGptToken> {
+ let status = await this.#getAuthStatus(input.forceRefresh);
+ if (status.authMethod !== "chatgpt" || status.authToken === undefined) {
+ throw input.forceRefresh
+ ? new ChatGptSignInRequiredError()
+ : new ChatGptSignedOutError(
+ "ChatGPT subscription is not signed in to Codex. Run `codex login` or sign in from /model.",
+ );
+ }
+ let token = tokenFromCodex(status.authToken);
+ if (!input.forceRefresh && !isChatGptTokenFresh(token, input.now())) {
+ status = await this.#getAuthStatus(true);
+ if (status.authMethod !== "chatgpt" || status.authToken === undefined) {
+ throw new ChatGptSignInRequiredError();
+ }
+ token = tokenFromCodex(status.authToken);
+ }
+ return token;
+ }
+
+ async #getAuthStatus(refreshToken: boolean): Promise<CodexAuthStatus> {
+ const connection = await this.#connect();
+ try {
+ return await connection.getAuthStatus({ refreshToken });
+ } catch (error) {
+ if (connection.exited) this.#connection = undefined;
+ throw error;
+ }
+ }
+
+ restart(): void {
+ const connection = this.#connection;
+ this.#connection = undefined;
+ void connection?.then((value) => value.close()).catch(() => undefined);
+ }
+
+ #connect(): Promise<CodexAppServerConnection> {
+ if (this.#connection === undefined) {
+ this.#connection = CodexAppServerConnection.start({
+ command: this.#command,
+ env: this.#env,
+ spawnProcess: this.#spawnProcess,
+ }).catch((error: unknown) => {
+ this.#connection = undefined;
+ throw error;
+ });
+ }
+ return this.#connection;
+ }
+}
+
+class CodexAppServerConnection {
+ readonly #child: CodexAppServerProcess;
+ readonly #lines: Interface;
+ readonly #pending = new Map<
+ number,
+ { readonly reject: (error: Error) => void; readonly resolve: (value: unknown) => void }
+ >();
+ #nextId = 1;
+ #exited = false;
+ #failure: Error | undefined;
+
+ private constructor(child: CodexAppServerProcess) {
+ this.#child = child;
+ child.unref();
+ unrefStream(child.stdin);
+ unrefStream(child.stdout);
+ unrefStream(child.stderr);
+ child.stderr.resume();
+ this.#lines = createInterface({ input: child.stdout });
+ this.#lines.on("line", (line) => this.#handleLine(line));
+ child.once("error", (error) => this.#fail(error));
+ child.once("exit", (code, signal) => {
+ const suffix = signal === null ? `code ${code ?? "unknown"}` : `signal ${signal}`;
+ this.#fail(new Error(`Codex app-server exited with ${suffix}.`));
+ });
+ }
+
+ get exited(): boolean {
+ return this.#exited;
+ }
+
+ close(): void {
+ this.#child.kill();
+ this.#fail(new Error("Codex app-server connection was restarted."));
+ }
+
+ static async start(input: {
+ readonly command: string;
+ readonly env?: NodeJS.ProcessEnv;
+ readonly spawnProcess: SpawnCodexAppServer;
+ }): Promise<CodexAppServerConnection> {
+ let child: CodexAppServerProcess;
+ try {
+ child = input.spawnProcess(input.command, ["app-server", "--stdio"], {
+ env: input.env,
+ stdio: ["pipe", "pipe", "pipe"],
+ });
+ } catch (error) {
+ throw appServerError(error);
+ }
+
+ const connection = new CodexAppServerConnection(child);
+ try {
+ await connection.#request("initialize", {
+ capabilities: null,
+ clientInfo: {
+ name: "eve",
+ title: "eve",
+ version: resolveInstalledPackageInfo().version,
+ },
+ });
+ connection.#notify("initialized", {});
+ return connection;
+ } catch (error) {
+ child.kill();
+ throw error;
+ }
+ }
+
+ async getAuthStatus(input: { readonly refreshToken: boolean }): Promise<CodexAuthStatus> {
+ const value = await this.#request("getAuthStatus", {
+ includeToken: true,
+ refreshToken: input.refreshToken,
+ });
+ if (!isObject(value)) {
+ throw new Error("Codex app-server returned an invalid authentication response.");
+ }
+ return {
+ ...(typeof value.authMethod === "string" && { authMethod: value.authMethod }),
+ ...(typeof value.authToken === "string" && { authToken: value.authToken }),
+ ...(typeof value.requiresOpenaiAuth === "boolean" && {
+ requiresOpenaiAuth: value.requiresOpenaiAuth,
+ }),
+ };
+ }
+
+ #request(method: string, params: unknown): Promise<unknown> {
+ if (this.#exited) {
+ return Promise.reject(this.#failure ?? new Error("Codex app-server is not running."));
+ }
+ const id = this.#nextId++;
+ const response = new Promise<unknown>((resolve, reject) => {
+ this.#pending.set(id, { reject, resolve });
+ });
+ this.#write({ id, method, params });
+ return response;
+ }
+
+ #notify(method: string, params: unknown): void {
+ this.#write({ method, params });
+ }
+
+ #write(value: unknown): void {
+ this.#child.stdin.write(`${JSON.stringify(value)}\n`);
+ }
+
+ #handleLine(line: string): void {
+ let value: RpcResponse;
+ try {
+ value = JSON.parse(line) as RpcResponse;
+ } catch {
+ return;
+ }
+ if (typeof value.id !== "number") return;
+ const pending = this.#pending.get(value.id);
+ if (pending === undefined) return;
+ this.#pending.delete(value.id);
+ if (value.error !== undefined) {
+ pending.reject(
+ new Error(value.error.message ?? `Codex app-server request failed (${value.error.code}).`),
+ );
+ return;
+ }
+ pending.resolve(value.result);
+ }
+
+ #fail(error: Error): void {
+ if (this.#exited) return;
+ this.#exited = true;
+ this.#failure = appServerError(error);
+ this.#lines.close();
+ for (const pending of this.#pending.values()) pending.reject(this.#failure);
+ this.#pending.clear();
+ }
+}
+
+function spawnCodexAppServer(
+ command: string,
+ args: readonly string[],
+ options: {
+ readonly env?: NodeJS.ProcessEnv;
+ stdio: ["pipe", "pipe", "pipe"];
+ },
+): CodexAppServerProcess {
+ return spawn(command, [...args], options);
+}
+
+function unrefStream(stream: NodeJS.ReadableStream | NodeJS.WritableStream): void {
+ if ("unref" in stream && typeof stream.unref === "function") stream.unref();
+}
+
+function tokenFromCodex(token: string): ChatGptToken {
+ const accountId = extractCodexAccountIdFromToken(token);
+ const accountLabel = extractCodexAccountLabelFromToken(token);
+ const expiresAt = readCodexJwtExpirationMs(token);
+ return {
+ token,
+ ...(accountId !== undefined && { accountId }),
+ ...(accountLabel !== undefined && { accountLabel }),
+ ...(expiresAt !== undefined && { expiresAt }),
+ };
+}
+
+function appServerError(error: unknown): Error {
+ if (isErrnoCode(error, "ENOENT")) return new CodexBinaryNotFoundError(error);
+ const message = error instanceof Error ? error.message : String(error);
+ return new Error(`Codex app-server is unavailable: ${message}`, { cause: error });
+}
diff --git a/packages/eve/src/public/models/openai/chatgpt/credential-store.scenario.test.ts b/packages/eve/src/public/models/openai/chatgpt/credential-store.scenario.test.ts
index 80ac59b60..d94ba6943 100644
--- a/packages/eve/src/public/models/openai/chatgpt/credential-store.scenario.test.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/credential-store.scenario.test.ts
@@ -8,6 +8,8 @@ import {
ChatGptInvalidStoredSessionError,
createChatGptCredentialStore,
} from "./credential-store.js";
+import { ChatGptSignInRequiredError } from "./oauth.js";
+import { ChatGptSignedOutError } from "./token.js";
const roots: string[] = [];
afterEach(async () => {
@@ -291,4 +293,129 @@ describe("ChatGPT credential storage", () => {
await expect(follower.promise).resolves.toBe(credentials.refreshToken);
expect(JSON.parse(native.current()!).refreshToken).toBe("refresh-rotated");
});
+
+ it("resolves a cold-start refresh session and caches its access token", async () => {
+ const path = await credentialPath();
+ const native = memorySecrets(JSON.stringify({ sessionId: "session-1", ...refreshCredentials }));
+ const store = createChatGptCredentialStore(path, native);
+ const fetch = vi.fn<typeof globalThis.fetch>(async () =>
+ Response.json({ access_token: "new-access", refresh_token: "new-refresh", expires_in: 3600 }),
+ );
+
+ await expect(
+ store.resolveToken({ forceRefresh: false, fetch, now: () => 1_800_000_000_000 }),
+ ).resolves.toMatchObject({
+ token: "new-access",
+ accountId: credentials.accountId,
+ accountLabel: credentials.accountLabel,
+ });
+ await expect(
+ store.resolveToken({ forceRefresh: false, fetch, now: () => 1_800_000_000_000 }),
+ ).resolves.toMatchObject({ token: "new-access" });
+ expect(fetch).toHaveBeenCalledOnce();
+ expect(JSON.parse(native.current()!)).toMatchObject({ refreshToken: "new-refresh" });
+ expect(native.current()).not.toContain("new-access");
+ });
+
+ it("refreshes an expiring owned token inside the credential lock", async () => {
+ const path = await credentialPath();
+ const native = memorySecrets();
+ const store = createChatGptCredentialStore(path, native);
+ await store.update(async () => ({ ...credentials, expiresAt: 1_800_000_100_000 }));
+ const fetch = vi.fn<typeof globalThis.fetch>(async () =>
+ Response.json({ access_token: "new-access", refresh_token: "new-refresh", expires_in: 3600 }),
+ );
+
+ await expect(
+ store.resolveToken({ forceRefresh: false, fetch, now: () => 1_800_000_000_000 }),
+ ).resolves.toMatchObject({ token: "new-access" });
+ expect(fetch).toHaveBeenCalledOnce();
+ expect(JSON.parse(native.current()!).refreshToken).toBe("new-refresh");
+ });
+
+ it("uses the latest refresh token after waiting for the credential lock", async () => {
+ const path = await credentialPath();
+ const native = memorySecrets();
+ const first = createChatGptCredentialStore(path, native);
+ const second = createChatGptCredentialStore(path, native);
+ await first.update(async () => credentials);
+ const entered = Promise.withResolvers<void>();
+ const release = Promise.withResolvers<void>();
+ const rotation = first.update(async () => {
+ entered.resolve();
+ await release.promise;
+ return { ...credentials, refreshToken: "rotated-by-first" };
+ });
+ await entered.promise;
+ const fetch = vi.fn<typeof globalThis.fetch>(async () =>
+ Response.json({ access_token: "new-access", refresh_token: "new-refresh", expires_in: 3600 }),
+ );
+ const resolution = second.resolveToken({
+ forceRefresh: true,
+ fetch,
+ now: () => 1_800_000_000_000,
+ });
+
+ release.resolve();
+ await rotation;
+ await expect(resolution).resolves.toMatchObject({ token: "new-access" });
+ const body = fetch.mock.calls[0]?.[1]?.body as URLSearchParams;
+ expect(body.get("refresh_token")).toBe("rotated-by-first");
+ });
+
+ it("preserves owned credentials when refresh is revoked", async () => {
+ const path = await credentialPath();
+ const native = memorySecrets();
+ const store = createChatGptCredentialStore(path, native);
+ await store.update(async () => ({ ...credentials, expiresAt: 1 }));
+ const saved = native.current();
+
+ await expect(
+ store.resolveToken({
+ forceRefresh: true,
+ fetch: async () => new Response("secret", { status: 401 }),
+ now: Date.now,
+ }),
+ ).rejects.toBeInstanceOf(ChatGptSignInRequiredError);
+ expect(native.current()).toBe(saved);
+ });
+
+ it("preserves owned credentials across a temporary refresh failure and retry", async () => {
+ const path = await credentialPath();
+ const native = memorySecrets();
+ const store = createChatGptCredentialStore(path, native);
+ await store.update(async () => ({ ...credentials, expiresAt: 1 }));
+ const saved = native.current();
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(new Response("secret", { status: 503 }))
+ .mockResolvedValueOnce(
+ Response.json({
+ access_token: "recovered-access",
+ refresh_token: "recovered-refresh",
+ expires_in: 3600,
+ }),
+ );
+
+ await expect(store.resolveToken({ forceRefresh: false, fetch, now: Date.now })).rejects.toThrow(
+ "HTTP 503",
+ );
+ expect(native.current()).toBe(saved);
+ await expect(
+ store.resolveToken({ forceRefresh: false, fetch, now: Date.now }),
+ ).resolves.toMatchObject({ token: "recovered-access" });
+ expect(JSON.parse(native.current()!).refreshToken).toBe("recovered-refresh");
+ });
+
+ it("distinguishes missing owned credentials by request reason", async () => {
+ const path = await credentialPath();
+ const store = createChatGptCredentialStore(path, memorySecrets());
+
+ await expect(store.resolveToken({ forceRefresh: false, now: Date.now })).rejects.toBeInstanceOf(
+ ChatGptSignedOutError,
+ );
+ await expect(store.resolveToken({ forceRefresh: true, now: Date.now })).rejects.toBeInstanceOf(
+ ChatGptSignInRequiredError,
+ );
+ });
});
diff --git a/packages/eve/src/public/models/openai/chatgpt/credential-store.ts b/packages/eve/src/public/models/openai/chatgpt/credential-store.ts
index de984a904..0e5db3052 100644
--- a/packages/eve/src/public/models/openai/chatgpt/credential-store.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/credential-store.ts
@@ -6,7 +6,19 @@ import { setTimeout as delay } from "node:timers/promises";
import { secrets } from "#compiled/just-secrets/index.js";
import { isErrnoCode, isObject } from "#shared/guards.js";
-import type { ChatGptCredentials, ChatGptRefreshCredentials } from "./oauth.js";
+import {
+ CHATGPT_LOGIN_HINT,
+ ChatGptSignInRequiredError,
+ requestChatGptTokens,
+ type ChatGptCredentials,
+ type ChatGptRefreshCredentials,
+} from "./oauth.js";
+import {
+ ChatGptSignedOutError,
+ isChatGptTokenFresh,
+ type ChatGptToken,
+ type ChatGptTokenResolutionInput,
+} from "./token.js";
const SECRET_ID = { service: "eve", name: "chatgpt" };
const MAX_SECRET_BYTES = 2560;
@@ -21,6 +33,9 @@ export class ChatGptInvalidStoredSessionError extends Error {
export interface ChatGptCredentialStore {
read(): Promise<ChatGptRefreshCredentials | ChatGptCredentials | undefined>;
+ resolveToken(
+ input: ChatGptTokenResolutionInput & { readonly fetch?: typeof fetch },
+ ): Promise<ChatGptToken>;
update(
callback: (
current: ChatGptRefreshCredentials | ChatGptCredentials | undefined,
@@ -95,10 +110,46 @@ export function createChatGptCredentialStore(
return { sessionId: value.sessionId, credentials };
}
- return {
+ const store: ChatGptCredentialStore = {
async read() {
return (await load())?.credentials;
},
+ async resolveToken(input) {
+ let credentials = await store.read();
+ if (!credentials) {
+ if (input.forceRefresh) throw new ChatGptSignInRequiredError();
+ throw new ChatGptSignedOutError(
+ `ChatGPT subscription is not signed in. ${CHATGPT_LOGIN_HINT}`,
+ );
+ }
+ const rejectedToken = tokenFromCredentials(credentials)?.token;
+ if (
+ input.forceRefresh ||
+ !isChatGptTokenFresh(tokenFromCredentials(credentials), input.now())
+ ) {
+ credentials = await store.update(async (current) => {
+ if (!current) throw new ChatGptSignInRequiredError();
+ if (
+ "accessToken" in current &&
+ isChatGptTokenFresh(tokenFromCredentials(current), input.now()) &&
+ (!input.forceRefresh || current.accessToken !== rejectedToken)
+ ) {
+ return current;
+ }
+ return requestChatGptTokens(
+ { grant_type: "refresh_token", refresh_token: current.refreshToken },
+ {
+ fetch: input.fetch,
+ previous: current,
+ now: input.now,
+ },
+ );
+ });
+ }
+ const token = tokenFromCredentials(credentials);
+ if (!token) throw new Error(`ChatGPT access token is unavailable. ${CHATGPT_LOGIN_HINT}`);
+ return token;
+ },
async update(callback, options) {
await mkdir(dirname(path), { recursive: true, mode: 0o700 });
const lockPath = `${path}.lock`;
@@ -151,6 +202,7 @@ export function createChatGptCredentialStore(
}
},
};
+ return store;
}
let defaultStore: ChatGptCredentialStore | undefined;
@@ -159,6 +211,18 @@ export function getDefaultChatGptCredentialStore(): ChatGptCredentialStore {
return (defaultStore ??= createChatGptCredentialStore());
}
+function tokenFromCredentials(
+ credentials: ChatGptCredentials | ChatGptRefreshCredentials,
+): ChatGptToken | undefined {
+ if (!("accessToken" in credentials)) return undefined;
+ return {
+ token: credentials.accessToken,
+ expiresAt: credentials.expiresAt,
+ ...(credentials.accountId && { accountId: credentials.accountId }),
+ ...(credentials.accountLabel && { accountLabel: credentials.accountLabel }),
+ };
+}
+
function secretStoreError(): Error {
const recovery =
process.platform === "linux"
diff --git a/packages/eve/src/public/models/openai/chatgpt/model.integration.test.ts b/packages/eve/src/public/models/openai/chatgpt/model.integration.test.ts
index 1a719f70b..232732183 100644
--- a/packages/eve/src/public/models/openai/chatgpt/model.integration.test.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/model.integration.test.ts
@@ -22,6 +22,7 @@ describe("ChatGPT streamed reasoning replay", () => {
{ model: "gpt-5.6-luna" },
{
broker: {
+ credentialOwner: () => undefined,
getToken: async () => ({ token: "test-token" }),
refreshState: async () => ({ kind: "ready" }),
state: () => ({ kind: "ready" }),
diff --git a/packages/eve/src/public/models/openai/chatgpt/model.test.ts b/packages/eve/src/public/models/openai/chatgpt/model.test.ts
index ba2b11d81..767a21f3f 100644
--- a/packages/eve/src/public/models/openai/chatgpt/model.test.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/model.test.ts
@@ -178,6 +178,7 @@ describe("Codex model", () => {
function fakeBroker(): CodexTokenBroker {
return {
+ credentialOwner: () => undefined,
getToken: async () => ({ token: "access-token" }),
refreshState: async () => ({ kind: "ready" }),
state: () => ({ kind: "ready" }),
diff --git a/packages/eve/src/public/models/openai/chatgpt/token-broker.test.ts b/packages/eve/src/public/models/openai/chatgpt/token-broker.test.ts
index 0d28f2c9d..e9230d11d 100644
--- a/packages/eve/src/public/models/openai/chatgpt/token-broker.test.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/token-broker.test.ts
@@ -1,183 +1,181 @@
import { describe, expect, it, vi } from "vitest";
+import { CodexBinaryNotFoundError, type CodexAppServer } from "./codex-app-server.js";
import type { ChatGptCredentialStore } from "./credential-store.js";
-import type { ChatGptCredentials, ChatGptRefreshCredentials } from "./oauth.js";
+import { ChatGptSignInRequiredError } from "./oauth.js";
+import { ChatGptSignedOutError, type ChatGptToken } from "./token.js";
import { createCodexTokenBroker } from "./token-broker.js";
-const credentials: ChatGptCredentials = {
- accessToken: "access-token",
- refreshToken: "refresh-token",
+const codexToken: ChatGptToken = { token: "codex-token" };
+const eveToken: ChatGptToken = {
+ token: "eve-token",
expiresAt: 2_000_000_000_000,
accountId: "acct-1",
accountLabel: "[email protected]",
};
-function memoryStore(
- initial: ChatGptCredentials | ChatGptRefreshCredentials | undefined = credentials,
+function appServer(
+ resolveToken: CodexAppServer["resolveToken"] = async () => codexToken,
+): CodexAppServer {
+ return { resolveToken: vi.fn(resolveToken), restart: vi.fn() };
+}
+
+function missingAppServer(): CodexAppServer {
+ return appServer(async () => {
+ throw new CodexBinaryNotFoundError();
+ });
+}
+
+function credentialStore(
+ resolveToken: ChatGptCredentialStore["resolveToken"] = async () => eveToken,
): ChatGptCredentialStore {
- let value = initial;
return {
- read: vi.fn(async () => value),
- update: vi.fn<ChatGptCredentialStore["update"]>(async (callback) => {
- const next = await callback(value);
- value = next;
- return next;
+ read: vi.fn(async () => undefined),
+ resolveToken: vi.fn(resolveToken),
+ update: vi.fn(async () => {
+ throw new Error("Unexpected credential update.");
}),
};
}
-function refreshed() {
- return Response.json({
- access_token: "new-access",
- refresh_token: "new-refresh",
- expires_in: 3600,
+describe("ChatGPT token broker", () => {
+ it("prefers Codex and leaves eve credentials untouched", async () => {
+ const codex = appServer();
+ const store = credentialStore();
+ const broker = createCodexTokenBroker({ appServer: codex, store });
+
+ await expect(broker.getToken({ reason: "request" })).resolves.toEqual(codexToken);
+ expect(codex.resolveToken).toHaveBeenCalledOnce();
+ expect(store.resolveToken).not.toHaveBeenCalled();
+ expect(broker.credentialOwner()).toBe("codex");
});
-}
-describe("ChatGPT token broker", () => {
- it("caches an eve session without spawning Codex", async () => {
- const store = memoryStore();
- const fetch = vi.fn<typeof globalThis.fetch>();
- const broker = createCodexTokenBroker({ store, fetch, now: () => 1_800_000_000_000 });
- await expect(broker.getToken({ reason: "request" })).resolves.toEqual({
- token: credentials.accessToken,
- expiresAt: credentials.expiresAt,
- accountId: "acct-1",
- accountLabel: "[email protected]",
- });
- await broker.getToken({ reason: "request" });
- expect(store.read).toHaveBeenCalledOnce();
- await expect(broker.refreshState()).resolves.toMatchObject({ kind: "ready" });
- expect(fetch).not.toHaveBeenCalled();
+ it("falls back to eve only when the Codex binary is not found", async () => {
+ const codex = missingAppServer();
+ const store = credentialStore();
+ const broker = createCodexTokenBroker({ appServer: codex, store });
+
+ await expect(broker.getToken({ reason: "request" })).resolves.toEqual(eveToken);
+ expect(store.resolveToken).toHaveBeenCalledOnce();
expect(broker.state()).toEqual({ kind: "ready", accountLabel: "[email protected]" });
+ expect(broker.credentialOwner()).toBe("eve");
});
- it("exchanges a saved refresh token on a cold start and caches the access token", async () => {
- const store = memoryStore({ refreshToken: "saved-refresh", accountId: "acct-1" });
- const fetch = vi.fn<typeof globalThis.fetch>(async () => refreshed());
- const broker = createCodexTokenBroker({ store, fetch });
- await expect(broker.getToken({ reason: "request" })).resolves.toMatchObject({
- token: "new-access",
- accountId: "acct-1",
+ it("does not hide other app-server failures behind eve credentials", async () => {
+ const codex = appServer(async () => {
+ throw new Error("Codex protocol failed");
});
- expect(fetch.mock.calls[0]?.[1]?.body?.toString()).toContain("refresh_token=saved-refresh");
- await broker.getToken({ reason: "request" });
- await broker.refreshState();
- expect(fetch).toHaveBeenCalledOnce();
+ const store = credentialStore();
+ const broker = createCodexTokenBroker({ appServer: codex, store });
+
+ await expect(broker.getToken({ reason: "request" })).rejects.toThrow("Codex protocol failed");
+ expect(store.resolveToken).not.toHaveBeenCalled();
+ expect(broker.credentialOwner()).toBe("codex");
+ expect(broker.state()).toEqual({ kind: "unavailable", reason: "Codex protocol failed" });
});
- it("reads the latest saved refresh token after acquiring the update lock", async () => {
- const fetch = vi.fn<typeof globalThis.fetch>(async () => refreshed());
- const broker = createCodexTokenBroker({
- fetch,
- store: {
- read: async () => ({ refreshToken: "previous-refresh" }),
- update: async (callback) => callback({ refreshToken: "rotated-by-other-process" }),
- },
- });
- await expect(broker.getToken({ reason: "request" })).resolves.toMatchObject({
- token: "new-access",
+ it("keeps eve ownership until an explicit state refresh re-probes Codex", async () => {
+ let codexAvailable = false;
+ const codex = appServer(async () => {
+ if (!codexAvailable) throw new CodexBinaryNotFoundError();
+ return codexToken;
});
- expect(fetch.mock.calls[0]?.[1]?.body?.toString()).toContain(
- "refresh_token=rotated-by-other-process",
- );
+ const store = credentialStore();
+ const broker = createCodexTokenBroker({ appServer: codex, store });
+
+ await expect(broker.getToken({ reason: "request" })).resolves.toEqual(eveToken);
+ await broker.getToken({ reason: "request" });
+ expect(codex.resolveToken).toHaveBeenCalledOnce();
+
+ codexAvailable = true;
+ await expect(broker.refreshState()).resolves.toEqual({ kind: "ready" });
+ await expect(broker.getToken({ reason: "request" })).resolves.toEqual(codexToken);
+ expect(codex.resolveToken).toHaveBeenCalledTimes(2);
+ expect(store.resolveToken).toHaveBeenCalledOnce();
+ expect(broker.credentialOwner()).toBe("codex");
});
- it("refreshes within five minutes of expiry and persists rotated credentials", async () => {
- const store = memoryStore({ ...credentials, expiresAt: 1_800_000_100_000 });
- const fetch = vi.fn<typeof globalThis.fetch>(async () => refreshed());
- const broker = createCodexTokenBroker({ store, fetch, now: () => 1_800_000_000_000 });
- await expect(broker.getToken({ reason: "request" })).resolves.toMatchObject({
- token: "new-access",
- });
- expect(fetch.mock.calls[0]?.[1]?.body?.toString()).toContain("refresh_token=refresh-token");
- await expect(store.read()).resolves.toMatchObject({
- accessToken: "new-access",
- refreshToken: "new-refresh",
+ it("caches fresh resolved tokens", async () => {
+ const codex = appServer();
+ const broker = createCodexTokenBroker({
+ appServer: codex,
+ store: credentialStore(),
+ now: () => 1_800_000_000_000,
});
+
+ await broker.getToken({ reason: "request" });
+ await broker.getToken({ reason: "request" });
+ expect(codex.resolveToken).toHaveBeenCalledOnce();
});
- it("coalesces concurrent rejected-token refreshes", async () => {
- const gate = Promise.withResolvers<Response>();
- const fetch = vi.fn<typeof globalThis.fetch>(() => gate.promise);
- const broker = createCodexTokenBroker({ store: memoryStore(), fetch });
+ it("coalesces concurrent rejected-token resolutions", async () => {
+ const gate = Promise.withResolvers<ChatGptToken>();
+ const codex = appServer(() => gate.promise);
+ const broker = createCodexTokenBroker({ appServer: codex, store: credentialStore() });
+
const first = broker.getToken({ reason: "rejected" });
const second = broker.getToken({ reason: "rejected" });
- await vi.waitFor(() => expect(fetch).toHaveBeenCalledOnce());
- gate.resolve(refreshed());
- await Promise.all([first, second]);
- expect(fetch).toHaveBeenCalledOnce();
- });
+ await vi.waitFor(() => expect(codex.resolveToken).toHaveBeenCalledOnce());
+ gate.resolve(codexToken);
- it("reuses credentials another eve process refreshed while acquiring the lock", async () => {
- const fetch = vi.fn<typeof globalThis.fetch>();
- const broker = createCodexTokenBroker({
- fetch,
- store: {
- read: async () => credentials,
- update: async (callback) => callback({ ...credentials, accessToken: "other-process" }),
- },
- });
- await expect(broker.getToken({ reason: "rejected" })).resolves.toMatchObject({
- token: "other-process",
- });
- expect(fetch).not.toHaveBeenCalled();
+ await expect(Promise.all([first, second])).resolves.toEqual([codexToken, codexToken]);
+ expect(codex.resolveToken).toHaveBeenCalledOnce();
});
- it("forces a refresh after an ordinary resolution already in flight", async () => {
- const gate = Promise.withResolvers<ChatGptCredentials>();
- const store = memoryStore();
- vi.mocked(store.read).mockReturnValueOnce(gate.promise);
- const fetch = vi.fn<typeof globalThis.fetch>(async () => refreshed());
- const broker = createCodexTokenBroker({ store, fetch });
+ it("queues a forced refresh behind an ordinary resolution", async () => {
+ const gate = Promise.withResolvers<ChatGptToken>();
+ const codex = appServer(
+ vi
+ .fn<CodexAppServer["resolveToken"]>()
+ .mockReturnValueOnce(gate.promise)
+ .mockResolvedValueOnce({ ...codexToken, token: "refreshed-token" }),
+ );
+ const broker = createCodexTokenBroker({ appServer: codex, store: credentialStore() });
+
const first = broker.getToken({ reason: "request" });
const second = broker.getToken({ reason: "rejected" });
- gate.resolve(credentials);
- await expect(first).resolves.toMatchObject({ token: "access-token" });
- await expect(second).resolves.toMatchObject({ token: "new-access" });
- expect(fetch).toHaveBeenCalledOnce();
+ gate.resolve(codexToken);
+
+ await expect(first).resolves.toEqual(codexToken);
+ await expect(second).resolves.toEqual({ ...codexToken, token: "refreshed-token" });
+ expect(codex.resolveToken).toHaveBeenNthCalledWith(
+ 2,
+ expect.objectContaining({ forceRefresh: true }),
+ );
});
- it("reports signed out and discovers a subsequent eve login", async () => {
- const store = memoryStore();
- vi.mocked(store.read).mockResolvedValueOnce(undefined);
- const broker = createCodexTokenBroker({ store });
- await expect(broker.getToken({ reason: "request" })).rejects.toThrow("/model");
- expect(broker.state()).toEqual({ kind: "signed-out" });
- await expect(broker.refreshState()).resolves.toEqual({
- kind: "ready",
- accountLabel: "[email protected]",
+ it("coalesces state refreshes before restarting a signed-out app-server", async () => {
+ const gate = Promise.withResolvers<void>();
+ let requests = 0;
+ const codex = appServer(async () => {
+ requests += 1;
+ if (requests > 1) await gate.promise;
+ throw new ChatGptSignedOutError();
});
- });
+ const broker = createCodexTokenBroker({ appServer: codex, store: credentialStore() });
+ await expect(broker.refreshState()).resolves.toEqual({ kind: "signed-out" });
- it("preserves the sign-in hint when credentials disappear before a rejected request retries", async () => {
- const store = memoryStore();
- vi.mocked(store.read).mockResolvedValue(undefined);
- const broker = createCodexTokenBroker({ store });
- await expect(broker.getToken({ reason: "rejected" })).rejects.toThrow("/model");
- expect(broker.state()).toEqual({ kind: "reauth-required" });
+ const first = broker.refreshState();
+ const second = broker.refreshState();
+ gate.resolve();
+
+ await expect(Promise.all([first, second])).resolves.toEqual([
+ { kind: "signed-out" },
+ { kind: "signed-out" },
+ ]);
+ expect(codex.restart).toHaveBeenCalledOnce();
+ expect(codex.resolveToken).toHaveBeenCalledTimes(2);
});
- it("reports revoked credentials without exposing the provider response", async () => {
- const broker = createCodexTokenBroker({
- store: memoryStore(),
- fetch: async () => new Response("secret-bearer-token", { status: 401 }),
+ it("maps source reauthentication errors into broker state", async () => {
+ const codex = appServer(async () => {
+ throw new ChatGptSignInRequiredError();
});
- await expect(broker.getToken({ reason: "rejected" })).rejects.toThrow("/model");
- expect(broker.state()).toEqual({ kind: "reauth-required" });
- });
+ const broker = createCodexTokenBroker({ appServer: codex, store: credentialStore() });
- it("keeps credentials after a temporary provider failure and recovers", async () => {
- const fetch = vi
- .fn<typeof globalThis.fetch>()
- .mockResolvedValueOnce(new Response("secret", { status: 503 }))
- .mockResolvedValueOnce(refreshed());
- const store = memoryStore({ ...credentials, expiresAt: 1 });
- const broker = createCodexTokenBroker({ store, fetch });
- await expect(broker.getToken({ reason: "request" })).rejects.toThrow("HTTP 503");
- expect(broker.state()).toMatchObject({ kind: "unavailable" });
- expect(JSON.stringify(broker.state())).not.toContain("secret");
- await expect(store.read()).resolves.toMatchObject({ refreshToken: "refresh-token" });
- await expect(broker.refreshState()).resolves.toMatchObject({ kind: "ready" });
+ await expect(broker.getToken({ reason: "rejected" })).rejects.toBeInstanceOf(
+ ChatGptSignInRequiredError,
+ );
+ expect(broker.state()).toEqual({ kind: "reauth-required" });
});
});
diff --git a/packages/eve/src/public/models/openai/chatgpt/token-broker.ts b/packages/eve/src/public/models/openai/chatgpt/token-broker.ts
index da7556e66..9cd835592 100644
--- a/packages/eve/src/public/models/openai/chatgpt/token-broker.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/token-broker.ts
@@ -3,14 +3,13 @@ import {
type ChatGptCredentialStore,
} from "./credential-store.js";
import {
- CHATGPT_LOGIN_HINT,
- ChatGptSignInRequiredError,
- requestChatGptTokens,
- type ChatGptCredentials,
- type ChatGptRefreshCredentials,
-} from "./oauth.js";
-
-const TOKEN_REFRESH_WINDOW_MS = 5 * 60_000;
+ CodexAppServerClient,
+ CodexBinaryNotFoundError,
+ type CodexAppServer,
+ type CodexAppServerOptions,
+} from "./codex-app-server.js";
+import { ChatGptSignInRequiredError } from "./oauth.js";
+import { ChatGptSignedOutError, isChatGptTokenFresh, type ChatGptToken } from "./token.js";
export type ChatGptAuthState =
| { readonly kind: "checking" }
@@ -22,53 +21,79 @@ export type ChatGptAuthState =
| { readonly kind: "reauth-required" }
| { readonly kind: "unavailable"; readonly reason: string };
-export interface ChatGptToken {
- readonly accountId?: string;
- readonly accountLabel?: string;
- readonly expiresAt?: number;
- readonly token: string;
-}
+export type { ChatGptToken } from "./token.js";
export interface CodexTokenBroker {
+ credentialOwner(): ChatGptCredentialOwner | undefined;
getToken(input: { readonly reason: "rejected" | "request" }): Promise<ChatGptToken>;
refreshState(): Promise<ChatGptAuthState>;
state(): ChatGptAuthState;
}
-export interface CodexTokenBrokerOptions {
+export type ChatGptCredentialOwner = "codex" | "eve";
+
+export interface CodexTokenBrokerOptions extends CodexAppServerOptions {
+ readonly appServer?: CodexAppServer;
readonly store?: ChatGptCredentialStore;
readonly fetch?: typeof fetch;
readonly now?: () => number;
}
export function createCodexTokenBroker(options: CodexTokenBrokerOptions = {}): CodexTokenBroker {
+ const appServer = options.appServer ?? new CodexAppServerClient(options);
const store = options.store ?? getDefaultChatGptCredentialStore();
const now = options.now ?? Date.now;
+ let credentialOwner: ChatGptCredentialOwner | undefined;
let currentState: ChatGptAuthState = { kind: "checking" };
let cached: ChatGptToken | undefined;
let resolution: { readonly forced: boolean; readonly promise: Promise<ChatGptToken> } | undefined;
+ let stateRefresh: Promise<ChatGptAuthState> | undefined;
return {
+ credentialOwner() {
+ return credentialOwner;
+ },
getToken(input) {
return getToken(input.reason);
},
- async refreshState() {
- cached = undefined;
- try {
- await getToken("request");
- } catch {
- // The state is the reportable result; callers should not need exception control flow.
- }
- return currentState;
+ refreshState() {
+ if (stateRefresh !== undefined) return stateRefresh;
+ const promise = refreshAuthState();
+ stateRefresh = promise;
+ void promise.finally(() => {
+ if (stateRefresh === promise) stateRefresh = undefined;
+ });
+ return promise;
},
state() {
return currentState;
},
};
+ async function refreshAuthState(): Promise<ChatGptAuthState> {
+ if (resolution !== undefined) await resolution.promise.catch(() => undefined);
+ if (
+ credentialOwner === "codex" &&
+ (currentState.kind === "signed-out" || currentState.kind === "reauth-required")
+ ) {
+ appServer.restart?.();
+ } else if (credentialOwner === "eve") {
+ // Re-probe at an explicit readiness boundary so a newly installed Codex
+ // becomes authoritative without changing owners in the middle of a request.
+ credentialOwner = undefined;
+ }
+ cached = undefined;
+ try {
+ await getToken("request");
+ } catch {
+ // The state is the reportable result; callers should not need exception control flow.
+ }
+ return currentState;
+ }
+
function getToken(reason: "rejected" | "request"): Promise<ChatGptToken> {
const forced = reason === "rejected";
- if (!forced && cached !== undefined && isFresh(cached, now())) {
+ if (!forced && cached !== undefined && isChatGptTokenFresh(cached, now())) {
return Promise.resolve(cached);
}
if (resolution !== undefined && (!forced || resolution.forced)) {
@@ -89,43 +114,30 @@ export function createCodexTokenBroker(options: CodexTokenBrokerOptions = {}): C
async function resolveToken(forceRefresh: boolean): Promise<ChatGptToken> {
try {
- let credentials = await store.read();
- if (!credentials) {
- cached = undefined;
- if (forceRefresh) throw new ChatGptSignInRequiredError();
- currentState = { kind: "signed-out" };
- throw new Error(`ChatGPT subscription is not signed in. ${CHATGPT_LOGIN_HINT}`);
- }
- const rejectedToken = tokenFrom(credentials)?.token;
- if (forceRefresh || !isFresh(tokenFrom(credentials), now())) {
- credentials = await store.update(async (current) => {
- if (!current) throw new ChatGptSignInRequiredError();
- // A different eve process may already have rotated this refresh token.
- if (
- "accessToken" in current &&
- isFresh(tokenFrom(current), now()) &&
- (!forceRefresh || tokenFrom(current)?.token !== rejectedToken)
- )
- return current;
- return requestChatGptTokens(
- { grant_type: "refresh_token", refresh_token: current.refreshToken },
- {
- fetch: options.fetch,
- previous: current,
- now,
- },
- );
- });
+ let token: ChatGptToken;
+ if (credentialOwner === "eve") {
+ token = await store.resolveToken({ forceRefresh, fetch: options.fetch, now });
+ } else {
+ try {
+ token = await appServer.resolveToken({ forceRefresh, now });
+ credentialOwner = "codex";
+ } catch (error) {
+ if (!(error instanceof CodexBinaryNotFoundError)) {
+ credentialOwner ??= "codex";
+ throw error;
+ }
+ credentialOwner = "eve";
+ token = await store.resolveToken({ forceRefresh, fetch: options.fetch, now });
+ }
}
- const token = tokenFrom(credentials);
- if (!token) throw new Error(`ChatGPT access token is unavailable. ${CHATGPT_LOGIN_HINT}`);
cached = token;
currentState = readyState(token);
return token;
} catch (error) {
cached = undefined;
if (error instanceof ChatGptSignInRequiredError) currentState = { kind: "reauth-required" };
- else if (currentState.kind !== "signed-out") {
+ else if (error instanceof ChatGptSignedOutError) currentState = { kind: "signed-out" };
+ else {
const reason = error instanceof Error ? error.message : String(error);
currentState = { kind: "unavailable", reason };
}
@@ -141,28 +153,9 @@ export function getDefaultCodexTokenBroker(): CodexTokenBroker {
return defaultBroker;
}
-function tokenFrom(
- credentials: ChatGptCredentials | ChatGptRefreshCredentials,
-): ChatGptToken | undefined {
- if (!("accessToken" in credentials)) return undefined;
- return {
- token: credentials.accessToken,
- expiresAt: credentials.expiresAt,
- ...(credentials.accountId && { accountId: credentials.accountId }),
- ...(credentials.accountLabel && { accountLabel: credentials.accountLabel }),
- };
-}
-
function readyState(token: ChatGptToken): ChatGptAuthState {
return {
kind: "ready",
...(token.accountLabel !== undefined && { accountLabel: token.accountLabel }),
};
}
-
-function isFresh(token: ChatGptToken | undefined, now: number): boolean {
- return (
- token !== undefined &&
- (token.expiresAt === undefined || token.expiresAt - TOKEN_REFRESH_WINDOW_MS > now)
- );
-}
diff --git a/packages/eve/src/public/models/openai/chatgpt/token.ts b/packages/eve/src/public/models/openai/chatgpt/token.ts
new file mode 100644
index 000000000..7140ead7c
--- /dev/null
+++ b/packages/eve/src/public/models/openai/chatgpt/token.ts
@@ -0,0 +1,22 @@
+const TOKEN_REFRESH_WINDOW_MS = 5 * 60_000;
+
+export interface ChatGptToken {
+ readonly accountId?: string;
+ readonly accountLabel?: string;
+ readonly expiresAt?: number;
+ readonly token: string;
+}
+
+export interface ChatGptTokenResolutionInput {
+ readonly forceRefresh: boolean;
+ readonly now: () => number;
+}
+
+export class ChatGptSignedOutError extends Error {}
+
+export function isChatGptTokenFresh(token: ChatGptToken | undefined, now: number): boolean {
+ return (
+ token !== undefined &&
+ (token.expiresAt === undefined || token.expiresAt - TOKEN_REFRESH_WINDOW_MS > now)
+ );
+}
diff --git a/packages/eve/src/public/models/openai/chatgpt/transport.test.ts b/packages/eve/src/public/models/openai/chatgpt/transport.test.ts
index 3aa85b66b..21fa6ff6a 100644
--- a/packages/eve/src/public/models/openai/chatgpt/transport.test.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/transport.test.ts
@@ -150,6 +150,7 @@ function fakeBroker(
tokens: Array<{ readonly accountId?: string; readonly token: string }>,
): CodexTokenBroker {
return {
+ credentialOwner: () => undefined,
getToken: vi.fn(async () => {
const token = tokens.shift();
if (token === undefined) throw new Error("No token configured.");
diff --git a/packages/eve/src/public/models/openai/chatgpt/transport.ts b/packages/eve/src/public/models/openai/chatgpt/transport.ts
index fbb26b0ca..51ccd777d 100644
--- a/packages/eve/src/public/models/openai/chatgpt/transport.ts
+++ b/packages/eve/src/public/models/openai/chatgpt/transport.ts
@@ -14,7 +14,8 @@ export interface CodexTransportOptions {
/**
* Routes OpenAI Responses requests through the Codex backend. Authentication is
- * resolved and refreshed from eve's local ChatGPT session.
+ * resolved through Codex app-server when available, with eve-owned credentials
+ * used only when the Codex binary is not installed.
*/
export function createCodexFetch(options: CodexTransportOptions = {}): Fetch {
const httpFetch = options.fetch ?? fetch;
diff --git a/packages/eve/src/public/models/openai/index.ts b/packages/eve/src/public/models/openai/index.ts
index 43a56439b..bcdff4744 100644
--- a/packages/eve/src/public/models/openai/index.ts
+++ b/packages/eve/src/public/models/openai/index.ts
@@ -11,8 +11,9 @@ import { createCodexSubscriptionModel } from "./chatgpt/model.js";
* only, so any other provider-qualified id is rejected. Model availability is
* enforced by the Codex backend per account at call time, not at compile time.
*
- * eve stores and refreshes credentials locally without requiring the Codex
- * CLI. This model works in local dev and fails in a deployment.
+ * eve uses Codex app-server when the Codex CLI is installed. If the binary is
+ * not found, eve stores and refreshes its own local credentials instead. This
+ * model works in local dev and fails in a deployment.
* Branch on environment for production:
*
* ```ts
diff --git a/packages/eve/src/setup/flows/chatgpt-auth.scenario.test.ts b/packages/eve/src/setup/flows/chatgpt-auth.scenario.test.ts
index 1cd4b271d..d8ca6da16 100644
--- a/packages/eve/src/setup/flows/chatgpt-auth.scenario.test.ts
+++ b/packages/eve/src/setup/flows/chatgpt-auth.scenario.test.ts
@@ -4,7 +4,15 @@ import { afterEach, describe, expect, it, vi } from "vitest";
import { createCodexTokenBroker } from "#public/models/openai/chatgpt/token-broker.js";
import type { ChatGptCredentialStore } from "#public/models/openai/chatgpt/credential-store.js";
-import type { ChatGptCredentials } from "#public/models/openai/chatgpt/oauth.js";
+import {
+ CodexBinaryNotFoundError,
+ type CodexAppServer,
+} from "#public/models/openai/chatgpt/codex-app-server.js";
+import {
+ ChatGptSignInRequiredError,
+ type ChatGptCredentials,
+} from "#public/models/openai/chatgpt/oauth.js";
+import { ChatGptSignedOutError } from "#public/models/openai/chatgpt/token.js";
import { ensureChatGptAuth } from "./chatgpt-auth.js";
const controllers: AbortController[] = [];
@@ -16,6 +24,13 @@ function setup() {
let credentials: ChatGptCredentials | undefined;
const store: ChatGptCredentialStore = {
read: async () => credentials,
+ resolveToken: vi.fn(async ({ forceRefresh }) => {
+ if (!credentials) {
+ if (forceRefresh) throw new ChatGptSignInRequiredError();
+ throw new ChatGptSignedOutError();
+ }
+ return { token: credentials.accessToken, expiresAt: credentials.expiresAt };
+ }),
update: vi.fn<ChatGptCredentialStore["update"]>(async (callback) => {
credentials = await callback(credentials);
return credentials;
@@ -30,12 +45,20 @@ function setup() {
store,
controller,
fetch,
- broker: createCodexTokenBroker({ store, fetch }),
+ broker: createCodexTokenBroker({ appServer: missingCodexAppServer(), store, fetch }),
log: vi.fn(),
headless: false,
};
}
+function missingCodexAppServer(): CodexAppServer {
+ return {
+ resolveToken: vi.fn(async () => {
+ throw new CodexBinaryNotFoundError();
+ }),
+ };
+}
+
describe("native ChatGPT browser login", () => {
it("signs in from an empty eve session with PKCE and ignores unrelated callbacks", async () => {
const options = setup();
diff --git a/packages/eve/src/setup/flows/chatgpt-auth.test.ts b/packages/eve/src/setup/flows/chatgpt-auth.test.ts
index 83a1cbbc5..3c0765a42 100644
--- a/packages/eve/src/setup/flows/chatgpt-auth.test.ts
+++ b/packages/eve/src/setup/flows/chatgpt-auth.test.ts
@@ -1,13 +1,29 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+ CodexBinaryNotFoundError,
+ type CodexAppServer,
+} from "#public/models/openai/chatgpt/codex-app-server.js";
import {
ChatGptInvalidStoredSessionError,
type ChatGptCredentialStore,
} from "#public/models/openai/chatgpt/credential-store.js";
-import type { ChatGptCredentials } from "#public/models/openai/chatgpt/oauth.js";
-import { createCodexTokenBroker } from "#public/models/openai/chatgpt/token-broker.js";
+import {
+ ChatGptSignInRequiredError,
+ type ChatGptCredentials,
+} from "#public/models/openai/chatgpt/oauth.js";
+import { ChatGptSignedOutError } from "#public/models/openai/chatgpt/token.js";
+import {
+ createCodexTokenBroker,
+ type CodexTokenBroker,
+} from "#public/models/openai/chatgpt/token-broker.js";
import { ensureChatGptAuth } from "./chatgpt-auth.js";
+vi.mock("node:child_process", () => ({ spawn: vi.fn() }));
vi.mock("node:timers/promises", () => ({
setTimeout: (ms: number, _value: unknown, options: { signal: AbortSignal }) =>
new Promise<void>((resolve, reject) => {
@@ -24,12 +40,27 @@ vi.mock("node:timers/promises", () => ({
}),
}));
-afterEach(() => vi.useRealTimers());
+afterEach(() => {
+ vi.useRealTimers();
+ vi.mocked(spawn).mockReset();
+});
function setup() {
let credentials: ChatGptCredentials | undefined;
const store: ChatGptCredentialStore = {
read: async () => credentials,
+ resolveToken: vi.fn(async ({ forceRefresh }) => {
+ if (!credentials) {
+ if (forceRefresh) throw new ChatGptSignInRequiredError();
+ throw new ChatGptSignedOutError();
+ }
+ return {
+ token: credentials.accessToken,
+ expiresAt: credentials.expiresAt,
+ ...(credentials.accountId && { accountId: credentials.accountId }),
+ ...(credentials.accountLabel && { accountLabel: credentials.accountLabel }),
+ };
+ }),
update: vi.fn<ChatGptCredentialStore["update"]>(async (callback) => {
credentials = await callback(credentials);
return credentials;
@@ -39,13 +70,21 @@ function setup() {
return {
store,
fetch,
- broker: createCodexTokenBroker({ store, fetch }),
+ broker: createCodexTokenBroker({ appServer: missingCodexAppServer(), store, fetch }),
open: vi.fn(),
log: vi.fn(),
headless: true,
};
}
+function missingCodexAppServer(): CodexAppServer {
+ return {
+ resolveToken: vi.fn(async () => {
+ throw new CodexBinaryNotFoundError();
+ }),
+ };
+}
+
const device = { device_auth_id: "device-id", user_code: "ABCD-EFGH", interval: "1" };
describe("ChatGPT device sign-in", () => {
@@ -87,6 +126,100 @@ describe("ChatGPT device sign-in", () => {
expect(options.store.update).toHaveBeenCalledWith(expect.any(Function), { replace: true });
});
+ it("uses Codex login when app-server owns the credentials", async () => {
+ const options = setup();
+ let signedIn = false;
+ const restart = vi.fn();
+ const appServer: CodexAppServer = {
+ restart,
+ resolveToken: vi.fn(async () => {
+ if (!signedIn) throw new ChatGptSignedOutError();
+ return { token: "codex-token" };
+ }),
+ };
+ const broker = createCodexTokenBroker({ appServer, store: options.store });
+ const codexLogin = vi.fn(async () => {
+ signedIn = true;
+ });
+
+ await ensureChatGptAuth({ ...options, broker, codexLogin });
+
+ expect(codexLogin).toHaveBeenCalledOnce();
+ expect(restart).toHaveBeenCalledOnce();
+ expect(options.store.update).not.toHaveBeenCalled();
+ expect(options.open).not.toHaveBeenCalled();
+ expect(broker.credentialOwner()).toBe("codex");
+ });
+
+ it("pipes Codex login output through the parent logger", async () => {
+ const options = setup();
+ let signedIn = false;
+ const restart = vi.fn();
+ const appServer: CodexAppServer = {
+ restart,
+ resolveToken: vi.fn(async () => {
+ if (!signedIn) throw new ChatGptSignedOutError();
+ return { token: "codex-token" };
+ }),
+ };
+ const broker = createCodexTokenBroker({ appServer, store: options.store });
+ const stdout = new PassThrough();
+ const stderr = new PassThrough();
+ const child = Object.assign(new EventEmitter(), { stdout, stderr });
+ vi.mocked(spawn).mockReturnValue(child as never);
+
+ const login = ensureChatGptAuth({ ...options, broker });
+ await vi.waitFor(() => expect(spawn).toHaveBeenCalledOnce());
+ stdout.write("Starting local login server.\nOpen the browser");
+ stderr.write("Waiting for authentication.\n");
+ signedIn = true;
+ child.emit("close", 0, null);
+ await login;
+
+ expect(spawn).toHaveBeenCalledWith("codex", ["login"], {
+ stdio: ["ignore", "pipe", "pipe"],
+ });
+ expect(options.log).toHaveBeenCalledWith("Starting local login server.");
+ expect(options.log).toHaveBeenCalledWith("Waiting for authentication.");
+ expect(options.log).toHaveBeenCalledWith("Open the browser");
+ expect(restart).toHaveBeenCalledOnce();
+ });
+
+ it("does not fall back when app-server fails for a reason other than a missing binary", async () => {
+ const options = setup();
+ const codexLogin = vi.fn();
+ const broker = createCodexTokenBroker({
+ appServer: {
+ resolveToken: vi.fn(async () => {
+ throw new Error("Codex protocol failed");
+ }),
+ },
+ store: options.store,
+ });
+
+ await expect(ensureChatGptAuth({ ...options, broker, codexLogin })).rejects.toThrow(
+ "Codex protocol failed",
+ );
+ expect(codexLogin).not.toHaveBeenCalled();
+ expect(options.store.update).not.toHaveBeenCalled();
+ });
+
+ it("does not enter eve-owned sign-in with an unresolved credential owner", async () => {
+ const options = setup();
+ const broker: CodexTokenBroker = {
+ credentialOwner: () => undefined,
+ getToken: vi.fn(),
+ refreshState: vi.fn(async () => ({ kind: "signed-out" }) as const),
+ state: () => ({ kind: "signed-out" }),
+ };
+
+ await expect(ensureChatGptAuth({ ...options, broker })).rejects.toThrow(
+ "ChatGPT credential owner could not be resolved",
+ );
+ expect(options.store.update).not.toHaveBeenCalled();
+ expect(options.open).not.toHaveBeenCalled();
+ });
+
it("completes a first sign-in after pending polls without any Codex credentials", async () => {
vi.useFakeTimers();
const options = setup();
diff --git a/packages/eve/src/setup/flows/chatgpt-auth.ts b/packages/eve/src/setup/flows/chatgpt-auth.ts
index 9d7929996..be4d24e9b 100644
--- a/packages/eve/src/setup/flows/chatgpt-auth.ts
+++ b/packages/eve/src/setup/flows/chatgpt-auth.ts
@@ -1,7 +1,10 @@
+import { spawn } from "node:child_process";
import { createHash, randomBytes } from "node:crypto";
import { createServer } from "node:http";
import { setTimeout as delay } from "node:timers/promises";
+import { createProcessOutputBuffer } from "#setup/primitives/process-output.js";
+
import {
ChatGptInvalidStoredSessionError,
getDefaultChatGptCredentialStore,
@@ -28,6 +31,7 @@ const REDIRECT_URI = "http://localhost:1455/auth/callback";
interface ChatGptAuthOptions {
readonly signal?: AbortSignal;
readonly broker?: CodexTokenBroker;
+ readonly codexLogin?: (signal?: AbortSignal) => Promise<void>;
readonly store?: ChatGptCredentialStore;
readonly fetch?: typeof fetch;
readonly open?: (url: string) => void;
@@ -35,18 +39,49 @@ interface ChatGptAuthOptions {
readonly headless?: boolean;
}
-/** Signs in directly with OpenAI; credentials belong to eve, independently of Codex. */
+/** Signs in through the credential owner selected by the ChatGPT auth facade. */
export async function ensureChatGptAuth(options: ChatGptAuthOptions = {}): Promise<void> {
const broker = options.broker ?? getDefaultCodexTokenBroker();
const store = options.store ?? getDefaultChatGptCredentialStore();
options.signal?.throwIfAborted();
const state = await broker.refreshState();
if (state.kind === "ready") return;
+ const owner = broker.credentialOwner();
+ if (owner === undefined) {
+ throw new Error("ChatGPT credential owner could not be resolved.");
+ }
+ if (owner === "codex") {
+ if (state.kind === "unavailable") throw new Error(state.reason);
+ try {
+ const log = options.log ?? ((message: string) => process.stdout.write(`${message}\n`));
+ await (options.codexLogin ?? ((signal) => loginWithCodex(signal, log)))(options.signal);
+ await assertChatGptAuthReady(
+ broker,
+ "Codex login completed without a usable ChatGPT session.",
+ );
+ return;
+ } catch (error) {
+ if (!isErrnoCode(error, "ENOENT")) throw error;
+ const reprobed = await broker.refreshState();
+ if (broker.credentialOwner() !== "eve") throw error;
+ if (reprobed.kind === "ready") return;
+ if (reprobed.kind === "unavailable") throw new Error(reprobed.reason);
+ }
+ }
+
try {
await store.read();
} catch (error) {
if (!(error instanceof ChatGptInvalidStoredSessionError)) throw error;
}
+ await signInWithOwnedCredentials(options, broker, store);
+}
+
+async function signInWithOwnedCredentials(
+ options: ChatGptAuthOptions,
+ broker: CodexTokenBroker,
+ store: ChatGptCredentialStore,
+): Promise<void> {
const controller = new AbortController();
const cancel = (): void => controller.abort(new WizardCancelledError());
process.once("SIGINT", cancel);
@@ -70,9 +105,10 @@ export async function ensureChatGptAuth(options: ChatGptAuthOptions = {}): Promi
},
{ replace: true },
);
- const refreshed = await broker.refreshState();
- if (refreshed.kind !== "ready")
- throw new Error("ChatGPT sign-in could not be verified. Retry from /model.");
+ await assertChatGptAuthReady(
+ broker,
+ "ChatGPT sign-in could not be verified. Retry from /model.",
+ );
log("ChatGPT subscription connected.");
} catch (error) {
signal.throwIfAborted();
@@ -83,6 +119,35 @@ export async function ensureChatGptAuth(options: ChatGptAuthOptions = {}): Promi
}
}
+async function assertChatGptAuthReady(broker: CodexTokenBroker, message: string): Promise<void> {
+ const refreshed = await broker.refreshState();
+ if (refreshed.kind !== "ready") throw new Error(message);
+}
+
+async function loginWithCodex(
+ signal: AbortSignal | undefined,
+ log: (message: string) => void,
+): Promise<void> {
+ const child = spawn("codex", ["login"], {
+ stdio: ["ignore", "pipe", "pipe"],
+ ...(signal !== undefined && { signal }),
+ });
+ const output = createProcessOutputBuffer(({ text }) => log(text));
+ child.stdout.on("data", (chunk: Buffer) => output.write("stdout", chunk));
+ child.stderr.on("data", (chunk: Buffer) => output.write("stderr", chunk));
+ try {
+ await new Promise<void>((resolve, reject) => {
+ child.once("error", reject);
+ child.once("close", (code, signal) => {
+ if (code === 0) resolve();
+ else reject(new Error(`codex login failed (${signal ?? code ?? "unknown"}).`));
+ });
+ });
+ } finally {
+ output.flush();
+ }
+}
+
type LoginOptions = ChatGptAuthOptions & {
signal: AbortSignal;
log: (message: string) => void;