@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/tests/sessions-api.test.js

@@ -1,9 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { handleSessionsApi } from "../gateway/http/sessions.js";
-import { SessionManager } from "../cli/core/sessionManager.js";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SessionManager } from "../cli/core/sessionManager.js";
+import { handleSessionsApi } from "../gateway/http/sessions.js";
 const isBunRuntime = void 0 !== globalThis.Bun;
 const describeIfBun = isBunRuntime ? describe : describe.skip;
 describeIfBun("sessions API", ()=>{
@@ -59,4 +59,118 @@ describeIfBun("sessions API", ()=>{
         expect(updated?.messageCount).toBe(0);
         expect(updated?.lastMessagePreview).toBeNull();
     });
+    it("returns pending messages and clears them via DELETE", async ()=>{
+        const ctx = {
+            getSessionManager: async ()=>manager,
+            router: {
+                selectAgent: (agentId)=>agentId || "main"
+            }
+        };
+        const createReq = new Request("http://localhost/api/sessions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Pending Test"
+            })
+        });
+        const createRes = await handleSessionsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        manager.persistPendingMessage({
+            sessionId: created.id,
+            requestId: "req-pending-test",
+            message: {
+                id: "user-req-pending-test",
+                role: "user",
+                content: "Persist me",
+                createdAt: Date.now()
+            }
+        });
+        const getReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}/messages?agentId=main`, {
+            method: "GET"
+        });
+        const getRes = await handleSessionsApi(ctx, getReq, new URL(getReq.url));
+        expect(getRes).not.toBeNull();
+        expect(getRes?.ok).toBe(true);
+        const pendingMessages = await getRes.json();
+        expect(pendingMessages.some((message)=>"user" === message.role && message.content.includes("Persist me"))).toBe(true);
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}/messages?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await handleSessionsApi(ctx, deleteReq, new URL(deleteReq.url));
+        expect(deleteRes).not.toBeNull();
+        expect(deleteRes?.ok).toBe(true);
+        const afterClearGetReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}/messages?agentId=main`, {
+            method: "GET"
+        });
+        const afterClearGetRes = await handleSessionsApi(ctx, afterClearGetReq, new URL(afterClearGetReq.url));
+        expect(afterClearGetRes).not.toBeNull();
+        expect(afterClearGetRes?.ok).toBe(true);
+        const afterClearMessages = await afterClearGetRes.json();
+        expect(afterClearMessages).toHaveLength(0);
+    });
+    it("lists sessions for discovered agents not present in config", async ()=>{
+        const configDir = join(tempDir, ".wingman");
+        const discoveredAgentId = "local-helper";
+        const discoveredAgentDir = join(configDir, "agents", discoveredAgentId);
+        mkdirSync(discoveredAgentDir, {
+            recursive: true
+        });
+        writeFileSync(join(discoveredAgentDir, "agent.json"), JSON.stringify({
+            name: discoveredAgentId,
+            description: "Local helper agent",
+            systemPrompt: "You are a local helper."
+        }, null, 2));
+        const ctx = {
+            workspace: tempDir,
+            configDir,
+            getWingmanConfig: ()=>({
+                    agents: {
+                        list: [
+                            {
+                                id: "main",
+                                model: "openai:gpt-4.1-mini"
+                            }
+                        ]
+                    }
+                }),
+            getSessionManager: async ()=>manager,
+            router: {
+                selectAgent: (agentId)=>agentId || "main"
+            },
+            logger: {
+                debug: ()=>{},
+                info: ()=>{},
+                warn: ()=>{},
+                error: ()=>{}
+            }
+        };
+        const createReq = new Request("http://localhost/api/sessions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: discoveredAgentId,
+                name: "Discovered Agent Thread"
+            })
+        });
+        const createRes = await handleSessionsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        expect(created.agentId).toBe(discoveredAgentId);
+        const listReq = new Request("http://localhost/api/sessions?limit=100", {
+            method: "GET"
+        });
+        const listRes = await handleSessionsApi(ctx, listReq, new URL(listReq.url));
+        expect(listRes).not.toBeNull();
+        expect(listRes?.ok).toBe(true);
+        const sessions = await listRes.json();
+        expect(sessions.some((session)=>session.id === created.id && session.agentId === discoveredAgentId)).toBe(true);
+    });
 });

package/dist/tests/terminalProbe.test.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const terminalProbe_cjs_namespaceObject = require("../debug/terminalProbe.cjs");
+(0, external_vitest_namespaceObject.describe)("shouldReportTerminalProbeEvent", ()=>{
+    (0, external_vitest_namespaceObject.it)("reports terminal events by default", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("agent-complete")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("agent-error")).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("hides non-terminal events by default", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("agent-start")).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("request-queued")).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("includes lifecycle events in verbose mode", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("agent-start", true)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbe_cjs_namespaceObject.shouldReportTerminalProbeEvent)("request-queued", true)).toBe(true);
+    });
+});
+(0, external_vitest_namespaceObject.describe)("formatTerminalProbeEvent", ()=>{
+    (0, external_vitest_namespaceObject.it)("formats terminal events in a compact single line", ()=>{
+        const line = (0, terminalProbe_cjs_namespaceObject.formatTerminalProbeEvent)({
+            type: "agent-complete",
+            requestId: "req-1",
+            sessionId: "session-1",
+            timestampIso: "2026-02-12T18:12:00.000Z"
+        });
+        (0, external_vitest_namespaceObject.expect)(line).toContain("type=agent-complete");
+        (0, external_vitest_namespaceObject.expect)(line).toContain("req=req-1");
+        (0, external_vitest_namespaceObject.expect)(line).toContain("session=session-1");
+    });
+    (0, external_vitest_namespaceObject.it)("includes error text for error events", ()=>{
+        const line = (0, terminalProbe_cjs_namespaceObject.formatTerminalProbeEvent)({
+            type: "agent-error",
+            requestId: "req-2",
+            error: "Provider timeout",
+            timestampIso: "2026-02-12T18:12:01.000Z"
+        });
+        (0, external_vitest_namespaceObject.expect)(line).toContain("type=agent-error");
+        (0, external_vitest_namespaceObject.expect)(line).toContain('error="Provider timeout"');
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/tests/terminalProbe.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { formatTerminalProbeEvent, shouldReportTerminalProbeEvent } from "../debug/terminalProbe.js";
+describe("shouldReportTerminalProbeEvent", ()=>{
+    it("reports terminal events by default", ()=>{
+        expect(shouldReportTerminalProbeEvent("agent-complete")).toBe(true);
+        expect(shouldReportTerminalProbeEvent("agent-error")).toBe(true);
+    });
+    it("hides non-terminal events by default", ()=>{
+        expect(shouldReportTerminalProbeEvent("agent-start")).toBe(false);
+        expect(shouldReportTerminalProbeEvent("request-queued")).toBe(false);
+    });
+    it("includes lifecycle events in verbose mode", ()=>{
+        expect(shouldReportTerminalProbeEvent("agent-start", true)).toBe(true);
+        expect(shouldReportTerminalProbeEvent("request-queued", true)).toBe(true);
+    });
+});
+describe("formatTerminalProbeEvent", ()=>{
+    it("formats terminal events in a compact single line", ()=>{
+        const line = formatTerminalProbeEvent({
+            type: "agent-complete",
+            requestId: "req-1",
+            sessionId: "session-1",
+            timestampIso: "2026-02-12T18:12:00.000Z"
+        });
+        expect(line).toContain("type=agent-complete");
+        expect(line).toContain("req=req-1");
+        expect(line).toContain("session=session-1");
+    });
+    it("includes error text for error events", ()=>{
+        const line = formatTerminalProbeEvent({
+            type: "agent-error",
+            requestId: "req-2",
+            error: "Provider timeout",
+            timestampIso: "2026-02-12T18:12:01.000Z"
+        });
+        expect(line).toContain("type=agent-error");
+        expect(line).toContain('error="Provider timeout"');
+    });
+});

package/dist/tests/terminalProbeAuth.test.cjs

@@ -0,0 +1,85 @@
+"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 terminalProbeAuth_cjs_namespaceObject = require("../debug/terminalProbeAuth.cjs");
+function writeConfig(configDir, config) {
+    const wingmanDir = (0, external_node_path_namespaceObject.join)(configDir, ".wingman");
+    (0, external_node_fs_namespaceObject.mkdirSync)(wingmanDir, {
+        recursive: true
+    });
+    const configPath = (0, external_node_path_namespaceObject.join)(wingmanDir, "wingman.config.json");
+    (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify(config), "utf-8");
+    return configPath;
+}
+(0, external_vitest_namespaceObject.describe)("resolveTerminalProbeAuth", ()=>{
+    (0, external_vitest_namespaceObject.it)("prefers CLI auth when provided", ()=>{
+        const auth = (0, terminalProbeAuth_cjs_namespaceObject.resolveTerminalProbeAuth)({
+            cliToken: "cli-token",
+            cliPassword: "cli-pass",
+            env: {
+                [terminalProbeAuth_cjs_namespaceObject.TERMINAL_PROBE_GATEWAY_TOKEN_ENV]: "env-token"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(auth.source).toBe("cli");
+        (0, external_vitest_namespaceObject.expect)(auth.token).toBe("cli-token");
+        (0, external_vitest_namespaceObject.expect)(auth.password).toBe("cli-pass");
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to env auth when CLI auth is missing", ()=>{
+        const auth = (0, terminalProbeAuth_cjs_namespaceObject.resolveTerminalProbeAuth)({
+            env: {
+                [terminalProbeAuth_cjs_namespaceObject.TERMINAL_PROBE_GATEWAY_TOKEN_ENV]: "env-token",
+                [terminalProbeAuth_cjs_namespaceObject.TERMINAL_PROBE_GATEWAY_PASSWORD_ENV]: "env-pass"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(auth.source).toBe("env");
+        (0, external_vitest_namespaceObject.expect)(auth.token).toBe("env-token");
+        (0, external_vitest_namespaceObject.expect)(auth.password).toBe("env-pass");
+    });
+    (0, external_vitest_namespaceObject.it)("loads token auth from config when env and CLI are missing", ()=>{
+        const dir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "terminal-probe-auth-"));
+        const configPath = writeConfig(dir, {
+            gateway: {
+                auth: {
+                    mode: "token",
+                    token: "config-token"
+                }
+            }
+        });
+        const auth = (0, terminalProbeAuth_cjs_namespaceObject.resolveTerminalProbeAuth)({
+            env: {},
+            cwd: dir,
+            homeDir: (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "non-existent-home")
+        });
+        (0, external_vitest_namespaceObject.expect)(auth.source).toBe("config");
+        (0, external_vitest_namespaceObject.expect)(auth.token).toBe("config-token");
+        (0, external_vitest_namespaceObject.expect)(auth.configPath).toBe(configPath);
+    });
+    (0, external_vitest_namespaceObject.it)("returns none when no auth material is available", ()=>{
+        const auth = (0, terminalProbeAuth_cjs_namespaceObject.resolveTerminalProbeAuth)({
+            env: {},
+            cwd: (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "terminal-probe-auth-empty"),
+            homeDir: (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "terminal-probe-auth-empty-home")
+        });
+        (0, external_vitest_namespaceObject.expect)(auth.source).toBe("none");
+        (0, external_vitest_namespaceObject.expect)(auth.token).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)(auth.password).toBeUndefined();
+    });
+});
+(0, external_vitest_namespaceObject.describe)("formatTerminalProbeHandshakeFailure", ()=>{
+    (0, external_vitest_namespaceObject.it)("formats string payloads directly", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbeAuth_cjs_namespaceObject.formatTerminalProbeHandshakeFailure)("authentication failed")).toBe("authentication failed");
+    });
+    (0, external_vitest_namespaceObject.it)("formats structured payloads as JSON", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, terminalProbeAuth_cjs_namespaceObject.formatTerminalProbeHandshakeFailure)({
+            code: "AUTH_FAILED",
+            message: "bad token"
+        })).toContain('"code":"AUTH_FAILED"');
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/tests/terminalProbeAuth.test.js

@@ -0,0 +1,79 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { TERMINAL_PROBE_GATEWAY_PASSWORD_ENV, TERMINAL_PROBE_GATEWAY_TOKEN_ENV, formatTerminalProbeHandshakeFailure, resolveTerminalProbeAuth } from "../debug/terminalProbeAuth.js";
+function writeConfig(configDir, config) {
+    const wingmanDir = join(configDir, ".wingman");
+    mkdirSync(wingmanDir, {
+        recursive: true
+    });
+    const configPath = join(wingmanDir, "wingman.config.json");
+    writeFileSync(configPath, JSON.stringify(config), "utf-8");
+    return configPath;
+}
+describe("resolveTerminalProbeAuth", ()=>{
+    it("prefers CLI auth when provided", ()=>{
+        const auth = resolveTerminalProbeAuth({
+            cliToken: "cli-token",
+            cliPassword: "cli-pass",
+            env: {
+                [TERMINAL_PROBE_GATEWAY_TOKEN_ENV]: "env-token"
+            }
+        });
+        expect(auth.source).toBe("cli");
+        expect(auth.token).toBe("cli-token");
+        expect(auth.password).toBe("cli-pass");
+    });
+    it("falls back to env auth when CLI auth is missing", ()=>{
+        const auth = resolveTerminalProbeAuth({
+            env: {
+                [TERMINAL_PROBE_GATEWAY_TOKEN_ENV]: "env-token",
+                [TERMINAL_PROBE_GATEWAY_PASSWORD_ENV]: "env-pass"
+            }
+        });
+        expect(auth.source).toBe("env");
+        expect(auth.token).toBe("env-token");
+        expect(auth.password).toBe("env-pass");
+    });
+    it("loads token auth from config when env and CLI are missing", ()=>{
+        const dir = mkdtempSync(join(tmpdir(), "terminal-probe-auth-"));
+        const configPath = writeConfig(dir, {
+            gateway: {
+                auth: {
+                    mode: "token",
+                    token: "config-token"
+                }
+            }
+        });
+        const auth = resolveTerminalProbeAuth({
+            env: {},
+            cwd: dir,
+            homeDir: join(tmpdir(), "non-existent-home")
+        });
+        expect(auth.source).toBe("config");
+        expect(auth.token).toBe("config-token");
+        expect(auth.configPath).toBe(configPath);
+    });
+    it("returns none when no auth material is available", ()=>{
+        const auth = resolveTerminalProbeAuth({
+            env: {},
+            cwd: join(tmpdir(), "terminal-probe-auth-empty"),
+            homeDir: join(tmpdir(), "terminal-probe-auth-empty-home")
+        });
+        expect(auth.source).toBe("none");
+        expect(auth.token).toBeUndefined();
+        expect(auth.password).toBeUndefined();
+    });
+});
+describe("formatTerminalProbeHandshakeFailure", ()=>{
+    it("formats string payloads directly", ()=>{
+        expect(formatTerminalProbeHandshakeFailure("authentication failed")).toBe("authentication failed");
+    });
+    it("formats structured payloads as JSON", ()=>{
+        expect(formatTerminalProbeHandshakeFailure({
+            code: "AUTH_FAILED",
+            message: "bad token"
+        })).toContain('"code":"AUTH_FAILED"');
+    });
+});

package/dist/tools/fal/runtime.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveFalWorkdir: ()=>resolveFalWorkdir,
+    resolveFalStateDir: ()=>resolveFalStateDir,
+    resolveFalOutputDir: ()=>resolveFalOutputDir,
+    resolveFalLocalMediaPath: ()=>resolveFalLocalMediaPath
+});
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const DEFAULT_STATE_SUBPATH = [
+    ".wingman",
+    "fal-ai"
+];
+const DEFAULT_OUTPUT_SUBPATH = [
+    "generated"
+];
+function normalizeHomePath(pathname, homeDir) {
+    if ("~" === pathname) return homeDir;
+    if (pathname.startsWith("~/")) return (0, external_node_path_namespaceObject.join)(homeDir, pathname.slice(2));
+    return pathname;
+}
+function normalizeFromBase(pathname, baseDir) {
+    return (0, external_node_path_namespaceObject.isAbsolute)(pathname) ? (0, external_node_path_namespaceObject.normalize)(pathname) : (0, external_node_path_namespaceObject.normalize)((0, external_node_path_namespaceObject.resolve)(baseDir, pathname));
+}
+function resolveFalWorkdir(options) {
+    const env = options?.env || process.env;
+    const cwd = options?.cwd || process.cwd();
+    const homeDir = options?.homeDir || (0, external_node_os_namespaceObject.homedir)();
+    const raw = env.WINGMAN_WORKDIR?.trim();
+    if (!raw) return (0, external_node_path_namespaceObject.normalize)(cwd);
+    const withHome = normalizeHomePath(raw, homeDir);
+    return normalizeFromBase(withHome, cwd);
+}
+function resolveFalStateDir(options) {
+    const env = options?.env || process.env;
+    const explicit = env.FAL_MCP_STATE_DIR?.trim();
+    if (explicit) {
+        const cwd = options?.cwd || process.cwd();
+        const homeDir = options?.homeDir || (0, external_node_os_namespaceObject.homedir)();
+        const withHome = normalizeHomePath(explicit, homeDir);
+        return normalizeFromBase(withHome, cwd);
+    }
+    const workdir = resolveFalWorkdir(options);
+    return (0, external_node_path_namespaceObject.join)(workdir, ...DEFAULT_STATE_SUBPATH);
+}
+function resolveFalOutputDir(options) {
+    const env = options?.env || process.env;
+    const explicit = env.FAL_MCP_OUTPUT_DIR?.trim();
+    if (explicit) {
+        const cwd = options?.cwd || process.cwd();
+        const homeDir = options?.homeDir || (0, external_node_os_namespaceObject.homedir)();
+        const withHome = normalizeHomePath(explicit, homeDir);
+        const workdir = resolveFalWorkdir(options);
+        return normalizeFromBase(withHome, workdir || cwd);
+    }
+    const workdir = resolveFalWorkdir(options);
+    return (0, external_node_path_namespaceObject.join)(workdir, ...DEFAULT_OUTPUT_SUBPATH);
+}
+function resolveFalLocalMediaPath(pathname, workdir, options) {
+    const cwd = options?.cwd || process.cwd();
+    const homeDir = options?.homeDir || (0, external_node_os_namespaceObject.homedir)();
+    const trimmed = pathname.trim();
+    const withHome = normalizeHomePath(trimmed, homeDir);
+    if ((0, external_node_path_namespaceObject.isAbsolute)(withHome)) return (0, external_node_path_namespaceObject.normalize)(withHome);
+    return (0, external_node_path_namespaceObject.normalize)((0, external_node_path_namespaceObject.resolve)(workdir || cwd, withHome));
+}
+exports.resolveFalLocalMediaPath = __webpack_exports__.resolveFalLocalMediaPath;
+exports.resolveFalOutputDir = __webpack_exports__.resolveFalOutputDir;
+exports.resolveFalStateDir = __webpack_exports__.resolveFalStateDir;
+exports.resolveFalWorkdir = __webpack_exports__.resolveFalWorkdir;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveFalLocalMediaPath",
+    "resolveFalOutputDir",
+    "resolveFalStateDir",
+    "resolveFalWorkdir"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tools/fal/runtime.d.ts

@@ -0,0 +1,10 @@
+type RuntimePathOptions = {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    homeDir?: string;
+};
+export declare function resolveFalWorkdir(options?: RuntimePathOptions): string;
+export declare function resolveFalStateDir(options?: RuntimePathOptions): string;
+export declare function resolveFalOutputDir(options?: RuntimePathOptions): string;
+export declare function resolveFalLocalMediaPath(pathname: string, workdir: string, options?: Pick<RuntimePathOptions, "cwd" | "homeDir">): string;
+export {};

package/dist/tools/fal/runtime.js

@@ -0,0 +1,60 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize, resolve } from "node:path";
+const DEFAULT_STATE_SUBPATH = [
+    ".wingman",
+    "fal-ai"
+];
+const DEFAULT_OUTPUT_SUBPATH = [
+    "generated"
+];
+function normalizeHomePath(pathname, homeDir) {
+    if ("~" === pathname) return homeDir;
+    if (pathname.startsWith("~/")) return join(homeDir, pathname.slice(2));
+    return pathname;
+}
+function normalizeFromBase(pathname, baseDir) {
+    return isAbsolute(pathname) ? normalize(pathname) : normalize(resolve(baseDir, pathname));
+}
+function resolveFalWorkdir(options) {
+    const env = options?.env || process.env;
+    const cwd = options?.cwd || process.cwd();
+    const homeDir = options?.homeDir || homedir();
+    const raw = env.WINGMAN_WORKDIR?.trim();
+    if (!raw) return normalize(cwd);
+    const withHome = normalizeHomePath(raw, homeDir);
+    return normalizeFromBase(withHome, cwd);
+}
+function resolveFalStateDir(options) {
+    const env = options?.env || process.env;
+    const explicit = env.FAL_MCP_STATE_DIR?.trim();
+    if (explicit) {
+        const cwd = options?.cwd || process.cwd();
+        const homeDir = options?.homeDir || homedir();
+        const withHome = normalizeHomePath(explicit, homeDir);
+        return normalizeFromBase(withHome, cwd);
+    }
+    const workdir = resolveFalWorkdir(options);
+    return join(workdir, ...DEFAULT_STATE_SUBPATH);
+}
+function resolveFalOutputDir(options) {
+    const env = options?.env || process.env;
+    const explicit = env.FAL_MCP_OUTPUT_DIR?.trim();
+    if (explicit) {
+        const cwd = options?.cwd || process.cwd();
+        const homeDir = options?.homeDir || homedir();
+        const withHome = normalizeHomePath(explicit, homeDir);
+        const workdir = resolveFalWorkdir(options);
+        return normalizeFromBase(withHome, workdir || cwd);
+    }
+    const workdir = resolveFalWorkdir(options);
+    return join(workdir, ...DEFAULT_OUTPUT_SUBPATH);
+}
+function resolveFalLocalMediaPath(pathname, workdir, options) {
+    const cwd = options?.cwd || process.cwd();
+    const homeDir = options?.homeDir || homedir();
+    const trimmed = pathname.trim();
+    const withHome = normalizeHomePath(trimmed, homeDir);
+    if (isAbsolute(withHome)) return normalize(withHome);
+    return normalize(resolve(workdir || cwd, withHome));
+}
+export { resolveFalLocalMediaPath, resolveFalOutputDir, resolveFalStateDir, resolveFalWorkdir };

package/dist/tools/fal/summary.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildFalGenerationSummary: ()=>buildFalGenerationSummary,
+    formatFalPath: ()=>formatFalPath
+});
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+function buildFalGenerationSummary(input) {
+    const media = input.media || [];
+    const lines = [
+        `FAL job \`${input.jobId}\` for \`${input.toolName}\` is **${input.status.toLowerCase()}**.`,
+        `- Model: \`${input.modelId}\``,
+        `- Assets: ${media.length}`
+    ];
+    if ("pending" === input.reviewState) lines.push("- Review required: call `fal_generation_status` with `action` set to `accept` or `deny`.");
+    if (media.length > 0) {
+        lines.push("- Files:");
+        for (const item of media){
+            const localPath = "string" == typeof item.path && item.path.trim() ? formatFalPath(item.path, {
+                cwd: input.cwd,
+                homeDir: input.homeDir
+            }) : null;
+            const target = localPath || item.remoteUrl || "(unavailable)";
+            const mime = item.mimeType ? ` ${item.mimeType}` : "";
+            lines.push(`  - [${item.modality}] ${target}${mime}`);
+        }
+    }
+    if (input.error?.trim()) lines.push("", `Error: ${input.error.trim()}`);
+    return lines.join("\n");
+}
+function formatFalPath(pathname, options) {
+    const trimmed = pathname.trim();
+    if (!trimmed) return pathname;
+    const cwd = options?.cwd || process.cwd();
+    const homeDir = options?.homeDir || process.env.HOME || (0, external_node_os_namespaceObject.homedir)();
+    if (cwd) {
+        const rel = (0, external_node_path_namespaceObject.relative)(cwd, trimmed);
+        if (rel && "." !== rel && !rel.startsWith("..") && !(0, external_node_path_namespaceObject.isAbsolute)(rel)) return `./${rel}`;
+    }
+    if (homeDir && trimmed.startsWith(homeDir)) {
+        const suffix = trimmed.slice(homeDir.length).replace(/^[/\\]+/, "");
+        return suffix ? `~/${suffix}` : "~";
+    }
+    return (0, external_node_path_namespaceObject.basename)(trimmed) === trimmed ? `./${trimmed}` : trimmed;
+}
+exports.buildFalGenerationSummary = __webpack_exports__.buildFalGenerationSummary;
+exports.formatFalPath = __webpack_exports__.formatFalPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildFalGenerationSummary",
+    "formatFalPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tools/fal/summary.d.ts

@@ -0,0 +1,22 @@
+export type FalSummaryMedia = {
+    modality: "image" | "audio" | "video" | "file";
+    path?: string | null;
+    remoteUrl?: string | null;
+    mimeType?: string | null;
+};
+export interface FalSummaryInput {
+    toolName: string;
+    jobId: string;
+    status: string;
+    modelId: string;
+    reviewState?: "pending" | "accepted" | "denied" | null;
+    media?: FalSummaryMedia[];
+    error?: string | null;
+    cwd?: string;
+    homeDir?: string;
+}
+export declare function buildFalGenerationSummary(input: FalSummaryInput): string;
+export declare function formatFalPath(pathname: string, options?: {
+    cwd?: string;
+    homeDir?: string;
+}): string;