pinokiod 5.1.5 → 5.1.11

package/kernel/util.js

@@ -195,8 +195,6 @@ const filepicker = async(req, ondata, kernel) => {
       return [type, extensions]
     })
   }
-  console.log("Filetype", req.params.filetype)
-  console.log("Filetypes", req.params.filetypes)
   let response = await new Promise((resolve, reject) => {
     let picker_path = kernel.path("bin/py/picker.py")
     let python
@@ -205,7 +203,6 @@ const filepicker = async(req, ondata, kernel) => {
     } else {
       python = kernel.path("bin/miniconda/bin/python")
     }
-    console.log("run python", { python, picker_path })
     const proc = spawn(python, [picker_path])
 
     let output = "";
@@ -346,6 +343,10 @@ const parse_env = async (filename) => {
 
     return config
   } catch (e) {
+    if (e && e.code === "ENOENT") {
+      // Missing env files are expected on first run; treat as empty without warning
+      return {}
+    }
     console.warn(`[parse_env] failed to read/parse ${filename}: ${e.message}`)
     return {}
   }
@@ -395,16 +396,26 @@ const run = (cmd, cwd, kernel) => {
 //  console.log("Util.run", { cmd, cwd })
 //  child_process.exec(cmd, { cwd })
   if (kernel) {
-    kernel.exec({
-      message: cmd,
-      path: cwd
-    }, (e) => {
-      process.stdout.write(e.raw)
-    }).then(() => {
-      console.log("DONE")
-    })
+    try {
+      kernel.exec({
+        message: cmd,
+        path: cwd
+      }, (e) => {
+        process.stdout.write(e.raw)
+      }).then(() => {
+        console.log("DONE")
+      }).catch((err) => {
+        console.warn('[Util.run] kernel.exec failed:', err && err.message ? err.message : err)
+      })
+    } catch (err) {
+      console.warn('[Util.run] spawn failed:', err && err.message ? err.message : err)
+    }
   } else {
-    child_process.exec(command)
+    try {
+      child_process.exec(cmd)
+    } catch (err) {
+      console.warn('[Util.run] exec failed:', err && err.message ? err.message : err)
+    }
   }
 }
 const openURL = (url) => {
@@ -417,7 +428,11 @@ const openURL = (url) => {
   } else {
     command = `xdg-open "${url}"`; // Linux
   }
-  child_process.exec(command);
+  try {
+    child_process.exec(command);
+  } catch (err) {
+    console.warn('[Util.openURL] exec failed:', err && err.message ? err.message : err)
+  }
 }
 const openfs = (dirPath, options, kernel) => {
   let command = '';
@@ -443,7 +458,11 @@ const openfs = (dirPath, options, kernel) => {
           command = `xdg-open "${dirPath}"`;
           break;
       }
-      child_process.exec(command)
+      try {
+        child_process.exec(command)
+      } catch (err) {
+        console.warn('[Util.openfs] exec(view) failed:', err && err.message ? err.message : err)
+      }
     } else if (mode === "open") {
       switch (platform) {
         case 'darwin':
@@ -456,20 +475,34 @@ const openfs = (dirPath, options, kernel) => {
           command = `xdg-open "${dirPath}"`;
           break;
       }
-      child_process.exec(command)
+      try {
+        child_process.exec(command)
+      } catch (err) {
+        console.warn('[Util.openfs] exec(open) failed:', err && err.message ? err.message : err)
+      }
     } else {
       command = `${mode} "${dirPath}"`
       console.log("> command", command)
       if (kernel) {
-        kernel.exec({
-          message: command,
-        }, (e) => {
-          process.stdout.write(e.raw)
-        }).then(() => {
-          console.log("DONE")
-        })
+        try {
+          kernel.exec({
+            message: command,
+          }, (e) => {
+            process.stdout.write(e.raw)
+          }).then(() => {
+            console.log("DONE")
+          }).catch((err) => {
+            console.warn('[Util.openfs] kernel.exec(custom) failed:', err && err.message ? err.message : err)
+          })
+        } catch (err) {
+          console.warn('[Util.openfs] spawn(custom) failed:', err && err.message ? err.message : err)
+        }
       } else {
-        child_process.exec(command)
+        try {
+          child_process.exec(command)
+        } catch (err) {
+          console.warn('[Util.openfs] exec(custom) failed:', err && err.message ? err.message : err)
+        }
       }
     }
   } else {
@@ -502,7 +535,11 @@ const openfs = (dirPath, options, kernel) => {
           break;
       }
     }
-    child_process.exec(command)
+    try {
+      child_process.exec(command)
+    } catch (err) {
+      console.warn('[Util.openfs] exec(default) failed:', err && err.message ? err.message : err)
+    }
   }
 }
 const parse_env_detail = async (filename) => {

package/kernel/workspace_status.js

@@ -1,4 +1,7 @@
 const ParcelWatcher = require('@parcel/watcher')
+const fs = require('fs')
+const path = require('path')
+const ignore = require('ignore')
 
 class WorkspaceStatusManager {
   constructor(options = {}) {
@@ -6,6 +9,8 @@ class WorkspaceStatusManager {
     this.fallbackIntervalMs = typeof options.fallbackIntervalMs === 'number' ? options.fallbackIntervalMs : 60000
     this.cache = new Map()
     this.watchers = new Map()
+    this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : null
+    this.gitIgnoreEngines = new Map()
     this.defaultIgnores = options.ignores && Array.isArray(options.ignores) ? options.ignores : [
       '**/.git/**',
       '**/node_modules/**',
@@ -26,6 +31,76 @@ class WorkspaceStatusManager {
     ]
   }
 
+  async ensureGitIgnoreEngine(workspaceName, workspaceRoot) {
+    if (!workspaceRoot) {
+      return
+    }
+    if (this.gitIgnoreEngines.has(workspaceName)) {
+      return
+    }
+    const ig = ignore()
+    const gitignoreFiles = []
+
+    const walk = async (dir) => {
+      let entries
+      try {
+        entries = await fs.promises.readdir(dir, { withFileTypes: true })
+      } catch (error) {
+        return
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === 'venv' || entry.name === '.venv') {
+            continue
+          }
+          await walk(path.join(dir, entry.name))
+        } else if (entry.isFile() && entry.name === '.gitignore') {
+          gitignoreFiles.push(path.join(dir, entry.name))
+        }
+      }
+    }
+
+    try {
+      await walk(workspaceRoot)
+    } catch (error) {
+      console.warn('workspace gitignore scan failed', workspaceName, error && error.message ? error.message : error)
+    }
+
+    for (const gitignorePath of gitignoreFiles) {
+      let content
+      try {
+        content = await fs.promises.readFile(gitignorePath, 'utf8')
+      } 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.gitIgnoreEngines.set(workspaceName, ig)
+  }
+
   markDirty(workspaceName) {
     let entry = this.cache.get(workspaceName)
     if (!entry) {
@@ -44,6 +119,7 @@ class WorkspaceStatusManager {
       return
     }
     try {
+      await this.ensureGitIgnoreEngine(workspaceName, workspaceRoot)
       const subscription = await ParcelWatcher.subscribe(
         workspaceRoot,
         (error, events) => {
@@ -51,9 +127,35 @@ class WorkspaceStatusManager {
             console.warn('workspace watcher error', workspaceName, error)
             return
           }
-          if (events && events.length > 0) {
-            console.log("Events", events)
-            this.markDirty(workspaceName)
+          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)
+            } catch (err) {
+              console.warn('workspace watcher callback error', workspaceName, err && err.message ? err.message : err)
+            }
           }
         },
         { ignore: this.defaultIgnores }
@@ -81,15 +183,37 @@ class WorkspaceStatusManager {
       entry.dirty = true
     }
 
+    if (this.enableWatchers && workspaceRoot) {
+      await this.ensureWatcher(workspaceName, workspaceRoot)
+    }
+
     if (!entry.dirty && entry.data) {
       return entry.data
     }
-    if (entry.inflight) {
-      return entry.inflight
+
+    if (entry.dirty && entry.data) {
+      if (!entry.inflight) {
+        entry.inflight = (async () => {
+          try {
+            const data = await computeStatusFn()
+            entry.data = data
+            entry.dirty = false
+            entry.updatedAt = Date.now()
+          } catch (error) {
+            console.warn('workspace status background compute failed', workspaceName, error && error.message ? error.message : error)
+          } finally {
+            entry.inflight = null
+          }
+        })()
+      }
+      return entry.data
     }
 
-    if (this.enableWatchers && workspaceRoot) {
-      await this.ensureWatcher(workspaceName, workspaceRoot)
+    if (entry.inflight) {
+      if (entry.data) {
+        return entry.data
+      }
+      return entry.inflight
     }
 
     entry.inflight = (async () => {

package/package.json

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

package/pipe/index.js

@@ -77,7 +77,7 @@ class Pipe {
           }
         })
         req.session.authenticated = true;
-        res.redirect('/');
+        res.redirect('/home');
       } else {
         res.status(401).render("login", { error: "Invalid passcode", ...config })
       }