pinokiod 7.2.16 → 7.2.18

package/server/features/notes/service.js

@@ -0,0 +1,326 @@
+const fs = require("fs")
+const path = require("path")
+const crypto = require("crypto")
+const {
+  RESULT_RELATIVE_DIR,
+  NOTE_FILENAME,
+  METADATA_FILENAME,
+  buildExcerpt,
+  describeMediaRefs,
+  extractTitle,
+  parseNoteMetadata
+} = require("./parser")
+
+const MAX_MARKDOWN_BYTES = 5 * 1024 * 1024
+
+function createHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 24)
+}
+
+function clonePlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null
+  }
+  try {
+    return JSON.parse(JSON.stringify(value))
+  } catch (_) {
+    return null
+  }
+}
+
+function normalizeRelativePath(value, fallback) {
+  const raw = String(value || fallback || "").trim().replace(/\\/g, "/")
+  if (raw.startsWith("/") || /^[a-zA-Z]:/.test(raw)) {
+    return fallback
+  }
+  const normalized = path.posix.normalize(raw)
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+    return fallback
+  }
+  return normalized
+}
+
+function isInside(candidate, parent) {
+  const relative = path.relative(path.resolve(parent), path.resolve(candidate))
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+function normalizeNoteConfig(config = {}) {
+  const params = config && typeof config === "object" ? config : {}
+  return {
+    path: normalizeRelativePath(params.path, RESULT_RELATIVE_DIR),
+    content: normalizeRelativePath(params.content, ""),
+    ready: normalizeRelativePath(params.ready, METADATA_FILENAME),
+    description: typeof params.description === "string" ? params.description.trim() : "",
+    publish: clonePlainObject(params.publish)
+  }
+}
+
+async function findMetadataFiles(rootDir, filename) {
+  const root = path.resolve(rootDir)
+  const stats = await fs.promises.stat(root).catch(() => null)
+  if (!stats || !stats.isDirectory()) {
+    return []
+  }
+  const target = String(filename || METADATA_FILENAME)
+  const results = []
+  const visit = async (dir) => {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true }).catch(() => null)
+    if (!entries) return
+    for (const entry of entries) {
+      const fullPath = path.resolve(dir, entry.name)
+      if (entry.isDirectory()) {
+        await visit(fullPath)
+      } else if (entry.isFile() && entry.name === target) {
+        results.push(fullPath)
+      }
+    }
+  }
+  await visit(root)
+  return results
+}
+
+function createNoteService({ kernel, taskWorkspaceLinks } = {}) {
+  if (!kernel) {
+    throw new Error("kernel is required")
+  }
+
+  const resultsByBundle = new Map()
+
+  async function readMarkdown(notePath, stats) {
+    const noteStats = stats || await fs.promises.stat(notePath)
+    if (noteStats.size > MAX_MARKDOWN_BYTES) {
+      throw new Error(`note markdown is too large (${noteStats.size} bytes)`)
+    }
+    return fs.promises.readFile(notePath, "utf8")
+  }
+
+  async function readNoteMetadata(metadataPath) {
+    if (path.extname(metadataPath).toLowerCase() !== ".json") {
+      return {}
+    }
+    const raw = await fs.promises.readFile(metadataPath, "utf8")
+    return parseNoteMetadata(raw)
+  }
+
+  async function inspectNoteBundle({ taskId, ref, cwd, note, bundlePath, metadataPath } = {}) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null
+    }
+    const workspacePath = path.resolve(cwd.trim())
+    const noteConfig = normalizeNoteConfig(note)
+    const rootDir = path.resolve(workspacePath, noteConfig.path)
+    const resultDir = path.resolve(bundlePath || rootDir)
+    const readyPath = path.resolve(metadataPath || path.resolve(resultDir, noteConfig.ready))
+    const readyStats = await fs.promises.stat(readyPath).catch(() => null)
+    if (!readyStats || !readyStats.isFile()) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+    let metadata = {}
+    try {
+      metadata = await readNoteMetadata(readyPath)
+    } catch (_) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+
+    const contentPath = normalizeRelativePath(metadata.content || noteConfig.content, NOTE_FILENAME)
+    const notePath = path.resolve(resultDir, contentPath)
+    const noteStats = await fs.promises.stat(notePath).catch(() => null)
+    if (!noteStats || !noteStats.isFile()) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+
+    const markdown = await readMarkdown(notePath, noteStats)
+    const workspaceName = path.basename(workspacePath)
+    const bundleName = path.basename(resultDir)
+    const media = await describeMediaRefs(markdown, resultDir)
+    const updatedAtMs = Math.max(readyStats.mtimeMs || 0, noteStats.mtimeMs || 0)
+    const id = createHash(`${workspacePath}|${resultDir}|${notePath}|${readyPath}`)
+    const previous = resultsByBundle.get(resultDir) || null
+    const publish = noteConfig.publish || (previous && previous.publish) || null
+    const description = noteConfig.description || (previous && previous.description) || ""
+    const mediaRevision = media
+      .map((item) => `${item.ref}:${item.exists ? item.bytes : "missing"}:${item.mtimeMs || 0}`)
+      .join("|")
+    const revision = createHash(`${noteStats.size}|${noteStats.mtimeMs}|${readyStats.size}|${readyStats.mtimeMs}|${mediaRevision}`)
+    const result = {
+      id,
+      revision,
+      taskId,
+      ref,
+      cwd: workspacePath,
+      workspaceName,
+      bundleName,
+      title: metadata.title || extractTitle(markdown, bundleName || workspaceName),
+      markdown,
+      excerpt: buildExcerpt(markdown),
+      resultDir,
+      watchRoot: rootDir,
+      notePath,
+      contentPath: notePath,
+      readyPath,
+      metadataPath: readyPath,
+      metadata,
+      publish,
+      description,
+      noteBytes: noteStats.size,
+      media: media.map((item, index) => ({
+        index,
+        ref: item.ref,
+        path: item.path,
+        bytes: item.bytes,
+        mtimeMs: item.mtimeMs,
+        exists: item.exists,
+        ext: path.extname(item.ref || "").toLowerCase()
+      })),
+      mediaCount: media.length,
+      missingMediaCount: media.filter((item) => !item.exists).length,
+      mediaBytes: media.reduce((total, item) => total + (Number.isFinite(item.bytes) ? item.bytes : 0), 0),
+      updatedAt: new Date(updatedAtMs || Date.now()).toISOString()
+    }
+    resultsByBundle.set(resultDir, result)
+    return result
+  }
+
+  async function inspectWorkspace({ taskId, ref, cwd, note } = {}) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null
+    }
+    const workspacePath = path.resolve(cwd.trim())
+    const noteConfig = normalizeNoteConfig(note)
+    const rootDir = path.resolve(workspacePath, noteConfig.path)
+    const metadataFiles = await findMetadataFiles(rootDir, noteConfig.ready)
+    const seen = new Set()
+    const results = []
+    for (const metadataPath of metadataFiles) {
+      const bundlePath = path.dirname(metadataPath)
+      const result = await inspectNoteBundle({
+        taskId,
+        ref,
+        cwd: workspacePath,
+        note: noteConfig,
+        bundlePath,
+        metadataPath
+      })
+      if (result) {
+        seen.add(result.resultDir)
+        results.push(result)
+      }
+    }
+    for (const [bundlePath, result] of Array.from(resultsByBundle.entries())) {
+      if (result && result.cwd === workspacePath && result.watchRoot === rootDir && !seen.has(bundlePath)) {
+        resultsByBundle.delete(bundlePath)
+      }
+    }
+    return results[0] || null
+  }
+
+  async function trackWorkspace({ taskId, ref, cwd } = {}) {
+    let resolvedCwd = cwd
+    if (!resolvedCwd && ref && taskWorkspaceLinks && typeof taskWorkspaceLinks.resolveWorkspaceRef === "function") {
+      resolvedCwd = taskWorkspaceLinks.resolveWorkspaceRef(ref)
+    }
+    if (!resolvedCwd) {
+      return null
+    }
+    return inspectWorkspace({ taskId, ref, cwd: resolvedCwd })
+  }
+
+  async function listPending(options = {}) {
+    const filterCwd = typeof options.cwd === "string" && options.cwd.trim()
+      ? path.resolve(options.cwd.trim())
+      : ""
+    return Array.from(resultsByBundle.values())
+      .filter((result) => !filterCwd || result.cwd === filterCwd)
+      .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+  }
+
+  async function getPendingById(id) {
+    const normalizedId = typeof id === "string" ? id.trim() : ""
+    if (!normalizedId) {
+      return null
+    }
+    return Array.from(resultsByBundle.values()).find((item) => item.id === normalizedId) || null
+  }
+
+  async function refreshPendingItem(item) {
+    if (!item || !item.cwd || !item.resultDir || !item.metadataPath) {
+      return null
+    }
+    return inspectNoteBundle({
+      taskId: item.taskId,
+      ref: item.ref,
+      cwd: item.cwd,
+      note: {
+        description: item.description,
+        publish: item.publish
+      },
+      bundlePath: item.resultDir,
+      metadataPath: item.metadataPath
+    })
+  }
+
+  async function savePendingById(id, options = {}) {
+    const item = await getPendingById(id)
+    if (!item) {
+      return null
+    }
+    const markdown = typeof options.markdown === "string" ? options.markdown : null
+    if (markdown === null) {
+      throw new Error("markdown is required")
+    }
+    if (Buffer.byteLength(markdown, "utf8") > MAX_MARKDOWN_BYTES) {
+      const error = new Error(`note markdown is too large; limit is ${MAX_MARKDOWN_BYTES} bytes`)
+      error.code = "NOTE_TOO_LARGE"
+      throw error
+    }
+
+    const current = await refreshPendingItem(item)
+    if (!current) {
+      return null
+    }
+    const expectedRevision = typeof options.revision === "string" ? options.revision.trim() : ""
+    if (expectedRevision && current.revision !== expectedRevision) {
+      const error = new Error("Note changed on disk. Reload it before saving.")
+      error.code = "NOTE_CONFLICT"
+      error.item = current
+      throw error
+    }
+
+    const notePath = path.resolve(current.notePath)
+    const resultDir = path.resolve(current.resultDir)
+    if (!isInside(notePath, resultDir)) {
+      const error = new Error("Note path is outside the note folder")
+      error.code = "NOTE_INVALID_PATH"
+      throw error
+    }
+
+    await fs.promises.writeFile(notePath, markdown, "utf8")
+    return refreshPendingItem(current)
+  }
+
+  async function start() {
+  }
+
+  async function stop() {
+  }
+
+  return {
+    RESULT_RELATIVE_DIR,
+    getPendingById,
+    inspectNoteBundle,
+    inspectWorkspace,
+    listPending,
+    savePendingById,
+    start,
+    stop,
+    trackWorkspace
+  }
+}
+
+module.exports = {
+  createNoteService
+}

package/server/features/{drafts → notes}/watcher.js

@@ -5,21 +5,19 @@ function isInside(candidate, parent) {
   return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
 }
 
-class DraftWatcher {
+class NoteWatcher {
   constructor(options = {}) {
-    this.drafts = options.drafts
+    this.notes = options.notes
   }
 
-  async ready(ctx, params = {}) {
-    if (!this.drafts || typeof this.drafts.inspectWorkspace !== "function") {
-      throw new Error("draft service is unavailable")
+  async watch(ctx, params = {}) {
+    if (!this.notes || typeof this.notes.inspectWorkspace !== "function") {
+      throw new Error("note service is unavailable")
     }
 
-    const draftDir = ctx.resolve(params.path || ".pinokio/draft")
-    const draftConfig = {
-      path: params.path || ".pinokio/draft",
-      content: params.content,
-      ready: params.ready,
+    const noteDir = ctx.resolve(params.path || ".pinokio/notes")
+    const noteConfig = {
+      path: params.path || ".pinokio/notes",
       description: params.description,
       publish: params.publish
     }
@@ -28,7 +26,7 @@ class DraftWatcher {
 
     const inspect = async () => {
       if (disposed) return
-      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig })
+      await this.notes.inspectWorkspace({ cwd: ctx.cwd, note: noteConfig })
     }
 
     const scheduleInspect = () => {
@@ -37,7 +35,7 @@ class DraftWatcher {
       timer = setTimeout(() => {
         timer = null
         inspect().catch((error) => {
-          console.warn("[drafts] failed to inspect workspace", error && error.message ? error.message : error)
+          console.warn("[notes] failed to inspect workspace", error && error.message ? error.message : error)
         })
       }, 250)
     }
@@ -46,12 +44,12 @@ class DraftWatcher {
     const stopPoll = ctx.poll(params.interval || 1500, inspect, {
       immediate: false,
       onError: (error) => {
-        console.warn("[drafts] poll failed", error && error.message ? error.message : error)
+        console.warn("[notes] poll failed", error && error.message ? error.message : error)
       }
     })
     const unsubscribe = await ctx.watch.fs(ctx.cwd, (events) => {
       if (!Array.isArray(events)) return
-      if (events.some((event) => event && event.path && isInside(path.resolve(event.path), draftDir))) {
+      if (events.some((event) => event && event.path && isInside(path.resolve(event.path), noteDir))) {
         scheduleInspect()
       }
     })
@@ -61,7 +59,7 @@ class DraftWatcher {
         clearTimeout(timer)
         timer = null
       }
-      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig }).catch(() => {})
+      await this.notes.inspectWorkspace({ cwd: ctx.cwd, note: noteConfig }).catch(() => {})
       disposed = true
       if (typeof stopPoll === "function") {
         await stopPoll()
@@ -73,4 +71,4 @@ class DraftWatcher {
   }
 }
 
-module.exports = DraftWatcher
+module.exports = NoteWatcher

package/server/index.js

@@ -2758,10 +2758,12 @@ class Server {
           } else {
             resolved = runner(this.kernel, this.kernel.info)
           }
-          runnable = resolved && Array.isArray(resolved[actionKey]) && resolved[actionKey].length > 0
+          const action = resolved ? resolved[actionKey] : null
+          runnable = typeof action === "function" || (Array.isArray(action) && action.length > 0)
         } else {
-          runnable = runner && Array.isArray(runner[actionKey]) && runner[actionKey].length > 0
           resolved = runner
+          const action = resolved ? resolved[actionKey] : null
+          runnable = typeof action === "function" || (Array.isArray(action) && action.length > 0)
         }
 
         let template = "terminal"
@@ -2870,10 +2872,10 @@ class Server {
           const protectionPreference = protectionAppId && this.appPreferences && typeof this.appPreferences.getPreference === "function"
             ? await this.appPreferences.getPreference(protectionAppId)
             : null
-          const draftWatchEnabled = this.kernel.watch && typeof this.kernel.watch.hasHandler === "function"
-            ? this.kernel.watch.hasHandler(resolved, "draft")
+          const noteWatchEnabled = this.kernel.watch && typeof this.kernel.watch.hasHandler === "function"
+            ? this.kernel.watch.hasHandler(resolved, "note")
             : false
-          const draftWatchCwd = draftWatchEnabled
+          const noteWatchCwd = noteWatchEnabled
             ? (req.query.cwd || path.dirname(filepath))
             : ""
           const activeProcessWait = this.kernel.activeProcessWaits && this.kernel.activeProcessWaits[filepath]
@@ -2884,8 +2886,8 @@ class Server {
             projectName: (pathComponents.length > 0 ? pathComponents[0] : ''),
             protection_app_id: protectionAppId,
             protection_enabled: protectionPreference ? protectionPreference.protection_enabled !== false : false,
-            draft_watch_enabled: draftWatchEnabled,
-            draft_watch_cwd: draftWatchCwd,
+            note_watch_enabled: noteWatchEnabled,
+            note_watch_cwd: noteWatchCwd,
             active_process_wait: activeProcessWait ? {
               title: activeProcessWait.title,
               description: activeProcessWait.description,
@@ -5311,15 +5313,7 @@ class Server {
     return normalized
   }
   isValidBundledPluginConfig(pluginConfig) {
-    if (!pluginConfig || !Array.isArray(pluginConfig.run)) {
-      return false
-    }
-    for (const key of Object.keys(pluginConfig)) {
-      if (typeof pluginConfig[key] === "function") {
-        return false
-      }
-    }
-    return true
+    return PluginSources.isValidPluginConfig(pluginConfig)
   }
   isPathInsideRootForBundledPlugin(candidatePath, rootPath) {
     const relative = path.relative(rootPath, candidatePath)
@@ -6857,9 +6851,9 @@ class Server {
             cwd: typeof pluginItem.ownerApp.cwd === "string" ? pluginItem.ownerApp.cwd : "",
           }
           : null,
-        hasInstall: Array.isArray(pluginItem?.install),
-        hasUninstall: Array.isArray(pluginItem?.uninstall),
-        hasUpdate: Array.isArray(pluginItem?.update),
+        hasInstall: PluginSources.isAction(pluginItem?.install),
+        hasUninstall: PluginSources.isAction(pluginItem?.uninstall),
+        hasUpdate: PluginSources.isAction(pluginItem?.update),
         category,
         categoryTitle: category === "ide" ? "Desktop Plugin" : "Terminal Plugin",
         categorySubtitle: category === "ide" ? "Launch externally" : "Launch in Pinokio",
@@ -8415,12 +8409,12 @@ class Server {
       defaultRegistryUrl: DEFAULT_REGISTRY_URL
     })
     this.features = features
-    const drafts = features.drafts.service
-    this.drafts = drafts
+    const notes = features.notes.service
+    this.notes = notes
     const workspaceCatalog = createWorkspaceCatalogService({
       kernel: this.kernel,
       workspaceRuntime,
-      drafts
+      notes
     })
     registerWorkspacesRoutes(this.app, {
       workspaceCatalog,
@@ -9744,6 +9738,13 @@ class Server {
       })
     }))
 
+    this.app.get("/tasker", ex(async (req, res) => {
+      res.render("tasker", {
+        theme: this.theme,
+        agent: req.agent,
+      })
+    }))
+
     this.app.get("/tasks/new", ex(async (req, res) => {
       const sourceWorkspace = normalizeTaskBuilderSourceWorkspace(req.query.sourceWorkspaceCwd)
       const lockTargetSelection = req.query.lockTarget === "1" || req.query.lockTarget === "true"
@@ -13415,9 +13416,21 @@ class Server {
 //      }
 //    }))
     this.app.post("/env", ex(async (req, res) => {
-      let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
+      const requestFilepath = typeof req.body.filepath === "string" ? req.body.filepath : ""
+      const requestRoot = path.resolve(this.kernel.homedir, requestFilepath)
+      let fullpath = path.resolve(requestRoot, "ENVIRONMENT")
+      if (!(await this.kernel.exists(fullpath))) {
+        const normalizedFilepath = requestFilepath.replace(/\\/g, "/")
+        const filepathParts = normalizedFilepath.split("/").filter(Boolean)
+        if (filepathParts[0] === "api" && filepathParts[1] && filepathParts.length === 2) {
+          const launcher = await this.kernel.api.launcher(filepathParts[1])
+          if (launcher && launcher.launcher_root) {
+            fullpath = path.resolve(launcher.root, launcher.launcher_root, "ENVIRONMENT")
+          }
+        }
+      }
       let updated = req.body.vals
-      let hosts = req.body.hosts
+      let hosts = req.body.hosts || {}
       await Util.update_env(fullpath, updated)
       const normalizedFilepath = typeof req.body.filepath === "string"
         ? req.body.filepath.replace(/\\/g, "/")
@@ -13570,14 +13583,15 @@ class Server {
     this.app.get("/pre/api/:name", ex(async (req, res) => {
       let launcher = await this.kernel.api.launcher(req.params.name)
       let config = launcher.script
-      if (config && config.pre) {
-        config.pre.forEach((item) => {
-          if (item.icon) {
+      if (config && Array.isArray(config.pre)) {
+        const items = config.pre.filter((item) => item && typeof item === "object")
+        items.forEach((item) => {
+          if (typeof item.icon === "string" && item.icon) {
             item.icon = `/api/${req.params.name}/${item.icon}?raw=true`
           } else {
             item.icon = "/pinokio-black.png"
           }
-          if (!item.href.startsWith("http")) {
+          if (typeof item.href === "string" && item.href && !item.href.startsWith("http")) {
             item.href = path.resolve(this.kernel.homedir, "api", req.params.name, item.href)
           }
         })
@@ -13588,7 +13602,7 @@ class Server {
           theme: this.theme,
           agent: req.agent,
           name: req.params.name,
-          items: config.pre,
+          items,
           env
         })
       } else {
@@ -14074,7 +14088,7 @@ class Server {
               mode = "launch_type.desktop"
             } else if (launchType === "terminal") {
               mode = "launch_type.terminal"
-            } else {
+            } else if (Array.isArray(item.run)) {
               for(let step of item.run) {
                 if (step.method === "exec") {
                   mode = "exec" 
@@ -14089,6 +14103,8 @@ class Server {
                   break
                 }
               }
+            } else if (typeof item.run === "function") {
+              mode = "shell"
             }
             if (mode === "launch_type.desktop" || mode === "exec" || mode === "launch") {
               item.type = "Open"
@@ -14141,6 +14157,20 @@ class Server {
         spec = await fs.promises.readFile(path.resolve(filepath, "SPEC.md"), "utf8")
       } catch (e) {
       }
+      const registryEnabled = await this.isRegistryEnabled().catch(() => false)
+      let registry_parent_url = ""
+      if (registryEnabled) {
+        try {
+          registry_parent_url = await git.getConfig({
+            fs,
+            http,
+            dir: filepath,
+            path: "remote.origin.url"
+          }) || ""
+        } catch (_) {
+          registry_parent_url = ""
+        }
+      }
       res.render("d", {
         filepath,
         spec,
@@ -14151,6 +14181,7 @@ class Server {
         install: this.install,
         agent: req.agent,
         theme: this.theme,
+        registry_parent_url,
         //dynamic: plugin_menu
         dynamic,
       })

package/server/lib/content_validation.js

@@ -147,9 +147,9 @@ function createContentValidationService({ kernel }) {
       absolutePath,
       dir: pluginDir,
       config,
-      hasInstall: Array.isArray(config && config.install),
-      hasUpdate: Array.isArray(config && config.update),
-      hasUninstall: Array.isArray(config && config.uninstall),
+      hasInstall: PluginSources.isAction(config && config.install),
+      hasUpdate: PluginSources.isAction(config && config.update),
+      hasUninstall: PluginSources.isAction(config && config.uninstall),
       image: null,
     }
 
@@ -252,21 +252,32 @@ function createContentValidationService({ kernel }) {
         { file: absolutePath }
       ))
     } else {
-      if (!Array.isArray(config.run)) {
+      if (!PluginSources.isAction(config.run)) {
         errors.push(buildError(
-          "Plugins must define a top-level run array.",
-          "Add `run: [...]` to pinokio.js.",
+          "Plugins must define a top-level run array or function.",
+          "Add `run: [...]` or `run: async (ctx) => [...]` to pinokio.js.",
           { file: absolutePath }
         ))
       }
-      const topLevelFunctionKeys = Object.keys(config).filter((key) => typeof config[key] === "function")
+      const topLevelFunctionKeys = Object.keys(config).filter((key) => {
+        return typeof config[key] === "function" && !PluginSources.ACTION_KEYS.has(key)
+      })
       if (topLevelFunctionKeys.length > 0) {
         errors.push(buildError(
           `Top-level function fields are not supported: ${topLevelFunctionKeys.join(", ")}.`,
-          "Move those functions out of pinokio.js or replace them with data.",
+          "Only action fields such as run, install, uninstall, and update may be functions.",
           { file: absolutePath }
         ))
       }
+      for (const key of PluginSources.ACTION_KEYS) {
+        if (key in config && !PluginSources.isAction(config[key])) {
+          errors.push(buildError(
+            `Plugin action ${key} must be an array or function.`,
+            `Set ${key} to an array or async function returning an array.`,
+            { file: absolutePath }
+          ))
+        }
+      }
       if (normalizedPath.startsWith("/plugin/")) {
         const declaredPath = typeof config.path === "string" ? config.path.trim() : ""
         if (declaredPath !== "plugin") {