shadow-claw 1.52.0 → 1.52.1

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

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