pinokiod 7.3.1 → 7.3.3

package/system/plugin/codex-desktop/pinokio.js

@@ -0,0 +1,23 @@
+module.exports = {
+  title: "Codex Desktop",
+  link: "https://openai.com/codex",
+  icon: "icon.png",
+  description: "Codex Desktop",
+  launch_type: "desktop",
+  run: [{
+    method: "uri.open",
+    params: {
+      uri: "codex://new",
+      params: {
+        prompt: "{{args.prompt || ''}}",
+        path: "{{args.cwd || ''}}"
+      }
+    }
+  }, {
+    method: "process.wait",
+    params: {
+      title: "Launched",
+      description: "Click the stop button to stop watching file changes"
+    }
+  }]
+}

package/system/plugin/crush/pinokio.js

@@ -0,0 +1,15 @@
+module.exports = {
+  title: "Crush",
+  icon: "crush.png",
+  link: "https://github.com/charmbracelet/crush",
+  run: [{
+    id: "run",
+    method: "shell.run",
+    params: {
+      message: "npx -y @charmland/crush@latest",
+      path: "{{args.cwd}}",
+      buffer: 1024,
+      input: true
+    }
+  }]
+}

package/system/plugin/cursor/pinokio.js

@@ -0,0 +1,23 @@
+module.exports = {
+  title: "Cursor",
+  link: "https://cursor.com",
+  icon: "cursor.jpeg",
+  description: "The AI Code Editor",
+  launch_type: "desktop",
+  run: [{
+    when: "{{which('cursor')}}",
+    method: "exec",
+    params: {
+      message: "cursor .",
+      path: "{{args.cwd}}"
+    }
+  }, {
+    when: "{{!which('cursor')}}",
+    method: "notify",
+    params: {
+      html: "Cursor is not installed. Click to visit the Cursor homepage to download",
+      href: "https://cursor.com",
+      target: "_blank"
+    }
+  }]
+}

package/system/plugin/qwen/pinokio.js

@@ -0,0 +1,34 @@
+module.exports = {
+  title: "Qwen Code",
+  link: "https://github.com/QwenLM/qwen-code",
+  icon: "qwen.png",
+  env: [{
+    key: "OPENAI_API_KEY",
+    default: "OPENAI_API_KEY"
+  }, {
+    key: "OPENAI_BASE_URL",
+    description: "use the OpenAI API compatible api endpoint",
+    default: "http://localhost:1234/v1"
+  }, {
+    key: "OPENAI_MODEL",
+    description: "the openai compatible model",
+    default: "mradermacher/Bootes-Qwen3_Coder-Reasoning-i1-GGUF"
+  }],
+  run: [{
+    id: "run",
+    method: "shell.run",
+    params: {
+      message: {
+        _: [
+          "npx",
+          "-y",
+          "@qwen-code/qwen-code@latest"
+        ],
+        "prompt-interactive": "{{args.prompt || undefined}}"
+      },
+      path: "{{args.cwd}}",
+      buffer: 1024,
+      input: true
+    }
+  }]
+}

package/system/plugin/vscode/pinokio.js

@@ -0,0 +1,20 @@
+module.exports = {
+  title: "VS Code",
+  link: "https://code.visualstudio.com/",
+  icon: "vscode.png",
+  description: "The AI Code Editor",
+  run: [{
+    when: "{{which('code')}}",
+    method: "exec",
+    params: {
+      message: "code .",
+      path: "{{args.cwd}}",
+    }
+  }, {
+    method: "process.wait",
+    params: {
+      title: "Launched",
+      description: "Click the stop button to stop watching file changes"
+    }
+  }]
+}

package/system/plugin/windsurf/pinokio.js

@@ -0,0 +1,23 @@
+module.exports = {
+  title: "Windsurf",
+  link: "https://windsurf.com/",
+  icon: "windsurf.png",
+  description: "The AI Code Editor",
+  launch_type: "desktop",
+  run: [{
+    method: "uri.open",
+    params: {
+      uri: "windsurf://cascade/newChat",
+      params: {
+        prompt: "{{args.prompt || ''}}",
+        folder: "{{args.cwd || ''}}"
+      }
+    }
+  }, {
+    method: "process.wait",
+    params: {
+      title: "Launched",
+      description: "Click the stop button to stop watching file changes"
+    }
+  }]
+}

package/test/antigravity-cli-plugin.test.js

@@ -0,0 +1,185 @@
+const assert = require("node:assert/strict")
+const fsp = require("node:fs/promises")
+const os = require("node:os")
+const path = require("node:path")
+const test = require("node:test")
+
+const antigravityCli = require("../system/plugin/antigravity-cli/pinokio")
+const antigravityCliAuto = require("../system/plugin/antigravity-cli-auto/pinokio")
+const antigravityCommon = require("../system/plugin/antigravity-cli/common")
+
+function createKernel(root, platform = "darwin") {
+  return {
+    platform,
+    path: (...parts) => path.join(root, ...parts),
+  }
+}
+
+test("Antigravity CLI plugins expose managed lifecycle actions", () => {
+  for (const plugin of [antigravityCli, antigravityCliAuto]) {
+    assert.equal(typeof plugin.install, "function")
+    assert.equal(typeof plugin.update, "function")
+    assert.equal(typeof plugin.uninstall, "function")
+    assert.equal(typeof plugin.installed, "function")
+    assert.equal(typeof plugin.run, "function")
+  }
+})
+
+test("Antigravity CLI install and update install agy into Pinokio bin", () => {
+  const root = path.join(os.tmpdir(), "pinokio-antigravity-test")
+  const kernel = createKernel(root)
+
+  const install = antigravityCli.install(kernel, {})[0]
+  const update = antigravityCli.update(kernel, {})[0]
+
+  for (const step of [install, update]) {
+    assert.equal(step.method, "shell.run")
+    assert.equal(step.params.path, root)
+    assert.equal(step.params.conda.skip, true)
+    assert.equal(step.params.message._[0], process.execPath)
+    assert.equal(step.params.message._[1], antigravityCommon.installerPath())
+    assert.deepEqual(step.params.message._.slice(2), [
+      "--install-dir",
+      path.join(root, "bin"),
+      "--managed-dir",
+      path.join(root, "bin", "antigravity-cli"),
+    ])
+    assert.doesNotMatch(step.params.message._.join(" "), / -e /)
+    assert.doesNotMatch(step.params.message._.join(" "), /api\.github\.com\/repos\/google-antigravity\/antigravity-cli\/releases\/latest/)
+    assert.equal(Object.prototype.hasOwnProperty.call(step.params, "input"), false)
+  }
+})
+
+test("Antigravity CLI installer script downloads and verifies official release assets", () => {
+  const source = require("node:fs").readFileSync(antigravityCommon.installerPath(), "utf8")
+
+  assert.match(source, /api\.github\.com\/repos\/google-antigravity\/antigravity-cli\/releases\/latest/)
+  assert.match(source, /assetNameForPlatform/)
+  assert.match(source, /agy_cli_mac_.*\.tar\.gz/)
+  assert.match(source, /agy_cli_linux_.*\.tar\.gz/)
+  assert.match(source, /agy_cli_windows_.*\.zip/)
+  assert.match(source, /asset\.digest/)
+  assert.match(source, /install\.json/)
+  assert.doesNotMatch(source, /profile|bashrc|zshrc/)
+  assert.doesNotMatch(source, /antigravity-cli-auto-updater/)
+})
+
+test("Antigravity CLI uninstall removes only the managed binary and staging directory", () => {
+  const root = path.join(os.tmpdir(), "pinokio-antigravity-test")
+  const kernel = createKernel(root)
+  const step = antigravityCli.uninstall(kernel, {})[0]
+
+  assert.equal(step.method, "shell.run")
+  assert.equal(step.params.path, path.join(root, "bin"))
+  assert.match(step.params.message, new RegExp(`rm -f '${path.join(root, "bin", "agy")}'`.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
+  assert.match(step.params.message, new RegExp(`rm -rf '${path.join(root, "bin", "antigravity-cli")}'`.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
+  assert.doesNotMatch(step.params.message, new RegExp(`rm -rf '${path.join(root, "bin")}'`.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
+  assert.equal(Object.prototype.hasOwnProperty.call(step.params, "input"), false)
+})
+
+test("Antigravity CLI run uses the Pinokio-managed binary path", async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), "pinokio-antigravity-run-"))
+  try {
+    const kernel = createKernel(root)
+    const bin = antigravityCommon.binaryPath(kernel, "darwin")
+    await fsp.mkdir(path.dirname(bin), { recursive: true })
+    await fsp.writeFile(bin, "")
+
+    const steps = antigravityCli.run(kernel, {}, {
+      args: { cwd: "/tmp/workspace", prompt: "build this" },
+      input: {},
+    })
+
+    assert.equal(steps.length, 1)
+    assert.equal(steps[0].method, "shell.run")
+    assert.deepEqual(steps[0].params.message, {
+      _: [bin, "--prompt-interactive", "build this"]
+    })
+    assert.equal(steps[0].params.path, "/tmp/workspace")
+    assert.equal(steps[0].params.conda.skip, true)
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("Antigravity CLI installed checks the Pinokio-managed agy binary", async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), "pinokio-antigravity-installed-"))
+  try {
+    const kernel = createKernel(root)
+    const bin = antigravityCommon.binaryPath(kernel, "darwin")
+
+    assert.equal(antigravityCli.installed(kernel, {}), false)
+
+    await fsp.mkdir(path.dirname(bin), { recursive: true })
+    await fsp.writeFile(bin, "")
+
+    assert.equal(antigravityCli.installed(kernel, {}), true)
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("Antigravity CLI Auto adds the current permission-skip flag", async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), "pinokio-antigravity-auto-"))
+  try {
+    const kernel = createKernel(root)
+    const bin = antigravityCommon.binaryPath(kernel, "darwin")
+    await fsp.mkdir(path.dirname(bin), { recursive: true })
+    await fsp.writeFile(bin, "")
+
+    const steps = antigravityCliAuto.run(kernel, {}, {
+      args: { cwd: "/tmp/workspace" },
+      input: {},
+    })
+
+    assert.deepEqual(steps[0].params.message, {
+      _: [bin, "--dangerously-skip-permissions"]
+    })
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("Antigravity CLI run asks for Pinokio install when managed binary is missing", async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), "pinokio-antigravity-missing-"))
+  try {
+    const kernel = createKernel(root)
+    const steps = antigravityCli.run(kernel, {}, {
+      args: { cwd: "/tmp/workspace" },
+      input: {},
+    })
+
+    assert.equal(steps[0].method, "notify")
+    assert.match(steps[0].params.html, /Open the plugin page/)
+    assert.equal(steps[0].params.href, "/plugin?path=%2Fpinokio%2Frun%2Fplugin%2Fantigravity-cli%2Fpinokio.js&next=install")
+    assert.equal(steps[0].params.target, "_parent")
+    assert.equal(steps[0].params.type, "warning")
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("Antigravity CLI uses kernel.platform for Windows binary paths", async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), "pinokio-antigravity-win-"))
+  try {
+    const kernel = createKernel(root, "win32")
+    const bin = antigravityCommon.binaryPath(kernel, "win32")
+    await fsp.mkdir(path.dirname(bin), { recursive: true })
+    await fsp.writeFile(bin, "")
+
+    assert.equal(bin, path.join(root, "bin", "agy.exe"))
+    assert.equal(antigravityCli.installed(kernel, {}), true)
+
+    const uninstall = antigravityCli.uninstall(kernel, {})[0]
+    assert.equal(uninstall.params.shell, "powershell")
+    assert.match(uninstall.params.message, /agy\.exe/)
+
+    const run = antigravityCli.run(kernel, {}, {
+      args: { cwd: "C:\\workspace" },
+      input: {},
+    })
+    assert.deepEqual(run[0].params.message, { _: [bin] })
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true })
+  }
+})

package/test/app-api.test.js

@@ -0,0 +1,239 @@
+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 AppAPI = require('../kernel/api/app')
+
+function createKernel(root, launcher = {}) {
+  const commands = []
+  return {
+    platform: 'test',
+    appLauncher: launcher,
+    bin: {
+      install2: async () => {
+        commands.push({ type: 'install2' })
+      },
+      sh: async (params) => {
+        commands.push({ type: 'sh', params })
+      }
+    },
+    api: {
+      userdir: path.join(root, 'api'),
+      init: async () => {
+        commands.push({ type: 'api.init' })
+      }
+    },
+    path: (...parts) => path.join(root, ...parts),
+    commands
+  }
+}
+
+test('app APIs forward search/info/refresh/launch requests to the launcher service', async () => {
+  const calls = []
+  const launcher = {
+    search: async (params) => {
+      calls.push({ method: 'search', params })
+      return ['search-result']
+    },
+    info: async (params) => {
+      calls.push({ method: 'info', params })
+      return { id: params.id }
+    },
+    refresh: async (params) => {
+      calls.push({ method: 'refresh', params })
+      return { refreshed: true }
+    },
+    launch: async (params) => {
+      calls.push({ method: 'launch', params })
+      return { launched: true }
+    }
+  }
+  const api = new AppAPI()
+  const kernel = createKernel('/tmp/pinokio-app-api', launcher)
+
+  assert.deepEqual(await api.search({ params: { query: 'Code', limit: 3, refresh: true } }, () => {}, kernel), ['search-result'])
+  assert.deepEqual(await api.info({ params: { id: 'com.example.Code', refresh: true } }, () => {}, kernel), { id: 'com.example.Code' })
+  assert.deepEqual(await api.refresh({ params: { force: true } }, () => {}, kernel), { refreshed: true })
+  assert.deepEqual(await api.launch({ params: { id: 'com.example.Code', args: ['--new-window'] } }, () => {}, kernel), { launched: true })
+
+  assert.deepEqual(calls, [
+    { method: 'search', params: { query: 'Code', limit: 3, refresh: true } },
+    { method: 'info', params: { id: 'com.example.Code', refresh: true } },
+    { method: 'refresh', params: { force: true } },
+    { method: 'launch', params: { id: 'com.example.Code', app: undefined, args: ['--new-window'], refresh: undefined, install: undefined } }
+  ])
+})
+
+test('app.launch delegates missing app install fallback without driving native UI', async () => {
+  const api = new AppAPI()
+  let fallbackArgs
+  api.handleInstallFlow = async (args) => {
+    fallbackArgs = args
+    return { installed: true }
+  }
+  const launcher = {
+    launch: async () => {
+      const error = new Error('not found')
+      error.code = 'APP_NOT_FOUND'
+      throw error
+    }
+  }
+  const kernel = createKernel('/tmp/pinokio-app-api', launcher)
+  const req = {
+    params: {
+      app: 'Native Tool',
+      install: 'https://example.test/tool.dmg'
+    }
+  }
+
+  assert.deepEqual(await api.launch(req, () => {}, kernel), { installed: true })
+  assert.equal(fallbackArgs.req, req)
+  assert.equal(fallbackArgs.kernel, kernel)
+  assert.equal(fallbackArgs.launcher, launcher)
+  assert.equal(fallbackArgs.params, req.params)
+})
+
+test('app.download validates names and builds git clone commands', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-app-api-'))
+  try {
+    await fs.mkdir(path.join(root, 'api'), { recursive: true })
+    const api = new AppAPI()
+    const kernel = createKernel(root, {
+      refresh: async (params) => {
+        kernel.commands.push({ type: 'launcher.refresh', params })
+      }
+    })
+
+    await assert.rejects(
+      api.download({ params: {} }, () => {}, kernel),
+      /app\.download requires params\.uri/
+    )
+
+    assert.deepEqual(
+      await api.download({
+        params: {
+          uri: 'https://github.com/example/tool.git',
+          name: '../bad'
+        }
+      }, () => {}, kernel),
+      {
+        ok: false,
+        code: 'INVALID_NAME',
+        error: 'invalid name',
+        name: '../bad',
+        uri: 'https://github.com/example/tool.git'
+      }
+    )
+
+    await fs.mkdir(path.join(root, 'api', 'existing'), { recursive: true })
+    assert.deepEqual(
+      await api.download({
+        params: {
+          uri: 'https://github.com/example/existing.git',
+          name: 'existing'
+        }
+      }, () => {}, kernel),
+      {
+        ok: false,
+        code: 'APP_EXISTS',
+        error: 'already exists',
+        name: 'existing',
+        path: path.join(root, 'api', 'existing'),
+        uri: 'https://github.com/example/existing.git'
+      }
+    )
+
+    const result = await api.download({
+      params: {
+        uri: 'https://github.com/example/fresh.git',
+        name: 'fresh',
+        branch: 'dev'
+      }
+    }, () => {}, kernel)
+
+    assert.deepEqual(result, {
+      ok: true,
+      name: 'fresh',
+      path: path.join(root, 'api', 'fresh'),
+      uri: 'https://github.com/example/fresh.git',
+      branch: 'dev'
+    })
+    assert.equal(kernel.commands[0].type, 'install2')
+    assert.equal(kernel.commands[1].type, 'sh')
+    assert.equal(kernel.commands[1].params.path, path.join(root, 'api'))
+    assert.equal(kernel.commands[1].params.message, 'git clone --branch "dev" "https://github.com/example/fresh.git" "fresh"')
+    assert.deepEqual(kernel.commands.slice(2), [
+      { type: 'api.init' },
+      { type: 'launcher.refresh', params: { force: true } }
+    ])
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('waitForAppPresence handles present, missing, and install-detected apps', async () => {
+  const api = new AppAPI()
+  const modalEvents = []
+  api.htmlModal = {
+    open: async (req) => {
+      modalEvents.push({ action: 'open', params: req.params })
+    },
+    update: async (req) => {
+      modalEvents.push({ action: 'update', params: req.params })
+    },
+    close: async (req) => {
+      modalEvents.push({ action: 'close', params: req.params })
+    }
+  }
+
+  const byId = await api.waitForAppPresence({
+    params: { id: 'com.example.Present' }
+  }, () => {}, createKernel('/tmp/pinokio-app-api', {
+    info: async () => ({ id: 'com.example.Present', name: 'Present' }),
+    findMatch: async () => null
+  }))
+  assert.deepEqual(byId, { id: 'com.example.Present', name: 'Present' })
+
+  const byName = await api.waitForAppPresence({
+    params: { app: 'Present by Name' }
+  }, () => {}, createKernel('/tmp/pinokio-app-api', {
+    findMatch: async () => ({ entry: { id: 'present-by-name', name: 'Present by Name' } })
+  }))
+  assert.deepEqual(byName, { id: 'present-by-name', name: 'Present by Name' })
+
+  await assert.rejects(
+    api.waitForAppPresence({
+      params: { app: 'Missing' }
+    }, () => {}, createKernel('/tmp/pinokio-app-api', {
+      findMatch: async () => null
+    })),
+    (error) => error && error.code === 'APP_NOT_FOUND'
+  )
+
+  let matchAttempts = 0
+  const installed = await api.waitForAppPresence({
+    parent: { path: '/pinokio/api/demo/start.js' },
+    params: {
+      app: 'Later',
+      install: 'https://example.test/later.dmg',
+      installPollIntervalMs: 1,
+      installTimeoutMs: 50
+    }
+  }, () => {}, createKernel('/tmp/pinokio-app-api', {
+    refresh: async () => {},
+    findMatch: async () => {
+      matchAttempts += 1
+      if (matchAttempts >= 2) {
+        return { entry: { id: 'later', name: 'Later' } }
+      }
+      return null
+    }
+  }))
+
+  assert.deepEqual(installed, { id: 'later', name: 'Later' })
+  assert.ok(modalEvents.some((event) => event.action === 'open'))
+  assert.ok(modalEvents.some((event) => event.action === 'update'))
+  assert.ok(modalEvents.some((event) => event.action === 'close'))
+})

package/test/app-log-report.test.js

@@ -0,0 +1,67 @@
+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 AppLogReportService = require('../server/lib/app_log_report')
+
+const createRegistry = () => ({
+  parseTailCount: (value, fallback) => Number.parseInt(value, 10) || fallback,
+  async pathIsDirectory(targetPath) {
+    try {
+      return (await fs.stat(targetPath)).isDirectory()
+    } catch (_) {
+      return false
+    }
+  },
+  isPathWithin(parentPath, childPath) {
+    const relative = path.relative(parentPath, childPath)
+    return !relative || (!relative.startsWith('..') && !path.isAbsolute(relative))
+  }
+})
+
+test('app log report includes every logs/api/**/latest file and ignores shell logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-app-log-report-'))
+  try {
+    const appRoot = path.join(root, 'demo')
+    await fs.mkdir(path.join(appRoot, 'logs', 'api', 'install.js'), { recursive: true })
+    await fs.mkdir(path.join(appRoot, 'logs', 'api', 'nested', 'start.js'), { recursive: true })
+    await fs.mkdir(path.join(appRoot, 'logs', 'shell'), { recursive: true })
+
+    await fs.writeFile(path.join(appRoot, 'logs', 'api', 'install.js', 'latest'), 'install log\n')
+    await fs.writeFile(path.join(appRoot, 'logs', 'api', 'nested', 'start.js', 'latest'), 'nested start log\n')
+    await fs.writeFile(path.join(appRoot, 'logs', 'shell', 'latest'), 'shell log should not be included\n')
+    await fs.mkdir(path.join(appRoot, '.git'), { recursive: true })
+    await fs.writeFile(path.join(appRoot, '.git', 'config'), [
+      '[remote "origin"]',
+      '  url = https://token:secret@github.com/example/demo.git',
+      ''
+    ].join('\n'))
+
+    const service = new AppLogReportService({ registry: createRegistry() })
+    const report = await service.buildReport({
+      appId: 'demo',
+      status: {
+        path: appRoot,
+        title: 'Demo'
+      },
+      redact: false
+    })
+
+    assert.deepEqual(
+      report.sections.map((section) => section.file).sort(),
+      [
+        'logs/api/install.js/latest',
+        'logs/api/nested/start.js/latest'
+      ]
+    )
+    assert.equal(report.repo_url, 'https://github.com/example/demo.git')
+    assert.equal(report.markdown.includes('token:secret'), false)
+    assert.equal(report.markdown.includes('Repo: https://github.com/example/demo.git'), true)
+    assert.equal(report.markdown.includes('## Sanitization'), false)
+    assert.equal(report.markdown.includes('shell log should not be included'), false)
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})