@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/tests/cli-init.test.cjs

@@ -43,6 +43,7 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingAgentPath)).toBe(true);
         const codingPrompt = (0, external_node_fs_namespaceObject.readFileSync)(codingAgentPath, "utf-8");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("read_todos");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("update_plan");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("subAgents:");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("Do not delegate coding work to subagents");
@@ -55,6 +56,7 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("promptFile: ./implementor.md");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("`task` tool");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("read_todos");
         const codingV2ImplementorPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "implementor.md");
         const codingV2PlannerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "planner.md");
         const codingV2ReviewerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "reviewer.md");
@@ -63,6 +65,40 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2PlannerPath)).toBe(false);
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ReviewerPath)).toBe(false);
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ResearcherPath)).toBe(false);
+        const gameDevAgentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "agent.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevAgentPath)).toBe(true);
+        const gameDevPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevAgentPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: game-dev");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("subAgents:");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: art-generation");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./art-generation.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: asset-refinement");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./asset-refinement.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: planning-idea");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./planning-idea.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: ui-specialist");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./ui-specialist.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("read_todos");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("UV-aware texture planning");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("MeshStandardMaterial");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("uv`/`uv2");
+        const gameDevArtGenerationPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "art-generation.md");
+        const gameDevAssetRefinementPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "asset-refinement.md");
+        const gameDevPlanningIdeaPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "planning-idea.md");
+        const gameDevUiSpecialistPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "ui-specialist.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevArtGenerationPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevAssetRefinementPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevPlanningIdeaPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevUiSpecialistPath)).toBe(true);
+        const gameDevArtGenerationPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevArtGenerationPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("UV set(s) or UDIM tiles");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("texel density targets");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("Texture-to-geometry mapping notes");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("material slot");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("need `uv`, and `aoMap`");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("flipY = false");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("RepeatWrapping");
     });
     (0, external_vitest_namespaceObject.it)("merges existing config when --merge is set", async ()=>{
         const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");

package/dist/tests/cli-init.test.js

@@ -41,6 +41,7 @@ describe("CLI init", ()=>{
         expect(existsSync(codingAgentPath)).toBe(true);
         const codingPrompt = readFileSync(codingAgentPath, "utf-8");
         expect(codingPrompt).toContain("write_todos");
+        expect(codingPrompt).toContain("read_todos");
         expect(codingPrompt).not.toContain("update_plan");
         expect(codingPrompt).not.toContain("subAgents:");
         expect(codingPrompt).toContain("Do not delegate coding work to subagents");
@@ -53,6 +54,7 @@ describe("CLI init", ()=>{
         expect(codingV2Prompt).toContain("promptFile: ./implementor.md");
         expect(codingV2Prompt).toContain("`task` tool");
         expect(codingV2Prompt).toContain("write_todos");
+        expect(codingV2Prompt).toContain("read_todos");
         const codingV2ImplementorPath = join(workspace, ".wingman", "agents", "coding-v2", "implementor.md");
         const codingV2PlannerPath = join(workspace, ".wingman", "agents", "coding-v2", "planner.md");
         const codingV2ReviewerPath = join(workspace, ".wingman", "agents", "coding-v2", "reviewer.md");
@@ -61,6 +63,40 @@ describe("CLI init", ()=>{
         expect(existsSync(codingV2PlannerPath)).toBe(false);
         expect(existsSync(codingV2ReviewerPath)).toBe(false);
         expect(existsSync(codingV2ResearcherPath)).toBe(false);
+        const gameDevAgentPath = join(workspace, ".wingman", "agents", "game-dev", "agent.md");
+        expect(existsSync(gameDevAgentPath)).toBe(true);
+        const gameDevPrompt = readFileSync(gameDevAgentPath, "utf-8");
+        expect(gameDevPrompt).toContain("name: game-dev");
+        expect(gameDevPrompt).toContain("subAgents:");
+        expect(gameDevPrompt).toContain("name: art-generation");
+        expect(gameDevPrompt).toContain("promptFile: ./art-generation.md");
+        expect(gameDevPrompt).toContain("name: asset-refinement");
+        expect(gameDevPrompt).toContain("promptFile: ./asset-refinement.md");
+        expect(gameDevPrompt).toContain("name: planning-idea");
+        expect(gameDevPrompt).toContain("promptFile: ./planning-idea.md");
+        expect(gameDevPrompt).toContain("name: ui-specialist");
+        expect(gameDevPrompt).toContain("promptFile: ./ui-specialist.md");
+        expect(gameDevPrompt).toContain("write_todos");
+        expect(gameDevPrompt).toContain("read_todos");
+        expect(gameDevPrompt).toContain("UV-aware texture planning");
+        expect(gameDevPrompt).toContain("MeshStandardMaterial");
+        expect(gameDevPrompt).toContain("uv`/`uv2");
+        const gameDevArtGenerationPath = join(workspace, ".wingman", "agents", "game-dev", "art-generation.md");
+        const gameDevAssetRefinementPath = join(workspace, ".wingman", "agents", "game-dev", "asset-refinement.md");
+        const gameDevPlanningIdeaPath = join(workspace, ".wingman", "agents", "game-dev", "planning-idea.md");
+        const gameDevUiSpecialistPath = join(workspace, ".wingman", "agents", "game-dev", "ui-specialist.md");
+        expect(existsSync(gameDevArtGenerationPath)).toBe(true);
+        expect(existsSync(gameDevAssetRefinementPath)).toBe(true);
+        expect(existsSync(gameDevPlanningIdeaPath)).toBe(true);
+        expect(existsSync(gameDevUiSpecialistPath)).toBe(true);
+        const gameDevArtGenerationPrompt = readFileSync(gameDevArtGenerationPath, "utf-8");
+        expect(gameDevArtGenerationPrompt).toContain("UV set(s) or UDIM tiles");
+        expect(gameDevArtGenerationPrompt).toContain("texel density targets");
+        expect(gameDevArtGenerationPrompt).toContain("Texture-to-geometry mapping notes");
+        expect(gameDevArtGenerationPrompt).toContain("material slot");
+        expect(gameDevArtGenerationPrompt).toContain("need `uv`, and `aoMap`");
+        expect(gameDevArtGenerationPrompt).toContain("flipY = false");
+        expect(gameDevArtGenerationPrompt).toContain("RepeatWrapping");
     });
     it("merges existing config when --merge is set", async ()=>{
         const configDir = join(workspace, ".wingman");

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

@@ -161,6 +161,171 @@ const codex_cjs_namespaceObject = require("../providers/codex.cjs");
         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
@@ -204,6 +369,14 @@ function writeCodexAuth(payload) {
     });
     (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

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+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";
@@ -159,6 +159,171 @@ describe("codex provider", ()=>{
         const payload = JSON.parse(String(requestInit?.body));
         expect(payload.store).toBe(false);
     });
+    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 = 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 ?? ""));
+                expect(params.get("grant_type")).toBe("refresh_token");
+                expect(params.get("refresh_token")).toBe("refresh-old");
+                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"
+                    }
+                });
+            }
+            expect(url).toBe("https://chatgpt.com/backend-api/codex/responses");
+            const headers = new Headers(init?.headers);
+            expect(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
+            expect(headers.get("chatgpt-account-id")).toBe("acct_refreshed");
+            return new Response("{}", {
+                status: 200
+            });
+        });
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        });
+        expect(baseFetch).toHaveBeenCalledTimes(2);
+        const persisted = JSON.parse(readFileSync(getCodexAuthPath(), "utf-8"));
+        expect(persisted.tokens?.access_token).toBe(refreshedAccessToken);
+        expect(persisted.tokens?.refresh_token).toBe("refresh-new");
+        expect(persisted.tokens?.id_token).toBe(refreshedIdToken);
+        expect(persisted.tokens?.account_id).toBe("acct_refreshed");
+        expect(typeof persisted.last_refresh).toBe("string");
+    });
+    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 = 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 ?? ""));
+                expect(params.get("grant_type")).toBe("refresh_token");
+                expect(params.get("refresh_token")).toBe("refresh-retry");
+                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) {
+                expect(headers.get("authorization")).toBe(`Bearer ${initialAccessToken}`);
+                return new Response("unauthorized", {
+                    status: 401
+                });
+            }
+            expect(codexCallCount).toBe(2);
+            expect(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
+            expect(headers.get("chatgpt-account-id")).toBe("acct_retry_new");
+            return new Response("{}", {
+                status: 200
+            });
+        });
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        });
+        expect(codexCallCount).toBe(2);
+        expect(baseFetch).toHaveBeenCalledTimes(3);
+        const persisted = JSON.parse(readFileSync(getCodexAuthPath(), "utf-8"));
+        expect(persisted.tokens?.access_token).toBe(refreshedAccessToken);
+        expect(persisted.tokens?.refresh_token).toBe("refresh-retry-new");
+        expect(persisted.tokens?.account_id).toBe("acct_retry_new");
+    });
     it("uses fallback token when codex auth file is unavailable", async ()=>{
         const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
                 status: 200
@@ -202,3 +367,11 @@ function writeCodexAuth(payload) {
     });
     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`;
+}

package/dist/tests/falRuntime.test.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const runtime_cjs_namespaceObject = require("../tools/fal/runtime.cjs");
+(0, external_vitest_namespaceObject.describe)("fal runtime paths", ()=>{
+    (0, external_vitest_namespaceObject.it)("uses WINGMAN_WORKDIR when provided", ()=>{
+        const workdir = (0, runtime_cjs_namespaceObject.resolveFalWorkdir)({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/wingman-session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(workdir).toBe("/tmp/wingman-session");
+    });
+    (0, external_vitest_namespaceObject.it)("resolves relative WINGMAN_WORKDIR against cwd", ()=>{
+        const workdir = (0, runtime_cjs_namespaceObject.resolveFalWorkdir)({
+            env: {
+                WINGMAN_WORKDIR: "projects/game"
+            },
+            cwd: "/Users/test"
+        });
+        (0, external_vitest_namespaceObject.expect)(workdir).toBe("/Users/test/projects/game");
+    });
+    (0, external_vitest_namespaceObject.it)("prefers explicit FAL_MCP_STATE_DIR", ()=>{
+        const stateDir = (0, runtime_cjs_namespaceObject.resolveFalStateDir)({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session",
+                FAL_MCP_STATE_DIR: "/tmp/custom-state"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(stateDir).toBe("/tmp/custom-state");
+    });
+    (0, external_vitest_namespaceObject.it)("defaults state dir under working folder", ()=>{
+        const stateDir = (0, runtime_cjs_namespaceObject.resolveFalStateDir)({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(stateDir).toBe("/tmp/session/.wingman/fal-ai");
+    });
+    (0, external_vitest_namespaceObject.it)("prefers explicit FAL_MCP_OUTPUT_DIR", ()=>{
+        const outputDir = (0, runtime_cjs_namespaceObject.resolveFalOutputDir)({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session",
+                FAL_MCP_OUTPUT_DIR: "assets/out"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(outputDir).toBe("/tmp/session/assets/out");
+    });
+    (0, external_vitest_namespaceObject.it)("defaults output dir under working folder", ()=>{
+        const outputDir = (0, runtime_cjs_namespaceObject.resolveFalOutputDir)({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(outputDir).toBe("/tmp/session/generated");
+    });
+    (0, external_vitest_namespaceObject.it)("resolves local relative media paths against working folder", ()=>{
+        const resolved = (0, runtime_cjs_namespaceObject.resolveFalLocalMediaPath)("images/source.png", "/tmp/session", {
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(resolved).toBe("/tmp/session/images/source.png");
+    });
+    (0, external_vitest_namespaceObject.it)("keeps local absolute media paths unchanged", ()=>{
+        const resolved = (0, runtime_cjs_namespaceObject.resolveFalLocalMediaPath)("/tmp/session/images/source.png", "/tmp/session", {
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(resolved).toBe("/tmp/session/images/source.png");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/falRuntime.test.d.ts

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

package/dist/tests/falRuntime.test.js

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { resolveFalLocalMediaPath, resolveFalOutputDir, resolveFalStateDir, resolveFalWorkdir } from "../tools/fal/runtime.js";
+describe("fal runtime paths", ()=>{
+    it("uses WINGMAN_WORKDIR when provided", ()=>{
+        const workdir = resolveFalWorkdir({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/wingman-session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        expect(workdir).toBe("/tmp/wingman-session");
+    });
+    it("resolves relative WINGMAN_WORKDIR against cwd", ()=>{
+        const workdir = resolveFalWorkdir({
+            env: {
+                WINGMAN_WORKDIR: "projects/game"
+            },
+            cwd: "/Users/test"
+        });
+        expect(workdir).toBe("/Users/test/projects/game");
+    });
+    it("prefers explicit FAL_MCP_STATE_DIR", ()=>{
+        const stateDir = resolveFalStateDir({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session",
+                FAL_MCP_STATE_DIR: "/tmp/custom-state"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        expect(stateDir).toBe("/tmp/custom-state");
+    });
+    it("defaults state dir under working folder", ()=>{
+        const stateDir = resolveFalStateDir({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        expect(stateDir).toBe("/tmp/session/.wingman/fal-ai");
+    });
+    it("prefers explicit FAL_MCP_OUTPUT_DIR", ()=>{
+        const outputDir = resolveFalOutputDir({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session",
+                FAL_MCP_OUTPUT_DIR: "assets/out"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        expect(outputDir).toBe("/tmp/session/assets/out");
+    });
+    it("defaults output dir under working folder", ()=>{
+        const outputDir = resolveFalOutputDir({
+            env: {
+                WINGMAN_WORKDIR: "/tmp/session"
+            },
+            cwd: "/repo/apps/wingman"
+        });
+        expect(outputDir).toBe("/tmp/session/generated");
+    });
+    it("resolves local relative media paths against working folder", ()=>{
+        const resolved = resolveFalLocalMediaPath("images/source.png", "/tmp/session", {
+            cwd: "/repo/apps/wingman"
+        });
+        expect(resolved).toBe("/tmp/session/images/source.png");
+    });
+    it("keeps local absolute media paths unchanged", ()=>{
+        const resolved = resolveFalLocalMediaPath("/tmp/session/images/source.png", "/tmp/session", {
+            cwd: "/repo/apps/wingman"
+        });
+        expect(resolved).toBe("/tmp/session/images/source.png");
+    });
+});