@wingman-ai/gateway 0.5.3 → 0.5.4

package/dist/tests/cli-workspace-root.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/cli-workspace-root.test.js

@@ -1,108 +0,0 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { resolveWorkspaceRoot } from "../cli/core/workspace.js";
-describe("resolveWorkspaceRoot", ()=>{
-    let sandbox;
-    beforeEach(()=>{
-        sandbox = join(tmpdir(), `wingman-workspace-${Date.now()}-${Math.random()}`);
-        mkdirSync(sandbox, {
-            recursive: true
-        });
-    });
-    afterEach(()=>{
-        if (existsSync(sandbox)) rmSync(sandbox, {
-            recursive: true,
-            force: true
-        });
-    });
-    it("uses explicit workspace override when provided", ()=>{
-        const startDir = join(sandbox, "repo", "apps", "wingman");
-        mkdirSync(startDir, {
-            recursive: true
-        });
-        const resolved = resolveWorkspaceRoot(startDir, "../..");
-        expect(resolved).toBe(resolve(startDir, "../.."));
-    });
-    it("finds nearest ancestor with .wingman/wingman.config.json", ()=>{
-        const workspaceRoot = join(sandbox, "repo");
-        const nestedDir = join(workspaceRoot, "apps", "wingman", "src");
-        mkdirSync(join(workspaceRoot, ".wingman"), {
-            recursive: true
-        });
-        mkdirSync(nestedDir, {
-            recursive: true
-        });
-        writeFileSync(join(workspaceRoot, ".wingman", "wingman.config.json"), JSON.stringify({
-            logLevel: "info"
-        }));
-        const resolved = resolveWorkspaceRoot(nestedDir);
-        expect(resolved).toBe(workspaceRoot);
-    });
-    it("finds nearest ancestor with .wingman/agents marker", ()=>{
-        const workspaceRoot = join(sandbox, "repo");
-        const nestedDir = join(workspaceRoot, "packages", "cli");
-        mkdirSync(join(workspaceRoot, ".wingman", "agents"), {
-            recursive: true
-        });
-        mkdirSync(nestedDir, {
-            recursive: true
-        });
-        const resolved = resolveWorkspaceRoot(nestedDir);
-        expect(resolved).toBe(workspaceRoot);
-    });
-    it("does not search above git root when workspace markers are missing", ()=>{
-        const parentRoot = join(sandbox, "parent");
-        const gitRoot = join(parentRoot, "repo");
-        const nestedDir = join(gitRoot, "apps", "wingman");
-        mkdirSync(join(parentRoot, ".wingman"), {
-            recursive: true
-        });
-        mkdirSync(join(gitRoot, ".git"), {
-            recursive: true
-        });
-        mkdirSync(nestedDir, {
-            recursive: true
-        });
-        writeFileSync(join(parentRoot, ".wingman", "wingman.config.json"), JSON.stringify({
-            logLevel: "info"
-        }));
-        const resolved = resolveWorkspaceRoot(nestedDir);
-        expect(resolved).toBe(nestedDir);
-    });
-    it("falls back to nested apps/wingman workspace from repo root", ()=>{
-        const repoRoot = join(sandbox, "repo");
-        const nestedWorkspace = join(repoRoot, "apps", "wingman");
-        mkdirSync(join(repoRoot, ".git"), {
-            recursive: true
-        });
-        mkdirSync(join(nestedWorkspace, ".wingman"), {
-            recursive: true
-        });
-        writeFileSync(join(nestedWorkspace, ".wingman", "wingman.config.json"), JSON.stringify({
-            logLevel: "info"
-        }));
-        const resolved = resolveWorkspaceRoot(repoRoot);
-        expect(resolved).toBe(nestedWorkspace);
-    });
-    it("falls back to nested apps/wingman workspace from sibling app directory", ()=>{
-        const repoRoot = join(sandbox, "repo");
-        const startDir = join(repoRoot, "apps", "docs-website");
-        const nestedWorkspace = join(repoRoot, "apps", "wingman");
-        mkdirSync(join(repoRoot, ".git"), {
-            recursive: true
-        });
-        mkdirSync(startDir, {
-            recursive: true
-        });
-        mkdirSync(join(nestedWorkspace, ".wingman"), {
-            recursive: true
-        });
-        writeFileSync(join(nestedWorkspace, ".wingman", "wingman.config.json"), JSON.stringify({
-            logLevel: "info"
-        }));
-        const resolved = resolveWorkspaceRoot(startDir);
-        expect(resolved).toBe(nestedWorkspace);
-    });
-});

package/dist/tests/codex-credentials-precedence.test.cjs

@@ -1,94 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_os_namespaceObject = require("node:os");
-const external_node_path_namespaceObject = require("node:path");
-const external_vitest_namespaceObject = require("vitest");
-(0, external_vitest_namespaceObject.describe)("codex credential precedence", ()=>{
-    let homeDir;
-    let codexHome;
-    const originalHome = process.env.HOME;
-    const originalCodexHome = process.env.CODEX_HOME;
-    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
-    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
-    (0, external_vitest_namespaceObject.beforeEach)(()=>{
-        homeDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-home-"));
-        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-home-"));
-        process.env.HOME = homeDir;
-        process.env.CODEX_HOME = codexHome;
-        delete process.env.CODEX_ACCESS_TOKEN;
-        delete process.env.CHATGPT_ACCESS_TOKEN;
-    });
-    (0, external_vitest_namespaceObject.afterEach)(()=>{
-        if (void 0 === originalHome) delete process.env.HOME;
-        else process.env.HOME = originalHome;
-        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
-        else process.env.CODEX_HOME = originalCodexHome;
-        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
-        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
-        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
-        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
-        if ((0, external_node_fs_namespaceObject.existsSync)(homeDir)) (0, external_node_fs_namespaceObject.rmSync)(homeDir, {
-            recursive: true,
-            force: true
-        });
-        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
-            recursive: true,
-            force: true
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
-        external_vitest_namespaceObject.vi.resetModules();
-        const credentials = await import("../providers/credentials.cjs");
-        const codex = await import("../providers/codex.cjs");
-        const credsPath = credentials.getCredentialsPath();
-        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(credsPath), {
-            recursive: true
-        });
-        (0, external_node_fs_namespaceObject.writeFileSync)(credsPath, JSON.stringify({
-            version: 1,
-            updatedAt: new Date().toISOString(),
-            providers: {
-                codex: {
-                    apiKey: "stale-wingman-token"
-                }
-            }
-        }, null, 2));
-        const authPath = codex.getCodexAuthPath();
-        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
-            recursive: true
-        });
-        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
-            tokens: {
-                access_token: "codex-file-token",
-                account_id: "acct_123"
-            }
-        }, null, 2));
-        const resolved = credentials.resolveProviderToken("codex");
-        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("codex-file-token");
-        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("credentials");
-    });
-    (0, external_vitest_namespaceObject.it)("still prefers env vars over Codex auth file", async ()=>{
-        process.env.CODEX_ACCESS_TOKEN = "env-token";
-        external_vitest_namespaceObject.vi.resetModules();
-        const credentials = await import("../providers/credentials.cjs");
-        const codex = await import("../providers/codex.cjs");
-        const authPath = codex.getCodexAuthPath();
-        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
-            recursive: true
-        });
-        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
-            tokens: {
-                access_token: "codex-file-token"
-            }
-        }, null, 2));
-        const resolved = credentials.resolveProviderToken("codex");
-        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("env-token");
-        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("env");
-        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)(authPath, "utf-8")).toContain("codex-file-token");
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/tests/codex-credentials-precedence.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/codex-credentials-precedence.test.js

@@ -1,88 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("codex credential precedence", ()=>{
-    let homeDir;
-    let codexHome;
-    const originalHome = process.env.HOME;
-    const originalCodexHome = process.env.CODEX_HOME;
-    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
-    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
-    beforeEach(()=>{
-        homeDir = mkdtempSync(join(tmpdir(), "wingman-home-"));
-        codexHome = mkdtempSync(join(tmpdir(), "wingman-codex-home-"));
-        process.env.HOME = homeDir;
-        process.env.CODEX_HOME = codexHome;
-        delete process.env.CODEX_ACCESS_TOKEN;
-        delete process.env.CHATGPT_ACCESS_TOKEN;
-    });
-    afterEach(()=>{
-        if (void 0 === originalHome) delete process.env.HOME;
-        else process.env.HOME = originalHome;
-        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
-        else process.env.CODEX_HOME = originalCodexHome;
-        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
-        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
-        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
-        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
-        if (existsSync(homeDir)) rmSync(homeDir, {
-            recursive: true,
-            force: true
-        });
-        if (existsSync(codexHome)) rmSync(codexHome, {
-            recursive: true,
-            force: true
-        });
-    });
-    it("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
-        vi.resetModules();
-        const credentials = await import("../providers/credentials.js");
-        const codex = await import("../providers/codex.js");
-        const credsPath = credentials.getCredentialsPath();
-        mkdirSync(dirname(credsPath), {
-            recursive: true
-        });
-        writeFileSync(credsPath, JSON.stringify({
-            version: 1,
-            updatedAt: new Date().toISOString(),
-            providers: {
-                codex: {
-                    apiKey: "stale-wingman-token"
-                }
-            }
-        }, null, 2));
-        const authPath = codex.getCodexAuthPath();
-        mkdirSync(dirname(authPath), {
-            recursive: true
-        });
-        writeFileSync(authPath, JSON.stringify({
-            tokens: {
-                access_token: "codex-file-token",
-                account_id: "acct_123"
-            }
-        }, null, 2));
-        const resolved = credentials.resolveProviderToken("codex");
-        expect(resolved.token).toBe("codex-file-token");
-        expect(resolved.source).toBe("credentials");
-    });
-    it("still prefers env vars over Codex auth file", async ()=>{
-        process.env.CODEX_ACCESS_TOKEN = "env-token";
-        vi.resetModules();
-        const credentials = await import("../providers/credentials.js");
-        const codex = await import("../providers/codex.js");
-        const authPath = codex.getCodexAuthPath();
-        mkdirSync(dirname(authPath), {
-            recursive: true
-        });
-        writeFileSync(authPath, JSON.stringify({
-            tokens: {
-                access_token: "codex-file-token"
-            }
-        }, null, 2));
-        const resolved = credentials.resolveProviderToken("codex");
-        expect(resolved.token).toBe("env-token");
-        expect(resolved.source).toBe("env");
-        expect(readFileSync(authPath, "utf-8")).toContain("codex-file-token");
-    });
-});

package/dist/tests/codex-provider.test.cjs

@@ -1,383 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_os_namespaceObject = require("node:os");
-const external_node_path_namespaceObject = require("node:path");
-const external_vitest_namespaceObject = require("vitest");
-const codex_cjs_namespaceObject = require("../providers/codex.cjs");
-(0, external_vitest_namespaceObject.describe)("codex provider", ()=>{
-    let codexHome;
-    const originalCodexHome = process.env.CODEX_HOME;
-    (0, external_vitest_namespaceObject.beforeEach)(()=>{
-        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-"));
-        process.env.CODEX_HOME = codexHome;
-        delete process.env.CODEX_ACCESS_TOKEN;
-        delete process.env.CHATGPT_ACCESS_TOKEN;
-    });
-    (0, external_vitest_namespaceObject.afterEach)(()=>{
-        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
-        else process.env.CODEX_HOME = originalCodexHome;
-        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
-            recursive: true,
-            force: true
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("reads access token and account id from codex auth file", ()=>{
-        writeCodexAuth({
-            tokens: {
-                access_token: "codex-access-token",
-                account_id: "acct_123"
-            }
-        });
-        const resolved = (0, codex_cjs_namespaceObject.resolveCodexAuthFromFile)();
-        (0, external_vitest_namespaceObject.expect)(resolved.accessToken).toBe("codex-access-token");
-        (0, external_vitest_namespaceObject.expect)(resolved.accountId).toBe("acct_123");
-        (0, external_vitest_namespaceObject.expect)(resolved.authPath).toBe((0, external_node_path_namespaceObject.join)(codexHome, "auth.json"));
-    });
-    (0, external_vitest_namespaceObject.it)("applies codex auth headers and forces store=false", async ()=>{
-        writeCodexAuth({
-            tokens: {
-                access_token: "file-token",
-                account_id: "acct_file"
-            }
-        });
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            headers: {
-                "x-api-key": "placeholder"
-            },
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello",
-                temperature: 1
-            })
-        });
-        (0, external_vitest_namespaceObject.expect)(baseFetch).toHaveBeenCalledTimes(1);
-        const requestInit = baseFetch.mock.calls[0]?.[1];
-        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
-        const headers = new Headers(requestInit?.headers);
-        const payload = JSON.parse(String(requestInit?.body));
-        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer file-token");
-        (0, external_vitest_namespaceObject.expect)(headers.get("chatgpt-account-id")).toBe("acct_file");
-        (0, external_vitest_namespaceObject.expect)(headers.get("x-api-key")).toBeNull();
-        (0, external_vitest_namespaceObject.expect)(payload.store).toBe(false);
-        (0, external_vitest_namespaceObject.expect)(payload.temperature).toBeUndefined();
-        (0, external_vitest_namespaceObject.expect)(typeof payload.instructions).toBe("string");
-        (0, external_vitest_namespaceObject.expect)(payload.instructions.length).toBeGreaterThan(0);
-    });
-    (0, external_vitest_namespaceObject.it)("derives instructions from system/developer input when missing", async ()=>{
-        writeCodexAuth({
-            tokens: {
-                access_token: "file-token"
-            }
-        });
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "gpt-5.3-codex",
-                input: [
-                    {
-                        role: "developer",
-                        content: [
-                            {
-                                type: "input_text",
-                                text: "Always run tests first."
-                            }
-                        ]
-                    },
-                    {
-                        role: "user",
-                        content: [
-                            {
-                                type: "input_text",
-                                text: "Fix the bug."
-                            }
-                        ]
-                    }
-                ]
-            })
-        });
-        const requestInit = baseFetch.mock.calls[0]?.[1];
-        const payload = JSON.parse(String(requestInit?.body));
-        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Always run tests first.");
-    });
-    (0, external_vitest_namespaceObject.it)("preserves explicit instructions when provided", async ()=>{
-        writeCodexAuth({
-            tokens: {
-                access_token: "file-token"
-            }
-        });
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "gpt-5.3-codex",
-                instructions: "Use concise answers.",
-                input: "hello"
-            })
-        });
-        const requestInit = baseFetch.mock.calls[0]?.[1];
-        const payload = JSON.parse(String(requestInit?.body));
-        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Use concise answers.");
-    });
-    (0, external_vitest_namespaceObject.it)("overrides explicit store values to false when provided", async ()=>{
-        writeCodexAuth({
-            tokens: {
-                access_token: "file-token"
-            }
-        });
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "gpt-5.3-codex",
-                store: true,
-                input: "hello"
-            })
-        });
-        const requestInit = baseFetch.mock.calls[0]?.[1];
-        const payload = JSON.parse(String(requestInit?.body));
-        (0, external_vitest_namespaceObject.expect)(payload.store).toBe(false);
-    });
-    (0, external_vitest_namespaceObject.it)("refreshes tokens when the codex access token is expiring", async ()=>{
-        const expiringAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 30000) / 1000),
-            client_id: "app_client_123"
-        });
-        const refreshedAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 86400000) / 1000),
-            client_id: "app_client_123"
-        });
-        const staleIdToken = createJwt({
-            aud: [
-                "app_client_123"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_old"
-            }
-        });
-        const refreshedIdToken = createJwt({
-            aud: [
-                "app_client_123"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_refreshed"
-            }
-        });
-        writeCodexAuth({
-            tokens: {
-                access_token: expiringAccessToken,
-                refresh_token: "refresh-old",
-                id_token: staleIdToken,
-                account_id: "acct_old"
-            }
-        });
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (input, init)=>{
-            const url = "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url;
-            if ("https://auth.openai.com/oauth/token" === url) {
-                const params = new URLSearchParams(String(init?.body ?? ""));
-                (0, external_vitest_namespaceObject.expect)(params.get("grant_type")).toBe("refresh_token");
-                (0, external_vitest_namespaceObject.expect)(params.get("refresh_token")).toBe("refresh-old");
-                (0, external_vitest_namespaceObject.expect)(params.get("client_id")).toBe("app_client_123");
-                return new Response(JSON.stringify({
-                    access_token: refreshedAccessToken,
-                    refresh_token: "refresh-new",
-                    id_token: refreshedIdToken,
-                    token_type: "bearer",
-                    expires_in: 864000
-                }), {
-                    status: 200,
-                    headers: {
-                        "content-type": "application/json"
-                    }
-                });
-            }
-            (0, external_vitest_namespaceObject.expect)(url).toBe("https://chatgpt.com/backend-api/codex/responses");
-            const headers = new Headers(init?.headers);
-            (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
-            (0, external_vitest_namespaceObject.expect)(headers.get("chatgpt-account-id")).toBe("acct_refreshed");
-            return new Response("{}", {
-                status: 200
-            });
-        });
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        });
-        (0, external_vitest_namespaceObject.expect)(baseFetch).toHaveBeenCalledTimes(2);
-        const persisted = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)((0, codex_cjs_namespaceObject.getCodexAuthPath)(), "utf-8"));
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.access_token).toBe(refreshedAccessToken);
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.refresh_token).toBe("refresh-new");
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.id_token).toBe(refreshedIdToken);
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.account_id).toBe("acct_refreshed");
-        (0, external_vitest_namespaceObject.expect)(typeof persisted.last_refresh).toBe("string");
-    });
-    (0, external_vitest_namespaceObject.it)("retries once after auth failure by refreshing codex token", async ()=>{
-        const initialAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 86400000) / 1000),
-            client_id: "app_client_retry"
-        });
-        const refreshedAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 172800000) / 1000),
-            client_id: "app_client_retry"
-        });
-        const idToken = createJwt({
-            aud: [
-                "app_client_retry"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_retry"
-            }
-        });
-        const refreshedIdToken = createJwt({
-            aud: [
-                "app_client_retry"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_retry_new"
-            }
-        });
-        writeCodexAuth({
-            tokens: {
-                access_token: initialAccessToken,
-                refresh_token: "refresh-retry",
-                id_token: idToken,
-                account_id: "acct_retry"
-            }
-        });
-        let codexCallCount = 0;
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (input, init)=>{
-            const url = "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url;
-            if ("https://auth.openai.com/oauth/token" === url) {
-                const params = new URLSearchParams(String(init?.body ?? ""));
-                (0, external_vitest_namespaceObject.expect)(params.get("grant_type")).toBe("refresh_token");
-                (0, external_vitest_namespaceObject.expect)(params.get("refresh_token")).toBe("refresh-retry");
-                (0, external_vitest_namespaceObject.expect)(params.get("client_id")).toBe("app_client_retry");
-                return new Response(JSON.stringify({
-                    access_token: refreshedAccessToken,
-                    refresh_token: "refresh-retry-new",
-                    id_token: refreshedIdToken,
-                    token_type: "bearer",
-                    expires_in: 864000
-                }), {
-                    status: 200,
-                    headers: {
-                        "content-type": "application/json"
-                    }
-                });
-            }
-            codexCallCount += 1;
-            const headers = new Headers(init?.headers);
-            if (1 === codexCallCount) {
-                (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe(`Bearer ${initialAccessToken}`);
-                return new Response("unauthorized", {
-                    status: 401
-                });
-            }
-            (0, external_vitest_namespaceObject.expect)(codexCallCount).toBe(2);
-            (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
-            (0, external_vitest_namespaceObject.expect)(headers.get("chatgpt-account-id")).toBe("acct_retry_new");
-            return new Response("{}", {
-                status: 200
-            });
-        });
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        });
-        (0, external_vitest_namespaceObject.expect)(codexCallCount).toBe(2);
-        (0, external_vitest_namespaceObject.expect)(baseFetch).toHaveBeenCalledTimes(3);
-        const persisted = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)((0, codex_cjs_namespaceObject.getCodexAuthPath)(), "utf-8"));
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.access_token).toBe(refreshedAccessToken);
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.refresh_token).toBe("refresh-retry-new");
-        (0, external_vitest_namespaceObject.expect)(persisted.tokens?.account_id).toBe("acct_retry_new");
-    });
-    (0, external_vitest_namespaceObject.it)("uses fallback token when codex auth file is unavailable", async ()=>{
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch,
-            fallbackToken: "fallback-token"
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        });
-        const requestInit = baseFetch.mock.calls[0]?.[1];
-        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
-        const headers = new Headers(requestInit?.headers);
-        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer fallback-token");
-    });
-    (0, external_vitest_namespaceObject.it)("throws when no codex token is available", async ()=>{
-        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
-                status: 200
-            }));
-        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
-            baseFetch
-        });
-        await (0, external_vitest_namespaceObject.expect)(codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        })).rejects.toThrow(/Codex credentials missing/);
-    });
-});
-function writeCodexAuth(payload) {
-    const authPath = (0, codex_cjs_namespaceObject.getCodexAuthPath)();
-    (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
-        recursive: true
-    });
-    (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify(payload, null, 2));
-}
-function createJwt(payload) {
-    const header = Buffer.from(JSON.stringify({
-        alg: "HS256",
-        typ: "JWT"
-    })).toString("base64url");
-    const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
-    return `${header}.${body}.signature`;
-}
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});