pinokiod 7.5.19 → 7.5.21

package/test/launch-requirements-browser.test.js

@@ -27,6 +27,7 @@ const playwright = loadPlaywright()
 
 const root = path.resolve(__dirname, "..")
 const appViewPath = path.resolve(root, "server/views/app.ejs")
+const autolaunchViewPath = path.resolve(root, "server/views/autolaunch.ejs")
 const statusClientPath = path.resolve(root, "server/views/partials/launch_requirements_status_client.ejs")
 const homeViewPath = path.resolve(root, "server/views/index.ejs")
 
@@ -55,6 +56,19 @@ async function renderAppAutolaunchScript(initialState) {
   })
 }
 
+async function renderGlobalAutolaunchScript(state) {
+  const view = await fs.readFile(autolaunchViewPath, "utf8")
+  const start = view.indexOf("<script>\nlet autolaunchApps =")
+  assert.notEqual(start, -1)
+  const end = view.indexOf("\n</script>", start)
+  assert.notEqual(end, -1)
+  return ejs.render(view.slice(start + "<script>".length, end), {
+    appsJson: JSON.stringify([state.targetApp])
+  }, {
+    filename: autolaunchViewPath
+  })
+}
+
 async function renderLaunchRequirementsStatusClient(enabled) {
   const template = await fs.readFile(statusClientPath, "utf8")
   return ejs.render(template, {
@@ -89,6 +103,9 @@ function html(body, script = "") {
           body { font-family: sans-serif; }
           .app-autolaunch-modal { position: fixed; inset: 20px; background: white; border: 1px solid #ccc; padding: 16px; }
           .app-autolaunch-script-option, .app-autolaunch-dependency-option, .app-autolaunch-dependency-row { display: block; margin: 6px 0; }
+          .transformed-sidebar-fixture { display: flex; width: 100%; min-height: 520px; }
+          .transformed-sidebar-fixture > aside { width: 280px; flex: 0 0 280px; transform: translateX(0); }
+          .transformed-sidebar-fixture > main { flex: 1 1 auto; }
           .launch-requirements-card { width: 560px; margin: 40px auto; }
           .launch-requirements-row { display: grid; grid-template-columns: 32px 1fr auto; gap: 8px; align-items: center; }
         </style>
@@ -100,9 +117,8 @@ function html(body, script = "") {
     </html>`
 }
 
-async function appFixtureHtml(initialApp) {
-  const script = await renderAppAutolaunchScript(initialApp)
-  return html(`
+function appAutolaunchMarkup(initialApp) {
+  return `
     <div class="app-autolaunch" data-app-autolaunch data-app-id="target">
       <button type="button" class="app-autolaunch-row" data-app-autolaunch-button data-enabled="${initialApp.autolaunch_enabled ? "true" : "false"}" aria-haspopup="dialog" aria-expanded="false">
         <span class="app-autolaunch-label">Autolaunch</span>
@@ -122,6 +138,37 @@ async function appFixtureHtml(initialApp) {
         <div data-app-autolaunch-feedback></div>
       </div>
     </div>
+  `
+}
+
+async function appFixtureHtml(initialApp) {
+  const script = await renderAppAutolaunchScript(initialApp)
+  return html(appAutolaunchMarkup(initialApp), script)
+}
+
+async function transformedSidebarAppFixtureHtml(initialApp) {
+  const script = await renderAppAutolaunchScript(initialApp)
+  return html(`
+    <div class="appcanvas transformed-sidebar-fixture">
+      <aside>
+        ${appAutolaunchMarkup(initialApp)}
+      </aside>
+      <main></main>
+    </div>
+  `, script)
+}
+
+async function globalAutolaunchFixtureHtml(state) {
+  const script = await renderGlobalAutolaunchScript(state)
+  return html(`
+    <main class="autolaunch-page">
+      <strong data-enabled-count>0</strong>
+      <strong data-app-count>1</strong>
+      <button type="button" data-disable-all disabled>Disable startup</button>
+      <input type="search" data-app-search>
+      <div data-app-list></div>
+      <section data-detail></section>
+    </main>
   `, script)
 }
 
@@ -201,6 +248,8 @@ function readBody(req) {
 async function startFixtureServer(state) {
   const pages = {
     app: await appFixtureHtml(state.targetApp),
+    transformedApp: await transformedSidebarAppFixtureHtml(state.targetApp),
+    autolaunch: await globalAutolaunchFixtureHtml(state),
     openWithoutLaunching: await openWithoutLaunchingHtml(),
     status: await statusFixtureHtml(),
     home: await homeFixtureHtml()
@@ -213,6 +262,16 @@ async function startFixtureServer(state) {
         res.end(pages.app)
         return
       }
+      if (req.method === "GET" && url.pathname === "/app-transformed-sidebar-fixture") {
+        res.writeHead(200, { "Content-Type": "text/html" })
+        res.end(pages.transformedApp)
+        return
+      }
+      if (req.method === "GET" && url.pathname === "/autolaunch-fixture") {
+        res.writeHead(200, { "Content-Type": "text/html" })
+        res.end(pages.autolaunch)
+        return
+      }
       if (req.method === "GET" && url.pathname === "/open-without-launching") {
         res.writeHead(200, { "Content-Type": "text/html" })
         res.end(pages.openWithoutLaunching)
@@ -392,6 +451,15 @@ async function textContent(page, selector) {
   return page.locator(selector).first().textContent()
 }
 
+async function waitForState(predicate, message, timeoutMs = 2000) {
+  const started = Date.now()
+  while (Date.now() - started < timeoutMs) {
+    if (predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+  assert.ok(predicate(), message)
+}
+
 browserTest("browser: selecting a launch script from empty state persists and stays off", async () => {
   const state = baseState({ targetScript: "" })
   await withBrowser(state, async ({ page, baseUrl }) => {
@@ -414,6 +482,194 @@ browserTest("browser: selecting a launch script from empty state persists and st
   })
 })
 
+browserTest("browser: app autolaunch modal is viewport sized from transformed sidebar", async () => {
+  const state = baseState({ targetScript: "" })
+  await withBrowser(state, async ({ page, baseUrl }) => {
+    await page.setViewportSize({ width: 1000, height: 700 })
+    await page.goto(`${baseUrl}/app-transformed-sidebar-fixture`)
+    await page.click("[data-app-autolaunch-button]")
+    await page.waitForSelector("[data-app-autolaunch-modal]:not(.hidden)")
+
+    const rect = await page.locator("[data-app-autolaunch-modal]").evaluate((modal) => {
+      const box = modal.getBoundingClientRect()
+      return {
+        left: box.left,
+        top: box.top,
+        right: box.right,
+        bottom: box.bottom,
+        width: box.width,
+        height: box.height,
+        parentTag: modal.parentElement ? modal.parentElement.tagName : ""
+      }
+    })
+
+    assert.equal(rect.parentTag, "BODY")
+    assert.ok(rect.width > 900, `modal width should span the viewport, got ${rect.width}`)
+    assert.ok(Math.abs(rect.left - 20) <= 1, `modal should use viewport left inset, got ${rect.left}`)
+    assert.ok(Math.abs(rect.right - 980) <= 1, `modal should use viewport right inset, got ${rect.right}`)
+  })
+})
+
+browserTest("browser: startup toggle from empty selection saves the single eligible default", async () => {
+  const state = baseState({ targetScript: "" })
+  await withBrowser(state, async ({ page, baseUrl }) => {
+    await page.goto(`${baseUrl}/app-fixture`)
+    await page.click("[data-app-autolaunch-button]")
+    await page.waitForSelector('input[name="app-autolaunch-script"][value="start.js"]')
+
+    assert.equal(await page.isChecked('input[name="app-autolaunch-script"][value="start.js"]'), false)
+
+    await page.click("[data-app-autolaunch-switch]")
+    await waitForState(
+      () => state.autolaunchPosts.length === 1,
+      "Start with Pinokio should save the single eligible default"
+    )
+
+    assert.deepEqual(state.autolaunchPosts[0], {
+      app: "target",
+      script: "start.js",
+      enabled: true
+    })
+    assert.equal(state.launchRequirementsGets, 0)
+    assert.equal(await page.isChecked('input[name="app-autolaunch-script"][value="start.js"]'), true)
+    assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "ON")
+  })
+})
+
+browserTest("browser: startup toggle from empty selection warns when no eligible default exists", async () => {
+  const cases = [{
+    name: "no default",
+    menu: [{ script: "start.js", label: "Start" }],
+    other: [{ script: "target.custom.js", label: "Custom" }]
+  }, {
+    name: "multiple defaults",
+    menu: [
+      { script: "start.js", label: "Start", menu_default: true },
+      { script: "target.custom.js", label: "Custom", menu_default: true }
+    ],
+    other: []
+  }, {
+    name: "params default",
+    menu: [{ script: "start.js", label: "Start", menu_default: true, has_params: true }],
+    other: [{ script: "target.custom.js", label: "Custom" }]
+  }]
+
+  for (const scenario of cases) {
+    const state = baseState({ targetScript: "" })
+    state.candidates.target.menu = scenario.menu
+    state.candidates.target.other = scenario.other
+    await withBrowser(state, async ({ page, baseUrl }) => {
+      await page.goto(`${baseUrl}/app-fixture`)
+      await page.click("[data-app-autolaunch-button]")
+      await page.waitForSelector("[data-app-autolaunch-switch]")
+
+      await page.click("[data-app-autolaunch-switch]")
+      await page.waitForFunction(() => {
+        const feedback = document.querySelector("[data-app-autolaunch-feedback]")
+        return feedback && /Choose .*launch script/i.test(feedback.textContent || "")
+      })
+
+      assert.equal(state.autolaunchPosts.length, 0, scenario.name)
+      assert.equal((await textContent(page, "[data-app-autolaunch-status]")).trim(), "OFF")
+    })
+  }
+})
+
+browserTest("browser: global startup toggle from empty selection saves the single eligible default", async () => {
+  const state = baseState({ targetScript: "" })
+  await withBrowser(state, async ({ page, baseUrl }) => {
+    await page.goto(`${baseUrl}/autolaunch-fixture?app=target`)
+    await page.waitForSelector('input[name="autolaunch-script"][value="start.js"]')
+
+    assert.equal(await page.isChecked('input[name="autolaunch-script"][value="start.js"]'), false)
+
+    await page.click("[data-autolaunch-switch]")
+    await waitForState(
+      () => state.autolaunchPosts.length === 1,
+      "Global Start with Pinokio should save the single eligible default"
+    )
+
+    assert.deepEqual(state.autolaunchPosts[0], {
+      app: "target",
+      script: "start.js",
+      enabled: true
+    })
+    assert.equal(state.launchRequirementsGets, 0)
+    await page.waitForFunction(() => {
+      const input = document.querySelector('input[name="autolaunch-script"][value="start.js"]')
+      const enabledCount = document.querySelector("[data-enabled-count]")
+      return input && input.checked && enabledCount && enabledCount.textContent.trim() === "1"
+    })
+    assert.equal(await page.isChecked('input[name="autolaunch-script"][value="start.js"]'), true)
+    assert.equal((await textContent(page, "[data-enabled-count]")).trim(), "1")
+  })
+})
+
+browserTest("browser: global startup toggle from empty selection warns when no eligible default exists", async () => {
+  const cases = [{
+    name: "no default",
+    menu: [{ script: "start.js", label: "Start" }],
+    other: [{ script: "target.custom.js", label: "Custom" }]
+  }, {
+    name: "multiple defaults",
+    menu: [
+      { script: "start.js", label: "Start", menu_default: true },
+      { script: "target.custom.js", label: "Custom", menu_default: true }
+    ],
+    other: []
+  }, {
+    name: "params default",
+    menu: [{ script: "start.js", label: "Start", menu_default: true, has_params: true }],
+    other: [{ script: "target.custom.js", label: "Custom" }]
+  }]
+
+  for (const scenario of cases) {
+    const state = baseState({ targetScript: "" })
+    state.candidates.target.menu = scenario.menu
+    state.candidates.target.other = scenario.other
+    await withBrowser(state, async ({ page, baseUrl }) => {
+      await page.goto(`${baseUrl}/autolaunch-fixture?app=target`)
+      await page.waitForSelector("[data-manual-script]")
+
+      await page.click("[data-autolaunch-switch]")
+      await page.waitForFunction(() => {
+        const feedback = document.querySelector("[data-feedback]")
+        return feedback && /Choose .*launch script/i.test(feedback.textContent || "")
+      })
+
+      assert.equal(state.autolaunchPosts.length, 0, scenario.name)
+      assert.equal((await textContent(page, "[data-enabled-count]")).trim(), "0")
+    })
+  }
+})
+
+browserTest("browser: global startup toggle uses pending manual script before eligible default", async () => {
+  const state = baseState({ targetScript: "" })
+  await withBrowser(state, async ({ page, baseUrl }) => {
+    await page.goto(`${baseUrl}/autolaunch-fixture?app=target`)
+    await page.waitForSelector("[data-manual-script]")
+
+    await page.fill("[data-manual-script]", "target.custom.js")
+    await page.click("[data-autolaunch-switch]")
+    await waitForState(
+      () => state.autolaunchPosts.length === 1,
+      "Global Start with Pinokio should save the pending manual script"
+    )
+
+    assert.deepEqual(state.autolaunchPosts[0], {
+      app: "target",
+      script: "target.custom.js",
+      enabled: true
+    })
+    assert.equal(await page.isChecked('input[name="autolaunch-script"][value="start.js"]'), false)
+    await page.waitForFunction(() => {
+      const enabledCount = document.querySelector("[data-enabled-count]")
+      return enabledCount && enabledCount.textContent.trim() === "1"
+    })
+    assert.equal((await textContent(page, "[data-enabled-count]")).trim(), "1")
+  })
+})
+
 browserTest("browser: adding a requirement with an existing script still requires script confirmation", async () => {
   const state = baseState({ targetScript: "target.custom.js", helperScript: "start.js" })
   await withBrowser(state, async ({ page, baseUrl }) => {

package/test/plugin-dev-iframe.test.js

@@ -1,10 +1,13 @@
 const assert = require("assert")
+const ejs = require("ejs")
 const fs = require("node:fs")
 const path = require("node:path")
 const test = require("node:test")
 
+const viewPath = path.join(__dirname, "..", "server", "views", "d.ejs")
+
 test("dev iframe checks plugin install state before posting a launch request", () => {
-  const view = fs.readFileSync(path.join(__dirname, "..", "server", "views", "d.ejs"), "utf8")
+  const view = fs.readFileSync(viewPath, "utf8")
   const launchStart = view.indexOf("const launchTab = async (tab) =>")
   const redirectIndex = view.indexOf("if (await redirectToPluginInstallIfNeeded(href))", launchStart)
   const postMessageIndex = view.indexOf("window.parent.postMessage", launchStart)
@@ -15,3 +18,66 @@ test("dev iframe checks plugin install state before posting a launch request", (
   assert.ok(view.includes("window.top.location.href = redirectHref"))
   assert.ok(view.includes("/api/plugin/install-state?path="))
 })
+
+test("dev iframe renders plugin apps before project shell and shows description metadata", async () => {
+  const html = await ejs.renderFile(viewPath, {
+    filepath: "/tmp/pinokio-dev-view",
+    retry: false,
+    theme: "light",
+    agent: "browser",
+    dynamic: [{
+      icon: "fa-solid fa-terminal",
+      title: "Terminals",
+      subtitle: "Open a project shell, with or without Python activated.",
+      menu: [{
+        icon: "fa-solid fa-terminal",
+        title: "Bash",
+        subtitle: "Plain shell plus detected Python environments",
+        menu: [{
+          icon: "fa-solid fa-terminal",
+          title: "Shell",
+          subtitle: "Open a plain Bash shell",
+          href: "/shell/dev.bash.plain?path=%2Ftmp%2Fpinokio-dev-view"
+        }]
+      }]
+    }, {
+      icon: "fa-solid fa-plug-circle-bolt",
+      title: "Terminal Apps",
+      subtitle: "Terminal apps provided by your installed",
+      subtitle_link_href: "/plugins",
+      subtitle_link_label: "plugins",
+      menu: [{
+        icon: "fa-solid fa-terminal",
+        title: "Agent CLI",
+        description: "Runs the agent inside this workspace.",
+        href: "/run/plugin/agent"
+      }]
+    }, {
+      icon: "fa-solid fa-arrow-up-right-from-square",
+      title: "Desktop Apps",
+      subtitle: "Desktop apps provided by your installed",
+      subtitle_link_href: "/plugins",
+      subtitle_link_label: "plugins",
+      menu: [{
+        icon: "fa-solid fa-code",
+        title: "Editor",
+        metadata: {
+          description: "Opens the workspace in a desktop editor."
+        },
+        href: "/run/plugin/editor"
+      }]
+    }],
+  })
+
+  const terminalAppsIndex = html.indexOf("Terminal Apps")
+  const desktopAppsIndex = html.indexOf("Desktop Apps")
+  const projectShellIndex = html.indexOf("Project Shell")
+
+  assert.ok(terminalAppsIndex !== -1)
+  assert.ok(desktopAppsIndex !== -1)
+  assert.ok(projectShellIndex !== -1)
+  assert.ok(terminalAppsIndex < projectShellIndex)
+  assert.ok(desktopAppsIndex < projectShellIndex)
+  assert.ok(html.includes("Runs the agent inside this workspace."))
+  assert.ok(html.includes("Opens the workspace in a desktop editor."))
+})

package/test/plugin-sources.test.js

@@ -189,7 +189,7 @@ module.exports = {
     const systemPlugins = menu.filter((item) => item.source === "system")
     const localPlugins = menu.filter((item) => item.source === "local")
 
-    assert.strictEqual(systemPlugins.length, 13)
+    assert.strictEqual(systemPlugins.length, 10)
     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/")))

package/test/url-split-modal.test.js

@@ -0,0 +1,107 @@
+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 root = path.resolve(__dirname, "..")
+const dropdownScriptPath = path.resolve(root, "server/public/urldropdown.js")
+
+function jsonResponse(payload) {
+  return {
+    ok: true,
+    status: 200,
+    statusText: "OK",
+    json: async () => payload
+  }
+}
+
+async function waitFor(predicate, message = "condition") {
+  const deadline = Date.now() + 2000
+  while (Date.now() < deadline) {
+    if (predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 20))
+  }
+  assert.fail(`Timed out waiting for ${message}`)
+}
+
+async function createDropdownDom() {
+  const script = await fs.readFile(dropdownScriptPath, "utf8")
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on("jsdomError", (error) => {
+    throw error
+  })
+
+  const dom = new JSDOM(`<!doctype html>
+    <html>
+      <head><title>Current app</title></head>
+      <body>
+        <form class="urlbar"><input type="url"></form>
+        <div id="url-dropdown"></div>
+        <script>${script}</script>
+      </body>
+    </html>`, {
+    url: "http://127.0.0.1:42000/p/current",
+    runScripts: "dangerously",
+    resources: "usable",
+    pretendToBeVisual: true,
+    virtualConsole,
+    beforeParse(window) {
+      window.fetch = async (url) => {
+        if (String(url).includes("/info/apps")) {
+          return jsonResponse({
+            apps: [
+              { name: "MMAudio", title: "MMAudio" },
+              { name: "AllTalk-TTS", title: "AllTalk-TTS v2" }
+            ]
+          })
+        }
+        if (String(url).includes("/info/procs")) {
+          return jsonResponse({ info: [] })
+        }
+        return jsonResponse({})
+      }
+    }
+  })
+
+  const { window } = dom
+  await new Promise((resolve) => window.addEventListener("DOMContentLoaded", resolve, { once: true }))
+  window.initUrlDropdown()
+  return dom
+}
+
+test("split URL modal uses inline submit and omits Files actions", async () => {
+  const dom = await createDropdownDom()
+  const { window } = dom
+  const { document } = window
+
+  const selection = window.PinokioUrlDropdown.openSplitModal({
+    title: "Split Into Columns",
+    description: "Choose a running process or use the current tab URL for the new pane.",
+    confirmLabel: "Open in pane"
+  })
+
+  await waitFor(() => document.querySelector(".url-modal-content.split-mode .url-mode-button"), "split modal app rows")
+
+  const overlay = document.getElementById("url-modal-overlay")
+  const content = document.querySelector(".url-modal-content")
+  const inlineSubmit = document.querySelector(".url-modal-inline-submit")
+  const actions = document.querySelector(".url-modal-actions")
+  const modeLabels = Array.from(document.querySelectorAll(".url-modal-content.split-mode .url-mode-button span"))
+    .map((node) => node.textContent)
+
+  assert.equal(overlay.classList.contains("split-mode"), true)
+  assert.equal(content.classList.contains("split-mode"), true)
+  assert.equal(inlineSubmit.textContent, "Open in pane")
+  assert.ok(actions)
+  assert.deepEqual([...new Set(modeLabels)].sort(), ["Dev", "Run"])
+  assert.doesNotMatch(content.textContent, /\bFiles\b/)
+
+  const input = document.querySelector(".url-modal-input")
+  input.value = "http://localhost:7860"
+  input.dispatchEvent(new window.Event("input", { bubbles: true }))
+  assert.equal(inlineSubmit.disabled, false)
+  inlineSubmit.click()
+
+  assert.equal(await selection, "/container?url=http%3A%2F%2Flocalhost%3A7860")
+})

package/system/plugin/crush/pinokio.js

@@ -1,15 +0,0 @@
-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/qwen/pinokio.js

@@ -1,34 +0,0 @@
-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/windsurf/pinokio.js

@@ -1,23 +0,0 @@
-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"
-    }
-  }]
-}