shadow-claw 1.51.0 → 1.52.1

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();
+    });
   });
 });

package/src/cli/commands/send-file.test.ts

@@ -138,4 +138,77 @@ describe("runSendFileCommand", () => {
       expect.stringContaining("The CSV has 2 columns and 1 row."),
     );
   });
+
+  it("fails when path is a directory", async () => {
+    await runSendFileCommand(tempDir, {});
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Cannot send directory"),
+    );
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("fails when no client specified and no clients connected", async () => {
+    const filePath = path.join(tempDir, "file.txt");
+    fs.writeFileSync(filePath, "data", "utf8");
+
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([]);
+
+    await runSendFileCommand(filePath, {});
+
+    expect(errorSpy).toHaveBeenCalledWith("Error: No clients are connected.");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles client transfer failure", async () => {
+    const filePath = path.join(tempDir, "fail.txt");
+    fs.writeFileSync(filePath, "data", "utf8");
+
+    jest
+      .spyOn(CliControlClient.prototype, "sendFile")
+      .mockResolvedValueOnce({ success: false, error: "Disk quota exceeded" });
+
+    await runSendFileCommand(filePath, { client: "client-1" });
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error from client: Disk quota exceeded",
+    );
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles exception thrown during file send", async () => {
+    const filePath = path.join(tempDir, "err.txt");
+    fs.writeFileSync(filePath, "data", "utf8");
+
+    jest
+      .spyOn(CliControlClient.prototype, "sendFile")
+      .mockRejectedValueOnce(new Error("Pipe broken"));
+
+    await runSendFileCommand(filePath, { client: "client-1" });
+
+    expect(errorSpy).toHaveBeenCalledWith("Error sending file: Pipe broken");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("outputs json when --json is passed and no reply text", async () => {
+    const filePath = path.join(tempDir, "json.txt");
+    fs.writeFileSync(filePath, "data", "utf8");
+
+    jest.spyOn(CliControlClient.prototype, "sendFile").mockResolvedValueOnce({
+      success: true,
+      data: { transferredBytes: 4 },
+    });
+
+    await runSendFileCommand(filePath, {
+      client: "client-1",
+      json: true,
+      name: "custom.txt",
+      timeout: 15,
+    });
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('"transferredBytes": 4'),
+    );
+  });
 });

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

@@ -89,4 +89,62 @@ describe("runSendCommand", () => {
       }),
     );
   });
+
+  it("auto-resolves client when client option omitted", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([
+        { clientId: "c-first", deviceLabel: "My Laptop" },
+      ]);
+    const sendSpy = jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({ success: true, data: { status: "ok" } });
+
+    await runSendCommand("Hello first", { timeout: 10, json: true });
+
+    expect(sendSpy).toHaveBeenCalledWith(
+      "c-first",
+      "send-message",
+      { text: "Hello first", groupId: undefined },
+      10000,
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Targeting client: My Laptop (c-first)"),
+    );
+  });
+
+  it("errors when client option omitted and no clients connected", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([]);
+
+    await runSendCommand("Hello nobody", {});
+
+    expect(errorSpy).toHaveBeenCalledWith("Error: No clients are connected.");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles client error response", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({ success: false, error: "Model timeout" });
+
+    await runSendCommand("Hello failure", { client: "client-target" });
+
+    expect(errorSpy).toHaveBeenCalledWith("Error from client: Model timeout");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles exception during sending", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockRejectedValueOnce(new Error("Socket closed"));
+
+    await runSendCommand("Hello exception", { client: "client-target" });
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error sending message: Socket closed",
+    );
+    expect(process.exitCode).toBe(1);
+  });
 });

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

@@ -61,4 +61,82 @@ describe("runTasksCommand", () => {
 
     expect(logSpy).toHaveBeenCalledWith("No tasks configured on client.");
   });
+
+  it("prints empty message with group when no tasks exist for group", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({
+        success: true,
+        data: { tasks: [] },
+      });
+
+    await runTasksCommand({ client: "test-client", group: "my-group" });
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'No tasks configured on client for group "my-group".',
+    );
+  });
+
+  it("resolves default client from listClients when client option omitted", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([{ clientId: "first-client" }]);
+    const sendSpy = jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({
+        success: true,
+        data: {
+          tasks: [{ prompt: "Say hello and do things", enabled: true }],
+        },
+      });
+
+    await runTasksCommand({});
+
+    expect(sendSpy).toHaveBeenCalledWith("first-client", "list-tasks", {
+      groupId: undefined,
+    });
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("1. [enabled] Say hello and do things (manual)"),
+    );
+  });
+
+  it("errors when client option omitted and no clients connected", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "listClients")
+      .mockResolvedValueOnce([]);
+
+    await runTasksCommand({});
+
+    expect(errorSpy).toHaveBeenCalledWith("Error: No clients connected.");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles sendCommand failure", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockResolvedValueOnce({
+        success: false,
+        error: "Client unreachable",
+      });
+
+    await runTasksCommand({ client: "offline-client" });
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Failed to list tasks: Client unreachable",
+    );
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("handles exception thrown during execution", async () => {
+    jest
+      .spyOn(CliControlClient.prototype, "sendCommand")
+      .mockRejectedValueOnce(new Error("Connection reset"));
+
+    await runTasksCommand({ client: "error-client" });
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error executing tasks command: Connection reset",
+    );
+    expect(process.exitCode).toBe(1);
+  });
 });