superacli 1.1.6 → 1.1.8

package/__tests__/resend-plugin.test.js

@@ -1,122 +1,149 @@
-const fs = require("fs")
-const os = require("os")
-const path = require("path")
-const { execSync } = require("child_process")
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execSync } = require("child_process");
 
-const CLI = path.join(__dirname, "..", "cli", "supercli.js")
-const nodeDir = path.dirname(process.execPath)
+const CLI = path.join(__dirname, "..", "cli", "supercli.js");
+const nodeDir = path.dirname(process.execPath);
 
 function runNoServer(args, options = {}) {
   try {
-    const env = { ...process.env }
-    delete env.SUPERCLI_SERVER
+    const env = { ...process.env };
+    delete env.SUPERCLI_SERVER;
     const out = execSync(`node ${CLI} ${args}`, {
       encoding: "utf-8",
       timeout: 15000,
-      env: { ...env, ...(options.env || {}) }
-    })
-    return { ok: true, output: out.trim(), code: 0 }
+      env: { ...env, ...(options.env || {}) },
+    });
+    return { ok: true, output: out.trim(), code: 0 };
   } catch (err) {
     return {
       ok: false,
       output: (err.stdout || "").trim(),
       stderr: (err.stderr || "").trim(),
-      code: err.status
-    }
+      code: err.status,
+    };
   }
 }
 
 function writeFakeCurlBinary(dir) {
-  const bin = path.join(dir, "curl")
-  fs.writeFileSync(bin, [
-    "#!/usr/bin/env node",
-    "const args = process.argv.slice(2);",
-    "const url = args[args.length - 1] || '';",
-    "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
-    "if (url.endsWith('/README.md')) { console.log('# Resend CLI\\n\\nTest readme.'); process.exit(0); }",
-    "process.exit(22);"
-  ].join("\n"), "utf-8")
-  fs.chmodSync(bin, 0o755)
-  return bin
+  const bin = path.join(dir, "curl");
+  fs.writeFileSync(
+    bin,
+    [
+      "#!/usr/bin/env node",
+      "const args = process.argv.slice(2);",
+      "const url = args[args.length - 1] || '';",
+      "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
+      "if (url.endsWith('/README.md')) { console.log('# Resend CLI\\n\\nTest readme.'); process.exit(0); }",
+      "process.exit(22);",
+    ].join("\n"),
+    "utf-8",
+  );
+  fs.chmodSync(bin, 0o755);
+  return bin;
 }
 
 describe("resend hybrid plugin", () => {
-  const fakeBinDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-resend-bin-"))
-  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-resend-"))
-  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-resend-"))
-  writeFakeCurlBinary(fakeBinDir)
-  
+  const fakeBinDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-resend-bin-"));
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-resend-"));
+  const fakeUserHome = fs.mkdtempSync(
+    path.join(os.tmpdir(), "dcli-user-home-resend-"),
+  );
+  writeFakeCurlBinary(fakeBinDir);
+
   const env = {
     ...process.env,
     PATH: `${fakeBinDir}:${process.env.PATH || ""}`,
     SUPERCLI_HOME: tempHome,
-    HOME: fakeUserHome
-  }
-  let removed = false
+    HOME: fakeUserHome,
+  };
+  let removed = false;
 
   beforeAll(() => {
     // Install the plugin
-    const install = runNoServer("plugins install ./plugins/resend --on-conflict replace --json", { env })
+    const install = runNoServer(
+      "plugins install ./plugins/resend --on-conflict replace --json",
+      { env },
+    );
     if (!install.ok) {
-        console.error("Install failed:", install.output, install.stderr)
+      console.error("Install failed:", install.output, install.stderr);
     }
-    expect(install.ok).toBe(true)
-  })
+    expect(install.ok).toBe(true);
+  });
 
   afterAll(() => {
-    if (!removed) runNoServer("plugins remove resend --json", { env })
-    fs.rmSync(fakeBinDir, { recursive: true, force: true })
-    fs.rmSync(tempHome, { recursive: true, force: true })
-    fs.rmSync(fakeUserHome, { recursive: true, force: true })
-  })
+    if (!removed) runNoServer("plugins remove resend --json", { env });
+    fs.rmSync(fakeBinDir, { recursive: true, force: true });
+    fs.rmSync(tempHome, { recursive: true, force: true });
+    fs.rmSync(fakeUserHome, { recursive: true, force: true });
+  });
 
   test("indexes resend skills provider", () => {
-    const list = runNoServer("skills list --catalog --provider resend --json", { env })
-    expect(list.ok).toBe(true)
-    const listData = JSON.parse(list.output)
-    expect(listData.skills.some(skill => skill.id === "resend:root.readme")).toBe(true)
-  })
+    const list = runNoServer("skills list --catalog --provider resend --json", {
+      env,
+    });
+    expect(list.ok).toBe(true);
+    const listData = JSON.parse(list.output);
+    expect(
+      listData.skills.some((skill) => skill.id === "resend:root.readme"),
+    ).toBe(true);
+  });
 
   test("fetches indexed remote skill markdown", () => {
-    const skill = runNoServer("skills get resend:root.readme", { env })
-    expect(skill.ok).toBe(true)
-    expect(skill.output).toContain("Resend CLI")
-  })
+    const skill = runNoServer("skills get resend:root.readme", { env });
+    expect(skill.ok).toBe(true);
+    expect(skill.output).toContain("Resend CLI");
+  });
 
   test("fails with helpful message when resend binary is missing", () => {
-    // Ensure 'resend' is not found, but keep 'node' available
-    const r = runNoServer("resend cli doctor --json", { 
-        env: { ...env, PATH: `${fakeBinDir}:${nodeDir}` } 
-    })
-    expect(r.ok).toBe(false)
-    const data = JSON.parse(r.output || r.stderr)
-    expect(data.error.message).toContain("Missing dependency 'resend'")
-    expect(data.error.message).toContain("Please run 'dcli resend cli setup'")
-  })
+    // Skip test if resend is installed in the same directory as node
+    const resendInNodeDir = fs.existsSync(path.join(nodeDir, "resend"));
+    if (resendInNodeDir) {
+      console.log("Skipping test: resend is installed in node directory");
+      return;
+    }
+
+    // Create a minimal PATH with node but without resend
+    // Only include fakeBinDir (has curl) and nodeDir (has node)
+    const minimalPath = `${fakeBinDir}:${nodeDir}`;
+
+    const r = runNoServer("resend cli doctor --json", {
+      env: { ...env, PATH: minimalPath },
+    });
+    expect(r.ok).toBe(false);
+    const data = JSON.parse(r.output || r.stderr);
+    expect(data.error.message).toContain("Missing dependency 'resend'");
+    expect(data.error.message).toContain("Please run 'dcli resend cli setup'");
+  });
 
   test("exposes expanded structured commands", () => {
-    const help = runNoServer("help resend --json", { env })
-    expect(help.ok).toBe(true)
-    const data = JSON.parse(help.output)
-    
-    const resendNamespace = data.namespaces.find(n => n.name === "resend")
-    expect(resendNamespace).toBeDefined()
-
-    const resources = new Set(resendNamespace.resources.map(r => r.name))
-    
-    expect(resources.has("domains")).toBe(true)
-    expect(resources.has("api-keys")).toBe(true)
-    expect(resources.has("webhooks")).toBe(true)
-    expect(resources.has("contacts")).toBe(true)
-    expect(resources.has("auth")).toBe(true)
-  })
+    const help = runNoServer("help resend --json", { env });
+    expect(help.ok).toBe(true);
+    const data = JSON.parse(help.output);
+
+    const resendNamespace = data.namespaces.find((n) => n.name === "resend");
+    expect(resendNamespace).toBeDefined();
+
+    const resources = new Set(resendNamespace.resources.map((r) => r.name));
+
+    expect(resources.has("domains")).toBe(true);
+    expect(resources.has("api-keys")).toBe(true);
+    expect(resources.has("webhooks")).toBe(true);
+    expect(resources.has("contacts")).toBe(true);
+    expect(resources.has("auth")).toBe(true);
+  });
 
   test("doctor reports node and npm dependencies as healthy", () => {
-    const r = runNoServer("plugins doctor resend --json", { env })
-    expect(r.ok).toBe(true)
-    const data = JSON.parse(r.output)
-    expect(data.ok).toBe(true)
-    expect(data.checks.some(c => c.binary === "node" && c.ok === true)).toBe(true)
-    expect(data.checks.some(c => c.binary === "npm" && c.ok === true)).toBe(true)
-  })
-})
+    const r = runNoServer("plugins doctor resend --json", { env });
+    expect(r.ok).toBe(true);
+    const data = JSON.parse(r.output);
+    expect(data.ok).toBe(true);
+    expect(data.checks.some((c) => c.binary === "node" && c.ok === true)).toBe(
+      true,
+    );
+    expect(data.checks.some((c) => c.binary === "npm" && c.ok === true)).toBe(
+      true,
+    );
+  });
+});

package/__tests__/server-app.test.js

@@ -29,6 +29,7 @@ jest.mock("express", () => {
   mExpress.Router = jest.fn(() => ({
     get: jest.fn(),
     post: jest.fn(),
+    patch: jest.fn(),
     put: jest.fn(),
     delete: jest.fn(),
     use: jest.fn(),

package/__tests__/server-routes-commands.test.js

@@ -39,12 +39,30 @@ describe("server routes - commands", () => {
   })
 
   test("POST / success", async () => {
-    await getHandler(commandsRouter, "post", "/")({ body: { namespace: "n", resource: "r", action: "a" }, headers: {} }, res)
+    await getHandler(commandsRouter, "post", "/")({
+      body: {
+        namespace: "n",
+        resource: "r",
+        action: "a",
+        adapter: "http",
+        adapterConfig: { url: "https://example.com" },
+      },
+      headers: {},
+    }, res)
     expect(res.status).toHaveBeenCalledWith(201)
   })
 
   test("PUT / success", async () => {
-    await getHandler(commandsRouter, "put", "/:id")({ params: { id: "old" }, body: { namespace: "n", resource: "r", action: "a" } }, res)
+    await getHandler(commandsRouter, "put", "/:id")({
+      params: { id: "old" },
+      body: {
+        namespace: "n",
+        resource: "r",
+        action: "a",
+        adapter: "http",
+        adapterConfig: { url: "https://example.com" },
+      },
+    }, res)
     expect(res.json).toHaveBeenCalledWith({ ok: true })
   })
 

package/__tests__/server-routes-plugins.test.js

@@ -0,0 +1,130 @@
+const { EventEmitter } = require("events")
+const pluginsRouter = require("../server/routes/plugins")
+const pluginsService = require("../server/services/pluginsService")
+
+jest.mock("../server/services/pluginsService")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+function multipartReq(fields, file) {
+  const boundary = "----supercli-boundary"
+  const chunks = []
+
+  for (const [name, value] of Object.entries(fields)) {
+    chunks.push(Buffer.from(`--${boundary}\r\n`))
+    chunks.push(Buffer.from(`Content-Disposition: form-data; name="${name}"\r\n\r\n`))
+    chunks.push(Buffer.from(String(value)))
+    chunks.push(Buffer.from("\r\n"))
+  }
+
+  chunks.push(Buffer.from(`--${boundary}\r\n`))
+  chunks.push(Buffer.from("Content-Disposition: form-data; name=\"archive\"; filename=\"plugin.zip\"\r\n"))
+  chunks.push(Buffer.from("Content-Type: application/zip\r\n\r\n"))
+  chunks.push(file)
+  chunks.push(Buffer.from("\r\n"))
+  chunks.push(Buffer.from(`--${boundary}--\r\n`))
+
+  const req = new EventEmitter()
+  req.headers = {
+    "content-type": `multipart/form-data; boundary=${boundary}`,
+  }
+  req.body = undefined
+  req._bodyBuffer = Buffer.concat(chunks)
+  return req
+}
+
+describe("server routes - plugins", () => {
+  let res
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis(),
+      render: jest.fn().mockReturnThis(),
+      setHeader: jest.fn().mockReturnThis(),
+      send: jest.fn().mockReturnThis(),
+    }
+  })
+
+  test("GET / returns plugins and settings", async () => {
+    pluginsService.listServerPlugins.mockResolvedValue([{ name: "resend" }])
+    pluginsService.getSettings.mockResolvedValue({ max_zip_mb: 10, default_hooks_policy: "deny" })
+
+    await getHandler(pluginsRouter, "get", "/")({ query: { format: "json" }, headers: {} }, res)
+
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
+      plugins: [{ name: "resend" }],
+      settings: expect.any(Object),
+    }))
+  })
+
+  test("POST / uses JSON plugin upsert by default", async () => {
+    pluginsService.upsertJsonPlugin.mockResolvedValue({ name: "demo" })
+
+    await getHandler(pluginsRouter, "post", "/")({ body: { name: "demo", manifest: { name: "demo", commands: [] } } }, res)
+
+    expect(pluginsService.upsertJsonPlugin).toHaveBeenCalled()
+    expect(res.status).toHaveBeenCalledWith(201)
+  })
+
+  test("POST /upload parses multipart payload and calls zip upsert", async () => {
+    pluginsService.upsertZipPlugin.mockResolvedValue({ name: "zip-demo" })
+
+    const req = multipartReq(
+      {
+        name: "zip-demo",
+        version: "1.0.0",
+        enabled: "true",
+        hooks_policy: "inherit",
+        manifest: JSON.stringify({ name: "zip-demo", commands: [] }),
+      },
+      Buffer.from([0x50, 0x4b, 0x03, 0x04, 0x00]),
+    )
+
+    const run = getHandler(pluginsRouter, "post", "/upload")(req, res)
+    req.emit("data", req._bodyBuffer)
+    req.emit("end")
+    await run
+
+    expect(pluginsService.upsertZipPlugin).toHaveBeenCalledWith(expect.objectContaining({
+      name: "zip-demo",
+      source_type: "zip",
+      archive_buffer: expect.any(Buffer),
+      manifest: expect.objectContaining({ name: "zip-demo" }),
+    }))
+    expect(res.status).toHaveBeenCalledWith(201)
+  })
+
+  test("PATCH /:name updates metadata", async () => {
+    pluginsService.updatePluginMetadata.mockResolvedValue({ name: "demo", enabled: false })
+
+    await getHandler(pluginsRouter, "patch", "/:name")({ params: { name: "demo" }, body: { enabled: false } }, res)
+
+    expect(pluginsService.updatePluginMetadata).toHaveBeenCalledWith("demo", { enabled: false })
+    expect(res.json).toHaveBeenCalledWith({ ok: true, plugin: { name: "demo", enabled: false } })
+  })
+
+  test("GET /:name/archive sends zip buffer", async () => {
+    pluginsService.getPluginArchiveBuffer.mockResolvedValue(Buffer.from([0x50, 0x4b]))
+
+    await getHandler(pluginsRouter, "get", "/:name/archive")({ params: { name: "demo" } }, res)
+
+    expect(res.setHeader).toHaveBeenCalledWith("Content-Type", "application/zip")
+    expect(res.send).toHaveBeenCalledWith(expect.any(Buffer))
+  })
+
+  test("returns 400 for invalid service input errors", async () => {
+    pluginsService.upsertJsonPlugin.mockRejectedValue(
+      Object.assign(new Error("bad payload"), { code: 85, type: "invalid_argument" }),
+    )
+
+    await getHandler(pluginsRouter, "post", "/")({ body: { source_type: "json" } }, res)
+
+    expect(res.status).toHaveBeenCalledWith(400)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ error: "bad payload" }))
+  })
+})

package/__tests__/skills.test.js

@@ -1,9 +1,11 @@
 const {
   MCP_SERVERS_USAGE_SKILL_ID,
+  PLUGINS_AUTHORING_SKILL_ID,
   normalizeSkillId,
   buildCommandSkillMarkdown,
   buildTeachSkillMarkdown,
   buildPluginsUsageSkillMarkdown,
+  buildPluginsAuthoringSkillMarkdown,
   buildMcpServersUsageSkillMarkdown,
   listSkillsMetadata,
   handleSkillsCommand,
@@ -99,6 +101,14 @@ describe("skills", () => {
     expect(md).toContain("# Instruction")
   })
 
+  test("buildPluginsAuthoringSkillMarkdown returns markdown", () => {
+    const md = buildPluginsAuthoringSkillMarkdown({ showDag: true })
+    expect(md).toContain("skill_name: \"plugins_authoring_usage\"")
+    expect(md).toContain("plugins/<name>/")
+    expect(md).toContain("~/.supercli/plugins/local/<name>/")
+    expect(md).toContain("dag:")
+  })
+
   test("buildMcpServersUsageSkillMarkdown returns markdown", () => {
     const md = buildMcpServersUsageSkillMarkdown({ showDag: true })
     expect(md).toContain("skill_name: \"mcp_servers_usage\"")
@@ -120,6 +130,8 @@ describe("skills", () => {
     expect(item.description).toBe("desc")
     const mcpSkill = skills.find(s => s.name === MCP_SERVERS_USAGE_SKILL_ID)
     expect(mcpSkill).toBeTruthy()
+    const authoringSkill = skills.find(s => s.name === PLUGINS_AUTHORING_SKILL_ID)
+    expect(authoringSkill).toBeTruthy()
   })
 
   describe("handleSkillsCommand", () => {
@@ -236,6 +248,20 @@ describe("skills", () => {
       consoleSpy.mockRestore()
     })
 
+    test("get subcommand (plugins authoring usage)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "plugins.authoring.usage"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("skill_name: \"plugins_authoring_usage\""))
+      consoleSpy.mockRestore()
+    })
+
     test("get subcommand (mcp servers usage)", () => {
       const consoleSpy = jest.spyOn(console, "log").mockImplementation()
       const result = handleSkillsCommand({

package/__tests__/squirrelscan-plugin.test.js

@@ -0,0 +1,129 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeDockerBinary(dir) {
+  const bin = path.join(dir, "docker")
+  const statePath = path.join(dir, "docker-state.json")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "const args = process.argv.slice(2);",
+    "const statePath = path.join(__dirname, 'docker-state.json');",
+    "const state = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, 'utf-8')) : { built: false, buildCount: 0 };",
+    "const save = () => fs.writeFileSync(statePath, JSON.stringify(state));",
+    "if (args.includes('--version')) { console.log('Docker version 26.1.0, build test'); process.exit(0); }",
+    "if (args[0] === 'image' && args[1] === 'inspect') { process.exit(state.built ? 0 : 1); }",
+    "if (args[0] === 'build') { state.built = true; state.buildCount += 1; save(); console.log('build ok'); process.exit(0); }",
+    "if (args[0] === 'run') { console.log(JSON.stringify({ ok: true, args })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return statePath
+}
+
+describe("squirrelscan plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-squirrelscan-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-squirrelscan-"))
+  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-squirrelscan-"))
+  const statePath = writeFakeDockerBinary(fakeDir)
+  const env = {
+    ...process.env,
+    PATH: `${fakeDir}:${process.env.PATH || ""}`,
+    SUPERCLI_HOME: tempHome,
+    HOME: fakeUserHome,
+  }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/squirrelscan --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove squirrelscan --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+    fs.rmSync(fakeUserHome, { recursive: true, force: true })
+  })
+
+  test("runs squirrel audit in docker with passthrough args", () => {
+    const r = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+    expect(r.ok).toBe(true)
+
+    const payload = JSON.parse(r.output)
+    expect(payload.command).toBe("squirrel.passthrough")
+
+    const dockerPayload = JSON.parse(payload.data.raw)
+    expect(dockerPayload.args[0]).toBe("run")
+    expect(dockerPayload.args).toContain("dcli-squirrelscan:0.0.38")
+    expect(dockerPayload.args).toContain("audit")
+    expect(dockerPayload.args).toContain("https://example.com")
+    expect(dockerPayload.args).toContain("-C")
+    expect(dockerPayload.args).toContain("quick")
+    expect(dockerPayload.args).toContain("dcli-squirrelscan-home:/root/.squirrel")
+  })
+
+  test("routes structured audit command to squirrel audit", () => {
+    const r = runNoServer("squirrel audit run --url https://example.com --coverage quick --json", { env })
+    expect(r.ok).toBe(true)
+
+    const payload = JSON.parse(r.output)
+    expect(payload.command).toBe("squirrel.audit.run")
+
+    const dockerPayload = JSON.parse(payload.data.raw)
+    expect(dockerPayload.args).toContain("audit")
+    expect(dockerPayload.args).toContain("https://example.com")
+    expect(dockerPayload.args).toContain("--coverage")
+    expect(dockerPayload.args).toContain("quick")
+  })
+
+  test("exposes learn content for agents", () => {
+    const r = runNoServer("plugins learn squirrelscan --json", { env })
+    expect(r.ok).toBe(true)
+    const payload = JSON.parse(r.output)
+    expect(payload.plugin).toBe("squirrelscan")
+    expect(payload.learn_markdown).toContain("SquirrelScan Quickstart")
+  })
+
+  test("registers squirrelscan skills provider in catalog", () => {
+    const r = runNoServer("skills list --catalog --provider squirrelscan --json", { env })
+    expect(r.ok).toBe(true)
+    const payload = JSON.parse(r.output)
+    expect(Array.isArray(payload.skills)).toBe(true)
+    expect(payload.skills.some(skill => skill.id === "squirrelscan:quickstart")).toBe(true)
+  })
+
+  test("builds image once and reuses on subsequent runs", () => {
+    const first = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+    const second = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+
+    expect(first.ok).toBe(true)
+    expect(second.ok).toBe(true)
+
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8"))
+    expect(state.buildCount).toBe(1)
+  })
+})