pinokiod 7.3.15 → 7.4.1

package/server/index.js

@@ -28,6 +28,7 @@ const system = require('systeminformation')
 const serveIndex = require('./serveIndex')
 const registerFileRoutes = require('./routes/files')
 const registerAppRoutes = require('./routes/apps')
+const ServerAutolaunch = require('./autolaunch')
 const Git = require("../kernel/git")
 const TerminalApi = require('../kernel/api/terminal')
 const PluginSources = require("../kernel/plugin_sources")
@@ -192,28 +193,9 @@ class Server {
       /(^|\/)\.pytest_cache\//,
       /(^|\/)\.git\//
     ]
-    this.apiGitRefreshTimer = null
     this.workspaceStatus = new WorkspaceStatusManager({
       enableWatchers: process.env.PINOKIO_DISABLE_WATCH === '1' ? false : true,
       fallbackIntervalMs: 60000,
-      onEvent: (workspaceName, events) => {
-        if (!this.kernel.homedir) return
-        if (!events || events.length === 0) return
-        const apiRoot = this.kernel.path('api')
-        const topLevel = events.some(({ path: evtPath, type }) => {
-          if (!evtPath) return false
-          const rel = path.relative(apiRoot, evtPath)
-          if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return false
-          const parts = rel.split(path.sep)
-          return parts.length === 1 && (type === 'create' || type === 'delete')
-        })
-        if (topLevel) {
-          if (this.apiGitRefreshTimer) clearTimeout(this.apiGitRefreshTimer)
-          this.apiGitRefreshTimer = setTimeout(() => {
-            this.kernel.git.repos(apiRoot).catch(() => {})
-          }, 1000)
-        }
-      },
     })
     this.appRegistry = new AppRegistryService({ kernel: this.kernel })
     this.appPreferences = new AppPreferencesService({ kernel: this.kernel })
@@ -228,6 +210,7 @@ class Server {
     })
     this.desktopEventRouter = createDesktopEventRouter({ kernel: this.kernel })
     this.injectRouter = createInjectRouter({ kernel: this.kernel })
+    this.autolaunch = new ServerAutolaunch(this)
 
     // sometimes the C:\Windows\System32 is not in PATH, need to add
     let platform = os.platform()
@@ -395,6 +378,73 @@ class Server {
       console.error('Failed to emit fatal notification:', err)
     }
   }
+  async refreshTopLevelAppInventory() {
+    try {
+      if (this.kernel && this.kernel.api && typeof this.kernel.api.linkGit === "function") {
+        await this.kernel.api.linkGit()
+      }
+    } catch (error) {
+      console.warn("App inventory refresh error:", error && error.message ? error.message : error)
+    }
+  }
+  async findApiRepoByGitUrl(gitUrl) {
+    if (!gitUrl || typeof gitUrl !== "string") return null
+    const candidates = [gitUrl]
+    if (gitUrl.endsWith(".git")) {
+      candidates.push(gitUrl.slice(0, -4))
+    } else {
+      candidates.push(`${gitUrl}.git`)
+    }
+    const mapping = this.kernel && this.kernel.git ? this.kernel.git.mapping : null
+    const removeStaleMapping = (candidate) => {
+      if (!mapping) return
+      delete mapping[candidate]
+      if (candidate.endsWith(".git")) {
+        delete mapping[candidate.slice(0, -4)]
+      } else {
+        delete mapping[`${candidate}.git`]
+      }
+    }
+    const isUsableRepoPath = async (repoPath) => {
+      if (!repoPath || typeof repoPath !== "string") return false
+      if (this.kernel.git && typeof this.kernel.git.hasGitMetadata === "function") {
+        return this.kernel.git.hasGitMetadata(repoPath)
+      }
+      try {
+        const stat = await fs.promises.stat(repoPath)
+        return stat.isDirectory()
+      } catch (_) {
+        return false
+      }
+    }
+
+    for (const candidate of candidates) {
+      const found = this.kernel.git.find(candidate)
+      if (found && await isUsableRepoPath(found.path)) return found
+      if (found) removeStaleMapping(candidate)
+    }
+
+    if (this.kernel.api && this.kernel.api.gitPath) {
+      for (const candidate of candidates) {
+        const repoPath = this.kernel.api.gitPath[candidate]
+        if (repoPath && await isUsableRepoPath(repoPath)) {
+          const found = { path: repoPath }
+          try {
+            found.head = await this.kernel.git.getHead(repoPath)
+          } catch (_) {}
+          this.kernel.git.mapping[candidate] = found
+          return found
+        }
+      }
+    }
+
+    await this.kernel.git.repos(this.kernel.path("api"))
+    for (const candidate of candidates) {
+      const found = this.kernel.git.find(candidate)
+      if (found) return found
+    }
+    return null
+  }
   stop() {
     if (this.resourceUsage && typeof this.resourceUsage.stop === 'function') {
       this.resourceUsage.stop()
@@ -759,6 +809,11 @@ class Server {
         shortcuts: x.shortcuts,
         index: x.index,
         running_scripts: x.running_scripts,
+        autolaunch_starting: x.autolaunch_starting ? true : false,
+        autolaunch_waiting: x.autolaunch_waiting ? true : false,
+        autolaunch_blocked: x.autolaunch_blocked ? true : false,
+        autolaunch_status_label: typeof x.autolaunch_status_label === "string" ? x.autolaunch_status_label : "",
+        autolaunch_script: typeof x.autolaunch_script === "string" ? x.autolaunch_script : "",
         //icon: (x.isDirectory() ? "fa-solid fa-folder" : "fa-regular fa-file"),
         name,
         uri,
@@ -1170,296 +1225,6 @@ class Server {
       list: this.getPeers(),
     }
   }
-  normalizeAutolaunchAppId(value) {
-    if (typeof value !== "string") {
-      return ""
-    }
-    const id = value.trim()
-    if (!id || id === "." || id === ".." || id.includes("\0") || /[\\/]/.test(id)) {
-      return ""
-    }
-    return id
-  }
-  normalizeAutolaunchScriptPath(value) {
-    if (typeof value !== "string") {
-      return ""
-    }
-    let script = value.trim().replace(/\\/g, "/")
-    if (!script || script.includes("\0")) {
-      return ""
-    }
-    script = script.split("#")[0].split("?")[0].trim()
-    if (!script || /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(script) || script.startsWith("//")) {
-      return ""
-    }
-    if (script.startsWith("/")) {
-      return ""
-    }
-    const normalized = path.posix.normalize(script).replace(/^\.\/+/, "")
-    if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
-      return ""
-    }
-    return normalized
-  }
-  isAutolaunchScriptFilename(filename) {
-    const ext = path.extname(filename || "").toLowerCase()
-    if (![".js", ".json", ".mjs", ".cjs"].includes(ext)) {
-      return false
-    }
-    const base = path.basename(filename || "").toLowerCase()
-    return !["package.json", "pinokio.js", "pinokio.json", "pinokio_meta.json"].includes(base)
-  }
-  stripAutolaunchLabel(value) {
-    if (typeof value !== "string") {
-      return ""
-    }
-    return value
-      .replace(/<[^>]*>/g, " ")
-      .replace(/\s+/g, " ")
-      .trim()
-  }
-  async getAutolaunchAppById(appId) {
-    const id = this.normalizeAutolaunchAppId(appId)
-    if (!id) {
-      return null
-    }
-    const apps = await this.kernel.api.listApps()
-    return apps.find((app) => app && app.id === id) || null
-  }
-  async getAutolaunchEnvInfo(app) {
-    const appRoot = path.resolve(this.kernel.api.userdir, app.id)
-    const gotRoot = await Environment.get_root({ path: appRoot }, this.kernel)
-    const envRoot = gotRoot && gotRoot.root ? gotRoot.root : appRoot
-    const envPath = path.resolve(envRoot, "ENVIRONMENT")
-    const env = await Util.parse_env(envPath)
-    const value = typeof env.PINOKIO_SCRIPT_AUTOLAUNCH === "string"
-      ? env.PINOKIO_SCRIPT_AUTOLAUNCH.trim()
-      : ""
-    const exists = await this.exists(envPath)
-    return {
-      appRoot,
-      envRoot,
-      envPath,
-      envRelpath: gotRoot && gotRoot.relpath ? gotRoot.relpath : "",
-      exists,
-      value,
-      enabled: value.length > 0
-    }
-  }
-  async buildAutolaunchAppState(app) {
-    const envInfo = await this.getAutolaunchEnvInfo(app)
-    return {
-      id: app.id,
-      name: app.name,
-      title: app.title || app.name || app.id,
-      description: app.description || "",
-      icon: app.icon || "/pinokio-black.png",
-      workspace_path: app.workspace_path,
-      launcher_path: app.launcher_path,
-      launcher_root: app.launcher_root || "",
-      env_path: envInfo.envPath,
-      autolaunch: envInfo.value,
-      autolaunch_enabled: envInfo.enabled
-    }
-  }
-  async buildAutolaunchAppsState() {
-    const apps = await this.kernel.api.listApps()
-    const states = []
-    for (const app of apps) {
-      states.push(await this.buildAutolaunchAppState(app))
-    }
-    return states
-  }
-  async resolveAutolaunchScript(appRoot, script) {
-    const normalized = this.normalizeAutolaunchScriptPath(script)
-    if (!normalized || !this.isAutolaunchScriptFilename(normalized)) {
-      return null
-    }
-    const scriptPath = path.resolve(appRoot, normalized)
-    if (!this.is_subpath(appRoot, scriptPath)) {
-      return null
-    }
-    let stat
-    try {
-      stat = await fs.promises.stat(scriptPath)
-    } catch (_) {
-      return null
-    }
-    if (!stat || !stat.isFile()) {
-      return null
-    }
-    return {
-      script: normalized,
-      path: scriptPath
-    }
-  }
-  flattenAutolaunchMenu(menu, trail = []) {
-    const items = []
-    if (!Array.isArray(menu)) {
-      return items
-    }
-    for (const menuitem of menu) {
-      if (!menuitem || typeof menuitem !== "object") {
-        continue
-      }
-      const label = this.stripAutolaunchLabel(menuitem.text || menuitem.name || menuitem.html || "")
-      const nextTrail = label ? trail.concat(label) : trail
-      if (Array.isArray(menuitem.menu)) {
-        items.push(...this.flattenAutolaunchMenu(menuitem.menu, nextTrail))
-      } else {
-        items.push({ item: menuitem, group: trail.join(" / ") })
-      }
-    }
-    return items
-  }
-  async addAutolaunchCandidate(candidates, seen, candidate, appRoot) {
-    const resolved = await this.resolveAutolaunchScript(appRoot, candidate.script)
-    if (!resolved || seen.has(resolved.script)) {
-      return null
-    }
-    seen.add(resolved.script)
-    const label = this.stripAutolaunchLabel(candidate.label || "") || resolved.script
-    const menuDefault = !!candidate.menu_default
-    const item = {
-      script: resolved.script,
-      label,
-      group: candidate.group || "",
-      icon: candidate.icon || "",
-      source: candidate.source || "local",
-      menu_default: menuDefault,
-      has_params: !!candidate.has_params
-    }
-    candidates.push(item)
-    return item
-  }
-  async collectAutolaunchScriptFiles(root, appRoot) {
-    const results = []
-    const ignoredDirs = new Set([
-      ".git",
-      ".venv",
-      "__pycache__",
-      "app",
-      "cache",
-      "data",
-      "env",
-      "logs",
-      "models",
-      "node_modules",
-      "output",
-      "outputs",
-      "venv"
-    ])
-    const maxResults = 500
-    const walk = async (dir, depth) => {
-      if (depth > 4 || results.length >= maxResults) {
-        return
-      }
-      let entries
-      try {
-        entries = await fs.promises.readdir(dir, { withFileTypes: true })
-      } catch (_) {
-        return
-      }
-      for (const entry of entries) {
-        if (!entry || !entry.name || entry.name.includes("\0")) {
-          continue
-        }
-        const fullPath = path.resolve(dir, entry.name)
-        if (entry.isDirectory()) {
-          if (!ignoredDirs.has(entry.name)) {
-            await walk(fullPath, depth + 1)
-          }
-          continue
-        }
-        if (!entry.isFile() || !this.isAutolaunchScriptFilename(entry.name)) {
-          continue
-        }
-        if (!this.is_subpath(appRoot, fullPath)) {
-          continue
-        }
-        const rel = path.relative(appRoot, fullPath).split(path.sep).join("/")
-        results.push(rel)
-      }
-    }
-    await walk(root, 0)
-    results.sort((a, b) => a.localeCompare(b))
-    return results
-  }
-  async buildAutolaunchCandidates(app) {
-    const envInfo = await this.getAutolaunchEnvInfo(app)
-    const appRoot = envInfo.appRoot
-    const launcher = await this.kernel.api.launcher(app.id)
-    const launcherRoot = launcher && launcher.launcher_root
-      ? path.resolve(appRoot, launcher.launcher_root)
-      : appRoot
-    const menuCandidates = []
-    const otherCandidates = []
-    const seen = new Set()
-
-    try {
-      let config = await this.kernel.api.meta(app.id)
-      config = await this.processMenu(app.id, safeStructuredClone(config || {}))
-      const flat = this.flattenAutolaunchMenu(config && config.menu ? config.menu : [])
-      for (const entry of flat) {
-        const menuitem = entry.item
-        if (!menuitem || typeof menuitem.href !== "string") {
-          continue
-        }
-        let href = menuitem.href.trim()
-        const apiPrefix = `/api/${app.id}/`
-        if (href.startsWith(apiPrefix)) {
-          href = href.slice(apiPrefix.length)
-        } else if (href.startsWith("/")) {
-          continue
-        }
-        const localScript = this.normalizeAutolaunchScriptPath(href)
-        if (!localScript) {
-          continue
-        }
-        const scriptPath = path.resolve(launcherRoot, localScript)
-        if (!this.is_subpath(appRoot, scriptPath)) {
-          continue
-        }
-        const script = path.relative(appRoot, scriptPath).split(path.sep).join("/")
-        await this.addAutolaunchCandidate(menuCandidates, seen, {
-          script,
-          label: menuitem.text || menuitem.name || script,
-          group: entry.group,
-          icon: typeof menuitem.icon === "string" ? menuitem.icon : "",
-          source: "menu",
-          menu_default: !!menuitem.default,
-          has_params: !!(menuitem.params && typeof menuitem.params === "object")
-        }, appRoot)
-      }
-    } catch (error) {
-      console.warn("[autolaunch] failed to resolve menu candidates", app.id, error && error.message ? error.message : error)
-    }
-
-    if (envInfo.value) {
-      await this.addAutolaunchCandidate(menuCandidates, seen, {
-        script: envInfo.value,
-        label: envInfo.value,
-        source: "current"
-      }, appRoot)
-    }
-
-    const localScripts = await this.collectAutolaunchScriptFiles(launcherRoot, appRoot)
-    for (const script of localScripts) {
-      await this.addAutolaunchCandidate(otherCandidates, seen, {
-        script,
-        label: script,
-        source: "local"
-      }, appRoot)
-    }
-
-    return {
-      app: await this.buildAutolaunchAppState(app),
-      launcher_root: path.relative(appRoot, launcherRoot).split(path.sep).join("/"),
-      menu: menuCandidates,
-      other: otherCandidates,
-      current: envInfo.value
-    }
-  }
   async renderInvalidContentPage(req, res, invalid, options = {}) {
     const type = invalid && typeof invalid.type === "string" ? invalid.type : "app"
     const sidebarSelected = options.sidebarSelected || (type === "plugin" ? "plugins" : type === "task" ? "tasks" : "home")
@@ -1718,7 +1483,7 @@ class Server {
     let autolaunchAppState = null
     try {
       const appRoot = this.kernel.path("api", name)
-      autolaunchAppState = await this.buildAutolaunchAppState({
+      autolaunchAppState = await this.autolaunch.buildAppState({
         id: name,
         name,
         title: config && config.title ? config.title : name,
@@ -1766,6 +1531,12 @@ class Server {
       config,
       protection_enabled: protectionPreference ? protectionPreference.protection_enabled !== false : false,
       autolaunch_app: autolaunchAppState,
+      launch_requirements_status_enabled: !!(
+        autolaunchAppState &&
+        autolaunchAppState.autolaunch &&
+        Array.isArray(autolaunchAppState.autolaunch_depends) &&
+        autolaunchAppState.autolaunch_depends.length > 0
+      ),
 //        sidebar_url: "/pinokio/sidebar/" + name,
       home: req.originalUrl,
       run_tab,
@@ -2014,7 +1785,7 @@ class Server {
     let check = !!relative && !relative.startsWith('..') && !path.isAbsolute(relative);
     return check
   }
-  async getRepoHeadStatus(repoRelPath) {
+  async getRepoHeadStatus(repoRelPath, options = {}) {
     const repoParam = repoRelPath || ""
     const dir = repoParam ? this.kernel.path("api", repoParam) : this.kernel.path("api")
 
@@ -2027,19 +1798,21 @@ class Server {
       return { changes: [], git_commit_url: null }
     }
 
-      let gitIgnoreEngine = null
       let workspaceName = null
+      let workspaceRoot = null
       let workspaceRelBase = ''
+      let gitIgnoreContext = null
       try {
         if (this.workspaceStatus && this.kernel && typeof this.kernel.path === 'function') {
           if (repoParam && repoParam.length > 0) {
             const parts = repoParam.split('/')
             workspaceName = parts[0]
-            const workspaceRoot = this.kernel.path("api", workspaceName)
-            await this.workspaceStatus.ensureGitIgnoreEngine(workspaceName, workspaceRoot)
-            gitIgnoreEngine = this.workspaceStatus.gitIgnoreEngines && this.workspaceStatus.gitIgnoreEngines.get
-              ? this.workspaceStatus.gitIgnoreEngines.get(workspaceName) || null
-              : null
+            workspaceRoot = this.kernel.path("api", workspaceName)
+            gitIgnoreContext = options && options.gitIgnoreContext
+              ? options.gitIgnoreContext
+              : (typeof this.workspaceStatus.createPathScopedGitIgnoreContext === 'function'
+                  ? this.workspaceStatus.createPathScopedGitIgnoreContext(workspaceRoot)
+                  : null)
             if (parts.length > 1) {
               workspaceRelBase = parts.slice(1).join('/')
             }
@@ -2116,16 +1889,16 @@ class Server {
         if (!filepath) {
           continue
         }
-        if (gitIgnoreEngine && workspaceName) {
+        if (!shouldIncludePath(filepath)) {
+          continue
+        }
+        if (gitIgnoreContext && workspaceName && this.workspaceStatus && typeof this.workspaceStatus.isPathScopedGitIgnored === 'function') {
           const workspaceRelative = workspaceRelBase ? `${workspaceRelBase}/${filepath}` : filepath
           const normalizedWorkspaceRel = normalizePath(workspaceRelative)
-          if (gitIgnoreEngine.ignores(normalizedWorkspaceRel)) {
+          if (await this.workspaceStatus.isPathScopedGitIgnored(gitIgnoreContext, normalizedWorkspaceRel)) {
             continue
           }
         }
-        if (!shouldIncludePath(filepath)) {
-          continue
-        }
         const normalizedFile = normalizePath(filepath)
         const absolutePath = path.join(dir, filepath)
         let stats
@@ -2774,12 +2547,15 @@ class Server {
   async computeWorkspaceGitStatus(workspaceName) {
     const workspacePath = this.kernel.path("api", workspaceName)
     const repos = await this.kernel.git.repos(workspacePath)
+    const gitIgnoreContext = this.workspaceStatus && typeof this.workspaceStatus.createPathScopedGitIgnoreContext === 'function'
+      ? this.workspaceStatus.createPathScopedGitIgnoreContext(workspacePath)
+      : null
 
     const statuses = []
     for (const repo of repos) {
       const repoParam = repo.gitParentRelPath || workspaceName
       try {
-        const { changes, git_commit_url, git_history_url, git_fork_url, git_push_url } = await this.getRepoHeadStatus(repoParam)
+        const { changes, git_commit_url, git_history_url, git_fork_url, git_push_url } = await this.getRepoHeadStatus(repoParam, { gitIgnoreContext })
         const historyUrl = git_history_url || (repoParam ? `/info/git/HEAD/${repoParam}` : `/info/git/HEAD/${workspaceName}`)
         statuses.push({
           name: repo.name,
@@ -3320,6 +3096,7 @@ class Server {
           const result = {
             portal: this.portal,
             projectName: (pathComponents.length > 0 ? pathComponents[0] : ''),
+            name: (pathComponents.length > 0 ? pathComponents[0] : ''),
             protection_app_id: protectionAppId,
             protection_enabled: protectionPreference ? protectionPreference.protection_enabled !== false : false,
             active_process_wait: activeProcessWait ? {
@@ -3371,6 +3148,9 @@ class Server {
             taskSaveWorkspacesRoot: this.kernel.path("workspaces"),
             script_id: (req.base ? `${full_filepath}?cwd=${req.query.cwd}` : null),
             script_path: (req.base ? full_filepath : null),
+            launch_requirements_status_enabled: this.kernel && typeof this.kernel.hasLaunchRequirementConfig === "function"
+              ? await this.kernel.hasLaunchRequirementConfig(filepath)
+              : false,
           }
 
           res.render(template, result)
@@ -3596,6 +3376,9 @@ class Server {
 
 
         let index = 0
+        const homeStartupDisplayGraph = !this.kernel.launch_complete
+          ? await this.autolaunch.buildHomeStartupDisplayGraph()
+          : null
         for(let i=0; i<items.length; i++) {
           let item = items[i]
           let launcher = await this.kernel.api.launcher(item.name)
@@ -3793,7 +3576,14 @@ class Server {
                 if (this.is_subpath(api_path, key)) {
                   // scripts inside api folder
                   if (this.is_subpath(p, key)) {
-                    items[i].running_scripts.push({ path: path.relative(this.kernel.homedir, key), name: path.relative(p, key) })
+                    const progress = this.kernel && typeof this.kernel.getScriptProgress === "function"
+                      ? this.kernel.getScriptProgress(key)
+                      : null
+                    items[i].running_scripts.push({
+                      path: path.relative(this.kernel.homedir, key),
+                      name: path.relative(p, key),
+                      ...(progress || {})
+                    })
                   }
                 } else {
                   // other global scripts
@@ -3810,6 +3600,14 @@ class Server {
             }
           }
           items[i].terminal_online_count = userTerminalShellMatches.length + pluginTerminalRunCount
+          if (items[i].running && !this.kernel.launch_complete) {
+            const status = this.kernel.autolaunch_status && this.kernel.autolaunch_status.apps
+              ? this.kernel.autolaunch_status.apps[items[i].name]
+              : null
+            if (status && !["ready", "blocked"].includes(status.state || "")) {
+              await this.autolaunch.applyHomeStartingState(items[i], items[i].index, homeStartupDisplayGraph)
+            }
+          }
           if (!items[i].running && shellMatches && shellMatches.length > 0) {
             running.push(items[i])
             items[i].running = true
@@ -3818,9 +3616,14 @@ class Server {
             index++
           }
           if (!items[i].running) {
-            items[i].index = index
-            index++;
-            notRunning.push(items[i])
+            if (await this.autolaunch.applyHomeStartingState(items[i], index, homeStartupDisplayGraph)) {
+              running.push(items[i])
+              index++
+            } else {
+              items[i].index = index
+              index++;
+              notRunning.push(items[i])
+            }
           }
         }
       }
@@ -6346,7 +6149,6 @@ class Server {
         let str = await Environment.ENV("system", this.kernel.homedir, this.kernel)
         await fs.promises.writeFile(path.resolve(this.kernel.homedir, "ENVIRONMENT"), str)
       }
-      this.workspaceStatus.ensureWatcher('api', this.kernel.path('api')).catch(() => {})
     }
 
 
@@ -6613,88 +6415,64 @@ class Server {
       }
     })
     */
-    this.app.get("/autolaunch/candidates", ex(async (req, res) => {
-      const app = await this.getAutolaunchAppById(req.query.app)
-      if (!app) {
-        res.status(404).json({ ok: false, error: "App not found." })
-        return
-      }
-      const state = await this.buildAutolaunchCandidates(app)
-      res.json({ ok: true, ...state })
+    this.autolaunch.registerRoutes()
+    this.app.get("/pinokio/launch-requirements/:app", ex(async (req, res) => {
+      const appId = this.kernel && typeof this.kernel.normalizeAppId === "function"
+        ? this.kernel.normalizeAppId(req.params.app)
+        : ""
+      const status = this.kernel && typeof this.kernel.getLaunchRequirementsStatus === "function"
+        ? this.kernel.getLaunchRequirementsStatus(appId || req.params.app)
+        : null
+      res.json({
+        ok: true,
+        status
+      })
     }))
-    this.app.post("/autolaunch", ex(async (req, res) => {
-      const app = await this.getAutolaunchAppById(req.body && req.body.app)
-      if (!app) {
-        res.status(404).json({ ok: false, error: "App not found." })
+    this.app.post("/pinokio/launch-requirements/:app/cancel", ex(async (req, res) => {
+      const appId = this.kernel && typeof this.kernel.normalizeAppId === "function"
+        ? this.kernel.normalizeAppId(req.params.app)
+        : ""
+      if (!appId) {
+        res.status(400).json({ ok: false, error: "Invalid app." })
         return
       }
-      const requestedScript = typeof req.body.script === "string" ? req.body.script.trim() : ""
-      if (!requestedScript) {
-        const envInfo = await this.getAutolaunchEnvInfo(app)
-        if (envInfo.exists) {
-          await Util.update_env(envInfo.envPath, {
-            PINOKIO_SCRIPT_AUTOLAUNCH: ""
+      const status = this.kernel && typeof this.kernel.getLaunchRequirementsStatus === "function"
+        ? this.kernel.getLaunchRequirementsStatus(appId)
+        : null
+      let script = status && typeof status.script === "string" ? status.script.trim() : ""
+      if (!script) {
+        const appRoot = this.kernel.path("api", appId)
+        const env = await Environment.get(appRoot, this.kernel).catch(() => ({}))
+        script = Environment.getScriptAutolaunch(env)
+      }
+      const launchPath = script ? path.resolve(this.kernel.path("api", appId), script) : ""
+      const cancelled = !!(launchPath && this.kernel.launchRequirements && typeof this.kernel.launchRequirements.cancel === "function" && this.kernel.launchRequirements.cancel(launchPath, { force: true }))
+      const running = this.kernel && this.kernel.api && this.kernel.api.running ? this.kernel.api.running : {}
+      const runningKeys = launchPath
+        ? Object.keys(running).filter((key) => {
+            const value = String(key || "")
+            return value === launchPath || value.startsWith(`${launchPath}?`) || value.startsWith(`${launchPath}&`)
           })
+        : []
+      for (const key of runningKeys) {
+        if (this.kernel && this.kernel.api && typeof this.kernel.api.stop === "function") {
+          await this.kernel.api.stop({ params: { id: key } })
         }
-        res.json({
-          ok: true,
-          app: await this.buildAutolaunchAppState(app)
-        })
-        return
       }
-
-      const envInfo = await this.getAutolaunchEnvInfo(app)
-      const resolved = await this.resolveAutolaunchScript(envInfo.appRoot, requestedScript)
-      if (!resolved) {
-        res.status(400).json({
-          ok: false,
-          error: "Select an existing local script inside the app."
+      if ((cancelled || runningKeys.length > 0) && this.kernel && this.kernel.api && typeof this.kernel.api.ondata === "function") {
+        this.kernel.api.ondata({
+          id: launchPath,
+          type: "launch.requirements.control",
+          data: {
+            action: "cancelled",
+            app_id: appId
+          }
         })
-        return
       }
-      const initialized = await Environment.init({ name: app.id }, this.kernel)
-      await Util.update_env(initialized.env_path, {
-        PINOKIO_SCRIPT_AUTOLAUNCH: resolved.script
-      })
       res.json({
         ok: true,
-        app: await this.buildAutolaunchAppState(app)
-      })
-    }))
-    this.app.post("/autolaunch/disable-all", ex(async (req, res) => {
-      const apps = await this.kernel.api.listApps()
-      let disabled = 0
-      for (const app of apps) {
-        const envInfo = await this.getAutolaunchEnvInfo(app)
-        if (envInfo.exists && envInfo.value) {
-          await Util.update_env(envInfo.envPath, {
-            PINOKIO_SCRIPT_AUTOLAUNCH: ""
-          })
-          disabled++
-        }
-      }
-      res.json({
-        ok: true,
-        disabled,
-        apps: await this.buildAutolaunchAppsState()
-      })
-    }))
-    this.app.get("/autolaunch", ex(async (req, res) => {
-      const peerAccess = await this.composePeerAccessPayload()
-      const list = this.getPeers()
-      const apps = await this.buildAutolaunchAppsState()
-      const appsJson = JSON.stringify(apps).replace(/</g, "\\u003c")
-      res.render("autolaunch", {
-        current_host: this.kernel.peer.host,
-        ...peerAccess,
-        apps,
-        appsJson,
-        enabledCount: apps.filter((app) => app.autolaunch_enabled).length,
-        portal: this.portal,
-        logo: this.logo,
-        theme: this.theme,
-        agent: req.agent,
-        list,
+        cancelled,
+        stopped: runningKeys.length > 0
       })
     }))
     this.app.get("/tools", ex(async (req, res) => {
@@ -7230,6 +7008,7 @@ class Server {
           res.json({ ok: false, error: err && err.message ? err.message : 'Clone failed' })
           return
         }
+        await this.refreshTopLevelAppInventory()
         res.json({ ok: true, redirect: `/p/${encodeURIComponent(folder)}` })
         return
       }
@@ -7258,6 +7037,7 @@ class Server {
       if (this.kernel.git && this.kernel.git.activeSnapshot) {
         this.kernel.git.activeSnapshot[folder] = { id: snapshot.id, remoteKey }
       }
+      await this.refreshTopLevelAppInventory()
       res.json({ ok: true, redirect: `/p/${encodeURIComponent(folder)}` })
     }))
     this.app.post("/checkpoints/delete", ex(async (req, res) => {
@@ -10929,6 +10709,9 @@ class Server {
             tool: selectedTool,
             uploadToken: ""
           })
+          if (payload && payload.ok) {
+            await this.refreshTopLevelAppInventory()
+          }
           res.redirect(payload.url)
         } catch (error) {
           await renderTaskLaunchPage(req, res, task, {
@@ -11217,6 +11000,7 @@ class Server {
         return
       }
 
+      await this.refreshTopLevelAppInventory()
       res.json({
         ok: true,
         folder: folderName,
@@ -11532,6 +11316,7 @@ class Server {
         })
 
         if (intent === "create_app") {
+          await this.refreshTopLevelAppInventory()
           res.json({
             ok: true,
             url: `/initialize/${encodeURIComponent(requestedFolderName)}`
@@ -11581,6 +11366,10 @@ class Server {
           name: typeof body.name === "string" ? body.name : "",
           id: typeof body.id === "string" ? body.id : ""
         })
+        const intent = typeof body.intent === "string" ? body.intent.trim().toLowerCase() : ""
+        if (intent === "create_app") {
+          await this.refreshTopLevelAppInventory()
+        }
         res.json({
           ok: true,
           ...finalized
@@ -11602,6 +11391,9 @@ class Server {
           tool: body.tool,
           uploadToken: body.uploadToken
         })
+        if (payload && payload.ok) {
+          await this.refreshTopLevelAppInventory()
+        }
         res.json(payload)
       } catch (error) {
         const status = Number.isInteger(error && error.status) ? error.status : 500
@@ -14614,16 +14406,10 @@ class Server {
     }))
     this.app.get("/gitdiff/:ref/*", ex(async (req, res) => {
       let fullpath = this.kernel.path("api", req.params[0])
-      let dir
-      let dirs = Array.from(this.kernel.git.dirs)
-      dirs.sort((x, y) => {
-        return y.length - x.length
-      })
-      for(let d of dirs) {
-        if (fullpath.startsWith(d)) {
-          dir = d
-          break
-        }
+      let dir = await this.kernel.git.findRepoRootForPath(fullpath)
+      if (!dir) {
+        res.status(404).json({ error: "Repository not found" })
+        return
       }
       let filepath = path.relative(dir, fullpath)
       let binary = false;
@@ -15686,7 +15472,7 @@ class Server {
     }))
     this.app.get("/info/api", ex(async (req,res) => {
       // api related info
-      let repo = this.kernel.git.find(req.query.git)
+      let repo = await this.findApiRepoByGitUrl(req.query.git)
       if (repo) {
         let repos = await this.kernel.git.repos(repo.path)
         repos = repos.filter((r) => {
@@ -15876,6 +15662,7 @@ class Server {
               resolve()
             }, 2000)
           })
+          await this.refreshTopLevelAppInventory()
           res.json({ success: true })
         }
       } catch(err) {
@@ -15974,6 +15761,43 @@ class Server {
       delete info.memory
       res.json(info)
     }))
+    this.app.get("/pinokio/home_status", ex((req, res) => {
+      const runningMap = this.kernel && this.kernel.api && this.kernel.api.running
+        ? this.kernel.api.running
+        : {}
+      const apiRoot = this.kernel.path("api")
+      const runningApps = new Set()
+      const runningScripts = []
+      for (const key of Object.keys(runningMap)) {
+        if (typeof key !== "string" || !path.isAbsolute(key) || !this.is_subpath(apiRoot, key)) {
+          continue
+        }
+        const relativePath = path.relative(apiRoot, key)
+        if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+          continue
+        }
+        const app = relativePath.split(path.sep)[0]
+        if (!app) {
+          continue
+        }
+        runningApps.add(app)
+        runningScripts.push({
+          id: key,
+          app,
+          path: relativePath,
+          home_path: path.relative(this.kernel.homedir, key),
+          script_path: path.relative(path.resolve(apiRoot, app), key),
+          ...((this.kernel && typeof this.kernel.getScriptProgress === "function" && this.kernel.getScriptProgress(key)) || {})
+        })
+      }
+      res.json({
+        launch_complete: this.kernel.launch_complete,
+        running_apps: Array.from(runningApps),
+        running_scripts: runningScripts,
+        autolaunch: this.kernel.autolaunch_status || { apps: {} },
+        startup: this.getStartupStatus()
+      })
+    }))
     this.app.get("/pinokio/home", ex((req, res) => {
       res.json({
         path: this.kernel.homedir ? path.resolve(this.kernel.homedir) : null
@@ -16123,6 +15947,7 @@ class Server {
         */
 
         let formData = req.body
+        let appInventoryChanged = false
         for(let key in req.files) {
           let file = req.files[key]
           formData[file.fieldname] = file.buffer
@@ -16137,6 +15962,7 @@ class Server {
               let new_path = this.kernel.path("api", formData.new_path)
 
               await fs.promises.cp(old_path, new_path, { recursive: true })
+              appInventoryChanged = true
 
               // 2. edit meta in the new_path
               await this.kernel.api.updateMeta(formData, formData.new_path)
@@ -16149,6 +15975,7 @@ class Server {
               let old_path = this.kernel.path("api", formData.old_path)
               let new_path = this.kernel.path("api", formData.new_path)
               await fs.promises.rename(old_path, new_path)
+              appInventoryChanged = true
             }
 
             // 2. edit meta in the new_path
@@ -16165,15 +15992,20 @@ class Server {
             let old_path = this.kernel.path("api", formData.old_path)
             let new_path = this.kernel.path("api", formData.new_path)
             await fs.promises.cp(old_path, new_path, { recursive: true })
+            appInventoryChanged = true
           } else if (formData.move) {
             // 2. move only
             let old_path = this.kernel.path("api", formData.old_path)
             let new_path = this.kernel.path("api", formData.new_path)
             await fs.promises.rename(old_path, new_path)
+            appInventoryChanged = true
           } else {
             // nothing
           }
         }
+        if (appInventoryChanged) {
+          await this.refreshTopLevelAppInventory()
+        }
         res.json({
           success: true,
           reload: formData.new_path,
@@ -16403,6 +16235,7 @@ class Server {
                 path: this.kernel.api.userdir
               }, (stream) => {
               })
+              await this.refreshTopLevelAppInventory()
               res.json({
                 result: "success"
               })