pinokiod 7.3.15 → 7.4.0

package/kernel/api/index.js

@@ -424,6 +424,9 @@ class Api {
     }
     this.running[id] = true
     this.done[id] = done
+    if (this.kernel && typeof this.kernel.markAppLaunchStarted === "function") {
+      this.kernel.markAppLaunchStarted(request.path)
+    }
   }
   isActionCandidate(action) {
     return (Array.isArray(action) && action.length > 0) || typeof action === "function"
@@ -509,6 +512,10 @@ class Api {
         let fullpath = path.resolve(cwd, ...args)
         return this.running[fullpath]
       },
+      ready: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.kernel.isScriptReady(fullpath)
+      },
       name,
       self: script,
       port,
@@ -554,7 +561,7 @@ class Api {
     }
     return steps
   }
-  async stop(req, ondata) {
+  async stop(req, ondata, options = {}) {
     // 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
 
@@ -586,10 +593,11 @@ class Api {
 
 
     // stop all shell processes connected to the uri
-    if (req.params.id) {
-      this.kernel.shell.kill({ group: req.params.id })
-    } else {
-      this.kernel.shell.kill({ group: requestPath })
+    const stopGroups = new Set()
+    if (req.params.id) stopGroups.add(req.params.id)
+    stopGroups.add(requestPath)
+    for (const group of stopGroups) {
+      this.kernel.shell.kill({ group })
     }
 
     // if any process is in a "wait" state, resume it
@@ -608,12 +616,17 @@ class Api {
       this.waiter[requestPath].reject()
       delete this.waiter[requestPath]
     }
-    if (req.params.id) {
-      delete this.running[req.params.id]
-      delete this.kernel.memory.local[req.params.id]
-    } else {
-      delete this.running[requestPath]
-      delete this.kernel.memory.local[requestPath]
+    const stoppedKeys = new Set()
+    if (req.params.id) stoppedKeys.add(req.params.id)
+    stoppedKeys.add(requestPath)
+    for (const key of stoppedKeys) {
+      delete this.running[key]
+      delete this.kernel.memory.local[key]
+    }
+    if (this.kernel && typeof this.kernel.markAppLaunchStopped === "function") {
+      this.kernel.markAppLaunchStopped(requestPath, {
+        internal_completion: !!(options && options.internal_completion)
+      })
     }
     this.ondata({
       id: req.params.id || requestPath,
@@ -1083,6 +1096,10 @@ class Api {
         let fullpath = path.resolve(cwd, ...args)
         return this.running[fullpath]
       },
+      ready: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.kernel.isScriptReady(fullpath)
+      },
       name,
       self: script,
       port,
@@ -1235,6 +1252,9 @@ class Api {
 
         this.kernel.memory.rpc[id].current = rpc.current
         this.kernel.memory.rpc[id].total = rpc.total
+        if (this.kernel && typeof this.kernel.markAppLaunchProgress === "function") {
+          this.kernel.markAppLaunchProgress(request.path, rpc.current, rpc.total)
+        }
 
 //        this.kernel.memory.rpc[request.path] = rpc
 //        this.kernel.memory.args[request.path] = args
@@ -1314,13 +1334,13 @@ class Api {
                     params: {
                       id: request.id
                     }
-                  })
+                  }, null, { internal_completion: true })
                 } else {
                   await this.stop({
                     params: {
                       uri: request.path
                     }
-                  })
+                  }, null, { internal_completion: true })
                 }
               }
               return { request, input: null, step: rpc.next, total: totalSteps, args }
@@ -1545,13 +1565,13 @@ class Api {
                   params: {
                     id: request.id
                   }
-                })
+                }, null, { internal_completion: true })
               } else {
                 await this.stop({
                   params: {
                     uri: request.path
                   }
-                })
+                }, null, { internal_completion: true })
               }
               return { request, input: result, step: rpc.next, total: totalSteps, args }
             }
@@ -1631,6 +1651,9 @@ class Api {
             this.queue(response.request, response.rawrpc, response.input, response.step, response.total, cwd, args)
           } else {
             let id = response.request.id || response.request.path
+            if (this.kernel && typeof this.kernel.markAppLaunchReady === "function") {
+              this.kernel.markAppLaunchReady(response.request.path)
+            }
             if (response.request.caller) {
               if (this.done[response.request.path]) {
                 this.done[response.request.path]({
@@ -1655,6 +1678,9 @@ class Api {
 //        this.kernel.refresh(true)
       } catch (e) {
         this.clearResolvedAction(request)
+        if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+          this.kernel.markAppLaunchFailed(request.path, e)
+        }
         ondata({ raw: e.toString() })
       }
     }, concurrency)
@@ -1838,8 +1864,72 @@ class Api {
 
           // 3. Check if the resolved endpoint has the requested action attribute and resolve it to steps.
           if (this.isActionCandidate(action)) {
+            const emitLaunchRequirementsControl = (result) => {
+              if (!result || !result.action || result.action === "continue") {
+                return
+              }
+              this.ondata({
+                id: request.id || request.path,
+                type: "launch.requirements.control",
+                data: result
+              })
+            }
+            let launchOperation = null
+            const releaseLaunchOperation = () => {
+              if (launchOperation && this.kernel && typeof this.kernel.endLaunchOperation === "function") {
+                this.kernel.endLaunchOperation(launchOperation)
+              }
+              launchOperation = null
+            }
+            const shouldCheckLaunchRequirements = !request.skip_requirements &&
+              this.kernel &&
+              typeof this.kernel.ensureLaunchRequirements === "function" &&
+              (typeof this.kernel.hasLaunchRequirementConfig === "function"
+                ? await this.kernel.hasLaunchRequirementConfig(request.path)
+                : true)
+            if (shouldCheckLaunchRequirements && request.path && this.kernel && typeof this.kernel.beginLaunchOperation === "function") {
+              launchOperation = this.kernel.beginLaunchOperation(request.path, { request })
+            }
+            if (shouldCheckLaunchRequirements) {
+              let requirementResult
+              try {
+                requirementResult = await this.kernel.ensureLaunchRequirements(request.path, {
+                  request,
+                  owner: launchOperation
+                })
+              } catch (e) {
+                releaseLaunchOperation()
+                if (e && (e.cancelled || e.blocked_reason)) {
+                  const control = {
+                    action: e.cancelled ? "cancelled" : "blocked",
+                    app_id: e.app_id || "",
+                    reason: e.blocked_reason || ""
+                  }
+                  emitLaunchRequirementsControl(control)
+                  return {
+                    request,
+                    launch_requirements: control
+                  }
+                }
+                this.ondata({
+                  id: request.id || request.path,
+                  type: "error",
+                  data: e && e.stack ? e.stack : String(e || "Launch requirements failed"),
+                })
+                return
+              }
+              if (requirementResult && requirementResult.action && requirementResult.action !== "continue") {
+                releaseLaunchOperation()
+                emitLaunchRequirementsControl(requirementResult)
+                return {
+                  request,
+                  launch_requirements: requirementResult
+                }
+              }
+            }
 
             this.setRunning(request, done)
+            releaseLaunchOperation()
 
             // set DNS
 
@@ -1865,6 +1955,9 @@ class Api {
             } catch (e) {
               this.clearResolvedAction(request)
               delete this.running[this.requestId(request)]
+              if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+                this.kernel.markAppLaunchFailed(request.path, e)
+              }
               this.ondata({
                 id: request.id || request.path,
                 type: "error",
@@ -1876,6 +1969,9 @@ class Api {
             if (!Array.isArray(steps) || steps.length === 0) {
               this.clearResolvedAction(request)
               delete this.running[this.requestId(request)]
+              if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+                this.kernel.markAppLaunchFailed(request.path, new Error(`missing or invalid attribute: ${actionKey}`))
+              }
               this.ondata({
                 id: request.id || request.path,
                 type: "error",

package/kernel/api/script/index.js

@@ -160,6 +160,16 @@ class Script {
       ondata({ raw: `\r\nStopped ${uri}\r\n` })
     }
   }
+  async ready(req, ondata, kernel) {
+    const params = req && req.params
+    let uri = this.currentPath(req)
+    if (typeof params === "string") {
+      uri = params
+    } else if (params && typeof params === "object") {
+      uri = params.uri || params.path || params.script || uri
+    }
+    return kernel.isScriptReady(kernel.resolveReadyScriptPath(uri, req && req.cwd))
+  }
   async run(req, ondata, kernel) {
     /*
       {

package/kernel/autolaunch.js

@@ -0,0 +1,111 @@
+const path = require('path')
+const Environment = require('./environment')
+
+class Autolaunch {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.kernel.autolaunch_status = this.startupStatus()
+  }
+  startupStatus() {
+    return this.kernel.launchRequirements && typeof this.kernel.launchRequirements.startupHomeStatus === "function"
+      ? this.kernel.launchRequirements.startupHomeStatus()
+      : (this.kernel.autolaunch_status || { running: false, apps: {} })
+  }
+  setStatus(status) {
+    const nextStatus = this.kernel.launchRequirements && typeof this.kernel.launchRequirements.replaceStartupHomeStatus === "function"
+      ? this.kernel.launchRequirements.replaceStartupHomeStatus(status)
+      : status
+    this.kernel.autolaunch_status = nextStatus
+    return nextStatus
+  }
+  async collectCandidates() {
+    const apis = this.kernel.i && Array.isArray(this.kernel.i.api) ? this.kernel.i.api : []
+    const candidates = []
+    for (const api of apis) {
+      if (!api || !api.path) {
+        continue
+      }
+      const envPath = path.resolve(this.kernel.api.userdir, api.path)
+      const env = await Environment.get(envPath, this.kernel)
+      const script = Environment.getScriptAutolaunch(env)
+      if (!script || !Environment.getScriptAutolaunchEnabled(env)) {
+        continue
+      }
+      const autolaunchPath = path.resolve(this.kernel.api.userdir, api.path, script)
+      const exists = !!(autolaunchPath && await this.kernel.exists(autolaunchPath))
+      const dependencies = Environment.getScriptRequirements(env)
+      candidates.push({
+        id: api.path,
+        title: api.title || api.path,
+        script,
+        autolaunchPath,
+        dependencies,
+        exists
+      })
+    }
+    return candidates
+  }
+  async runScheduler() {
+    const startedAt = Date.now()
+    const candidates = await this.collectCandidates()
+    const status = this.kernel.launchRequirements && typeof this.kernel.launchRequirements.seedStartupHomeStatus === "function"
+      ? await this.kernel.launchRequirements.seedStartupHomeStatus(candidates, startedAt)
+      : this.setStatus({
+          running: true,
+          started_at: startedAt,
+          apps: {}
+        })
+    this.kernel.autolaunch_status = status
+    for (const candidate of candidates) {
+      if (!status.apps[candidate.id]) {
+        status.apps[candidate.id] = {
+          id: candidate.id,
+          title: candidate.title,
+          script: candidate.script,
+          launch_path: candidate.autolaunchPath,
+          state: "pending",
+          dependencies: candidate.dependencies,
+          waiting_for: candidate.dependencies,
+          startup_root: true
+        }
+      }
+      if (!candidate.exists) {
+        status.apps[candidate.id].state = "blocked"
+        status.apps[candidate.id].blocked_reason = candidate.script ? "Launch script does not exist" : "No launch script selected"
+        status.apps[candidate.id].waiting_for = []
+      }
+      status.apps[candidate.id].startup_root = true
+    }
+    const launchable = candidates.filter((candidate) => {
+      const row = status.apps[candidate.id]
+      if (!row || !candidate.exists) {
+        if (!candidate.exists) {
+          console.log("SCRIPT DOES NOT EXIST. Ignoring.", candidate.autolaunchPath)
+        }
+        return false
+      }
+      return row.state !== "blocked"
+    })
+    await Promise.all(launchable.map((candidate) => {
+      return this.kernel.api.process({
+        uri: candidate.autolaunchPath,
+        input: {},
+        startup: true
+      }).catch((err) => {
+        console.warn('[Kernel.init] startup process failed:', err && err.message ? err.message : err)
+        const row = status.apps[candidate.id]
+        if (row && row.state !== "ready") {
+          delete status.apps[candidate.id]
+        }
+      })
+    }))
+    status.running = false
+    status.completed_at = Date.now()
+    setTimeout(() => {
+      this.kernel.launch_complete = true
+      console.log("SETTING launch complete", this.kernel.launch_complete)
+    }, 2000)
+  }
+}
+
+module.exports = Autolaunch

package/kernel/environment.js

@@ -6,6 +6,81 @@ const ManagedSkills = require('./managed_skills')
 const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
 const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
 const CACHE_PREFLIGHT_KEYS = TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)
+const SCRIPT_AUTOLAUNCH_KEY = "PINOKIO_SCRIPT_AUTOLAUNCH"
+const SCRIPT_AUTOLAUNCH_ENABLED_KEY = "PINOKIO_SCRIPT_AUTOLAUNCH_ENABLED"
+const SCRIPT_REQUIREMENTS_KEY = "PINOKIO_SCRIPT_REQUIRES"
+
+const parseBooleanFlag = (value) => {
+  if (typeof value !== "string") {
+    return null
+  }
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) {
+    return null
+  }
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false
+  }
+  return null
+}
+
+const getScriptAutolaunch = (env) => {
+  return typeof (env && env[SCRIPT_AUTOLAUNCH_KEY]) === "string"
+    ? env[SCRIPT_AUTOLAUNCH_KEY].trim()
+    : ""
+}
+
+const getScriptAutolaunchEnabled = (env) => {
+  const script = getScriptAutolaunch(env)
+  if (!script) {
+    return false
+  }
+  const explicit = parseBooleanFlag(env && env[SCRIPT_AUTOLAUNCH_ENABLED_KEY])
+  return explicit === null ? true : explicit
+}
+
+const parseAutolaunchList = (value) => {
+  if (typeof value !== "string") {
+    return []
+  }
+  const seen = new Set()
+  const values = []
+  for (const part of value.split(",")) {
+    const raw = part.trim()
+    if (!raw) {
+      continue
+    }
+    let id = raw
+    try {
+      id = decodeURIComponent(raw)
+    } catch (_) {}
+    id = String(id || "").trim()
+    if (!id || seen.has(id)) {
+      continue
+    }
+    seen.add(id)
+    values.push(id)
+  }
+  return values
+}
+
+const formatAutolaunchList = (ids) => {
+  if (!Array.isArray(ids)) {
+    return ""
+  }
+  return ids
+    .map((id) => String(id || "").trim())
+    .filter(Boolean)
+    .map((id) => encodeURIComponent(id))
+    .join(",")
+}
+
+const getScriptRequirements = (env) => {
+  return parseAutolaunchList(env && env[SCRIPT_REQUIREMENTS_KEY])
+}
 
 const formatCachePreflightError = (error) => {
   if (!error) {
@@ -279,6 +354,19 @@ const ENVS = async () => {
       "#",
       "##########################################################################",
     ]
+  }, {
+    type: ["app"],
+    key: SCRIPT_REQUIREMENTS_KEY,
+    val: "",
+    comment: [
+      "##########################################################################",
+      "#",
+      "# PINOKIO_SCRIPT_REQUIRES",
+      "# comma-separated local app folder IDs this app requires before launch",
+      "# requirements do not automatically enable run-at-startup for those apps",
+      "#",
+      "##########################################################################",
+    ]
   }, {
     type: ["system"],
     key: "PINOKIO_SHARE_VAR",
@@ -946,4 +1034,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root  }
+module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root, SCRIPT_AUTOLAUNCH_KEY, SCRIPT_AUTOLAUNCH_ENABLED_KEY, SCRIPT_REQUIREMENTS_KEY, getScriptAutolaunch, getScriptAutolaunchEnabled, parseAutolaunchList, formatAutolaunchList, getScriptRequirements  }

package/kernel/git.js

@@ -228,16 +228,6 @@ class Git {
       return fs.promises.copyFile(src, dest)
     }))
 
-    // best-effort: clear any stale index.lock files across all known repos at startup
-    try {
-      const apiRoot = this.kernel.path("api")
-      const repos = await this.repos(apiRoot)
-      for (const repo of repos) {
-        if (repo && repo.dir) {
-          await this.clearStaleLock(repo.dir)
-        }
-      }
-    } catch (_) {}
   }
   checkpointsDir() {
     return path.resolve(this.kernel.homedir, "checkpoints")
@@ -1326,6 +1316,7 @@ class Git {
       const gitParentPath = path.dirname(gitPath)
       const gitParentRelPath = path.relative(this.kernel.path("api"), gitParentPath)
       let dir = path.dirname(gitPath)
+      await this.clearStaleLock(dir)
       let display_name
       let main
       if (gitRelPathSansGit === ".") {
@@ -1457,15 +1448,6 @@ class Git {
   async findRepoRootForPath(targetPath) {
     if (!targetPath || typeof targetPath !== "string") return null
     const absoluteTarget = path.resolve(targetPath)
-    const cachedRoots = Array.from(this.dirs)
-      .map((dir) => path.resolve(dir))
-      .sort((a, b) => b.length - a.length)
-    for (const root of cachedRoots) {
-      if (absoluteTarget === root || absoluteTarget.startsWith(`${root}${path.sep}`)) {
-        return root
-      }
-    }
-
     let probe = await this.findExistingAncestor(absoluteTarget)
     if (!probe) return null
     try {
@@ -1488,6 +1470,14 @@ class Git {
       this.dirs.add(probe)
       return probe
     }
+    const cachedRoots = Array.from(this.dirs)
+      .map((dir) => path.resolve(dir))
+      .sort((a, b) => b.length - a.length)
+    for (const root of cachedRoots) {
+      if (absoluteTarget === root || absoluteTarget.startsWith(`${root}${path.sep}`)) {
+        return root
+      }
+    }
     return null
   }
   getManagedRepairTarget(targetPath) {