pinokiod 7.5.21 → 7.5.24

package/test/plugin-delete.test.js

@@ -0,0 +1,143 @@
+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 { deletePluginFolder, resolvePluginDeleteTarget } = require("../server/lib/plugin_delete")
+
+async function withHome(fn) {
+  const homedir = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-delete-"))
+  const kernel = {
+    homedir,
+    path: (...parts) => path.join(homedir, ...parts),
+  }
+  try {
+    return await fn({ homedir, kernel })
+  } finally {
+    await fs.rm(homedir, { recursive: true, force: true })
+  }
+}
+
+test("deletePluginFolder removes only the selected downloaded plugin folder", async () => {
+  await withHome(async ({ homedir, kernel }) => {
+    const demoDir = path.join(homedir, "plugin", "demo")
+    const otherDir = path.join(homedir, "plugin", "other")
+    await fs.mkdir(demoDir, { recursive: true })
+    await fs.mkdir(otherDir, { recursive: true })
+    await fs.writeFile(path.join(demoDir, "pinokio.js"), "module.exports = { run: [] }\n")
+    await fs.writeFile(path.join(demoDir, "notes.txt"), "demo\n")
+    await fs.writeFile(path.join(otherDir, "pinokio.js"), "module.exports = { run: [] }\n")
+
+    const target = await deletePluginFolder({
+      kernel,
+      plugin: {
+        pluginPath: "/plugin/demo/pinokio.js",
+        source: "local",
+      },
+    })
+
+    assert.equal(target.localLabel, "plugin/demo")
+    await assert.rejects(fs.stat(demoDir), /ENOENT/)
+    assert.ok((await fs.stat(path.join(homedir, "plugin"))).isDirectory())
+    assert.ok((await fs.stat(path.join(otherDir, "pinokio.js"))).isFile())
+  })
+})
+
+test("resolvePluginDeleteTarget rejects built-in system plugins", async () => {
+  await withHome(async ({ kernel }) => {
+    assert.throws(
+      () => resolvePluginDeleteTarget({
+        kernel,
+        plugin: {
+          pluginPath: "/pinokio/run/plugin/demo/pinokio.js",
+          source: "system",
+          system: true,
+        },
+      }),
+      /Built-in plugins cannot be deleted/
+    )
+  })
+})
+
+test("resolvePluginDeleteTarget rejects traversal out of downloaded plugin folders", async () => {
+  await withHome(async ({ kernel }) => {
+    assert.throws(
+      () => resolvePluginDeleteTarget({
+        kernel,
+        plugin: {
+          pluginPath: "/plugin/../api/demo/pinokio.js",
+          source: "local",
+        },
+      }),
+      /(Only downloaded plugin folders can be deleted|outside the downloaded plugin folder)/
+    )
+  })
+})
+
+test("resolvePluginDeleteTarget refuses to delete the plugin root", async () => {
+  await withHome(async ({ homedir, kernel }) => {
+    await fs.mkdir(path.join(homedir, "plugin"), { recursive: true })
+
+    assert.throws(
+      () => resolvePluginDeleteTarget({
+        kernel,
+        plugin: {
+          pluginPath: "/plugin/pinokio.js",
+          source: "local",
+        },
+      }),
+      /plugin root folder cannot be deleted/
+    )
+  })
+})
+
+test("deletePluginFolder rejects plugin directory symlinks that resolve outside the plugin root", async () => {
+  await withHome(async ({ homedir, kernel }) => {
+    const outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-delete-outside-"))
+    try {
+      await fs.mkdir(path.join(homedir, "plugin"), { recursive: true })
+      await fs.writeFile(path.join(outsideDir, "pinokio.js"), "module.exports = { run: [] }\n")
+      await fs.symlink(outsideDir, path.join(homedir, "plugin", "linked"), "dir")
+
+      await assert.rejects(
+        deletePluginFolder({
+          kernel,
+          plugin: {
+            pluginPath: "/plugin/linked/pinokio.js",
+            source: "local",
+          },
+        }),
+        /outside the downloaded plugin folder/
+      )
+      assert.ok((await fs.stat(path.join(outsideDir, "pinokio.js"))).isFile())
+    } finally {
+      await fs.rm(outsideDir, { recursive: true, force: true })
+    }
+  })
+})
+
+test("deletePluginFolder removes nested symlinks without following them outside the plugin folder", async () => {
+  await withHome(async ({ homedir, kernel }) => {
+    const outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-delete-outside-"))
+    try {
+      const pluginDir = path.join(homedir, "plugin", "demo")
+      await fs.mkdir(pluginDir, { recursive: true })
+      await fs.writeFile(path.join(pluginDir, "pinokio.js"), "module.exports = { run: [] }\n")
+      await fs.writeFile(path.join(outsideDir, "keep.txt"), "keep\n")
+      await fs.symlink(outsideDir, path.join(pluginDir, "outside-link"), "dir")
+
+      await deletePluginFolder({
+        kernel,
+        plugin: {
+          pluginPath: "/plugin/demo/pinokio.js",
+          source: "local",
+        },
+      })
+
+      await assert.rejects(fs.stat(pluginDir), /ENOENT/)
+      assert.ok((await fs.stat(path.join(outsideDir, "keep.txt"))).isFile())
+    } finally {
+      await fs.rm(outsideDir, { recursive: true, force: true })
+    }
+  })
+})

package/test/plugin-detail-ui.test.js

@@ -0,0 +1,269 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const { JSDOM, VirtualConsole } = require("jsdom")
+
+const repoRoot = path.resolve(__dirname, "..")
+
+function visibleTextMatches(document, selector, text) {
+  return Array.from(document.querySelectorAll(selector)).filter((element) => {
+    if (element.textContent.trim() !== text) {
+      return false
+    }
+    return !element.closest(".task-hidden")
+  })
+}
+
+async function renderSharePanel(shareOverrides, options = {}) {
+  const script = await fs.readFile(path.join(repoRoot, "server/public/plugin-detail.js"), "utf8")
+  const share = {
+    manageable: true,
+    githubConnected: false,
+    gitInitialized: false,
+    hasCommit: false,
+    remoteUrl: "",
+    remoteWebUrl: "",
+    hasPublished: false,
+    changeCount: 0,
+    aheadCount: 0,
+    createUrl: "/github/create",
+    commitUrl: "/github/commit",
+    pushUrl: "/github/push",
+    dir: "/tmp/demo-plugin",
+    ...shareOverrides,
+  }
+  const staticClass = share.remoteWebUrl || (share.remoteUrl && share.githubConnected) ? "" : " task-hidden"
+  const remoteClass = share.remoteWebUrl ? "" : " task-hidden"
+  const refreshClass = share.remoteUrl && share.githubConnected ? "" : " task-hidden"
+  const bootstrap = {
+    plugin: { title: "Demo Plugin", cwd: "/tmp/demo-plugin", pluginPath: "plugin/demo/pinokio.js" },
+    share,
+    apps: [],
+    stateUrl: "",
+  }
+
+  const dom = new JSDOM(`<!doctype html>
+<body>
+  ${options.actionMarkup || ""}
+  <section class="task-side-group">
+    <div class="task-section-note" data-plugin-share-note></div>
+    <div class="task-share-next-step-main">
+      <h3 data-plugin-share-next-title></h3>
+      <p data-plugin-share-next-copy></p>
+      <div class="task-actions" data-plugin-share-next-actions></div>
+    </div>
+    <form class="task-share-inline-create task-hidden" data-plugin-share-create-form>
+      <input type="text" data-plugin-share-repo-name>
+      <select data-plugin-share-visibility><option value="public">Public</option></select>
+      <button type="button" data-plugin-share-create-cancel>Cancel</button>
+    </form>
+    <div class="task-actions plugin-share-static-actions${staticClass}" data-plugin-share-static-actions>
+      <a class="task-link-button${remoteClass}" href="${share.remoteWebUrl || "#"}" data-plugin-share-remote-link>
+        <span>View on GitHub</span>
+      </a>
+      <button class="${refreshClass}" type="button" data-plugin-share-refresh><span>Check again</span></button>
+    </div>
+    <p data-plugin-share-copy></p>
+    <div data-plugin-share-feedback hidden></div>
+  </section>
+  <script id="plugin-detail-bootstrap" type="application/json">${JSON.stringify(bootstrap)}</script>
+</body>`, {
+    runScripts: "dangerously",
+    url: "http://localhost/plugin",
+    virtualConsole: options.virtualConsole,
+  })
+
+  if (typeof options.beforeScript === "function") {
+    options.beforeScript(dom.window)
+  }
+
+  const scriptElement = dom.window.document.createElement("script")
+  scriptElement.textContent = script
+  dom.window.document.body.appendChild(scriptElement)
+
+  return dom.window.document
+}
+
+test("plugin detail hides static GitHub actions until a remote exists", async () => {
+  const document = await renderSharePanel()
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+
+  assert.ok(staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Setup needed")
+})
+
+test("plugin detail shows one static refresh action after a remote exists", async () => {
+  const document = await renderSharePanel({
+    githubConnected: true,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "git@github.com:octocat/demo-plugin.git",
+    remoteWebUrl: "https://github.com/octocat/demo-plugin",
+    hasPublished: true,
+  })
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+
+  assert.ok(!staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Connected")
+})
+
+test("plugin detail keeps refresh available for non-GitHub remotes", async () => {
+  const document = await renderSharePanel({
+    githubConnected: true,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "https://gitlab.com/octocat/demo-plugin.git",
+    remoteWebUrl: "",
+    hasPublished: true,
+  })
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+
+  assert.ok(!staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 0)
+})
+
+test("plugin detail does not duplicate refresh when auth is disconnected but a remote exists", async () => {
+  const document = await renderSharePanel({
+    githubConnected: false,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "git@github.com:octocat/demo-plugin.git",
+    remoteWebUrl: "https://github.com/octocat/demo-plugin",
+    hasPublished: true,
+  })
+
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Connected")
+})
+
+test("plugin action event panel completion closes the modal and refreshes after close", async () => {
+  let closeCount = 0
+  let fireOptions = null
+  let actionIframe = null
+  let reloadCount = 0
+  const unexpectedJsdomErrors = []
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on("jsdomError", (error) => {
+    if (error && /Not implemented: navigation/.test(error.message || "")) {
+      reloadCount += 1
+      return
+    }
+    unexpectedJsdomErrors.push(error)
+  })
+  const document = await renderSharePanel({}, {
+    actionMarkup: '<button type="button" data-plugin-action="install">Install</button>',
+    virtualConsole,
+    beforeScript(window) {
+      window.Swal = {
+        fire(options) {
+          fireOptions = options
+          const popup = window.document.createElement("div")
+          popup.innerHTML = options.html || ""
+          window.document.body.appendChild(popup)
+          actionIframe = popup.querySelector("iframe")
+          if (typeof options.didOpen === "function") {
+            options.didOpen(popup)
+          }
+          return Promise.resolve({})
+        },
+        close() {
+          closeCount += 1
+          if (fireOptions && typeof fireOptions.didClose === "function") {
+            fireOptions.didClose()
+          }
+        },
+      }
+    },
+  })
+  const window = document.defaultView
+
+  document.querySelector("[data-plugin-action='install']").click()
+  assert.ok(fireOptions)
+  assert.match(fireOptions.html, /\/action\/install\/plugin\/demo\/pinokio\.js/)
+  assert.match(fireOptions.html, /__pinokio_event_panel=1/)
+  assert.ok(actionIframe && actionIframe.contentWindow)
+
+  window.dispatchEvent(new window.MessageEvent("message", {
+    origin: window.location.origin,
+    data: {
+      e: "pinokio:event-panel-status",
+      success: true,
+    },
+  }))
+  assert.equal(closeCount, 0)
+  assert.equal(reloadCount, 0)
+
+  window.dispatchEvent(new window.MessageEvent("message", {
+    origin: window.location.origin,
+    source: actionIframe.contentWindow,
+    data: {
+      e: "pinokio:event-panel-status",
+      success: true,
+    },
+  }))
+
+  assert.equal(closeCount, 1)
+  assert.equal(reloadCount, 1)
+  assert.deepEqual(unexpectedJsdomErrors, [])
+})
+
+test("plugin delete confirmation and failure do not request SweetAlert icons", async () => {
+  const fireOptions = []
+  const document = await renderSharePanel({
+    localLabel: "plugin/demo",
+  }, {
+    actionMarkup: '<button type="button" data-plugin-delete>Delete</button>',
+    beforeScript(window) {
+      window.fetch = () => Promise.resolve({
+        ok: false,
+        status: 400,
+        json: () => Promise.resolve({ ok: false, error: "Plugin path is required." }),
+      })
+      window.Swal = {
+        fire(options) {
+          fireOptions.push(options)
+          return Promise.resolve(fireOptions.length === 1 ? { isConfirmed: true } : {})
+        },
+      }
+    },
+  })
+
+  document.querySelector("[data-plugin-delete]").click()
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  await new Promise((resolve) => setTimeout(resolve, 0))
+
+  assert.equal(fireOptions.length, 2)
+  assert.equal(fireOptions[0].icon, undefined)
+  assert.equal(fireOptions[0].title, "Delete Demo Plugin?")
+  assert.match(fireOptions[0].html, /plugin\/demo/)
+  assert.equal(fireOptions[0].confirmButtonText, "Delete plugin")
+  assert.equal(fireOptions[1].icon, undefined)
+  assert.equal(fireOptions[1].title, "Delete failed")
+  assert.equal(fireOptions[1].text, "Plugin path is required.")
+  assert.equal(fireOptions[1].confirmButtonText, "Close")
+  assert.equal(fireOptions[1].buttonsStyling, false)
+})
+
+test("terminal action view uses generic event panel completion", async () => {
+  const terminalView = await fs.readFile(path.join(repoRoot, "server/views/terminal.ejs"), "utf8")
+  const disconnectBranchStart = terminalView.indexOf("packet.type === 'disconnect'")
+  const eventBranchStart = terminalView.indexOf('packet.type === "event"', disconnectBranchStart)
+  const eventBranchEnd = terminalView.indexOf("//this.socket.close()", eventBranchStart)
+
+  assert.ok(disconnectBranchStart >= 0)
+  assert.ok(eventBranchStart > disconnectBranchStart)
+  assert.ok(eventBranchEnd > eventBranchStart)
+
+  assert.match(terminalView, /pinokio:event-panel-status/)
+  assert.match(terminalView.slice(disconnectBranchStart, eventBranchStart), /pinokio:event-panel-status/)
+  assert.match(terminalView.slice(eventBranchStart, eventBranchEnd), /eventPanelStopPending = true/)
+  assert.doesNotMatch(terminalView.slice(eventBranchStart, eventBranchEnd), /pinokio:event-panel-status/)
+  assert.doesNotMatch(terminalView, /pluginActionCompletion/)
+  assert.doesNotMatch(terminalView, /pinokio:plugin-action-complete/)
+})

package/test/plugin-detail-view.test.js

@@ -0,0 +1,160 @@
+const assert = require("node:assert/strict")
+const path = require("node:path")
+const test = require("node:test")
+const ejs = require("ejs")
+const { JSDOM } = require("jsdom")
+
+const viewPath = path.resolve(__dirname, "..", "server/views/plugin_detail.ejs")
+
+function basePlugin(overrides = {}) {
+  return {
+    title: "Demo Plugin",
+    description: "Demo plugin description.",
+    link: "https://example.com/plugin",
+    image: "",
+    icon: "fa-solid fa-terminal",
+    pluginPath: "/plugin/demo/pinokio.js",
+    extraParams: [],
+    defaultCwd: "",
+    hasInstall: true,
+    hasUpdate: true,
+    hasUninstall: true,
+    hasInstalledCheck: true,
+    installed: true,
+    category: "cli",
+    ...overrides,
+  }
+}
+
+function basePluginUi(overrides = {}) {
+  return {
+    badges: [{ label: "Local plugin", tone: "accent" }],
+    launchSummary: "Launches inside Pinokio",
+    hasChanges: false,
+    changePreview: [],
+    extraChangeCount: 0,
+    localChangesCopy: "",
+    showSidebar: true,
+    sourceLabel: "Local folder",
+    sourceValue: "plugin/demo",
+    statusLabel: "Status",
+    statusValue: "Not version tracked yet",
+    canOpenFolder: false,
+    canManageSource: true,
+    isManagedSource: false,
+    githubPanelTitle: "GitHub",
+    githubPanelCopy: "",
+    remoteLabel: "",
+    ...overrides,
+  }
+}
+
+function baseShareState(overrides = {}) {
+  return {
+    ownership: "local",
+    manageable: true,
+    canOpenFolder: false,
+    dir: "/tmp/pinokio/plugin/demo",
+    localLabel: "plugin/demo",
+    remoteUrl: "",
+    remoteWebUrl: "",
+    githubConnected: false,
+    gitInitialized: false,
+    hasCommit: false,
+    changeCount: 0,
+    changes: [],
+    branch: "HEAD",
+    commitUrl: "",
+    createUrl: "",
+    pushUrl: "",
+    ...overrides,
+  }
+}
+
+async function renderPluginDetail({ plugin = {}, pluginUi = {}, shareState = {} } = {}) {
+  const html = await ejs.renderFile(viewPath, {
+    theme: "dark",
+    agent: "browser",
+    list: [],
+    current_host: "",
+    showPeerAccess: false,
+    plugin: basePlugin(plugin),
+    pluginUi: basePluginUi(pluginUi),
+    pluginCwd: "",
+    shareState: baseShareState(shareState),
+    apps: [],
+  })
+  return new JSDOM(html).window.document
+}
+
+test("plugin detail omits the right column for built-in system plugins", async () => {
+  const document = await renderPluginDetail({
+    plugin: {
+      title: "Antigravity CLI Auto",
+      pluginPath: "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js",
+    },
+    pluginUi: {
+      badges: [{ label: "Built-in plugin", tone: "neutral" }],
+      showSidebar: false,
+    },
+    shareState: {
+      ownership: "system",
+      localLabel: "plugin/antigravity-cli-auto/pinokio.js",
+      manageable: false,
+    },
+  })
+
+  assert.equal(document.querySelector(".task-detail-sidebar"), null)
+  assert.ok(document.querySelector(".task-detail-layout-single"))
+  assert.equal(document.querySelector("[data-plugin-share-next-title]"), null)
+  assert.doesNotMatch(document.body.textContent, /Plugin status/)
+  assert.match(document.querySelector(".task-header-actions").textContent, /Website/)
+  assert.doesNotMatch(document.querySelector(".task-header-actions").textContent, /Back/)
+  assert.equal(document.querySelector("[data-plugin-delete]"), null)
+  assert.equal(document.querySelector('.plugin-detail-breadcrumb a[href="/plugins"]')?.textContent, "Plugins")
+})
+
+test("plugin detail keeps source management column for local plugins", async () => {
+  const document = await renderPluginDetail()
+
+  assert.ok(document.querySelector(".task-detail-sidebar"))
+  assert.equal(document.querySelector(".task-detail-layout-single"), null)
+  assert.ok(document.querySelector("[data-plugin-share-next-title]"))
+  assert.match(document.body.textContent, /Plugin status/)
+  assert.equal(document.querySelector('.plugin-detail-breadcrumb a[href="/plugins"]')?.textContent, "Plugins")
+  assert.equal(
+    document.querySelector('.plugin-detail-breadcrumb a[aria-current="page"]')?.getAttribute("href"),
+    "/plugin?path=%2Fplugin%2Fdemo%2Fpinokio.js"
+  )
+  assert.match(document.querySelector(".task-header-actions").textContent, /Delete/)
+  assert.ok(document.querySelector(".task-header-actions [data-plugin-delete]"))
+  assert.doesNotMatch(document.querySelector(".task-header-actions").textContent, /Back/)
+  assert.equal(document.querySelectorAll(".plugin-detail-status-row").length, 3)
+  assert.equal(document.querySelectorAll(".task-detail-sidebar .task-meta-chip").length, 0)
+  assert.equal(
+    Array.from(document.querySelectorAll(".task-detail-sidebar h2")).some((heading) => heading.textContent.trim() === "GitHub"),
+    false
+  )
+})
+
+test("plugin detail does not show delete for managed non-local plugin source", async () => {
+  const document = await renderPluginDetail({
+    pluginUi: {
+      badges: [{ label: "Managed by Pinokio", tone: "neutral" }],
+      canManageSource: false,
+      isManagedSource: true,
+      sourceLabel: "Managed folder",
+      sourceValue: "plugin/code/demo",
+      githubPanelTitle: "Managed by Pinokio",
+      githubPanelCopy: "Managed plugin source.",
+    },
+    shareState: {
+      ownership: "managed",
+      manageable: false,
+      dir: "/tmp/pinokio/plugin/code/demo",
+      localLabel: "plugin/code/demo",
+    },
+  })
+
+  assert.equal(document.querySelector("[data-plugin-delete]"), null)
+})

package/test/plugin-sources.test.js

@@ -32,6 +32,25 @@ test("resolveLauncherPluginSelection returns app-dev plugin query paths", () =>
   )
 })
 
+test("systemPluginPathForLocalPath maps local-shaped plugin paths to system candidates", () => {
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/plugin/antigravity-cli-auto/pinokio.js"),
+    "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("plugin/antigravity-cli-auto"),
+    "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"),
+    ""
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/api/example/plugins/helper/pinokio.js"),
+    ""
+  )
+})
+
 test("normalizeActionPathComponents maps action URLs back to filesystem roots", () => {
   assert.deepStrictEqual(
     PluginSources.normalizeActionPathComponents(["pinokio", "run", "plugin", "antigravity-cli", "pinokio.js"]),