@askalf/dario 5.5.83 → 5.5.85

package/README.md

@@ -18,7 +18,7 @@
 
 <p><strong>One local endpoint. Every AI tool you own. The subscription you already pay for.</strong></p>
 
-<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~25k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
+<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~26k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
 
 <sub>Part of <a href="#own-your-stack"><strong>Own Your Stack</strong></a> — 12 open tools for owning your AI infra: <a href="https://github.com/askalf/truecopy">truecopy</a> · <a href="https://github.com/askalf/strongroom">strongroom</a> · <a href="https://github.com/askalf/fieldpass">fieldpass</a> · <a href="https://github.com/askalf/plumbline">plumbline</a> · <a href="#own-your-stack">full family ↓</a></sub>
 
@@ -121,6 +121,7 @@ You point every tool at one URL. dario reads each request, decides which backend
 | Anthropic Messages | `claude-*` / `opus` / `sonnet` / `haiku` | Claude backend | OAuth swap + CC template → `api.anthropic.com` |
 | Anthropic Messages | `gpt-*`, `llama-*`, … | OpenAI-compat backend | Anthropic→OpenAI translation, forwarded |
 | OpenAI Chat | `gpt-*` / `o1-*` / `o3-*` | OpenAI-compat backend | Auth swap, body forwarded byte-for-byte |
+| OpenAI Chat | a slug your ChatGPT account lists | Codex backend | chat/completions→Responses translation, subscription auth |
 | OpenAI Chat | `claude-*` | Claude backend | OpenAI→Anthropic translation, then Claude path |
 | Either | `<provider>:<model>` | Forced by prefix | Explicit override |
 
@@ -130,6 +131,34 @@ The tool doesn't know. The backend doesn't know. dario is the seam.
 
 ---
 
+## ChatGPT subscription accounts (Codex engine)
+
+Your ChatGPT Plus/Pro plan, served on dario's OpenAI-compatible endpoint — so any client or harness that speaks `/v1/chat/completions` can use it: Codex CLI, OpenClaw-style clients, the OpenAI SDKs, your own scripts.
+
+```bash
+dario codex add work        # prints an authorize URL; paste the redirect URL back
+dario codex list
+dario codex remove work
+```
+
+The browser lands on a `localhost` page that doesn't load — that's expected, nothing is listening there. Copy the whole address bar and paste it at the prompt; dario reads the code out of it. A bare code (or `code#state`) works too.
+
+Once an account is stored, an OpenAI-shape request naming a model that account may use is served from the subscription:
+
+```bash
+curl localhost:3456/v1/models | jq -r '.data[].id'
+curl localhost:3456/v1/chat/completions -H 'content-type: application/json' \
+  -d '{"model":"gpt-5.5","messages":[{"role":"user","content":"hi"}]}'
+```
+
+**Model names are discovered, not hardcoded.** The set a ChatGPT subscription may use is per-account and moves; dario asks the backend which models this account lists, caches the answer, and advertises them on `GET /v1/models` so a client's model picker finds them. Anything not on that list — `gpt-4o` and friends — is untouched and still routes to a configured API-key backend as before. `codex:<model>` / `chatgpt:<model>` forces the route explicitly.
+
+Streaming, tool calls, and tool-result round trips work: dario translates chat/completions to the Responses API the subscription backend speaks, and translates the stream back to `chat.completion.chunk`. Inbound is chat/completions only — there is no `/v1/responses` inbound yet.
+
+Codex accounts live in `~/.dario/codex-accounts/`, entirely separate from the Claude pool. Nothing about `dario login`, `dario accounts`, or Claude routing changes.
+
+---
+
 ## Multi-account pool
 
 **In v5 every dario is a pool** — a plain `dario login` is a pool of one, no separate mode to switch on. One Claude subscription has a ceiling; hold more than one seat — a personal Max and a work Max, a couple of Pros, team seats — and the same `localhost:3456` routes every request to whichever seat has the most headroom, live, per request. A single `dario accounts add` even bootstraps a servable proxy with no `dario login` step:
@@ -274,7 +303,7 @@ Ongoing discussion, including other users' experiences: [#724](https://github.co
 
 ## Commands
 
-`dario` (TUI) · `login` · `proxy` · `doctor` · `accounts {list,add,remove}` · `backend {list,add,remove}` · `mcp` · `subagent {install,status,remove}` · `usage` · `config` · `upgrade` · `status` · `refresh` · `resume` · `logout` · `help`
+`dario` (TUI) · `login` · `proxy` · `doctor` · `accounts {list,add,remove}` · `backend {list,add,remove}` · `codex {list,add,remove}` · `mcp` · `subagent {install,status,remove}` · `usage` · `config` · `upgrade` · `status` · `refresh` · `resume` · `logout` · `help`
 
 Per-flag reference: [`docs/commands.md`](./docs/commands.md) · env vars grouped by task, for Docker / k8s / systemd: [`docs/configuration.md`](./docs/configuration.md) · SDK examples + per-tool setup: [`docs/usage.md`](./docs/usage.md)
 

package/dist/cli.js

@@ -21,10 +21,11 @@ import { realpathSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { startAutoOAuthFlow, startManualOAuthFlow, detectHeadlessEnvironment, getStatus, refreshTokens, loadCredentials } from './oauth.js';
+import { startAutoOAuthFlow, startManualOAuthFlow, detectHeadlessEnvironment, getStatus, refreshTokens, loadCredentials, readLineFromStdin } from './oauth.js';
 import { startProxy, sanitizeError, parseModelAliasSpecs } from './proxy.js';
 import { VALID_EFFORT_VALUES } from './cc-template.js';
 import { listAccountAliases, loadAllAccounts, addAccountViaOAuth, addAccountViaManualOAuth, addAccountFromKeychain, KeychainImportError, removeAccount, ensureLoginCredentialsInPool, resyncLoginFromCredentialsIfStale, MIGRATED_LOGIN_ALIAS } from './accounts.js';
+import { listCodexAccountAliases, loadAllCodexAccounts, startAddCodexAccount, completeAddCodexAccount, removeCodexAccount, parseCodexManualPaste } from './codex-accounts.js';
 import { listBackends, saveBackend, removeBackend } from './openai-backend.js';
 import { parseOutboundProxy, installOutboundProxyWrapper } from './outbound-proxy.js';
 // `args` / `command` at module scope — command handlers below close over
@@ -1067,6 +1068,108 @@ async function accounts() {
     console.error('Usage: dario accounts [list|add <alias>|remove <alias>]');
     process.exit(1);
 }
+/**
+ * The "altman" engine (dario#1009) — a Codex/ChatGPT-subscription account
+ * pool, structurally parallel to `accounts()` above but for a fully
+ * separate provider. Manual-paste only (no localhost callback server):
+ * simpler, and matches the flow OpenAI's own `codex` CLI already trains
+ * users on. Accounts added here serve /v1/chat/completions requests naming a
+ * model the ChatGPT backend lists for them — see codex-backend.ts.
+ */
+async function codex() {
+    const sub = args[1];
+    if (!sub || sub === 'list') {
+        const aliases = await listCodexAccountAliases();
+        console.log('');
+        console.log('  dario — Codex accounts (altman engine)');
+        console.log('  ───────────────────────────────────────');
+        console.log('');
+        if (aliases.length === 0) {
+            console.log('  No Codex accounts yet.');
+            console.log('    dario codex add <alias>');
+            console.log('');
+            return;
+        }
+        const loaded = await loadAllCodexAccounts();
+        const now = Date.now();
+        console.log(`  ${aliases.length} account${aliases.length === 1 ? '' : 's'}`);
+        console.log('');
+        for (const a of loaded) {
+            const msLeft = Math.max(0, a.expiresAt - now);
+            const mins = Math.floor(msLeft / 60000);
+            const expiry = msLeft > 0 ? `${mins}m` : 'expired';
+            console.log(`    ${a.alias.padEnd(20)} token expires in ${expiry}`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'add') {
+        const alias = args[2];
+        if (!alias) {
+            console.error('');
+            console.error('  Usage: dario codex add <alias>');
+            console.error('');
+            process.exit(1);
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(alias)) {
+            console.error('[dario] Invalid alias. Use letters, numbers, dot, underscore, dash only.');
+            process.exit(1);
+        }
+        const existing = await listCodexAccountAliases();
+        if (existing.includes(alias)) {
+            console.error(`[dario] Codex account "${alias}" already exists. Remove it first with \`dario codex remove ${alias}\`.`);
+            process.exit(1);
+        }
+        const { authorizeUrl, codeVerifier } = await startAddCodexAccount(alias);
+        console.log('');
+        console.log('  Open this URL and log in with your ChatGPT Plus/Pro account.');
+        console.log('  The browser will land on a localhost page that does not load —');
+        console.log('  that is expected. Copy the whole address bar and paste it here:');
+        console.log('');
+        console.log(`  ${authorizeUrl}`);
+        console.log('');
+        const pasted = await readLineFromStdin('  Redirect URL (or code): ');
+        const { code } = parseCodexManualPaste(pasted);
+        if (!code) {
+            console.error('[dario] No code found in what you pasted.');
+            process.exit(1);
+        }
+        try {
+            await completeAddCodexAccount(alias, code, codeVerifier);
+            console.log('');
+            console.log(`  Added Codex account "${alias}".`);
+            console.log('  A proxy that is already running picks it up within ~30s —');
+            console.log('  no restart needed (dario#1138).');
+            console.log('');
+        }
+        catch (err) {
+            console.error(`[dario] Failed to add Codex account: ${err.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (sub === 'remove' || sub === 'rm') {
+        const alias = args[2];
+        if (!alias) {
+            console.error('');
+            console.error('  Usage: dario codex remove <alias>');
+            console.error('');
+            process.exit(1);
+        }
+        const ok = await removeCodexAccount(alias);
+        if (ok) {
+            console.log(`[dario] Codex account "${alias}" removed.`);
+        }
+        else {
+            console.error(`[dario] No Codex account "${alias}" found.`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.error(`[dario] Unknown codex subcommand: ${sub}`);
+    console.error('Usage: dario codex [list|add <alias>|remove <alias>]');
+    process.exit(1);
+}
 async function backend() {
     const sub = args[1];
     if (!sub || sub === 'list') {
@@ -1202,6 +1305,11 @@ async function help() {
                              entry by its platform identifier (Linux account
                              attribute, Windows TargetName).
     dario accounts remove N  Remove an account from the pool
+    dario codex list         List ChatGPT-subscription accounts, served on
+                             /v1/chat/completions.
+    dario codex add NAME     Add a ChatGPT-subscription account (prints an
+                             authorize URL; paste the redirect URL back).
+    dario codex remove NAME  Remove a ChatGPT-subscription account.
     dario backend list       List configured OpenAI-compat backends
     dario backend add NAME --key=sk-... [--base-url=...]
                              Add an OpenAI-compat backend (OpenAI, OpenRouter, Groq, etc.)
@@ -2129,6 +2237,7 @@ const commands = {
     resume,
     logout,
     accounts,
+    codex,
     backend,
     shim,
     subagent,

package/dist/codex-accounts.d.ts

@@ -0,0 +1,60 @@
+export interface CodexAccountCredentials {
+    alias: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    idToken?: string;
+}
+export declare function listCodexAccountAliases(): Promise<string[]>;
+export declare function hasAnyCodexAccount(nowMs?: number): Promise<boolean>;
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export declare function _resetCodexPresenceCacheForTest(): void;
+export declare function loadCodexAccount(alias: string): Promise<CodexAccountCredentials | null>;
+export declare function loadAllCodexAccounts(): Promise<CodexAccountCredentials[]>;
+export declare function saveCodexAccount(creds: CodexAccountCredentials): Promise<void>;
+export declare function removeCodexAccount(alias: string): Promise<boolean>;
+export declare function getCodexAccountsDir(): string;
+export declare function startAddCodexAccount(alias: string): Promise<{
+    authorizeUrl: string;
+    codeVerifier: string;
+    state: string;
+}>;
+export declare function completeAddCodexAccount(alias: string, code: string, codeVerifier: string): Promise<CodexAccountCredentials>;
+export declare function codexAccountNeedsRefresh(creds: CodexAccountCredentials): boolean;
+export declare function refreshCodexAccount(creds: CodexAccountCredentials): Promise<CodexAccountCredentials>;
+/**
+ * Return credentials guaranteed fresh enough to send upstream, refreshing (once,
+ * per alias, per process) when within the expiry buffer.
+ */
+export declare function getFreshCodexAccount(creds: CodexAccountCredentials): Promise<CodexAccountCredentials>;
+/**
+ * Pick the account to serve a request. Single account is the expected case (one
+ * ChatGPT subscription); with several, `DARIO_CODEX_ACCOUNT` names one and
+ * otherwise the first alphabetically wins. No rotation/least-recently-used
+ * balancing — a subscription is per-seat, so spreading load across seats is the
+ * user's decision to make explicitly, not something to do implicitly.
+ */
+export declare function selectCodexAccount(preferredAlias?: string): Promise<CodexAccountCredentials | null>;
+/**
+ * Parse whatever the user pastes back after authorizing.
+ *
+ * Three accepted shapes, because all three are what people actually have on
+ * their clipboard:
+ *
+ *   1. the FULL redirect URL out of the browser address bar —
+ *      `http://localhost:1455/auth/callback?code=…&state=…`. This is the
+ *      common one: the manual-paste flow starts no listener on 1455, so the
+ *      browser lands on a connection error and the address bar is the only
+ *      place the code is visible. The first live login failed exactly here.
+ *   2. `code#state`, the fragment-joined form the Claude flow's success page
+ *      renders (parseManualPaste in oauth.ts).
+ *   3. a bare code.
+ *
+ * Codex-local rather than shared with oauth.ts: the Claude flow has no
+ * redirect-URL shape to parse, and its parser is on the login path for every
+ * user of the Claude engine.
+ */
+export declare function parseCodexManualPaste(input: string): {
+    code: string;
+    state: string | null;
+};

package/dist/codex-accounts.js

@@ -0,0 +1,260 @@
+/**
+ * Codex account storage — the "altman" engine (dario#1009).
+ *
+ * Deliberately isolated from accounts.ts: separate directory
+ * (~/.dario/codex-accounts/), separate types, no shared code path with the
+ * Claude pool — in particular none of the pool/lock/lease machinery, which
+ * a live race test showed this provider does not need (see the
+ * getFreshCodexAccount comment below). Request routing lives in
+ * provider-adapter.ts + codex-backend.ts; this module owns credentials on
+ * disk and the selection/refresh in front of them.
+ */
+import { readFile, mkdir, readdir, unlink } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { generateCodexPKCE, buildCodexAuthorizeUrl, exchangeCodexAuthorizationCode, refreshCodexAccessToken, } from './codex-oauth.js';
+import { durableWriteFile } from './durable-write.js';
+const DARIO_DIR = join(homedir(), '.dario');
+const CODEX_ACCOUNTS_DIR = join(DARIO_DIR, 'codex-accounts');
+/** Same alias charset/traversal guard as accounts.ts's safeAliasPath. */
+function safeAliasPath(alias) {
+    if (typeof alias !== 'string' || alias.length === 0)
+        return null;
+    const leaf = basename(alias);
+    if (leaf !== alias)
+        return null;
+    if (leaf === '.' || leaf === '..')
+        return null;
+    if (!/^[A-Za-z0-9][A-Za-z0-9_\-.]{0,63}$/.test(leaf))
+        return null;
+    return join(CODEX_ACCOUNTS_DIR, `${leaf}.json`);
+}
+async function ensureDir() {
+    await mkdir(CODEX_ACCOUNTS_DIR, { recursive: true, mode: 0o700 });
+}
+export async function listCodexAccountAliases() {
+    try {
+        await ensureDir();
+        const entries = await readdir(CODEX_ACCOUNTS_DIR);
+        return entries.filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * "Is the codex route available at all" — the routing question, asked per
+ * request rather than once at startup (dario#1138).
+ *
+ * The proxy used to resolve this a single time while booting, so an account
+ * stored by `dario codex add` against an ALREADY-RUNNING proxy stayed
+ * invisible until a restart: /v1/models advertised no gpt slugs and a listed
+ * slug fell through to the Claude path as an unknown model. `dario login`
+ * restarts the proxy by convention, `dario codex add` does not.
+ *
+ * Cheap enough to ask often — a readdir of a directory holding at most a
+ * handful of files — but an idle proxy still shouldn't hit the filesystem on
+ * every request, so the NEGATIVE answer is cached briefly. The positive one
+ * isn't cached: the caller goes on to read the credentials anyway, and a
+ * `codex remove` has to take effect immediately.
+ */
+const CODEX_PRESENCE_NEGATIVE_TTL_MS = 30_000;
+let codexAbsentUntil = 0;
+export async function hasAnyCodexAccount(nowMs = Date.now()) {
+    if (nowMs < codexAbsentUntil)
+        return false;
+    const present = (await listCodexAccountAliases()).length > 0;
+    codexAbsentUntil = present ? 0 : nowMs + CODEX_PRESENCE_NEGATIVE_TTL_MS;
+    return present;
+}
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export function _resetCodexPresenceCacheForTest() {
+    codexAbsentUntil = 0;
+}
+export async function loadCodexAccount(alias) {
+    const path = safeAliasPath(alias);
+    if (!path)
+        return null;
+    try {
+        const raw = await readFile(path, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadAllCodexAccounts() {
+    const aliases = await listCodexAccountAliases();
+    const loaded = await Promise.all(aliases.map(a => loadCodexAccount(a)));
+    return loaded.filter((a) => a !== null);
+}
+export async function saveCodexAccount(creds) {
+    const path = safeAliasPath(creds.alias);
+    if (!path)
+        throw new Error(`invalid codex account alias: ${creds.alias}`);
+    await ensureDir();
+    await durableWriteFile(path, JSON.stringify(creds, null, 2), 0o600);
+    // An account stored in THIS process (`dario codex add` in a running admin
+    // path, or a test) must not be hidden by a negative cache entry taken
+    // moments earlier.
+    codexAbsentUntil = 0;
+}
+export async function removeCodexAccount(alias) {
+    const path = safeAliasPath(alias);
+    if (!path)
+        return false;
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getCodexAccountsDir() {
+    return CODEX_ACCOUNTS_DIR;
+}
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export async function startAddCodexAccount(alias) {
+    if (!safeAliasPath(alias)) {
+        throw new Error(`invalid account alias "${alias}" (allowed: letters, digits, _-. — up to 64 chars, no path separators)`);
+    }
+    const { codeVerifier, codeChallenge } = generateCodexPKCE();
+    const state = base64url(randomBytes(32));
+    const authorizeUrl = buildCodexAuthorizeUrl(codeChallenge, state);
+    return { authorizeUrl, codeVerifier, state };
+}
+export async function completeAddCodexAccount(alias, code, codeVerifier) {
+    if (!safeAliasPath(alias)) {
+        throw new Error(`invalid account alias "${alias}"`);
+    }
+    const tokens = await exchangeCodexAuthorizationCode(code, codeVerifier);
+    const creds = {
+        alias,
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt,
+        idToken: tokens.idToken,
+    };
+    await saveCodexAccount(creds);
+    return creds;
+}
+/**
+ * Refresh 30 min before expiry — same buffer as oauth.ts's Claude path.
+ * No single-flight or distributed-lock wrapping here (unlike accounts.ts's
+ * refreshAccountToken) — see codex-oauth.ts's header for why.
+ */
+const REFRESH_BUFFER_MS = 30 * 60 * 1000;
+export function codexAccountNeedsRefresh(creds) {
+    return Date.now() >= creds.expiresAt - REFRESH_BUFFER_MS;
+}
+export async function refreshCodexAccount(creds) {
+    const tokens = await refreshCodexAccessToken(creds.refreshToken);
+    const updated = {
+        ...creds,
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt,
+        idToken: tokens.idToken,
+    };
+    await saveCodexAccount(updated);
+    return updated;
+}
+/**
+ * In-process refresh serialization.
+ *
+ * dario#1010's open question is answered: test/manual/codex-refresh-race.mjs
+ * was run twice against a live ChatGPT Plus account and came back TOLERANT both
+ * times — two concurrent refreshes of the same refresh_token BOTH succeed, and
+ * each returns a different new refresh_token. OpenAI does not invalidate the
+ * previous one. So Codex needs none of the Claude engine's pool/lock/lease
+ * machinery (#993/#1008): no Durable Object, no Redis, nothing cross-process.
+ *
+ * What's left is purely an efficiency concern — N concurrent requests arriving
+ * on an expiring token shouldn't fire N identical refresh calls. One in-memory
+ * promise per alias collapses them. If a second dario process refreshes the same
+ * account at the same time, both simply succeed; last writer wins on disk and
+ * the other process's token stays valid until its own expiry.
+ */
+const inflightRefresh = new Map();
+/**
+ * Return credentials guaranteed fresh enough to send upstream, refreshing (once,
+ * per alias, per process) when within the expiry buffer.
+ */
+export async function getFreshCodexAccount(creds) {
+    if (!codexAccountNeedsRefresh(creds))
+        return creds;
+    const existing = inflightRefresh.get(creds.alias);
+    if (existing)
+        return existing;
+    const p = refreshCodexAccount(creds).finally(() => {
+        inflightRefresh.delete(creds.alias);
+    });
+    inflightRefresh.set(creds.alias, p);
+    return p;
+}
+/**
+ * Pick the account to serve a request. Single account is the expected case (one
+ * ChatGPT subscription); with several, `DARIO_CODEX_ACCOUNT` names one and
+ * otherwise the first alphabetically wins. No rotation/least-recently-used
+ * balancing — a subscription is per-seat, so spreading load across seats is the
+ * user's decision to make explicitly, not something to do implicitly.
+ */
+export async function selectCodexAccount(preferredAlias) {
+    const alias = preferredAlias || process.env.DARIO_CODEX_ACCOUNT;
+    if (alias) {
+        const one = await loadCodexAccount(alias);
+        if (one)
+            return one;
+    }
+    const all = await loadAllCodexAccounts();
+    if (all.length === 0)
+        return null;
+    return [...all].sort((a, b) => a.alias.localeCompare(b.alias))[0];
+}
+/**
+ * Parse whatever the user pastes back after authorizing.
+ *
+ * Three accepted shapes, because all three are what people actually have on
+ * their clipboard:
+ *
+ *   1. the FULL redirect URL out of the browser address bar —
+ *      `http://localhost:1455/auth/callback?code=…&state=…`. This is the
+ *      common one: the manual-paste flow starts no listener on 1455, so the
+ *      browser lands on a connection error and the address bar is the only
+ *      place the code is visible. The first live login failed exactly here.
+ *   2. `code#state`, the fragment-joined form the Claude flow's success page
+ *      renders (parseManualPaste in oauth.ts).
+ *   3. a bare code.
+ *
+ * Codex-local rather than shared with oauth.ts: the Claude flow has no
+ * redirect-URL shape to parse, and its parser is on the login path for every
+ * user of the Claude engine.
+ */
+export function parseCodexManualPaste(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return { code: '', state: null };
+    if (/^https?:\/\//i.test(trimmed)) {
+        try {
+            const url = new URL(trimmed);
+            return {
+                code: url.searchParams.get('code') ?? '',
+                state: url.searchParams.get('state'),
+            };
+        }
+        catch {
+            return { code: '', state: null };
+        }
+    }
+    const hashIdx = trimmed.indexOf('#');
+    if (hashIdx === -1)
+        return { code: trimmed, state: null };
+    return {
+        code: trimmed.slice(0, hashIdx).trim(),
+        state: trimmed.slice(hashIdx + 1).trim(),
+    };
+}

package/dist/codex-backend.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Codex backend — request path for the "altman" engine (dario#1009/#1010).
+ *
+ * The ChatGPT subscription is NOT an api.openai.com API key: it can't be used
+ * with `Authorization: Bearer sk-…` against the public API. OpenAI's own `codex`
+ * CLI sends the OAuth access_token as a bearer to the ChatGPT Codex backend's
+ * Responses endpoint, with the workspace id from the id_token as a header.
+ * Mirrored from the CLI source rather than guessed:
+ *
+ *   base URL   codex-rs/model-provider-info/src/lib.rs
+ *              `CHATGPT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"`
+ *              (used as the default base_url whenever auth_mode is Chatgpt)
+ *   wire api   same file, `WireApi::Responses` — "the Responses API exposed by
+ *              OpenAI at /v1/responses", i.e. `${base}/responses`
+ *   headers    codex-rs/model-provider/src/bearer_auth_provider.rs
+ *              `Authorization: Bearer <access_token>` + `ChatGPT-Account-ID: <id>`
+ *   account id codex-rs/login/src/token_data.rs — id_token claim
+ *              `https://api.openai.com/auth`.chatgpt_account_id
+ *
+ * dario's inbound is OpenAI chat/completions — what any OpenAI-compatible
+ * client speaks — so this module owns the chat/completions ⇄ Responses
+ * translation in both directions, including SSE.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { CodexAccountCredentials } from './codex-accounts.js';
+export declare const CODEX_BACKEND_BASE_URL: string;
+/**
+ * Client version sent on the model-discovery call. The backend REQUIRES the
+ * `client_version` query parameter and rejects the request without it; the
+ * value tracks a released codex CLI. Bump it when the backend starts gating on
+ * a newer one — it is a constant precisely so that stays a one-line change.
+ */
+export declare const CODEX_CLIENT_VERSION: string;
+/** Test seam — drop the discovery cache. */
+export declare function clearCodexModelCache(): void;
+/**
+ * Slugs the backend lists for this account. `visibility` separates models meant
+ * for a picker ("list") from internal ones ("hide" — e.g. `gpt-reserve`,
+ * `codex-auto-review`); only listed ones are routable and advertisable.
+ * Throws on a non-2xx or unparseable response; getCodexModelSlugs absorbs it.
+ */
+export declare function fetchCodexModels(creds: CodexAccountCredentials, fetchImpl?: typeof fetch): Promise<readonly string[]>;
+/**
+ * Cached {@link fetchCodexModels}, keyed by account alias. Never throws — an
+ * unreachable backend yields the last known set, or an empty one, which means
+ * "route nothing here by name". An explicit `codex:`/`chatgpt:` prefix still
+ * routes, so discovery being down never makes the engine unusable.
+ */
+export declare function getCodexModelSlugs(creds: CodexAccountCredentials, fetchImpl?: typeof fetch): Promise<readonly string[]>;
+/**
+ * Whether a request naming `model` should be served from the subscription: the
+ * name matches a discovered slug. Pure, with the slugs injected, so routing is
+ * testable without network — and checked BEFORE openai-backend's
+ * `isOpenAIModel` (the codex adapter has the higher priority), so a discovered
+ * `gpt-5.5` reaches the subscription while a plain `gpt-4o` still reaches a
+ * configured API-key backend.
+ */
+export declare function isCodexModel(model: string, slugs: readonly string[]): boolean;
+/**
+ * Pull `chatgpt_account_id` out of the id_token's `https://api.openai.com/auth`
+ * claim. Payload only — this is reading our own token for a routing header, not
+ * validating a token, so there's nothing to verify a signature against here.
+ * Null when the token is absent/malformed/claimless; the caller then omits the
+ * header, which is what the CLI does for accounts without a workspace.
+ */
+export declare function extractChatGPTAccountId(idToken: string | undefined): string | null;
+/**
+ * Translate an OpenAI chat/completions request body into a Responses request.
+ *
+ * - system messages collapse into `instructions` (Responses has no system role)
+ * - assistant `tool_calls` become `function_call` items, `role: "tool"` replies
+ *   become `function_call_output` items, keyed by the same call_id
+ * - tools lose the `{type:'function', function:{…}}` nesting; Responses takes
+ *   name/description/parameters flat on the tool
+ * - `store: false` because dario is a proxy: nothing here is a ChatGPT thread
+ *   the user would expect to find in their history
+ */
+export declare function chatCompletionsToResponses(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Stateful per-request translator: Responses SSE in, chat/completions out.
+ *
+ * `chunk()` returns the chat.completion.chunk SSE line to write back (null when
+ * the upstream event has no chat-shape equivalent — reasoning summaries,
+ * progress events). It also accumulates, so `complete()` can hand back a single
+ * non-streaming `chat.completion` body. dario always asks the Codex backend for
+ * a stream and collapses it here when the client didn't want one; that keeps one
+ * upstream code path instead of two.
+ *
+ * One translator per request — never module-global — for the same reason
+ * createOpenAIStreamTranslator is per-call (#642-audit: interleaved streams
+ * corrupting shared tool-call indices).
+ */
+export declare function createResponsesTranslator(model: string): {
+    /** Feed one raw SSE line. Returns the line to forward, or null. */
+    chunk(line: string): string | null;
+    /** Everything seen so far, as one non-streaming chat.completion body. */
+    complete(): Record<string, unknown>;
+};
+export declare function buildCodexHeaders(creds: CodexAccountCredentials): Record<string, string>;
+/**
+ * Serve a /v1/chat/completions request from a stored Codex account.
+ *
+ * `fetchImpl` is injectable so the translation and header construction are
+ * testable without network (test/codex-backend.mjs), matching the pattern
+ * test/codex-oauth.mjs already uses.
+ */
+export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse, body: Buffer, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, fetchImpl?: typeof fetch): Promise<void>;