pinokiod 7.2.18 → 7.3.0

package/Dockerfile

@@ -37,6 +37,8 @@ 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

@@ -11,8 +11,6 @@ const fastq = require('fastq')
 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) {
@@ -28,22 +26,8 @@ class Api {
     this.proxies = {}
     this.mods = {}
     this.child_procs = {}
-    this.resolved_actions = {}
     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")
@@ -235,7 +219,7 @@ class Api {
       meta.ui = `/p/${api_name}`
       meta.browse = `/p/${api_name}/dev`
     } else {
-      meta.icon = meta.icon ? `/asset/api/${api_name}/${relpath}/${meta.icon}` : "/pinokio-black.png"
+      meta.icon = meta.icon ? `/asset/api/${api_name}/${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}`
@@ -414,84 +398,6 @@ 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
@@ -500,24 +406,16 @@ 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) {
         await this.process(script.on.stop) 
       }
     }
-    if (this.kernel.watch && typeof this.kernel.watch.stop === "function") {
-      if (req.params.id) {
-        await this.kernel.watch.stop(req.params.id)
-      }
-      await this.kernel.watch.stop(requestPath)
-    }
     // reset modules
     let modpath = this.resolvePath(cwd, req.params.uri)
     if (this.child_procs[modpath]) {
@@ -992,7 +890,7 @@ class Api {
 
     let { cwd: scriptDir, script } = await this.resolveScript(request.path)
     const actionKey = request.action || 'run'
-    const steps = await this.resolveActionSteps({ request, script, scriptDir, actionKey, input, args }) || []
+    const steps = (script && Array.isArray(script[actionKey])) ? script[actionKey] : []
     const totalSteps = steps.length
 
     let name = path.relative(this.kernel.path("api"), scriptDir)
@@ -1112,7 +1010,6 @@ 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) {
@@ -1281,7 +1178,7 @@ class Api {
           this.ondata({
             id: request.id || request.path,
             type: "start",
-            data: this.startData(rpc)
+            data: rpc
           })
 
           // DEPRECATED APIS
@@ -1557,41 +1454,6 @@ class Api {
     }
     return false
   }
-  async startWatchersForRequest(request, script, scriptDir, input) {
-    if (!this.kernel.watch || typeof this.kernel.watch.startForScript !== "function") {
-      return
-    }
-    const id = request.id || request.path
-    if (!id) {
-      return
-    }
-    const cwd = request.cwd || scriptDir
-    await this.kernel.watch.startForScript({
-      id,
-      request,
-      script,
-      cwd,
-      dirname: scriptDir,
-      input,
-      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 {
@@ -1809,12 +1671,18 @@ class Api {
         } else {
           const actionKey = request.action || 'run'
           request.action = actionKey
-          const action = script ? script[actionKey] : null
+          const steps = script ? script[actionKey] : null
 
-          // 3. Check if the resolved endpoint has the requested action attribute and resolve it to steps.
-          if (this.isActionCandidate(action)) {
+          // 3. Check if the resolved endpoint has the requested action attribute and it's an array
+          if (Array.isArray(steps) && steps.length > 0) {
 
-            this.setRunning(request, done)
+            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
+            }
 
             // set DNS
 
@@ -1827,40 +1695,6 @@ 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)
 
           } else {

package/kernel/api/process/index.js

@@ -34,16 +34,6 @@ 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 := {
@@ -169,8 +159,6 @@ 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),
@@ -181,8 +169,6 @@ 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),
@@ -194,8 +180,6 @@ 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)
     }
 
@@ -214,21 +198,9 @@ 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),
@@ -240,84 +212,57 @@ class Process {
     if 'cancel' is pressed before the condition is met, stops the script
 
     */
-    let ms
-    const waitPath = req && req.parent && req.parent.path
-    if (waitPath && kernel) {
-      if (!kernel.activeProcessWaits) {
-        kernel.activeProcessWaits = {}
+    let ms 
+    if (req.params) {
+      if (req.params.app || req.params.id || req.params.name) {
+        await this.appApi.waitForAppPresence(req, ondata, kernel)
+        return
       }
-      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
+      // 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
         }
-        // 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
+        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)
+          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`
           })
-        } 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)
+          ondata(req.params, "wait")
         }
-      } 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")
+        console.log("Wait", req.params.on)
+        await waitOn(req.params.on)
+        console.log("Wait finished")
+        ondata(req.params, "wait.end")
       }
+    } else {
+      await new Promise((resolve, reject) => {
+        this.resolve = resolve
+      })
     }
   }
 }

package/kernel/bin/conda-python.js

@@ -0,0 +1,30 @@
+const semver = require('semver')
+
+const WINDOWS_PYTHON_SSL_FIX_SPEC = "python=3.10.20=*_1_cpython"
+const WINDOWS_PYTHON_SSL_FIX_VERSION = "3.10.20"
+
+const condaBuildNumber = (build) => {
+  const chunks = String(build || "").split("_").reverse()
+  const buildNumber = chunks.find((chunk) => /^\d+$/.test(chunk))
+  return buildNumber ? Number(buildNumber) : null
+}
+
+const isWindowsPythonSslFixed = (version, build) => {
+  const coerced = semver.coerce(version)
+  if (!coerced) {
+    return false
+  }
+  if (!semver.satisfies(coerced, ">=3.10.20 <3.11.0")) {
+    return false
+  }
+  if (semver.eq(coerced, WINDOWS_PYTHON_SSL_FIX_VERSION)) {
+    const buildNumber = condaBuildNumber(build)
+    return typeof buildNumber === "number" && buildNumber >= 1
+  }
+  return true
+}
+
+module.exports = {
+  WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isWindowsPythonSslFixed,
+}

package/kernel/bin/conda.js

@@ -4,6 +4,11 @@ const fetch = require('cross-fetch')
 const { glob } = require('glob')
 const semver = require('semver')
 const { buildCondaListFromMeta } = require('./conda-meta')
+const {
+  WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isWindowsPythonSslFixed,
+} = require('./conda-python')
+
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
   urls = {
@@ -160,6 +165,7 @@ report_errors: false`)
     let conda_check = {}
     let conda = new Set()
     let conda_versions = {}
+    let conda_builds = {}
     let start = false
     for(let line of lines) {
       if (start) {
@@ -167,8 +173,10 @@ report_errors: false`)
         if (chunks.length > 2) {
           let name = chunks[0]
           let version = chunks[1]
+          let build = chunks[2]
           conda.add(name)
           conda_versions[name] = version
+          conda_builds[name] = build
           if (name === "conda") {
             conda_check.conda = true
 //            //if (String(version) === "24.11.1") {
@@ -206,6 +214,9 @@ report_errors: false`)
             //  console.log("semver NOT satisfied")
             //}
           }
+          if (name === "python") {
+            conda_check.python = this.kernel.platform !== "win32" || isWindowsPythonSslFixed(version, build)
+          }
         }
       } else {
         if (/.*name.*version.*build.*channel/i.test(line)) {
@@ -215,7 +226,8 @@ report_errors: false`)
     }
     this.kernel.bin.installed.conda = conda
     this.kernel.bin.installed.conda_versions = conda_versions
-    return conda_check.conda && conda_check.mamba && conda_check.sqlite
+    this.kernel.bin.installed.conda_builds = conda_builds
+    return conda_check.conda && conda_check.mamba && conda_check.sqlite && (this.kernel.platform !== "win32" || conda_check.python)
     //return conda_check.conda && conda_check.mamba
   }
   async install(req, ondata) {
@@ -300,10 +312,18 @@ report_errors: false`)
     }).join(" ")
     console.log("Conda dependencies to install", { mods })
 
+    let condaPackages = [
+      `"sqlite=3.47.2"`,
+      `"conda-libmamba-solver>=25.4.0"`,
+    ]
+    if (this.kernel.platform === "win32") {
+      condaPackages.unshift(`"${WINDOWS_PYTHON_SSL_FIX_SPEC}"`)
+    }
+
     let cmds = [
       //"conda clean -y --index-cache",
       "conda clean -y --all",
-      `conda install -y -c conda-forge "sqlite=3.47.2" "conda-libmamba-solver>=25.4.0" ${mods}`,
+      `conda install -y -c conda-forge ${condaPackages.join(" ")} ${mods}`.trim(),
 
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_connect_timeout_secs 20`,
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_read_timeout_secs 300`,
@@ -339,7 +359,6 @@ report_errors: false`)
     //if (this.kernel.platform === "win32" || this.kernel.platform === "darwin") {
     //  cmds.push("conda install -y conda-libmamba-solver=24.7.0 conda=24.7.1 --freeze-installed")
     //}
-
     await this.kernel.bin.exec({
       message: cmds,
       env: {

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 (coerced && semver.eq(coerced, "1.0.1")) {
+        if (semver.satisfies(coerced, ">=1.0.1")) {
           return true
         }
       }

package/kernel/bin/index.js

@@ -22,6 +22,7 @@ const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { buildCondaListFromMeta } = require('./conda-meta')
+const { isWindowsPythonSslFixed } = require('./conda-python')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
 const fse = require('fs-extra')
@@ -348,6 +349,8 @@ class Bin {
     let conda_check = {}
     let conda = new Set()
     let conda_versions = {}
+    let conda_builds = {}
+    this.correct_conda = false
 
     //////////////////////////////////////////////////////////////////
     // exception handling
@@ -386,8 +389,10 @@ class Bin {
           if (chunks.length > 2) {
             let name = chunks[0]
             let version = chunks[1]
+            let build = chunks[2]
             conda.add(name)
             conda_versions[name] = version
+            conda_builds[name] = build
             if (name === "conda") {
               conda_check.conda = true
             }
@@ -408,6 +413,9 @@ class Bin {
                 conda_check.sqlite = true
               }
             }
+            if (name === "python") {
+              conda_check.python = this.platform !== "win32" || isWindowsPythonSslFixed(version, build)
+            }
           }
         } else {
           if (/.*name.*version.*build.*channel/i.test(line)) {
@@ -416,13 +424,14 @@ class Bin {
         }
       }
 
-      if (conda_check.conda && conda_check.mamba && conda_check.sqlite) {
+      if (conda_check.conda && conda_check.mamba && conda_check.sqlite && (this.platform !== "win32" || conda_check.python)) {
       //if (conda_check.conda && conda_check.mamba) {
         this.correct_conda = true
       }
     }
     this.installed.conda = conda
     this.installed.conda_versions = conda_versions
+    this.installed.conda_builds = conda_builds
   }
   async refreshInstalled() {
 
@@ -430,6 +439,7 @@ class Bin {
 
     this.installed_initialized = false
     this.requirements_cache = {}
+    this.correct_conda = false
 
     //this.installed = {}