pinokiod 8.0.20 → 8.0.22

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.20",
+  "version": "8.0.22",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/public/common.js

@@ -3013,15 +3013,19 @@ if (typeof window !== 'undefined' && !window.__pinokioNavigateListenerInstalled)
         return;
       }
     }
+    // Only the registry iframe rendered by the Explore page uses this stable name.
+    const exploreFrame = document.querySelector('iframe[name="pinokio-explore"]');
+    // Trust the message only when it comes from that exact iframe and its configured origin.
+    const fromExplore = Boolean(
+      exploreFrame &&
+      event.source === exploreFrame.contentWindow &&
+      event.origin === new URL(exploreFrame.src).origin
+    );
     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;
-    }
+    // Mobile Safari can leave the parent body focused after a tap inside the registry iframe.
+    const exploreFallback = (!frame || frame.tagName !== 'IFRAME') && fromExplore;
+    if (exploreFallback) frame = exploreFrame;
+    // Preserve the existing generic behavior when there is no identifiable sending iframe.
     if (!frame || frame.tagName !== 'IFRAME') {
       try {
         console.warn('[pinokio:navigate] no active iframe');
@@ -3037,23 +3041,31 @@ if (typeof window !== 'undefined' && !window.__pinokioNavigateListenerInstalled)
       } catch (_) {}
       return;
     }
+    // Only translate the two local Pinokio actions emitted by the registry.
     const localInstall =
       target.origin === 'http://localhost:42000' &&
       (
+        // A normal launcher install must include the repository URI.
         (target.pathname === '/pinokio/download' && Boolean(target.searchParams.get('uri'))) ||
         (
+          // A snapshot restore must include its registry and a canonical SHA-256 hash.
           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);
+    // Handle trusted Explore installs here so Pinokio replaces the parent page, not the iframe.
+    if (fromExplore && localInstall) {
+      // LAN/Home Server clients must use the Pinokio origin they can actually reach.
+      if (target.origin !== window.location.origin) {
+        target = new URL(`${target.pathname}${target.search}${target.hash}`, window.location.origin);
+      }
+      window.location.href = target.toString();
+      return;
     }
+    // If focus was recovered through the Explore fallback, reject every non-allowlisted action.
+    if (exploreFallback) return;
+    // Keep the existing generic iframe navigation restricted to the current Pinokio origin.
     if (target.origin !== window.location.origin) {
       try {
         console.warn('[pinokio:navigate] blocked origin', target.origin);

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

@@ -7,18 +7,34 @@ 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") {
+async function createHarness(
+  url = "http://192.168.1.50:42000/home?mode=explore",
+  frameUrl = "https://pinokio.co/?embed=1&theme=dark",
+) {
   const source = await fs.readFile(commonScriptPath, "utf8")
   const virtualConsole = new VirtualConsole()
+  const navigationErrors = []
   virtualConsole.on("jsdomError", (error) => {
+    if (error && /Not implemented: navigation/.test(error.message || "")) {
+      navigationErrors.push(error)
+      return
+    }
     throw error
   })
-  const dom = new JSDOM("<!doctype html><body><main><iframe></iframe></main></body>", {
+  const dom = new JSDOM('<!doctype html><body><main><iframe name="pinokio-explore"></iframe></main></body>', {
     runScripts: "dangerously",
     pretendToBeVisual: true,
     url,
     virtualConsole,
     beforeParse(window) {
+      const NativeURL = window.URL
+      window.__pinokioConstructedUrls = []
+      window.URL = class extends NativeURL {
+        constructor(value, base) {
+          super(value, base)
+          window.__pinokioConstructedUrls.push(this.toString())
+        }
+      }
       window.fetch = async () => ({ ok: true, json: async () => ({}) })
       window.matchMedia = () => ({
         matches: false,
@@ -35,13 +51,14 @@ async function createHarness(url = "http://192.168.1.50:42000/home?mode=explore"
   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.src = frameUrl
   frame.focus()
   assert.equal(dom.window.document.activeElement, frame)
-  return { dom, frame }
+  return { dom, frame, navigationErrors }
 }
 
 function navigate(dom, frame, target, options = {}) {
+  dom.window.__pinokioConstructedUrls.length = 0
   dom.window.dispatchEvent(new dom.window.MessageEvent("message", {
     data: { e: "pinokio:navigate", url: target },
     origin: options.origin || "https://pinokio.co",
@@ -49,6 +66,12 @@ function navigate(dom, frame, target, options = {}) {
   }))
 }
 
+function assertParentNavigation(dom, frame, navigationErrors, originalFrameUrl, expectedUrl) {
+  assert.ok(dom.window.__pinokioConstructedUrls.includes(expectedUrl))
+  assert.equal(navigationErrors.length, 1)
+  assert.equal(frame.src, originalFrameUrl)
+}
+
 test("Explore uses a stable frame identity instead of the launcher schema", async () => {
   const source = await fs.readFile(exploreTemplatePath, "utf8")
 
@@ -56,46 +79,77 @@ test("Explore uses a stable frame identity instead of the launcher schema", asyn
   assert.doesNotMatch(source, /name="<%=schema%>"/)
 })
 
-test("LAN Explore rebases registry download installs onto the Home Server origin", async (t) => {
-  const { dom, frame } = await createHarness()
+test("LAN Explore trusts the configured registry origin", async (t) => {
+  const { dom, frame, navigationErrors } = await createHarness(
+    undefined,
+    "https://beta.pinokio.co/?embed=1&theme=dark",
+  )
   t.after(() => dom.window.close())
+  const originalFrameUrl = frame.src
 
-  navigate(dom, frame, "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api&branch=dev")
+  navigate(
+    dom,
+    frame,
+    "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api&branch=dev",
+    { origin: "https://beta.pinokio.co" },
+  )
 
-  assert.equal(
-    frame.src,
+  assertParentNavigation(
+    dom,
+    frame,
+    navigationErrors,
+    originalFrameUrl,
     "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()
+  const { dom, frame, navigationErrors } = await createHarness()
   t.after(() => dom.window.close())
+  const originalFrameUrl = frame.src
   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,
+  assertParentNavigation(
+    dom,
+    frame,
+    navigationErrors,
+    originalFrameUrl,
     "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()
+  const { dom, frame, navigationErrors } = await createHarness()
   t.after(() => dom.window.close())
+  const originalFrameUrl = frame.src
   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,
+  assertParentNavigation(
+    dom,
+    frame,
+    navigationErrors,
+    originalFrameUrl,
     `http://192.168.1.50:42000/checkpoints?registry=https%3A%2F%2Fapi.pinokio.co&hash=${hash}&path=api`,
   )
 })
 
+test("localhost Explore replaces itself for registry installs instead of nesting Pinokio", async (t) => {
+  const { dom, frame, navigationErrors } = await createHarness("http://localhost:42000/home?mode=explore")
+  t.after(() => dom.window.close())
+  const originalFrameUrl = frame.src
+  const target = "http://localhost:42000/pinokio/download?uri=https%3A%2F%2Fgithub.com%2Facme%2Fdemo&path=api"
+
+  navigate(dom, frame, target)
+
+  assertParentNavigation(dom, frame, navigationErrors, originalFrameUrl, target)
+})
+
 const blockedCases = [
   ["unrelated local route", "http://localhost:42000/tasker?vars=url", {}],
   ["download without a URI", "http://localhost:42000/pinokio/download", {}],

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" }