pinokiod 6.0.65 → 6.0.66

package/package.json

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

package/server/lib/inject_router.js

@@ -5,81 +5,6 @@ const path = require("path")
 
 const { resolveDesktopEventWorkspace } = require("./desktop_event_router")
 
-const escapeRegex = (value) => String(value || "").replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
-
-const wildcardToRegex = (pattern) => {
-  const source = escapeRegex(pattern).replace(/\*/g, ".*")
-  return new RegExp(`^${source}$`)
-}
-
-const normalizeInjectPatterns = (value) => {
-  const list = Array.isArray(value) ? value : [value]
-  const patterns = list
-    .map((item) => (typeof item === "string" ? item.trim() : ""))
-    .filter(Boolean)
-  return patterns.length ? patterns : ["*"]
-}
-
-const normalizeInjectEntries = (injectConfig) => {
-  if (!injectConfig) {
-    return []
-  }
-  const entries = Array.isArray(injectConfig) ? injectConfig : [injectConfig]
-  const normalized = []
-  for (const entry of entries) {
-    const config = typeof entry === "string" ? { href: entry } : entry
-    if (!config || typeof config !== "object") {
-      continue
-    }
-    const href = typeof config.href === "string" ? config.href.trim() : ""
-    if (!href) {
-      continue
-    }
-    normalized.push({
-      href,
-      match: normalizeInjectPatterns(config.match)
-    })
-  }
-  return normalized
-}
-
-const resolveInjectMatchCandidates = (targetUrl) => {
-  if (typeof targetUrl !== "string") {
-    return []
-  }
-  const value = targetUrl.trim()
-  if (!value) {
-    return []
-  }
-  let parsed
-  try {
-    parsed = new URL(value)
-  } catch (_) {
-    return [value]
-  }
-  const pathname = parsed.pathname || ""
-  const originPath = `${parsed.origin}${pathname}`
-  const hostPath = `${parsed.host}${pathname}`
-  return [parsed.href, originPath, hostPath, pathname].filter(Boolean)
-}
-
-const matchesInjectPattern = (pattern, targetUrl) => {
-  if (pattern === "*") {
-    return true
-  }
-  const candidates = resolveInjectMatchCandidates(targetUrl)
-  if (!candidates.length) {
-    return false
-  }
-  let expression
-  try {
-    expression = wildcardToRegex(pattern)
-  } catch (_) {
-    return false
-  }
-  return candidates.some((candidate) => expression.test(candidate))
-}
-
 const normalizeInjectHrefList = (value) => {
   if (!value) {
     return []
@@ -236,45 +161,7 @@ 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") {
-        injectConfig = await injectConfig(kernel, kernel.info)
-      } else {
-        injectConfig = injectConfig(kernel, kernel.info)
-      }
-    }
-    const entries = normalizeInjectEntries(injectConfig)
-    if (!entries.length) {
+    if (frameInjectEntries.length === 0) {
       return {
         status: 200,
         body: {
@@ -282,21 +169,18 @@ const createInjectRouter = ({ kernel }) => {
           matched: false,
           workspace,
           scripts: [],
-          reason: "inject_not_configured"
+          reason: "inject_not_requested"
         }
       }
     }
 
     const scripts = []
-    for (const entry of entries) {
-      if (!entry.match.some((pattern) => matchesInjectPattern(pattern, frameUrl))) {
-        continue
-      }
+    for (const hrefRaw of frameInjectEntries) {
       const launchUrl = await resolveInjectLaunchUrl({
         workspace,
         workspaceRoot,
         launcher,
-        hrefRaw: entry.href
+        hrefRaw
       })
       if (!launchUrl) {
         continue
@@ -311,7 +195,8 @@ const createInjectRouter = ({ kernel }) => {
         ok: true,
         matched: uniqueScripts.length > 0,
         workspace,
-        scripts: uniqueScripts
+        scripts: uniqueScripts,
+        source: "frame_query"
       }
     }
   }

package/server/views/app.ejs

@@ -12243,7 +12243,6 @@ document.addEventListener("DOMContentLoaded", () => {
     const messageType = event.data.e
     const isPinokioBridgeMessage = (
       messageType === "pinokio:event" ||
-      messageType === "pinokio:event-launch" ||
       messageType === "pinokio:inject:request"
     )
     const trusted = isTrustedOrigin(event.origin) || (isPinokioBridgeMessage && isKnownFrameSource(event.source))
@@ -12276,14 +12275,6 @@ document.addEventListener("DOMContentLoaded", () => {
           })
         }
       }).catch(() => {})
-    } else if (messageType === "pinokio:event-launch") {
-      const payloadFrameUrl = event.data && event.data.context && typeof event.data.context.frameUrl === "string"
-        ? event.data.context.frameUrl
-        : ""
-      openEventLaunch(event.data && event.data.launch, {
-        sourceWindow: event.source,
-        sourceFrameUrl: payloadFrameUrl || resolveFrameUrlFromSource(event.source)
-      })
     } else if (messageType === "pinokio:inject:request") {
       dispatchPinokioInjectRequest(event.data, event.source).then((result) => {
         if (!result || !result.ok || !event.source || typeof event.source.postMessage !== "function") {