shadow-claw 1.51.0 → 1.52.1

package/src/cli/commands/webrtc-listen.test.ts

@@ -400,5 +400,79 @@ describe("webrtc-listen command", () => {
       expect(res1.path.includes("shadow-claw")).toBe(true);
       expect(res1.path.includes("workspace-")).toBe(true);
     });
+
+    it("handles error during runWebRtcListenCommand startup", async () => {
+      const { CliWebRtcListener } =
+        await import("../utils/webrtc-control-client.js");
+      jest
+        .spyOn(CliWebRtcListener.prototype, "start")
+        .mockRejectedValueOnce(new Error("Signaling fail"));
+      const errorSpy = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      await runWebRtcListenCommand({ cacheDir: tmpDir });
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Error starting WebRTC listener: Signaling fail",
+      );
+      expect(process.exitCode).toBe(1);
+      errorSpy.mockRestore();
+    });
+
+    it("wires up IPC command result handler in _setupConnection during runWebRtcListenCommand", async () => {
+      const { CliWebRtcListener } =
+        await import("../utils/webrtc-control-client.js");
+      jest
+        .spyOn(CliWebRtcListener.prototype, "start")
+        .mockImplementation(async function (this: any) {
+          const listeners: Record<string, Function> = {};
+          const mockConn = {
+            on: (ev: string, cb: any) => {
+              listeners[ev] = cb;
+            },
+          };
+          let receivedPayload: any = null;
+          this._pendingIpc.set("cmd-1", (payload: any) => {
+            receivedPayload = payload;
+          });
+
+          this._setupConnection(mockConn, "remote-peer-1");
+
+          // Test non-object/null
+          listeners["data"]?.(null);
+          // Test invalid JSON string
+          listeners["data"]?.("invalid-json");
+          // Test valid command result
+          listeners["data"]?.(
+            JSON.stringify({
+              type: "command:result",
+              payload: { commandId: "cmd-1", success: true },
+            }),
+          );
+
+          expect(receivedPayload).toEqual({
+            commandId: "cmd-1",
+            success: true,
+          });
+          throw new Error("Simulated stop");
+        });
+
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      const errorSpy = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      await runWebRtcListenCommand({
+        cacheDir: tmpDir,
+        secure: true,
+        insecure: true,
+        trustedPeer: ["peer-a", "peer-b"],
+      });
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Error starting WebRTC listener: Simulated stop",
+      );
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
   });
 });

package/src/cli/tools/assert-version-bump.test.ts

@@ -1,8 +1,9 @@
-import { describe, it, expect } from "@jest/globals";
+import { describe, it, expect, jest } from "@jest/globals";
 import {
   parseSemver,
   compareSemver,
   assertVersionBump,
+  main,
 } from "./assert-version-bump.js";
 
 describe("assert-version-bump", () => {
@@ -122,6 +123,34 @@ describe("assert-version-bump", () => {
         }),
       ).resolves.toBeUndefined();
     });
+
+    it("logs message when silent is false and versions pass", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      try {
+        await assertVersionBump({
+          localPkgVersion: "1.23.4",
+          localLockVersion: "1.23.4",
+          wellKnownMcpVersion: "1.23.4",
+          wellKnownServerCardVersion: "1.23.4",
+          pkgName: "shadow-claw",
+          publishedVersion: "1.23.3",
+          silent: false,
+        });
+        expect(logSpy).toHaveBeenCalledWith(
+          expect.stringContaining("Version assertion passed"),
+        );
+      } finally {
+        logSpy.mockRestore();
+      }
+    });
+
+    it("runs main() and validates repository version against npm", async () => {
+      try {
+        await main();
+      } catch (err: any) {
+        expect(err.message).toMatch(/Version assertion failed/);
+      }
+    });
   });
 
   describe("repository live version parity", () => {

package/src/cli/tools/file-search-replace.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, jest } from "@jest/globals";
 
-import { fileSearchReplace, readStdin } from "./file-search-replace.js";
+import { fileSearchReplace, readStdin, main } from "./file-search-replace.js";
 
 describe("readStdin", () => {
   it("joins stdin chunks and trims the result", async () => {
@@ -69,4 +69,36 @@ describe("fileSearchReplace", () => {
     ).rejects.toThrow(SyntaxError);
     expect(readFileImpl).not.toHaveBeenCalled();
   });
+
+  it("joins string chunks in readStdin", async () => {
+    const stdin = (async function* () {
+      yield "  non-buffer ";
+      yield "chunk \n";
+    })();
+
+    await expect(readStdin(stdin)).resolves.toBe("non-buffer chunk");
+  });
+
+  it("main() replaces content when valid arguments are passed", async () => {
+    const fs = await import("node:fs/promises");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "fsr-test-"));
+    const tempFile = path.join(tempDir, "replace-target.txt");
+    await fs.writeFile(tempFile, "apple and orange and apple", "utf8");
+
+    const origLength = process.argv.length;
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    try {
+      process.argv.push("apple", tempFile, "", "banana");
+      await main();
+      const updated = await fs.readFile(tempFile, "utf8");
+      expect(updated).toBe("banana and orange and banana");
+    } finally {
+      process.argv.length = origLength;
+      logSpy.mockRestore();
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
 });

package/src/cli/tools/patch-service-worker-trusted-types.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it, jest } from "@jest/globals";
 
-import { patchServiceWorkerTrustedTypesFile } from "./patch-service-worker-trusted-types.js";
+import {
+  patchServiceWorkerTrustedTypesFile,
+  main,
+} from "./patch-service-worker-trusted-types.js";
 
 describe("patchServiceWorkerTrustedTypesFile", () => {
   it("writes the patched service worker when content changes", async () => {
@@ -69,4 +72,24 @@ describe("patchServiceWorkerTrustedTypesFile", () => {
       }),
     ).rejects.toBe(error);
   });
+
+  it("main() patches target path specified in process.argv[2]", async () => {
+    const fs = await import("node:fs/promises");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "sw-patch-"));
+    const tempFile = path.join(tempDir, "service-worker.js");
+    await fs.writeFile(tempFile, "/* sw content */", "utf8");
+
+    const prevArgv = process.argv;
+    try {
+      process.argv = ["node", "patch.js", tempFile];
+      await main();
+      const content = await fs.readFile(tempFile, "utf8");
+      expect(content).toBeDefined();
+    } finally {
+      process.argv = prevArgv;
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
 });

package/src/cli/tools/touch-nojekyll.test.ts

@@ -15,4 +15,16 @@ describe("touchNoJekyll", () => {
       "utf-8",
     );
   });
+
+  it("uses default project root dist/public when targetDir is omitted", async () => {
+    const writeFileImpl = jest.fn<any>().mockResolvedValue(undefined);
+
+    await touchNoJekyll(undefined, { writeFileImpl });
+
+    expect(writeFileImpl).toHaveBeenCalledWith(
+      expect.stringMatching(/dist\/public\/\.nojekyll$/),
+      "",
+      "utf-8",
+    );
+  });
 });

package/src/cli/tools/version.test.ts

@@ -1,4 +1,11 @@
-import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from "@jest/globals";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -125,10 +132,27 @@ describe("src/cli/tools/version.ts", () => {
       expect(result.versions["shadow-claw"]).toBeDefined();
     });
 
-    it("returns help action when --help flag is provided", async () => {
-      const result = await runVersion(["--help"], { stdio: "pipe" });
-      expect(result.action).toBe("help");
-      expect(result.message).toContain(USAGE_NOTICE);
+    it("logs version map when stdio is inherit and no arguments provided", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      try {
+        const result = await runVersion([], { stdio: "inherit" });
+        expect(result.action).toBe("list");
+        expect(logSpy).toHaveBeenCalled();
+      } finally {
+        logSpy.mockRestore();
+      }
+    });
+
+    it("returns help action and logs USAGE_NOTICE when stdio is inherit", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      try {
+        const result = await runVersion(["--help"], { stdio: "inherit" });
+        expect(result.action).toBe("help");
+        expect(result.message).toContain(USAGE_NOTICE);
+        expect(logSpy).toHaveBeenCalledWith(USAGE_NOTICE);
+      } finally {
+        logSpy.mockRestore();
+      }
     });
 
     it("throws error when disallowed keyword is provided", async () => {
@@ -136,5 +160,85 @@ describe("src/cli/tools/version.ts", () => {
         'Keyword command "minor" is not supported',
       );
     });
+
+    it("handles isLifecycle mode with git directory", async () => {
+      const tempDir = await mkdtemp(path.join(os.tmpdir(), "lifecycle-test-"));
+      try {
+        await writeFile(
+          path.join(tempDir, "package.json"),
+          JSON.stringify({ name: "test-pkg", version: "2.0.0" }),
+          "utf8",
+        );
+        await mkdir(path.join(tempDir, ".well-known/mcp"), { recursive: true });
+        await writeFile(
+          path.join(tempDir, ".well-known/mcp.json"),
+          JSON.stringify({ version: "1.0.0" }),
+          "utf8",
+        );
+        await mkdir(path.join(tempDir, ".git"), { recursive: true });
+
+        const result = await runVersion([], {
+          isLifecycle: true,
+          rootDir: tempDir,
+        });
+
+        expect(result.version).toBe("2.0.0");
+        expect(result.updated).toContain(".well-known/mcp.json");
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    it("handles syncWellKnownVersions JSON parse error gracefully", async () => {
+      const tempDir = await mkdtemp(path.join(os.tmpdir(), "corrupt-test-"));
+      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+      try {
+        await mkdir(path.join(tempDir, ".well-known"), { recursive: true });
+        await writeFile(
+          path.join(tempDir, ".well-known/mcp.json"),
+          "invalid-json",
+          "utf8",
+        );
+
+        const updated = await syncWellKnownVersions("1.2.3", tempDir);
+        expect(updated).toEqual([]);
+        expect(warnSpy).toHaveBeenCalled();
+      } finally {
+        warnSpy.mockRestore();
+        await rm(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    it("executes npm version and syncs well-known when valid semver given", async () => {
+      const tempDir = await mkdtemp(
+        path.join(os.tmpdir(), "npm-version-test-"),
+      );
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      try {
+        await writeFile(
+          path.join(tempDir, "package.json"),
+          JSON.stringify({ name: "version-bump-test", version: "1.0.0" }),
+          "utf8",
+        );
+        await mkdir(path.join(tempDir, ".well-known/mcp"), { recursive: true });
+        await writeFile(
+          path.join(tempDir, ".well-known/mcp.json"),
+          JSON.stringify({ version: "1.0.0" }),
+          "utf8",
+        );
+
+        const result = await runVersion(["1.0.1"], {
+          rootDir: tempDir,
+          stdio: "inherit",
+          execOptions: { cwd: tempDir, stdio: "pipe" },
+        });
+
+        expect(result.version).toBe("1.0.1");
+        expect(result.updated).toContain(".well-known/mcp.json");
+      } finally {
+        logSpy.mockRestore();
+        await rm(tempDir, { recursive: true, force: true });
+      }
+    });
   });
 });

package/src/cli/utils/agent-core.test.ts

@@ -0,0 +1,40 @@
+import { jest } from "@jest/globals";
+import { getAgentCore } from "./agent-core.js";
+
+describe("agent-core", () => {
+  it("loads and caches the headless-agent core module", async () => {
+    const core1 = await getAgentCore();
+    expect(core1).toBeDefined();
+
+    // second call should return cached instance
+    const core2 = await getAgentCore();
+    expect(core2).toBe(core1);
+  });
+
+  it("loads from dist when NODE_ENV is not test", async () => {
+    const prevEnv = process.env.NODE_ENV;
+    try {
+      process.env.NODE_ENV = "production";
+      await jest.isolateModulesAsync(async () => {
+        const { getAgentCore: isolatedGetAgentCore } =
+          await import("./agent-core.js");
+        const core = await isolatedGetAgentCore();
+        expect(core).toBeDefined();
+      });
+    } finally {
+      process.env.NODE_ENV = prevEnv;
+    }
+  });
+
+  it("falls back to dist/headless-agent.js when worker/headless-agent import fails", async () => {
+    await jest.isolateModulesAsync(async () => {
+      jest.unstable_mockModule("../../worker/headless-agent.js", () => {
+        throw new Error("Module failed to load");
+      });
+      const { getAgentCore: isolatedGetAgentCore } =
+        await import("./agent-core.js");
+      const core = await isolatedGetAgentCore();
+      expect(core).toBeDefined();
+    });
+  });
+});

package/src/cli/utils/control-client.test.ts

@@ -1,13 +1,23 @@
 import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
 import express from "express";
-import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from "@jest/globals";
 import {
   openClientStore,
   closeClientStore,
 } from "../../server/client-registry.js";
 import { createControlPlane } from "../../server/control-plane.js";
 import { registerBackupRoutes } from "../../server/routes/backup.js";
-import { CliControlClient } from "./control-client.js";
+import { CliControlClient, resolveControlToken } from "./control-client.js";
 
 describe("src/cli/utils/control-client.ts", () => {
   let app: any;
@@ -39,6 +49,27 @@ describe("src/cli/utils/control-client.ts", () => {
       res.json({ sent: 1, failed: 0, received: req.body });
     });
 
+    app.post("/api/control/command", (req: any, res: any) => {
+      res.json({ ok: true, result: "command-executed", body: req.body });
+    });
+
+    app.delete("/api/backup/:id", (req: any, res: any) => {
+      res.json({ ok: true, deleted: req.params.id });
+    });
+
+    app.get("/push/subscriptions", (_req: any, res: any) => {
+      res.json([
+        { client_id: "client-sub-1", device_label: "Device 1" },
+        { client_id: "client-sub-2" },
+      ]);
+    });
+
+    app.get("/push/clients", (_req: any, res: any) => {
+      res.json({
+        clients: [{ clientId: "client-push-1", deviceLabel: "Push 1" }],
+      });
+    });
+
     await new Promise<void>((resolve) => {
       server.listen(0, "127.0.0.1", () => {
         port = server.address().port;
@@ -149,4 +180,210 @@ describe("src/cli/utils/control-client.ts", () => {
     expect(Array.isArray(clients)).toBe(true);
     expect(client.token).toBe(token);
   });
+
+  it("deletes a backup via deleteBackup", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+    const res = await client.deleteBackup("backup-123", "client-1");
+    expect(res).toEqual({ success: true, deleted: "backup-123" });
+  });
+
+  it("lists push subscriptions and clients", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+    const subs = await client.listPushSubscriptions();
+    expect(subs).toHaveLength(2);
+
+    const pushClients = await client.listPushClients();
+    expect(pushClients).toHaveLength(1);
+    expect(pushClients[0].clientId).toBe("client-push-1");
+  });
+
+  it("sends commands and files via sendCommand and sendFile", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+    await expect(
+      client.sendCommand("client-1", "ping", { foo: "bar" }),
+    ).rejects.toThrow("Client not connected: client-1");
+
+    // sendFile error: file not found
+    await expect(
+      client.sendFile("client-1", "/non/existent/file.txt"),
+    ).rejects.toThrow("File not found");
+
+    // sendFile error: directory
+    await expect(client.sendFile("client-1", os.tmpdir())).rejects.toThrow(
+      "Cannot send directory",
+    );
+
+    // sendFile success attempt
+    const tmpFile = path.join(os.tmpdir(), `test-file-${Date.now()}.txt`);
+    fs.writeFileSync(tmpFile, "hello shadow-claw", "utf8");
+    try {
+      await expect(
+        client.sendFile("client-1", tmpFile, { prompt: "Read this" }),
+      ).rejects.toThrow("Client not connected: client-1");
+    } finally {
+      fs.unlinkSync(tmpFile);
+    }
+  });
+
+  it("supports WebRTC transport delegation and fallbacks", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+      transport: "webrtc",
+    });
+    expect(client._webrtcClient).not.toBeNull();
+
+    // 1. listClients with webrtc clients
+    client._webrtcClient!.listClients = jest
+      .fn()
+      .mockResolvedValue([
+        { clientId: "client-peer-ok", peerId: "peer-ok-id" },
+        { clientId: "client-no-peer" },
+      ]);
+    client._webrtcClient!.sendCommand = jest
+      .fn()
+      .mockResolvedValue({ ok: true, webrtc: true });
+
+    const clients = await client.listClients();
+    expect(clients[0].clientId).toBe("client-peer-ok");
+
+    // 2. sendCommand with matching peerId
+    const cmdRes = await client.sendCommand(
+      "client-peer-ok",
+      "test-action",
+      {},
+    );
+    expect(cmdRes).toEqual({ ok: true, webrtc: true });
+    expect(client._webrtcClient!.sendCommand).toHaveBeenCalledWith(
+      "peer-ok-id",
+      "test-action",
+      {},
+      30000,
+    );
+
+    // 3. sendCommand with matching client that has NO peerId (triggers warn)
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await client.sendCommand("client-no-peer", "test-action", {});
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("has no PeerJS peer ID registered"),
+      );
+    } finally {
+      warnSpy.mockRestore();
+    }
+
+    // 4. listClients fallback to control plane when webrtc listClients returns empty
+    client._webrtcClient!.listClients = jest.fn().mockResolvedValue([]);
+    const cpClients = await client.listClients();
+    expect(Array.isArray(cpClients)).toBe(true);
+  });
+
+  it("resolves control token from cacheDir and custom options", () => {
+    expect(resolveControlToken("custom-tok-123")).toBe("custom-tok-123");
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctrl-tok-test-"));
+    try {
+      const tokFile = path.join(tempDir, "control-token.json");
+      fs.writeFileSync(
+        tokFile,
+        JSON.stringify({ token: "cached-file-tok" }),
+        "utf8",
+      );
+      const resolved = resolveControlToken(undefined, tempDir);
+      expect(resolved).toBe("cached-file-tok");
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to listPushSubscriptions when /push/clients fails", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+    jest
+      .spyOn(client as any, "_request")
+      .mockImplementation(async (opts: any) => {
+        if (opts.path === "/push/clients") {
+          throw new Error("404 Not Found");
+        }
+        if (opts.path === "/push/subscriptions") {
+          return [
+            { client_id: "client-sub-1", device_label: "Device 1" },
+            { client_id: "client-sub-1", device_label: "Device 1 duplicate" },
+            { id: 42, device_label: "Device ID Only" },
+          ];
+        }
+        return {};
+      });
+
+    const pushClients = await client.listPushClients();
+    expect(pushClients).toHaveLength(2);
+    expect(pushClients[0]).toEqual({
+      clientId: "client-sub-1",
+      deviceLabel: "Device 1",
+    });
+    expect(pushClients[1]).toEqual({
+      clientId: "42",
+      deviceLabel: "Device ID Only",
+    });
+  });
+
+  it("falls back to sqlite push-subscriptions.db when both endpoints fail", async () => {
+    const tempDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), "control-client-sqlite-"),
+    );
+    try {
+      const sqlite = (process as any).getBuiltinModule?.("node:sqlite");
+      if (sqlite && sqlite.DatabaseSync) {
+        const dbFile = path.join(tempDir, "push-subscriptions.db");
+        const db = new sqlite.DatabaseSync(dbFile);
+        db.exec(
+          "CREATE TABLE subscriptions (id INTEGER PRIMARY KEY, client_id TEXT, device_label TEXT, created_at INTEGER);",
+        );
+        db.prepare(
+          "INSERT INTO subscriptions (id, client_id, device_label, created_at) VALUES (?, ?, ?, ?)",
+        ).run(1, "sql-client-1", "Desk 1", Date.now());
+        db.prepare(
+          "INSERT INTO subscriptions (id, client_id, device_label, created_at) VALUES (?, ?, ?, ?)",
+        ).run(2, "", "No CID", Date.now());
+        db.close();
+
+        const client = new CliControlClient({
+          host: "127.0.0.1",
+          port,
+          token,
+          cacheDir: tempDir,
+        });
+        jest
+          .spyOn(client as any, "_request")
+          .mockRejectedValue(new Error("Network failure"));
+
+        const clients = await client.listPushClients();
+        expect(clients.length).toBe(2);
+        const c1 = clients.find((c) => c.clientId === "sql-client-1");
+        expect(c1).toBeDefined();
+        expect(c1?.deviceLabel).toBe("Desk 1");
+        const c2 = clients.find((c) => c.clientId === "2");
+        expect(c2).toBeDefined();
+        expect(c2?.deviceLabel).toBe("No CID");
+      }
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
 });