pinokiod 7.2.16 → 7.2.18

package/kernel/agent_instructions.js

@@ -0,0 +1,166 @@
+const fs = require("fs")
+const path = require("path")
+const PluginSources = require("./plugin_sources")
+
+const NOTES_BEGIN = "<!-- PINOKIO:NOTES:BEGIN -->"
+const NOTES_END = "<!-- PINOKIO:NOTES:END -->"
+const LEGACY_DRAFTS_BEGIN = "<!-- PINOKIO:DRAFTS:BEGIN -->"
+const LEGACY_DRAFTS_END = "<!-- PINOKIO:DRAFTS:END -->"
+
+const AGENT_INSTRUCTION_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  "QWEN.md",
+  ".windsurfrules",
+  ".cursorrules",
+  ".clinerules",
+]
+
+const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+
+const normalizeBlock = (block) => `${String(block || "").trim()}\n`
+
+const extractManagedBlock = (content, begin = NOTES_BEGIN, end = NOTES_END) => {
+  const text = String(content || "")
+  const start = text.indexOf(begin)
+  const finish = text.indexOf(end, start + begin.length)
+  if (start < 0 || finish < 0) {
+    return ""
+  }
+  return text.slice(start, finish + end.length)
+}
+
+const insertionIndex = (content) => {
+  const text = String(content || "")
+  let offset = 0
+
+  if (text.startsWith("---\n")) {
+    const frontmatterEnd = text.indexOf("\n---\n", 4)
+    if (frontmatterEnd >= 0) {
+      offset = frontmatterEnd + "\n---\n".length
+      while (text[offset] === "\n") {
+        offset += 1
+      }
+    }
+  }
+
+  const rest = text.slice(offset)
+  const h1 = rest.match(/^# .*(?:\n|$)/)
+  if (h1) {
+    return offset + h1[0].length
+  }
+
+  return offset
+}
+
+const insertManagedBlock = (content, block) => {
+  const text = String(content || "").replace(/\r\n/g, "\n")
+  const noteBlock = normalizeBlock(block)
+  if (!text.trim()) {
+    return noteBlock
+  }
+
+  const index = insertionIndex(text)
+  const before = text.slice(0, index)
+  const after = text.slice(index).replace(/^\n+/, "")
+  const beforeGap = before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n"
+  const afterGap = after ? "\n" : ""
+
+  return `${before}${beforeGap}${noteBlock}${afterGap}${after}`
+}
+
+const upsertManagedBlock = (content, block, begin = NOTES_BEGIN, end = NOTES_END) => {
+  let text = String(content || "").replace(/\r\n/g, "\n")
+  const noteBlock = normalizeBlock(block)
+  const pattern = new RegExp(`${escapeRegExp(begin)}[\\s\\S]*?${escapeRegExp(end)}\\n?`)
+  const legacyPattern = new RegExp(`${escapeRegExp(LEGACY_DRAFTS_BEGIN)}[\\s\\S]*?${escapeRegExp(LEGACY_DRAFTS_END)}\\n?`)
+
+  if (pattern.test(text)) {
+    return text.replace(pattern, `${noteBlock}\n`)
+  }
+
+  text = text.replace(legacyPattern, "")
+  return insertManagedBlock(text, noteBlock)
+}
+
+const containedBy = (child, parent) => {
+  const relative = path.relative(path.resolve(parent), path.resolve(child))
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+const isPluginScriptPath = (kernel, scriptPath) => {
+  if (!kernel || !scriptPath) {
+    return false
+  }
+
+  const absolutePath = path.resolve(scriptPath)
+  if (containedBy(absolutePath, kernel.path("plugin", "code"))) {
+    return false
+  }
+
+  const roots = [
+    PluginSources.systemPluginRoot(kernel),
+    kernel.path("plugin"),
+  ].filter(Boolean)
+
+  return roots.some((root) => containedBy(absolutePath, root))
+}
+
+const ensureManagedBlockInFile = async (filePath, block) => {
+  let content = ""
+  try {
+    content = await fs.promises.readFile(filePath, "utf8")
+  } catch (e) {
+    if (!e || e.code !== "ENOENT") {
+      throw e
+    }
+  }
+
+  const nextContent = upsertManagedBlock(content, block)
+  if (nextContent !== content) {
+    await fs.promises.writeFile(filePath, nextContent, "utf8")
+    return true
+  }
+
+  return false
+}
+
+const ensureNoteInstructionsForCwd = async ({ kernel, cwd }) => {
+  if (!kernel || !cwd) {
+    return { updated: [], skipped: "missing-cwd" }
+  }
+
+  const targetDir = path.resolve(cwd)
+  const stat = await fs.promises.stat(targetDir).catch(() => null)
+  if (!stat || !stat.isDirectory()) {
+    return { updated: [], skipped: "invalid-cwd" }
+  }
+
+  const sourcePath = kernel.path("prototype", "system", "AGENTS.md")
+  const source = await fs.promises.readFile(sourcePath, "utf8").catch(() => "")
+  const block = extractManagedBlock(source)
+  if (!block) {
+    return { updated: [], skipped: "missing-block" }
+  }
+
+  const updated = []
+  for (const filename of AGENT_INSTRUCTION_FILES) {
+    const filePath = path.join(targetDir, filename)
+    if (await ensureManagedBlockInFile(filePath, block)) {
+      updated.push(filePath)
+    }
+  }
+
+  return { updated, skipped: null }
+}
+
+module.exports = {
+  NOTES_BEGIN,
+  NOTES_END,
+  AGENT_INSTRUCTION_FILES,
+  extractManagedBlock,
+  upsertManagedBlock,
+  isPluginScriptPath,
+  ensureNoteInstructionsForCwd,
+}

package/kernel/api/index.js

@@ -12,6 +12,7 @@ const Loader = require("../loader")
 const Environment = require("../environment")
 const Util = require('../util')
 const ShellRunTemplate = require('./shell_run_template')
+const AgentInstructions = require("../agent_instructions")
 
 class Api {
   constructor(kernel) {
@@ -27,6 +28,7 @@ class Api {
     this.proxies = {}
     this.mods = {}
     this.child_procs = {}
+    this.resolved_actions = {}
     this.lproxy = new Lproxy()
   }
   startData(rpc) {
@@ -233,7 +235,7 @@ class Api {
       meta.ui = `/p/${api_name}`
       meta.browse = `/p/${api_name}/dev`
     } else {
-      meta.icon = meta.icon ? `/asset/api/${api_name}/${meta.icon}` : "/pinokio-black.png"
+      meta.icon = meta.icon ? `/asset/api/${api_name}/${relpath}/${meta.icon}` : "/pinokio-black.png"
       meta.link = `/p/${api_name}/${relpath}/dev#n1`
       meta.web_path = `/api/${api_name}/${relpath}`
       meta.ui = `/p/${api_name}/${relpath}`
@@ -412,6 +414,84 @@ class Api {
     let result = await endpoint(rpc, ondata, this.kernel)
     return result
   }
+  requestId(request) {
+    return request ? (request.id || request.path) : null
+  }
+  clearResolvedAction(requestOrId) {
+    const id = typeof requestOrId === "string" ? requestOrId : this.requestId(requestOrId)
+    if (id) {
+      delete this.resolved_actions[id]
+    }
+  }
+  setRunning(request, done) {
+    const id = this.requestId(request)
+    if (!id) {
+      return
+    }
+    this.running[id] = true
+    this.done[id] = done
+  }
+  isActionCandidate(action) {
+    return (Array.isArray(action) && action.length > 0) || typeof action === "function"
+  }
+  async actionContext({ request, script, scriptDir, actionKey, input, args }) {
+    const cwd = request.cwd || scriptDir
+    const id = this.requestId(request)
+    const env = await Environment.get2(request.path, this.kernel)
+    this.kernel.template.update({ envs: env, env })
+    const port = await this.kernel.port()
+    const name = path.relative(this.kernel.path("api"), scriptDir)
+    return {
+      kernel: this.kernel,
+      info: this.kernel.info,
+      script: this.kernel.script,
+      action: actionKey,
+      input,
+      args,
+      global: (this.kernel.memory.global[id] || {}),
+      local: (this.kernel.memory.local[id] || {}),
+      key: this.kernel.memory.key,
+      uri: request.uri,
+      cwd,
+      dirname: scriptDir,
+      exists: (...args) => {
+        return fs.existsSync(path.resolve(cwd, ...args))
+      },
+      running: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.running[fullpath]
+      },
+      name,
+      self: script,
+      port,
+      env,
+      envs: env,
+      ...this.kernel.vars,
+    }
+  }
+  async resolveActionSteps({ request, script, scriptDir, actionKey, input, args }) {
+    const id = this.requestId(request)
+    const cached = id ? this.resolved_actions[id] : null
+    if (cached && cached.actionKey === actionKey && Array.isArray(cached.steps)) {
+      return cached.steps
+    }
+
+    const action = script ? script[actionKey] : null
+    let steps
+    if (Array.isArray(action)) {
+      steps = action
+    } else if (typeof action === "function") {
+      const context = await this.actionContext({ request, script, scriptDir, actionKey, input, args })
+      steps = await action.call(script, this.kernel, this.kernel.info, context)
+    } else {
+      steps = null
+    }
+
+    if (id && Array.isArray(steps)) {
+      this.resolved_actions[id] = { actionKey, steps }
+    }
+    return steps
+  }
   async stop(req, ondata) {
     // 1. set the "stop" flag for the uri, so the next execution in the queue for the uri will NOT queue another task
     // 2. stream a message closing the socket
@@ -420,10 +500,12 @@ class Api {
       // /Users/x/pinokio/prototype/system/aicode/template/claude.json?cwd=/Users/x/pinokio/api/MMAudio.git
       // take the first part only since the rest is the cwd
       req.params.uri = req.params.id.split("?")[0]
+      this.clearResolvedAction(req.params.id)
     }
 
     // 1. if the scropt has 'on.stop', run it when stopping
     let requestPath = this.filePath(req.params.uri)
+    this.clearResolvedAction(requestPath)
     let { cwd, script } = await this.resolveScript(requestPath)
     if (script.on) {
       if (script.on.stop) {
@@ -910,7 +992,7 @@ class Api {
 
     let { cwd: scriptDir, script } = await this.resolveScript(request.path)
     const actionKey = request.action || 'run'
-    const steps = (script && Array.isArray(script[actionKey])) ? script[actionKey] : []
+    const steps = await this.resolveActionSteps({ request, script, scriptDir, actionKey, input, args }) || []
     const totalSteps = steps.length
 
     let name = path.relative(this.kernel.path("api"), scriptDir)
@@ -1494,6 +1576,22 @@ class Api {
       args: input
     })
   }
+  async ensurePluginAgentInstructions(request) {
+    if (!request || !request.cwd || !request.path) {
+      return
+    }
+    if (!AgentInstructions.isPluginScriptPath(this.kernel, request.path)) {
+      return
+    }
+    try {
+      await AgentInstructions.ensureNoteInstructionsForCwd({
+        kernel: this.kernel,
+        cwd: request.cwd,
+      })
+    } catch (e) {
+      console.warn("[agent-instructions] failed to update note instructions:", e && e.message ? e.message : e)
+    }
+  }
   createQueue(queue_id, concurrency) {
     this.queues[queue_id] = fastq.promise(async ({ request, rawrpc, input, step, total, cwd, args }) => {
       try {
@@ -1711,18 +1809,12 @@ class Api {
         } else {
           const actionKey = request.action || 'run'
           request.action = actionKey
-          const steps = script ? script[actionKey] : null
+          const action = script ? script[actionKey] : null
 
-          // 3. Check if the resolved endpoint has the requested action attribute and it's an array
-          if (Array.isArray(steps) && steps.length > 0) {
+          // 3. Check if the resolved endpoint has the requested action attribute and resolve it to steps.
+          if (this.isActionCandidate(action)) {
 
-            if (request.id) {
-              this.running[request.id] = true
-              this.done[request.id] = done
-            } else if (request.path) {
-              this.running[request.path] = true
-              this.done[request.path] = done
-            }
+            this.setRunning(request, done)
 
             // set DNS
 
@@ -1735,6 +1827,39 @@ class Api {
             }
 
             const initialPayload = typeof request.input === "undefined" ? {} : request.input
+            let steps
+            try {
+              steps = await this.resolveActionSteps({
+                request,
+                script,
+                scriptDir: cwd,
+                actionKey,
+                input: initialPayload,
+                args: initialPayload
+              })
+            } catch (e) {
+              this.clearResolvedAction(request)
+              delete this.running[this.requestId(request)]
+              this.ondata({
+                id: request.id || request.path,
+                type: "error",
+                data: e.stack,
+              })
+              return
+            }
+
+            if (!Array.isArray(steps) || steps.length === 0) {
+              this.clearResolvedAction(request)
+              delete this.running[this.requestId(request)]
+              this.ondata({
+                id: request.id || request.path,
+                type: "error",
+                data: `missing or invalid attribute: ${actionKey}`
+              })
+              return
+            }
+
+            await this.ensurePluginAgentInstructions(request)
             await this.startWatchersForRequest(request, script, cwd, initialPayload)
             this.queue(request, steps[0], initialPayload, 0, steps.length, cwd, initialPayload)
 

package/kernel/bin/huggingface.js

@@ -18,7 +18,7 @@ class Huggingface {
       let version = this.kernel.bin.installed.conda_versions.huggingface_hub
       if (version) {
         let coerced = semver.coerce(version)
-        if (semver.satisfies(coerced, ">=1.0.1")) {
+        if (coerced && semver.eq(coerced, "1.0.1")) {
           return true
         }
       }

package/kernel/environment.js

@@ -154,6 +154,8 @@ const ensurePinokioCacheDirs = async (kernel, options = {}) => {
     logCachePreflight(`cache root mkdir failed path=${cacheRoot} ${formatCachePreflightError(error)}`)
   }
 
+  if (process.platform === "darwin") await fs.promises.writeFile(path.resolve(root, ".metadata_never_index"), "", { flag: "a" }).catch(() => {})
+
   const errors = []
   const results = []
 
@@ -618,18 +620,21 @@ const requirements = async (script, cwd, kernel) => {
   let requires_instantiation = false
   if (script) {
     let pre
-    if (script.pre) {
+    if (Array.isArray(script.pre)) {
       pre = script.pre
-    } else if (script.env) {
+    } else if (Array.isArray(script.env)) {
       pre = script.env
     }
     if (pre) {
       let env = await get2(cwd, kernel)
       for(let item of pre) {
+        if (!item || typeof item !== "object") {
+          continue
+        }
         let env_key
-        if (item.env) {
+        if (typeof item.env === "string" && item.env) {
           env_key = item.env
-        } else if (item.key) {
+        } else if (typeof item.key === "string" && item.key) {
           env_key = item.key
           item.env = item.key
         }
@@ -638,11 +643,20 @@ const requirements = async (script, cwd, kernel) => {
           if (!item.index) {
             item.index = 0
           }
-          if (item.host) {
-            const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(item.host);
-            const url = new URL(hasProtocol ? item.host : `https://${item.host}`);
-            item.host = url.host
-            item.val = await kernel.kv.get(item.host, item.index)
+          if (typeof item.host === "string" && item.host.trim()) {
+            const host = item.host.trim()
+            let parsedHost = ""
+            try {
+              const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(host);
+              const url = new URL(hasProtocol ? host : `https://${host}`);
+              parsedHost = url.host
+            } catch (e) {
+              item.host = ""
+            }
+            if (parsedHost) {
+              item.host = parsedHost
+              item.val = await kernel.kv.get(item.host, item.index)
+            }
           } else {
             item.host = ""
           }

package/kernel/plugin_sources.js

@@ -10,6 +10,7 @@ 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() : ""
@@ -124,6 +125,29 @@ const pluginAssetHrefForIcon = (normalizedPath, icon) => {
   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, "")
@@ -161,7 +185,32 @@ const resolveLauncherPluginHref = (toolValue) => {
   return `${LOCAL_PLUGIN_RUN_PREFIX}/${normalizedTool}/pinokio.js`
 }
 
-const loadPluginsFromRoot = async ({ kernel, root, runPrefix, assetPrefix, source, ignore = [] }) => {
+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 []
 
@@ -170,9 +219,7 @@ const loadPluginsFromRoot = async ({ kernel, root, runPrefix, assetPrefix, sourc
   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
+    if (!isValidPluginConfig(config, { standalone })) continue
 
     const cwd = normalizedPluginPath.split("/").slice(0, -1).join("/")
     const href = `${runPrefix}/${normalizedPluginPath}`
@@ -204,6 +251,7 @@ const loadPluginMenu = async (kernel) => {
     assetPrefix: LOCAL_PLUGIN_ASSET_PREFIX,
     source: "local",
     ignore: ["code/**"],
+    standalone: true,
   })
   return systemPlugins.concat(localPlugins)
 }
@@ -232,5 +280,10 @@ module.exports = {
   pluginRunHrefForPath,
   pluginAssetHrefForIcon,
   resolveLauncherPluginHref,
+  resolveLauncherPluginSelection,
+  normalizeLauncherSuccessPlugin,
   loadPluginMenu,
+  ACTION_KEYS,
+  isAction,
+  isValidPluginConfig,
 }

package/kernel/prototype.js

@@ -3,6 +3,7 @@ const path = require('path')
 const { glob, sync, hasMagic } = require('glob-gitignore')
 const marked = require('marked')
 const matter = require('gray-matter');
+const PluginSources = require("./plugin_sources")
 class Proto {
   constructor(kernel) {
     this.kernel = kernel
@@ -148,6 +149,9 @@ class Proto {
 
 
       if (response) {
+        if (response.success) {
+          response.success = PluginSources.normalizeLauncherSuccessPlugin(response.success, req.params.tool)
+        }
         return response
       } else {
         return { success: "/p/" + name + "/dev" }

package/kernel/shell.js

@@ -294,6 +294,8 @@ class Shell {
       }
     }
 
+    setDefaultEnvValue(this.env, "HF_HUB_DISABLE_UPDATE_CHECK", "1")
+
     if (this.platform === "win32") {
       // Hugging Face file symlinks regularly fail on non-admin Windows setups.
       // Default to no-symlink cache mode unless the user/app explicitly overrides it.

package/kernel/watch/index.js

@@ -18,7 +18,34 @@ class WatchManager {
 
   hasHandler(script, handlerName) {
     const watches = script && Array.isArray(script.watch) ? script.watch : []
-    return watches.some((watch) => watch && watch.handler === handlerName)
+    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) {
@@ -105,10 +132,10 @@ class WatchManager {
           input,
           args
         })
-        const methodName = typeof declaration.method === "string" ? declaration.method.trim() : ""
+        const { handlerName, methodName } = this.resolveHandlerMethod(declaration)
         let handler = null
-        if (declaration.handler) {
-          handler = this.handlers.get(String(declaration.handler).trim())
+        if (handlerName) {
+          handler = this.handlers.get(handlerName)
         } else if (declaration.uri) {
           handler = await this.resolveExternalHandler(ctx, declaration.uri)
         }

package/package.json

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

package/server/features/index.js

@@ -1,10 +1,10 @@
-const { createDraftFeature } = require("./drafts")
+const { createNoteFeature } = require("./notes")
 
 async function mountFeatures(options = {}) {
-  const drafts = createDraftFeature(options)
-  await drafts.start()
+  const notes = createNoteFeature(options)
+  await notes.start()
   return {
-    drafts
+    notes
   }
 }