pinokiod 7.3.0 → 7.3.3

package/kernel/api/index.js

@@ -11,6 +11,15 @@ const fastq = require('fastq')
 const Loader = require("../loader")
 const Environment = require("../environment")
 const Util = require('../util')
+const ShellRunTemplate = require('./shell_run_template')
+const PluginSources = require('../plugin_sources')
+
+const escapeHtml = (value) => String(value || "")
+  .replace(/&/g, "&")
+  .replace(/</g, "&lt;")
+  .replace(/>/g, "&gt;")
+  .replace(/"/g, "&quot;")
+  .replace(/'/g, "&#39;")
 
 class Api {
   constructor(kernel) {
@@ -26,6 +35,7 @@ class Api {
     this.proxies = {}
     this.mods = {}
     this.child_procs = {}
+    this.resolved_actions = {}
     this.lproxy = new Lproxy()
   }
   async launcher_path(name) {
@@ -398,6 +408,152 @@ 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"
+  }
+  isPathInsideRoot(candidatePath, rootPath) {
+    if (!candidatePath || !rootPath) {
+      return false
+    }
+    const relative = path.relative(path.resolve(rootPath), path.resolve(candidatePath))
+    return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+  }
+  toPosixPath(value) {
+    return String(value || "").split(path.sep).join("/")
+  }
+  pluginPathFromFilePath(filePath) {
+    if (!filePath) {
+      return ""
+    }
+    const candidatePath = path.resolve(filePath)
+    const systemPluginRoot = PluginSources.systemPluginRoot(this.kernel)
+    if (this.isPathInsideRoot(candidatePath, systemPluginRoot)) {
+      const relativePath = this.toPosixPath(path.relative(systemPluginRoot, candidatePath))
+      return PluginSources.normalizePluginPath(`${PluginSources.SYSTEM_PLUGIN_RUN_PREFIX}/${relativePath}`)
+    }
+    const localPluginRoot = this.kernel && typeof this.kernel.path === "function"
+      ? this.kernel.path("plugin")
+      : ""
+    if (this.isPathInsideRoot(candidatePath, localPluginRoot)) {
+      const relativePath = this.toPosixPath(path.relative(localPluginRoot, candidatePath))
+      return PluginSources.normalizePluginPath(`/plugin/${relativePath}`)
+    }
+    return ""
+  }
+  pluginInstallDetailHref(request) {
+    const uri = request && typeof request.uri === "string" ? request.uri : ""
+    let pluginPath = ""
+    if (uri && (PluginSources.isRunPath(uri) || uri.startsWith("/plugin/") || uri.startsWith("plugin/"))) {
+      pluginPath = PluginSources.normalizePluginPath(uri)
+    }
+    if (!pluginPath) {
+      pluginPath = this.pluginPathFromFilePath(request && request.path)
+    }
+    return pluginPath
+      ? `/plugin?path=${encodeURIComponent(pluginPath)}&next=install`
+      : "/plugins"
+  }
+  pluginInstallNoticeStep(request, script) {
+    const title = escapeHtml(script && script.title ? script.title : "This plugin")
+    return {
+      method: "notify",
+      params: {
+        html: `${title} is not installed. Open the plugin page and click Install.`,
+        href: this.pluginInstallDetailHref(request),
+        target: "_parent",
+        type: "warning",
+      }
+    }
+  }
+  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)
+
+    if (actionKey === "run" && script && typeof script.installed === "function" && this.isActionCandidate(script.install)) {
+      let installed = null
+      try {
+        const context = await this.actionContext({ request, script, scriptDir, actionKey: "installed", input, args })
+        installed = await script.installed.call(script, this.kernel, this.kernel.info, context)
+      } catch (error) {
+        console.warn("Plugin installed check failed", request && request.path, error)
+      }
+      if (installed === false) {
+        return [this.pluginInstallNoticeStep(request, script)]
+      }
+    }
+
+    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
@@ -406,10 +562,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) {
@@ -890,7 +1048,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)
@@ -1010,6 +1168,7 @@ class Api {
     }
     // replace {{{ }}} with {{ }}
     rpc = this.kernel.template.flatten(rpc)
+    rpc = ShellRunTemplate.renderEnvArgs(this.kernel, rpc, memory)
 
     // 6. rpc must have method names
     if (rpc.method) {
@@ -1222,6 +1381,7 @@ class Api {
 
 
           if (result && result.error) {
+            this.clearResolvedAction(request)
             this.ondata({
               id: request.id || request.path,
               type: "error",
@@ -1403,6 +1563,7 @@ class Api {
 
         } catch (e) {
           console.log("<>ERROR", e)
+          this.clearResolvedAction(request)
           this.ondata({
             id: request.id || request.path,
             type: "error",
@@ -1492,6 +1653,7 @@ class Api {
 //        console.log("kernel.refresh after step")
 //        this.kernel.refresh(true)
       } catch (e) {
+        this.clearResolvedAction(request)
         ondata({ raw: e.toString() })
       }
     }, concurrency)
@@ -1671,18 +1833,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
 
@@ -1695,6 +1851,38 @@ 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
+            }
+
             this.queue(request, steps[0], initialPayload, 0, steps.length, cwd, initialPayload)
 
           } else {

package/kernel/api/process/index.js

@@ -34,6 +34,37 @@ class Process {
   constructor() {
     this.appApi = new AppAPI()
   }
+  isIndefiniteWait(params) {
+    return !params || !(
+      params.app ||
+      params.id ||
+      params.name ||
+      params.sec ||
+      params.min ||
+      params.uri ||
+      params.url ||
+      params.on
+    )
+  }
+  normalizeIndefiniteWaitParams(req) {
+    if (!req.params) {
+      req.params = {}
+    }
+    if (!req.params.title && !req.params.description && !req.params.message) {
+      req.params.title = "Waiting"
+      req.params.description = "Click Stop when done."
+    }
+  }
+  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 +190,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 +202,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 +215,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 +235,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 +261,88 @@ 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
+    const indefiniteWait = this.isIndefiniteWait(req && req.params)
+    if (indefiniteWait && req) {
+      this.normalizeIndefiniteWaitParams(req)
+    }
+    if (waitPath && kernel) {
+      if (!kernel.activeProcessWaits) {
+        kernel.activeProcessWaits = {}
+      }
+      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()
       }
-      // 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
+    }
+    const showFooter = req.params && (req.params.title || req.params.description || req.params.message)
+    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
-      })
     }
   }
 }