pinokiod 6.0.72 → 6.0.73

package/package.json

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

package/server/index.js

@@ -67,7 +67,7 @@ const Setup = require("../kernel/bin/setup")
 const { createTerminalSessionHelpers } = require("./lib/terminal_session_helpers")
 const { createTerminalGitResetHandler } = require("./lib/terminal_git_reset")
 const { createDesktopEventRouter } = require("./lib/desktop_event_router")
-const { createInjectRouter, normalizeInjectHrefList } = require("./lib/inject_router")
+const { createInjectRouter, normalizeInjectList } = require("./lib/inject_router")
 const AppRegistryService = require("./lib/app_registry")
 const AppLogService = require("./lib/app_logs")
 const AppSearchService = require("./lib/app_search")
@@ -3539,40 +3539,6 @@ class Server {
 
   async renderMenu(req, uri, name, config, pathComponents, indexPath) {
     if (config.menu) {
-      const appendInjectQueryParam = (href, injectList) => {
-        if (typeof href !== "string") {
-          return href
-        }
-        const trimmedHref = href.trim()
-        if (!trimmedHref || !injectList.length) {
-          return href
-        }
-        let parsed
-        let isAbsolute = false
-        try {
-          if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(trimmedHref)) {
-            isAbsolute = true
-            parsed = new URL(trimmedHref)
-          } else {
-            parsed = new URL(trimmedHref, "http://localhost")
-          }
-        } catch (_) {
-          return href
-        }
-        const seen = new Set(parsed.searchParams.getAll("__pinokio_inject"))
-        for (const entry of injectList) {
-          if (seen.has(entry)) {
-            continue
-          }
-          seen.add(entry)
-          parsed.searchParams.append("__pinokio_inject", entry)
-        }
-        if (isAbsolute) {
-          return parsed.toString()
-        }
-        return `${parsed.pathname}${parsed.search}${parsed.hash}`
-      }
-
 //      config.menu = [{
 //        base: "/",
 //        text: "Configure",
@@ -3663,13 +3629,13 @@ class Server {
         if (menuitem.href && menuitem.params) {
           menuitem.href = menuitem.href + "?" + new URLSearchParams(menuitem.params).toString();
         }
-        if (menuitem.href) {
-          const injectList = normalizeInjectHrefList(menuitem.inject)
-          if (injectList.length > 0) {
-            const hrefWithInject = appendInjectQueryParam(menuitem.href, injectList)
-            menuitem.href = hrefWithInject
-            config.menu[i].href = hrefWithInject
-          }
+        const injectList = normalizeInjectList(menuitem.inject)
+        if (injectList.length > 0) {
+          menuitem.inject = injectList
+          config.menu[i].inject = injectList
+        } else if (menuitem.inject) {
+          delete menuitem.inject
+          delete config.menu[i].inject
         }
 
 
@@ -5970,7 +5936,7 @@ class Server {
       }
       res.json({ ok: !!ok, meta })
     }))
-    this.app.get("/agents", ex(async (req, res) => {
+    this.app.get("/plugins", ex(async (req, res) => {
       let pluginMenu = []
       try {
         if (!this.kernel.plugin.config) {
@@ -6049,7 +6015,7 @@ class Server {
 
       const peerAccess = await this.composePeerAccessPayload()
       const list = this.getPeers()
-      res.render("agents", {
+      res.render("plugins", {
         current_host: this.kernel.peer.host,
         ...peerAccess,
         pluginMenu,
@@ -6075,11 +6041,8 @@ class Server {
         res.json({ menu: [] })
       }
     }))
-    this.app.get("/plugins", (req, res) => {
-      res.redirect(301, "/agents")
-    })
     this.app.get("/terminals", (req, res) => {
-      res.redirect(301, "/agents")
+      res.redirect(301, "/home?mode=terminals")
     })
     this.app.get("/screenshots", ex(async (req, res) => {
       const peerAccess = await this.composePeerAccessPayload()
@@ -10481,14 +10444,14 @@ class Server {
       let dynamic = [
         terminal,
         {
-          icon: "fa-solid fa-robot",
-          title: "Terminal Agents",
+          icon: "fa-solid fa-plug-circle-bolt",
+          title: "Terminal Plugins",
           subtitle: "Start a session in Pinokio",
           menu: shell_menus
         },
         {
           icon: "fa-solid fa-arrow-up-right-from-square",
-          title: "Desktop App Agents",
+          title: "Desktop Plugins",
           subtitle: "Open the project in external desktop apps",
           menu: exec_menus
         },
@@ -10592,73 +10555,6 @@ class Server {
       const runPath = typeof req.params[0] === "string" ? req.params[0] : ""
       let pathComponents = runPath.split("/")
       req.base = this.kernel.homedir
-      const readQueryValue = (value) => {
-        if (Array.isArray(value)) {
-          const first = value[0]
-          if (typeof first === "string") {
-            return first.trim()
-          }
-          if (typeof first === "number" || typeof first === "boolean") {
-            return String(first).trim()
-          }
-          return ""
-        }
-        if (typeof value === "string") {
-          return value.trim()
-        }
-        if (typeof value === "number" || typeof value === "boolean") {
-          return String(value).trim()
-        }
-        return ""
-      }
-      const normalizedRunPath = runPath.replace(/^\/+/, "").split("?")[0].toLowerCase()
-      const providerByPath = {
-        "plugin/code/codex/pinokio.js": "codex",
-        "plugin/code/claude/pinokio.js": "claude",
-        "plugin/code/gemini/pinokio.js": "gemini"
-      }
-      const pluginProvider = providerByPath[normalizedRunPath] || ""
-      const promptValue = readQueryValue(req.query ? req.query.prompt : "")
-      const terminalIdValue = readQueryValue(req.query ? req.query.terminal_id : "")
-      const workspacePath = readQueryValue(req.query ? req.query.cwd : "")
-      let refererIsDev = false
-      const referer = req.get("referer")
-      if (typeof referer === "string" && referer.length > 0) {
-        try {
-          const refererUrl = new URL(referer)
-          refererIsDev = /^\/p\/[^/]+\/dev(?:$|\/)/.test(refererUrl.pathname || "")
-        } catch (_) {
-          refererIsDev = false
-        }
-      }
-      const shouldRewriteToManagedStart = Boolean(
-        pluginProvider &&
-        refererIsDev &&
-        workspacePath &&
-        !promptValue &&
-        !terminalIdValue
-      )
-      if (shouldRewriteToManagedStart) {
-        try {
-          const payload = await createManagedTerminalSession({
-            provider: pluginProvider,
-            workspacePath
-          })
-          if (payload && typeof payload.url === "string" && payload.url.length > 0) {
-            res.redirect(payload.url)
-            return
-          }
-        } catch (error) {
-          console.warn("[run-plugin-managed-dev] managed start error, fallback to legacy", {
-            provider: pluginProvider,
-            error: error && error.message ? error.message : error
-          })
-        }
-      }
-      // Strip dev-only marker so legacy /run semantics remain unchanged outside rewrite path.
-      if (req.query && Object.prototype.hasOwnProperty.call(req.query, "managed_dev")) {
-        delete req.query.managed_dev
-      }
       try {
         await this.render(req, res, pathComponents)
       } catch (e) {

package/server/lib/inject_router.js

@@ -5,7 +5,11 @@ const path = require("path")
 
 const { resolveDesktopEventWorkspace } = require("./desktop_event_router")
 
-const normalizeInjectHrefList = (value) => {
+const VALID_INJECT_WORLDS = new Set(["main", "isolated"])
+const VALID_INJECT_WHEN = new Set(["start", "end", "idle"])
+const VALID_INJECT_FRAMES = new Set(["top", "all"])
+
+const normalizeInjectMatchList = (value) => {
   if (!value) {
     return []
   }
@@ -35,6 +39,93 @@ const normalizeInjectHrefList = (value) => {
   return normalized
 }
 
+const normalizeInjectHrefList = (value) => {
+  return normalizeInjectList(value).map((entry) => entry.src)
+}
+
+const normalizeInjectEntry = (value) => {
+  let src = ""
+  let match = []
+  let world = "main"
+  let when = "idle"
+  let frame = "top"
+
+  if (typeof value === "string") {
+    src = value.trim()
+  } else if (value && typeof value === "object" && !Array.isArray(value)) {
+    src = typeof value.src === "string" ? value.src.trim() : ""
+    match = normalizeInjectMatchList(value.match)
+    if (typeof value.world === "string") {
+      const normalizedWorld = value.world.trim().toLowerCase()
+      if (VALID_INJECT_WORLDS.has(normalizedWorld)) {
+        world = normalizedWorld
+      }
+    }
+    if (typeof value.when === "string") {
+      const normalizedWhen = value.when.trim().toLowerCase()
+      if (VALID_INJECT_WHEN.has(normalizedWhen)) {
+        when = normalizedWhen
+      }
+    }
+    if (typeof value.frame === "string") {
+      const normalizedFrame = value.frame.trim().toLowerCase()
+      if (VALID_INJECT_FRAMES.has(normalizedFrame)) {
+        frame = normalizedFrame
+      }
+    }
+  }
+
+  if (!src || src.length > 1024) {
+    return null
+  }
+
+  return {
+    src,
+    match: match.length > 0 ? match : ["*"],
+    world,
+    when,
+    frame
+  }
+}
+
+const normalizeInjectList = (value) => {
+  if (!value) {
+    return []
+  }
+  const values = Array.isArray(value) ? value : [value]
+  const normalized = []
+  const seen = new Set()
+  for (const entry of values) {
+    if (typeof entry === "string") {
+      const parts = entry.split(",").map((item) => item.trim()).filter(Boolean)
+      for (const part of parts) {
+        const normalizedEntry = normalizeInjectEntry(part)
+        if (!normalizedEntry) {
+          continue
+        }
+        const signature = JSON.stringify(normalizedEntry)
+        if (seen.has(signature)) {
+          continue
+        }
+        seen.add(signature)
+        normalized.push(normalizedEntry)
+      }
+      continue
+    }
+    const normalizedEntry = normalizeInjectEntry(entry)
+    if (!normalizedEntry) {
+      continue
+    }
+    const signature = JSON.stringify(normalizedEntry)
+    if (seen.has(signature)) {
+      continue
+    }
+    seen.add(signature)
+    normalized.push(normalizedEntry)
+  }
+  return normalized
+}
+
 const parseFrameInjectEntries = (frameUrl) => {
   if (typeof frameUrl !== "string") {
     return []
@@ -50,7 +141,7 @@ const parseFrameInjectEntries = (frameUrl) => {
     return []
   }
   const entries = parsed.searchParams.getAll("__pinokio_inject")
-  return normalizeInjectHrefList(entries)
+  return normalizeInjectList(entries)
 }
 
 const resolveInjectLaunchUrl = async ({ workspace, workspaceRoot, launcher, hrefRaw }) => {
@@ -108,6 +199,25 @@ const resolveInjectLaunchUrl = async ({ workspace, workspaceRoot, launcher, href
   return queryString ? `${launchPath}?${queryString}` : launchPath
 }
 
+const resolveInjectDescriptor = async ({ workspace, workspaceRoot, launcher, descriptor }) => {
+  const resolvedSrc = await resolveInjectLaunchUrl({
+    workspace,
+    workspaceRoot,
+    launcher,
+    hrefRaw: descriptor.src
+  })
+  if (!resolvedSrc) {
+    return null
+  }
+  return {
+    src: resolvedSrc,
+    match: Array.isArray(descriptor.match) ? descriptor.match.slice() : ["*"],
+    world: descriptor.world || "main",
+    when: descriptor.when || "idle",
+    frame: descriptor.frame || "top"
+  }
+}
+
 const createInjectRouter = ({ kernel }) => {
   const handle = async (body = {}) => {
     const context = body && body.context && typeof body.context === "object" ? body.context : {}
@@ -159,44 +269,59 @@ const createInjectRouter = ({ kernel }) => {
       }
     }
 
+    const requestInjectEntries = normalizeInjectList(body && body.inject)
     const frameUrl = typeof context.frameUrl === "string" ? context.frameUrl : ""
-    const frameInjectEntries = parseFrameInjectEntries(frameUrl)
-    if (frameInjectEntries.length === 0) {
+    const injectEntries = requestInjectEntries.length > 0
+      ? requestInjectEntries
+      : parseFrameInjectEntries(frameUrl)
+    if (injectEntries.length === 0) {
       return {
         status: 200,
         body: {
           ok: true,
           matched: false,
           workspace,
+          inject: [],
           scripts: [],
           reason: "inject_not_requested"
         }
       }
     }
 
-    const scripts = []
-    for (const hrefRaw of frameInjectEntries) {
-      const launchUrl = await resolveInjectLaunchUrl({
+    const inject = []
+    for (const descriptor of injectEntries) {
+      const resolvedDescriptor = await resolveInjectDescriptor({
         workspace,
         workspaceRoot,
         launcher,
-        hrefRaw
+        descriptor
       })
-      if (!launchUrl) {
+      if (!resolvedDescriptor) {
         continue
       }
-      scripts.push(launchUrl)
+      inject.push(resolvedDescriptor)
     }
 
-    const uniqueScripts = [...new Set(scripts)]
+    const uniqueInject = []
+    const seen = new Set()
+    for (const descriptor of inject) {
+      const signature = JSON.stringify(descriptor)
+      if (seen.has(signature)) {
+        continue
+      }
+      seen.add(signature)
+      uniqueInject.push(descriptor)
+    }
+    const scripts = uniqueInject.map((descriptor) => descriptor.src)
     return {
       status: 200,
       body: {
         ok: true,
-        matched: uniqueScripts.length > 0,
+        matched: uniqueInject.length > 0,
         workspace,
-        scripts: uniqueScripts,
-        source: "frame_query"
+        inject: uniqueInject,
+        scripts,
+        source: requestInjectEntries.length > 0 ? "request_body" : "frame_query"
       }
     }
   }
@@ -208,5 +333,6 @@ const createInjectRouter = ({ kernel }) => {
 
 module.exports = {
   createInjectRouter,
-  normalizeInjectHrefList
+  normalizeInjectHrefList,
+  normalizeInjectList
 }

package/server/public/common.js

@@ -23,7 +23,7 @@ const guardedRoutePrefixes = [
   '/github',
   '/setup/',
   '/requirements_check/',
-  '/agents',
+  '/plugins',
   '/network',
   '/net/',
   '/git/',
@@ -3692,7 +3692,7 @@ document.addEventListener("DOMContentLoaded", () => {
         return mapped.length > 0 ? mapped : ASK_AI_FALLBACK_TOOLS.slice();
       })
       .catch((error) => {
-        console.warn('Failed to load Ask AI agents, using fallback list', error);
+        console.warn('Failed to load Ask AI plugins, using fallback list', error);
         return ASK_AI_FALLBACK_TOOLS.slice();
       })
       .finally(() => {
@@ -3703,52 +3703,136 @@ document.addEventListener("DOMContentLoaded", () => {
     return tools;
   }
 
-  function resolveAskAiCliProvider(agentHref) {
-    if (!agentHref) {
-      return '';
+  const TERMINALS_DISCOVERY_REFRESH_SIGNAL_KEY = 'pinokio.terminals.discovery.refresh';
+  let terminalsDiscoveryBroadcastChannel = null;
+  const terminalsDiscoveryRefreshState = {
+    lastAtByWorkspace: new Map()
+  };
+
+  function normalizeWorkspaceCwdForTerminalsDiscovery(value) {
+    return typeof value === 'string' ? value.trim() : '';
+  }
+
+  function getTerminalsDiscoveryBroadcastChannel() {
+    if (terminalsDiscoveryBroadcastChannel !== null) {
+      return terminalsDiscoveryBroadcastChannel;
+    }
+    if (typeof window.BroadcastChannel !== 'function') {
+      terminalsDiscoveryBroadcastChannel = false;
+      return null;
     }
     try {
-      const parsed = new URL(agentHref, window.location.origin);
-      const match = /^\/run\/plugin\/code\/(codex|claude|gemini)\/pinokio\.js$/i.exec(parsed.pathname || '');
-      if (!match || !match[1]) {
-        return '';
-      }
-      return String(match[1]).toLowerCase();
+      terminalsDiscoveryBroadcastChannel = new window.BroadcastChannel(TERMINALS_DISCOVERY_REFRESH_SIGNAL_KEY);
+      return terminalsDiscoveryBroadcastChannel;
     } catch (_) {
-      return '';
+      terminalsDiscoveryBroadcastChannel = false;
+      return null;
     }
   }
 
-  async function startAskAiCliSession(provider, workspaceCwd) {
-    const response = await fetch('/terminals/start', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        provider,
-        workspacePath: workspaceCwd || ''
-      })
-    });
-    let payload = null;
+  function extractWorkspaceCwdFromPluginLaunchUrl(rawUrl, workspaceCwd = '') {
+    const fallbackCwd = normalizeWorkspaceCwdForTerminalsDiscovery(workspaceCwd);
+    if (!rawUrl) {
+      return fallbackCwd;
+    }
     try {
-      payload = await response.json();
+      const parsed = new URL(rawUrl, window.location.origin);
+      if (parsed.origin !== window.location.origin) {
+        return fallbackCwd;
+      }
+      if (!parsed.pathname.startsWith('/run/plugin/')) {
+        return '';
+      }
+      const launchCwd = normalizeWorkspaceCwdForTerminalsDiscovery(parsed.searchParams.get('cwd') || '');
+      return launchCwd || fallbackCwd;
     } catch (_) {
-      payload = null;
+      return fallbackCwd;
     }
-    if (!response.ok || !payload || !payload.url) {
-      const message = payload && payload.error ? payload.error : `Failed to start ${provider}`;
-      throw new Error(message);
+  }
+
+  function buildTerminalsDiscoveryRefreshUrl(workspaceCwd = '') {
+    const params = new URLSearchParams();
+    params.set('mode', 'terminals');
+    params.set('fetch', '1');
+    params.set('sync', '1');
+    params.set('limit', '1');
+    const normalizedWorkspace = normalizeWorkspaceCwdForTerminalsDiscovery(workspaceCwd);
+    if (normalizedWorkspace) {
+      params.set('workspace', normalizedWorkspace);
     }
+    return `/home?${params.toString()}`;
+  }
+
+  function dispatchTerminalsDiscoveryRefreshSignal(workspaceCwd = '') {
+    const payload = {
+      workspaceCwd: normalizeWorkspaceCwdForTerminalsDiscovery(workspaceCwd),
+      ts: Date.now()
+    };
     try {
-      const parsed = new URL(payload.url, window.location.origin);
-      parsed.searchParams.set('ask_ai', '1');
-      return `${parsed.pathname}${parsed.search}${parsed.hash}`;
-    } catch (_) {
-      return payload.url;
+      window.localStorage.setItem(TERMINALS_DISCOVERY_REFRESH_SIGNAL_KEY, JSON.stringify(payload));
+    } catch (_) {}
+    const channel = getTerminalsDiscoveryBroadcastChannel();
+    if (channel) {
+      try {
+        channel.postMessage(payload);
+      } catch (_) {}
+    }
+    return payload;
+  }
+
+  function requestTerminalsDiscoveryRefresh(workspaceCwd = '', options = {}) {
+    const normalizedWorkspace = normalizeWorkspaceCwdForTerminalsDiscovery(workspaceCwd);
+    if (!normalizedWorkspace) {
+      return false;
+    }
+    const now = Date.now();
+    const dedupeWindowMs = Number.isFinite(options && options.dedupeWindowMs)
+      ? Math.max(0, Math.floor(options.dedupeWindowMs))
+      : 1200;
+    const lastAt = terminalsDiscoveryRefreshState.lastAtByWorkspace.get(normalizedWorkspace) || 0;
+    if (now - lastAt < dedupeWindowMs) {
+      return false;
+    }
+    terminalsDiscoveryRefreshState.lastAtByWorkspace.set(normalizedWorkspace, now);
+
+    const requestRefresh = () => {
+      dispatchTerminalsDiscoveryRefreshSignal(normalizedWorkspace);
+      const refreshUrl = buildTerminalsDiscoveryRefreshUrl(normalizedWorkspace);
+      fetch(refreshUrl, {
+        method: 'GET',
+        keepalive: true,
+        cache: 'no-store',
+        headers: {
+          Accept: 'application/json'
+        }
+      }).catch(() => {});
+    };
+
+    requestRefresh();
+    const retryDelays = Array.isArray(options && options.retryDelays) && options.retryDelays.length > 0
+      ? options.retryDelays
+      : [2500];
+    retryDelays.forEach((delay) => {
+      const safeDelay = Number.isFinite(delay) ? Math.max(0, Math.floor(delay)) : 0;
+      window.setTimeout(requestRefresh, safeDelay);
+    });
+    return true;
+  }
+
+  function refreshTerminalSessions(rawUrl, workspaceCwd = '', options = {}) {
+    const resolvedWorkspace = extractWorkspaceCwdFromPluginLaunchUrl(rawUrl, workspaceCwd);
+    if (!resolvedWorkspace) {
+      return false;
     }
+    return requestTerminalsDiscoveryRefresh(resolvedWorkspace, options);
   }
 
+  window.PinokioTerminalsDiscovery = Object.assign({}, window.PinokioTerminalsDiscovery, {
+    buildRefreshUrl: buildTerminalsDiscoveryRefreshUrl,
+    requestRefresh: requestTerminalsDiscoveryRefresh,
+    refreshTerminalSessions
+  });
+
   function buildAskAiLaunchUrl(agentHref, workspaceCwd) {
     let next = agentHref || '';
     try {
@@ -3842,19 +3926,11 @@ document.addEventListener("DOMContentLoaded", () => {
     if (dispatchAskAiLaunch(payload)) {
       return;
     }
-    const cliProvider = resolveAskAiCliProvider(tool.href);
-    if (cliProvider) {
-      startAskAiCliSession(cliProvider, workspaceCwd).then((sessionUrl) => {
-        if (sessionUrl) {
-          window.location.href = sessionUrl;
-        }
-      }).catch((error) => {
-        console.warn('Failed to start Ask AI CLI session', error);
-      });
-      return;
-    }
     const fallbackUrl = buildAskAiLaunchUrl(tool.href, workspaceCwd);
     if (fallbackUrl) {
+      refreshTerminalSessions(fallbackUrl, workspaceCwd, {
+        retryDelays: []
+      });
       window.location.href = fallbackUrl;
     }
   }