pinokiod 7.3.0 → 7.3.3

package/test/plugin-sources.test.js

@@ -0,0 +1,203 @@
+const assert = require("assert")
+const fs = require("node:fs/promises")
+const os = require("node:os")
+const path = require("node:path")
+const test = require("node:test")
+const PluginSources = require("../kernel/plugin_sources")
+
+test("resolveLauncherPluginSelection returns app-dev plugin query paths", () => {
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("claude"),
+    "/pinokio/run/plugin/claude/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("antigravity-cli"),
+    "/pinokio/run/plugin/antigravity-cli/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("codex-auto"),
+    "/plugin/codex-auto/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("plugin/local-tool"),
+    "/plugin/local-tool/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("api/my-app/plugins/helper"),
+    "/api/my-app/plugins/helper/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.resolveLauncherPluginSelection("pinokio/run/plugin/codex-auto"),
+    "/pinokio/run/plugin/codex-auto/pinokio.js"
+  )
+})
+
+test("normalizeActionPathComponents maps action URLs back to filesystem roots", () => {
+  assert.deepStrictEqual(
+    PluginSources.normalizeActionPathComponents(["pinokio", "run", "plugin", "antigravity-cli", "pinokio.js"]),
+    {
+      system: true,
+      pathComponents: ["plugin", "antigravity-cli", "pinokio.js"],
+    }
+  )
+  assert.deepStrictEqual(
+    PluginSources.normalizeActionPathComponents(["plugin", "local-tool", "pinokio.js"]),
+    {
+      system: false,
+      pathComponents: ["plugin", "local-tool", "pinokio.js"],
+    }
+  )
+  assert.deepStrictEqual(
+    PluginSources.normalizeActionPathComponents(["run", "plugin", "local-tool", "pinokio.js"]),
+    {
+      system: false,
+      pathComponents: ["plugin", "local-tool", "pinokio.js"],
+    }
+  )
+  assert.deepStrictEqual(
+    PluginSources.normalizeActionPathComponents(["api", "my-app", "plugins", "helper", "pinokio.js"]),
+    {
+      system: false,
+      pathComponents: ["api", "my-app", "plugins", "helper", "pinokio.js"],
+    }
+  )
+})
+
+test("normalizeLauncherSuccessPlugin rewrites prototype plugin redirects", () => {
+  assert.strictEqual(
+    PluginSources.normalizeLauncherSuccessPlugin(
+      "/p/example/dev?plugin=/plugin/pinokio/run/plugin/codex-auto/pinokio.js&prompt=build",
+      "pinokio/run/plugin/codex-auto"
+    ),
+    "/p/example/dev?plugin=%2Fpinokio%2Frun%2Fplugin%2Fcodex-auto%2Fpinokio.js&prompt=build"
+  )
+
+  assert.strictEqual(
+    PluginSources.normalizeLauncherSuccessPlugin(
+      "/p/example/dev?plugin=/plugin/api/my-app/plugins/helper/pinokio.js",
+      "api/my-app/plugins/helper"
+    ),
+    "/p/example/dev?plugin=%2Fapi%2Fmy-app%2Fplugins%2Fhelper%2Fpinokio.js"
+  )
+
+  assert.strictEqual(
+    PluginSources.normalizeLauncherSuccessPlugin("/p/example/dev", "pinokio/run/plugin/codex-auto"),
+    "/p/example/dev"
+  )
+})
+
+test("isValidPluginConfig accepts only action functions and valid standalone plugin paths", () => {
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig({ run: async () => [] }),
+    true
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig({
+      run: [{ method: "shell.run", params: { message: "echo ok" } }],
+      install: async () => [],
+      update: async () => [],
+      uninstall: async () => [],
+      installed: async () => true,
+    }),
+    true
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig({
+      run: [{ method: "shell.run", params: { message: "echo ok" } }],
+      helper: () => [],
+    }),
+    false
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig({
+      run: [{ method: "shell.run", params: { message: "echo ok" } }],
+      install: "install.js",
+    }),
+    false
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig({
+      run: [{ method: "shell.run", params: { message: "echo ok" } }],
+      installed: true,
+    }),
+    false
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig(
+      { path: "plugin", run: async () => [] },
+      { standalone: true }
+    ),
+    true
+  )
+
+  assert.strictEqual(
+    PluginSources.isValidPluginConfig(
+      { path: "api/example/plugins/tool", run: async () => [] },
+      { standalone: true }
+    ),
+    false
+  )
+})
+
+test("loadPluginMenu merges bundled plugins and valid standalone local plugins", async () => {
+  const homedir = await fs.mkdtemp(path.join(os.tmpdir(), "pinokio-plugin-menu-"))
+  try {
+    await fs.mkdir(path.join(homedir, "plugin", "local-tool"), { recursive: true })
+    await fs.writeFile(path.join(homedir, "plugin", "local-tool", "pinokio.js"), `
+module.exports = {
+  path: "plugin",
+  title: "Local Tool",
+  icon: "local.png",
+  run: [{ method: "shell.run", params: { message: "echo local" } }]
+}
+`)
+
+    await fs.mkdir(path.join(homedir, "plugin", "code", "legacy"), { recursive: true })
+    await fs.writeFile(path.join(homedir, "plugin", "code", "legacy", "pinokio.js"), `
+module.exports = {
+  path: "plugin",
+  title: "Legacy Code Plugin",
+  run: [{ method: "shell.run", params: { message: "echo legacy" } }]
+}
+`)
+
+    await fs.mkdir(path.join(homedir, "plugin", "app-owned"), { recursive: true })
+    await fs.writeFile(path.join(homedir, "plugin", "app-owned", "pinokio.js"), `
+module.exports = {
+  path: "api/example/plugins/tool",
+  title: "App Owned",
+  run: [{ method: "shell.run", params: { message: "echo app" } }]
+}
+`)
+
+    const repoRoot = path.resolve(__dirname, "..")
+    const kernel = {
+      homedir,
+      systemPath: (...parts) => path.join(repoRoot, "system", ...parts),
+      require: async (filepath) => {
+        delete require.cache[require.resolve(filepath)]
+        return require(filepath)
+      }
+    }
+
+    const menu = await PluginSources.loadPluginMenu(kernel)
+    const systemPlugins = menu.filter((item) => item.source === "system")
+    const localPlugins = menu.filter((item) => item.source === "local")
+
+    assert.strictEqual(systemPlugins.length, 13)
+    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/")))
+
+    assert.deepStrictEqual(localPlugins.map((item) => item.title), ["Local Tool"])
+    assert.strictEqual(localPlugins[0].href, "/run/plugin/local-tool/pinokio.js")
+    assert.strictEqual(localPlugins[0].image, "/asset/plugin/local-tool/local.png")
+  } finally {
+    await fs.rm(homedir, { recursive: true, force: true })
+  }
+})

package/test/privacy-filter-worker-heuristics.test.js

@@ -0,0 +1,69 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+const test = require('node:test')
+const vm = require('node:vm')
+
+function loadWorkerHelpers() {
+  const workerPath = path.resolve(__dirname, '..', 'server', 'public', 'privacy_filter_worker.js')
+  const code = `${fs.readFileSync(workerPath, 'utf8')}\n;globalThis.__test = { prepareMaskEntities, maskText }`
+  const sandbox = {
+    URL,
+    console,
+    performance: { now: () => 0 },
+    self: {
+      postMessage: () => {},
+      addEventListener: () => {}
+    }
+  }
+  vm.runInNewContext(code, sandbox, { filename: workerPath })
+  return sandbox.__test
+}
+
+test('privacy filter preserves URLs by default and masks URL credentials only', () => {
+  const { prepareMaskEntities, maskText } = loadWorkerHelpers()
+
+  const publicText = [
+    '+ mlx==0.31.3 (from git+https://github.com/ml-explore/mlx.git)',
+    '+ tool==1.0.0 (from https://example.org/packages/tool.tar.gz)',
+    '+ sshpkg (from git@gitlab.com:group/project.git)'
+  ].join('\n')
+  const publicStart = publicText.indexOf('https://github.com')
+  assert.equal(
+    prepareMaskEntities(publicText, [{
+      label: 'private_url',
+      start: publicStart,
+      end: publicText.indexOf(')', publicStart)
+    }]).length,
+    0
+  )
+
+  const credentialText = 'from https://x-access-token:ghp_secret@github.com/org/private.git'
+  const credentialStart = credentialText.indexOf('https://')
+  const credentialMasked = maskText(credentialText, prepareMaskEntities(credentialText, [{
+    label: 'private_url',
+    start: credentialStart,
+    end: credentialText.length
+  }])).masked
+  assert.equal(credentialMasked, 'from https://[url_credential]@github.com/org/private.git')
+
+  const tokenText = 'from https://github.com/org/repo.git?token=secret'
+  const tokenStart = tokenText.indexOf('https://')
+  const tokenMasked = maskText(tokenText, prepareMaskEntities(tokenText, [{
+    label: 'private_url',
+    start: tokenStart,
+    end: tokenText.length
+  }])).masked
+  assert.equal(tokenMasked, 'from https://github.com/org/repo.git?token=[url_secret]')
+
+  const privateHostText = 'callback https://customer.example.test/install'
+  const privateHostStart = privateHostText.indexOf('https://')
+  assert.equal(
+    prepareMaskEntities(privateHostText, [{
+      label: 'private_url',
+      start: privateHostStart,
+      end: privateHostText.length
+    }]).length,
+    0
+  )
+})

package/test/process-wait.test.js

@@ -0,0 +1,169 @@
+const assert = require("node:assert/strict")
+const test = require("node:test")
+
+const Process = require("../kernel/api/process")
+
+test("process.wait tracks active waits with metadata and clears them when done", async () => {
+  const processApi = new Process()
+  const waitPath = "/pinokio/api/demo/start.js"
+  const kernel = {
+    activeProcessWaits: {},
+    procs: {}
+  }
+  const events = []
+  const req = {
+    parent: { path: waitPath },
+    params: {
+      sec: 0.001,
+      title: "Launching",
+      description: "Waiting for app",
+      message: "Hold on"
+    }
+  }
+
+  const waitPromise = processApi.wait(req, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.equal(kernel.activeProcessWaits[waitPath].path, waitPath)
+  assert.equal(kernel.activeProcessWaits[waitPath].title, "Launching")
+  assert.equal(kernel.activeProcessWaits[waitPath].description, "Waiting for app")
+  assert.equal(kernel.activeProcessWaits[waitPath].message, "Hold on")
+  assert.equal(kernel.activeProcessWaits[waitPath].params, req.params)
+
+  await waitPromise
+
+  assert.equal(kernel.activeProcessWaits[waitPath], undefined)
+  assert.deepEqual(events.map((event) => event.type), [
+    "process.wait.start",
+    "process.wait.end"
+  ])
+})
+
+test("process.wait preserves existing no-metadata waits without footer events", async () => {
+  const processApi = new Process()
+  const waitPath = "/pinokio/api/demo/start.js"
+  const kernel = {
+    activeProcessWaits: {},
+    procs: {}
+  }
+  const events = []
+  const req = {
+    parent: { path: waitPath },
+    params: { sec: 0.001 }
+  }
+
+  const waitPromise = processApi.wait(req, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.equal(kernel.activeProcessWaits[waitPath].path, waitPath)
+  await waitPromise
+
+  assert.equal(kernel.activeProcessWaits[waitPath], undefined)
+  assert.deepEqual(events, [])
+})
+
+test("process.wait shows default footer metadata for indefinite waits", async () => {
+  const processApi = new Process()
+  const waitPath = "/pinokio/api/demo/start.js"
+  const kernel = {
+    activeProcessWaits: {},
+    procs: {}
+  }
+  const events = []
+  const req = {
+    parent: { path: waitPath }
+  }
+
+  const waitPromise = processApi.wait(req, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.equal(req.params.title, "Waiting")
+  assert.equal(req.params.description, "Click Stop when done.")
+  assert.equal(kernel.activeProcessWaits[waitPath].title, "Waiting")
+  assert.equal(kernel.activeProcessWaits[waitPath].description, "Click Stop when done.")
+  assert.equal(kernel.procs[waitPath], processApi)
+  assert.deepEqual(events.map((event) => event.type), ["process.wait.start"])
+
+  processApi.resolve()
+  await waitPromise
+
+  assert.equal(kernel.activeProcessWaits[waitPath], undefined)
+  assert.deepEqual(events.map((event) => event.type), [
+    "process.wait.start",
+    "process.wait.end"
+  ])
+})
+
+test("process.wait shows message-only indefinite waits in the footer", async () => {
+  const processApi = new Process()
+  const waitPath = "/pinokio/api/demo/start.js"
+  const kernel = {
+    activeProcessWaits: {},
+    procs: {}
+  }
+  const events = []
+  const req = {
+    parent: { path: waitPath },
+    params: {
+      message: "Waiting for external app"
+    }
+  }
+
+  const waitPromise = processApi.wait(req, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.equal(req.params.title, undefined)
+  assert.equal(req.params.description, undefined)
+  assert.equal(kernel.activeProcessWaits[waitPath].message, "Waiting for external app")
+  assert.deepEqual(events.map((event) => event.type), ["process.wait.start"])
+
+  processApi.resolve()
+  await waitPromise
+
+  assert.equal(kernel.activeProcessWaits[waitPath], undefined)
+  assert.deepEqual(events.map((event) => event.type), [
+    "process.wait.start",
+    "process.wait.end"
+  ])
+})
+
+test("process.wait dispatches app presence waits through AppAPI", async () => {
+  const processApi = new Process()
+  const waitPath = "/pinokio/api/demo/start.js"
+  const kernel = {
+    activeProcessWaits: {},
+    procs: {}
+  }
+  const calls = []
+  processApi.appApi = {
+    waitForAppPresence: async (req, ondata, kernelArg) => {
+      calls.push({ req, kernel: kernelArg })
+      return { id: req.params.app }
+    }
+  }
+  const req = {
+    parent: { path: waitPath },
+    params: {
+      app: "Native Tool",
+      title: "Waiting for Native Tool"
+    }
+  }
+  const events = []
+
+  await processApi.wait(req, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.equal(calls.length, 1)
+  assert.equal(calls[0].req, req)
+  assert.equal(calls[0].kernel, kernel)
+  assert.equal(kernel.activeProcessWaits[waitPath], undefined)
+  assert.deepEqual(events.map((event) => event.type), [
+    "process.wait.start",
+    "process.wait.end"
+  ])
+})

package/test/script-api.test.js

@@ -0,0 +1,97 @@
+const assert = require('node:assert/strict')
+const path = require('node:path')
+const test = require('node:test')
+
+const Script = require('../kernel/api/script')
+
+test('script.restart stops explicit target and schedules start with explicit params', async () => {
+  const script = new Script()
+  const scheduled = []
+  script.scheduleStart = (req) => {
+    scheduled.push(req)
+  }
+  const stopped = []
+  const kernel = {
+    memory: { args: {} },
+    api: {
+      filePath: (uri, cwd) => path.resolve(cwd, uri),
+      stop: async (req) => {
+        stopped.push(req)
+      }
+    }
+  }
+  const events = []
+
+  const result = await script.restart({
+    cwd: '/pinokio/api/demo',
+    parent: {
+      path: '/pinokio/api/demo/main.js',
+      id: 'main-session'
+    },
+    params: {
+      uri: 'child.js',
+      params: { prompt: 'hello' }
+    }
+  }, (data, type) => {
+    events.push({ data, type })
+  }, kernel)
+
+  assert.deepEqual(stopped, [
+    { params: { uri: '/pinokio/api/demo/child.js' } }
+  ])
+  assert.equal(scheduled.length, 1)
+  assert.equal(scheduled[0].params.uri, 'child.js')
+  assert.deepEqual(scheduled[0].params.params, { prompt: 'hello' })
+  assert.deepEqual(result, {
+    uri: 'child.js',
+    scheduled: true,
+    self: false,
+    params: { prompt: 'hello' }
+  })
+  assert.equal(events[0].type, 'restart')
+  assert.equal(events[0].data.id, '/pinokio/api/demo/child.js')
+})
+
+test('script.restart self restart preserves session id and parent args', async () => {
+  const script = new Script()
+  const scheduled = []
+  script.scheduleStart = (req) => {
+    scheduled.push(req)
+  }
+  const stopped = []
+  const kernel = {
+    memory: { args: {} },
+    api: {
+      filePath: (uri, cwd) => path.resolve(cwd, uri),
+      stop: async (req) => {
+        stopped.push(req)
+      }
+    }
+  }
+
+  const result = await script.restart({
+    cwd: '/pinokio/api/demo',
+    parent: {
+      path: '/pinokio/api/demo/main.js',
+      id: 'main-session',
+      caller: 'caller-session',
+      args: { prompt: 'again' }
+    },
+    params: {}
+  }, () => {}, kernel)
+
+  assert.deepEqual(stopped, [
+    { params: { id: 'main-session' } }
+  ])
+  assert.equal(scheduled.length, 1)
+  assert.equal(scheduled[0].id, 'main-session')
+  assert.equal(scheduled[0].caller, 'caller-session')
+  assert.equal(scheduled[0].params.uri, '/pinokio/api/demo/main.js')
+  assert.deepEqual(scheduled[0].params.params, { prompt: 'again' })
+  assert.deepEqual(result, {
+    uri: '/pinokio/api/demo/main.js',
+    scheduled: true,
+    self: true,
+    params: { prompt: 'again' }
+  })
+})

package/test/shell-api.test.js

@@ -0,0 +1,134 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const path = require('node:path')
+const ShellAPI = require('../kernel/api/shell')
+
+function createKernel () {
+  const calls = []
+  return {
+    calls,
+    homedir: '/tmp/pinokio-home',
+    shell: {
+      start: async (params, options) => {
+        calls.push({ method: 'start', params: structuredClone(params), options: structuredClone(options) })
+        return 'shell-id'
+      },
+      enter: async (params) => {
+        calls.push({ method: 'enter', params: structuredClone(params) })
+        return 'entered'
+      },
+      write: async (params) => {
+        calls.push({ method: 'write', params: structuredClone(params) })
+        return 'written'
+      },
+      run: async (params, options) => {
+        calls.push({ method: 'run', params: structuredClone(params), options: structuredClone(options) })
+        return { stdout: 'ok' }
+      },
+      kill: async (params) => {
+        calls.push({ method: 'kill', params: structuredClone(params) })
+      }
+    }
+  }
+}
+
+test('shell.start forwards defaults, client size, parent, and shell options', async () => {
+  const api = new ShellAPI()
+  const kernel = createKernel()
+  const cwd = path.join('/tmp', 'pinokio-shell-api')
+  const result = await api.start({
+    cwd,
+    parent: {
+      id: 'parent-request',
+      body: { title: 'Parent Title' }
+    },
+    client: {
+      rows: 33,
+      cols: 120
+    }
+  }, () => {}, kernel)
+
+  assert.equal(result, 'shell-id')
+  assert.deepEqual(kernel.calls, [{
+    method: 'start',
+    params: {
+      id: cwd,
+      path: cwd,
+      rows: 33,
+      cols: 120,
+      $parent: {
+        id: 'parent-request',
+        body: { title: 'Parent Title' }
+      },
+      bluefairy: 'off'
+    },
+    options: {
+      cwd,
+      group: 'parent-request',
+      title: 'Parent Title'
+    }
+  }])
+})
+
+test('shell.enter, shell.write, and shell.stop target current cwd by default', async () => {
+  const api = new ShellAPI()
+  const kernel = createKernel()
+  const cwd = path.join('/tmp', 'pinokio-shell-api')
+  const parent = { path: path.join(cwd, 'script.js') }
+
+  assert.equal(await api.enter({ cwd, parent, params: { message: 'echo hi' } }, () => {}, kernel), 'entered')
+  assert.equal(await api.write({ cwd, params: { message: 'typed' } }, () => {}, kernel), 'written')
+  await api.stop({ cwd, params: {} }, () => {}, kernel)
+
+  assert.deepEqual(kernel.calls, [{
+    method: 'enter',
+    params: {
+      message: 'echo hi',
+      id: cwd,
+      $parent: parent
+    }
+  }, {
+    method: 'write',
+    params: {
+      message: 'typed',
+      id: cwd
+    }
+  }, {
+    method: 'kill',
+    params: {
+      id: cwd
+    }
+  }])
+})
+
+test('shell.run applies deterministic defaults and forwards execution options', async () => {
+  const api = new ShellAPI()
+  const kernel = createKernel()
+  const cwd = path.join('/tmp', 'pinokio-shell-api')
+  const result = await api.run({
+    cwd,
+    parent: {
+      path: path.join(cwd, 'script.js')
+    },
+    params: {
+      message: 'echo ok'
+    }
+  }, () => {}, kernel)
+
+  assert.deepEqual(result, { stdout: 'ok' })
+  assert.deepEqual(kernel.calls, [{
+    method: 'run',
+    params: {
+      message: 'echo ok',
+      path: cwd,
+      $parent: {
+        path: path.join(cwd, 'script.js')
+      },
+      bluefairy: 'off'
+    },
+    options: {
+      cwd,
+      group: path.join(cwd, 'script.js')
+    }
+  }])
+})