pinokiod 8.0.19 → 8.0.21

package/kernel/api/index.js

@@ -1887,6 +1887,9 @@ class Api {
         }
       } else {
         let { cwd, script } = await this.resolveScript(request.path)
+        if (!request.cwd && this.isPathInsideRoot(cwd, PluginSources.systemPluginRoot(this.kernel))) {
+          request.cwd = this.kernel.path("bin")
+        }
 
         if (!script) {
           this.ondata({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.19",
+  "version": "8.0.21",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -7632,7 +7632,7 @@ class Server {
       const category = classifyPluginMenuItem(pluginItem)
       const title = pluginItem?.title || pluginItem?.text || pluginItem?.name || "Plugin"
       const hasInstalledCheck = PluginSources.isInstalledCheck(pluginItem?.installed)
-      const installed = hasInstalledCheck ? await evaluatePluginInstalled(pluginItem) : null
+      const installed = null
       return {
         index,
         title,
@@ -8262,6 +8262,11 @@ class Server {
         res.status(404).send("Plugin not found.")
         return
       }
+      if (plugin.hasInstalledCheck) {
+        const validation = await contentValidation.validatePluginByPath(plugin.pluginPath)
+        const config = validation.valid && validation.context ? validation.context.config : null
+        plugin.installed = config ? await evaluatePluginInstalled(config) : null
+      }
       const [apps, shareState, sidebarContext] = await Promise.all([
         collectPluginApps(),
         buildPluginShareState(plugin),

package/server/public/common.js

@@ -3013,7 +3013,15 @@ if (typeof window !== 'undefined' && !window.__pinokioNavigateListenerInstalled)
         return;
       }
     }
-    const frame = document.activeElement;
+    let frame = document.activeElement;
+    if (
+      (!frame || frame.tagName !== 'IFRAME') &&
+      new URLSearchParams(window.location.search).get('mode') === 'explore' &&
+      event.origin === 'https://pinokio.co'
+    ) {
+      const exploreFrame = document.querySelector('main > iframe');
+      if (exploreFrame && event.source === exploreFrame.contentWindow) frame = exploreFrame;
+    }
     if (!frame || frame.tagName !== 'IFRAME') {
       try {
         console.warn('[pinokio:navigate] no active iframe');
@@ -3029,6 +3037,23 @@ if (typeof window !== 'undefined' && !window.__pinokioNavigateListenerInstalled)
       } catch (_) {}
       return;
     }
+    const localInstall =
+      target.origin === 'http://localhost:42000' &&
+      (
+        (target.pathname === '/pinokio/download' && Boolean(target.searchParams.get('uri'))) ||
+        (
+          target.pathname === '/checkpoints' &&
+          Boolean(target.searchParams.get('registry')) &&
+          /^(?:sha256:)?[0-9a-f]{64}$/i.test(target.searchParams.get('hash') || '')
+        )
+      );
+    const lanExplore =
+      new URLSearchParams(window.location.search).get('mode') === 'explore' &&
+      !['localhost', '127.0.0.1', '::1', '[::1]'].includes(window.location.hostname) &&
+      event.origin === 'https://pinokio.co' && event.source === frame.contentWindow;
+    if (lanExplore && localInstall) {
+      target = new URL(`${target.pathname}${target.search}${target.hash}`, window.location.origin);
+    }
     if (target.origin !== window.location.origin) {
       try {
         console.warn('[pinokio:navigate] blocked origin', target.origin);

package/server/public/logs.js

@@ -590,7 +590,17 @@
         return `${detailUrl}${separator}next=install`
       }
     }
-    redirectToPluginInstallIfNeeded(tool) {
+    async redirectToPluginInstallIfNeeded(tool) {
+      if (tool && tool.hasInstall === true && tool.hasInstalledCheck === true && typeof tool.installed !== 'boolean') {
+        const pluginPath = typeof tool.pluginPath === 'string' ? tool.pluginPath.trim() : ''
+        if (pluginPath) {
+          try {
+            const response = await fetch(`/api/plugin/install-state?path=${encodeURIComponent(pluginPath)}`)
+            const state = response.ok ? await response.json() : null
+            tool.installed = state && typeof state.installed === 'boolean' ? state.installed : null
+          } catch (_) {}
+        }
+      }
       const href = this.pluginInstallHref(tool)
       if (!href) {
         return false
@@ -992,7 +1002,7 @@
           return
         }
         error.textContent = ''
-        if (this.redirectToPluginInstallIfNeeded(tool)) {
+        if (await this.redirectToPluginInstallIfNeeded(tool)) {
           close()
           return
         }

package/server/views/explore.ejs

@@ -177,9 +177,9 @@ body.dark .explore-url {
 <%- include('partials/home_server_popover_assets') %>
 <main>
 <% if (theme === "dark") { %>
-  <iframe name="<%=schema%>" src="<%=discover_dark%>" <%=agent === "electron" ? "no-referrer" : ""%> allow="fullscreen *;" allowfullscreen></iframe>
+  <iframe name="pinokio-explore" src="<%=discover_dark%>" <%=agent === "electron" ? "no-referrer" : ""%> allow="fullscreen *;" allowfullscreen></iframe>
 <% } else { %>
-  <iframe name="<%=schema%>" src="<%=discover_light%>" <%=agent === "electron" ? "no-referrer" : ""%> allow="fullscreen *;" allowfullscreen></iframe>
+  <iframe name="pinokio-explore" src="<%=discover_light%>" <%=agent === "electron" ? "no-referrer" : ""%> allow="fullscreen *;" allowfullscreen></iframe>
 <% } %>
 <%- include('partials/main_sidebar', { selected: 'explore' }) %>
 </main>

package/system/plugin/opencode/pinokio.js

@@ -0,0 +1,57 @@
+module.exports = {
+  title: "Opencode",
+  icon: "icon.png",
+  description: "The AI coding agent built for the terminal.",
+  link: "https://opencode.ai/",
+  path: "plugin",
+  async installed(kernel) {
+    return Boolean(kernel.which("opencode"))
+  },
+  install: [{
+    method: "shell.run",
+    params: {
+      message: "npm install -g opencode-ai@latest"
+    }
+  }],
+  uninstall: [{
+    method: "shell.run",
+    params: {
+      message: "npm uninstall -g opencode-ai"
+    }
+  }, {
+    method: "fs.rm",
+    params: {
+      path: "."
+    }
+  }],
+  update: [{
+    method: "shell.run",
+    params: {
+      message: "git pull",
+    }
+  }, {
+    method: "shell.run",
+    params: {
+      message: "npm install -g opencode-ai@latest"
+    }
+  }],
+  run: [{
+    when: "{{platform === 'win32'}}",
+    method: "shell.run",
+    params: {
+      shell: "bash",
+      message: "opencode",
+      path: "{{args.cwd}}",
+      input: true
+    }
+  }, {
+    when: "{{platform !== 'win32'}}",
+    id: "run",
+    method: "shell.run",
+    params: {
+      message: "opencode",
+      path: "{{args.cwd}}",
+      input: true
+    }
+  }]
+}

package/system/plugin/opencode-auto/pinokio.js

@@ -0,0 +1,14 @@
+const opencode = require("../opencode/pinokio")
+
+module.exports = {
+  ...opencode,
+  title: "Opencode Auto",
+  description: "OpenCode with permission prompts automatically approved unless explicitly denied.",
+  run: opencode.run.map((step) => ({
+    ...step,
+    params: {
+      ...step.params,
+      message: "opencode --auto",
+    },
+  })),
+}

package/test/explore-lan-install-navigation.test.js

@@ -0,0 +1,145 @@
+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 commonScriptPath = path.resolve(__dirname, "../server/public/common.js")
+const exploreTemplatePath = path.resolve(__dirname, "../server/views/explore.ejs")
+
+async function createHarness(url = "http://192.168.1.50:42000/home?mode=explore") {
+  const source = await fs.readFile(commonScriptPath, "utf8")
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on("jsdomError", (error) => {
+    throw error
+  })
+  const dom = new JSDOM("<!doctype html><body><main><iframe></iframe></main></body>", {
+    runScripts: "dangerously",
+    pretendToBeVisual: true,
+    url,
+    virtualConsole,
+    beforeParse(window) {
+      window.fetch = async () => ({ ok: true, json: async () => ({}) })
+      window.matchMedia = () => ({
+        matches: false,
+        addEventListener() {},
+        removeEventListener() {},
+      })
+      window.ResizeObserver = class {
+        observe() {}
+        disconnect() {}
+      }
+    },
+  })
+  const script = dom.window.document.createElement("script")
+  script.textContent = source
+  dom.window.document.body.appendChild(script)
+  const frame = dom.window.document.querySelector("iframe")
+  frame.src = "https://pinokio.co/?embed=1&theme=dark"
+  frame.focus()
+  assert.equal(dom.window.document.activeElement, frame)
+  return { dom, frame }
+}
+
+function navigate(dom, frame, target, options = {}) {
+  dom.window.dispatchEvent(new dom.window.MessageEvent("message", {
+    data: { e: "pinokio:navigate", url: target },
+    origin: options.origin || "https://pinokio.co",
+    source: options.source === undefined ? frame.contentWindow : options.source,
+  }))
+}
+
+test("Explore uses a stable frame identity instead of the launcher schema", async () => {
+  const source = await fs.readFile(exploreTemplatePath, "utf8")
+
+  assert.equal(source.match(/name="pinokio-explore"/g)?.length, 2)
+  assert.doesNotMatch(source, /name="<%=schema%>"/)
+})
+
+test("LAN Explore rebases registry download installs onto the Home Server origin", async (t) => {
+  const { dom, frame } = await createHarness()
+  t.after(() => dom.window.close())
+
+  navigate(dom, frame, "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api&branch=dev")
+
+  assert.equal(
+    frame.src,
+    "http://192.168.1.50:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api&branch=dev",
+  )
+})
+
+test("LAN Explore handles registry installs when mobile Safari leaves the parent body focused", async (t) => {
+  const { dom, frame } = await createHarness()
+  t.after(() => dom.window.close())
+  dom.window.document.body.tabIndex = -1
+  dom.window.document.body.focus()
+  assert.equal(dom.window.document.activeElement, dom.window.document.body)
+
+  navigate(dom, frame, "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api")
+
+  assert.equal(
+    frame.src,
+    "http://192.168.1.50:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api",
+  )
+})
+
+test("LAN Explore rebases valid checkpoint installs onto the Home Server origin", async (t) => {
+  const { dom, frame } = await createHarness()
+  t.after(() => dom.window.close())
+  const hash = `sha256%3A${"a".repeat(64)}`
+
+  navigate(dom, frame, `http://localhost:42000/checkpoints?registry=https%3A%2F%2Fapi.pinokio.co&hash=${hash}&path=api`)
+
+  assert.equal(
+    frame.src,
+    `http://192.168.1.50:42000/checkpoints?registry=https%3A%2F%2Fapi.pinokio.co&hash=${hash}&path=api`,
+  )
+})
+
+const blockedCases = [
+  ["unrelated local route", "http://localhost:42000/tasker?vars=url", {}],
+  ["download without a URI", "http://localhost:42000/pinokio/download", {}],
+  ["checkpoint with an invalid hash", "http://localhost:42000/checkpoints?registry=https%3A%2F%2Fapi.pinokio.co&hash=abc", {}],
+  ["different message origin", "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo", { origin: "https://example.com" }],
+  ["different message source", "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo", { source: null }],
+]
+
+for (const [label, target, options] of blockedCases) {
+  test(`LAN Explore leaves ${label} blocked`, async (t) => {
+    const { dom, frame } = await createHarness()
+    t.after(() => dom.window.close())
+    const original = frame.src
+
+    navigate(dom, frame, target, options)
+
+    assert.equal(frame.src, original)
+  })
+}
+
+test("the additive branch does not run outside Explore", async (t) => {
+  const { dom, frame } = await createHarness("http://192.168.1.50:42000/home")
+  t.after(() => dom.window.close())
+  const original = frame.src
+
+  navigate(dom, frame, "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo")
+
+  assert.equal(frame.src, original)
+})
+
+test("localhost keeps the existing same-origin navigation behavior", async (t) => {
+  const { dom, frame } = await createHarness("http://localhost:42000/home?mode=explore")
+  t.after(() => dom.window.close())
+
+  navigate(dom, frame, "http://localhost:42000/existing-local-route?value=1")
+
+  assert.equal(frame.src, "http://localhost:42000/existing-local-route?value=1")
+})
+
+test("LAN keeps the existing same-origin navigation behavior", async (t) => {
+  const { dom, frame } = await createHarness()
+  t.after(() => dom.window.close())
+
+  navigate(dom, frame, "http://192.168.1.50:42000/existing-lan-route?value=1")
+
+  assert.equal(frame.src, "http://192.168.1.50:42000/existing-lan-route?value=1")
+})

package/test/opencode-plugin.test.js

@@ -0,0 +1,45 @@
+const assert = require("node:assert/strict")
+const test = require("node:test")
+
+const opencode = require("../system/plugin/opencode/pinokio")
+const opencodeAuto = require("../system/plugin/opencode-auto/pinokio")
+
+test("OpenCode installed status follows executable availability", async () => {
+  const lookups = []
+  const kernel = {
+    which(name) {
+      lookups.push(name)
+      return null
+    },
+  }
+
+  assert.equal(await opencode.installed(kernel, {}), false)
+
+  kernel.which = (name) => {
+    lookups.push(name)
+    return "/pinokio/bin/npm/bin/opencode"
+  }
+
+  assert.equal(await opencode.installed(kernel, {}), true)
+  assert.deepEqual(lookups, ["opencode", "opencode"])
+})
+
+test("OpenCode Auto shares the managed lifecycle and launches in auto mode", () => {
+  for (const action of ["install", "uninstall", "update", "installed"]) {
+    assert.equal(opencodeAuto[action], opencode[action])
+  }
+
+  assert.equal(opencodeAuto.run.length, opencode.run.length)
+  for (let index = 0; index < opencodeAuto.run.length; index += 1) {
+    const normalStep = opencode.run[index]
+    const autoStep = opencodeAuto.run[index]
+
+    assert.equal(autoStep.when, normalStep.when)
+    assert.equal(autoStep.id, normalStep.id)
+    assert.equal(autoStep.method, normalStep.method)
+    assert.equal(autoStep.params.path, normalStep.params.path)
+    assert.equal(autoStep.params.input, normalStep.params.input)
+    assert.equal(autoStep.params.shell, normalStep.params.shell)
+    assert.equal(autoStep.params.message, "opencode --auto")
+  }
+})

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

@@ -237,6 +237,34 @@ test("resolveActionSteps links system plugin setup prompts to plugin detail", as
   assert.equal(steps[0].params.target, "_parent")
 })
 
+test("process uses kernel bin as a bundled plugin's implicit cwd", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-cwd-"))
+  try {
+    const virtualSystemRoot = path.join(root, "app.asar", "node_modules", "pinokiod", "system")
+    const virtualPluginDir = path.join(virtualSystemRoot, "plugin", "demo")
+
+    const kernel = createKernel()
+    kernel.homedir = path.join(root, "pinokio")
+    kernel.path = (...parts) => path.join(kernel.homedir, ...parts)
+    kernel.shell = { init: async () => {} }
+    kernel.systemPath = (...parts) => path.join(virtualSystemRoot, ...parts)
+    const api = new Api(kernel)
+    const request = { uri: path.join(virtualPluginDir, "pinokio.js") }
+    api.logSessions = null
+    api.resolveScript = async () => ({
+      cwd: virtualPluginDir,
+      script: { run: [{ method: "shell.run", params: { message: "install" } }] },
+    })
+    api.queue = () => {}
+
+    await api.process(request, () => {})
+
+    assert.equal(request.cwd, kernel.path("bin"))
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
 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" }

package/test/plugin-sources.test.js

@@ -208,7 +208,7 @@ module.exports = {
     const systemPlugins = menu.filter((item) => item.source === "system")
     const localPlugins = menu.filter((item) => item.source === "local")
 
-    assert.strictEqual(systemPlugins.length, 10)
+    assert.strictEqual(systemPlugins.length, 12)
     assert.ok(systemPlugins.every((item) => item.system === true))
     assert.ok(systemPlugins.every((item) => item.href.startsWith("/pinokio/run/plugin/")))
     assert.ok(systemPlugins.every((item) => item.image.startsWith("/pinokio/asset/plugin/")))