@mandujs/core 0.40.1 → 0.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",

package/src/brain/adapters/__tests__/_helpers.ts

@@ -5,12 +5,15 @@
  * in the real network / keychain / filesystem paths.
  */
 
+import path from "node:path";
+import os from "node:os";
 import {
   CredentialStore,
   type CredentialBackend,
   type StoredToken,
 } from "../../credentials";
 import type { HttpClient, OAuthEndpoints } from "../oauth-flow";
+import { ChatGPTAuth } from "../chatgpt-auth";
 
 /**
  * In-memory credential store that satisfies `CredentialBackend`. We
@@ -62,3 +65,19 @@ export function jsonResponse(body: unknown, status = 200): Response {
     headers: { "content-type": "application/json" },
   });
 }
+
+/**
+ * Isolated ChatGPTAuth that always reports no session token — points at
+ * a nonexistent path so it never picks up the developer's real
+ * `~/.codex/auth.json`. Tests that exercise the keychain path must
+ * pass this helper to prevent the ChatGPT code path from short-
+ * circuiting the test's intended flow.
+ */
+export function makeEmptyChatGPTAuth(): ChatGPTAuth {
+  return new ChatGPTAuth({
+    authFilePath: path.join(
+      os.tmpdir(),
+      `mandu-test-no-auth-${process.pid}-${Date.now()}.json`,
+    ),
+  });
+}

package/src/brain/adapters/__tests__/chatgpt-auth.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for the ChatGPT session-token auth helper
+ * (`packages/core/src/brain/adapters/chatgpt-auth.ts`).
+ *
+ * ChatGPTAuth reads whatever `@openai/codex login` wrote to
+ * `~/.codex/auth.json` (or the `CHATGPT_LOCAL_HOME` / `CODEX_HOME`
+ * override), auto-refreshes when the access token is near expiry, and
+ * exposes `{ accessToken, accountId, idToken, refreshToken }` to
+ * callers. Tests here exercise the pure-file behaviour — the refresh
+ * path uses an injected `httpClient` so no network hits the real
+ * `auth.openai.com`.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { promises as fs } from "node:fs";
+import { writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ChatGPTAuth } from "../chatgpt-auth";
+
+let tmp: string;
+let authPath: string;
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-chatgpt-auth-"));
+  authPath = path.join(tmp, "auth.json");
+});
+
+afterEach(async () => {
+  await fs.rm(tmp, { recursive: true, force: true });
+});
+
+/** Minimal JWT whose `exp` claim is far in the future (no refresh). */
+function makeFarFutureJwt(): string {
+  const header = Buffer.from('{"alg":"none"}').toString("base64url");
+  const payload = Buffer.from(
+    JSON.stringify({
+      exp: Math.floor(Date.now() / 1000) + 60 * 60 * 24, // 24h from now
+      "https://api.openai.com/auth": {
+        chatgpt_account_id: "acct_test",
+      },
+    }),
+  ).toString("base64url");
+  return `${header}.${payload}.`;
+}
+
+function makeExpiredJwt(): string {
+  const header = Buffer.from('{"alg":"none"}').toString("base64url");
+  const payload = Buffer.from(
+    JSON.stringify({
+      exp: Math.floor(Date.now() / 1000) - 60, // 1 min ago
+      "https://api.openai.com/auth": {
+        chatgpt_account_id: "acct_test",
+      },
+    }),
+  ).toString("base64url");
+  return `${header}.${payload}.`;
+}
+
+function seedAuthFile(contents: unknown): void {
+  writeFileSync(authPath, JSON.stringify(contents), { encoding: "utf-8" });
+}
+
+describe("ChatGPTAuth — discovery + isAuthenticated", () => {
+  it("reports false when auth.json does not exist", () => {
+    const auth = new ChatGPTAuth({ authFilePath: authPath });
+    expect(auth.isAuthenticated()).toBe(false);
+    expect(auth.locateAuthFile()).toBe(null);
+  });
+
+  it("reports true when auth.json has an access_token", () => {
+    seedAuthFile({ tokens: { access_token: "x" } });
+    const auth = new ChatGPTAuth({ authFilePath: authPath });
+    expect(auth.isAuthenticated()).toBe(true);
+    expect(auth.locateAuthFile()).toBe(authPath);
+  });
+});
+
+describe("ChatGPTAuth — getAuth with a valid (non-expiring) token", () => {
+  it("returns accessToken + accountId without calling refresh", async () => {
+    const jwt = makeFarFutureJwt();
+    seedAuthFile({
+      tokens: {
+        access_token: "live-access",
+        id_token: jwt,
+        refresh_token: "live-refresh",
+      },
+      last_refresh: new Date().toISOString(),
+    });
+
+    let refreshCalls = 0;
+    const auth = new ChatGPTAuth({
+      authFilePath: authPath,
+      httpClient: async () => {
+        refreshCalls++;
+        return new Response("{}", { status: 200 });
+      },
+    });
+
+    const effective = await auth.getAuth();
+    expect(effective.accessToken).toBe("live-access");
+    expect(effective.accountId).toBe("acct_test");
+    expect(effective.sourcePath).toBe(authPath);
+    expect(refreshCalls).toBe(0);
+  });
+
+  it("throws a helpful message when auth.json is missing", async () => {
+    const auth = new ChatGPTAuth({ authFilePath: authPath });
+    await expect(auth.getAuth()).rejects.toThrow(/auth\.json not found/);
+  });
+});
+
+describe("ChatGPTAuth — automatic refresh on expired access_token", () => {
+  it("calls the token endpoint once and persists the new tokens", async () => {
+    const expiredJwt = makeExpiredJwt();
+    seedAuthFile({
+      tokens: {
+        access_token: expiredJwt, // exp < now → triggers refresh
+        id_token: expiredJwt,
+        refresh_token: "r-fresh",
+      },
+    });
+
+    let tokenCalls = 0;
+    const newJwt = makeFarFutureJwt();
+    const auth = new ChatGPTAuth({
+      authFilePath: authPath,
+      httpClient: async (url, init) => {
+        tokenCalls++;
+        expect(url).toBe("https://auth.openai.com/oauth/token");
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        expect(body.grant_type).toBe("refresh_token");
+        expect(body.refresh_token).toBe("r-fresh");
+        return new Response(
+          JSON.stringify({
+            access_token: "brand-new-access",
+            refresh_token: "brand-new-refresh",
+            id_token: newJwt,
+          }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      },
+    });
+
+    const effective = await auth.getAuth();
+    expect(effective.accessToken).toBe("brand-new-access");
+    expect(effective.refreshToken).toBe("brand-new-refresh");
+    expect(effective.accountId).toBe("acct_test");
+    expect(tokenCalls).toBe(1);
+
+    // auth.json on disk should have been rewritten with the new tokens.
+    const onDisk = JSON.parse(await fs.readFile(authPath, "utf-8"));
+    expect(onDisk.tokens.access_token).toBe("brand-new-access");
+    expect(onDisk.tokens.refresh_token).toBe("brand-new-refresh");
+    expect(typeof onDisk.last_refresh).toBe("string");
+  });
+
+  it("surfaces token endpoint errors verbatim", async () => {
+    seedAuthFile({
+      tokens: {
+        access_token: makeExpiredJwt(),
+        refresh_token: "r-bad",
+      },
+    });
+
+    const auth = new ChatGPTAuth({
+      authFilePath: authPath,
+      httpClient: async () =>
+        new Response("bad token", { status: 401 }),
+    });
+
+    await expect(auth.getAuth()).rejects.toThrow(/Token refresh 401/);
+  });
+});
+
+describe("ChatGPTAuth — malformed auth.json", () => {
+  it("rejects when access_token is missing", async () => {
+    seedAuthFile({ tokens: {} });
+    const auth = new ChatGPTAuth({ authFilePath: authPath });
+    await expect(auth.getAuth()).rejects.toThrow(/no access_token/);
+  });
+
+  it("rejects when refresh is required but refresh_token is absent", async () => {
+    seedAuthFile({
+      tokens: {
+        access_token: makeExpiredJwt(),
+        // refresh_token intentionally omitted
+      },
+    });
+    const auth = new ChatGPTAuth({ authFilePath: authPath });
+    await expect(auth.getAuth()).rejects.toThrow(/no refresh_token/);
+  });
+});

package/src/brain/adapters/__tests__/openai-oauth.test.ts

@@ -23,6 +23,7 @@ import {
   makeStubHttpClient,
   FAKE_ENDPOINTS,
   jsonResponse,
+  makeEmptyChatGPTAuth,
 } from "./_helpers";
 import type { StoredToken } from "../../credentials";
 
@@ -49,6 +50,7 @@ describe("OpenAIOAuthAdapter — shape + defaults", () => {
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: makeStubHttpClient(() => new Response("ok")),
       skipConsent: true,
     });
@@ -76,6 +78,7 @@ describe("OpenAIOAuthAdapter — redaction invariant", () => {
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: http,
       skipConsent: true,
     });
@@ -118,6 +121,7 @@ describe("OpenAIOAuthAdapter — 401 fallback chain", () => {
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: http,
       skipConsent: true,
     });
@@ -137,6 +141,7 @@ describe("OpenAIOAuthAdapter — no-token → empty completion (not strict)", ()
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: makeStubHttpClient(() =>
         jsonResponse({
           choices: [{ message: { content: "should-not-run" } }],
@@ -164,6 +169,7 @@ describe("OpenAIOAuthAdapter — consent decline short-circuits transmission", (
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: http,
       consentDeps: {
         ask: async () => "n",
@@ -192,6 +198,7 @@ describe("OpenAIOAuthAdapter — model override flows through to the wire body",
       credentialStore: store,
       projectRoot: tmp,
       endpoints: FAKE_ENDPOINTS,
+      chatgptAuth: makeEmptyChatGPTAuth(),
       httpClient: http,
       skipConsent: true,
       model: "gpt-4o",

package/src/brain/adapters/chatgpt-auth.ts

@@ -0,0 +1,300 @@
+/**
+ * ChatGPT OAuth 토큰 관리 — `codex login`이 만든 auth.json을 읽고 자동 refresh.
+ *
+ * 첫 로그인은 OpenAI 공식 Codex CLI가 담당:
+ *   `npx @openai/codex login`
+ * → 브라우저에서 ChatGPT 로그인 → 토큰이 `~/.codex/auth.json` 또는
+ *   `~/.chatgpt-local/auth.json`에 저장됨.
+ *
+ * Mandu 는 그 파일을 읽고, 만료 임박 시 refresh_token으로 자동 갱신.
+ *
+ * 이 접근의 장점:
+ *   - Mandu OAuth 앱 등록 불필요. OpenAI 공식 clientId 재사용.
+ *   - 사용자가 codex CLI 를 이미 설치했다면 로그인 1회로 끝.
+ *   - 토큰 저장소를 OpenAI 공식 경로와 공유 → 여러 도구가 같은 세션 사용.
+ *
+ * 포팅 원본: kakao-bot-sdk `src/auth/chatgpt.ts` (EvanZhouDev/openai-oauth
+ * MIT 패턴의 단순화 버전).
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+const DEFAULT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const DEFAULT_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const REFRESH_EXPIRY_MARGIN_MS = 5 * 60 * 1000;
+
+interface StoredTokens {
+  id_token?: string;
+  access_token?: string;
+  refresh_token?: string;
+  account_id?: string;
+}
+
+interface AuthFile {
+  OPENAI_API_KEY?: string;
+  tokens?: StoredTokens;
+  last_refresh?: string;
+}
+
+export interface EffectiveAuth {
+  accessToken: string;
+  accountId: string;
+  idToken?: string;
+  refreshToken?: string;
+  sourcePath: string;
+}
+
+/** Minimal fetch surface — matches `HttpClient` from `./oauth-flow`. */
+export type ChatGPTHttpClient = (
+  input: string,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export interface ChatGPTAuthOptions {
+  /** auth.json 경로 명시 override. 기본: 자동 탐색. */
+  authFilePath?: string;
+  /** OAuth client_id. 기본: ChatGPT 공식 (`app_EMoamEEZ73f0CkXaXp7hrann`). */
+  clientId?: string;
+  /** Token endpoint. 기본: `https://auth.openai.com/oauth/token`. */
+  tokenUrl?: string;
+  /** Test 주입용 — 실제 fetch 대신 stub. */
+  httpClient?: ChatGPTHttpClient;
+}
+
+export class ChatGPTAuth {
+  private readonly clientId: string;
+  private readonly tokenUrl: string;
+  private readonly httpClient: ChatGPTHttpClient;
+  /** 명시된 경로 또는 첫 read 시 결정된 경로. write 시 같은 경로 사용. */
+  private resolvedPath: string | null;
+  private readonly explicitPath: string | undefined;
+
+  constructor(options: ChatGPTAuthOptions = {}) {
+    this.clientId = options.clientId ?? DEFAULT_CLIENT_ID;
+    this.tokenUrl = options.tokenUrl ?? DEFAULT_TOKEN_URL;
+    this.httpClient = options.httpClient ?? fetch;
+    this.explicitPath = options.authFilePath;
+    this.resolvedPath = options.authFilePath ?? null;
+  }
+
+  /** 저장된 토큰이 존재하는지 (만료 무관). */
+  isAuthenticated(): boolean {
+    const data = this.readFile();
+    return Boolean(data?.tokens?.access_token);
+  }
+
+  /**
+   * 유효한 access_token + account_id 반환. 만료 임박 시 자동 refresh.
+   * 토큰 없거나 refresh 실패 시 throw.
+   */
+  async getAuth(): Promise<EffectiveAuth> {
+    let data = this.readFile();
+    if (!data) {
+      throw new Error(
+        `[mandu brain] OpenAI auth.json not found. Expected at one of:\n${candidatePaths(this.explicitPath).join("\n")}\n` +
+          `Run \`npx @openai/codex login\` first (or \`mandu brain login\` which wraps it).`,
+      );
+    }
+
+    let accessToken = data.tokens?.access_token;
+    let idToken = data.tokens?.id_token;
+    let refreshToken = data.tokens?.refresh_token;
+    let accountId = data.tokens?.account_id ?? deriveAccountId(idToken);
+
+    if (!accessToken) {
+      throw new Error(
+        "[mandu brain] auth.json has no access_token. Re-run `npx @openai/codex login`.",
+      );
+    }
+
+    if (shouldRefresh(accessToken, data.last_refresh)) {
+      if (!refreshToken) {
+        throw new Error(
+          "[mandu brain] Token expired and no refresh_token available. Re-run `npx @openai/codex login`.",
+        );
+      }
+      const refreshed = await this.callTokenEndpoint(refreshToken);
+      accessToken = refreshed.access_token;
+      idToken = refreshed.id_token ?? idToken;
+      refreshToken = refreshed.refresh_token ?? refreshToken;
+      accountId = deriveAccountId(idToken) ?? accountId;
+
+      data = {
+        ...data,
+        tokens: {
+          id_token: idToken,
+          access_token: accessToken,
+          refresh_token: refreshToken,
+          account_id: accountId,
+        },
+        last_refresh: new Date().toISOString(),
+      };
+      this.writeFile(data);
+    }
+
+    if (!accountId) {
+      throw new Error(
+        "[mandu brain] Could not derive chatgpt_account_id from auth.json. Re-login required.",
+      );
+    }
+    if (!accessToken) {
+      throw new Error(
+        "[mandu brain] access_token is null after refresh (unexpected).",
+      );
+    }
+
+    return {
+      accessToken,
+      accountId,
+      idToken,
+      refreshToken,
+      sourcePath: this.resolvedPath ?? "(unknown)",
+    };
+  }
+
+  /** 로그인 후 auth.json 이 존재하는 위치 반환 (디버그용). */
+  locateAuthFile(): string | null {
+    const candidates = candidatePaths(this.explicitPath);
+    for (const p of candidates) {
+      if (existsSync(p)) return p;
+    }
+    return null;
+  }
+
+  // ─── 내부 ────────────────────────────────────
+
+  private readFile(): AuthFile | null {
+    const candidates = candidatePaths(this.explicitPath);
+    for (const p of candidates) {
+      try {
+        if (!existsSync(p)) continue;
+        const text = readFileSync(p, "utf-8");
+        const parsed = JSON.parse(text) as AuthFile;
+        if (typeof parsed === "object" && parsed !== null) {
+          this.resolvedPath = p;
+          return parsed;
+        }
+      } catch {
+        // 다음 candidate 시도
+      }
+    }
+    return null;
+  }
+
+  private writeFile(data: AuthFile): void {
+    const path = this.resolvedPath ?? this.explicitPath ?? defaultWritePath();
+    const dir = dirname(path);
+    if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+    renameSync(tmp, path);
+    this.resolvedPath = path;
+  }
+
+  private async callTokenEndpoint(refreshToken: string): Promise<StoredTokens> {
+    const resp = await this.httpClient(this.tokenUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: this.clientId,
+        scope: "openid profile email offline_access",
+      }),
+    });
+    const text = await resp.text();
+    if (!resp.ok) {
+      throw new Error(`Token refresh ${resp.status}: ${text.slice(0, 300)}`);
+    }
+    let json: { access_token?: string; refresh_token?: string; id_token?: string };
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new Error(`Token refresh: invalid JSON: ${text.slice(0, 200)}`);
+    }
+    if (!json.access_token) {
+      throw new Error(`Token refresh: missing access_token: ${text}`);
+    }
+    return {
+      access_token: json.access_token,
+      refresh_token: json.refresh_token,
+      id_token: json.id_token,
+    };
+  }
+}
+
+// ─── 헬퍼 ─────────────────────────────────────
+
+function candidatePaths(explicit?: string): string[] {
+  if (explicit) return [explicit];
+  const out: string[] = [];
+  const env1 = process.env["CHATGPT_LOCAL_HOME"];
+  const env2 = process.env["CODEX_HOME"];
+  if (env1) out.push(join(env1, "auth.json"));
+  if (env2) out.push(join(env2, "auth.json"));
+  out.push(join(homedir(), ".chatgpt-local", "auth.json"));
+  out.push(join(homedir(), ".codex", "auth.json"));
+  return [...new Set(out)];
+}
+
+function defaultWritePath(): string {
+  return process.env["CHATGPT_LOCAL_HOME"]
+    ? join(process.env["CHATGPT_LOCAL_HOME"]!, "auth.json")
+    : process.env["CODEX_HOME"]
+      ? join(process.env["CODEX_HOME"]!, "auth.json")
+      : join(homedir(), ".chatgpt-local", "auth.json");
+}
+
+function deriveAccountId(idToken?: string): string | undefined {
+  if (!idToken || !idToken.includes(".")) return undefined;
+  const parts = idToken.split(".");
+  if (parts.length < 2 || !parts[1]) return undefined;
+  try {
+    const padded = parts[1] + "=".repeat(((-parts[1].length % 4) + 4) % 4);
+    const payload = JSON.parse(
+      Buffer.from(padded, "base64url").toString("utf-8"),
+    ) as Record<string, unknown>;
+    const auth = payload["https://api.openai.com/auth"];
+    if (typeof auth === "object" && auth !== null && "chatgpt_account_id" in auth) {
+      const id = (auth as Record<string, unknown>)["chatgpt_account_id"];
+      if (typeof id === "string" && id.length > 0) return id;
+    }
+  } catch {
+    // ignore
+  }
+  return undefined;
+}
+
+function shouldRefresh(accessToken: string, lastRefreshIso: string | undefined): boolean {
+  // JWT exp 클레임으로 우선 판단
+  const claims = parseJwtClaims(accessToken);
+  if (claims && typeof claims["exp"] === "number") {
+    const expMs = (claims["exp"] as number) * 1000;
+    if (expMs <= Date.now() + REFRESH_EXPIRY_MARGIN_MS) return true;
+  }
+  // last_refresh 기반 휴리스틱 (55분 초과)
+  if (lastRefreshIso) {
+    const last = Date.parse(lastRefreshIso);
+    if (!Number.isNaN(last) && Date.now() - last > 55 * 60 * 1000) return true;
+  }
+  return false;
+}
+
+function parseJwtClaims(token: string): Record<string, unknown> | undefined {
+  if (!token.includes(".")) return undefined;
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts[1]) return undefined;
+  try {
+    const padded = parts[1] + "=".repeat(((-parts[1].length % 4) + 4) % 4);
+    const payload = JSON.parse(Buffer.from(padded, "base64url").toString("utf-8"));
+    return typeof payload === "object" && payload !== null
+      ? (payload as Record<string, unknown>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/brain/adapters/index.ts

@@ -25,6 +25,7 @@ export * from "./ollama";
 export * from "./openai-oauth";
 export * from "./anthropic-oauth";
 export * from "./oauth-flow";
+export * from "./chatgpt-auth";
 
 import { type LLMAdapter, NoopAdapter } from "./base";
 import { OllamaAdapter, createOllamaAdapter } from "./ollama";

package/src/brain/adapters/openai-oauth.ts

@@ -1,11 +1,21 @@
 /**
  * Brain — OpenAI OAuth adapter (Issue #235).
  *
- * Connects to the OpenAI Chat Completions API using a token obtained
- * via OAuth authorization code + PKCE. Mandu never owns an OpenAI API
- * key — the user's OAuth credentials are loaded from the OS keychain
- * (`packages/core/src/brain/credentials.ts`) and forwarded on each
- * request.
+ * Connects to the OpenAI Chat Completions API using a ChatGPT session
+ * token. Mandu NEVER owns an OpenAI OAuth app — we reuse the OpenAI
+ * official `@openai/codex` CLI's login flow. First-time login:
+ *
+ *     npx @openai/codex login          # (or `mandu brain login`)
+ *
+ * OpenAI handles the browser OAuth handshake and writes the token to
+ * `~/.codex/auth.json`. This adapter reads that file via
+ * `ChatGPTAuth`, auto-refreshes the access token on expiry, and
+ * forwards the resulting Bearer to `api.openai.com/v1/chat/completions`.
+ *
+ * Legacy code in this file (`runAuthorizationCodeFlow` + keychain
+ * `CredentialStore`) remains available for `mandu brain login` flows
+ * that opt into a custom OAuth app (e.g. enterprise proxies), but the
+ * default path is now the ChatGPT session token.
  *
  * Failure modes handled here:
  *   - Missing token            → adapter reports `available: false`, the
@@ -50,6 +60,7 @@ import {
   type HttpClient,
   type OAuthEndpoints,
 } from "./oauth-flow";
+import { ChatGPTAuth, type EffectiveAuth } from "./chatgpt-auth";
 
 /* -------------------------------------------------------------------- */
 /* Defaults                                                             */
@@ -98,7 +109,7 @@ export const DEFAULT_OPENAI_CONFIG: AdapterConfig = {
 export interface OpenAIOAuthAdapterOptions extends Partial<AdapterConfig> {
   /** Injection point — tests supply an in-memory fetch stub. */
   httpClient?: HttpClient;
-  /** Injection point — tests swap in a canned endpoint pair. */
+  /** Injection point — tests swap in a canned endpoint pair (legacy flow only). */
   endpoints?: OAuthEndpoints;
   /** OAuth client id override (for enterprise OpenAI proxies). */
   clientId?: string;
@@ -118,6 +129,18 @@ export interface OpenAIOAuthAdapterOptions extends Partial<AdapterConfig> {
    * command to loudly fail if the flow never wrote a token.
    */
   strict?: boolean;
+  /**
+   * ChatGPT session-token auth helper. Default: reads
+   * `~/.codex/auth.json` / `~/.chatgpt-local/auth.json` produced by
+   * `npx @openai/codex login`. Tests inject a helper pointed at a
+   * throwaway fixture path.
+   */
+  chatgptAuth?: ChatGPTAuth;
+  /**
+   * Override: explicit path to the ChatGPT auth.json. Only used when
+   * `chatgptAuth` is not supplied.
+   */
+  chatgptAuthFilePath?: string;
 }
 
 /* -------------------------------------------------------------------- */
@@ -136,6 +159,7 @@ export class OpenAIOAuthAdapter extends BaseLLMAdapter {
   private consentDeps?: ConsentPromptDeps;
   private strict: boolean;
   private refreshInFlight: Promise<StoredToken | null> | null = null;
+  private chatgptAuth: ChatGPTAuth;
 
   constructor(options: OpenAIOAuthAdapterOptions = {}) {
     super({
@@ -152,23 +176,38 @@ export class OpenAIOAuthAdapter extends BaseLLMAdapter {
     this.skipConsent = options.skipConsent ?? false;
     this.consentDeps = options.consentDeps;
     this.strict = options.strict ?? false;
+    this.chatgptAuth =
+      options.chatgptAuth ??
+      new ChatGPTAuth({
+        authFilePath: options.chatgptAuthFilePath,
+        httpClient: this.httpClient,
+      });
   }
 
   /* ----------------------- Status / login ---------------------------- */
 
   async checkStatus(): Promise<AdapterStatus> {
+    // Primary path — ChatGPT session token from `@openai/codex login`.
+    if (this.chatgptAuth.isAuthenticated()) {
+      return {
+        available: true,
+        model: this.config.model,
+      };
+    }
+    // Legacy fallback — custom Mandu OAuth app token stored in keychain.
     const token = await this.credentialStore.load("openai");
-    if (!token) {
+    if (token) {
       return {
-        available: false,
-        model: null,
-        error:
-          "No OpenAI OAuth token stored. Run `mandu brain login --provider=openai` first.",
+        available: true,
+        model: this.config.model,
       };
     }
     return {
-      available: true,
-      model: this.config.model,
+      available: false,
+      model: null,
+      error:
+        "No OpenAI OAuth token found. Run `mandu brain login --provider=openai` " +
+        "(which wraps `npx @openai/codex login`) first.",
     };
   }
 
@@ -219,8 +258,18 @@ export class OpenAIOAuthAdapter extends BaseLLMAdapter {
     messages: ChatMessage[],
     options: CompletionOptions = {},
   ): Promise<CompletionResult> {
-    const token = await this.loadTokenOrReject();
-    if (!token) {
+    // Primary: ChatGPT session token (managed by `@openai/codex login`).
+    let chatgpt: EffectiveAuth | null = null;
+    if (this.chatgptAuth.isAuthenticated()) {
+      try {
+        chatgpt = await this.chatgptAuth.getAuth();
+      } catch {
+        chatgpt = null;
+      }
+    }
+    // Legacy keychain fallback only if ChatGPT auth unavailable.
+    const token = chatgpt ? null : await this.loadTokenOrReject();
+    if (!chatgpt && !token) {
       if (this.strict) {
         throw new Error(
           "OpenAIOAuthAdapter.complete() called without a stored token",
@@ -273,27 +322,48 @@ export class OpenAIOAuthAdapter extends BaseLLMAdapter {
     }
 
     // First attempt — fresh token.
-    let attemptToken = token.access_token;
+    let attemptToken = chatgpt ? chatgpt.accessToken : token!.access_token;
     let result = await this.callChatApi(
       attemptToken,
       redactedMessages,
       options,
     );
-    if (result.status === 401 && token.refresh_token) {
-      const refreshed = await this.trySilentRefresh(token);
-      if (refreshed) {
-        attemptToken = refreshed.access_token;
-        result = await this.callChatApi(
-          attemptToken,
-          redactedMessages,
-          options,
-        );
+    if (result.status === 401) {
+      if (chatgpt) {
+        // ChatGPTAuth auto-refreshes via JWT exp; a 401 here means even
+        // the refreshed token was rejected. Force a re-read (which will
+        // trigger another refresh if needed) and retry once.
+        try {
+          const refreshed = await this.chatgptAuth.getAuth();
+          attemptToken = refreshed.accessToken;
+          result = await this.callChatApi(
+            attemptToken,
+            redactedMessages,
+            options,
+          );
+        } catch {
+          /* fall through to 401 handling */
+        }
+      } else if (token!.refresh_token) {
+        const refreshed = await this.trySilentRefresh(token!);
+        if (refreshed) {
+          attemptToken = refreshed.access_token;
+          result = await this.callChatApi(
+            attemptToken,
+            redactedMessages,
+            options,
+          );
+        }
       }
     }
     if (result.status === 401) {
-      // Persistent auth failure — scrub the token so subsequent runs
-      // skip straight to the next resolver tier.
-      await this.credentialStore.delete("openai");
+      if (!chatgpt) {
+        // Persistent auth failure on the legacy keychain path — scrub so
+        // subsequent runs skip to the next resolver tier. For the
+        // ChatGPTAuth path we leave auth.json alone (the user re-runs
+        // `codex login`; we must not race their session).
+        await this.credentialStore.delete("openai");
+      }
       return emptyCompletion();
     }
     if (!result.ok) {
@@ -301,7 +371,7 @@ export class OpenAIOAuthAdapter extends BaseLLMAdapter {
         `OpenAI request failed (${result.status}): ${result.bodySnippet}`,
       );
     }
-    await this.credentialStore.touch("openai");
+    if (!chatgpt) await this.credentialStore.touch("openai");
     return result.completion;
   }