pinokiod 6.0.63 → 6.0.65

package/package.json

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

package/server/index.js

@@ -3539,6 +3539,68 @@ class Server {
 
   async renderMenu(req, uri, name, config, pathComponents, indexPath) {
     if (config.menu) {
+      const normalizeMenuInjectList = (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") {
+            continue
+          }
+          const raw = entry.trim()
+          if (!raw) {
+            continue
+          }
+          const parts = raw.split(",").map((item) => item.trim()).filter(Boolean)
+          for (const part of parts) {
+            if (part.length > 1024) {
+              continue
+            }
+            if (seen.has(part)) {
+              continue
+            }
+            seen.add(part)
+            normalized.push(part)
+          }
+        }
+        return normalized
+      }
+      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: "/",
@@ -3630,6 +3692,14 @@ class Server {
         if (menuitem.href && menuitem.params) {
           menuitem.href = menuitem.href + "?" + new URLSearchParams(menuitem.params).toString();
         }
+        if (menuitem.href) {
+          const injectList = normalizeMenuInjectList(menuitem.inject)
+          if (injectList.length > 0) {
+            const hrefWithInject = appendInjectQueryParam(menuitem.href, injectList)
+            menuitem.href = hrefWithInject
+            config.menu[i].href = hrefWithInject
+          }
+        }
 
 
         if (menuitem.shell) {

package/server/lib/inject_router.js

@@ -80,6 +80,54 @@ const matchesInjectPattern = (pattern, targetUrl) => {
   return candidates.some((candidate) => expression.test(candidate))
 }
 
+const normalizeInjectHrefList = (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") {
+      continue
+    }
+    const raw = entry.trim()
+    if (!raw) {
+      continue
+    }
+    const parts = raw.split(",").map((item) => item.trim()).filter(Boolean)
+    for (const part of parts) {
+      if (part.length > 1024) {
+        continue
+      }
+      if (seen.has(part)) {
+        continue
+      }
+      seen.add(part)
+      normalized.push(part)
+    }
+  }
+  return normalized
+}
+
+const parseFrameInjectEntries = (frameUrl) => {
+  if (typeof frameUrl !== "string") {
+    return []
+  }
+  const value = frameUrl.trim()
+  if (!value) {
+    return []
+  }
+  let parsed
+  try {
+    parsed = new URL(value)
+  } catch (_) {
+    return []
+  }
+  const entries = parsed.searchParams.getAll("__pinokio_inject")
+  return normalizeInjectHrefList(entries)
+}
+
 const resolveInjectLaunchUrl = async ({ workspace, workspaceRoot, launcher, hrefRaw }) => {
   let hrefPath = hrefRaw
   let querySuffix = ""
@@ -94,7 +142,14 @@ const resolveInjectLaunchUrl = async ({ workspace, workspaceRoot, launcher, href
 
   let launchPath
   if (hrefPath.startsWith("/")) {
-    launchPath = hrefPath
+    const normalized = hrefPath.trim()
+    if (normalized.startsWith("/api/")) {
+      launchPath = `/raw/${normalized.slice("/api/".length)}`
+    } else if (normalized.startsWith("/_api/")) {
+      launchPath = `/raw/${normalized.slice("/_api/".length)}`
+    } else {
+      launchPath = normalized
+    }
   } else {
     const launcherRoot = launcher.launcher_root
       ? path.resolve(workspaceRoot, launcher.launcher_root)
@@ -120,7 +175,7 @@ const resolveInjectLaunchUrl = async ({ workspace, workspaceRoot, launcher, href
     if (routeSegments.length === 0) {
       return null
     }
-    launchPath = `/api/${encodeURIComponent(workspace)}/${routeSegments.join("/")}`
+    launchPath = `/raw/${encodeURIComponent(workspace)}/${routeSegments.join("/")}`
   }
 
   const queryParams = new URLSearchParams(querySuffix)
@@ -179,6 +234,37 @@ const createInjectRouter = ({ kernel }) => {
       }
     }
 
+    const frameUrl = typeof context.frameUrl === "string" ? context.frameUrl : ""
+    const frameInjectEntries = parseFrameInjectEntries(frameUrl)
+    if (frameInjectEntries.length > 0) {
+      const scripts = []
+      for (const hrefRaw of frameInjectEntries) {
+        const launchUrl = await resolveInjectLaunchUrl({
+          workspace,
+          workspaceRoot,
+          launcher,
+          hrefRaw
+        })
+        if (!launchUrl) {
+          continue
+        }
+        scripts.push(launchUrl)
+      }
+      const uniqueScripts = [...new Set(scripts)]
+      if (uniqueScripts.length > 0) {
+        return {
+          status: 200,
+          body: {
+            ok: true,
+            matched: true,
+            workspace,
+            scripts: uniqueScripts,
+            source: "frame_query"
+          }
+        }
+      }
+    }
+
     let injectConfig = launcher.script.inject
     if (typeof injectConfig === "function") {
       if (injectConfig.constructor.name === "AsyncFunction") {
@@ -201,7 +287,6 @@ const createInjectRouter = ({ kernel }) => {
       }
     }
 
-    const frameUrl = typeof context.frameUrl === "string" ? context.frameUrl : ""
     const scripts = []
     for (const entry of entries) {
       if (!entry.match.some((pattern) => matchesInjectPattern(pattern, frameUrl))) {