pinokiod 7.3.15 → 7.4.1

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) {

package/kernel/index.js

@@ -40,6 +40,9 @@ const Git = require('./git')
 const Connect = require('./connect')
 const Favicon = require('./favicon')
 const AppLauncher = require('./app_launcher')
+const ReadyState = require('./ready')
+const Autolaunch = require('./autolaunch')
+const LaunchRequirements = require('./launch_requirements')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
@@ -92,6 +95,11 @@ class Kernel {
     this.torch_backend = "cpu"
     this.vram = 0
     this.ram = 0
+    this.readyState = new ReadyState(this)
+    this.app_ready_status = this.readyState.status
+    this.launchRequirements = new LaunchRequirements(this)
+    this.autolaunch = new Autolaunch(this)
+    this.autolaunch_status = this.autolaunch.startupStatus()
     this.sysReady = new Promise((resolve) => {
       this._resolveSysReady = resolve
     })
@@ -110,6 +118,130 @@ class Kernel {
     })
     return response
   }
+  normalizeAppId(value) {
+    return this.readyState.normalizeAppId(value)
+  }
+  getAppIdForLaunchPath(launchPath) {
+    return this.readyState.getAppIdForLaunchPath(launchPath)
+  }
+  getAppRelativeLaunchScript(appId, launchPath) {
+    return this.readyState.getAppRelativeLaunchScript(appId, launchPath)
+  }
+  resolveReadyScriptPath(uri, cwd) {
+    return this.readyState.resolveScriptPath(uri, cwd)
+  }
+  isScriptReady(scriptPath) {
+    return this.readyState.isScriptReady(scriptPath)
+  }
+  getScriptProgress(scriptPath) {
+    return this.readyState.getScriptProgress(scriptPath)
+  }
+  ready(requestOrUri) {
+    return this.readyState.ready(requestOrUri)
+  }
+  hasLaunchRequirementRuntime(launchPath) {
+    return !!(
+      this.launchRequirements &&
+      typeof this.launchRequirements.hasRuntimeForLaunchPath === "function" &&
+      this.launchRequirements.hasRuntimeForLaunchPath(launchPath)
+    )
+  }
+  markAppLaunchStarted(launchPath) {
+    const status = this.readyState.markStarted(launchPath)
+    const appId = this.readyState.getAppIdForLaunchPath(launchPath)
+    if (this.hasLaunchRequirementRuntime(launchPath) && this.launchRequirements && typeof this.launchRequirements.markStarted === "function") {
+      if (typeof this.launchRequirements.markStartupStarted === "function") {
+        this.launchRequirements.markStartupStarted(appId)
+      }
+      this.launchRequirements.markStarted(launchPath)
+    }
+    return status
+  }
+  markAppLaunchProgress(launchPath, current, total) {
+    const progress = this.readyState.markProgress(launchPath, current, total)
+    if (progress && this.hasLaunchRequirementRuntime(launchPath) && this.launchRequirements && typeof this.launchRequirements.markProgress === "function") {
+      this.launchRequirements.markProgress(launchPath, progress)
+    }
+    return progress
+  }
+  markAppLaunchReady(launchPath) {
+    const status = this.readyState.markReady(launchPath)
+    const appId = this.readyState.getAppIdForLaunchPath(launchPath)
+    if (this.hasLaunchRequirementRuntime(launchPath) && this.launchRequirements && typeof this.launchRequirements.markDone === "function") {
+      if (typeof this.launchRequirements.markStartupReady === "function") {
+        this.launchRequirements.markStartupReady(appId)
+      }
+      this.launchRequirements.markDone(launchPath)
+    }
+    return status
+  }
+  markAppLaunchFailed(launchPath, error) {
+    return this.readyState.markFailed(launchPath, error)
+  }
+  markAppLaunchStopped(launchPath, options = {}) {
+    const status = this.readyState.markStopped(launchPath)
+    if (options && options.internal_completion) {
+      return status
+    }
+    const appId = this.readyState.getAppIdForLaunchPath(launchPath)
+    if (this.hasLaunchRequirementRuntime(launchPath) && this.launchRequirements && typeof this.launchRequirements.cancel === "function") {
+      if (typeof this.launchRequirements.markStartupStopped === "function") {
+        this.launchRequirements.markStartupStopped(appId)
+      }
+      const cancelled = this.launchRequirements.cancel(launchPath)
+      if (!cancelled && typeof this.launchRequirements.markDone === "function") {
+        this.launchRequirements.markDone(launchPath)
+      }
+      if (typeof this.launchRequirements.clearRelated === "function") {
+        this.launchRequirements.clearRelated(appId)
+      }
+    }
+    return status
+  }
+  beginLaunchOperation(launchPath, meta = {}) {
+    return this.launchRequirements && typeof this.launchRequirements.beginLaunchOperation === "function"
+      ? this.launchRequirements.beginLaunchOperation(launchPath, meta)
+      : null
+  }
+  endLaunchOperation(token) {
+    return this.launchRequirements && typeof this.launchRequirements.endLaunchOperation === "function"
+      ? this.launchRequirements.endLaunchOperation(token)
+      : false
+  }
+  isAppReady(appId) {
+    return this.readyState.isAppReady(appId)
+  }
+  collectAutolaunchCandidates() {
+    return this.autolaunch.collectCandidates()
+  }
+  runAutolaunchScheduler() {
+    return this.autolaunch.runScheduler()
+  }
+  ensureLaunchRequirements(launchPath, options = {}) {
+    return this.launchRequirements.ensureForLaunchPath(launchPath, options)
+  }
+  async hasLaunchRequirementConfig(launchPath) {
+    if (!launchPath) {
+      return false
+    }
+    const appId = this.getAppIdForLaunchPath(launchPath)
+    if (!appId) {
+      return false
+    }
+    const env = await Environment.get(this.path("api", appId), this)
+    return !!(
+      (typeof env.PINOKIO_SCRIPT_AUTOLAUNCH === "string" && env.PINOKIO_SCRIPT_AUTOLAUNCH.trim()) &&
+      (typeof env.PINOKIO_SCRIPT_REQUIRES === "string" && env.PINOKIO_SCRIPT_REQUIRES.trim())
+    )
+  }
+  clearLaunchRequirementsStatus(appId) {
+    if (this.launchRequirements && typeof this.launchRequirements.clearRelated === "function") {
+      this.launchRequirements.clearRelated(appId)
+    }
+  }
+  getLaunchRequirementsStatus(appId) {
+    return this.launchRequirements.getStatus(appId)
+  }
   async dns(request) {
     let config
     let api_path
@@ -1091,13 +1223,7 @@ class Kernel {
       // Initialize core tools
       this.bin.init().then(() => {
         if (this.homedir) {
-          this.git.init().then(() => {
-            this.git.index(this).then(() => {
-              //console.log(this.git.mapping)
-            }).catch((err) => {
-              console.warn("Git index error:", err && err.message ? err.message : err)
-            })
-          }).catch((err) => {
+          this.git.init().catch((err) => {
             console.warn("Git init error:", err && err.message ? err.message : err)
           })
           this.shell.init().then(async () => {
@@ -1151,42 +1277,15 @@ class Kernel {
 
               // get env
               if (!this.launch_complete) {
-                let interval = setInterval(async () => {
-                  try {
-                    if (this.i) {
-                      for (let api of this.i.api) {
-                        let env_path = path.resolve(this.api.userdir, api.path)
-                        let e = await Environment.get(env_path, this)
-                        if (e.PINOKIO_SCRIPT_AUTOLAUNCH && e.PINOKIO_SCRIPT_AUTOLAUNCH.trim().length > 0) {
-                          let autolaunch_path = path.resolve(env_path, e.PINOKIO_SCRIPT_AUTOLAUNCH)
-                          let exists = await this.exists(autolaunch_path)
-                          if (exists) {
-                            this.api.process({
-                              uri: autolaunch_path,
-                              input: {}
-            //                client: req.client,
-            //                caller: req.parent.path,
-                            }, (r) => {
-                              console.log({ autolaunch_path, r })
-//                              resolve(r.input)
-                            }).catch((err) => {
-                              console.warn('[Kernel.init] autolaunch process failed:', err && err.message ? err.message : err)
-                            })
-                          } else {
-                            console.log("SCRIPT DOES NOT EXIST. Ignoring.", autolaunch_path)
-                          }
-                        }
-                      }
-                      clearInterval(interval)
-                      setTimeout(() => {
-                        this.launch_complete = true
-                        console.log("SETTING launch complete", this.launch_complete)
-                      }, 2000)
-                    }
-                  } catch (err) {
-                    console.warn('[Kernel.init] autolaunch loop failed:', err && err.message ? err.message : err)
-                  }
-                }, 1000)
+                this.runAutolaunchScheduler().catch((err) => {
+                  console.warn('[Kernel.init] autolaunch scheduler failed:', err && err.message ? err.message : err)
+                  this.autolaunch.setStatus({
+                    running: false,
+                    error: err && err.message ? err.message : String(err || "Autolaunch failed"),
+                    apps: {}
+                  })
+                  this.launch_complete = true
+                })
               }
             }
           }).catch((err) => {