@wingman-ai/gateway 0.2.5 → 0.3.1

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

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, normalize } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { handleFsApi } from "../gateway/http/fs.js";
+describe("fs API", ()=>{
+    let rootDir;
+    let extraDir;
+    beforeEach(()=>{
+        rootDir = mkdtempSync(join(tmpdir(), "wingman-fs-api-"));
+        extraDir = null;
+    });
+    afterEach(()=>{
+        rmSync(rootDir, {
+            recursive: true,
+            force: true
+        });
+        if (extraDir) rmSync(extraDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    const createCtx = ()=>({
+            resolveFsRoots: ()=>[
+                    rootDir
+                ],
+            resolveFsPath: (path)=>normalize(path),
+            isPathWithinRoots: (targetPath, roots)=>{
+                const resolved = normalize(targetPath);
+                return roots.some((root)=>{
+                    const normalizedRoot = normalize(root);
+                    return resolved === normalizedRoot || resolved.startsWith(`${normalizedRoot}/`) || resolved.startsWith(`${normalizedRoot}\\`);
+                });
+            }
+        });
+    it("creates a folder inside allowed roots", async ()=>{
+        const parent = join(rootDir, "parent");
+        mkdirSync(parent, {
+            recursive: true
+        });
+        const req = new Request("http://localhost/api/fs/mkdir", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                path: parent,
+                name: "new-folder"
+            })
+        });
+        const res = await handleFsApi(createCtx(), req, new URL(req.url));
+        expect(res).not.toBeNull();
+        expect(res?.ok).toBe(true);
+        const payload = await res?.json();
+        expect(payload.path).toBe(normalize(join(parent, "new-folder")));
+        expect(existsSync(payload.path)).toBe(true);
+    });
+    it("rejects invalid folder names", async ()=>{
+        const parent = join(rootDir, "parent");
+        mkdirSync(parent, {
+            recursive: true
+        });
+        const req = new Request("http://localhost/api/fs/mkdir", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                path: parent,
+                name: "bad/name"
+            })
+        });
+        const res = await handleFsApi(createCtx(), req, new URL(req.url));
+        expect(res).not.toBeNull();
+        expect(res?.status).toBe(400);
+        expect(await res?.text()).toBe("invalid folder name");
+    });
+    it("rejects paths outside allowed roots", async ()=>{
+        extraDir = mkdtempSync(join(tmpdir(), "wingman-fs-outside-"));
+        const req = new Request("http://localhost/api/fs/mkdir", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                path: extraDir,
+                name: "new-folder"
+            })
+        });
+        const res = await handleFsApi(createCtx(), req, new URL(req.url));
+        expect(res).not.toBeNull();
+        expect(res?.status).toBe(403);
+        expect(await res?.text()).toBe("path not allowed");
+    });
+    it("returns 409 when the target folder already exists", async ()=>{
+        const parent = join(rootDir, "parent");
+        const existing = join(parent, "existing");
+        mkdirSync(existing, {
+            recursive: true
+        });
+        const req = new Request("http://localhost/api/fs/mkdir", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                path: parent,
+                name: "existing"
+            })
+        });
+        const res = await handleFsApi(createCtx(), req, new URL(req.url));
+        expect(res).not.toBeNull();
+        expect(res?.status).toBe(409);
+        expect(await res?.text()).toBe("path already exists");
+    });
+    it("rejects non-string path and folder name values", async ()=>{
+        const req = new Request("http://localhost/api/fs/mkdir", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                path: 123,
+                name: 456
+            })
+        });
+        const res = await handleFsApi(createCtx(), req, new URL(req.url));
+        expect(res).not.toBeNull();
+        expect(res?.status).toBe(400);
+        expect(await res?.text()).toBe("path required");
+    });
+});

package/dist/tests/gateway-command-workspace.test.cjs

@@ -0,0 +1,150 @@
+"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 gateway_cjs_namespaceObject = require("../cli/commands/gateway.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const daemonStartMock = external_vitest_namespaceObject.vi.fn(async (_config)=>{});
+const daemonStopMock = external_vitest_namespaceObject.vi.fn(async ()=>{});
+const daemonRestartMock = external_vitest_namespaceObject.vi.fn(async ()=>{});
+const daemonGetStatusMock = external_vitest_namespaceObject.vi.fn(()=>({
+        running: false
+    }));
+const daemonGetLogFileMock = external_vitest_namespaceObject.vi.fn(()=>"/tmp/wingman-gateway.log");
+const daemonGetPidFileMock = external_vitest_namespaceObject.vi.fn(()=>"/tmp/wingman-gateway.pid");
+const daemonGetConfigFileMock = external_vitest_namespaceObject.vi.fn(()=>"/tmp/wingman-gateway.json");
+let serverStartShouldReject = false;
+const createdServerConfigs = [];
+const serverStartMock = external_vitest_namespaceObject.vi.fn(async ()=>{
+    if (serverStartShouldReject) throw new Error("synthetic gateway run stop");
+});
+const serverStopMock = external_vitest_namespaceObject.vi.fn(async ()=>{});
+const loadConfigMock = external_vitest_namespaceObject.vi.fn(()=>({
+        gateway: {
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "none"
+            }
+        }
+    }));
+external_vitest_namespaceObject.vi.mock("../gateway/index.js", ()=>({
+        GatewayDaemon: class {
+            constructor(){
+                _define_property(this, "start", daemonStartMock);
+                _define_property(this, "stop", daemonStopMock);
+                _define_property(this, "restart", daemonRestartMock);
+                _define_property(this, "getStatus", daemonGetStatusMock);
+                _define_property(this, "getLogFile", daemonGetLogFileMock);
+                _define_property(this, "getPidFile", daemonGetPidFileMock);
+                _define_property(this, "getConfigFile", daemonGetConfigFileMock);
+            }
+        },
+        GatewayServer: class {
+            constructor(config){
+                _define_property(this, "start", serverStartMock);
+                _define_property(this, "stop", serverStopMock);
+                createdServerConfigs.push(config);
+            }
+        },
+        GatewayClient: class {
+        }
+    }));
+external_vitest_namespaceObject.vi.mock("../cli/config/loader.js", ()=>({
+        WingmanConfigLoader: class {
+            constructor(){
+                _define_property(this, "loadConfig", loadConfigMock);
+            }
+        }
+    }));
+(0, external_vitest_namespaceObject.describe)("gateway command workspace handling", ()=>{
+    let tempRoot;
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let processExitSpy;
+    const originalGatewayConfigEnv = process.env.WINGMAN_GATEWAY_CONFIG;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        tempRoot = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-gateway-command-"));
+        serverStartShouldReject = false;
+        createdServerConfigs.length = 0;
+        daemonStartMock.mockClear();
+        serverStartMock.mockClear();
+        loadConfigMock.mockClear();
+        consoleLogSpy = external_vitest_namespaceObject.vi.spyOn(console, "log").mockImplementation(()=>{});
+        consoleErrorSpy = external_vitest_namespaceObject.vi.spyOn(console, "error").mockImplementation(()=>{});
+        processExitSpy = external_vitest_namespaceObject.vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        delete process.env.WINGMAN_GATEWAY_CONFIG;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        processExitSpy.mockRestore();
+        if (originalGatewayConfigEnv) process.env.WINGMAN_GATEWAY_CONFIG = originalGatewayConfigEnv;
+        else delete process.env.WINGMAN_GATEWAY_CONFIG;
+        if ((0, external_node_fs_namespaceObject.existsSync)(tempRoot)) (0, external_node_fs_namespaceObject.rmSync)(tempRoot, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("passes workspace/configDir into daemon config on gateway start", async ()=>{
+        const workspace = (0, external_node_path_namespaceObject.join)(tempRoot, "workspace");
+        const configDir = ".wingman-dev";
+        await (0, gateway_cjs_namespaceObject.executeGatewayCommand)({
+            subcommand: "start",
+            args: [],
+            options: {}
+        }, {
+            workspace,
+            configDir
+        });
+        (0, external_vitest_namespaceObject.expect)(daemonStartMock).toHaveBeenCalledTimes(1);
+        (0, external_vitest_namespaceObject.expect)(daemonStartMock).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+            workspace,
+            configDir
+        }));
+    });
+    (0, external_vitest_namespaceObject.it)("fills missing workspace/configDir when running from daemon config", async ()=>{
+        const workspace = (0, external_node_path_namespaceObject.join)(tempRoot, "workspace");
+        const configDir = ".wingman-dev";
+        const daemonConfigPath = (0, external_node_path_namespaceObject.join)(tempRoot, "gateway-daemon.json");
+        (0, external_node_fs_namespaceObject.writeFileSync)(daemonConfigPath, JSON.stringify({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "none"
+            }
+        }));
+        process.env.WINGMAN_GATEWAY_CONFIG = daemonConfigPath;
+        serverStartShouldReject = true;
+        await (0, external_vitest_namespaceObject.expect)((0, gateway_cjs_namespaceObject.executeGatewayCommand)({
+            subcommand: "run",
+            args: [],
+            options: {
+                daemon: true
+            }
+        }, {
+            workspace,
+            configDir
+        })).rejects.toThrow("process.exit(1)");
+        (0, external_vitest_namespaceObject.expect)(createdServerConfigs).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(createdServerConfigs[0]?.workspace).toBe(workspace);
+        (0, external_vitest_namespaceObject.expect)(createdServerConfigs[0]?.configDir).toBe(configDir);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/gateway-command-workspace.test.d.ts

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

package/dist/tests/gateway-command-workspace.test.js

@@ -0,0 +1,144 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { executeGatewayCommand } from "../cli/commands/gateway.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const daemonStartMock = vi.fn(async (_config)=>{});
+const daemonStopMock = vi.fn(async ()=>{});
+const daemonRestartMock = vi.fn(async ()=>{});
+const daemonGetStatusMock = vi.fn(()=>({
+        running: false
+    }));
+const daemonGetLogFileMock = vi.fn(()=>"/tmp/wingman-gateway.log");
+const daemonGetPidFileMock = vi.fn(()=>"/tmp/wingman-gateway.pid");
+const daemonGetConfigFileMock = vi.fn(()=>"/tmp/wingman-gateway.json");
+let serverStartShouldReject = false;
+const createdServerConfigs = [];
+const serverStartMock = vi.fn(async ()=>{
+    if (serverStartShouldReject) throw new Error("synthetic gateway run stop");
+});
+const serverStopMock = vi.fn(async ()=>{});
+const loadConfigMock = vi.fn(()=>({
+        gateway: {
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "none"
+            }
+        }
+    }));
+vi.mock("../gateway/index.js", ()=>({
+        GatewayDaemon: class {
+            constructor(){
+                _define_property(this, "start", daemonStartMock);
+                _define_property(this, "stop", daemonStopMock);
+                _define_property(this, "restart", daemonRestartMock);
+                _define_property(this, "getStatus", daemonGetStatusMock);
+                _define_property(this, "getLogFile", daemonGetLogFileMock);
+                _define_property(this, "getPidFile", daemonGetPidFileMock);
+                _define_property(this, "getConfigFile", daemonGetConfigFileMock);
+            }
+        },
+        GatewayServer: class {
+            constructor(config){
+                _define_property(this, "start", serverStartMock);
+                _define_property(this, "stop", serverStopMock);
+                createdServerConfigs.push(config);
+            }
+        },
+        GatewayClient: class {
+        }
+    }));
+vi.mock("../cli/config/loader.js", ()=>({
+        WingmanConfigLoader: class {
+            constructor(){
+                _define_property(this, "loadConfig", loadConfigMock);
+            }
+        }
+    }));
+describe("gateway command workspace handling", ()=>{
+    let tempRoot;
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let processExitSpy;
+    const originalGatewayConfigEnv = process.env.WINGMAN_GATEWAY_CONFIG;
+    beforeEach(()=>{
+        tempRoot = mkdtempSync(join(tmpdir(), "wingman-gateway-command-"));
+        serverStartShouldReject = false;
+        createdServerConfigs.length = 0;
+        daemonStartMock.mockClear();
+        serverStartMock.mockClear();
+        loadConfigMock.mockClear();
+        consoleLogSpy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+        processExitSpy = vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        delete process.env.WINGMAN_GATEWAY_CONFIG;
+    });
+    afterEach(()=>{
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        processExitSpy.mockRestore();
+        if (originalGatewayConfigEnv) process.env.WINGMAN_GATEWAY_CONFIG = originalGatewayConfigEnv;
+        else delete process.env.WINGMAN_GATEWAY_CONFIG;
+        if (existsSync(tempRoot)) rmSync(tempRoot, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("passes workspace/configDir into daemon config on gateway start", async ()=>{
+        const workspace = join(tempRoot, "workspace");
+        const configDir = ".wingman-dev";
+        await executeGatewayCommand({
+            subcommand: "start",
+            args: [],
+            options: {}
+        }, {
+            workspace,
+            configDir
+        });
+        expect(daemonStartMock).toHaveBeenCalledTimes(1);
+        expect(daemonStartMock).toHaveBeenCalledWith(expect.objectContaining({
+            workspace,
+            configDir
+        }));
+    });
+    it("fills missing workspace/configDir when running from daemon config", async ()=>{
+        const workspace = join(tempRoot, "workspace");
+        const configDir = ".wingman-dev";
+        const daemonConfigPath = join(tempRoot, "gateway-daemon.json");
+        writeFileSync(daemonConfigPath, JSON.stringify({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "none"
+            }
+        }));
+        process.env.WINGMAN_GATEWAY_CONFIG = daemonConfigPath;
+        serverStartShouldReject = true;
+        await expect(executeGatewayCommand({
+            subcommand: "run",
+            args: [],
+            options: {
+                daemon: true
+            }
+        }, {
+            workspace,
+            configDir
+        })).rejects.toThrow("process.exit(1)");
+        expect(createdServerConfigs).toHaveLength(1);
+        expect(createdServerConfigs[0]?.workspace).toBe(workspace);
+        expect(createdServerConfigs[0]?.configDir).toBe(configDir);
+    });
+});

package/dist/tests/gateway-request-execution-overrides.test.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const server_cjs_namespaceObject = require("../gateway/server.cjs");
+(0, external_vitest_namespaceObject.describe)("gateway request execution overrides", ()=>{
+    (0, external_vitest_namespaceObject.it)("accepts absolute execution workspace overrides", ()=>{
+        const value = (0, server_cjs_namespaceObject.resolveExecutionWorkspaceOverride)({
+            execution: {
+                workspace: " /tmp/wingman/workspace "
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(value).toBe("/tmp/wingman/workspace");
+    });
+    (0, external_vitest_namespaceObject.it)("rejects relative execution workspace overrides", ()=>{
+        const value = (0, server_cjs_namespaceObject.resolveExecutionWorkspaceOverride)({
+            execution: {
+                workspace: "./apps/wingman"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(value).toBeNull();
+    });
+    (0, external_vitest_namespaceObject.it)("parses config-dir execution override when present", ()=>{
+        const value = (0, server_cjs_namespaceObject.resolveExecutionConfigDirOverride)({
+            execution: {
+                configDir: " .wingman-dev "
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(value).toBe(".wingman-dev");
+    });
+    (0, external_vitest_namespaceObject.it)("ignores empty config-dir execution override", ()=>{
+        const value = (0, server_cjs_namespaceObject.resolveExecutionConfigDirOverride)({
+            execution: {
+                configDir: "   "
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(value).toBeNull();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/gateway-request-execution-overrides.test.d.ts

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

package/dist/tests/gateway-request-execution-overrides.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { resolveExecutionConfigDirOverride, resolveExecutionWorkspaceOverride } from "../gateway/server.js";
+describe("gateway request execution overrides", ()=>{
+    it("accepts absolute execution workspace overrides", ()=>{
+        const value = resolveExecutionWorkspaceOverride({
+            execution: {
+                workspace: " /tmp/wingman/workspace "
+            }
+        });
+        expect(value).toBe("/tmp/wingman/workspace");
+    });
+    it("rejects relative execution workspace overrides", ()=>{
+        const value = resolveExecutionWorkspaceOverride({
+            execution: {
+                workspace: "./apps/wingman"
+            }
+        });
+        expect(value).toBeNull();
+    });
+    it("parses config-dir execution override when present", ()=>{
+        const value = resolveExecutionConfigDirOverride({
+            execution: {
+                configDir: " .wingman-dev "
+            }
+        });
+        expect(value).toBe(".wingman-dev");
+    });
+    it("ignores empty config-dir execution override", ()=>{
+        const value = resolveExecutionConfigDirOverride({
+            execution: {
+                configDir: "   "
+            }
+        });
+        expect(value).toBeNull();
+    });
+});