shadow-claw 1.52.0 → 1.52.1

package/src/cli/build/build.test.ts

@@ -361,4 +361,99 @@ describe("build without and with pages", () => {
       await rm(tempConsumerRoot, { recursive: true, force: true });
     }
   });
+
+  it("builds an external consumer with copyAllAssets, pagesOrigin, scripts, and service worker", async () => {
+    const tempConsumerRoot = await mkdtemp(
+      path.join(os.tmpdir(), "shadow-claw-consumer-prod-"),
+    );
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+    try {
+      await mkdir(path.join(tempConsumerRoot, "assets/icons"), {
+        recursive: true,
+      });
+      await mkdir(path.join(tempConsumerRoot, "assets/fonts"), {
+        recursive: true,
+      });
+      await writeFile(
+        path.join(tempConsumerRoot, "assets/icons/icon.png"),
+        "icon",
+      );
+      await writeFile(
+        path.join(tempConsumerRoot, "assets/fonts/font.woff2"),
+        "font",
+      );
+      await mkdir(path.join(tempConsumerRoot, ".agents/scripts"), {
+        recursive: true,
+      });
+      await writeFile(
+        path.join(tempConsumerRoot, ".agents/scripts/run.sh"),
+        "echo hi",
+      );
+      await writeFile(
+        path.join(tempConsumerRoot, "manifest.json"),
+        JSON.stringify({ start_url: "/initial" }),
+      );
+
+      // Create a dummy service-worker.js in tempProjectRoot/dist/public if missing
+      const swPath = path.join(
+        tempProjectRoot,
+        "dist/public/service-worker.js",
+      );
+      if (!fs.existsSync(swPath)) {
+        await writeFile(swPath, "// sw dummy\nimportScripts();");
+      }
+
+      await runConsumerBuild({
+        contentRoot: tempConsumerRoot,
+        toolchainRoot: tempProjectRoot,
+        isProduction: true,
+        copyAllAssets: true,
+        pagesOrigin: "https://consumer.example.com",
+        quiet: false,
+        stdio: "pipe",
+      });
+
+      const distDir = path.join(tempConsumerRoot, "dist/public");
+      expect(fs.existsSync(path.join(distDir, ".nojekyll"))).toBe(true);
+      expect(fs.existsSync(path.join(distDir, ".agents/scripts/run.sh"))).toBe(
+        true,
+      );
+
+      const manifest = JSON.parse(
+        await readFile(path.join(distDir, "manifest.json"), "utf8"),
+      );
+      expect(manifest.start_url).toBe("https://consumer.example.com");
+    } finally {
+      logSpy.mockRestore();
+      await rm(tempConsumerRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("builds in-repo with isProduction, copyAllAssets, and prerenderMainMemory false", async () => {
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+    try {
+      await runConsumerBuild({
+        contentRoot: projectRoot,
+        toolchainRoot: projectRoot,
+        isProduction: true,
+        copyAllAssets: true,
+        prerenderMainMemory: false,
+        pagesOrigin: "https://shadow-claw.example.com/",
+        basePath: "/shadow-claw/",
+        quiet: false,
+        stdio: "pipe",
+      });
+
+      const indexHtml = await readFile(
+        path.join(projectRoot, "dist/public/index.html"),
+        "utf8",
+      );
+      expect(indexHtml).toContain('<base href="/shadow-claw/"');
+      expect(
+        fs.existsSync(path.join(projectRoot, "dist/public/.nojekyll")),
+      ).toBe(true);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
 });

package/src/cli/build/build.ts

@@ -341,7 +341,11 @@ export async function runBuild(options: RunBuildOptions = {}): Promise<void> {
         src.includes("/assets/cache/") ||
         src.includes("\\assets\\cache\\") ||
         src.includes("/.cache/") ||
-        src.includes("\\.cache\\");
+        src.includes("\\.cache\\") ||
+        src.includes("/cache/") ||
+        src.includes("\\cache\\") ||
+        src.endsWith("/cache") ||
+        src.endsWith("\\cache");
       return !isCache;
     },
   });

package/src/cli/commands/agent.test.ts

@@ -3267,4 +3267,138 @@ Fetch today's weather.
     expect(calledOpts.model).toBe("test-model");
     expect(calledOpts.agent).toBe(true);
   });
+
+  it("prints usage when unknown subcommand passed to runAgentCommand", async () => {
+    const { runAgentCommand } = await import("./agent.js");
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await runAgentCommand("unknown-command", [], {});
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Usage: shadow-claw agent"),
+    );
+    logSpy.mockRestore();
+  });
+
+  it("handles skill subcommand without name", async () => {
+    const { runAgentCommand } = await import("./agent.js");
+    const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    await runAgentCommand("skill", [], {});
+
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Skill name required"),
+    );
+    expect(process.exitCode).toBe(1);
+    errSpy.mockRestore();
+  });
+
+  it("executes default listenFn dynamically importing webrtc-listen", async () => {
+    const { runAgentCommand } = await import("./agent.js");
+    const { CliWebRtcListener } =
+      await import("../utils/webrtc-control-client.js");
+    jest
+      .spyOn(CliWebRtcListener.prototype, "start")
+      .mockRejectedValueOnce(new Error("Listen stop"));
+    const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    await runAgentCommand("listen", [], { workspace: tmpDir });
+
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Error starting WebRTC listener: Listen stop"),
+    );
+    errSpy.mockRestore();
+  });
+
+  it("dispatches init, skills, tools, tool, clear, and models via runAgentCommand", async () => {
+    const { runAgentCommand } = await import("./agent.js");
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+    const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    // init
+    const initRes = await runAgentCommand("init", [], { workspace: tmpDir });
+    expect(initRes.success).toBe(true);
+
+    // skills (with a skill present)
+    const dummySkillDir = path.join(tmpDir, ".agents/skills/dummy");
+    await mkdir(dummySkillDir, { recursive: true });
+    await writeFile(
+      path.join(dummySkillDir, "SKILL.md"),
+      "---\nname: dummy\ndescription: Test skill description\n---\nBody",
+      "utf8",
+    );
+    const skillsRes = await runAgentCommand("skills", [], {
+      workspace: tmpDir,
+    });
+    expect(skillsRes.skills.length).toBeGreaterThan(0);
+
+    // tools (list)
+    const toolsRes = await runAgentCommand("tools", [], { workspace: tmpDir });
+    expect(toolsRes.tools).toBeDefined();
+
+    // tool (missing name)
+    await runAgentCommand("tool", [], { workspace: tmpDir });
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Tool name required"),
+    );
+
+    // clear
+    const clearRes = await runAgentCommand("clear", [], { workspace: tmpDir });
+    expect(clearRes.success).toBe(true);
+
+    // model list
+    const modelRes = await runAgentCommand("models", ["list"], {
+      workspace: tmpDir,
+      quiet: true,
+    });
+    expect(modelRes.success).toBe(true);
+
+    // tools with toolName
+    const toolCallRes = await runAgentCommand(
+      "tools",
+      ["bash", '{"command":"echo hi"}'],
+      { workspace: tmpDir, quiet: true },
+    );
+    expect(toolCallRes).toBeDefined();
+
+    // skill with skillName
+    await expect(
+      runAgentCommand("skill", ["non-existent-skill"], { workspace: tmpDir }),
+    ).rejects.toThrow("not found in workspace");
+
+    // run with prompt
+    const { getAgentCore } = await import("../utils/agent-core.js");
+    const core = await getAgentCore();
+    const runRes = await runAgentCommand("run", ["Hello agent"], {
+      workspace: tmpDir,
+      provider: "openrouter",
+      apiKey: "sk-test",
+      invokeHandler: async (_db, payload) => {
+        core.post({
+          type: "response",
+          payload: { groupId: payload.groupId, text: "Ready." },
+        });
+      },
+      quiet: true,
+    });
+    expect(runRes.success).toBe(true);
+
+    // run with empty prompt
+    const runEmptyRes = await runAgentCommand("run", [], {
+      workspace: tmpDir,
+      provider: "openrouter",
+      apiKey: "sk-test",
+      invokeHandler: async (_db, payload) => {
+        core.post({
+          type: "response",
+          payload: { groupId: payload.groupId, text: "Ready." },
+        });
+      },
+      quiet: true,
+    });
+    expect(runEmptyRes.success).toBe(false);
+
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+  });
 });

package/src/cli/commands/backup.test.ts

@@ -22,6 +22,7 @@ describe("runBackupCommand", () => {
   afterEach(() => {
     logSpy.mockRestore();
     errorSpy.mockRestore();
+    jest.restoreAllMocks();
     process.exitCode = 0;
   });
 
@@ -64,4 +65,88 @@ describe("runBackupCommand", () => {
     );
     expect(process.exitCode).toBe(1);
   });
+
+  it("deletes backup when backupId is provided", async () => {
+    const deleteSpy = jest
+      .spyOn(CliControlClient.prototype, "deleteBackup")
+      .mockResolvedValueOnce(undefined as any);
+
+    await runBackupCommand("delete", {
+      backupId: "bk-123",
+      client: "client-1",
+    });
+
+    expect(deleteSpy).toHaveBeenCalledWith("bk-123", "client-1");
+    expect(logSpy).toHaveBeenCalledWith("Backup bk-123 deleted.");
+  });
+
+  it("triggers backup with provided client successfully", async () => {
+    const sendSpy = jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({ success: true, data: { fileCount: 10 } });
+
+    await runBackupCommand("trigger", {
+      client: "client-target",
+      group: "grp-1",
+    });
+
+    expect(sendSpy).toHaveBeenCalledWith("client-target", "trigger-backup", {
+      groupId: "grp-1",
+      token: expect.anything(),
+    });
+    expect(logSpy).toHaveBeenCalledWith("Backup completed successfully.");
+  });
+
+  it("triggers backup falling back to first client from listClients", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([{ clientId: "auto-client" }]);
+    const sendSpy = jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({ success: true, data: {} });
+
+    await runBackupCommand("trigger", {});
+
+    expect(sendSpy).toHaveBeenCalledWith("auto-client", "trigger-backup", {
+      groupId: undefined,
+      token: expect.anything(),
+    });
+  });
+
+  it("errors when triggering backup and no clients are connected", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([]);
+
+    await runBackupCommand("trigger", {});
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error: No clients are connected to back up.",
+    );
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles backup failure response", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({ success: false, error: "Disk full" });
+
+    await runBackupCommand("trigger", { client: "client-fail" });
+
+    expect(errorSpy).toHaveBeenCalledWith("Backup failed: Disk full");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles exception thrown during execution", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listBackups")
+      .mockRejectedValueOnce(new Error("Network timeout"));
+
+    await runBackupCommand("list", {});
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error executing backup command: Network timeout",
+    );
+    expect(process.exitCode).toBe(1);
+  });
 });

package/src/cli/commands/clients.test.ts

@@ -57,4 +57,36 @@ describe("runClientsCommand", () => {
       "No clients currently registered or connected.",
     );
   });
+
+  it("formats client without peerId, empty capabilities, and older lastSeen", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([
+        {
+          clientId: "c-old",
+          deviceLabel: "Headless Agent",
+          capabilities: [],
+          version: "2.0.0",
+          lastSeen: Date.now() - 125000,
+        },
+      ]);
+
+    await runClientsCommand({});
+
+    expect(logSpy).toHaveBeenCalledWith("     Capabilities: none");
+    expect(logSpy).toHaveBeenCalledWith("     Last seen:    2m ago\n");
+  });
+
+  it("handles exception during fetch", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockRejectedValueOnce(new Error("Connection refused"));
+
+    await runClientsCommand({});
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error fetching clients: Connection refused",
+    );
+    expect(process.exitCode).toBe(1);
+  });
 });

package/src/cli/commands/mcp.test.ts

@@ -11,7 +11,9 @@ import {
   beforeEach,
   afterEach,
 } from "@jest/globals";
-import { createCliMcpEngine } from "./mcp.js";
+import http from "node:http";
+import readline from "node:readline";
+import { createCliMcpEngine, runMcpCommand } from "./mcp.js";
 
 const pkg = JSON.parse(
   fs.readFileSync(
@@ -1086,5 +1088,262 @@ describe("CLI MCP Engine (createCliMcpEngine)", () => {
       expect(toolNames).not.toContain("shadowclaw_local_write_file");
       expect(toolNames).not.toContain("shadowclaw_local_bash");
     });
+
+    it("supports setting and getting activeClientId", () => {
+      const engine = createCliMcpEngine({});
+      expect(engine.getActiveClientId()).toBe("");
+      engine.setActiveClientId?.("client-custom-1");
+      expect(engine.getActiveClientId()).toBe("client-custom-1");
+    });
+
+    it("handles tasks/get method", async () => {
+      const engine = createCliMcpEngine({});
+      const res = await engine.handleMessage({
+        jsonrpc: "2.0",
+        id: 50,
+        method: "tasks/get",
+        params: { taskId: "task-test-99" },
+      });
+      expect(res.result.task.taskId).toBe("task-test-99");
+      expect(res.result.task.status).toBe("completed");
+    });
+
+    it("handles unknown method returning error or null for notification", async () => {
+      const engine = createCliMcpEngine({});
+      const errRes = await engine.handleMessage({
+        jsonrpc: "2.0",
+        id: 51,
+        method: "unknown/method",
+      });
+      expect(errRes.error.code).toBe(-32601);
+
+      const notifRes = await engine.handleMessage({
+        jsonrpc: "2.0",
+        method: "unknown/notification",
+      });
+      expect(notifRes).toBeNull();
+    });
+
+    it("handles tools/call when no client is available", async () => {
+      const engine = createCliMcpEngine({
+        client: { listClients: async () => [] },
+      });
+      const res = await engine.handleMessage({
+        jsonrpc: "2.0",
+        id: 52,
+        method: "tools/call",
+        params: {
+          name: "remote_tool_1",
+          arguments: {},
+        },
+      });
+      expect(res.result.isError).toBe(true);
+      expect(res.result.content[0].text).toContain(
+        "No connected client available",
+      );
+    });
+
+    it("closes sqlite database when engine.close is invoked after headless context creation", async () => {
+      const tmpDir = await mkdtemp(path.join(tmpdir(), "sc-mcp-close-test-"));
+      const engine = createCliMcpEngine({
+        workspace: tmpDir,
+        localTools: true,
+      });
+
+      // Invoke local tool to initialize headlessContextPromise
+      await engine.handleMessage({
+        jsonrpc: "2.0",
+        id: 53,
+        method: "tools/call",
+        params: {
+          name: "shadowclaw_local_list_files",
+          arguments: {},
+        },
+      });
+
+      // Call close
+      await engine.close?.();
+      await rm(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe("runMcpCommand", () => {
+    let tmpWorkspace: string;
+
+    beforeEach(async () => {
+      tmpWorkspace = await mkdtemp(path.join(tmpdir(), "sc-mcp-cmd-test-"));
+    });
+
+    afterEach(async () => {
+      try {
+        await rm(tmpWorkspace, { recursive: true, force: true });
+      } catch (_) {}
+    });
+
+    it("handles HTTP transport requests including 404, parse error, success, notification, and 500", async () => {
+      let requestHandler: any;
+      const mockServer = {
+        listen: jest.fn((_port: any, _host: any, cb: any) => cb?.()),
+        close: jest.fn(),
+      };
+      jest.spyOn(http, "createServer").mockImplementation((handler: any) => {
+        requestHandler = handler;
+        return mockServer as any;
+      });
+
+      await runMcpCommand({
+        mcpTransport: "http",
+        port: 9999,
+        host: "127.0.0.1",
+        workspace: tmpWorkspace,
+      });
+
+      expect(http.createServer).toHaveBeenCalled();
+      expect(mockServer.listen).toHaveBeenCalledWith(
+        9999,
+        "127.0.0.1",
+        expect.any(Function),
+      );
+
+      // 1. Non-POST or wrong URL -> 404
+      const res404 = {
+        writeHead: jest.fn(),
+        end: jest.fn(),
+      };
+      await requestHandler({ method: "GET", url: "/mcp" }, res404);
+      expect(res404.writeHead).toHaveBeenCalledWith(404, expect.any(Object));
+
+      // Helper to simulate request events
+      const invokeHandler = (reqMeta: any, rawData: string) => {
+        return new Promise<any>((resolve) => {
+          const res = {
+            writeHead: jest.fn(),
+            end: jest.fn(() => resolve(res)),
+          };
+          const handlers: Record<string, Function> = {};
+          const req: any = {
+            method: "POST",
+            url: "/mcp",
+            headers: {},
+            ...reqMeta,
+            on: (event: string, cb: any) => {
+              handlers[event] = cb;
+            },
+          };
+          Promise.resolve(requestHandler(req, res)).then(() => {
+            handlers["data"]?.(rawData);
+            handlers["end"]?.();
+          });
+        });
+      };
+
+      // 2. Parse error -> 400
+      const res400 = await invokeHandler({}, "not-valid-json");
+      expect(res400.writeHead).toHaveBeenCalledWith(400, expect.any(Object));
+
+      // 3. Valid JSON-RPC method -> 200
+      const validReq = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+      });
+      const res200 = await invokeHandler(
+        {
+          headers: {
+            "mcp-protocol-version": "2026-07-28",
+            "mcp-method": "tools/list",
+            "mcp-name": "test-client",
+          },
+        },
+        validReq,
+      );
+      expect(res200.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+
+      // 4. Notification (reply === null) -> 202
+      const notifReq = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+      });
+      const res202 = await invokeHandler({}, notifReq);
+      expect(res202.writeHead).toHaveBeenCalledWith(202);
+
+      // 5. Error during handling -> 500
+      const throwingHeaders = {
+        get ["mcp-protocol-version"]() {
+          throw new Error("Boom headers");
+        },
+      };
+      const res500 = await invokeHandler(
+        { headers: throwingHeaders },
+        validReq,
+      );
+      expect(res500.writeHead).toHaveBeenCalledWith(500, expect.any(Object));
+
+      // Restore
+      jest.spyOn(http, "createServer").mockRestore();
+    });
+
+    it("handles STDIO transport lines including parse error, valid request, notification, and close", async () => {
+      let lineHandler: any;
+      let closeHandler: any;
+      const mockRl = {
+        on: jest.fn((event: string, cb: any) => {
+          if (event === "line") lineHandler = cb;
+          if (event === "close") closeHandler = cb;
+          return mockRl;
+        }),
+      };
+      jest.spyOn(readline, "createInterface").mockReturnValue(mockRl as any);
+      const writeSpy = jest
+        .spyOn(process.stdout, "write")
+        .mockImplementation(() => true);
+
+      await runMcpCommand({
+        mcpTransport: "stdio",
+        workspace: tmpWorkspace,
+      });
+
+      expect(readline.createInterface).toHaveBeenCalled();
+
+      // Empty line ignored
+      await lineHandler("   ");
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // Parse error
+      await lineHandler("bad-json");
+      expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining("-32700"));
+      writeSpy.mockClear();
+
+      // Valid tools/list
+      await lineHandler(
+        JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" }),
+      );
+      expect(writeSpy).toHaveBeenCalledWith(
+        expect.stringContaining('"result"'),
+      );
+      writeSpy.mockClear();
+
+      // Exception during write triggering catch block (lines 1613-1620)
+      writeSpy.mockImplementationOnce(() => {
+        throw new Error("Stdout write failure");
+      });
+      await lineHandler(
+        JSON.stringify({ jsonrpc: "2.0", id: 3, method: "tools/list" }),
+      );
+      expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining("-32603"));
+      writeSpy.mockClear();
+
+      // Notification
+      await lineHandler(
+        JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+      );
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // Close handler
+      await closeHandler();
+
+      writeSpy.mockRestore();
+      jest.spyOn(readline, "createInterface").mockRestore();
+    });
   });
 });