pinokiod 7.3.15 → 7.4.0

package/kernel/ready.js

@@ -0,0 +1,231 @@
+const path = require('path')
+
+class ReadyState {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.status = {
+      apps: {}
+    }
+  }
+  normalizeAppId(value) {
+    if (typeof value !== "string") {
+      return ""
+    }
+    const id = value.trim()
+    if (!id || id === "." || id === ".." || id.includes("\0") || /[\\/]/.test(id)) {
+      return ""
+    }
+    return id
+  }
+  getAppIdForLaunchPath(launchPath) {
+    if (!launchPath || typeof launchPath !== "string" || !path.isAbsolute(launchPath)) {
+      return ""
+    }
+    const apiRoot = this.kernel.path("api")
+    const relative = path.relative(apiRoot, launchPath)
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+      return ""
+    }
+    return this.normalizeAppId(relative.split(path.sep)[0])
+  }
+  getAppRelativeLaunchScript(appId, launchPath) {
+    const id = this.normalizeAppId(appId)
+    if (!id || !launchPath || typeof launchPath !== "string" || !path.isAbsolute(launchPath)) {
+      return ""
+    }
+    const appRoot = path.resolve(this.kernel.path("api"), id)
+    const relative = path.relative(appRoot, launchPath)
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+      return ""
+    }
+    return relative.split(path.sep).join("/")
+  }
+  resolveScriptPath(uri, cwd) {
+    if (typeof uri !== "string" || !uri.trim() || !this.kernel.api) {
+      return ""
+    }
+    try {
+      return this.kernel.api.filePath(uri.trim(), cwd)
+    } catch (e) {
+      return ""
+    }
+  }
+  isScriptReady(scriptPath) {
+    if (!scriptPath || typeof scriptPath !== "string") {
+      return false
+    }
+    const resolved = path.resolve(scriptPath)
+    const appId = this.getAppIdForLaunchPath(resolved)
+    if (!appId) {
+      return false
+    }
+    const status = this.status && this.status.apps
+      ? this.status.apps[appId]
+      : null
+    if (!status) {
+      return false
+    }
+    const script = this.getAppRelativeLaunchScript(appId, resolved)
+    const scriptStatus = status.scripts ? status.scripts[script] : null
+    if (scriptStatus) {
+      return scriptStatus.state === "ready"
+    }
+    return status.state === "ready" && (!status.script || status.script === script)
+  }
+  ready(requestOrUri) {
+    if (typeof requestOrUri === "string") {
+      return this.isScriptReady(this.resolveScriptPath(requestOrUri))
+    }
+    const params = requestOrUri && requestOrUri.params
+    const parent = requestOrUri && requestOrUri.parent && typeof requestOrUri.parent === "object"
+      ? requestOrUri.parent
+      : null
+    let uri = ""
+    if (typeof params === "string") {
+      uri = params
+    } else if (params && typeof params === "object") {
+      uri = params.uri || params.path || params.script || ""
+    } else if (parent && parent.path) {
+      uri = parent.path
+    }
+    return this.isScriptReady(this.resolveScriptPath(uri, requestOrUri && requestOrUri.cwd))
+  }
+  getScriptProgress(scriptPath) {
+    if (!scriptPath || typeof scriptPath !== "string") {
+      return null
+    }
+    const resolved = path.resolve(scriptPath)
+    const rpc = this.kernel.memory && this.kernel.memory.rpc
+      ? this.kernel.memory.rpc[resolved]
+      : null
+    if (!rpc || typeof rpc !== "object") {
+      return null
+    }
+    const current = Number(rpc.current)
+    const total = Number(rpc.total)
+    if (!Number.isInteger(current) || !Number.isInteger(total) || total <= 0) {
+      return null
+    }
+    return {
+      step_current: Math.max(1, current + 1),
+      step_total: total
+    }
+  }
+  stripProgress(record = {}) {
+    const next = { ...record }
+    delete next.step_current
+    delete next.step_total
+    return next
+  }
+  clearScriptProgress(launchPath) {
+    if (!launchPath || typeof launchPath !== "string") {
+      return
+    }
+    const resolved = path.resolve(launchPath)
+    const rpc = this.kernel.memory && this.kernel.memory.rpc
+      ? this.kernel.memory.rpc[resolved]
+      : null
+    if (rpc && typeof rpc === "object") {
+      delete rpc.current
+      delete rpc.total
+    }
+  }
+  writeScriptProgress(launchPath, current, total) {
+    if (!launchPath || typeof launchPath !== "string") {
+      return
+    }
+    if (!this.kernel.memory) {
+      this.kernel.memory = {}
+    }
+    if (!this.kernel.memory.rpc) {
+      this.kernel.memory.rpc = {}
+    }
+    const resolved = path.resolve(launchPath)
+    this.kernel.memory.rpc[resolved] = {
+      ...(this.kernel.memory.rpc[resolved] || {}),
+      current,
+      total
+    }
+  }
+  updateLaunchStatus(launchPath, state, details) {
+    const appId = this.getAppIdForLaunchPath(launchPath)
+    if (!appId) {
+      return
+    }
+    const script = this.getAppRelativeLaunchScript(appId, launchPath)
+    const current = this.status.apps[appId] || { id: appId, scripts: {} }
+    const scripts = { ...(current.scripts || {}) }
+    const hasProgress = Object.prototype.hasOwnProperty.call(details || {}, "step_current")
+      || Object.prototype.hasOwnProperty.call(details || {}, "step_total")
+    if (script) {
+      scripts[script] = {
+        ...(hasProgress ? (scripts[script] || { script }) : this.stripProgress(scripts[script] || { script })),
+        script,
+        state,
+        ...details
+      }
+    }
+    this.status.apps[appId] = {
+      ...(hasProgress ? current : this.stripProgress(current)),
+      id: appId,
+      state,
+      script: script || current.script,
+      ...details,
+      scripts
+    }
+  }
+  markStarted(launchPath) {
+    this.clearScriptProgress(launchPath)
+    this.updateLaunchStatus(launchPath, "starting", {
+      started_at: Date.now()
+    })
+  }
+  markProgress(launchPath, current, total) {
+    const stepCurrent = Number(current)
+    const stepTotal = Number(total)
+    if (!Number.isInteger(stepCurrent) || !Number.isInteger(stepTotal) || stepTotal <= 0) {
+      return null
+    }
+    const progress = {
+      step_current: Math.max(1, stepCurrent + 1),
+      step_total: stepTotal
+    }
+    this.writeScriptProgress(launchPath, stepCurrent, stepTotal)
+    this.updateLaunchStatus(launchPath, "starting", progress)
+    return progress
+  }
+  markReady(launchPath) {
+    this.clearScriptProgress(launchPath)
+    this.updateLaunchStatus(launchPath, "ready", {
+      ready_at: Date.now()
+    })
+  }
+  markFailed(launchPath, error) {
+    this.clearScriptProgress(launchPath)
+    this.updateLaunchStatus(launchPath, "failed", {
+      error: error && error.message ? error.message : String(error || "Launch failed"),
+      failed_at: Date.now()
+    })
+  }
+  markStopped(launchPath) {
+    this.clearScriptProgress(launchPath)
+    this.updateLaunchStatus(launchPath, "stopped", {
+      stopped_at: Date.now()
+    })
+  }
+  isAppReady(appId) {
+    const dependencyId = this.normalizeAppId(appId)
+    const status = this.status && this.status.apps
+      ? this.status.apps[dependencyId]
+      : null
+    if (!status) {
+      return false
+    }
+    if (status.scripts && Object.values(status.scripts).some((script) => script && script.state === "ready")) {
+      return true
+    }
+    return status.state === "ready"
+  }
+}
+
+module.exports = ReadyState

package/kernel/script.js

@@ -39,6 +39,22 @@ class Script {
       return false
     }
   }
+  // script.ready('https://github.com/cocktailpeanutlabs/comfyui.git/start.json')
+  // script.ready('~/api/comfyui.git/start.json')
+  // script.ready(cwd, 'start.json')
+  ready(...chunks) {
+    let id
+    try {
+      id = this.resolve(...chunks)
+    } catch (e) {
+      return false
+    }
+    if (id) {
+      return this.kernel.isScriptReady(id)
+    } else {
+      return false
+    }
+  }
   // script.local('https://github.com/cocktailpeanutlabs/comfyui.git/start.json')
   // script.local('~/api/comfyui.git/start.json')
   // script.local(cwd, 'start.json')

package/kernel/shells.js

@@ -235,7 +235,15 @@ class Shells {
         if (segments.length > 0) {
           workspaceName = segments[0]
           workspaceRoot = this.kernel.path("api", workspaceName)
-          beforeDirs = new Set(this.kernel.git.dirs)
+          beforeDirs = new Set()
+          try {
+            const beforeRepos = await this.kernel.git.repos(workspaceRoot)
+            for (const repo of beforeRepos) {
+              if (repo && repo.gitParentPath) {
+                beforeDirs.add(repo.gitParentPath)
+              }
+            }
+          } catch (_) {}
         }
       }
     }

package/kernel/workspace_status.js

@@ -11,6 +11,7 @@ class WorkspaceStatusManager {
     this.watchers = new Map()
     this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : null
     this.gitIgnoreEngines = new Map()
+    this.gitIgnoreScanSkipDirs = new Set(['.git', 'node_modules', 'venv', '.venv'])
     this.defaultIgnores = options.ignores && Array.isArray(options.ignores) ? options.ignores : [
       '**/.git/**',
       '**/node_modules/**',
@@ -50,7 +51,7 @@ class WorkspaceStatusManager {
       }
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === 'venv' || entry.name === '.venv') {
+          if (this.gitIgnoreScanSkipDirs.has(entry.name)) {
             continue
           }
           await walk(path.join(dir, entry.name))
@@ -73,34 +74,119 @@ class WorkspaceStatusManager {
       } catch (_) {
         continue
       }
-      const relDir = path.relative(workspaceRoot, path.dirname(gitignorePath))
-      const prefix = relDir && relDir !== '.' ? relDir.split(path.sep).join('/') + '/' : ''
-      const lines = content.split(/\r?\n/)
-      for (let line of lines) {
-        if (!line) continue
-        line = line.trim()
-        if (!line || line.startsWith('#')) continue
-        let negated = false
-        if (line.startsWith('!')) {
-          negated = true
-          line = line.slice(1)
-        }
-        if (!line) continue
-        line = line.replace(/^\/+/, '')
-        if (!line) continue
-        const pattern = prefix + line
-        if (!pattern) continue
-        if (negated) {
-          ig.add('!' + pattern)
-        } else {
-          ig.add(pattern)
-        }
-      }
+      this.addGitIgnoreContent(ig, workspaceRoot, gitignorePath, content)
     }
 
     this.gitIgnoreEngines.set(workspaceName, ig)
   }
 
+  normalizeGitIgnorePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/\/+/g, '/')
+  }
+
+  addGitIgnoreContent(engine, workspaceRoot, gitignorePath, content) {
+    const relDir = path.relative(workspaceRoot, path.dirname(gitignorePath))
+    const prefix = relDir && relDir !== '.' ? this.normalizeGitIgnorePath(relDir) + '/' : ''
+    const lines = String(content || '').split(/\r?\n/)
+    for (let line of lines) {
+      if (!line) continue
+      line = line.trim()
+      if (!line || line.startsWith('#')) continue
+      let negated = false
+      if (line.startsWith('!')) {
+        negated = true
+        line = line.slice(1)
+      }
+      if (!line) continue
+      line = line.replace(/^\/+/, '')
+      if (!line) continue
+      const pattern = prefix + line
+      if (!pattern) continue
+      engine.add((negated ? '!' : '') + pattern)
+    }
+  }
+
+  createPathScopedGitIgnoreContext(workspaceRoot) {
+    return {
+      workspaceRoot,
+      contentCache: new Map(),
+      engineCache: new Map(),
+    }
+  }
+
+  async readPathScopedGitIgnore(context, gitignorePath) {
+    if (context.contentCache.has(gitignorePath)) {
+      return context.contentCache.get(gitignorePath)
+    }
+    try {
+      const content = await fs.promises.readFile(gitignorePath, 'utf8')
+      context.contentCache.set(gitignorePath, content)
+      return content
+    } catch (_) {
+      context.contentCache.set(gitignorePath, null)
+      return null
+    }
+  }
+
+  pathScopedGitIgnoreDirs(workspaceRelativePath) {
+    const normalized = this.normalizeGitIgnorePath(workspaceRelativePath)
+    const parts = normalized.split('/').filter(Boolean)
+    const dirs = []
+    for (let depth = 0; depth < parts.length; depth++) {
+      dirs.push(depth === 0 ? '' : parts.slice(0, depth).join('/'))
+      if (this.gitIgnoreScanSkipDirs.has(parts[depth])) {
+        break
+      }
+    }
+    return dirs
+  }
+
+  async pathScopedGitIgnoreEngine(context, workspaceRelativePath) {
+    if (!context || !context.workspaceRoot) {
+      return null
+    }
+    const dirs = this.pathScopedGitIgnoreDirs(workspaceRelativePath)
+    const cacheKey = dirs.join('\0')
+    if (context.engineCache.has(cacheKey)) {
+      return context.engineCache.get(cacheKey)
+    }
+    const engine = ignore()
+    for (const relDir of dirs) {
+      const gitignorePath = path.join(context.workspaceRoot, relDir, '.gitignore')
+      const content = await this.readPathScopedGitIgnore(context, gitignorePath)
+      if (content) {
+        this.addGitIgnoreContent(engine, context.workspaceRoot, gitignorePath, content)
+      }
+    }
+    context.engineCache.set(cacheKey, engine)
+    return engine
+  }
+
+  async isPathScopedGitIgnored(context, workspaceRelativePath) {
+    const normalized = this.normalizeGitIgnorePath(workspaceRelativePath)
+    if (!normalized) {
+      return false
+    }
+    const engine = await this.pathScopedGitIgnoreEngine(context, normalized)
+    return !!(engine && engine.ignores(normalized))
+  }
+
+  async filterPathScopedGitIgnored(contextOrWorkspaceRoot, records) {
+    const context = typeof contextOrWorkspaceRoot === 'string'
+      ? this.createPathScopedGitIgnoreContext(contextOrWorkspaceRoot)
+      : contextOrWorkspaceRoot
+    const ignored = new Set()
+    for (const record of records || []) {
+      if (!record || !record.key || !record.workspaceRelative) {
+        continue
+      }
+      if (await this.isPathScopedGitIgnored(context, record.workspaceRelative)) {
+        ignored.add(record.key)
+      }
+    }
+    return ignored
+  }
+
   markDirty(workspaceName) {
     let entry = this.cache.get(workspaceName)
     if (!entry) {
@@ -119,7 +205,6 @@ class WorkspaceStatusManager {
       return
     }
     try {
-      await this.ensureGitIgnoreEngine(workspaceName, workspaceRoot)
       const subscription = await ParcelWatcher.subscribe(
         workspaceRoot,
         (error, events) => {
@@ -130,29 +215,10 @@ class WorkspaceStatusManager {
           if (!events || events.length === 0) {
             return
           }
-          let relevantEvents = events
-          const engine = this.gitIgnoreEngines.get(workspaceName)
-          if (engine && workspaceRoot) {
-            const root = workspaceRoot
-            relevantEvents = events.filter((evt) => {
-              if (!evt || !evt.path) {
-                return true
-              }
-              let rel = path.relative(root, evt.path)
-              if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
-                return true
-              }
-              const normalized = rel.split(path.sep).join('/')
-              return !engine.ignores(normalized)
-            })
-          }
-          if (relevantEvents.length === 0) {
-            return
-          }
           this.markDirty(workspaceName)
           if (this.onEvent) {
             try {
-              this.onEvent(workspaceName, relevantEvents)
+              this.onEvent(workspaceName, events)
             } catch (err) {
               console.warn('workspace watcher callback error', workspaceName, err && err.message ? err.message : err)
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "7.3.15",
+  "version": "7.4.0",
   "description": "",
   "main": "index.js",
   "scripts": {