shadow-claw 1.52.0 → 1.52.1

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

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