@sumicom/quicksave 0.8.1 → 0.8.3

package/dist/ai/codexAppServer/stdioTransport.js

@@ -0,0 +1,111 @@
+import { createInterface } from 'node:readline';
+/**
+ * Stdio transport for the codex `app-server` child process. Frames
+ * messages as JSONL on stdin/stdout — one JSON object per line.
+ *
+ * This wrapper is intentionally narrow: it does NOT spawn the child
+ * (that's `processManager.ts`) or run the JSON-RPC protocol (that's
+ * `rpcClient.ts`). It just translates between line-buffered JSON and
+ * structured messages.
+ */
+export class StdioTransport {
+    child;
+    messageListeners = new Set();
+    closeListeners = new Set();
+    closed = false;
+    /** Logger for parse failures and stderr lines. The default no-ops so
+     * tests stay quiet; real users should pass a console-bound logger. */
+    log;
+    constructor(child, opts = {}) {
+        if (!child.stdin || !child.stdout) {
+            throw new Error('StdioTransport requires a child process with stdin and stdout pipes');
+        }
+        this.child = child;
+        this.log = opts.log ?? { warn: () => { } };
+        const rl = createInterface({ input: child.stdout });
+        rl.on('line', (line) => this.handleLine(line));
+        rl.on('close', () => this.handleClose(null));
+        child.on('exit', (code, signal) => {
+            const reason = code === 0 || code === null
+                ? null
+                : new Error(`codex app-server exited with code=${code} signal=${signal ?? 'none'}`);
+            this.handleClose(reason);
+        });
+        child.on('error', (err) => this.handleClose(err));
+    }
+    async send(message) {
+        if (this.closed)
+            throw new Error('stdio transport closed');
+        const stdin = this.child.stdin;
+        if (!stdin || stdin.destroyed)
+            throw new Error('stdio transport stdin unavailable');
+        const line = JSON.stringify(message) + '\n';
+        return new Promise((resolve, reject) => {
+            stdin.write(line, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    onMessage(listener) {
+        this.messageListeners.add(listener);
+        return () => this.messageListeners.delete(listener);
+    }
+    onClose(listener) {
+        this.closeListeners.add(listener);
+        return () => this.closeListeners.delete(listener);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.handleClose(null);
+        try {
+            this.child.stdin?.end();
+        }
+        catch {
+            // best-effort
+        }
+    }
+    handleLine(line) {
+        if (line.length === 0)
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            this.log.warn(`codex app-server: failed to parse JSON-RPC line: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        if (typeof parsed !== 'object' || parsed === null) {
+            this.log.warn(`codex app-server: ignoring non-object JSON-RPC line: ${typeof parsed}`);
+            return;
+        }
+        for (const l of this.messageListeners) {
+            try {
+                l(parsed);
+            }
+            catch {
+                // listeners must not throw; swallow.
+            }
+        }
+    }
+    handleClose(reason) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const l of this.closeListeners) {
+            try {
+                l(reason);
+            }
+            catch {
+                // swallow
+            }
+        }
+        this.messageListeners.clear();
+        this.closeListeners.clear();
+    }
+}
+//# sourceMappingURL=stdioTransport.js.map

package/dist/ai/codexAppServer/stdioTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdioTransport.js","sourceRoot":"","sources":["../../../src/ai/codexAppServer/stdioTransport.ts"],"names":[],"mappings":"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"}

package/dist/ai/codexAppServer/tokenAccounting.d.ts

@@ -0,0 +1,76 @@
+import type { CardStreamEnd } from '@sumicom/quicksave-shared';
+import type { ThreadTokenUsage } from './schema/generated/v2/ThreadTokenUsage.js';
+import type { ThreadTokenUsageUpdatedNotification } from './schema/generated/v2/ThreadTokenUsageUpdatedNotification.js';
+import type { TokenUsageBreakdown } from './schema/generated/v2/TokenUsageBreakdown.js';
+/**
+ * Cumulative seed loaded from `eventStore` on cold resume so per-turn
+ * deltas line up after a daemon restart. Mirrors the SDK provider's
+ * `loadCumulativeSeed` shape so we can swap providers without touching
+ * the eventStore round-trip.
+ */
+export interface CumulativeUsageSeed {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+}
+/**
+ * Tracks `thread/tokenUsage/updated` notifications and produces the
+ * `tokenUsage` block for `CardStreamEnd` at `turn/completed` time.
+ *
+ * Key facts about v2's token usage model (verified against codex CLI
+ * 0.125.0 — see `docs/references/codex-app-server/implementation-plan.md`
+ * §11):
+ *
+ * - `ThreadTokenUsageUpdatedNotification.tokenUsage.last` is the
+ *   **per-turn delta** the server already computed. We pass it through
+ *   directly — no slice math required.
+ * - `tokenUsage.total` is the running thread-cumulative. We expose it
+ *   on `CardStreamEnd.tokenUsage.cumulative*` so the eventStore can
+ *   round-trip it for cold resumes.
+ * - The notification carries `turnId` so we can key updates per-turn
+ *   even when several arrive between `turn/started` and `turn/completed`.
+ *
+ * Ordering: typically the latest `thread/tokenUsage/updated` precedes
+ * `turn/completed` for that turn, but not always. The provider's run
+ * loop should `awaitFor(turnId)` briefly when finalizing — see
+ * `awaitTurnUsage()`.
+ */
+export declare class TokenAccounting {
+    /** Latest cumulative we believe the server has, regardless of which
+     * turn supplied it. Persisted to eventStore via the run path. */
+    private cumulative;
+    /** Latest `tokenUsage` payload keyed by turnId. */
+    private byTurn;
+    /** Pending awaiters waiting for a usage notification on a specific turn. */
+    private waiters;
+    seedFromLastTurn(seed: CumulativeUsageSeed | null | undefined): void;
+    /**
+     * Feed a `thread/tokenUsage/updated` notification. Updates the
+     * running cumulative and per-turn caches, and resolves any active
+     * waiters.
+     */
+    observe(notification: ThreadTokenUsageUpdatedNotification): void;
+    /**
+     * Wait for a `thread/tokenUsage/updated` notification carrying
+     * `turnId`. Resolves immediately if one was already observed.
+     * Resolves to `null` if `timeoutMs` elapses first (the run loop
+     * should still emit `CardStreamEnd` — better an empty usage block
+     * than a hung turn).
+     */
+    awaitTurnUsage(turnId: string, timeoutMs: number): Promise<ThreadTokenUsage | null>;
+    /** Drop any state for a turn — call after stream-end is emitted to
+     * keep the per-turn cache from growing unboundedly. */
+    releaseTurn(turnId: string): void;
+    /** Map a `ThreadTokenUsage` payload to the `CardStreamEnd.tokenUsage`
+     * shape. Returns undefined when the input is null. */
+    static toCardStreamEndUsage(usage: ThreadTokenUsage | null | undefined): CardStreamEnd['tokenUsage'];
+    /** Snapshot the running cumulative — used by the run path to
+     * persist `LastTurnInfo` after every successful turn end. */
+    snapshotCumulative(): CumulativeUsageSeed;
+}
+/** Build a synthetic `ThreadTokenUsage` from a per-turn breakdown plus
+ * a precomputed cumulative — used in tests. */
+export declare function makeUsage(last: TokenUsageBreakdown, total: TokenUsageBreakdown, modelContextWindow?: number | null): ThreadTokenUsage;
+/** Build a `TokenUsageBreakdown` literal — used in tests. */
+export declare function makeBreakdown(input: number, output: number, cachedInput?: number): TokenUsageBreakdown;
+//# sourceMappingURL=tokenAccounting.d.ts.map

package/dist/ai/codexAppServer/tokenAccounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenAccounting.d.ts","sourceRoot":"","sources":["../../../src/ai/codexAppServer/tokenAccounting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,8DAA8D,CAAC;AACxH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAExF;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,eAAe;IAC1B;qEACiE;IACjE,OAAO,CAAC,UAAU,CAIhB;IAEF,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAuC;IAErD,4EAA4E;IAC5E,OAAO,CAAC,OAAO,CAA+D;IAE9E,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IASpE;;;;OAIG;IACH,OAAO,CAAC,YAAY,EAAE,mCAAmC,GAAG,IAAI;IAchE;;;;;;OAMG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAuBnF;2DACuD;IACvD,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKjC;0DACsD;IACtD,MAAM,CAAC,oBAAoB,CACzB,KAAK,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GACzC,aAAa,CAAC,YAAY,CAAC;IAW9B;iEAC6D;IAC7D,kBAAkB,IAAI,mBAAmB;CAG1C;AAED;+CAC+C;AAC/C,wBAAgB,SAAS,CACvB,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,mBAAmB,EAC1B,kBAAkB,GAAE,MAAM,GAAG,IAAW,GACvC,gBAAgB,CAElB;AAED,6DAA6D;AAC7D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,mBAAmB,CAQjG"}

package/dist/ai/codexAppServer/tokenAccounting.js

@@ -0,0 +1,135 @@
+/**
+ * Tracks `thread/tokenUsage/updated` notifications and produces the
+ * `tokenUsage` block for `CardStreamEnd` at `turn/completed` time.
+ *
+ * Key facts about v2's token usage model (verified against codex CLI
+ * 0.125.0 — see `docs/references/codex-app-server/implementation-plan.md`
+ * §11):
+ *
+ * - `ThreadTokenUsageUpdatedNotification.tokenUsage.last` is the
+ *   **per-turn delta** the server already computed. We pass it through
+ *   directly — no slice math required.
+ * - `tokenUsage.total` is the running thread-cumulative. We expose it
+ *   on `CardStreamEnd.tokenUsage.cumulative*` so the eventStore can
+ *   round-trip it for cold resumes.
+ * - The notification carries `turnId` so we can key updates per-turn
+ *   even when several arrive between `turn/started` and `turn/completed`.
+ *
+ * Ordering: typically the latest `thread/tokenUsage/updated` precedes
+ * `turn/completed` for that turn, but not always. The provider's run
+ * loop should `awaitFor(turnId)` briefly when finalizing — see
+ * `awaitTurnUsage()`.
+ */
+export class TokenAccounting {
+    /** Latest cumulative we believe the server has, regardless of which
+     * turn supplied it. Persisted to eventStore via the run path. */
+    cumulative = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+    };
+    /** Latest `tokenUsage` payload keyed by turnId. */
+    byTurn = new Map();
+    /** Pending awaiters waiting for a usage notification on a specific turn. */
+    waiters = new Map();
+    seedFromLastTurn(seed) {
+        if (!seed)
+            return;
+        this.cumulative = {
+            inputTokens: seed.inputTokens,
+            outputTokens: seed.outputTokens,
+            cachedInputTokens: seed.cachedInputTokens ?? 0,
+        };
+    }
+    /**
+     * Feed a `thread/tokenUsage/updated` notification. Updates the
+     * running cumulative and per-turn caches, and resolves any active
+     * waiters.
+     */
+    observe(notification) {
+        this.byTurn.set(notification.turnId, notification.tokenUsage);
+        this.cumulative = {
+            inputTokens: notification.tokenUsage.total.inputTokens,
+            outputTokens: notification.tokenUsage.total.outputTokens,
+            cachedInputTokens: notification.tokenUsage.total.cachedInputTokens,
+        };
+        const ws = this.waiters.get(notification.turnId);
+        if (ws) {
+            this.waiters.delete(notification.turnId);
+            for (const w of ws)
+                w(notification.tokenUsage);
+        }
+    }
+    /**
+     * Wait for a `thread/tokenUsage/updated` notification carrying
+     * `turnId`. Resolves immediately if one was already observed.
+     * Resolves to `null` if `timeoutMs` elapses first (the run loop
+     * should still emit `CardStreamEnd` — better an empty usage block
+     * than a hung turn).
+     */
+    awaitTurnUsage(turnId, timeoutMs) {
+        const cached = this.byTurn.get(turnId);
+        if (cached)
+            return Promise.resolve(cached);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                const arr = this.waiters.get(turnId);
+                if (arr) {
+                    const idx = arr.indexOf(onUsage);
+                    if (idx >= 0)
+                        arr.splice(idx, 1);
+                    if (arr.length === 0)
+                        this.waiters.delete(turnId);
+                }
+                resolve(null);
+            }, timeoutMs);
+            const onUsage = (usage) => {
+                clearTimeout(timer);
+                resolve(usage);
+            };
+            const arr = this.waiters.get(turnId) ?? [];
+            arr.push(onUsage);
+            this.waiters.set(turnId, arr);
+        });
+    }
+    /** Drop any state for a turn — call after stream-end is emitted to
+     * keep the per-turn cache from growing unboundedly. */
+    releaseTurn(turnId) {
+        this.byTurn.delete(turnId);
+        this.waiters.delete(turnId);
+    }
+    /** Map a `ThreadTokenUsage` payload to the `CardStreamEnd.tokenUsage`
+     * shape. Returns undefined when the input is null. */
+    static toCardStreamEndUsage(usage) {
+        if (!usage)
+            return undefined;
+        return {
+            input: usage.last.inputTokens,
+            output: usage.last.outputTokens,
+            cumulativeInput: usage.total.inputTokens,
+            cumulativeOutput: usage.total.outputTokens,
+            cumulativeCachedInput: usage.total.cachedInputTokens,
+        };
+    }
+    /** Snapshot the running cumulative — used by the run path to
+     * persist `LastTurnInfo` after every successful turn end. */
+    snapshotCumulative() {
+        return { ...this.cumulative };
+    }
+}
+/** Build a synthetic `ThreadTokenUsage` from a per-turn breakdown plus
+ * a precomputed cumulative — used in tests. */
+export function makeUsage(last, total, modelContextWindow = null) {
+    return { last, total, modelContextWindow };
+}
+/** Build a `TokenUsageBreakdown` literal — used in tests. */
+export function makeBreakdown(input, output, cachedInput = 0) {
+    return {
+        totalTokens: input + output,
+        inputTokens: input,
+        cachedInputTokens: cachedInput,
+        outputTokens: output,
+        reasoningOutputTokens: 0,
+    };
+}
+//# sourceMappingURL=tokenAccounting.js.map

package/dist/ai/codexAppServer/tokenAccounting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenAccounting.js","sourceRoot":"","sources":["../../../src/ai/codexAppServer/tokenAccounting.ts"],"names":[],"mappings":"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"}

package/dist/ai/codexAppServer/version.d.ts

@@ -0,0 +1,7 @@
+/** Codex CLI version that the vendored schema under
+ * `schema/generated/` was generated from. The schema must be
+ * regenerated (see `apps/agent/scripts/regen-codex-schema.sh`)
+ * whenever this is bumped. ProcessManager warns if the running CLI
+ * differs by minor or major. */
+export declare const CODEX_SCHEMA_PINNED_VERSION = "0.125.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/ai/codexAppServer/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/ai/codexAppServer/version.ts"],"names":[],"mappings":"AAAA;;;;gCAIgC;AAChC,eAAO,MAAM,2BAA2B,YAAY,CAAC"}

package/dist/ai/codexAppServer/version.js

@@ -0,0 +1,7 @@
+/** Codex CLI version that the vendored schema under
+ * `schema/generated/` was generated from. The schema must be
+ * regenerated (see `apps/agent/scripts/regen-codex-schema.sh`)
+ * whenever this is bumped. ProcessManager warns if the running CLI
+ * differs by minor or major. */
+export const CODEX_SCHEMA_PINNED_VERSION = '0.125.0';
+//# sourceMappingURL=version.js.map

package/dist/ai/codexAppServer/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../src/ai/codexAppServer/version.ts"],"names":[],"mappings":"AAAA;;;;gCAIgC;AAChC,MAAM,CAAC,MAAM,2BAA2B,GAAG,SAAS,CAAC"}

package/dist/ai/codexLogin.d.ts

@@ -0,0 +1,57 @@
+import type { CodexLoginState } from '@sumicom/quicksave-shared';
+export type CodexLoginUpdateHandler = (state: CodexLoginState) => void;
+export declare class CodexLoginManager {
+    private state;
+    private child;
+    private parseTimer;
+    private stdoutBuf;
+    private onUpdate?;
+    setUpdateHandler(handler: CodexLoginUpdateHandler | undefined): void;
+    /**
+     * Returns a fresh snapshot of login status. Consults the filesystem each
+     * call so a login completed out-of-band (user ran `codex login` in their
+     * terminal) is detected without restarting the daemon.
+     */
+    getStatus(): Promise<CodexLoginState>;
+    /**
+     * Start a device-auth login flow. Spawns `codex login --device-auth`,
+     * parses its stdout for the verification URL + user code, and returns
+     * once both are available (or the CLI exits / times out).
+     */
+    start(): Promise<CodexLoginState>;
+    /**
+     * Cancel an in-progress login. Safe to call when nothing is running —
+     * returns the current state unchanged.
+     */
+    cancel(): CodexLoginState;
+    private handleExit;
+    private handleError;
+    private cleanup;
+    private emit;
+    /** Test-only: inject output as if the spawned CLI printed it. */
+    _debugFeed(chunk: string): void;
+}
+/**
+ * Parse `codex login --device-auth` stdout.
+ *
+ * Sample (ANSI escapes stripped):
+ *
+ *     Welcome to Codex [v0.118.0]
+ *     OpenAI's command-line coding agent
+ *
+ *     Follow these steps to sign in with ChatGPT using device code authorization:
+ *
+ *     1. Open this link in your browser and sign in to your account
+ *        https://auth.openai.com/codex/device
+ *
+ *     2. Enter this one-time code (expires in 15 minutes)
+ *        YKFF-30JQC
+ *
+ * We look for the first bare https URL and the first XXXX-XXXX code token.
+ * Returns null until both have appeared.
+ */
+export declare function parseDeviceAuthOutput(raw: string): {
+    verificationUrl: string;
+    userCode: string;
+} | null;
+//# sourceMappingURL=codexLogin.d.ts.map

package/dist/ai/codexLogin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codexLogin.d.ts","sourceRoot":"","sources":["../../src/ai/codexLogin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AA4BjE,MAAM,MAAM,uBAAuB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEvE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAA2D;IACxE,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,CAA0B;IAE3C,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,SAAS,GAAG,IAAI;IAIpE;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC;IAe3C;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAqEvC;;;OAGG;IACH,MAAM,IAAI,eAAe;IAczB,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,IAAI;IAIZ,iEAAiE;IACjE,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAchC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMvG"}

package/dist/ai/codexLogin.js

@@ -0,0 +1,240 @@
+import { spawn } from 'child_process';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Coordinates `codex login --device-auth` on behalf of the PWA. The daemon
+ * spawns the codex CLI, parses the one-time verification URL and user code
+ * from its stdout, and exposes them to the PWA so the user can complete the
+ * flow on whatever device they have at hand (typically a phone).
+ *
+ * Only one login attempt runs at a time. Subsequent `start()` calls while
+ * inProgress return the existing state — the same URL / code the first
+ * caller already has, which is what we want when the PWA reconnects
+ * mid-flow and re-requests the status.
+ */
+/** Device codes expire after 15 minutes per the OpenAI device-auth protocol. */
+const DEVICE_CODE_TTL_MS = 15 * 60 * 1000;
+/** Abandon if the CLI hasn't emitted a code within this window. Longer than
+ *  device-code TTL so a slow OAuth provider still surfaces the code rather
+ *  than us killing the process prematurely. */
+const PARSE_TIMEOUT_MS = 30_000;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+// Observed codex CLI codes are 4-5 chars per half (e.g. `YKFF-30JQC`). Allow
+// a small range on each side so a protocol change doesn't silently break
+// parsing, while the uppercase-only constraint keeps false positives low.
+const CODE_RE = /\b([A-Z0-9]{3,6}-[A-Z0-9]{3,6})\b/;
+const URL_RE = /https?:\/\/[^\s]+/;
+export class CodexLoginManager {
+    state = { loggedIn: false, inProgress: false };
+    child = null;
+    parseTimer = null;
+    stdoutBuf = '';
+    onUpdate;
+    setUpdateHandler(handler) {
+        this.onUpdate = handler;
+    }
+    /**
+     * Returns a fresh snapshot of login status. Consults the filesystem each
+     * call so a login completed out-of-band (user ran `codex login` in their
+     * terminal) is detected without restarting the daemon.
+     */
+    async getStatus() {
+        const auth = await detectAuth();
+        if (auth.loggedIn) {
+            // A prior in-progress flow may have succeeded; clear the transient fields.
+            this.state = {
+                loggedIn: true,
+                inProgress: false,
+                method: auth.method,
+            };
+            return { ...this.state };
+        }
+        // Preserve the in-progress details so a reconnecting PWA sees the same code.
+        return { ...this.state, loggedIn: false };
+    }
+    /**
+     * Start a device-auth login flow. Spawns `codex login --device-auth`,
+     * parses its stdout for the verification URL + user code, and returns
+     * once both are available (or the CLI exits / times out).
+     */
+    async start() {
+        const current = await this.getStatus();
+        if (current.loggedIn)
+            return current;
+        if (this.state.inProgress && this.state.userCode) {
+            return { ...this.state };
+        }
+        // Reset and spawn.
+        this.cleanup();
+        this.state = { loggedIn: false, inProgress: true };
+        this.emit();
+        const child = spawn('codex', ['login', '--device-auth'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        this.child = child;
+        this.stdoutBuf = '';
+        // Resolves once we've parsed URL + code from stdout, or once the parse
+        // timer fires, or once the process exits early.
+        const parsed = new Promise((resolve) => {
+            let settled = false;
+            const settle = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (this.parseTimer)
+                    clearTimeout(this.parseTimer);
+                this.parseTimer = null;
+                resolve();
+            };
+            const onStdout = (chunk) => {
+                this.stdoutBuf += chunk.toString('utf-8');
+                const parsedState = parseDeviceAuthOutput(this.stdoutBuf);
+                if (parsedState && (this.state.verificationUrl !== parsedState.verificationUrl ||
+                    this.state.userCode !== parsedState.userCode)) {
+                    this.state = {
+                        loggedIn: false,
+                        inProgress: true,
+                        verificationUrl: parsedState.verificationUrl,
+                        userCode: parsedState.userCode,
+                        expiresAt: Date.now() + DEVICE_CODE_TTL_MS,
+                    };
+                    this.emit();
+                    settle();
+                }
+            };
+            child.stdout?.on('data', onStdout);
+            // Codex prints the login instructions to stdout, but some distros may
+            // tee to stderr — tail it too so we don't miss a working flow.
+            child.stderr?.on('data', onStdout);
+            child.once('exit', (code) => this.handleExit(code));
+            child.once('error', (err) => this.handleError(err.message || 'spawn failed'));
+            this.parseTimer = setTimeout(() => {
+                if (!this.state.userCode) {
+                    this.handleError('Timed out waiting for device code from `codex login --device-auth`');
+                    child.kill('SIGTERM');
+                }
+                settle();
+            }, PARSE_TIMEOUT_MS);
+        });
+        await parsed;
+        return { ...this.state };
+    }
+    /**
+     * Cancel an in-progress login. Safe to call when nothing is running —
+     * returns the current state unchanged.
+     */
+    cancel() {
+        if (this.child) {
+            try {
+                this.child.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+        }
+        this.cleanup();
+        this.state = {
+            loggedIn: false,
+            inProgress: false,
+            error: 'cancelled',
+        };
+        this.emit();
+        return { ...this.state };
+    }
+    handleExit(code) {
+        const wasInProgress = this.state.inProgress;
+        this.cleanup();
+        void detectAuth().then((auth) => {
+            if (auth.loggedIn) {
+                this.state = { loggedIn: true, inProgress: false, method: auth.method };
+            }
+            else if (wasInProgress) {
+                this.state = {
+                    loggedIn: false,
+                    inProgress: false,
+                    error: code === 0
+                        ? 'Login exited without credentials'
+                        : `codex login exited with code ${code ?? 'unknown'}`,
+                };
+            }
+            this.emit();
+        });
+    }
+    handleError(message) {
+        this.cleanup();
+        this.state = { loggedIn: false, inProgress: false, error: message };
+        this.emit();
+    }
+    cleanup() {
+        if (this.parseTimer) {
+            clearTimeout(this.parseTimer);
+            this.parseTimer = null;
+        }
+        this.child = null;
+        this.stdoutBuf = '';
+    }
+    emit() {
+        try {
+            this.onUpdate?.({ ...this.state });
+        }
+        catch { /* ignore handler errors */ }
+    }
+    /** Test-only: inject output as if the spawned CLI printed it. */
+    _debugFeed(chunk) {
+        this.stdoutBuf += chunk;
+        const parsedState = parseDeviceAuthOutput(this.stdoutBuf);
+        if (parsedState) {
+            this.state = {
+                loggedIn: false,
+                inProgress: true,
+                verificationUrl: parsedState.verificationUrl,
+                userCode: parsedState.userCode,
+                expiresAt: Date.now() + DEVICE_CODE_TTL_MS,
+            };
+            this.emit();
+        }
+    }
+}
+/**
+ * Parse `codex login --device-auth` stdout.
+ *
+ * Sample (ANSI escapes stripped):
+ *
+ *     Welcome to Codex [v0.118.0]
+ *     OpenAI's command-line coding agent
+ *
+ *     Follow these steps to sign in with ChatGPT using device code authorization:
+ *
+ *     1. Open this link in your browser and sign in to your account
+ *        https://auth.openai.com/codex/device
+ *
+ *     2. Enter this one-time code (expires in 15 minutes)
+ *        YKFF-30JQC
+ *
+ * We look for the first bare https URL and the first XXXX-XXXX code token.
+ * Returns null until both have appeared.
+ */
+export function parseDeviceAuthOutput(raw) {
+    const plain = raw.replace(ANSI_RE, '');
+    const urlMatch = plain.match(URL_RE);
+    const codeMatch = plain.match(CODE_RE);
+    if (!urlMatch || !codeMatch)
+        return null;
+    return { verificationUrl: urlMatch[0], userCode: codeMatch[1] };
+}
+async function detectAuth() {
+    if (process.env.OPENAI_API_KEY)
+        return { loggedIn: true, method: 'api-key' };
+    try {
+        const authPath = join(homedir(), '.codex', 'auth.json');
+        const raw = await readFile(authPath, 'utf-8');
+        const auth = JSON.parse(raw);
+        if (auth.OPENAI_API_KEY)
+            return { loggedIn: true, method: 'api-key' };
+        if (auth.tokens?.access_token)
+            return { loggedIn: true, method: 'chatgpt' };
+    }
+    catch { /* no auth file */ }
+    return { loggedIn: false };
+}
+//# sourceMappingURL=codexLogin.js.map