shadow-claw 1.51.0 → 1.52.1

package/src/cli/utils/load-workspace-config.test.ts

@@ -0,0 +1,63 @@
+import { loadWorkspaceConfig } from "./load-workspace-config.js";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+describe("load-workspace-config", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(path.join(os.tmpdir(), "sc-cfg-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns null when no config exists", async () => {
+    const res = await loadWorkspaceConfig(tmpDir);
+    expect(res).toBeNull();
+  });
+
+  it("loads shadow-claw.config.json from workspace", async () => {
+    const cfgPath = path.join(tmpDir, "shadow-claw.config.json");
+    await writeFile(cfgPath, JSON.stringify({ model: "test-model" }), "utf8");
+
+    const res = await loadWorkspaceConfig(tmpDir);
+    expect(res).not.toBeNull();
+    expect(res?.configPath).toBe(cfgPath);
+    expect(res?.config.model).toBe("test-model");
+  });
+
+  it("loads config from contentRoot", async () => {
+    const contentDir = path.join(tmpDir, "content");
+    await mkdir(contentDir, { recursive: true });
+    const cfgPath = path.join(contentDir, "site-config.json");
+    await writeFile(cfgPath, JSON.stringify({ siteName: "My Site" }), "utf8");
+
+    const res = await loadWorkspaceConfig(undefined, contentDir);
+    expect(res).not.toBeNull();
+    expect(res?.configPath).toBe(cfgPath);
+    expect((res?.config as any).siteName).toBe("My Site");
+  });
+
+  it("checks parent directory when workspace is .cache", async () => {
+    const cacheDir = path.join(tmpDir, ".cache");
+    await mkdir(cacheDir, { recursive: true });
+    const cfgPath = path.join(tmpDir, "shadowclaw.config.json");
+    await writeFile(cfgPath, JSON.stringify({ provider: "local" }), "utf8");
+
+    const res = await loadWorkspaceConfig(cacheDir);
+    expect(res).not.toBeNull();
+    expect(res?.configPath).toBe(cfgPath);
+    expect(res?.config.provider).toBe("local");
+  });
+
+  it("handles malformed JSON gracefully", async () => {
+    const cfgPath = path.join(tmpDir, "shadow-claw.config.json");
+    await writeFile(cfgPath, "{ malformed json", "utf8");
+
+    const res = await loadWorkspaceConfig(tmpDir);
+    expect(res).toBeNull();
+  });
+});

package/src/cli/utils/local-models.test.ts

@@ -1242,5 +1242,103 @@ describe("local-models", () => {
         globalThis.fetch = originalFetch;
       }
     });
+
+    it("allows selecting llamafile options 5 through 10", async () => {
+      for (const choice of ["5", "6", "7", "8", "9", "10"]) {
+        const mockStdin = new PassThrough();
+        const mockStdout = new Writable({
+          write(chunk, _encoding, callback) {
+            const str = chunk.toString();
+            if (str.includes("Enter choice [1-12]")) {
+              setImmediate(() => mockStdin.write(`${choice}\n`));
+            } else if (str.includes("Download model weights now?")) {
+              setImmediate(() => mockStdin.write("n\n"));
+            }
+            callback();
+          },
+        });
+        const result = await promptForAgentModel({
+          workspaceDir: tmpDir,
+          contentRoot: tmpDir,
+          cacheDir: tmpDir,
+          stdin: mockStdin,
+          stdout: mockStdout,
+          isTTY: true,
+        });
+        expect(result.providerId).toBe("llamafile");
+      }
+    });
+
+    it("allows direct entry of agentfile, llamafile, openrouter, and onnx models at the main prompt", async () => {
+      const inputs = [
+        { in: "helper.agentfile", p: "agentfile", m: "helper.agentfile" },
+        { in: "worker.llamafile", p: "llamafile", m: "worker.llamafile" },
+        { in: "meta-llama/llama-3", p: "openrouter", m: "meta-llama/llama-3" },
+        {
+          in: "custom-onnx-model",
+          p: "transformers_js_local",
+          m: "custom-onnx-model",
+        },
+      ];
+
+      for (const item of inputs) {
+        const mockStdin = new PassThrough();
+        const mockStdout = new Writable({
+          write(chunk, _encoding, callback) {
+            const str = chunk.toString();
+            if (str.includes("Enter choice [1-12]")) {
+              setImmediate(() => mockStdin.write(`${item.in}\n`));
+            } else if (str.includes("Download model weights now?")) {
+              setImmediate(() => mockStdin.write("n\n"));
+            }
+            callback();
+          },
+        });
+        const result = await promptForAgentModel({
+          workspaceDir: tmpDir,
+          contentRoot: tmpDir,
+          cacheDir: tmpDir,
+          stdin: mockStdin,
+          stdout: mockStdout,
+          isTTY: true,
+        });
+        expect(result.providerId).toBe(item.p);
+        expect(result.model).toBe(item.m);
+      }
+    });
+
+    it("tests isLlamafileLocallyCached and isAgentfileLocallyCached paths", () => {
+      const realFile = path.join(tmpDir, "model.llamafile");
+      fs.writeFileSync(realFile, "binary content", "utf8");
+
+      expect(isLlamafileLocallyCached(realFile)).toBe(true);
+      expect(isLlamafileLocallyCached(realFile, tmpDir)).toBe(true);
+
+      const agentFile = path.join(tmpDir, "model.agentfile");
+      fs.writeFileSync(agentFile, "agent content", "utf8");
+
+      expect(isAgentfileLocallyCached(agentFile)).toBe(true);
+      expect(isAgentfileLocallyCached(agentFile, tmpDir)).toBe(true);
+
+      // Part file returns false
+      const cacheDir = getLlamafileCacheDir(tmpDir);
+      fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(cacheDir, "test.llamafile.part"),
+        "incomplete",
+        "utf8",
+      );
+      expect(isLlamafileLocallyCached("test.llamafile", tmpDir)).toBe(false);
+
+      // Cache dirs with and without custom dir
+      expect(getLlamafileCacheDir()).toContain("llamafile");
+      expect(getAgentfileCacheDir()).toContain("agentfile");
+      expect(getLlamafileCacheDir(tmpDir)).toBe(
+        path.resolve(tmpDir, "llamafile"),
+      );
+      expect(getAgentfileCacheDir(tmpDir)).toBe(
+        path.resolve(tmpDir, "agentfile"),
+      );
+    });
   });
 });

package/src/cli/utils/progress-bar.test.ts

@@ -205,9 +205,48 @@ describe("progress-bar", () => {
         total: 1000,
       });
       bar.update({ status: "done", file: "model.onnx" });
-      bar.finish();
-
       expect(output).toBe("");
     });
+
+    it("handles failure message with prior files in TTY mode", () => {
+      let output = "";
+      const mockStream = {
+        isTTY: true,
+        write: (str: string) => {
+          output += str;
+        },
+      };
+
+      const bar = createCliProgressBar({
+        modelId: "bad-model",
+        stream: mockStream,
+        isTTY: true,
+      });
+
+      bar.update({ status: "progress", file: "part.bin", progress: 10 });
+      bar.fail("Custom failure occurred");
+      expect(output).toContain("Custom failure occurred");
+    });
+
+    it("handles done status directly in non-TTY mode without prior entry and formatBytes negative decimals", () => {
+      let output = "";
+      const mockStream = {
+        isTTY: false,
+        write: (str: string) => {
+          output += str;
+        },
+      };
+
+      const bar = createCliProgressBar({
+        modelId: "quick-model",
+        stream: mockStream,
+        isTTY: false,
+      });
+
+      bar.update({ status: "done", file: "direct-done.bin" });
+      expect(output).toContain("[Download] Finished file: direct-done.bin");
+
+      expect(formatBytes(1536, -1)).toBe("2 KB");
+    });
   });
 });

package/src/cli/utils/resolve-cache-dir.test.ts

@@ -96,6 +96,39 @@ describe("src/cli/utils/resolve-cache-dir.ts", () => {
     expect(resolved).toBe(path.resolve(tempDir, ".legacy-cache"));
   });
 
+  it("checks pages/site-config.json and shadowclaw.config.json variants and handles malformed JSON", async () => {
+    // Malformed JSON should be ignored
+    const badConfigPath = path.join(tempDir, "shadow-claw-config.json");
+    await fs.writeFile(badConfigPath, "{ bad json", "utf8");
+    expect(readConfigFileCacheDir(tempDir)).toBeNull();
+    await fs.unlink(badConfigPath);
+
+    // shadowclaw.config.json variant
+    const shadowclawPath = path.join(tempDir, "shadowclaw.config.json");
+    await fs.writeFile(
+      shadowclawPath,
+      JSON.stringify({ cacheDir: "sc-variant-cache" }),
+      "utf8",
+    );
+    expect(readConfigFileCacheDir(tempDir)).toBe(
+      path.resolve(tempDir, "sc-variant-cache"),
+    );
+    await fs.unlink(shadowclawPath);
+
+    // pages/site-config.json variant
+    const pagesDir = path.join(tempDir, "pages");
+    await fs.mkdir(pagesDir, { recursive: true });
+    const pagesSiteConfig = path.join(pagesDir, "site-config.json");
+    await fs.writeFile(
+      pagesSiteConfig,
+      JSON.stringify({ cacheDir: "pages-sub-cache" }),
+      "utf8",
+    );
+    expect(readConfigFileCacheDir(tempDir)).toBe(
+      path.resolve(tempDir, "pages-sub-cache"),
+    );
+  });
+
   it("respects explicit --tmp option", async () => {
     const result = await resolveCacheDir({
       contentRoot: tempDir,
@@ -366,4 +399,32 @@ describe("src/cli/utils/resolve-cache-dir.ts", () => {
     expect(exitCode).toBe(130);
     expect(output).toContain("Operation cancelled.");
   });
+
+  it("handles explicit databaseDir ending in /database and non-/database", async () => {
+    const res1 = await resolveCacheDir({
+      contentRoot: tempDir,
+      databaseDir: "my-cache/database",
+    });
+    expect(res1.databaseDir).toBe(path.resolve(tempDir, "my-cache/database"));
+    expect(res1.cacheDir).toBe(path.resolve(tempDir, "my-cache"));
+
+    const res2 = await resolveCacheDir({
+      contentRoot: tempDir,
+      databaseDir: "custom-db-dir",
+    });
+    expect(res2.databaseDir).toBe(path.resolve(tempDir, "custom-db-dir"));
+    expect(res2.cacheDir).toBe(path.resolve(tempDir));
+  });
+
+  it("reads server.cacheDir from site-config.json", async () => {
+    const cfgPath = path.join(tempDir, "site-config.json");
+    await fs.writeFile(
+      cfgPath,
+      JSON.stringify({ server: { cacheDir: "server-cache" } }),
+      "utf8",
+    );
+
+    const res = await resolveCacheDir({ contentRoot: tempDir });
+    expect(res.cacheDir).toBe(path.resolve(tempDir, "server-cache"));
+  });
 });

package/src/cli/utils/resolve-project-root.test.ts

@@ -0,0 +1,17 @@
+import { getProjectRoot } from "./resolve-project-root.js";
+import { pathToFileURL } from "node:url";
+
+describe("resolve-project-root", () => {
+  it("resolves the shadow-claw project root from current module url", () => {
+    const root = getProjectRoot();
+    expect(root).toContain("shadow-claw");
+  });
+
+  it("throws when shadow-claw package.json cannot be found", () => {
+    expect(() => {
+      getProjectRoot(pathToFileURL("/").href);
+    }).toThrow(
+      "Could not find shadow-claw project root containing package.json",
+    );
+  });
+});

package/src/cli/utils/stdin.test.ts

@@ -94,6 +94,44 @@ describe("src/cli/utils/stdin.ts - readStdin", () => {
     expect(result).toBe(json);
     expect(JSON.parse(result!)).toEqual({ text: "hello", tone: "happy" });
   });
+
+  it("resolves null on timeoutMs expiration and destroys stream", async () => {
+    const stream = new Readable({ read() {} });
+    const result = await readStdin({ stdin: stream, timeoutMs: 50 });
+    expect(result).toBeNull();
+  });
+
+  it("handles Buffer chunks, timer cleanup on end or error, and default process.stdin", async () => {
+    const stream = new Readable({
+      read() {
+        this.push(Buffer.from("buffer data"));
+        this.push(null);
+      },
+    });
+    (stream as any).setEncoding = null;
+    (stream as any).isTTY = false;
+    const res = await readStdin({ stdin: stream, timeoutMs: 5000 });
+    expect(res).toBe("buffer data");
+
+    const errStream = new Readable({
+      read() {
+        this.emit("error", new Error("with timer error"));
+      },
+    });
+    (errStream as any).isTTY = false;
+    await expect(
+      readStdin({ stdin: errStream, timeoutMs: 5000 }),
+    ).rejects.toThrow("with timer error");
+
+    const origIsTTY = process.stdin.isTTY;
+    try {
+      (process.stdin as any).isTTY = true;
+      const defRes = await readStdin();
+      expect(defRes).toBeNull();
+    } finally {
+      (process.stdin as any).isTTY = origIsTTY;
+    }
+  });
 });
 
 describe("src/cli/utils/stdin.ts - mapTextToToolInput", () => {

package/src/cli/utils/stdio.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 { Readable } from "node:stream";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -55,6 +62,29 @@ describe("src/cli/utils/stdio.ts", () => {
       const result = await readStdin({ stdin: mockStdin, force: true });
       expect(result).toBe("forced stream content");
     });
+
+    it("returns null on stream error", async () => {
+      const mockStdin = new Readable({
+        read() {
+          this.emit("error", new Error("stream read failure"));
+        },
+      });
+      (mockStdin as any).isTTY = false;
+      const result = await readStdin({ stdin: mockStdin });
+      expect(result).toBeNull();
+    });
+
+    it("resolves immediately when stream readableEnded is already true", async () => {
+      const mockStdin = new Readable({
+        read() {
+          this.push(null);
+        },
+      });
+      (mockStdin as any).isTTY = false;
+      Object.defineProperty(mockStdin, "readableEnded", { get: () => true });
+      const result = await readStdin({ stdin: mockStdin });
+      expect(result).toBe("");
+    });
   });
 
   describe("readInputOrStdin", () => {
@@ -130,5 +160,25 @@ describe("src/cli/utils/stdio.ts", () => {
       const content = await readFile(targetFile, "utf8");
       expect(JSON.parse(content)).toEqual({ success: true, count: 42 });
     });
+
+    it("logs string and JSON to console when output is not specified and quiet is false", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      try {
+        await writeOutput("console text output");
+        expect(logSpy).toHaveBeenCalledWith("console text output");
+
+        await writeOutput({ count: 1 });
+        expect(logSpy).toHaveBeenCalledWith(
+          JSON.stringify({ count: 1 }, null, 2),
+        );
+
+        // When quiet is true, does not log
+        logSpy.mockClear();
+        await writeOutput("quiet text", { quiet: true });
+        expect(logSpy).not.toHaveBeenCalled();
+      } finally {
+        logSpy.mockRestore();
+      }
+    });
   });
 });

package/src/cli/utils/suppress-warnings.test.ts

@@ -44,4 +44,13 @@ describe("suppressExperimentalWarnings", () => {
     expect(captured!.warning).toBe("Some other warning");
     expect(captured!.args[0]).toBe("UserWarning");
   });
+
+  it("is idempotent when called multiple times or when emitWarning is absent", () => {
+    suppressExperimentalWarnings();
+    // Second call should return early
+    expect(() => suppressExperimentalWarnings()).not.toThrow();
+
+    process.emitWarning = undefined as any;
+    expect(() => suppressExperimentalWarnings()).not.toThrow();
+  });
 });