pinokiod 6.0.46 → 6.0.48

package/package.json

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

package/server/lib/desktop_event_router.js

@@ -5,6 +5,7 @@ const path = require("path")
 
 const DESKTOP_EVENT_NAME_PATTERN = /^[a-z0-9][a-z0-9:_-]{0,127}$/
 const WORKSPACE_PATH_PATTERNS = [
+  /^\/pinokio\/([^/?#]+)/i,
   /^\/p\/([^/?#]+)/i,
   /^\/api\/([^/?#]+)/i,
   /^\/_api\/([^/?#]+)/i,
@@ -100,7 +101,134 @@ const extractWorkspaceFromUrl = (rawUrl) => {
   return extractWorkspaceFromPathname(parsedUrl.pathname)
 }
 
-const resolveDesktopEventWorkspace = async (context = {}) => {
+const toHttpHostKey = (rawUrl) => {
+  if (typeof rawUrl !== "string") {
+    return null
+  }
+  const value = rawUrl.trim()
+  if (!value) {
+    return null
+  }
+  let parsed
+  try {
+    parsed = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value)
+      ? new URL(value)
+      : new URL(value, "http://localhost")
+  } catch (_) {
+    return null
+  }
+  const protocol = parsed.protocol || ""
+  if (protocol !== "http:" && protocol !== "https:") {
+    return null
+  }
+  const host = (parsed.host || "").trim().toLowerCase()
+  return host || null
+}
+
+const collectUrlLikeValues = (value, out = new Set(), depth = 0) => {
+  if (depth > 4 || value === null || value === undefined) {
+    return out
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim()
+    if (trimmed) {
+      out.add(trimmed)
+    }
+    return out
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectUrlLikeValues(entry, out, depth + 1)
+    }
+    return out
+  }
+  if (typeof value === "object") {
+    for (const [key, entry] of Object.entries(value)) {
+      if (!key) {
+        continue
+      }
+      if (typeof entry === "string" && /url/i.test(key)) {
+        const trimmed = entry.trim()
+        if (trimmed) {
+          out.add(trimmed)
+        }
+        continue
+      }
+      if (typeof entry === "object" && entry !== null) {
+        collectUrlLikeValues(entry, out, depth + 1)
+      }
+    }
+  }
+  return out
+}
+
+const resolveWorkspaceFromRunningScripts = (kernel, context = {}) => {
+  if (!kernel || !kernel.info || typeof kernel.info.scriptsByApi !== "function") {
+    return null
+  }
+  const contextHosts = new Set()
+  const contextUrlCandidates = [
+    context.frameUrl,
+    context.pageUrl,
+    context.currentUrl,
+    context.sourceUrl,
+    context.referrerUrl,
+    context.topUrl,
+    context.destinationUrl,
+    context.url,
+  ]
+  for (const candidate of contextUrlCandidates) {
+    const hostKey = toHttpHostKey(candidate)
+    if (hostKey) {
+      contextHosts.add(hostKey)
+    }
+  }
+  if (contextHosts.size === 0) {
+    return null
+  }
+  let scriptsByApi
+  try {
+    scriptsByApi = kernel.info.scriptsByApi()
+  } catch (_) {
+    return null
+  }
+  if (!scriptsByApi || typeof scriptsByApi !== "object") {
+    return null
+  }
+  const matches = new Set()
+  for (const [workspace, entries] of Object.entries(scriptsByApi)) {
+    if (!workspace || !Array.isArray(entries)) {
+      continue
+    }
+    const normalizedWorkspace = sanitizeDesktopWorkspaceName(workspace)
+    if (!normalizedWorkspace) {
+      continue
+    }
+    let matched = false
+    for (const entry of entries) {
+      const urlValues = collectUrlLikeValues(entry, new Set())
+      for (const value of urlValues) {
+        const hostKey = toHttpHostKey(value)
+        if (hostKey && contextHosts.has(hostKey)) {
+          matched = true
+          break
+        }
+      }
+      if (matched) {
+        break
+      }
+    }
+    if (matched) {
+      matches.add(normalizedWorkspace)
+    }
+  }
+  if (matches.size === 1) {
+    return [...matches][0]
+  }
+  return null
+}
+
+const resolveDesktopEventWorkspace = async (context = {}, kernel = null) => {
   const explicitCandidates = [
     context.workspace,
     context.app,
@@ -114,11 +242,14 @@ const resolveDesktopEventWorkspace = async (context = {}) => {
     }
   }
   const urlCandidates = [
+    context.frameUrl,
     context.pageUrl,
     context.url,
     context.currentUrl,
     context.sourceUrl,
     context.referrerUrl,
+    context.topUrl,
+    context.destinationUrl,
   ]
   for (const candidate of urlCandidates) {
     const workspaceName = extractWorkspaceFromUrl(candidate)
@@ -126,6 +257,10 @@ const resolveDesktopEventWorkspace = async (context = {}) => {
       return workspaceName
     }
   }
+  const workspaceByHost = resolveWorkspaceFromRunningScripts(kernel, context)
+  if (workspaceByHost) {
+    return workspaceByHost
+  }
   return null
 }
 
@@ -195,7 +330,7 @@ const buildDesktopEventQueryParams = (eventName, payload) => {
 }
 
 const resolveDesktopEventHandler = async ({ kernel, eventName, payload, context = {} }) => {
-  const workspace = await resolveDesktopEventWorkspace(context)
+  const workspace = await resolveDesktopEventWorkspace(context, kernel)
   if (!workspace) {
     return { matched: false, reason: "workspace_not_resolved" }
   }

package/server/public/layout.js

@@ -479,6 +479,27 @@
     });
   }
 
+  function relayDesktopEventLaunch(payload, excludedSource = null) {
+    if (!payload || typeof payload !== 'object' || payload.e !== 'pinokio:desktop-event-launch') {
+      return 0;
+    }
+    let relayed = 0;
+    leafElements.forEach((entry) => {
+      const targetWindow = entry && entry.iframe ? entry.iframe.contentWindow : null;
+      if (!targetWindow) {
+        return;
+      }
+      if (excludedSource && targetWindow === excludedSource) {
+        return;
+      }
+      try {
+        targetWindow.postMessage(payload, '*');
+        relayed += 1;
+      } catch (_) {}
+    });
+    return relayed;
+  }
+
   let activeResize = null;
 
   function beginResize(splitId, pointerEvent) {
@@ -665,6 +686,10 @@
     if (!event || !event.data || typeof event.data !== 'object') {
       return;
     }
+    if (event.data.e === 'pinokio:desktop-event-launch') {
+      relayDesktopEventLaunch(event.data, event.source || null);
+      return;
+    }
     if (event.data.e === 'layout-state-request') {
       let frameEntry = null;
       let frameId = null;
@@ -770,6 +795,15 @@
 
   initLayout();
   window.addEventListener('message', onMessage);
+  window.addEventListener('pinokio:desktop-event-launch', (event) => {
+    const detail = event && event.detail && typeof event.detail === 'object'
+      ? event.detail
+      : null;
+    if (!detail || detail.e !== 'pinokio:desktop-event-launch') {
+      return;
+    }
+    relayDesktopEventLaunch(detail, null);
+  });
   window.addEventListener('resize', onResize);
   window.addEventListener('pinokio:viewport-change', onResize);
 

package/server/views/app.ejs

@@ -7422,6 +7422,12 @@ const rerenderMenuSection = (container, html) => {
       //if (String(port) === "<%=port%>" || /https:\/\/pinokio\..*localhost/.test(origin)) {
       //if (String(port) === "<%=port%>") {
         if (event.data) {
+          if (event.data.e === "pinokio:desktop-event-launch") {
+            return
+          }
+          if (event.data.e === "pinokio:desktop-event") {
+            return
+          }
           if (event.data.action) {
             if (event.data.action.type === "newtab") {
               addTab(event.data.action.url)
@@ -7437,18 +7443,23 @@ const rerenderMenuSection = (container, html) => {
               }
             }
           } else if (event.data.launch) {
-            const rawName = event.data.launch.name
+            const launchPayload = event.data.launch
+            const rawName = launchPayload && typeof launchPayload.name === "string" ? launchPayload.name : ""
+            const launchHref = launchPayload && typeof launchPayload.href === "string" ? launchPayload.href : ""
+            if (!rawName || !launchHref) {
+              return
+            }
             const escapedSelector = escapeTargetSelector(rawName)
             if (escapedSelector) {
               global_selector = `.frame-link[target="${escapedSelector}"]`
             } else {
               global_selector = null
             }
-          const frameExists = Array.from(document.querySelectorAll("main.browserview iframe")).some((frame) => {
+            const frameExists = Array.from(document.querySelectorAll("main.browserview iframe")).some((frame) => {
             return frame.name === rawName
           })
             if (!frameExists) {
-              create_iframe(rawName, event.data.launch.href)
+              create_iframe(rawName, launchHref)
             }
             refresh()
           } else if (event.data.type === "shell-session-id") {
@@ -11876,6 +11887,19 @@ document.addEventListener("DOMContentLoaded", () => {
     }
   })
 
+  const openDesktopEvent = (launch) => {
+    if (!launch || typeof launch !== "object") {
+      return false
+    }
+    const rawUrl = typeof launch.url === "string" ? launch.url : ""
+    if (!rawUrl) {
+      return false
+    }
+    return openWithUrl(rawUrl, {
+      workspaceCwd: resolveWorkspaceCwd(launch)
+    })
+  }
+
   if (resizer) {
     let isResizing = false
     let pointerId = null
@@ -11952,11 +11976,225 @@ document.addEventListener("DOMContentLoaded", () => {
     openWithAgent,
     openPicker,
     openWithUrl,
+    openDesktopEvent,
     close: () => setOpen(false),
     isOpen: () => open
   }
 })();
 
+(function() {
+  const normalizeLaunchUrl = (rawUrl) => {
+    if (typeof rawUrl !== "string" || !rawUrl.trim()) {
+      return null
+    }
+    let parsed
+    try {
+      parsed = new URL(rawUrl, window.location.origin)
+    } catch (_) {
+      return null
+    }
+    if (parsed.origin !== window.location.origin) {
+      return null
+    }
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`
+  }
+
+  const isTrustedOrigin = (origin) => {
+    if (!origin) {
+      return true
+    }
+    let parsed
+    try {
+      parsed = new URL(origin)
+    } catch (_) {
+      return false
+    }
+    const originPort = parsed.port || "80"
+    const currentPort = window.location.port || "80"
+    if (String(originPort) === String(currentPort)) {
+      return true
+    }
+    return /https:\/\/.*pinokio\..*(localhost|co)/.test(origin)
+  }
+
+  const escapeText = (value) => String(value || "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;")
+
+  let overlayEl = null
+  let overlayEscHandler = null
+
+  const closeOverlay = () => {
+    if (overlayEscHandler) {
+      document.removeEventListener("keydown", overlayEscHandler)
+      overlayEscHandler = null
+    }
+    if (overlayEl && overlayEl.parentNode) {
+      overlayEl.parentNode.removeChild(overlayEl)
+    }
+    overlayEl = null
+  }
+
+  const openOverlay = (launch) => {
+    if (!launch || typeof launch !== "object") {
+      return false
+    }
+    const normalizedUrl = normalizeLaunchUrl(launch.url)
+    if (!normalizedUrl) {
+      return false
+    }
+    closeOverlay()
+    const ui = launch.ui && typeof launch.ui === "object" ? launch.ui : {}
+    const title = typeof ui.title === "string" && ui.title.trim()
+      ? ui.title.trim()
+      : "Task"
+    const overlay = document.createElement("div")
+    overlay.className = "pinokio-custom-terminal-overlay pinokio-desktop-event-overlay"
+    overlay.innerHTML = `
+      <div class="pinokio-custom-terminal-modal">
+        <div class="pinokio-custom-terminal-header">
+          <h3>${escapeText(title)}</h3>
+          <button class="pinokio-custom-terminal-close" aria-label="Close">×</button>
+        </div>
+        <div class="pinokio-custom-terminal-body">
+          <iframe src="${escapeText(normalizedUrl)}" frameborder="0" allow="fullscreen *;" allowfullscreen></iframe>
+        </div>
+      </div>
+    `
+    const closeBtn = overlay.querySelector(".pinokio-custom-terminal-close")
+    if (closeBtn) {
+      closeBtn.addEventListener("click", closeOverlay)
+    }
+    overlay.addEventListener("click", (event) => {
+      if (event.target === overlay) {
+        closeOverlay()
+      }
+    })
+    overlayEscHandler = (event) => {
+      if (event.key === "Escape") {
+        closeOverlay()
+      }
+    }
+    document.addEventListener("keydown", overlayEscHandler)
+    document.body.appendChild(overlay)
+    overlayEl = overlay
+    return true
+  }
+
+  const openSidebar = (launch) => {
+    const drawer = window.PinokioAskAiDrawer
+    if (!drawer || typeof drawer.openDesktopEvent !== "function") {
+      return false
+    }
+    closeOverlay()
+    return drawer.openDesktopEvent(launch)
+  }
+
+  const handleDesktopLaunch = (envelope) => {
+    const launch = envelope && typeof envelope === "object" && envelope.launch && typeof envelope.launch === "object"
+      ? envelope.launch
+      : envelope
+    if (!launch || typeof launch !== "object") {
+      return false
+    }
+    const ui = launch.ui && typeof launch.ui === "object" ? launch.ui : {}
+    const mode = typeof ui.mode === "string" ? ui.mode.trim().toLowerCase() : "sidebar"
+    if (mode === "overlay") {
+      return openOverlay(launch)
+    }
+    if (mode === "sidebar") {
+      const opened = openSidebar(launch)
+      if (opened) {
+        return true
+      }
+      return openOverlay(launch)
+    }
+    return false
+  }
+
+  const dispatchDesktopEvent = async (envelope) => {
+    if (!envelope || typeof envelope !== "object") {
+      return null
+    }
+    const eventName = typeof envelope.event === "string" ? envelope.event.trim() : ""
+    if (!eventName) {
+      return null
+    }
+    const payload = envelope.payload && typeof envelope.payload === "object"
+      ? envelope.payload
+      : {}
+    const context = envelope.context && typeof envelope.context === "object"
+      ? { ...envelope.context }
+      : {}
+    if (!context.pageUrl) {
+      context.pageUrl = window.location.href
+    }
+    if (!context.currentUrl) {
+      context.currentUrl = window.location.href
+    }
+    if (!context.referrerUrl && document.referrer) {
+      context.referrerUrl = document.referrer
+    }
+    const response = await fetch("/pinokio/desktop/event", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ event: eventName, payload, context })
+    })
+    if (!response.ok) {
+      return null
+    }
+    return response.json().catch(() => null)
+  }
+
+  window.addEventListener("message", (event) => {
+    if (!event || !event.data || typeof event.data !== "object") {
+      return
+    }
+    if (event.data.e !== "pinokio:desktop-event") {
+      return
+    }
+    dispatchDesktopEvent(event.data).then((result) => {
+      if (!result || !result.ok || !result.matched || !result.launch || !result.launch.url) {
+        return
+      }
+      window.postMessage({ e: "pinokio:desktop-event-launch", launch: result.launch }, "*")
+    }).catch(() => {})
+  })
+
+  window.addEventListener("pinokio:desktop-event-launch", (event) => {
+    handleDesktopLaunch(event && event.detail ? event.detail : null)
+  })
+
+  window.addEventListener("message", (event) => {
+    if (!event || !event.data || typeof event.data !== "object") {
+      return
+    }
+    if (event.data.e !== "pinokio:desktop-event-launch") {
+      return
+    }
+    if (!isTrustedOrigin(event.origin)) {
+      return
+    }
+    handleDesktopLaunch(event.data)
+  })
+
+  window.PinokioDesktopEventUi = {
+    open: (launch) => handleDesktopLaunch(launch),
+    closeOverlay,
+    closeSidebar: () => {
+      const drawer = window.PinokioAskAiDrawer
+      if (drawer && typeof drawer.close === "function") {
+        drawer.close()
+      }
+    }
+  }
+})();
+
 (function() {
   const drawer = document.getElementById("community-drawer")
   if (!drawer) {