pinokiod 7.2.11 → 7.2.13

package/kernel/plugin_sources.js

@@ -0,0 +1,236 @@
+const fs = require("fs")
+const path = require("path")
+const { glob } = require("glob")
+
+const LOCAL_RUN_PREFIX = "/run"
+const LOCAL_ASSET_PREFIX = "/asset"
+const SYSTEM_RUN_PREFIX = "/pinokio/run"
+const SYSTEM_ASSET_PREFIX = "/pinokio/asset"
+const LOCAL_PLUGIN_RUN_PREFIX = `${LOCAL_RUN_PREFIX}/plugin`
+const LOCAL_PLUGIN_ASSET_PREFIX = `${LOCAL_ASSET_PREFIX}/plugin`
+const SYSTEM_PLUGIN_RUN_PREFIX = `${SYSTEM_RUN_PREFIX}/plugin`
+const SYSTEM_PLUGIN_ASSET_PREFIX = `${SYSTEM_ASSET_PREFIX}/plugin`
+
+const toPathname = (value) => {
+  const raw = typeof value === "string" ? value.trim() : ""
+  if (!raw) return ""
+  try {
+    if (/^https?:\/\//i.test(raw)) return new URL(raw).pathname
+    if (raw.startsWith("/")) return new URL(`http://localhost${raw}`).pathname
+  } catch (_) {
+  }
+  return raw.split("?")[0].split("#")[0]
+}
+
+const normalizeSlashes = (value) => String(value || "").replace(/\\/g, "/").replace(/\/{2,}/g, "/")
+
+const systemRoot = (kernel) => {
+  if (kernel && typeof kernel.systemPath === "function") {
+    return kernel.systemPath()
+  }
+  return path.resolve(__dirname, "..", "system")
+}
+
+const systemPluginRoot = (kernel) => {
+  if (kernel && typeof kernel.systemPath === "function") {
+    return kernel.systemPath("plugin")
+  }
+  return path.resolve(__dirname, "..", "system", "plugin")
+}
+
+const isSystemRunPath = (value) => toPathname(value).startsWith(`${SYSTEM_RUN_PREFIX}/`)
+const isLocalRunPath = (value) => toPathname(value).startsWith(`${LOCAL_RUN_PREFIX}/`)
+const isRunPath = (value) => isLocalRunPath(value) || isSystemRunPath(value)
+const isSystemPluginPath = (value) => normalizeSlashes(value).startsWith(`${SYSTEM_PLUGIN_RUN_PREFIX}/`)
+const isLegacyPluginCodePath = (value) => {
+  const normalized = normalizeSlashes(value).replace(/^\/+/, "")
+  return normalized.startsWith("plugin/code/") || normalized.startsWith("code/")
+}
+
+const normalizePluginPath = (value) => {
+  let normalized = toPathname(value)
+  if (!normalized) return ""
+  normalized = normalizeSlashes(normalized)
+  if (!normalized.startsWith(`${SYSTEM_RUN_PREFIX}/`)) {
+    normalized = normalized.replace(/^\/run(?=\/)/, "")
+  }
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`
+  }
+  normalized = normalized.replace(/\/+$/, "")
+  if (!normalized.endsWith("/pinokio.js")) {
+    normalized = `${normalized}/pinokio.js`
+  }
+  return normalized
+}
+
+const pluginSelectionMatches = (src, selectedValue) => {
+  const selectedPlugin = normalizeSlashes(typeof selectedValue === "string" ? selectedValue.trim() : "")
+  if (!selectedPlugin || !src) return false
+  const selectedRunPath = selectedPlugin.startsWith(`${SYSTEM_RUN_PREFIX}/`)
+    ? selectedPlugin
+    : `${LOCAL_RUN_PREFIX}${selectedPlugin}`
+  return src === selectedPlugin || src.startsWith(selectedRunPath)
+}
+
+const resolveRunPath = (kernel, value) => {
+  const pathname = toPathname(value)
+  if (isSystemRunPath(pathname)) {
+    const parts = pathname.split("/").filter(Boolean).slice(2)
+    return kernel.systemPath(...parts)
+  }
+  if (isLocalRunPath(pathname)) {
+    const parts = pathname.split("/").filter(Boolean).slice(1)
+    return kernel.path(...parts)
+  }
+  return ""
+}
+
+const resolvePinokioPath = (kernel, value) => {
+  const runPath = resolveRunPath(kernel, value)
+  if (runPath) return runPath
+  const pathname = toPathname(value)
+  return pathname ? kernel.path(pathname.replace(/^\/+/, "")) : ""
+}
+
+const systemRelativeFromPluginPath = (normalizedPath) => {
+  return normalizeSlashes(normalizedPath).replace(/^\/pinokio\/run\/+/, "")
+}
+
+const pluginPathToAbsolute = (kernel, normalizedPath) => {
+  if (isSystemPluginPath(normalizedPath)) {
+    return kernel.systemPath(systemRelativeFromPluginPath(normalizedPath))
+  }
+  return kernel.path(normalizeSlashes(normalizedPath).replace(/^\/+/, ""))
+}
+
+const pluginRunHrefForPath = (normalizedPath) => {
+  if (typeof normalizedPath !== "string" || !normalizedPath) return ""
+  if (isSystemPluginPath(normalizedPath)) return normalizedPath
+  return `${LOCAL_RUN_PREFIX}${normalizedPath}`
+}
+
+const pluginAssetHrefForIcon = (normalizedPath, icon) => {
+  const trimmedIcon = typeof icon === "string" ? icon.trim() : ""
+  if (!trimmedIcon) return ""
+  if (isSystemPluginPath(normalizedPath)) {
+    const relativeDir = path.posix.dirname(systemRelativeFromPluginPath(normalizedPath))
+    return `${SYSTEM_ASSET_PREFIX}/${relativeDir}/${trimmedIcon}`
+  }
+  if (normalizeSlashes(normalizedPath).startsWith("/plugin/")) {
+    const relativeDir = path.posix.dirname(normalizeSlashes(normalizedPath).slice(1))
+    return `${LOCAL_ASSET_PREFIX}/${relativeDir}/${trimmedIcon}`
+  }
+  return ""
+}
+
+const normalizeLauncherTool = (toolValue) => {
+  let normalizedTool = typeof toolValue === "string" ? toolValue.trim() : ""
+  normalizedTool = normalizedTool.replace(/^https?:\/\/[^/]+/i, "")
+  normalizedTool = normalizedTool.replace(/^\/+|\/+$/g, "")
+  if (!normalizedTool || normalizedTool.includes("..") || !/^[A-Za-z0-9._/-]+$/.test(normalizedTool)) {
+    const error = new Error("Invalid plugin.")
+    error.status = 400
+    throw error
+  }
+  if (!normalizedTool.startsWith("pinokio/run/")) {
+    normalizedTool = normalizedTool.replace(/^run\//, "")
+  }
+  if (isLegacyPluginCodePath(normalizedTool)) {
+    const error = new Error("The managed plugin/code path is no longer used.")
+    error.status = 400
+    throw error
+  }
+  return normalizedTool
+}
+
+const resolveLauncherPluginHref = (toolValue) => {
+  const normalizedTool = normalizeLauncherTool(toolValue)
+  if (normalizedTool.startsWith("pinokio/run/")) {
+    const scriptPath = normalizedTool.endsWith(".js")
+      ? normalizedTool
+      : `${normalizedTool}/pinokio.js`
+    return `/${scriptPath}`
+  }
+  if (normalizedTool.startsWith("plugin/") || normalizedTool.startsWith("api/")) {
+    const scriptPath = normalizedTool.endsWith(".js")
+      ? normalizedTool
+      : `${normalizedTool}/pinokio.js`
+    return `${LOCAL_RUN_PREFIX}/${scriptPath}`
+  }
+  return `${LOCAL_PLUGIN_RUN_PREFIX}/${normalizedTool}/pinokio.js`
+}
+
+const loadPluginsFromRoot = async ({ kernel, root, runPrefix, assetPrefix, source, ignore = [] }) => {
+  const exists = await fs.promises.stat(root).then((stat) => stat.isDirectory()).catch(() => false)
+  if (!exists) return []
+
+  const pluginPaths = await glob("**/pinokio.js", { cwd: root, ignore })
+  const plugins = []
+  for (const pluginPath of pluginPaths) {
+    const normalizedPluginPath = normalizeSlashes(pluginPath)
+    const config = await kernel.require(path.resolve(root, pluginPath))
+    if (!config || !Array.isArray(config.run)) continue
+    const invalid = Object.keys(config).some((key) => typeof config[key] === "function")
+    if (invalid) continue
+
+    const cwd = normalizedPluginPath.split("/").slice(0, -1).join("/")
+    const href = `${runPrefix}/${normalizedPluginPath}`
+    const image = config.icon ? `${assetPrefix}/${cwd}/${config.icon}` : config.image
+    plugins.push({
+      ...config,
+      href,
+      src: href,
+      image,
+      source,
+      system: source === "system",
+    })
+  }
+  return plugins
+}
+
+const loadPluginMenu = async (kernel) => {
+  const systemPlugins = await loadPluginsFromRoot({
+    kernel,
+    root: systemPluginRoot(kernel),
+    runPrefix: SYSTEM_PLUGIN_RUN_PREFIX,
+    assetPrefix: SYSTEM_PLUGIN_ASSET_PREFIX,
+    source: "system",
+  })
+  const localPlugins = await loadPluginsFromRoot({
+    kernel,
+    root: path.resolve(kernel.homedir, "plugin"),
+    runPrefix: LOCAL_PLUGIN_RUN_PREFIX,
+    assetPrefix: LOCAL_PLUGIN_ASSET_PREFIX,
+    source: "local",
+    ignore: ["code/**"],
+  })
+  return systemPlugins.concat(localPlugins)
+}
+
+module.exports = {
+  LOCAL_RUN_PREFIX,
+  LOCAL_ASSET_PREFIX,
+  SYSTEM_RUN_PREFIX,
+  SYSTEM_ASSET_PREFIX,
+  LOCAL_PLUGIN_RUN_PREFIX,
+  SYSTEM_PLUGIN_RUN_PREFIX,
+  SYSTEM_PLUGIN_ASSET_PREFIX,
+  systemRoot,
+  systemPluginRoot,
+  toPathname,
+  isSystemRunPath,
+  isLocalRunPath,
+  isRunPath,
+  isSystemPluginPath,
+  isLegacyPluginCodePath,
+  normalizePluginPath,
+  pluginSelectionMatches,
+  resolveRunPath,
+  resolvePinokioPath,
+  pluginPathToAbsolute,
+  pluginRunHrefForPath,
+  pluginAssetHrefForIcon,
+  resolveLauncherPluginHref,
+  loadPluginMenu,
+}

package/kernel/util.js

@@ -434,6 +434,65 @@ const openURL = (url) => {
     console.warn('[Util.openURL] exec failed:', err && err.message ? err.message : err)
   }
 }
+const openURI = async (uri) => {
+  const platform = os.platform()
+  const launch = (command, args) => {
+    return new Promise((resolve, reject) => {
+      let settled = false
+      const settle = (fn, value) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        fn(value)
+      }
+      const timer = setTimeout(() => {
+        settle(resolve, {
+          ok: true,
+          command,
+          status: 'started'
+        })
+      }, 3000)
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore'
+      })
+      child.on('error', (error) => {
+        settle(reject, error)
+      })
+      child.on('close', (code) => {
+        if (code) {
+          settle(reject, new Error(`${command} exited with code ${code}`))
+        } else {
+          settle(resolve, {
+            ok: true,
+            command,
+            status: 'exited'
+          })
+        }
+      })
+      child.unref()
+    })
+  }
+  try {
+    if (platform === 'darwin') {
+      return await launch('open', [uri])
+    } else if (platform === 'win32') {
+      try {
+        return await launch('rundll32.exe', ['url.dll,FileProtocolHandler', uri])
+      } catch (error) {
+        console.warn('[Util.openURI] rundll32 failed, falling back to explorer:', error && error.message ? error.message : error)
+        return await launch('explorer.exe', [uri])
+      }
+    }
+    return await launch('xdg-open', [uri])
+  } catch (err) {
+    console.warn('[Util.openURI] spawn failed:', err && err.message ? err.message : err)
+    return {
+      ok: false,
+      error: err && err.message ? err.message : String(err)
+    }
+  }
+}
 const openfs = (dirPath, options, kernel) => {
   let command = '';
   const platform = os.platform()
@@ -1197,6 +1256,7 @@ module.exports = {
   find_venv,
   fill_object,
   run,
+  openURI,
   openURL,
   u2p,
   p2u,

package/package.json

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

package/server/features/drafts/public/drafts.js

@@ -269,10 +269,10 @@
         justify-content: center;
         gap: 6px;
         min-height: 30px;
-        border: 1px solid rgba(15, 23, 42, 0.14);
+        border: 1px solid var(--pinokio-chrome-accent-bg-light);
         border-radius: 6px;
-        background: rgba(255, 255, 255, 0.88);
-        color: #1f2937;
+        background: var(--pinokio-chrome-accent-bg-light);
+        color: var(--pinokio-chrome-accent-fg-light);
         cursor: pointer;
         font-size: 12px;
         font-weight: 700;
@@ -282,37 +282,60 @@
       }
       .pinokio-draft-button:hover,
       .pinokio-draft-button:focus {
-        border-color: rgba(15, 23, 42, 0.24);
-        background: rgba(15, 23, 42, 0.04);
+        border-color: color-mix(in srgb, var(--pinokio-chrome-accent-bg-light) 88%, #ffffff);
+        background: color-mix(in srgb, var(--pinokio-chrome-accent-bg-light) 88%, #ffffff);
       }
       body.dark .pinokio-draft-button {
-        border-color: rgba(148, 163, 184, 0.28);
-        background: rgba(30, 41, 59, 0.92);
-        color: #f8fafc;
+        border-color: #fbbf24;
+        background: #fbbf24;
+        color: var(--universal-launcher-surface-solid, #0a0a0b);
       }
       body.dark .pinokio-draft-button:hover,
       body.dark .pinokio-draft-button:focus {
-        border-color: rgba(251, 191, 36, 0.56);
-        background: rgba(120, 53, 15, 0.32);
+        border-color: color-mix(in srgb, #fbbf24 90%, #ffffff);
+        background: color-mix(in srgb, #fbbf24 90%, #ffffff);
+        color: var(--universal-launcher-surface-solid, #0a0a0b);
       }
       .pinokio-draft-button.secondary {
+        border-color: rgba(15, 23, 42, 0.14);
         color: #374151;
         background: rgba(255, 255, 255, 0.72);
       }
+      .pinokio-draft-button.secondary:hover,
+      .pinokio-draft-button.secondary:focus {
+        border-color: rgba(15, 23, 42, 0.24);
+        background: rgba(15, 23, 42, 0.04);
+      }
       body.dark .pinokio-draft-button.secondary {
+        border-color: rgba(148, 163, 184, 0.28);
         color: #dbeafe;
         background: transparent;
       }
+      body.dark .pinokio-draft-button.secondary:hover,
+      body.dark .pinokio-draft-button.secondary:focus {
+        border-color: rgba(148, 163, 184, 0.38);
+        background: rgba(255, 255, 255, 0.06);
+      }
       .pinokio-draft-drawer .pinokio-draft-button.secondary {
         border-color: rgba(15, 23, 42, 0.18);
         color: #1f2937;
         background: #ffffff;
       }
+      .pinokio-draft-drawer .pinokio-draft-button.secondary:hover,
+      .pinokio-draft-drawer .pinokio-draft-button.secondary:focus {
+        border-color: rgba(15, 23, 42, 0.28);
+        background: rgba(15, 23, 42, 0.05);
+      }
       body.dark .pinokio-draft-drawer .pinokio-draft-button.secondary {
         border-color: rgba(148, 163, 184, 0.28);
         color: #dbeafe;
         background: transparent;
       }
+      body.dark .pinokio-draft-drawer .pinokio-draft-button.secondary:hover,
+      body.dark .pinokio-draft-drawer .pinokio-draft-button.secondary:focus {
+        border-color: rgba(148, 163, 184, 0.38);
+        background: rgba(255, 255, 255, 0.06);
+      }
       .pinokio-draft-button:disabled {
         cursor: default;
         opacity: 0.68;
@@ -1223,7 +1246,7 @@
     } finally {
       if (button) {
         button.disabled = false;
-        setActionButtonLabel(button, originalText || "Open draft");
+        setActionButtonLabel(button, originalText || "File explorer");
       }
     }
   }
@@ -1361,7 +1384,7 @@
     tabs.appendChild(createDrawerTab("Markdown", "markdown"));
     tabs.appendChild(createDrawerTab("Media", "media"));
     const actions = createElement("div", "pinokio-draft-drawer-actions");
-    const openButton = createActionButton("pinokio-draft-button secondary", "Open draft", "fa-solid fa-folder-open");
+    const openButton = createActionButton("pinokio-draft-button secondary", "File explorer", "fa-solid fa-folder-open");
     openButton.type = "button";
     openButton.addEventListener("click", () => {
       void openDraft(item, openButton);