shadow-claw 1.23.3 → 1.24.0

package/bin/rolldown.config.test.mjs

@@ -1,17 +1,410 @@
-import { describe, expect, it } from "@jest/globals";
+import fs from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from "@jest/globals";
 
 import config from "../rolldown.config.mjs";
 
-describe("rolldown bundle splitting", () => {
-  it("enables code splitting for frontend and agent worker bundles", () => {
-    const frontend = config.find(
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe("rolldown.config.mjs", () => {
+  describe("bundle configurations and splitting", () => {
+    it("exports an array of build configs", () => {
+      expect(Array.isArray(config)).toBe(true);
+      expect(config.length).toBeGreaterThanOrEqual(8);
+    });
+
+    it("enables code splitting for frontend and agent worker bundles", () => {
+      const frontend = config.find(
+        (entry) => entry.input === "src/core/index.ts",
+      );
+      const agentWorker = config.find(
+        (entry) => entry.input === "src/worker/worker.ts",
+      );
+
+      expect(frontend?.output?.codeSplitting).toBe(true);
+      expect(agentWorker?.output?.codeSplitting).toBe(true);
+    });
+
+    it("configures theme-init as iife and server/electron as node targets", () => {
+      const themeInit = config.find(
+        (entry) => entry.input === "src/core/theme-init.ts",
+      );
+      const server = config.find(
+        (entry) => entry.input === "src/server/server.ts",
+      );
+      const electron = config.find(
+        (entry) => entry.input === "electron/main.ts",
+      );
+
+      expect(themeInit?.output?.format).toBe("iife");
+      expect(themeInit?.output?.name).toBe("ShadowClawThemeInit");
+      expect(server?.platform).toBe("node");
+      expect(electron?.platform).toBe("node");
+      expect(server?.external).toContain("express");
+      expect(electron?.external).toContain("electron");
+    });
+  });
+
+  describe("aliasTurndownPlugin", () => {
+    const workerConfig = config.find(
+      (entry) => entry.input === "src/worker/worker.ts",
+    );
+    const turndownPlugin = workerConfig?.plugins?.find(
+      (p) => p && p.name === "alias-turndown-for-worker",
+    );
+
+    it("resolves turndown and @mixmark-io/domino IDs", () => {
+      expect(turndownPlugin).toBeDefined();
+      expect(turndownPlugin.resolveId("turndown")).toContain("turndown.es.js");
+      expect(turndownPlugin.resolveId("@mixmark-io/domino")).toContain(
+        "domino",
+      );
+      expect(turndownPlugin.resolveId("other-module")).toBeNull();
+    });
+
+    it("transforms turndown.es.js with domino ESM import", () => {
+      const code =
+        "var domino = require('@mixmark-io/domino');\nconsole.log(domino);";
+      const result = turndownPlugin.transform(
+        code,
+        "/path/to/node_modules/turndown/lib/turndown.es.js",
+      );
+      expect(result).not.toBeNull();
+      expect(result.code).toContain(
+        "import _domino_import from '@mixmark-io/domino';",
+      );
+      expect(result.code).toContain("var domino = _domino_import;");
+
+      // Non-matching id
+      expect(
+        turndownPlugin.transform(code, "/path/to/some-other-file.js"),
+      ).toBeNull();
+    });
+  });
+
+  describe("injectGlobalShimPlugin", () => {
+    const frontendConfig = config.find(
       (entry) => entry.input === "src/core/index.ts",
     );
-    const agentWorker = config.find(
-      (entry) => entry.input === "src/worker/worker.ts",
+    const globalShimPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "inject-global-shim",
+    );
+
+    it("ignores non-node_modules or non-js files", () => {
+      expect(globalShimPlugin).toBeDefined();
+      expect(
+        globalShimPlugin.transform("global.test = 1;", "/src/app.ts"),
+      ).toBeNull();
+      expect(
+        globalShimPlugin.transform(
+          "global.test = 1;",
+          "/node_modules/pkg/index.mjs",
+        ),
+      ).toBeNull();
+    });
+
+    it("skips files without global keyword", () => {
+      expect(
+        globalShimPlugin.transform(
+          "const a = 1;",
+          "/node_modules/pkg/index.js",
+        ),
+      ).toBeNull();
+    });
+
+    it("replaces standalone global with globalThis in node_modules JS files", () => {
+      const input = "var g = typeof global !== 'undefined' ? global : window;";
+      const result = globalShimPlugin.transform(
+        input,
+        "/node_modules/randombytes/browser.js",
+      );
+      expect(result).not.toBeNull();
+      expect(result.code).toContain("globalThis");
+    });
+
+    it("returns null if global is only present as member expression (.global)", () => {
+      const input = "const x = window.global;";
+      const result = globalShimPlugin.transform(
+        input,
+        "/node_modules/pkg/index.js",
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("patchGrayMatterEvalPlugin", () => {
+    const frontendConfig = config.find(
+      (entry) => entry.input === "src/core/index.ts",
+    );
+    const grayMatterPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "patch-gray-matter-direct-eval",
+    );
+
+    it("ignores files not matching gray-matter/lib/engines.js", () => {
+      expect(grayMatterPlugin).toBeDefined();
+      expect(
+        grayMatterPlugin.transform(
+          "return eval(str) || {};",
+          "/src/engines.js",
+        ),
+      ).toBeNull();
+    });
+
+    it("replaces direct eval in gray-matter engines.js", () => {
+      const input = "function js(str) { return eval(str) || {}; }";
+      const result = grayMatterPlugin.transform(
+        input,
+        "/node_modules/gray-matter/lib/engines.js",
+      );
+      expect(result).not.toBeNull();
+      expect(result.code).toContain("return (0, eval)(str) || {};");
+    });
+
+    it("returns null if code in gray-matter engines.js does not contain target eval", () => {
+      const input = "function js(str) { return {}; }";
+      const result = grayMatterPlugin.transform(
+        input,
+        "/node_modules/gray-matter/lib/engines.js",
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("replacePrerenderMainMemoryPlugin", () => {
+    const frontendConfig = config.find(
+      (entry) => entry.input === "src/core/index.ts",
+    );
+    const prerenderPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "replace-prerender-main-memory",
     );
 
-    expect(frontend?.output?.codeSplitting).toBe(true);
-    expect(agentWorker?.output?.codeSplitting).toBe(true);
+    it("returns null if __PRERENDER_MAIN_MEMORY__ is absent", () => {
+      expect(prerenderPlugin).toBeDefined();
+      expect(prerenderPlugin.transform("const a = true;")).toBeNull();
+    });
+
+    it("replaces __PRERENDER_MAIN_MEMORY__ with true by default", () => {
+      const originalEnv = process.env.PRERENDER_MAIN_MEMORY;
+      delete process.env.PRERENDER_MAIN_MEMORY;
+      try {
+        const input = "if (__PRERENDER_MAIN_MEMORY__) { doSomething(); }";
+        const result = prerenderPlugin.transform(input);
+        expect(result).not.toBeNull();
+        expect(result.code).toBe("if (true) { doSomething(); }");
+      } finally {
+        if (originalEnv !== undefined) {
+          process.env.PRERENDER_MAIN_MEMORY = originalEnv;
+        }
+      }
+    });
+
+    it("replaces __PRERENDER_MAIN_MEMORY__ with false when env is 'false'", () => {
+      const originalEnv = process.env.PRERENDER_MAIN_MEMORY;
+      process.env.PRERENDER_MAIN_MEMORY = "false";
+      try {
+        const input = "if (__PRERENDER_MAIN_MEMORY__) { doSomething(); }";
+        const result = prerenderPlugin.transform(input);
+        expect(result).not.toBeNull();
+        expect(result.code).toBe("if (false) { doSomething(); }");
+      } finally {
+        if (originalEnv !== undefined) {
+          process.env.PRERENDER_MAIN_MEMORY = originalEnv;
+        } else {
+          delete process.env.PRERENDER_MAIN_MEMORY;
+        }
+      }
+    });
+  });
+
+  describe("rolldownImportAttributes", () => {
+    const frontendConfig = config.find(
+      (entry) => entry.input === "src/core/index.ts",
+    );
+    const importAttrPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "rolldown-import-attributes",
+    );
+
+    it("returns null for non-html and non-css files", () => {
+      expect(importAttrPlugin).toBeDefined();
+      expect(importAttrPlugin.load("file.ts")).toBeNull();
+      expect(importAttrPlugin.load("file.js")).toBeNull();
+    });
+
+    it("loads and escapes .html templates with <template> tag", () => {
+      const tmpHtmlPath = join(__dirname, "__test_template.html");
+      fs.writeFileSync(
+        tmpHtmlPath,
+        '<template><div class="test">`Hello ${name}`</div></template>',
+        "utf-8",
+      );
+      try {
+        const result = importAttrPlugin.load(tmpHtmlPath);
+        expect(result).not.toBeNull();
+        expect(result.moduleType).toBe("js");
+        expect(result.code).toContain("DOMParser().parseFromString");
+        expect(result.code).toContain("templateEl.content.children");
+        expect(result.code).toContain("\\`Hello \\${name}\\`");
+      } finally {
+        fs.unlinkSync(tmpHtmlPath);
+      }
+    });
+
+    it("loads and escapes .html files without <template> tag", () => {
+      const tmpHtmlPath = join(__dirname, "__test_notemplate.html");
+      fs.writeFileSync(
+        tmpHtmlPath,
+        "<html><head><title>Test</title></head><body><p>Body</p></body></html>",
+        "utf-8",
+      );
+      try {
+        const result = importAttrPlugin.load(tmpHtmlPath);
+        expect(result).not.toBeNull();
+        expect(result.code).toContain(
+          "Array.from(doc.head.children).concat(Array.from(doc.body.children))",
+        );
+      } finally {
+        fs.unlinkSync(tmpHtmlPath);
+      }
+    });
+
+    it("loads and escapes .css stylesheets", () => {
+      const tmpCssPath = join(__dirname, "__test_style.css");
+      fs.writeFileSync(
+        tmpCssPath,
+        ':host { color: red; font-family: `Consolas`; content: "${var}"; }',
+        "utf-8",
+      );
+      try {
+        const result = importAttrPlugin.load(tmpCssPath);
+        expect(result).not.toBeNull();
+        expect(result.moduleType).toBe("js");
+        expect(result.code).toContain("new CSSStyleSheet()");
+        expect(result.code).toContain("sheet.replaceSync");
+      } finally {
+        fs.unlinkSync(tmpCssPath);
+      }
+    });
+  });
+
+  describe("swWatchPlugin", () => {
+    const frontendConfig = config.find(
+      (entry) => entry.input === "src/core/index.ts",
+    );
+    const watchPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "sw-watch-plugin",
+    );
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it("does nothing when --watch or -w is not in argv", () => {
+      expect(watchPlugin).toBeDefined();
+      const origArgv = [...process.argv];
+      process.argv = ["node", "rolldown"];
+      try {
+        watchPlugin.writeBundle();
+        expect(jest.getTimerCount()).toBe(0);
+      } finally {
+        process.argv = origArgv;
+      }
+    });
+
+    it("schedules post-build steps when --watch is in argv", () => {
+      const origArgv = [...process.argv];
+      process.argv = ["node", "rolldown", "--watch"];
+      try {
+        watchPlugin.writeBundle();
+        expect(jest.getTimerCount()).toBe(1);
+        // calling again resets the timer
+        watchPlugin.writeBundle();
+        expect(jest.getTimerCount()).toBe(1);
+      } finally {
+        process.argv = origArgv;
+      }
+    });
+  });
+
+  describe("copy plugin transforms and rename callbacks", () => {
+    const frontendConfig = config.find(
+      (entry) => entry.input === "src/core/index.ts",
+    );
+    const copyPlugin = frontendConfig?.plugins?.find(
+      (p) => p && p.name === "copy",
+    );
+
+    it("verifies copy targets and their transform/rename functions", async () => {
+      expect(copyPlugin).toBeDefined();
+
+      const cssTarget = frontendConfig.plugins
+        .flatMap((p) => (p && p.targets ? p.targets : []))
+        .find((t) => Array.isArray(t.src) && t.src.includes("src/**/*.css"));
+
+      if (cssTarget && typeof cssTarget.rename === "function") {
+        expect(
+          cssTarget.rename(
+            "shadow-claw.css",
+            "",
+            "src/components/shadow-claw/shadow-claw.css",
+          ),
+        ).toBe("components/shadow-claw/shadow-claw.css");
+      }
+
+      const htmlTarget = frontendConfig.plugins
+        .flatMap((p) => (p && p.targets ? p.targets : []))
+        .find((t) => Array.isArray(t.src) && t.src.includes("src/**/*.html"));
+
+      if (htmlTarget && typeof htmlTarget.rename === "function") {
+        expect(
+          htmlTarget.rename(
+            "shadow-claw.html",
+            "",
+            "src/components/shadow-claw/shadow-claw.html",
+          ),
+        ).toBe("components/shadow-claw/shadow-claw.html");
+      }
+    });
+
+    it("transforms files via copy plugin in development and production modes", async () => {
+      expect(copyPlugin).toBeDefined();
+
+      // Test dev mode buildEnd (already loaded with !isProduction)
+      if (typeof copyPlugin.buildEnd === "function") {
+        await copyPlugin.buildEnd();
+      }
+
+      // Test production mode buildEnd
+      const origEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = "production";
+      try {
+        const prodModule = await import(
+          `../rolldown.config.mjs?prodTest=${Date.now()}`
+        );
+        const prodFrontend = prodModule.default.find(
+          (entry) => entry.input === "src/core/index.ts",
+        );
+        const prodCopy = prodFrontend?.plugins?.find(
+          (p) => p && p.name === "copy",
+        );
+        if (prodCopy && typeof prodCopy.buildEnd === "function") {
+          await prodCopy.buildEnd();
+        }
+      } finally {
+        process.env.NODE_ENV = origEnv;
+      }
+    }, 30000);
   });
 });

package/bin/utils/control-client.mjs

@@ -0,0 +1,243 @@
+/**
+ * ShadowClaw CLI — Shared Control Client
+ *
+ * Provides a client library for CLI commands to interact with the ShadowClaw
+ * server control plane and backup REST endpoints.
+ */
+
+import http from "node:http";
+import https from "node:https";
+import path from "node:path";
+import fs from "node:fs";
+import { CliWebRtcControlClient } from "./webrtc-control-client.mjs";
+
+export function resolveControlToken(customToken) {
+  if (customToken && typeof customToken === "string") {
+    return customToken.trim();
+  }
+
+  if (process.env.SHADOWCLAW_CONTROL_TOKEN) {
+    return process.env.SHADOWCLAW_CONTROL_TOKEN.trim();
+  }
+
+  // 1. Try reading from .cache/control-token.json
+  try {
+    const candidates = [
+      path.join(process.cwd(), ".cache", "control-token.json"),
+      path.join(process.cwd(), "control-token.json"),
+    ];
+    for (const filePath of candidates) {
+      if (fs.existsSync(filePath)) {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.token === "string" && parsed.token.trim()) {
+          return parsed.token.trim();
+        }
+      }
+    }
+  } catch (_) {}
+
+  // 2. Try reading from SQLite clients.db if available locally
+  try {
+    let sqlite;
+    if (typeof process.getBuiltinModule === "function") {
+      sqlite = process.getBuiltinModule("node:sqlite");
+    }
+    if (sqlite && sqlite.DatabaseSync) {
+      const candidates = [
+        path.join(process.cwd(), "database", "clients.db"),
+        path.join(process.cwd(), ".cache", "database", "clients.db"),
+      ];
+      for (const dbPath of candidates) {
+        if (fs.existsSync(dbPath)) {
+          const db = new sqlite.DatabaseSync(dbPath);
+          const row = db
+            .prepare("SELECT value FROM metadata WHERE key = 'control_token'")
+            .get();
+          db.close();
+          if (row && row.value) {
+            return `${row.value}`;
+          }
+        }
+      }
+    }
+  } catch (_) {}
+
+  return "";
+}
+
+export class CliControlClient {
+  constructor(options = {}) {
+    this.host = options.host || process.env.SHADOWCLAW_HOST || "127.0.0.1";
+    this.port =
+      options.port || parseInt(process.env.SHADOWCLAW_PORT || "8888", 10);
+    this.token = options.token || resolveControlToken(options.token);
+    this.protocol = options.protocol || "http";
+    this.transport = options.transport || "http";
+    this._webrtcClient =
+      this.transport === "webrtc"
+        ? new CliWebRtcControlClient({
+            host: this.host,
+            port: this.port,
+            path: options.peerPath || "/",
+            secure: this.protocol === "https",
+            peerId: options.peerId,
+            cacheDir: options.cacheDir,
+            renewPeerId: Boolean(options.renewPeerId),
+          })
+        : null;
+  }
+
+  _request({ method = "GET", path: reqPath, body = null, timeout = 30000 }) {
+    return new Promise((resolve, reject) => {
+      const client = this.protocol === "https" ? https : http;
+      const headers = {
+        "Content-Type": "application/json",
+      };
+
+      if (this.token) {
+        headers["x-control-token"] = this.token;
+      }
+
+      const req = client.request(
+        {
+          hostname: this.host,
+          port: this.port,
+          path: reqPath,
+          method,
+          headers,
+          timeout,
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => (data += chunk));
+          res.on("end", () => {
+            let parsed = data;
+            try {
+              parsed = JSON.parse(data);
+            } catch (_) {}
+
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve(parsed);
+            } else {
+              const errMsg =
+                parsed?.error ||
+                `HTTP request failed with status ${res.statusCode}: ${data}`;
+              reject(new Error(errMsg));
+            }
+          });
+        },
+      );
+
+      req.on("error", (err) => {
+        reject(
+          new Error(
+            `Failed to connect to ShadowClaw server at ${this.host}:${this.port}: ${err.message}`,
+          ),
+        );
+      });
+
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error(`Request timed out after ${timeout}ms`));
+      });
+
+      if (body) {
+        req.write(typeof body === "string" ? body : JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+
+  async listClients() {
+    if (this._webrtcClient) {
+      try {
+        const webrtcClients = await this._webrtcClient.listClients();
+        if (webrtcClients && webrtcClients.length > 0) {
+          return webrtcClients;
+        }
+      } catch (_) {}
+
+      // Fallback: query HTTP control plane registry if available
+      try {
+        const data = await this._request({
+          path: "/api/control/clients",
+          method: "GET",
+        });
+        return data.clients || [];
+      } catch (_) {
+        return [];
+      }
+    }
+
+    const data = await this._request({
+      path: "/api/control/clients",
+      method: "GET",
+    });
+    return data.clients || [];
+  }
+
+  async sendCommand(clientId, action, args = {}, timeoutMs = 30000) {
+    if (this._webrtcClient) {
+      let targetPeerId = clientId;
+      // If the target looks like a control-plane client ID ("client-*"), try to
+      // resolve the PeerJS peer ID via the HTTP registry. Otherwise treat it
+      // directly as a PeerJS peer ID so WebRTC works without a control plane.
+      if (clientId && clientId.startsWith("client-")) {
+        try {
+          const clients = await this.listClients();
+          const match = clients.find((c) => c.clientId === clientId);
+          if (match && match.peerId) {
+            targetPeerId = match.peerId;
+          } else if (match && !match.peerId) {
+            console.warn(
+              `Warning: client "${clientId}" has no PeerJS peer ID registered.\n` +
+                `Ensure the browser has PeerJS enabled in Settings → WebRTC/PeerJS and has connected to the signaling server at least once.\n` +
+                `Alternatively, pass the browser's PeerJS peer ID directly with --client <peerId>.`,
+            );
+          }
+        } catch (_) {
+          // Control plane unreachable — fall through and attempt direct connection
+          // (will fail if clientId is truly a client-* and not a PeerJS peer ID)
+        }
+      }
+      return this._webrtcClient.sendCommand(
+        targetPeerId,
+        action,
+        args,
+        timeoutMs,
+      );
+    }
+
+    const data = await this._request({
+      path: "/api/control/command",
+      method: "POST",
+      body: {
+        clientId,
+        action,
+        args,
+        timeoutMs,
+      },
+      timeout: timeoutMs + 5000,
+    });
+    return data;
+  }
+
+  async listBackups(clientId) {
+    const query = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+    const data = await this._request({
+      path: `/api/backup/list${query}`,
+      method: "GET",
+    });
+    return data.backups || [];
+  }
+
+  async deleteBackup(backupId, clientId) {
+    const query = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+    const data = await this._request({
+      path: `/api/backup/${encodeURIComponent(backupId)}${query}`,
+      method: "DELETE",
+    });
+    return data;
+  }
+}