pinokiod 7.2.12 → 7.2.13

package/Dockerfile

@@ -37,8 +37,6 @@ RUN mkdir -p /app/.pinokio-seed \
     && rm -rf /app/.pinokio-seed/network/system/.git \
     && rm -rf /app/.pinokio-seed/plugin \
     && mkdir -p /app/.pinokio-seed/plugin \
-    && git clone --depth 1 https://github.com/pinokiocomputer/code /app/.pinokio-seed/plugin/code \
-    && rm -rf /app/.pinokio-seed/plugin/code/.git \
     && rm -rf /app/.pinokio-seed/prototype/system \
     && mkdir -p /app/.pinokio-seed/prototype \
     && git clone --depth 1 https://github.com/pinokiocomputer/proto /app/.pinokio-seed/prototype/system \

package/kernel/api/index.js

@@ -29,6 +29,19 @@ class Api {
     this.child_procs = {}
     this.lproxy = new Lproxy()
   }
+  startData(rpc) {
+    if (rpc && rpc.method === "process.wait" && rpc.params && typeof rpc.params === "object" && !Array.isArray(rpc.params)) {
+      let data = rpc
+      if (typeof data.title === "undefined" && typeof rpc.params.title !== "undefined") {
+        data = { ...data, title: rpc.params.title }
+      }
+      if (typeof data.description === "undefined" && typeof rpc.params.description !== "undefined") {
+        data = { ...data, description: rpc.params.description }
+      }
+      return data
+    }
+    return rpc
+  }
   async launcher_path(name) {
     let root_path = this.kernel.path("api", name)
     let primary_path = path.resolve(root_path, "pinokio.js")
@@ -1186,7 +1199,7 @@ class Api {
           this.ondata({
             id: request.id || request.path,
             type: "start",
-            data: rpc
+            data: this.startData(rpc)
           })
 
           // DEPRECATED APIS

package/kernel/api/process/index.js

@@ -34,6 +34,16 @@ class Process {
   constructor() {
     this.appApi = new AppAPI()
   }
+  async waitIndefinitely(req, kernel) {
+    await new Promise((resolve, reject) => {
+      this.resolve = resolve
+
+      // register the process with the root uri so it can be manually resolved (with this.resolve()) later
+      if (kernel && kernel.procs && req && req.parent && req.parent.path) {
+        kernel.procs[req.parent.path] = this
+      }
+    })
+  }
 //  async start(req, ondata, kernel) {
 //    /*
 //      req := {
@@ -159,6 +169,8 @@ class Process {
     /*
     params := {
       sec: <SECONDS>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -169,6 +181,8 @@ class Process {
 
     params := {
       min: <MINUTES>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -180,6 +194,8 @@ class Process {
     params := {
       url: <URL>,
       interval: (optional) how often to retry checking (in seconds)
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) the message to display while retrying (default: no message)
     }
 
@@ -198,9 +214,21 @@ class Process {
 
     or
 
+    params := {
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
+    }
+
+    This waits indefinitely until the script is stopped or the wait is manually
+    resolved.
+
+    or
+
 
     params := {
       on: <wait-on condition https://github.com/jeffbski/wait-on>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -212,57 +240,84 @@ class Process {
     if 'cancel' is pressed before the condition is met, stops the script
 
     */
-    let ms 
-    if (req.params) {
-      if (req.params.app || req.params.id || req.params.name) {
-        await this.appApi.waitForAppPresence(req, ondata, kernel)
-        return
+    let ms
+    const waitPath = req && req.parent && req.parent.path
+    if (waitPath && kernel) {
+      if (!kernel.activeProcessWaits) {
+        kernel.activeProcessWaits = {}
       }
-      // Display modal
-      if (req.params.sec || req.params.min) {
-        // Wait
-        if (req.params.sec) {
-          ms = req.params.sec * 1000
-        } else if (req.params.min) {
-          ms = req.params.min * 60 * 1000
+      kernel.activeProcessWaits[waitPath] = {
+        path: waitPath,
+        params: req.params || {},
+        title: req.params && req.params.title,
+        description: req.params && req.params.description,
+        message: req.params && req.params.message,
+        started: Date.now()
+      }
+    }
+    const showFooter = req.params && (req.params.title || req.params.description)
+    if (showFooter && typeof ondata === "function") {
+      ondata(req.params, "process.wait.start")
+    }
+    try {
+      if (req.params) {
+        if (req.params.app || req.params.id || req.params.name) {
+          await this.appApi.waitForAppPresence(req, ondata, kernel)
+          return
         }
-        await new Promise((resolve, reject) => {
-          this.resolve = resolve
+        // Display modal
+        if (req.params.sec || req.params.min) {
+          // Wait
+          if (req.params.sec) {
+            ms = req.params.sec * 1000
+          } else if (req.params.min) {
+            ms = req.params.min * 60 * 1000
+          }
+          await new Promise((resolve, reject) => {
+            this.resolve = resolve
 
-          // register the process with the root uri so it can be manually resolved (with this.resolve()) later
-          kernel.procs[req.parent.path] = this
+            // register the process with the root uri so it can be manually resolved (with this.resolve()) later
+            kernel.procs[req.parent.path] = this
 
-          setTimeout(() => {
-            this.resolve()
-          }, ms)
-        })
-      } else if (req.params.uri) {
-        let interval = req.params.interval ? req.params.interval * 1000 : 1000
-        ondata(req.params, "loading.start")
-        await waitForUrl(req.params.uri, req.params.message, interval, ondata)
-        ondata(req.params, "loading.end")
-      } else if (req.params.url) {
-        let interval = req.params.interval ? req.params.interval * 1000 : 1000
-        ondata(req.params, "loading.start")
-        await waitForUrl(req.params.url, req.params.message, interval, ondata)
-        ondata(req.params, "loading.end")
-      } else if (req.params.on) {
-        // Wait
-        if (req.params.message) {
-          ondata({
-            raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
+            setTimeout(() => {
+              this.resolve()
+            }, ms)
           })
-          ondata(req.params, "wait")
+        } else if (req.params.uri) {
+          let interval = req.params.interval ? req.params.interval * 1000 : 1000
+          ondata(req.params, "loading.start")
+          await waitForUrl(req.params.uri, req.params.message, interval, ondata)
+          ondata(req.params, "loading.end")
+        } else if (req.params.url) {
+          let interval = req.params.interval ? req.params.interval * 1000 : 1000
+          ondata(req.params, "loading.start")
+          await waitForUrl(req.params.url, req.params.message, interval, ondata)
+          ondata(req.params, "loading.end")
+        } else if (req.params.on) {
+          // Wait
+          if (req.params.message) {
+            ondata({
+              raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
+            })
+            ondata(req.params, "wait")
+          }
+          console.log("Wait", req.params.on)
+          await waitOn(req.params.on)
+          console.log("Wait finished")
+          ondata(req.params, "wait.end")
+        } else {
+          await this.waitIndefinitely(req, kernel)
         }
-        console.log("Wait", req.params.on)
-        await waitOn(req.params.on)
-        console.log("Wait finished")
-        ondata(req.params, "wait.end")
+      } else {
+        await this.waitIndefinitely(req, kernel)
+      }
+    } finally {
+      if (waitPath && kernel && kernel.activeProcessWaits) {
+        delete kernel.activeProcessWaits[waitPath]
+      }
+      if (showFooter && typeof ondata === "function") {
+        ondata(req.params, "process.wait.end")
       }
-    } else {
-      await new Promise((resolve, reject) => {
-        this.resolve = resolve
-      })
     }
   }
 }

package/kernel/api/uri/index.js

@@ -0,0 +1,51 @@
+const Util = require('../../util')
+
+const appendQueryParams = (uri, params) => {
+  if (!params || typeof params !== 'object' || Array.isArray(params)) {
+    return uri
+  }
+
+  const entries = []
+  for (const [key, value] of Object.entries(params)) {
+    const values = Array.isArray(value) ? value : [value]
+    for (const item of values) {
+      if (item === undefined || item === null) {
+        continue
+      }
+      const serialized = typeof item === 'object' ? JSON.stringify(item) : String(item)
+      entries.push(`${encodeURIComponent(key)}=${encodeURIComponent(serialized)}`)
+    }
+  }
+
+  if (entries.length === 0) {
+    return uri
+  }
+
+  const hashIndex = uri.indexOf('#')
+  const base = hashIndex === -1 ? uri : uri.slice(0, hashIndex)
+  const hash = hashIndex === -1 ? '' : uri.slice(hashIndex)
+  const separator = base.includes('?')
+    ? (base.endsWith('?') || base.endsWith('&') ? '' : '&')
+    : '?'
+
+  return `${base}${separator}${entries.join('&')}${hash}`
+}
+
+class URI {
+  build(params = {}) {
+    const uri = typeof params.uri === 'string' ? params.uri.trim() : ''
+    if (!uri) {
+      throw new Error('uri.open requires params.uri')
+    }
+    return appendQueryParams(uri, params.params)
+  }
+
+  async open(req, ondata, kernel) {
+    const uri = this.build(req.params)
+    ondata({ raw: `\r\nopening uri: ${uri}\r\n` })
+    const result = await Util.openURI(uri)
+    return { uri, result }
+  }
+}
+
+module.exports = URI

package/kernel/git.js

@@ -1378,19 +1378,6 @@ class Git {
     const absoluteTarget = path.resolve(targetPath)
     const home = path.resolve(this.kernel.homedir)
     const managedTargets = [
-      {
-        kind: "plugin",
-        root: path.resolve(home, "plugin/code"),
-        matches: (root, target) => target === root || target.startsWith(`${root}${path.sep}`),
-        bootstrap: async () => {
-          await fs.promises.rm(path.resolve(home, "plugin/code"), { recursive: true, force: true })
-          this.dirs.delete(path.resolve(home, "plugin/code"))
-          if (this.kernel.plugin && typeof this.kernel.plugin.init === "function") {
-            await this.kernel.plugin.init()
-          }
-        },
-        exists: async () => this.kernel.exists("plugin/code")
-      },
       {
         kind: "prototype",
         root: path.resolve(home, "prototype/system"),

package/kernel/index.js

@@ -415,6 +415,9 @@ class Kernel {
   path(...args) {
     return path.resolve(this.homedir, ...args)
   }
+  systemPath(...args) {
+    return path.resolve(__dirname, "..", "system", ...args)
+  }
   exists(...args) {
     if (args) {
       let abspath = this.path(...args)
@@ -1060,6 +1063,7 @@ class Kernel {
       args: {},
     }
     this.procs = {}
+    this.activeProcessWaits = {}
     this.template = new Template()
     try {
       if (this.homedir) {

package/kernel/plugin.js

@@ -1,39 +1,14 @@
-const path = require('path')
-const { glob } = require('glob')
-const Info = require("./info")
+const fs = require('fs')
+const PluginSources = require("./plugin_sources")
+
 class Plugin {
   constructor(kernel) {
     this.kernel = kernel
   }
   async setConfig() {
-    let plugin_dir = path.resolve(this.kernel.homedir, "plugin")
     this.cache = {}
 
-    let plugin_paths = await glob('**/pinokio.js', { cwd: plugin_dir })
-
-    let plugins = []
-    for(let plugin_path of plugin_paths) {
-      let config = await this.kernel.require(path.resolve(plugin_dir, plugin_path))
-      if (config && config.run && Array.isArray(config.run)) {
-        let invalid
-        for(let key in config) {
-          if (typeof config[key] === "function") {
-            invalid = true
-          }
-        }
-        if (invalid) {
-          continue
-        }
-
-        let chunks = plugin_path.split(path.sep)
-        let cwd = chunks.slice(0, -1).join("/")
-        config.image = "/asset/plugin/" + cwd + "/" + config.icon 
-        plugins.push({
-          href: "/run/plugin/" + chunks.join("/"),
-          ...config
-        })
-      }
-    }
+    const plugins = await PluginSources.loadPluginMenu(this.kernel)
 
     this.config = {
       menu: plugins.map((plugin) => {
@@ -48,37 +23,10 @@ class Plugin {
     if (!exists) {
       await fs.promises.mkdir(this.kernel.path("plugin"), { recursive: true }).catch((e) => {})
     }
-    let code_exists = await this.kernel.exists("plugin/code")
-    console.log({ code_exists })
-    if (!code_exists) {
-      if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-        await this.kernel.exec({
-          //message: "git clone https://github.com/peanutcocktail/plugin",
-          //message: "git clone https://github.com/pinokiocomputer/plugin",
-          message: "git clone https://github.com/pinokiocomputer/code",
-          path: this.kernel.path("plugin")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-        await this.setConfig()
-        return
-      }
-    } else {
-      await this.setConfig()
-    }
+    await this.setConfig()
   }
   async update() {
-    if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-      let exists = await this.kernel.exists("plugin")
-      if (!exists) {
-        await this.kernel.exec({
-          message: "git pull",
-          path: this.kernel.path("plugin")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-      }
-    }
+    await this.setConfig()
   }
 }
 module.exports = Plugin

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,
+}