@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/tests/gateway.test.js

@@ -20,6 +20,40 @@ vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
             async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
                 if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
+                if ("stream-model-failure-no-error" === content) {
+                    this.outputManager?.emitAgentStream?.({
+                        event: "on_chain_end",
+                        run_id: "model-failure-run-1",
+                        name: "ChannelWrite<branch:to:todoListMiddleware.after_model>",
+                        data: {
+                            output: [
+                                {
+                                    lg_name: "Command",
+                                    update: {
+                                        messages: [
+                                            {
+                                                type: "constructor",
+                                                id: [
+                                                    "langchain_core",
+                                                    "messages",
+                                                    "AIMessage"
+                                                ],
+                                                kwargs: {
+                                                    id: "model-failure-msg-1",
+                                                    content: "Model call failed after 3 attempts with Error: xAI image generation failed: Prompt len is larger than the maximum allowed length which is 8000"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ],
+                            input: {}
+                        }
+                    });
+                    return {
+                        streaming: true
+                    };
+                }
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -410,6 +444,29 @@ describeIfBun("Gateway", ()=>{
         });
         requester.close();
     });
+    it("does not auto-convert streamed model failure text into agent-error", async ()=>{
+        const requester = await connectClient("session-streamed-failure-requester");
+        const requestId = "req-streamed-failure-no-error";
+        const sessionId = "session-streamed-failure-no-error";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "stream-model-failure-no-error"
+            },
+            timestamp: Date.now()
+        }));
+        const streamMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-stream" && msg.payload?.chunk?.event === "on_chain_end", 10000);
+        expect(JSON.stringify(streamMsg.payload?.chunk?.data || {})).toContain("Model call failed after 3 attempts");
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 10000);
+        expect(completeMsg.payload?.sessionId).toBe(sessionId);
+        expect(completeMsg.payload?.agentId).toBe("main");
+        const terminalErrorEvents = await collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 400);
+        expect(terminalErrorEvents).toHaveLength(0);
+        requester.close();
+    });
     it("should emit a single agent-complete terminal event per request", async ()=>{
         const requester = await connectClient("session-single-complete-requester");
         const requestId = "req-single-complete";

package/dist/tests/imagePersistence.test.cjs

@@ -128,6 +128,32 @@ const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQA
         (0, external_vitest_namespaceObject.expect)(firstPath).toBeTruthy();
         (0, external_vitest_namespaceObject.expect)(secondPath).toBe(firstPath);
     });
+    (0, external_vitest_namespaceObject.it)("removes persisted session media directory", ()=>{
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
+        const sessionId = "session-cleanup";
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId,
+            messages
+        });
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, sessionId);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
+        (0, imagePersistence_cjs_namespaceObject.removeSessionMediaDirectory)(dbPath, sessionId);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
+    });
     (0, external_vitest_namespaceObject.it)("parses base64 data URLs and resolves extensions", ()=>{
         const parsed = (0, imagePersistence_cjs_namespaceObject.parseBase64DataUrl)(PNG_DATA_URL);
         (0, external_vitest_namespaceObject.expect)(parsed?.mimeType).toBe("image/png");

package/dist/tests/imagePersistence.test.js

@@ -2,7 +2,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { parseBase64DataUrl, persistAssistantImagesToDisk, resolveImageExtension } from "../cli/core/imagePersistence.js";
+import { getSessionMediaDirectory, parseBase64DataUrl, persistAssistantImagesToDisk, removeSessionMediaDirectory, resolveImageExtension } from "../cli/core/imagePersistence.js";
 const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
 describe("imagePersistence", ()=>{
     const tempDirs = [];
@@ -126,6 +126,32 @@ describe("imagePersistence", ()=>{
         expect(firstPath).toBeTruthy();
         expect(secondPath).toBe(firstPath);
     });
+    it("removes persisted session media directory", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const sessionId = "session-cleanup";
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId,
+            messages
+        });
+        const mediaDir = getSessionMediaDirectory(dbPath, sessionId);
+        expect(existsSync(mediaDir)).toBe(true);
+        removeSessionMediaDirectory(dbPath, sessionId);
+        expect(existsSync(mediaDir)).toBe(false);
+    });
     it("parses base64 data URLs and resolves extensions", ()=>{
         const parsed = parseBase64DataUrl(PNG_DATA_URL);
         expect(parsed?.mimeType).toBe("image/png");

package/dist/tests/run-terminal-bench-official-script.test.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const officialCli_cjs_namespaceObject = require("../bench/officialCli.cjs");
+(0, external_vitest_namespaceObject.describe)("run-terminal-bench-official cli args", ()=>{
+    (0, external_vitest_namespaceObject.it)("parses wingman bridge options", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--config",
+            "bench/config.tb2-wingman.json",
+            "--task-id",
+            "heterogeneous-dates",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--wingman-agent",
+            "coding",
+            "--wingman-model",
+            "openai/gpt-5"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.configPath).toBe((0, external_node_path_namespaceObject.join)(process.cwd(), "bench/config.tb2-wingman.json"));
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.taskNames).toEqual([
+            "heterogeneous-dates"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.nAttempts).toBe(3);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.nTasks).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.agentKwargs).toEqual({
+            wingman_agent: "coding",
+            wingman_model: "openai:gpt-5"
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("uses all dataset tasks when --all-tasks is set", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--task-name",
+            "heterogeneous-dates",
+            "--all-tasks"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.taskNames).toEqual([]);
+    });
+    (0, external_vitest_namespaceObject.it)("parses explicit registry options", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--registry-url",
+            "https://example.com/registry.json",
+            "--registry-path",
+            "/tmp/registry.json"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.registryUrl).toBe("https://example.com/registry.json");
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.registryPath).toBe("/tmp/registry.json");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/run-terminal-bench-official-script.test.d.ts

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

package/dist/tests/run-terminal-bench-official-script.test.js

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { parseOfficialBenchArgs } from "../bench/officialCli.js";
+describe("run-terminal-bench-official cli args", ()=>{
+    it("parses wingman bridge options", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--config",
+            "bench/config.tb2-wingman.json",
+            "--task-id",
+            "heterogeneous-dates",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--wingman-agent",
+            "coding",
+            "--wingman-model",
+            "openai/gpt-5"
+        ]);
+        expect(parsed.configPath).toBe(join(process.cwd(), "bench/config.tb2-wingman.json"));
+        expect(parsed.overrides.taskNames).toEqual([
+            "heterogeneous-dates"
+        ]);
+        expect(parsed.overrides.nAttempts).toBe(3);
+        expect(parsed.overrides.nTasks).toBe(2);
+        expect(parsed.overrides.agentKwargs).toEqual({
+            wingman_agent: "coding",
+            wingman_model: "openai:gpt-5"
+        });
+    });
+    it("uses all dataset tasks when --all-tasks is set", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--task-name",
+            "heterogeneous-dates",
+            "--all-tasks"
+        ]);
+        expect(parsed.overrides.taskNames).toEqual([]);
+    });
+    it("parses explicit registry options", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--registry-url",
+            "https://example.com/registry.json",
+            "--registry-path",
+            "/tmp/registry.json"
+        ]);
+        expect(parsed.overrides.registryUrl).toBe("https://example.com/registry.json");
+        expect(parsed.overrides.registryPath).toBe("/tmp/registry.json");
+    });
+});

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

@@ -4,6 +4,7 @@ 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 imagePersistence_cjs_namespaceObject = require("../cli/core/imagePersistence.cjs");
 const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
 const sessions_cjs_namespaceObject = require("../gateway/http/sessions.cjs");
 const isBunRuntime = void 0 !== globalThis.Bun;
@@ -11,9 +12,11 @@ const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe :
 describeIfBun("sessions API", ()=>{
     let manager;
     let tempDir;
+    let dbPath;
+    const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
     (0, external_vitest_namespaceObject.beforeEach)(async ()=>{
         tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sessions-"));
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "sessions.db");
+        dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "sessions.db");
         manager = new sessionManager_cjs_namespaceObject.SessionManager(dbPath);
         await manager.initialize();
     });
@@ -45,6 +48,23 @@ describeIfBun("sessions API", ()=>{
         (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
         (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
         const created = await createRes.json();
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, created.id);
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
         manager.updateSession(created.id, {
             messageCount: 2,
             lastMessagePreview: "Hello"
@@ -57,10 +77,58 @@ describeIfBun("sessions API", ()=>{
         (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
         const payload = await deleteRes.json();
         (0, external_vitest_namespaceObject.expect)(payload.messageCount).toBe(0);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
         const updated = manager.getSession(created.id);
         (0, external_vitest_namespaceObject.expect)(updated?.messageCount).toBe(0);
         (0, external_vitest_namespaceObject.expect)(updated?.lastMessagePreview).toBeNull();
     });
+    (0, external_vitest_namespaceObject.it)("removes persisted session media when deleting a session", 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: "Delete Session Media"
+            })
+        });
+        const createRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, created.id);
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, deleteReq, new URL(deleteReq.url));
+        (0, external_vitest_namespaceObject.expect)(deleteRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(manager.getSession(created.id)).toBeNull();
+    });
     (0, external_vitest_namespaceObject.it)("returns pending messages and clears them via DELETE", async ()=>{
         const ctx = {
             getSessionManager: async ()=>manager,

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

@@ -1,7 +1,8 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, 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 { getSessionMediaDirectory, persistAssistantImagesToDisk } from "../cli/core/imagePersistence.js";
 import { SessionManager } from "../cli/core/sessionManager.js";
 import { handleSessionsApi } from "../gateway/http/sessions.js";
 const isBunRuntime = void 0 !== globalThis.Bun;
@@ -9,9 +10,11 @@ const describeIfBun = isBunRuntime ? describe : describe.skip;
 describeIfBun("sessions API", ()=>{
     let manager;
     let tempDir;
+    let dbPath;
+    const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
     beforeEach(async ()=>{
         tempDir = mkdtempSync(join(tmpdir(), "wingman-sessions-"));
-        const dbPath = join(tempDir, "sessions.db");
+        dbPath = join(tempDir, "sessions.db");
         manager = new SessionManager(dbPath);
         await manager.initialize();
     });
@@ -43,6 +46,23 @@ describeIfBun("sessions API", ()=>{
         expect(createRes).not.toBeNull();
         expect(createRes?.ok).toBe(true);
         const created = await createRes.json();
+        const mediaDir = getSessionMediaDirectory(dbPath, created.id);
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        expect(existsSync(mediaDir)).toBe(true);
         manager.updateSession(created.id, {
             messageCount: 2,
             lastMessagePreview: "Hello"
@@ -55,10 +75,58 @@ describeIfBun("sessions API", ()=>{
         expect(deleteRes?.ok).toBe(true);
         const payload = await deleteRes.json();
         expect(payload.messageCount).toBe(0);
+        expect(existsSync(mediaDir)).toBe(false);
         const updated = manager.getSession(created.id);
         expect(updated?.messageCount).toBe(0);
         expect(updated?.lastMessagePreview).toBeNull();
     });
+    it("removes persisted session media when deleting a session", 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: "Delete Session Media"
+            })
+        });
+        const createRes = await handleSessionsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        const mediaDir = getSessionMediaDirectory(dbPath, created.id);
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        expect(existsSync(mediaDir)).toBe(true);
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await handleSessionsApi(ctx, deleteReq, new URL(deleteReq.url));
+        expect(deleteRes).not.toBeNull();
+        expect(deleteRes?.ok).toBe(true);
+        expect(existsSync(mediaDir)).toBe(false);
+        expect(manager.getSession(created.id)).toBeNull();
+    });
     it("returns pending messages and clears them via DELETE", async ()=>{
         const ctx = {
             getSessionManager: async ()=>manager,

package/dist/tests/sms-api.test.cjs

@@ -0,0 +1,183 @@
+"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 sms_cjs_namespaceObject = require("../gateway/http/sms.cjs");
+const requireTempDir = (value)=>{
+    if (!value) throw new Error("temp dir not initialized");
+    return value;
+};
+(0, external_vitest_namespaceObject.describe)("sms policy api", ()=>{
+    let tempDir = null;
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (!tempDir) return;
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+        tempDir = null;
+    });
+    (0, external_vitest_namespaceObject.it)("updates, fetches, and resets policy records", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {};
+        const updateReq = new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                stopEnabled: true,
+                pauseForMs: 120000,
+                alertMode: "all"
+            })
+        });
+        const updateRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, updateReq, new URL(updateReq.url));
+        (0, external_vitest_namespaceObject.expect)(updateRes?.status).toBe(200);
+        const updated = await updateRes?.json();
+        (0, external_vitest_namespaceObject.expect)(updated.paused).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(updated.pausedUntil).toBeTypeOf("number");
+        (0, external_vitest_namespaceObject.expect)(updated.stopEnabled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(updated.alertMode).toBe("all");
+        const getRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "GET"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        (0, external_vitest_namespaceObject.expect)(getRes?.status).toBe(200);
+        const listRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request("http://localhost/api/sms/policies", {
+            method: "GET"
+        }), new URL("http://localhost/api/sms/policies"));
+        (0, external_vitest_namespaceObject.expect)(listRes?.status).toBe(200);
+        const listPayload = await listRes?.json();
+        (0, external_vitest_namespaceObject.expect)(listPayload.policies).toHaveLength(1);
+        const deleteRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "DELETE"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.status).toBe(200);
+        const reset = await deleteRes?.json();
+        (0, external_vitest_namespaceObject.expect)(reset.paused).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(reset.stopEnabled).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("applies control commands and leaves non-commands as pass-through text", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const pauseReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "PAUSE 2h",
+                nowMs: 10000
+            })
+        });
+        const pauseRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, pauseReq, new URL(pauseReq.url));
+        (0, external_vitest_namespaceObject.expect)(pauseRes?.status).toBe(200);
+        const pausedPayload = await pauseRes?.json();
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.handled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.command?.name).toBe("pause");
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.policy.paused).toBe(true);
+        const textReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "deploy this now"
+            })
+        });
+        const textRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, textReq, new URL(textReq.url));
+        (0, external_vitest_namespaceObject.expect)(textRes?.status).toBe(200);
+        const textPayload = await textRes?.json();
+        (0, external_vitest_namespaceObject.expect)(textPayload.handled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(textPayload.passThroughText).toBe("deploy this now");
+    });
+    (0, external_vitest_namespaceObject.it)("normalizes inbound messages into command, stopped, or agent results", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const commandReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "HELP"
+            })
+        });
+        const commandRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, commandReq, new URL(commandReq.url));
+        (0, external_vitest_namespaceObject.expect)(commandRes?.status).toBe(200);
+        const commandPayload = await commandRes?.json();
+        (0, external_vitest_namespaceObject.expect)(commandPayload.kind).toBe("command");
+        (0, external_vitest_namespaceObject.expect)(commandPayload.handled).toBe(true);
+        const stopReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "STOP"
+            })
+        });
+        const stopRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, stopReq, new URL(stopReq.url));
+        (0, external_vitest_namespaceObject.expect)(stopRes?.status).toBe(200);
+        const blockedReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures"
+            })
+        });
+        const blockedRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, blockedReq, new URL(blockedReq.url));
+        (0, external_vitest_namespaceObject.expect)(blockedRes?.status).toBe(200);
+        const blockedPayload = await blockedRes?.json();
+        (0, external_vitest_namespaceObject.expect)(blockedPayload.kind).toBe("stopped");
+        (0, external_vitest_namespaceObject.expect)(blockedPayload.responseText).toContain("stopped");
+        store.upsert("sms-macos:+15555550000", {
+            stopEnabled: false
+        });
+        const agentReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures",
+                queueIfBusy: true
+            })
+        });
+        const agentRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, agentReq, new URL(agentReq.url));
+        (0, external_vitest_namespaceObject.expect)(agentRes?.status).toBe(200);
+        const agentPayload = await agentRes?.json();
+        (0, external_vitest_namespaceObject.expect)(agentPayload.kind).toBe("agent");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.agentId).toBe("main");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.content).toBe("summarize my build failures");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.sessionKey).toBe("agent:main:sms-macos:dm:+15555550000");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.routing?.channel).toBe("sms-macos");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.queueIfBusy).toBe(true);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sms-api.test.d.ts

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