pinokiod 7.3.1 → 7.3.4

package/test/managed-skills.test.js

@@ -0,0 +1,351 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const os = require("node:os")
+const path = require("node:path")
+const test = require("node:test")
+
+const ManagedSkills = require("../kernel/managed_skills")
+
+async function withTempHome(fn) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-managed-skills-"))
+  const homedir = path.resolve(root, "home")
+  const userhome = path.resolve(root, "user")
+  await fs.mkdir(homedir, { recursive: true })
+  await fs.mkdir(userhome, { recursive: true })
+  try {
+    await fs.writeFile(path.resolve(homedir, "AGENTS.md"), "# Home instructions\n\nUse Pinokio carefully.\n")
+    await fn({
+      root,
+      homedir,
+      userhome,
+      kernel: {
+        homedir,
+        path: (...parts) => path.resolve(homedir, ...parts),
+        exec: async () => {}
+      },
+      publishRoots: ManagedSkills.publishRoots(userhome)
+    })
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+}
+
+async function readJson(filepath) {
+  return JSON.parse(await fs.readFile(filepath, "utf8"))
+}
+
+function cloneTargetFromMessage(message) {
+  const command = Array.isArray(message) ? message[0] : message
+  assert.ok(command && command._ && Array.isArray(command._), "Clone command should use structured shell arguments.")
+  return command._[command._.length - 1]
+}
+
+function cloneRefFromMessage(message) {
+  const command = Array.isArray(message) ? message[0] : message
+  assert.ok(command && command._ && Array.isArray(command._), "Clone command should use structured shell arguments.")
+  return command._[command._.length - 2]
+}
+
+test("managed skills publish built-ins by default and respect disable state", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    const index = await readJson(ManagedSkills.indexPath(kernel))
+    assert.equal(index.skills.pinokio.enabled, true)
+    assert.equal(index.skills.gepeto.enabled, true)
+    assert.equal(index.skills.pinokio.publishName, "pinokio")
+    assert.equal(index.skills.gepeto.publishName, "gepeto")
+
+    for (const root of publishRoots) {
+      assert.match(await fs.readFile(path.resolve(root, "pinokio", "SKILL.md"), "utf8"), /name: pinokio/)
+      assert.match(await fs.readFile(path.resolve(root, "gepeto", "SKILL.md"), "utf8"), /name: gepeto/)
+      const marker = await readJson(path.resolve(root, "gepeto", ManagedSkills.MARKER_FILENAME))
+      assert.equal(marker.manager, "pinokio")
+      assert.equal(marker.skillId, "gepeto")
+    }
+
+    await ManagedSkills.setSkillEnabled(kernel, "gepeto", false, { publishRoots })
+
+    for (const root of publishRoots) {
+      await assert.rejects(
+        fs.stat(path.resolve(root, "gepeto")),
+        { code: "ENOENT" }
+      )
+      assert.match(await fs.readFile(path.resolve(root, "pinokio", "SKILL.md"), "utf8"), /name: pinokio/)
+    }
+  })
+})
+
+test("built-in publish names are fixed", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    await assert.rejects(
+      ManagedSkills.setSkillPublishName(kernel, "gepeto", "custom-gepeto", { publishRoots }),
+      /Built-in skill publish names cannot be changed/
+    )
+
+    const index = await readJson(ManagedSkills.indexPath(kernel))
+    index.skills.gepeto.publishName = "custom-gepeto"
+    await fs.writeFile(ManagedSkills.indexPath(kernel), JSON.stringify(index, null, 2))
+
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    const updated = await readJson(ManagedSkills.indexPath(kernel))
+    assert.equal(updated.skills.gepeto.publishName, "gepeto")
+    for (const root of publishRoots) {
+      assert.match(await fs.readFile(path.resolve(root, "gepeto", "SKILL.md"), "utf8"), /name: gepeto/)
+      await assert.rejects(
+        fs.stat(path.resolve(root, "custom-gepeto")),
+        { code: "ENOENT" }
+      )
+    }
+  })
+})
+
+test("enabled managed skills repair deleted published copies on sync", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    await fs.rm(path.resolve(publishRoots[0], "pinokio"), { recursive: true, force: true })
+
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    assert.match(await fs.readFile(path.resolve(publishRoots[0], "pinokio", "SKILL.md"), "utf8"), /name: pinokio/)
+  })
+})
+
+test("managed skills do not overwrite user-owned conflicts", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    const conflictDir = path.resolve(publishRoots[0], "gepeto")
+    await fs.mkdir(conflictDir, { recursive: true })
+    await fs.writeFile(path.resolve(conflictDir, "SKILL.md"), "---\nname: custom-gepeto\n---\n\nCustom content.\n")
+
+    const result = await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    const gepeto = result.results.find((entry) => entry.id === "gepeto")
+    const conflict = gepeto.targets.find((target) => target.path === conflictDir)
+
+    assert.equal(conflict.status, "conflict")
+    assert.match(await fs.readFile(path.resolve(conflictDir, "SKILL.md"), "utf8"), /custom-gepeto/)
+    await assert.rejects(
+      fs.stat(path.resolve(conflictDir, ManagedSkills.MARKER_FILENAME)),
+      { code: "ENOENT" }
+    )
+  })
+})
+
+test("same-content legacy folders with extra files are not adopted or removed", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    await ManagedSkills.setSkillEnabled(kernel, "gepeto", false, { publishRoots })
+
+    const sourceContent = await fs.readFile(ManagedSkills.skillPath(kernel, "gepeto"), "utf8")
+    const legacyDir = path.resolve(publishRoots[0], "gepeto")
+    await fs.mkdir(legacyDir, { recursive: true })
+    await fs.writeFile(path.resolve(legacyDir, "SKILL.md"), sourceContent)
+    await fs.writeFile(path.resolve(legacyDir, "USER_NOTES.md"), "keep this\n")
+
+    const result = await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    const gepeto = result.results.find((entry) => entry.id === "gepeto")
+    const conflict = gepeto.targets.find((target) => target.path === legacyDir)
+
+    assert.equal(conflict.status, "conflict")
+    assert.match(await fs.readFile(path.resolve(legacyDir, "USER_NOTES.md"), "utf8"), /keep this/)
+    await assert.rejects(
+      fs.stat(path.resolve(legacyDir, ManagedSkills.MARKER_FILENAME)),
+      { code: "ENOENT" }
+    )
+  })
+})
+
+test("same-content legacy folders without extra files are adopted", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    await fs.rm(path.resolve(publishRoots[0], "gepeto"), { recursive: true, force: true })
+
+    const sourceContent = await fs.readFile(ManagedSkills.skillPath(kernel, "gepeto"), "utf8")
+    const legacyDir = path.resolve(publishRoots[0], "gepeto")
+    await fs.mkdir(legacyDir, { recursive: true })
+    await fs.writeFile(path.resolve(legacyDir, "SKILL.md"), sourceContent)
+
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    const marker = await readJson(path.resolve(legacyDir, ManagedSkills.MARKER_FILENAME))
+    assert.equal(marker.manager, "pinokio")
+    assert.equal(marker.skillId, "gepeto")
+  })
+})
+
+test("downloaded skill publish-name changes clean up old managed copies", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    kernel.exec = async ({ message }) => {
+      const dir = cloneTargetFromMessage(message)
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(
+        path.resolve(dir, "SKILL.md"),
+        "---\nname: Music Generation\ndescription: Make music.\n---\n\nUse the music tool.\n"
+      )
+    }
+    await ManagedSkills.installSkillFromGit(kernel, {
+      ref: "https://example.com/music-generation.git",
+      publishRoots
+    })
+
+    await ManagedSkills.setSkillPublishName(kernel, "music-generation", "pinokio-music-alt", { publishRoots })
+
+    for (const root of publishRoots) {
+      await assert.rejects(
+        fs.stat(path.resolve(root, "pinokio-music-generation")),
+        { code: "ENOENT" }
+      )
+      assert.match(
+        await fs.readFile(path.resolve(root, "pinokio-music-alt", "SKILL.md"), "utf8"),
+        /name: Music Generation/
+      )
+    }
+  })
+})
+
+test("downloaded valid skills publish with the pinokio prefix", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    kernel.exec = async ({ message }) => {
+      const dir = cloneTargetFromMessage(message)
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(
+        path.resolve(dir, "SKILL.md"),
+        "---\nname: Music Generation\ndescription: Make music.\n---\n\nUse the music tool.\n"
+      )
+    }
+
+    const skill = await ManagedSkills.installSkillFromGit(kernel, {
+      ref: "https://example.com/music-generation.git",
+      publishRoots
+    })
+
+    assert.equal(skill.id, "music-generation")
+    assert.equal(skill.enabled, true)
+    assert.equal(skill.publishName, "pinokio-music-generation")
+
+    for (const root of publishRoots) {
+      assert.match(
+        await fs.readFile(path.resolve(root, "pinokio-music-generation", "SKILL.md"), "utf8"),
+        /name: Music Generation/
+      )
+    }
+  })
+})
+
+test("downloaded invalid skills stay installed but disabled", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    kernel.exec = async ({ message }) => {
+      const dir = cloneTargetFromMessage(message)
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(path.resolve(dir, "README.md"), "No root skill document.\n")
+    }
+
+    const skill = await ManagedSkills.installSkillFromGit(kernel, {
+      ref: "https://example.com/bad-skill.git",
+      publishRoots
+    })
+
+    assert.equal(skill.id, "bad-skill")
+    assert.equal(skill.enabled, false)
+    assert.equal(skill.valid, false)
+    assert.deepEqual(skill.errors, ["Missing SKILL.md at the skill root."])
+    assert.equal(skill.publishName, "pinokio-bad-skill")
+    await fs.stat(path.resolve(kernel.homedir, "skills", "bad-skill"))
+
+    for (const root of publishRoots) {
+      await assert.rejects(
+        fs.stat(path.resolve(root, "pinokio-bad-skill")),
+        { code: "ENOENT" }
+      )
+    }
+  })
+})
+
+test("clone failure cleanup only removes the temporary clone directory", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    const finalDir = path.resolve(kernel.homedir, "skills", "race-skill")
+    kernel.exec = async ({ message }) => {
+      const tempDir = cloneTargetFromMessage(message)
+      await fs.mkdir(tempDir, { recursive: true })
+      await fs.mkdir(finalDir, { recursive: true })
+      await fs.writeFile(path.resolve(finalDir, "KEEP.txt"), "do not remove\n")
+      throw new Error("clone failed")
+    }
+
+    await assert.rejects(
+      ManagedSkills.installSkillFromGit(kernel, {
+        ref: "https://example.com/race-skill.git",
+        publishRoots
+      }),
+      /clone failed/
+    )
+
+    assert.equal(await fs.readFile(path.resolve(finalDir, "KEEP.txt"), "utf8"), "do not remove\n")
+  })
+})
+
+test("skill clone uses structured shell arguments for untrusted git refs", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    const maliciousRef = "https://example.com/evil-$(id).git"
+    kernel.exec = async ({ message }) => {
+      assert.equal(cloneRefFromMessage(message), maliciousRef)
+      const dir = cloneTargetFromMessage(message)
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(
+        path.resolve(dir, "SKILL.md"),
+        "---\nname: Suspicious Ref\ndescription: Test.\n---\n\nUse carefully.\n"
+      )
+    }
+
+    const skill = await ManagedSkills.installSkillFromGit(kernel, {
+      ref: maliciousRef,
+      publishRoots
+    })
+
+    assert.equal(skill.id, "evil-id")
+    assert.equal(skill.enabled, true)
+  })
+})
+
+test("read-only skill lookup does not publish external copies", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    const skill = await ManagedSkills.getManagedSkill(kernel, "pinokio", { sync: false, publishRoots })
+
+    assert.equal(skill.id, "pinokio")
+    await assert.rejects(
+      fs.stat(path.resolve(publishRoots[0], "pinokio")),
+      { code: "ENOENT" }
+    )
+  })
+})
+
+test("no-op sync does not rewrite managed markers", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    const markerPath = path.resolve(publishRoots[0], "pinokio", ManagedSkills.MARKER_FILENAME)
+    const first = await fs.readFile(markerPath, "utf8")
+
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+
+    assert.equal(await fs.readFile(markerPath, "utf8"), first)
+  })
+})
+
+test("malformed index fails closed without republishing disabled skills", async () => {
+  await withTempHome(async ({ kernel, publishRoots }) => {
+    await ManagedSkills.syncManagedSkills(kernel, { publishRoots })
+    await ManagedSkills.setSkillEnabled(kernel, "gepeto", false, { publishRoots })
+    await fs.writeFile(ManagedSkills.indexPath(kernel), "{ invalid json\n")
+
+    await assert.rejects(
+      ManagedSkills.syncManagedSkills(kernel, { publishRoots }),
+      /Failed to read managed skills index/
+    )
+    await assert.rejects(
+      fs.stat(path.resolve(publishRoots[0], "gepeto")),
+      { code: "ENOENT" }
+    )
+  })
+})

package/test/plugin-action-functions.test.js

@@ -0,0 +1,337 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const os = require("node:os")
+const path = require("node:path")
+const test = require("node:test")
+
+const Api = require("../kernel/api")
+
+function createKernel() {
+  return {
+    info: { platform: "test" },
+    vars: { extra: "value" },
+    envs: {},
+    memory: {
+      global: {},
+      local: {},
+      key: {},
+      rpc: {},
+      args: {},
+      input: {},
+    },
+    script: {},
+    template: {
+      update: () => {},
+      render: (value) => value,
+      istemplate: () => false,
+      flatten: (value) => value,
+    },
+    port: async () => 42001,
+    path: (...parts) => ["/pinokio"].concat(parts).join("/"),
+    update_sysinfo: async () => {},
+  }
+}
+
+async function withStepApi(fn) {
+  const homedir = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-action-"))
+  try {
+    const appDir = path.join(homedir, "api", "demo")
+    await fs.mkdir(appDir, { recursive: true })
+    await fs.writeFile(path.join(homedir, "ENVIRONMENT"), "PINOKIO_TEST_ENV=1\n")
+    await fs.writeFile(path.join(appDir, "ENVIRONMENT"), "PINOKIO_APP_TEST_ENV=1\n")
+
+    const kernel = createKernel()
+    kernel.homedir = homedir
+    kernel.path = (...parts) => path.join(homedir, ...parts)
+    kernel.exists = async (targetPath) => {
+      return fs.access(targetPath).then(() => true).catch(() => false)
+    }
+
+    const api = new Api(kernel)
+    api.init = async () => {}
+    await fn({ api, appDir })
+  } finally {
+    await fs.rm(homedir, { recursive: true, force: true })
+  }
+}
+
+test("resolveActionSteps preserves array actions without changing launcher syntax", async () => {
+  const api = new Api(createKernel())
+  const request = { id: "array-request", path: "/pinokio/api/demo/start.js" }
+  const steps = [{ method: "shell.run", params: { message: "echo ok" } }]
+  const script = { run: steps }
+
+  const resolved = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/api/demo",
+    actionKey: "run",
+    input: {},
+    args: {},
+  })
+
+  assert.strictEqual(resolved, steps)
+  assert.deepEqual(api.resolved_actions["array-request"], {
+    actionKey: "run",
+    steps,
+  })
+})
+
+test("resolveActionSteps executes function actions once per request and clears cached steps", async () => {
+  const api = new Api(createKernel())
+  const request = { id: "function-request", path: "/pinokio/api/demo/plugin/pinokio.js" }
+  let calls = 0
+  const script = {
+    run: async function (kernel, info, context) {
+      calls += 1
+      assert.strictEqual(this, script)
+      assert.equal(kernel.info.platform, "test")
+      assert.equal(info.platform, "test")
+      assert.equal(context.extra, "context")
+      return [{
+        method: "shell.run",
+        params: { message: `echo ${context.input.prompt}` },
+      }]
+    },
+  }
+
+  api.actionContext = async ({ input, args, actionKey }) => ({
+    input,
+    args,
+    action: actionKey,
+    extra: "context",
+  })
+
+  const first = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/api/demo/plugin",
+    actionKey: "run",
+    input: { prompt: "first" },
+    args: { prompt: "first" },
+  })
+  const second = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/api/demo/plugin",
+    actionKey: "run",
+    input: { prompt: "second" },
+    args: { prompt: "second" },
+  })
+
+  assert.equal(calls, 1)
+  assert.strictEqual(second, first)
+  assert.equal(second[0].params.message, "echo first")
+
+  api.clearResolvedAction(request)
+  const third = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/api/demo/plugin",
+    actionKey: "run",
+    input: { prompt: "third" },
+    args: { prompt: "third" },
+  })
+
+  assert.equal(calls, 2)
+  assert.equal(third[0].params.message, "echo third")
+})
+
+test("resolveActionSteps prompts plugin-managed setup before first run", async () => {
+  const api = new Api(createKernel())
+  const request = { id: "plugin-run-install", path: "/pinokio/plugin/demo/pinokio.js" }
+  let runCalls = 0
+  let installCalls = 0
+  let installedCalls = 0
+  const installSteps = [{ method: "shell.run", params: { message: "install" } }]
+  const runSteps = [{ method: "shell.run", params: { message: "run" } }]
+  const script = {
+    installed: async () => {
+      installedCalls += 1
+      return false
+    },
+    install: async () => {
+      installCalls += 1
+      return installSteps
+    },
+    run: async () => {
+      runCalls += 1
+      return runSteps
+    },
+  }
+
+  api.actionContext = async ({ input, args, actionKey }) => ({
+    input,
+    args,
+    action: actionKey,
+  })
+
+  const steps = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/plugin/demo",
+    actionKey: "run",
+    input: { prompt: "first" },
+    args: { prompt: "first" },
+  })
+
+  assert.equal(installedCalls, 1)
+  assert.equal(installCalls, 0)
+  assert.equal(runCalls, 0)
+  assert.deepEqual(steps, [{
+    method: "notify",
+    params: {
+      html: "This plugin is not installed. Open the plugin page and click Install.",
+      href: "/plugin?path=%2Fplugin%2Fdemo%2Fpinokio.js&next=install",
+      target: "_parent",
+      type: "warning",
+    }
+  }])
+
+  api.clearResolvedAction(request)
+  const restarted = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/plugin/demo",
+    actionKey: "run",
+    input: { prompt: "first" },
+    args: { prompt: "first" },
+  })
+
+  assert.equal(installedCalls, 2)
+  assert.equal(installCalls, 0)
+  assert.equal(runCalls, 0)
+  assert.deepEqual(restarted, steps)
+})
+
+test("resolveActionSteps links system plugin setup prompts to plugin detail", async () => {
+  const kernel = createKernel()
+  kernel.systemPath = (...parts) => ["/pinokio-system"].concat(parts).join("/")
+  const api = new Api(kernel)
+  const request = { id: "system-plugin-run-install", path: "/pinokio-system/plugin/demo/pinokio.js" }
+  const script = {
+    title: "Demo System Plugin",
+    installed: async () => false,
+    install: async () => [{ method: "shell.run", params: { message: "install" } }],
+    run: async () => [{ method: "shell.run", params: { message: "run" } }],
+  }
+
+  api.actionContext = async ({ input, args, actionKey }) => ({
+    input,
+    args,
+    action: actionKey,
+  })
+
+  const steps = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio-system/plugin/demo",
+    actionKey: "run",
+    input: {},
+    args: {},
+  })
+
+  assert.equal(steps[0].method, "notify")
+  assert.equal(steps[0].params.html, "Demo System Plugin is not installed. Open the plugin page and click Install.")
+  assert.equal(steps[0].params.href, "/plugin?path=%2Fpinokio%2Frun%2Fplugin%2Fdemo%2Fpinokio.js&next=install")
+  assert.equal(steps[0].params.target, "_parent")
+})
+
+test("resolveActionSteps runs plugin action directly when installed check passes", async () => {
+  const api = new Api(createKernel())
+  const request = { id: "plugin-run-installed", path: "/pinokio/plugin/demo/pinokio.js" }
+  let installCalls = 0
+  let runCalls = 0
+  const runSteps = [{ method: "shell.run", params: { message: "run" } }]
+  const script = {
+    installed: async () => true,
+    install: async () => {
+      installCalls += 1
+      return [{ method: "shell.run", params: { message: "install" } }]
+    },
+    run: async () => {
+      runCalls += 1
+      return runSteps
+    },
+  }
+
+  api.actionContext = async ({ input, args, actionKey }) => ({
+    input,
+    args,
+    action: actionKey,
+  })
+
+  const steps = await api.resolveActionSteps({
+    request,
+    script,
+    scriptDir: "/pinokio/plugin/demo",
+    actionKey: "run",
+    input: {},
+    args: {},
+  })
+
+  assert.equal(installCalls, 0)
+  assert.equal(runCalls, 1)
+  assert.strictEqual(steps, runSteps)
+})
+
+test("step clears resolved function actions when an RPC returns an error", async () => {
+  await withStepApi(async ({ api, appDir }) => {
+    const request = {
+      id: "function-error",
+      path: path.join(appDir, "plugin", "pinokio.js"),
+    }
+    const steps = [{ method: "test.fail" }]
+    api.running[request.id] = true
+    api.resolved_actions[request.id] = { actionKey: "run", steps }
+    api.resolveScript = async () => ({
+      cwd: appDir,
+      script: { run: steps }
+    })
+    api.resolveMethod = async () => ({
+      method: async () => {},
+      dirname: appDir
+    })
+    api.run = async () => ({
+      error: "boom",
+      response: "failed"
+    })
+
+    await api.step(request, steps[0], {}, 0, 1, {})
+
+    assert.equal(api.resolved_actions[request.id], undefined)
+  })
+})
+
+test("step clears resolved function actions when an RPC throws", async () => {
+  await withStepApi(async ({ api, appDir }) => {
+    const request = {
+      id: "function-throw",
+      path: path.join(appDir, "plugin", "pinokio.js"),
+    }
+    const steps = [{ method: "test.throw" }]
+    api.running[request.id] = true
+    api.resolved_actions[request.id] = { actionKey: "run", steps }
+    api.resolveScript = async () => ({
+      cwd: appDir,
+      script: { run: steps }
+    })
+    api.resolveMethod = async () => ({
+      method: async () => {},
+      dirname: appDir
+    })
+    api.run = async () => {
+      throw new Error("boom")
+    }
+
+    const originalLog = console.log
+    console.log = () => {}
+    try {
+      await api.step(request, steps[0], {}, 0, 1, {})
+    } finally {
+      console.log = originalLog
+    }
+
+    assert.equal(api.resolved_actions[request.id], undefined)
+  })
+})

package/test/plugin-dev-iframe.test.js

@@ -0,0 +1,17 @@
+const assert = require("assert")
+const fs = require("node:fs")
+const path = require("node:path")
+const test = require("node:test")
+
+test("dev iframe checks plugin install state before posting a launch request", () => {
+  const view = fs.readFileSync(path.join(__dirname, "..", "server", "views", "d.ejs"), "utf8")
+  const launchStart = view.indexOf("const launchTab = async (tab) =>")
+  const redirectIndex = view.indexOf("if (await redirectToPluginInstallIfNeeded(href))", launchStart)
+  const postMessageIndex = view.indexOf("window.parent.postMessage", launchStart)
+
+  assert.notStrictEqual(launchStart, -1)
+  assert.ok(redirectIndex > launchStart)
+  assert.ok(postMessageIndex > redirectIndex)
+  assert.ok(view.includes("window.top.location.href = redirectHref"))
+  assert.ok(view.includes("/api/plugin/install-state?path="))
+})