pinokiod 6.0.55 → 6.0.56

package/package.json

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

package/server/index.js

@@ -10870,6 +10870,21 @@ class Server {
     })
     this.app.post("/pinokio/event", handlePinokioEvent)
     this.app.post("/pinokio/desktop/event", handlePinokioEvent)
+    this.app.get("/pinokio/event/run/:token", ex(async (req, res) => {
+      const token = req && req.params && typeof req.params.token === "string" ? req.params.token : ""
+      const payload = this.desktopEventRouter.resolveRun(token)
+      if (!payload) {
+        res.status(404).json({
+          ok: false,
+          error: "Event run payload not found"
+        })
+        return
+      }
+      res.json({
+        ok: true,
+        ...payload
+      })
+    }))
     this.app.post("/pinokio/peer/announce_kill", ex(async (req, res) => {
       this.kernel.peer.kill(req.body.host)
     }))

package/server/lib/desktop_event_router.js

@@ -1,9 +1,13 @@
 "use strict"
 
+const crypto = require("crypto")
 const fs = require("fs")
 const path = require("path")
 
 const DESKTOP_EVENT_NAME_PATTERN = /^[a-z0-9][a-z0-9:_-]{0,127}$/
+const DESKTOP_EVENT_RUN_TOKEN_PATTERN = /^[a-f0-9]{32}$/i
+const DESKTOP_EVENT_RUN_TTL_MS = 60 * 60 * 1000
+const DESKTOP_EVENT_RUN_STORE_LIMIT = 2048
 const WORKSPACE_PATH_PATTERNS = [
   /^\/pinokio\/([^/?#]+)/i,
   /^\/p\/([^/?#]+)/i,
@@ -296,50 +300,135 @@ const normalizeDesktopEventUi = (ui = {}) => {
   return normalized
 }
 
-const serializeDesktopEventValue = (value) => {
-  if (value === undefined) {
+const cloneDesktopEventValue = (value) => {
+  if (value === null || value === undefined) {
+    return value
+  }
+  try {
+    return structuredClone(value)
+  } catch (_) {
+    try {
+      return JSON.parse(JSON.stringify(value))
+    } catch (_) {
+      return value
+    }
+  }
+}
+
+const normalizeDesktopEventRunToken = (value) => {
+  if (typeof value !== "string") {
     return null
   }
-  if (value === null) {
-    return ""
+  const token = value.trim().toLowerCase()
+  if (!token || !DESKTOP_EVENT_RUN_TOKEN_PATTERN.test(token)) {
+    return null
   }
-  if (typeof value === "string") {
-    return value
+  return token
+}
+
+const createDesktopEventRunStore = () => {
+  const runs = new Map()
+
+  const pruneExpired = () => {
+    const now = Date.now()
+    for (const [token, entry] of runs.entries()) {
+      if (!entry || !entry.expiresAt || entry.expiresAt <= now) {
+        runs.delete(token)
+      }
+    }
   }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value)
+
+  const trimToLimit = () => {
+    if (runs.size < DESKTOP_EVENT_RUN_STORE_LIMIT) {
+      return
+    }
+    const entries = [...runs.entries()].sort((a, b) => {
+      const aTime = a[1] && a[1].createdAt ? a[1].createdAt : 0
+      const bTime = b[1] && b[1].createdAt ? b[1].createdAt : 0
+      return aTime - bTime
+    })
+    const overflow = (runs.size - DESKTOP_EVENT_RUN_STORE_LIMIT) + 1
+    for (let i = 0; i < overflow; i += 1) {
+      const entry = entries[i]
+      if (entry && entry[0]) {
+        runs.delete(entry[0])
+      }
+    }
   }
-  try {
-    return JSON.stringify(value)
-  } catch (_) {
-    return String(value)
+
+  const save = (payload = {}) => {
+    pruneExpired()
+    trimToLimit()
+    const token = crypto.randomBytes(16).toString("hex")
+    const now = Date.now()
+    runs.set(token, {
+      createdAt: now,
+      expiresAt: now + DESKTOP_EVENT_RUN_TTL_MS,
+      payload: cloneDesktopEventValue(payload)
+    })
+    return token
+  }
+
+  const read = (token) => {
+    pruneExpired()
+    const normalized = normalizeDesktopEventRunToken(token)
+    if (!normalized) {
+      return null
+    }
+    const entry = runs.get(normalized)
+    if (!entry) {
+      return null
+    }
+    if (!entry.expiresAt || entry.expiresAt <= Date.now()) {
+      runs.delete(normalized)
+      return null
+    }
+    return cloneDesktopEventValue(entry.payload)
+  }
+
+  return {
+    save,
+    read
   }
 }
 
-const buildDesktopEventQueryParams = (eventName, payload) => {
-  const params = new URLSearchParams()
-  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+const normalizeDesktopEventInput = ({ eventName, payload, context = {} }) => {
+  const input = {}
+  const positional = []
+
+  if (Array.isArray(payload)) {
+    positional.push(...payload)
+  } else if (payload && typeof payload === "object") {
+    if (Array.isArray(payload._)) {
+      positional.push(...payload._)
+    } else if (Array.isArray(payload.args)) {
+      positional.push(...payload.args)
+    }
     for (const [key, value] of Object.entries(payload)) {
-      if (!key || key.startsWith("__")) {
+      if (!key || key === "_" || key === "args" || key.startsWith("__")) {
         continue
       }
-      const serialized = serializeDesktopEventValue(value)
-      if (serialized !== null) {
-        params.set(key, serialized)
-      }
-    }
-  } else if (payload !== undefined) {
-    const serialized = serializeDesktopEventValue(payload)
-    if (serialized !== null) {
-      params.set("value", serialized)
+      input[key] = cloneDesktopEventValue(value)
     }
+  } else if (payload !== undefined && payload !== null) {
+    positional.push(payload)
   }
-  params.set("__desktop_event", eventName)
-  params.set("__desktop_payload", serializeDesktopEventValue(payload === undefined ? {} : payload) || "{}")
-  return params
+
+  input._ = positional.map((value) => cloneDesktopEventValue(value))
+  input.event = {
+    name: eventName,
+    source: typeof context.source === "string" ? context.source : "",
+    sourceEvent: typeof context.sourceEvent === "string" ? context.sourceEvent : "",
+    pageUrl: typeof context.pageUrl === "string" ? context.pageUrl : "",
+    frameUrl: typeof context.frameUrl === "string" ? context.frameUrl : "",
+    currentUrl: typeof context.currentUrl === "string" ? context.currentUrl : "",
+    topUrl: typeof context.topUrl === "string" ? context.topUrl : "",
+    referrerUrl: typeof context.referrerUrl === "string" ? context.referrerUrl : ""
+  }
+  return input
 }
 
-const resolveDesktopEventHandler = async ({ kernel, eventName, payload, context = {} }) => {
+const resolveDesktopEventHandler = async ({ kernel, eventName, payload, context = {}, runStore }) => {
   const workspace = await resolveDesktopEventWorkspace(context, kernel)
   if (!workspace) {
     return { matched: false, reason: "workspace_not_resolved" }
@@ -433,10 +522,18 @@ const resolveDesktopEventHandler = async ({ kernel, eventName, payload, context
   }
 
   const queryParams = new URLSearchParams(querySuffix)
-  const payloadParams = buildDesktopEventQueryParams(eventName, payload)
-  for (const [key, value] of payloadParams.entries()) {
-    queryParams.set(key, value)
-  }
+  const runInput = normalizeDesktopEventInput({ eventName, payload, context })
+  const runToken = runStore && typeof runStore.save === "function"
+    ? runStore.save({
+      workspace,
+      event: eventName,
+      input: runInput
+    })
+    : null
+  if (!runToken) {
+    return { matched: false, workspace, reason: "event_run_token_failed" }
+  }
+  queryParams.set("__pinokio_event_run", runToken)
 
   const queryString = queryParams.toString()
   const launchUrl = queryString ? `${launchPath}?${queryString}` : launchPath
@@ -452,6 +549,8 @@ const resolveDesktopEventHandler = async ({ kernel, eventName, payload, context
 }
 
 const createDesktopEventRouter = ({ kernel }) => {
+  const runStore = createDesktopEventRunStore()
+
   const handle = async (body = {}) => {
     const eventName = normalizeDesktopEventName(body ? body.event : null)
     if (!eventName) {
@@ -465,7 +564,7 @@ const createDesktopEventRouter = ({ kernel }) => {
     }
     const payload = body && Object.prototype.hasOwnProperty.call(body, "payload") ? body.payload : {}
     const context = body && body.context && typeof body.context === "object" ? body.context : {}
-    const result = await resolveDesktopEventHandler({ kernel, eventName, payload, context })
+    const result = await resolveDesktopEventHandler({ kernel, eventName, payload, context, runStore })
     if (!result.matched) {
       return {
         status: 200,
@@ -490,8 +589,17 @@ const createDesktopEventRouter = ({ kernel }) => {
     }
   }
 
+  const resolveRun = (token) => {
+    const payload = runStore.read(token)
+    if (!payload || typeof payload !== "object") {
+      return null
+    }
+    return payload
+  }
+
   return {
-    handle
+    handle,
+    resolveRun
   }
 }
 

package/server/views/terminal.ejs

@@ -999,11 +999,53 @@ document.addEventListener("DOMContentLoaded", async () => {
         this.socket.close()
 
         const searchParams = new URLSearchParams(location.search)
-        const query = Object.fromEntries(searchParams)
+        let query = {}
+        const positionalArgs = searchParams.getAll("_")
+        if (positionalArgs.length > 0) {
+          query._ = positionalArgs
+        }
+        for (const [key, value] of searchParams.entries()) {
+          if (!key || key === "_" || key === "__pinokio_event_panel" || key === "__pinokio_event_run") {
+            continue
+          }
+          if (Object.prototype.hasOwnProperty.call(query, key)) {
+            if (Array.isArray(query[key])) {
+              query[key].push(value)
+            } else {
+              query[key] = [query[key], value]
+            }
+          } else {
+            query[key] = value
+          }
+        }
+
+        const eventRunToken = searchParams.get("__pinokio_event_run")
+        if (eventRunToken) {
+          const response = await fetch(`/pinokio/event/run/${encodeURIComponent(eventRunToken)}`, {
+            method: "GET",
+            headers: {
+              "Accept": "application/json"
+            }
+          })
+          if (!response.ok) {
+            throw new Error("Event payload not found or expired")
+          }
+          const runPayload = await response.json().catch(() => null)
+          const eventInput = runPayload && runPayload.input && typeof runPayload.input === "object"
+            ? runPayload.input
+            : {}
+          const merged = Object.assign({}, query, eventInput)
+          merged._ = Array.isArray(eventInput._)
+            ? eventInput._
+            : (Array.isArray(query._) ? query._ : [])
+          query = merged
+        }
+
+        const sessionValue = Array.isArray(query.session) ? query.session[0] : query.session
         let runId = this.baseScriptId
-        if (query.session) {
+        if (typeof sessionValue === "string" && sessionValue.length > 0) {
           const baseId = this.baseScriptId || (scriptUri || ("~" + location.pathname))
-          runId = `${baseId}&session=${query.session}`
+          runId = `${baseId}&session=${sessionValue}`
         }
         this.currentId = runId || null
 
@@ -1549,8 +1591,19 @@ document.addEventListener("DOMContentLoaded", async () => {
       <% } else { %>
       await this.createTerm(xtermTheme.Tomorrow)
       <% } %>
-      await this.start(mode)
-      return true
+      try {
+        await this.start(mode)
+        return true
+      } catch (error) {
+        runControls.set("idle")
+        const message = error && error.message ? error.message : "Failed to start"
+        n.Noty({
+          text: message,
+          type: "error",
+          timeout: 4000
+        })
+        return false
+      }
     }
     async uploadFiles(files, overlay) {
       const localFiles = Array.isArray(files) ? files : []