@runfusion/fusion 0.26.0 → 0.27.1

package/dist/pi-claude-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
   "license": "MIT",
   "private": true,

package/dist/pi-claude-cli/src/__tests__/provider.test.ts

@@ -1188,28 +1188,42 @@ describe("streamViaCli", { timeout: 90_000 }, () => {
       expect(doneEvent.message.content).toBeDefined();
     });
 
-    it("logs stderr at warn level on close even with exit code 0", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      const warnSpy = vi.spyOn(console, "warn");
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      proc.stderr.emit("data", Buffer.from("minor warning from cli"));
-      proc.emit("close", 0, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("minor warning from cli"),
-      );
-    });
+    it.each([
+      { code: 0, shouldWarn: false },
+      { code: 42, shouldWarn: true },
+    ])(
+      "FN-3815: routes close stderr logging by exit code=$code",
+      async ({ code, shouldWarn }) => {
+        const model = mockModels[0] as any;
+        const context = {
+          messages: [{ role: "user", content: "Hello" }],
+        };
+
+        const warnSpy = vi.spyOn(console, "warn");
+
+        streamViaCli(model, context);
+        await vi.advanceTimersByTimeAsync(0);
+
+        const proc = (spawn as any).mock.results[0].value;
+
+        proc.stderr.emit("data", Buffer.from("minor warning from cli"));
+        proc.emit("close", code, null);
+        proc.stdout.end();
+        await vi.advanceTimersByTimeAsync(100);
+
+        const stderrWarnCalls = warnSpy.mock.calls.filter(([message]) =>
+          typeof message === "string" &&
+          message.includes("[pi-claude-cli] Claude CLI stderr on close:"),
+        );
+
+        if (shouldWarn) {
+          expect(stderrWarnCalls).toHaveLength(1);
+          expect(stderrWarnCalls[0]?.[0]).toContain("minor warning from cli");
+        } else {
+          expect(stderrWarnCalls).toHaveLength(0);
+        }
+      },
+    );
 
     it("warns when subprocess closes successfully with no content events", async () => {
       const model = mockModels[0] as any;

package/dist/pi-claude-cli/src/provider.ts

@@ -252,7 +252,13 @@ export function streamViaCli(
         if (broken) return; // Break-early kill, expected
         const stderr = getStderr().trim();
         if (stderr) {
-          console.warn(`[pi-claude-cli] Claude CLI stderr on close: ${stderr}`);
+          if (code === 0 || code === null) {
+            // FN-3815: Claude CLI writes benign MCP bring-up diagnostics to stderr
+            // on clean/abort shutdown; keep these debug-only to avoid false TUI warnings.
+            debugLog(`Claude CLI stderr on close (clean exit): ${stderr}`);
+          } else {
+            console.warn(`[pi-claude-cli] Claude CLI stderr on close: ${stderr}`);
+          }
         }
         if (code !== 0 && code !== null) {
           const message = stderr

package/dist/plugins/fusion-plugin-cli-printing-press/manifest.json

@@ -2,5 +2,23 @@
   "id": "fusion-plugin-cli-printing-press",
   "name": "CLI Printing Press",
   "version": "0.1.0",
-  "description": "Generate and manage CLIs for external services using cli-printing-press"
+  "description": "Guided wizard for drafting external service CLI definitions",
+  "dashboardViews": [
+    {
+      "viewId": "wizard",
+      "label": "Create Service CLI",
+      "componentPath": "./dashboard-view",
+      "icon": "Wand2",
+      "placement": "primary",
+      "order": 60
+    },
+    {
+      "viewId": "manage",
+      "label": "Manage Service CLIs",
+      "componentPath": "./manage-view",
+      "icon": "List",
+      "placement": "primary",
+      "order": 61
+    }
+  ]
 }

package/dist/plugins/fusion-plugin-cli-printing-press/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cli-printing-press",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "CLI Printing Press plugin package for Fusion",
   "private": true,
@@ -8,6 +8,14 @@
     ".": {
       "types": "./src/index.ts",
       "import": "./src/index.ts"
+    },
+    "./dashboard-view": {
+      "types": "./src/dashboard-view.tsx",
+      "import": "./src/dashboard-view.tsx"
+    },
+    "./manage-view": {
+      "types": "./src/manage-view.tsx",
+      "import": "./src/manage-view.tsx"
     }
   },
   "scripts": {
@@ -16,10 +24,20 @@
   },
   "dependencies": {
     "@fusion/core": "workspace:*",
-    "@fusion/plugin-sdk": "workspace:*"
+    "@fusion/dashboard": "workspace:*",
+    "@fusion/plugin-sdk": "workspace:*",
+    "express": "^5.1.0",
+    "lucide-react": "^0.542.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.2.4"
   },
   "devDependencies": {
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/express": "^5.0.5",
     "@types/node": "^25.5.2",
+    "@types/react": "^19.0.0",
     "typescript": "^5.7.0",
     "vitest": "^3.2.4"
   }

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/TestRunnerPanel.test.tsx

@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { CliPrintingPressTestRunner } from "../run/TestRunnerPanel";
+import type { ServiceDraft } from "../wizard/types";
+
+vi.mock("lucide-react", () => ({
+  Play: () => null,
+  RefreshCw: () => null,
+  CheckCircle2: () => null,
+  AlertTriangle: () => null,
+}));
+
+function makeDraft(): ServiceDraft {
+  const now = new Date().toISOString();
+  return {
+    id: "draft-1",
+    name: "Demo",
+    slug: "demo",
+    description: "",
+    baseUrl: "https://example.com",
+    transport: "http",
+    endpoints: [{ id: "e1", name: "Ping", method: "GET", path: "/ping", params: "q" }],
+    credential: { kind: "none" },
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+describe("CliPrintingPressTestRunner", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("submits run request and renders output states", async () => {
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      if (url.endsWith("/run")) {
+        return {
+          ok: true,
+          json: async () => ({ stdout: "ok", stderr: "", exitCode: 0, durationMs: 12, timedOut: false, argv: ["demo.mjs", "--endpoint", "e1", "--q", "***"] }),
+        };
+      }
+      if (url.endsWith("/regenerate")) {
+        return { ok: true, json: async () => ({ draft: makeDraft(), artifact: { draftId: "draft-1", slug: "demo", binPath: "/tmp/demo.mjs", entrypoint: "node", generatedAt: new Date().toISOString() } }) };
+      }
+      return { ok: false, status: 404, json: async () => ({ error: "missing" }) };
+    });
+
+    vi.stubGlobal("fetch", fetchMock);
+
+    const user = userEvent.setup();
+    render(<CliPrintingPressTestRunner draftId="draft-1" draft={makeDraft()} />);
+
+    expect(screen.getByRole("combobox")).toBeTruthy();
+    await user.type(screen.getByLabelText("q"), "hello");
+    await user.type(screen.getByPlaceholderText("api_key"), "secret-value");
+    await user.click(screen.getByRole("button", { name: /^Run$/i }));
+
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(expect.stringContaining("/run"), expect.objectContaining({ method: "POST" })));
+    const runCall = fetchMock.mock.calls.find((call) => String(call[0]).endsWith("/run"));
+    expect(runCall).toBeTruthy();
+    expect(JSON.parse(String((runCall?.[1] as RequestInit).body))).toMatchObject({ endpointId: "e1", params: { q: "hello" } });
+    expect(await screen.findByText("ok")).toBeTruthy();
+    expect(screen.queryByText("secret-value")).toBeNull();
+  });
+
+  it("renders error and timeout output states", async () => {
+    let calls = 0;
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/run")) {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            ok: true,
+            json: async () => ({ stdout: "", stderr: "boom", exitCode: 1, durationMs: 22, timedOut: false, argv: ["demo.mjs"] }),
+          };
+        }
+        return {
+          ok: true,
+          json: async () => ({ stdout: "", stderr: "", exitCode: null, durationMs: 33, timedOut: true, argv: ["demo.mjs"] }),
+        };
+      }
+      return { ok: false, status: 404, json: async () => ({ error: "missing" }) };
+    });
+
+    vi.stubGlobal("fetch", fetchMock);
+    const user = userEvent.setup();
+    render(<CliPrintingPressTestRunner draftId="draft-1" draft={makeDraft()} />);
+
+    await user.click(screen.getByRole("button", { name: /^Run$/i }));
+    expect(await screen.findByText("boom")).toBeTruthy();
+    await user.click(screen.getByRole("button", { name: /^Run$/i }));
+    expect(await screen.findByText("Failed")).toBeTruthy();
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/config-flow.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { makeFakeRegistry } from "./fixtures/registry.js";
+import { InvalidCredentialPlacementError, OAuthNotSupportedError } from "../store/cli-press-types.js";
+
+describe("cli press store config flow", () => {
+  it("round-trips service/spec/settings CRUD", () => {
+    const h = makeFakeRegistry();
+    try {
+      const created = h.store.createService({
+        slug: "gamma",
+        displayName: "Gamma Service",
+        description: "gamma",
+        baseUrl: "https://gamma.example.com",
+        sourceKind: "manual",
+      });
+      expect(h.store.getService(created.id)?.slug).toBe("gamma");
+
+      const spec = h.store.createSpec({
+        serviceId: created.id,
+        name: "gamma-cli",
+        version: "1.0.0",
+        generatorVersion: "cli-printing-press",
+        specJson: JSON.stringify({ id: created.id, regeneratedAt: "before" }),
+        status: "draft",
+      });
+
+      const updated = h.store.updateSpec(spec.id, {
+        status: "generated",
+        generatedAt: new Date().toISOString(),
+        specJson: JSON.stringify({ id: created.id, regeneratedAt: "after", artifactPath: "/tmp/gamma" }),
+      });
+      expect(updated.status).toBe("generated");
+      expect(JSON.parse(updated.specJson)).toMatchObject({ regeneratedAt: "after" });
+
+      const setting = h.store.setSetting({
+        serviceId: created.id,
+        key: "runner.timeoutMs",
+        value: "120000",
+        scope: "wizard",
+      });
+      expect(h.store.listSettings(created.id).find((entry) => entry.id === setting.id)?.value).toBe("120000");
+
+      h.store.deleteSpec(spec.id);
+      expect(h.store.getSpec(spec.id)).toBeUndefined();
+      h.store.deleteService(created.id);
+      expect(h.store.getService(created.id)).toBeUndefined();
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("stores credential values encoded and does not expose raw secrets", () => {
+    const h = makeFakeRegistry();
+    try {
+      const acme = h.services.acme;
+      const credential = h.store.listCredentials(acme.id)[0];
+      expect(credential.value).toMatchObject({ encoding: "base64" });
+      expect(JSON.stringify(credential.value)).not.toContain("acme-secret");
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("rejects oauth credentials and mismatched placement", () => {
+    const h = makeFakeRegistry();
+    try {
+      const serviceId = h.services.acme.id;
+      expect(() =>
+        h.store.createCredential({
+          serviceId,
+          name: "oauth",
+          kind: "oauth",
+          placement: { kind: "oauth", provider: "acme" } as never,
+          value: { encoding: "base64", value: "abc" },
+        } as never),
+      ).toThrow(OAuthNotSupportedError);
+
+      expect(() =>
+        h.store.createCredential({
+          serviceId,
+          name: "bad-placement",
+          kind: "header",
+          placement: { kind: "query_param", queryParam: "token" } as never,
+          value: { encoding: "base64", value: "abc" },
+        } as never),
+      ).toThrow(InvalidCredentialPlacementError);
+    } finally {
+      h.cleanup();
+    }
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/dashboard-view.test.tsx

@@ -0,0 +1,40 @@
+// @vitest-environment jsdom
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CliPrintingPressWizardView } from "../dashboard-view";
+
+vi.mock("lucide-react", () => ({ Wand2: () => null }));
+
+describe("CliPrintingPressWizardView", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: true, json: async () => ({ id: "draft-1" }) })));
+  });
+
+  it("walks steps, gates validation, and posts draft", async () => {
+    const user = userEvent.setup();
+    render(<CliPrintingPressWizardView />);
+
+    const next = screen.getByRole("button", { name: "Next" });
+    expect((next as HTMLButtonElement).disabled).toBe(true);
+
+    await user.type(screen.getByLabelText("Name"), "GitHub");
+    await user.type(screen.getByLabelText("Slug"), "github");
+    await user.type(screen.getByLabelText("Base URL"), "https://api.github.com");
+    expect((next as HTMLButtonElement).disabled).toBe(false);
+
+    await user.click(next);
+    await user.click(screen.getByRole("button", { name: "Next" }));
+
+    await user.type(screen.getByPlaceholderText("Name"), "List Repos");
+    await user.type(screen.getByPlaceholderText("/path"), "/user/repos");
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await user.click(screen.getByRole("button", { name: "Next" }));
+
+    await user.click(screen.getByRole("button", { name: "Save draft" }));
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const [, options] = (fetch as any).mock.calls[0];
+    expect(JSON.parse(options.body)).toMatchObject({ name: "GitHub", slug: "github", baseUrl: "https://api.github.com", transport: "http" });
+    expect(await screen.findByText(/Saved — draft id draft-1/)).toBeTruthy();
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/dashboard-views.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { createCliPrintingPressRoutes } from "../routes/wizard-routes.js";
+import { makeFakeRegistry } from "./fixtures/registry.js";
+
+function route(method: string, path: string) {
+  const found = createCliPrintingPressRoutes().find((entry) => entry.method === method && entry.path === path);
+  if (!found) throw new Error(`missing route ${method} ${path}`);
+  return found;
+}
+
+describe("dashboard API route contracts", () => {
+  it("defines expected wizard/list/detail/run endpoints", () => {
+    const routes = createCliPrintingPressRoutes();
+    expect(routes.map((entry) => `${entry.method} ${entry.path}`)).toEqual(
+      expect.arrayContaining([
+        "POST /drafts",
+        "GET /drafts",
+        "GET /drafts/:id",
+        "PUT /drafts/:id",
+        "POST /drafts/:id/regenerate",
+        "POST /drafts/:id/run",
+      ]),
+    );
+  });
+
+  it("supports happy and error API paths", async () => {
+    const h = makeFakeRegistry();
+    try {
+      const ctx = { taskStore: { getRootDir: () => h.rootDir, getDatabase: () => h.db } } as any;
+      const listRes = await route("GET", "/drafts").handler({ params: {} }, ctx);
+      expect(listRes.status).toBe(200);
+
+      const missRes = await route("GET", "/drafts/:id").handler({ params: { id: "missing" } }, ctx);
+      expect(missRes.status).toBe(404);
+
+      const badRun = await route("POST", "/drafts/:id/run").handler({ params: { id: h.services.acme.id }, body: { endpointId: "", params: {} } }, ctx);
+      expect(badRun.status).toBe(400);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("documents plugin-prefixed mount contract", () => {
+    expect("/api/plugins/cli-printing-press/drafts").toContain("/api/plugins/cli-printing-press/");
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/draft-store.test.ts

@@ -0,0 +1,50 @@
+import { mkdtemp, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDraftStore, NotFoundError } from "../storage/draft-store";
+import type { ServiceDraft } from "../wizard/types";
+
+function makeDraft(): ServiceDraft {
+  const now = new Date().toISOString();
+  return { id: "", name: "Demo", slug: "demo", description: "", baseUrl: "https://example.com", transport: "http", endpoints: [{ id: "e1", name: "Ping", method: "GET", path: "/ping" }], credential: { kind: "none" }, createdAt: now, updatedAt: now };
+}
+
+describe("draft store", () => {
+  it("creates, lists, gets, and deletes drafts", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-"));
+    const store = createDraftStore({ rootDir });
+    const created = await store.create(makeDraft());
+    expect(created.id).toBeTruthy();
+    const list = await store.list();
+    expect(list).toHaveLength(1);
+    expect(await store.get(created.id)).toMatchObject({ id: created.id, slug: "demo" });
+    await store.delete(created.id);
+    expect(await store.get(created.id)).toBeNull();
+  });
+
+  it("updates an existing draft and replaces endpoints", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-"));
+    const store = createDraftStore({ rootDir });
+    const created = await store.create(makeDraft());
+
+    const updated = await store.update(created.id, {
+      name: "Renamed",
+      endpoints: [{ id: "e2", name: "Health", method: "GET", path: "/health" }],
+    });
+
+    expect(updated.name).toBe("Renamed");
+    expect(updated.endpoints).toHaveLength(1);
+    expect(updated.endpoints[0]?.id).toBe("e2");
+    expect(updated.updatedAt).not.toBe(created.updatedAt);
+
+    const draftFiles = await readdir(join(rootDir, ".fusion", "plugins", "cli-printing-press", "drafts"));
+    expect(draftFiles.some((entry) => entry.includes(".tmp-"))).toBe(false);
+  });
+
+  it("throws NotFoundError on update for unknown ids", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-"));
+    const store = createDraftStore({ rootDir });
+    await expect(store.update("missing", { name: "Nope" })).rejects.toBeInstanceOf(NotFoundError);
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/fixtures/exec-mock.ts

@@ -0,0 +1,80 @@
+import { execSync } from "node:child_process";
+import { expect, vi } from "vitest";
+
+type ExecResult = {
+  stdout?: string;
+  stderr?: string;
+  code?: number;
+  timeoutAfterMs?: number;
+};
+
+type ExecCall = {
+  command: string;
+  options: Record<string, unknown>;
+};
+
+const calls: ExecCall[] = [];
+const queue: ExecResult[] = [];
+
+vi.mock("node:child_process", () => {
+  const execMock = vi.fn((command: string, options: Record<string, unknown>, callback: (err: Error | null, stdout: string, stderr: string) => void) => {
+    calls.push({ command, options });
+    const next = queue.shift() ?? { stdout: "", stderr: "", code: 0 };
+    if (next.timeoutAfterMs) {
+      const err = new Error(`Command timed out after ${next.timeoutAfterMs}ms`) as Error & { killed?: boolean; signal?: string };
+      err.killed = true;
+      err.signal = "SIGTERM";
+      callback(err, next.stdout ?? "", next.stderr ?? "");
+      return { kill: () => true };
+    }
+    if ((next.code ?? 0) !== 0) {
+      const err = new Error(next.stderr || `Command failed with code ${next.code}`) as Error & {
+        code?: number;
+        stdout?: string;
+        stderr?: string;
+      };
+      err.code = next.code;
+      err.stdout = next.stdout ?? "";
+      err.stderr = next.stderr ?? "";
+      callback(err, next.stdout ?? "", next.stderr ?? "");
+      return { kill: () => true };
+    }
+    callback(null, next.stdout ?? "", next.stderr ?? "");
+    return { kill: () => true };
+  });
+
+  execMock[Symbol.for("nodejs.util.promisify.custom")] = (command: string, options: Record<string, unknown>) =>
+    new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+      execMock(command, options, (error: Error | null, stdout: string, stderr: string) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve({ stdout, stderr });
+      });
+    });
+
+  return {
+    exec: execMock,
+    execSync: vi.fn(() => {
+      throw new Error("execSync should never be called");
+    }),
+  };
+});
+
+export function installExecMock() {
+  calls.length = 0;
+  queue.length = 0;
+
+  return {
+    setNextResult(result: ExecResult) {
+      queue.push(result);
+    },
+    getCalls() {
+      return [...calls];
+    },
+    assertExecSyncUnused() {
+      expect(execSync).not.toHaveBeenCalled();
+    },
+  };
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/fixtures/fixtures.test.ts

@@ -0,0 +1,40 @@
+import { promisify } from "node:util";
+import { describe, expect, it } from "vitest";
+import { makeFakeRegistry } from "./registry.js";
+import { installExecMock } from "./exec-mock.js";
+
+describe("test fixtures", () => {
+  it("creates seeded fake registry", () => {
+    const registry = makeFakeRegistry();
+    try {
+      expect(registry.store.listServices().map((s) => s.slug).sort()).toEqual(["acme", "beta"]);
+      expect(registry.store.listArtifacts(registry.specs.acme.id)).toHaveLength(1);
+      expect(registry.store.listArtifacts(registry.specs.beta.id)).toHaveLength(0);
+    } finally {
+      registry.cleanup();
+    }
+  });
+
+  it("records mocked exec calls", async () => {
+    const execMock = installExecMock();
+    execMock.setNextResult({ stdout: "ok" });
+
+    const { exec } = await import("node:child_process");
+    const execAsync = promisify(exec);
+    const result = await execAsync("node --version", { cwd: "/tmp" });
+
+    expect(result.stdout).toBe("ok");
+    expect(execMock.getCalls()).toEqual([{ command: "node --version", options: { cwd: "/tmp" } }]);
+    execMock.assertExecSyncUnused();
+  });
+
+  it("simulates timeout and blocks execSync", async () => {
+    const execMock = installExecMock();
+    execMock.setNextResult({ timeoutAfterMs: 25, stderr: "timed out" });
+    const { exec, execSync } = await import("node:child_process");
+    const execAsync = promisify(exec);
+
+    await expect(execAsync("echo slow", { timeout: 25 })).rejects.toThrow(/timed out/i);
+    expect(() => execSync("echo no")).toThrow("execSync should never be called");
+  });
+});