shadow-claw 1.23.3 → 1.24.0

package/bin/commands/peer-id.mjs

@@ -0,0 +1,76 @@
+/**
+ * ShadowClaw CLI — `peer-id` command
+ * Manages the WebRTC CLI peer ID stored in .cache/cli-peer-id.
+ */
+
+import {
+  getCliPeerIdFilePath,
+  getOrCreateCliPeerId,
+  readCliPeerId,
+  renewCliPeerId,
+} from "../utils/webrtc-control-client.mjs";
+
+export async function runPeerIdCommand(action = "get", options = {}) {
+  const cacheDir = options.cacheDir;
+  const filePath = getCliPeerIdFilePath(cacheDir);
+
+  const shouldRenew = Boolean(
+    options.renew ||
+    action === "renew" ||
+    action === "generate" ||
+    action === "new",
+  );
+  const customSetId =
+    options.set || (action === "set" && options.id ? options.id : null);
+
+  let peerId = "";
+  let isRenewed = false;
+
+  if (customSetId) {
+    peerId = renewCliPeerId(customSetId, cacheDir);
+    isRenewed = true;
+  } else if (shouldRenew) {
+    peerId = renewCliPeerId(undefined, cacheDir);
+    isRenewed = true;
+  } else {
+    const existing = readCliPeerId(cacheDir);
+    if (existing) {
+      peerId = existing;
+      isRenewed = false;
+    } else {
+      peerId = getOrCreateCliPeerId(undefined, cacheDir);
+      isRenewed = true;
+    }
+  }
+
+  if (options.quiet) {
+    console.log(peerId);
+    return { peerId, filePath, isRenewed };
+  }
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          peerId,
+          filePath,
+          renewed: isRenewed,
+        },
+        null,
+        2,
+      ),
+    );
+    return { peerId, filePath, isRenewed };
+  }
+
+  if (customSetId) {
+    console.log(`WebRTC CLI Peer ID set to: ${peerId}`);
+  } else if (isRenewed) {
+    console.log(`WebRTC CLI Peer ID created/renewed: ${peerId}`);
+  } else {
+    console.log(`WebRTC CLI Peer ID: ${peerId}`);
+  }
+  console.log(`Stored in: ${filePath}`);
+
+  return { peerId, filePath, isRenewed };
+}

package/bin/commands/peer-id.test.mjs

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  jest,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+} from "@jest/globals";
+import { runPeerIdCommand } from "./peer-id.mjs";
+import {
+  getCliPeerIdFilePath,
+  readCliPeerId,
+} from "../utils/webrtc-control-client.mjs";
+
+describe("runPeerIdCommand", () => {
+  let tempDir;
+  let logSpy;
+
+  beforeEach(() => {
+    tempDir = path.join(
+      os.tmpdir(),
+      "test-cli-peer-id-" +
+        Date.now() +
+        "-" +
+        Math.random().toString(36).slice(2),
+    );
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    if (logSpy) logSpy.mockRestore();
+    try {
+      if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch (_) {}
+  });
+
+  it("creates and retrieves a new peer ID if none exists", async () => {
+    const result = await runPeerIdCommand("get", { cacheDir: tempDir });
+    expect(result.peerId).toMatch(/^cli-[0-9a-z]+$/);
+    expect(result.isRenewed).toBe(true);
+
+    const saved = readCliPeerId(tempDir);
+    expect(saved).toBe(result.peerId);
+  });
+
+  it("returns existing peer ID without changing it on subsequent calls", async () => {
+    const res1 = await runPeerIdCommand("get", { cacheDir: tempDir });
+    const res2 = await runPeerIdCommand("get", { cacheDir: tempDir });
+
+    expect(res2.peerId).toBe(res1.peerId);
+    expect(res2.isRenewed).toBe(false);
+  });
+
+  it("renews peer ID when action is 'renew'", async () => {
+    const res1 = await runPeerIdCommand("get", { cacheDir: tempDir });
+    const res2 = await runPeerIdCommand("renew", { cacheDir: tempDir });
+
+    expect(res2.peerId).not.toBe(res1.peerId);
+    expect(res2.isRenewed).toBe(true);
+    expect(readCliPeerId(tempDir)).toBe(res2.peerId);
+  });
+
+  it("renews peer ID when --renew flag is passed", async () => {
+    const res1 = await runPeerIdCommand("get", { cacheDir: tempDir });
+    const res2 = await runPeerIdCommand("get", {
+      cacheDir: tempDir,
+      renew: true,
+    });
+
+    expect(res2.peerId).not.toBe(res1.peerId);
+    expect(res2.isRenewed).toBe(true);
+  });
+
+  it("sets a custom peer ID when --set is passed", async () => {
+    const res = await runPeerIdCommand("get", {
+      cacheDir: tempDir,
+      set: "custom-my-peer",
+    });
+
+    expect(res.peerId).toBe("custom-my-peer");
+    expect(res.isRenewed).toBe(true);
+    expect(readCliPeerId(tempDir)).toBe("custom-my-peer");
+  });
+
+  it("supports quiet mode and json mode", async () => {
+    const resQuiet = await runPeerIdCommand("get", {
+      cacheDir: tempDir,
+      quiet: true,
+    });
+    expect(resQuiet.peerId).toBeDefined();
+
+    const resJson = await runPeerIdCommand("get", {
+      cacheDir: tempDir,
+      json: true,
+    });
+    expect(resJson.peerId).toBe(resQuiet.peerId);
+    expect(resJson.filePath).toBe(getCliPeerIdFilePath(tempDir));
+  });
+});

package/bin/commands/send.mjs

@@ -0,0 +1,51 @@
+/**
+ * ShadowClaw CLI — `send` command
+ * Dispatches a prompt / message to a connected client.
+ */
+
+import { CliControlClient } from "../utils/control-client.mjs";
+
+export async function runSendCommand(message, options = {}) {
+  if (!message || typeof message !== "string" || !message.trim()) {
+    console.error("Error: Message cannot be empty.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const client = new CliControlClient(options);
+  try {
+    let targetClientId = options.client;
+
+    if (!targetClientId) {
+      const clients = await client.listClients();
+      if (!clients || clients.length === 0) {
+        console.error("Error: No clients are connected.");
+        process.exitCode = 1;
+        return;
+      }
+      targetClientId = clients[0].clientId;
+      console.log(
+        `Targeting client: ${clients[0].deviceLabel} (${targetClientId})`,
+      );
+    }
+
+    console.log(`Sending message to ${targetClientId}...`);
+    const result = await client.sendCommand(targetClientId, "send-message", {
+      text: message.trim(),
+      groupId: options.group,
+    });
+
+    if (result.success) {
+      console.log("Message successfully dispatched.");
+      if (result.data) {
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    } else {
+      console.error(`Error from client: ${result.error}`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`Error sending message: ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/bin/commands/tasks.mjs

@@ -0,0 +1,59 @@
+/**
+ * ShadowClaw CLI — `tasks` command
+ * Lists scheduled / active tasks on a connected client.
+ */
+
+import { CliControlClient } from "../utils/control-client.mjs";
+
+export async function runTasksCommand(options = {}) {
+  const client = new CliControlClient(options);
+
+  try {
+    let targetClientId = options.client;
+    if (!targetClientId) {
+      const clients = await client.listClients();
+      if (!clients || clients.length === 0) {
+        console.error("Error: No clients connected.");
+        process.exitCode = 1;
+        return;
+      }
+      targetClientId = clients[0].clientId;
+    }
+
+    console.log(
+      `Fetching tasks from client ${targetClientId}${options.group ? ` (group: ${options.group})` : ""}...`,
+    );
+    const result = await client.sendCommand(targetClientId, "list-tasks", {
+      groupId: options.group,
+    });
+
+    if (result.success) {
+      const tasks = result.data?.tasks || [];
+      if (tasks.length === 0) {
+        console.log(
+          options.group
+            ? `No tasks configured on client for group "${options.group}".`
+            : "No tasks configured on client.",
+        );
+        return;
+      }
+
+      console.log(
+        `Tasks on ${targetClientId}${options.group ? ` (group: ${options.group})` : ""} (${tasks.length}):\n`,
+      );
+      tasks.forEach((t, idx) => {
+        const status = t.enabled ? "[enabled]" : "[disabled]";
+        const name = t.name || t.prompt?.slice(0, 30) || "Untitled task";
+        console.log(
+          `  ${idx + 1}. ${status} ${name} (${t.schedule || "manual"})`,
+        );
+      });
+    } else {
+      console.error(`Failed to list tasks: ${result.error}`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`Error executing tasks command: ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/bin/commands/webrtc-listen.mjs

@@ -0,0 +1,254 @@
+/**
+ * ShadowClaw CLI — `webrtc listen` command
+ *
+ * Registers the CLI as a live PeerJS peer on the signaling server so that
+ * browser tabs can initiate WebRTC DataChannel connections to the CLI without
+ * needing a control-plane (SSE/WebSocket) connection.
+ *
+ * Also starts a local IPC HTTP server on a Unix domain socket
+ * (.cache/webrtc-ipc.sock) so that concurrent `send --transport webrtc`
+ * invocations can route through the already-established DataChannel instead
+ * of trying to register the same peer ID a second time.
+ * No port selection, no TCP, no collision.
+ */
+
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import {
+  CliWebRtcListener,
+  getOrCreateCliPeerId,
+  getIpcSocketPath,
+  clearIpcFile,
+} from "../utils/webrtc-control-client.mjs";
+
+function startIpcServer(listener, cacheDir) {
+  return new Promise((resolve, reject) => {
+    const socketPath = getIpcSocketPath(cacheDir);
+
+    // Remove stale socket from a previous run
+    try {
+      fs.unlinkSync(socketPath);
+    } catch (_) {}
+
+    // Ensure .cache dir exists
+    try {
+      fs.mkdirSync(path.dirname(socketPath), { recursive: true });
+    } catch (_) {}
+
+    const server = http.createServer(async (req, res) => {
+      // Health check
+      if (req.method === "GET" && req.url === "/ping") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, peerId: listener.cliPeerId }));
+        return;
+      }
+
+      // List connected WebRTC peers
+      if (req.method === "GET" && req.url === "/clients") {
+        const connectedPeers = Array.from(listener._connections.keys());
+        const clients = connectedPeers.map((peerId) => {
+          const card = listener._peerCards?.get(peerId);
+          return {
+            clientId: peerId,
+            peerId,
+            deviceLabel: card?.name || `Browser Peer (${peerId})`,
+            capabilities: card?.capabilities || ["webrtc", "peerjs"],
+            version: card?.version || "1.0.0",
+            transport: "webrtc",
+            connectedAt: Date.now(),
+            lastSeen: Date.now(),
+          };
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, clients }));
+        return;
+      }
+
+      // Forward command over the established DataChannel
+      if (req.method === "POST" && req.url === "/command") {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", async () => {
+          try {
+            const { targetPeerId, action, args, timeoutMs } = JSON.parse(body);
+
+            if (!targetPeerId) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "targetPeerId is required" }));
+              return;
+            }
+
+            const conn = listener._connections.get(targetPeerId);
+            if (!conn) {
+              const connectedPeers = Array.from(listener._connections.keys());
+              res.writeHead(503, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  error:
+                    `No DataChannel open to peer "${targetPeerId}". ` +
+                    `Make sure the browser has connected to this listener first.` +
+                    (connectedPeers.length
+                      ? ` Connected peers: ${connectedPeers.join(", ")}`
+                      : " No peers are currently connected."),
+                }),
+              );
+              return;
+            }
+
+            const commandId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            const message = {
+              id: commandId,
+              type: "command:execute",
+              payload: { commandId, action, args: args || {} },
+            };
+
+            const result = await new Promise((cmdResolve, cmdReject) => {
+              const timer = setTimeout(() => {
+                listener._pendingIpc.delete(commandId);
+                cmdReject(
+                  new Error(
+                    `Command "${action}" timed out after ${timeoutMs || 30000}ms`,
+                  ),
+                );
+              }, timeoutMs || 30000);
+
+              listener._pendingIpc.set(commandId, (payload) => {
+                clearTimeout(timer);
+                cmdResolve(payload);
+              });
+
+              try {
+                conn.send(message);
+              } catch (err) {
+                clearTimeout(timer);
+                listener._pendingIpc.delete(commandId);
+                cmdReject(err);
+              }
+            });
+
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+          } catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: err.message }));
+          }
+        });
+        return;
+      }
+
+      res.writeHead(404);
+      res.end();
+    });
+
+    server.listen(socketPath, () => {
+      console.log(`[webrtc-listen] IPC socket: ${socketPath}`);
+      resolve(server);
+    });
+
+    server.on("error", reject);
+  });
+}
+
+export async function runWebRtcListenCommand(options = {}) {
+  const host = options.host || process.env.SHADOWCLAW_HOST || "127.0.0.1";
+  const port = options.port
+    ? parseInt(options.port, 10)
+    : parseInt(process.env.SHADOWCLAW_PORT || "8888", 10);
+  const peerPath = options.path || "/";
+  const secure = Boolean(options.secure);
+  const trustedPeerIds = options.trustedPeer
+    ? Array.isArray(options.trustedPeer)
+      ? options.trustedPeer
+      : [options.trustedPeer]
+    : [];
+
+  const cliPeerId = getOrCreateCliPeerId(options.peerId, options.cacheDir);
+
+  console.log(`WebRTC CLI Peer ID : ${cliPeerId}`);
+  console.log(
+    `Signaling server   : ${secure ? "wss" : "ws"}://${host}:${port}${peerPath}`,
+  );
+  if (trustedPeerIds.length > 0) {
+    console.log(`Trusted peers      : ${trustedPeerIds.join(", ")}`);
+  } else {
+    console.log(
+      `Trusted peers      : (any — add --trusted-peer <id> to restrict)`,
+    );
+  }
+  console.log("");
+  console.log("Add this CLI Peer ID as a trusted peer in the browser:");
+  console.log(`  Settings → WebRTC/PeerJS → Trusted Peer IDs → "${cliPeerId}"`);
+  console.log("");
+
+  const listener = new CliWebRtcListener({
+    host,
+    port,
+    path: peerPath,
+    secure,
+    trustedPeerIds,
+    peerId: options.peerId,
+    cacheDir: options.cacheDir,
+    renewPeerId: Boolean(options.renewPeerId),
+    verbose: Boolean(options.verbose),
+  });
+
+  // Map for pending IPC-dispatched commands awaiting DataChannel responses
+  listener._pendingIpc = new Map();
+
+  // Intercept _setupConnection to wire up IPC command result handling
+  const originalSetup = listener._setupConnection.bind(listener);
+  listener._setupConnection = function (conn, remotePeerId) {
+    originalSetup(conn, remotePeerId);
+    conn.on("data", (rawData) => {
+      let msg = rawData;
+      if (typeof rawData === "string") {
+        try {
+          msg = JSON.parse(rawData);
+        } catch (_) {
+          return;
+        }
+      }
+      if (!msg || typeof msg !== "object") return;
+      if (msg.type === "command:result") {
+        const payload = msg.payload || {};
+        const cb = listener._pendingIpc.get(payload.commandId);
+        if (cb) {
+          listener._pendingIpc.delete(payload.commandId);
+          cb(payload);
+        }
+      }
+    });
+  };
+
+  const shutdown = (ipcServer) => {
+    console.log("\n[webrtc-listen] Shutting down…");
+    clearIpcFile(options.cacheDir);
+    if (ipcServer) {
+      try {
+        ipcServer.close();
+      } catch (_) {}
+    }
+    listener.close();
+    process.exit(0);
+  };
+
+  try {
+    await listener.start();
+    const ipcServer = await startIpcServer(listener, options.cacheDir);
+
+    process.on("SIGINT", () => shutdown(ipcServer));
+    process.on("SIGTERM", () => shutdown(ipcServer));
+
+    console.log(
+      `[webrtc-listen] Ready. Run commands with:\n` +
+        `  node bin/cli.mjs send --transport webrtc --client <browser-peer-id> "message"`,
+    );
+
+    await new Promise(() => {}); // keep alive
+  } catch (err) {
+    clearIpcFile(options.cacheDir);
+    console.error(`Error starting WebRTC listener: ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/bin/prerender-dsd-shell/prerender-dsd-shell.test.mjs

@@ -1,15 +1,19 @@
 import {
+  applySidebarVisibilityToTemplate,
   applyStaticPagesContent,
   collectPageSources,
   escapeJsonForHtmlScript,
+  extractTemplateContent,
   injectPageHeaderDsd,
   injectStaticManifestScript,
+  isPageFile,
   markNoSeedPrerenderHost,
   minifyDsdTemplateHtml,
   normalizePrerenderPagesOption,
   prerenderDsdShell,
   renderPageHtml,
   sortPagePaths,
+  splitFrontmatterWithGrayMatter,
 } from "./prerender-dsd-shell.mjs";
 
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
@@ -478,4 +482,46 @@ describe("prerenderDsdShell purge flag pages", () => {
     expect(manifestJson.purgeId).toBe("build-test-999");
     expect(manifestJson.preRenderedStaticPages["br-main"]).toBeDefined();
   });
+
+  describe("prerender helper functions", () => {
+    it("splits frontmatter with gray-matter", () => {
+      const src = "---\ntitle: Hello\n---\n# Content";
+      const res = splitFrontmatterWithGrayMatter(src);
+      expect(res.data.title).toBe("Hello");
+      expect(res.content.trim()).toBe("# Content");
+    });
+
+    it("extracts template content and throws on missing template", () => {
+      const html = "<template><div>Hello</div></template>";
+      expect(extractTemplateContent(html)).toBe("<div>Hello</div>");
+      expect(() => extractTemplateContent("<div>No template</div>")).toThrow(
+        "Template wrapper not found",
+      );
+    });
+
+    it("identifies page files by extension", () => {
+      expect(isPageFile("index.md")).toBe(true);
+      expect(isPageFile("page.html")).toBe(true);
+      expect(isPageFile("script.js")).toBe(false);
+    });
+
+    it("applies sidebar visibility config to template", () => {
+      const tpl =
+        '<li class="nav-item" data-page="chat">Chat</li><li class="nav-item" data-page="files">Files</li>';
+      const modified = applySidebarVisibilityToTemplate(tpl, {
+        chatHidden: true,
+      });
+      expect(modified).toContain('data-page="chat" hidden aria-hidden="true"');
+      expect(modified).not.toContain('data-page="files" hidden');
+    });
+
+    it("minifies DSD template HTML removing excess whitespace and comments", () => {
+      const html =
+        '<template shadowrootmode="open">\n<div>\n  <span>Text</span>\n</div>\n</template>';
+      const minified = minifyDsdTemplateHtml(html);
+      expect(minified).toBe(
+        '<template shadowrootmode="open"><div><span>Text</span></div></template>',
+      );
+    });
+  });
 });