pinokiod 7.2.18 → 7.3.0

package/kernel/plugin_sources.js

@@ -1,289 +0,0 @@
-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 ACTION_KEYS = new Set(["run", "install", "uninstall", "update"])
-
-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 isAction = (value) => Array.isArray(value) || typeof value === "function"
-const hasActionFunction = (config, key) => ACTION_KEYS.has(key) && typeof config[key] === "function"
-const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value)
-const declaredPluginPath = (config) => typeof config.path === "string" ? config.path.trim() : ""
-const hasInvalidTopLevelFunction = (config) => {
-  return Object.keys(config).some((key) => typeof config[key] === "function" && !hasActionFunction(config, key))
-}
-const hasInvalidAction = (config) => {
-  return Array.from(ACTION_KEYS).some((key) => key in config && !isAction(config[key]))
-}
-const isValidPluginConfig = (config, options = {}) => {
-  if (!isPlainObject(config) || !isAction(config.run)) {
-    return false
-  }
-  if (hasInvalidTopLevelFunction(config) || hasInvalidAction(config)) {
-    return false
-  }
-  if (options.standalone && declaredPluginPath(config) !== "plugin") {
-    return false
-  }
-  return true
-}
-
-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 resolveLauncherPluginSelection = (toolValue) => {
-  const href = resolveLauncherPluginHref(toolValue)
-  if (href.startsWith(`${LOCAL_RUN_PREFIX}/`)) {
-    return href.slice(LOCAL_RUN_PREFIX.length)
-  }
-  return href
-}
-
-const normalizeLauncherSuccessPlugin = (successUrl, toolValue) => {
-  if (typeof successUrl !== "string" || typeof toolValue !== "string" || !toolValue.trim()) {
-    return successUrl
-  }
-
-  try {
-    const parsed = new URL(successUrl, "http://localhost")
-    if (!parsed.searchParams.has("plugin")) {
-      return successUrl
-    }
-    parsed.searchParams.set("plugin", resolveLauncherPluginSelection(toolValue))
-    return `${parsed.pathname}${parsed.search}${parsed.hash}`
-  } catch (_) {
-    return successUrl
-  }
-}
-
-const loadPluginsFromRoot = async ({ kernel, root, runPrefix, assetPrefix, source, ignore = [], standalone = false }) => {
-  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 (!isValidPluginConfig(config, { standalone })) 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/**"],
-    standalone: true,
-  })
-  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,
-  resolveLauncherPluginSelection,
-  normalizeLauncherSuccessPlugin,
-  loadPluginMenu,
-  ACTION_KEYS,
-  isAction,
-  isValidPluginConfig,
-}

package/kernel/watch/context.js

@@ -1,42 +0,0 @@
-const path = require("path")
-const { watchFs } = require("./drivers/fs")
-const { poll } = require("./drivers/poll")
-
-class WatchContext {
-  constructor(options = {}) {
-    this.kernel = options.kernel
-    this.manager = options.manager
-    this.id = options.id
-    this.cwd = path.resolve(options.cwd)
-    this.dirname = path.resolve(options.dirname || options.cwd)
-    this.request = options.request
-    this.script = options.script
-    this.declaration = options.declaration
-    this.input = options.input || {}
-    this.args = options.args || this.input
-    this.watch = {
-      fs: (targetPath, callback, watchOptions = {}) => {
-        return watchFs(this.resolve(targetPath), callback, {
-          ...watchOptions,
-          onError: watchOptions.onError || ((error) => {
-            console.warn("[watch.fs]", error && error.message ? error.message : error)
-          })
-        })
-      }
-    }
-  }
-
-  resolve(targetPath) {
-    return this.kernel.api.resolvePath(this.cwd, String(targetPath || "."))
-  }
-
-  resolveModule(targetPath) {
-    return this.kernel.api.resolvePath(this.dirname, String(targetPath || "."))
-  }
-
-  poll(interval, callback, options = {}) {
-    return poll(interval, callback, options)
-  }
-}
-
-module.exports = WatchContext

package/kernel/watch/drivers/fs.js

@@ -1,71 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const ParcelWatcher = require("@parcel/watcher")
-
-const DEFAULT_IGNORE = [
-  "**/.git/**",
-  "**/node_modules/**",
-  "**/__pycache__/**",
-  "**/.venv/**",
-  "**/venv/**",
-  "**/env/**"
-]
-
-function isInside(candidate, parent) {
-  const relative = path.relative(parent, candidate)
-  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
-}
-
-async function nearestExistingDirectory(targetPath) {
-  let current = path.resolve(targetPath)
-  while (current && current !== path.dirname(current)) {
-    const stats = await fs.promises.stat(current).catch(() => null)
-    if (stats && stats.isDirectory()) {
-      return current
-    }
-    current = path.dirname(current)
-  }
-  return current || path.parse(path.resolve(targetPath)).root
-}
-
-async function watchFs(targetPath, callback, options = {}) {
-  const resolvedTarget = path.resolve(targetPath)
-  const targetStats = await fs.promises.stat(resolvedTarget).catch(() => null)
-  const watchRoot = targetStats && targetStats.isDirectory()
-    ? resolvedTarget
-    : await nearestExistingDirectory(resolvedTarget)
-  const filterToTarget = watchRoot !== resolvedTarget
-
-  const subscription = await ParcelWatcher.subscribe(
-    watchRoot,
-    (error, events) => {
-      if (error) {
-        if (typeof options.onError === "function") {
-          options.onError(error)
-        }
-        return
-      }
-      const normalizedEvents = Array.isArray(events) ? events : []
-      const filteredEvents = filterToTarget
-        ? normalizedEvents.filter((event) => event && event.path && isInside(path.resolve(event.path), resolvedTarget))
-        : normalizedEvents
-      if (filteredEvents.length === 0) {
-        return
-      }
-      callback(filteredEvents)
-    },
-    {
-      ignore: Array.isArray(options.ignore) ? options.ignore : DEFAULT_IGNORE
-    }
-  )
-
-  return async () => {
-    if (subscription && typeof subscription.unsubscribe === "function") {
-      await subscription.unsubscribe().catch(() => {})
-    }
-  }
-}
-
-module.exports = {
-  watchFs
-}

package/kernel/watch/drivers/poll.js

@@ -1,33 +0,0 @@
-function poll(interval, callback, options = {}) {
-  const delay = Math.max(100, Number(interval || options.interval || 1000))
-  let stopped = false
-  let running = false
-
-  const tick = async () => {
-    if (stopped || running) return
-    running = true
-    try {
-      await callback()
-    } catch (error) {
-      if (typeof options.onError === "function") {
-        options.onError(error)
-      }
-    } finally {
-      running = false
-    }
-  }
-
-  if (options.immediate !== false) {
-    setTimeout(tick, 0)
-  }
-  const timer = setInterval(tick, delay)
-
-  return async () => {
-    stopped = true
-    clearInterval(timer)
-  }
-}
-
-module.exports = {
-  poll
-}

package/kernel/watch/index.js

@@ -1,185 +0,0 @@
-const path = require("path")
-const WatchContext = require("./context")
-
-class WatchManager {
-  constructor(kernel) {
-    this.kernel = kernel
-    this.handlers = new Map()
-    this.sessions = new Map()
-  }
-
-  registerHandler(name, handler) {
-    const normalized = typeof name === "string" ? name.trim() : ""
-    if (!normalized) {
-      throw new Error("watch handler name is required")
-    }
-    this.handlers.set(normalized, handler)
-  }
-
-  hasHandler(script, handlerName) {
-    const watches = script && Array.isArray(script.watch) ? script.watch : []
-    return watches.some((watch) => {
-      const resolved = this.resolveHandlerMethod(watch)
-      return resolved.handlerName === handlerName
-    })
-  }
-
-  resolveHandlerMethod(declaration) {
-    if (!declaration || typeof declaration !== "object") {
-      return { handlerName: "", methodName: "" }
-    }
-    const method = typeof declaration.method === "string" ? declaration.method.trim() : ""
-    if (declaration.handler) {
-      return {
-        handlerName: String(declaration.handler).trim(),
-        methodName: method
-      }
-    }
-    if (!declaration.uri && method.includes(".")) {
-      const parts = method.split(".")
-      return {
-        handlerName: parts.slice(0, -1).join(".").trim(),
-        methodName: parts[parts.length - 1].trim()
-      }
-    }
-    return {
-      handlerName: "",
-      methodName: method
-    }
-  }
-
-  renderDeclaration(raw, memory) {
-    let rendered = raw
-    let pass = 0
-    while (true) {
-      rendered = this.kernel.template.render(rendered, memory)
-      if (this.kernel.template.istemplate(rendered)) {
-        pass += 1
-        if (pass >= 4) break
-      } else {
-        break
-      }
-    }
-    return this.kernel.template.flatten(rendered)
-  }
-
-  buildMemory({ request, script, cwd, dirname, input, args }) {
-    return {
-      script: this.kernel.script,
-      input,
-      args,
-      cwd,
-      dirname,
-      uri: request.uri,
-      self: script,
-      kernel: this.kernel,
-      ...this.kernel.vars
-    }
-  }
-
-  async resolveExternalHandler(ctx, uri) {
-    const modpath = ctx.resolveModule(uri)
-    const loaded = await this.kernel.loader.load(modpath)
-    let handler = loaded && loaded.resolved
-    if (typeof handler === "function") {
-      handler = new handler()
-    }
-    return handler
-  }
-
-  async startForScript(options = {}) {
-    const script = options.script
-    const declarations = script && Array.isArray(script.watch) ? script.watch : []
-    if (declarations.length === 0) {
-      return
-    }
-
-    const id = options.id
-    if (!id) {
-      return
-    }
-    await this.stop(id)
-
-    const input = options.input || {}
-    const args = options.args || input
-    const cwd = path.resolve(options.cwd)
-    const dirname = path.resolve(options.dirname || options.cwd)
-    const memory = this.buildMemory({
-      request: options.request || {},
-      script,
-      cwd,
-      dirname,
-      input,
-      args
-    })
-    const disposers = []
-
-    for (const rawDeclaration of declarations) {
-      if (!rawDeclaration || typeof rawDeclaration !== "object") {
-        continue
-      }
-      try {
-        const declaration = this.renderDeclaration(rawDeclaration, memory)
-        const ctx = new WatchContext({
-          kernel: this.kernel,
-          manager: this,
-          id,
-          cwd,
-          dirname,
-          request: options.request,
-          script,
-          declaration,
-          input,
-          args
-        })
-        const { handlerName, methodName } = this.resolveHandlerMethod(declaration)
-        let handler = null
-        if (handlerName) {
-          handler = this.handlers.get(handlerName)
-        } else if (declaration.uri) {
-          handler = await this.resolveExternalHandler(ctx, declaration.uri)
-        }
-        if (!handler || !methodName || typeof handler[methodName] !== "function") {
-          console.warn("[watch] handler not found", declaration)
-          continue
-        }
-        const cleanup = await handler[methodName](ctx, declaration.params || {})
-        if (cleanup) {
-          disposers.push(cleanup)
-        }
-      } catch (error) {
-        console.warn("[watch] failed to start", error && error.message ? error.message : error)
-      }
-    }
-
-    if (disposers.length > 0) {
-      this.sessions.set(id, disposers)
-    }
-  }
-
-  async stop(id) {
-    const normalized = typeof id === "string" ? id : ""
-    if (!normalized || !this.sessions.has(normalized)) {
-      return
-    }
-    const disposers = this.sessions.get(normalized) || []
-    this.sessions.delete(normalized)
-    for (const disposer of disposers.reverse()) {
-      try {
-        if (typeof disposer === "function") {
-          await disposer()
-        } else if (disposer && typeof disposer.stop === "function") {
-          await disposer.stop()
-        } else if (disposer && typeof disposer.dispose === "function") {
-          await disposer.dispose()
-        } else if (disposer && typeof disposer.unsubscribe === "function") {
-          await disposer.unsubscribe()
-        }
-      } catch (error) {
-        console.warn("[watch] cleanup failed", error && error.message ? error.message : error)
-      }
-    }
-  }
-}
-
-module.exports = WatchManager

package/server/features/index.js

@@ -1,13 +0,0 @@
-const { createNoteFeature } = require("./notes")
-
-async function mountFeatures(options = {}) {
-  const notes = createNoteFeature(options)
-  await notes.start()
-  return {
-    notes
-  }
-}
-
-module.exports = {
-  mountFeatures
-}

package/server/features/notes/index.js

@@ -1,41 +0,0 @@
-const { createNoteService } = require("./service")
-const registerNoteRoutes = require("./routes")
-const NoteWatcher = require("./watcher")
-
-function createNoteFeature(options = {}) {
-  const { app, kernel } = options
-  if (!app) {
-    throw new Error("app is required")
-  }
-  if (!kernel) {
-    throw new Error("kernel is required")
-  }
-
-  const service = createNoteService({
-    kernel,
-    taskWorkspaceLinks: options.taskWorkspaceLinks
-  })
-
-  registerNoteRoutes(app, {
-    ...options,
-    notes: service
-  })
-
-  if (kernel.watch && typeof kernel.watch.registerHandler === "function") {
-    kernel.watch.registerHandler("note", new NoteWatcher({ notes: service }))
-  }
-
-  return {
-    service,
-    async start() {
-      await service.start()
-    },
-    async stop() {
-      await service.stop()
-    }
-  }
-}
-
-module.exports = {
-  createNoteFeature
-}