pinokiod 3.23.0 → 3.25.0

package/kernel/api/exec/index.js

@@ -0,0 +1,67 @@
+const child_process = require('child_process')
+module.exports = async (req, ondata, kernel) => {
+  /*
+    req := {
+      method: "exec",
+      params: {
+
+        // pinokio params
+        message: <message>,
+        path: <path>,
+
+        // node.js child_process.exec params
+
+        // Working directory
+        cwd: '/path/to/working/directory',
+        
+        // Environment variables
+        env: { ...process.env, CUSTOM_VAR: 'value' },
+        
+        // Encoding for stdout/stderr (default: 'utf8')
+        encoding: 'utf8', // or 'buffer', 'ascii', etc.
+        
+        // Shell to execute the command
+        shell: '/bin/bash', // default varies by platform
+        
+        // Timeout in milliseconds
+        timeout: 10000, // Kill process after 10 seconds
+        
+        // Maximum buffer size for stdout/stderr
+        maxBuffer: 1024 * 1024, // 1MB (default: 1024 * 1024)
+        
+        // Signal to send when killing due to timeout
+        killSignal: 'SIGTERM', // default: 'SIGTERM'
+        
+        // User identity (Unix only)
+        uid: 1000,
+        gid: 1000,
+        
+        // Windows-specific options
+        windowsHide: true, // Hide subprocess console window on Windows
+        windowsVerbatimArguments: false // Quote handling on Windows
+
+      }
+    }
+  */
+  if (req.params && req.params.message) {
+    // if cwd exists, use cwd
+    // if cwd doesn't exist, set pat
+    if (!req.params.cwd && req.params.path) {
+      req.params.cwd = req.params.path
+    }
+    req.params.env = Object.assign({}, kernel.envs, req.params.env)
+    console.log("env", JSON.stringify(req.params.env, null, 2))
+    ondata({ raw: `██ Exec: ${req.params.message}\r\n` })
+    let response = await new Promise((resolve, reject) => {
+      child_process.exec(req.params.message, req.params, (error, stdout, stderr) => {
+        resolve({
+          stdout,
+          error,
+          stderr
+        })
+      })
+    })
+    console.log({ response })
+    return response
+  }
+}

package/kernel/api/index.js

@@ -1176,6 +1176,7 @@ class Api {
 //        console.log("kernel.refresh after step")
 //        this.kernel.refresh(true)
       } catch (e) {
+        console.log("FUDKDFKSDFLJSDFHSDFLKHSDLFHSDFH", e)
         ondata({ raw: e.toString() })
       }
     }, concurrency)

package/kernel/plugin.js

@@ -1,25 +1,55 @@
 const path = require('path')
+const { glob } = require('glob')
+const Info = require("./info")
 class Plugin {
   constructor(kernel) {
     this.kernel = kernel
   }
+  async setConfig() {
+    let plugin_dir = path.resolve(this.kernel.homedir, "plugin")
+    this.cache = {}
+
+    let plugin_paths = await glob('**/pinokio.js', { cwd: plugin_dir })
+
+    let plugins = []
+    for(let plugin_path of plugin_paths) {
+      let config = await this.kernel.require(path.resolve(plugin_dir, plugin_path))
+      let cwd = plugin_path.split("/").slice(0, -1).join("/")
+      config.image = "/asset/plugin/" + cwd + "/" + config.icon 
+      plugins.push({
+        href: "/run/plugin/" + plugin_path,
+        ...config
+      })
+    }
+
+    this.config = {
+      menu: plugins.map((plugin) => {
+        plugin.text = plugin.title
+        return plugin
+      })
+    }
+  }
   async init() {
-    if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-      // if ~/pinokio/prototype doesn't exist, clone
-      let exists = await this.kernel.exists("plugin")
-      if (!exists) {
+    let exists = await this.kernel.exists("plugin")
+    if (!exists) {
+      await fs.promises.mkdir(this.kernel.path("plugin"), { recursive: true }).catch((e) => {})
+    }
+    let code_exists = await this.kernel.exists("plugin/code")
+    if (!code_exists) {
+      if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
         await this.kernel.exec({
           //message: "git clone https://github.com/peanutcocktail/plugin",
-          message: "git clone https://github.com/pinokiocomputer/plugin",
-          path: this.kernel.homedir
+          //message: "git clone https://github.com/pinokiocomputer/plugin",
+          message: "git clone https://github.com/pinokiocomputer/code",
+          path: this.kernel.path("plugin")
         }, (e) => {
           process.stdout.write(e.raw)
         })
+        await this.setConfig()
+        return
       }
-      let plugin_dir = path.resolve(this.kernel.homedir, "plugin")
-      let pinokiojs = path.resolve(plugin_dir, "pinokio.js")
-      this.config = await this.kernel.require(pinokiojs)
-      this.cache = {}
+    } else {
+      await this.setConfig()
     }
   }
   async update() {

package/kernel/prototype.js

@@ -2,6 +2,7 @@ const fs = require('fs')
 const path = require('path')
 const { glob, sync, hasMagic } = require('glob-gitignore')
 const marked = require('marked')
+const matter = require('gray-matter');
 class Proto {
   constructor(kernel) {
     this.kernel = kernel
@@ -49,6 +50,28 @@ class Proto {
     }
     console.log("Proto init done")
   }
+  async ai() {
+    let ai_path = this.kernel.path("prototype/system/ai/new/static")
+    let mds = await fs.promises.readdir(ai_path)
+    mds = mds.filter((md) => {
+      return md.endsWith(".md")
+    })
+    const results = []
+    for(let md of mds) {
+      let mdpath = path.resolve(ai_path, md)
+      let mdstr = await fs.promises.readFile(mdpath, "utf8")
+      const { data, content } = matter(mdstr)
+//      const html = marked.parse(content)
+      let { title, description, ...meta } = data
+      results.push({
+        title,
+        description,
+        meta,
+        content
+      })
+    }
+    return results
+  }
   async reset() {
     await fs.promises.rm(this.kernel.path("prototype"), { recursive: true })
   }

package/kernel/router/index.js

@@ -216,6 +216,19 @@ class Router {
         await this.fill()
       }
     }
+    this.config.apps.http.servers.main.routes.push({
+      "handle": [
+        {
+          "handler": "static_response",
+          "status_code": 302,
+          "headers": {
+            "Location": [
+              `https://${this.default_match}/launch?url={http.request.scheme}://{http.request.host}{http.request.uri}`
+            ]
+          }
+        }
+      ]
+    })
     this.mapping = this._mapping
   }
 

package/kernel/router/localhost_home_router.js

@@ -6,6 +6,17 @@ class LocalhostHomeRouter {
     this.router.add({ host: this.router.kernel.peer.host, dial: this.router.default_host + ":" + this.router.default_port, match: this.router.default_match })
     this.router.config = {
       "apps": {
+        "tls": {
+          "automation": {
+            "policies": [
+              {
+                "issuers": [{ "module": "internal" }],
+                "on_demand": true
+              }
+            ]
+          }
+        },
+
         "http": {
           "servers": {
             "main": {

package/kernel/shell.js

@@ -16,6 +16,7 @@ const sudo = require("sudo-prompt-programfiles-x86");
 const unparse = require('yargs-unparser-custom-flag');
 const Util = require('./util')
 const Environment = require('./environment')
+const ShellParser = require('./shell_parser')
 const home = os.homedir()
 class Shell {
   /*
@@ -1018,6 +1019,7 @@ class Shell {
     return params
   }
   async exec(params) {
+    this.parser = new ShellParser()
     params = await this.activate(params)
     this.cmd = this.build(params)
     let res = await new Promise((resolve, reject) => {
@@ -1046,6 +1048,22 @@ class Shell {
             }
             this.monitor = this.monitor + data
             this.monitor = this.monitor.slice(-300) // last 300
+
+            let notifications = this.parser.processData(data)
+            if (notifications.length > 0) {
+              console.log({ notifications })
+              for(let notif of notifications) {
+                if (notif.type !== "bell") {
+                  Util.push({
+                    image: path.resolve(__dirname, "../server/public/pinokio-black.png"),
+                    message: notif.title,
+                    sound: true,
+                    timeout: 30,
+                  })
+                }
+              }
+            }
+
             if (!this.done) {
 
               // "request cursor position" handling: https://github.com/microsoft/node-pty/issues/535
@@ -1114,8 +1132,10 @@ class Shell {
         this.ptyProcess = undefined
         // automatically remove the shell from this.kernel.shells
         this.kernel.shell.rm(this.id)
-        this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
-        this.ondata({ raw: "", type: "shell.kill" })
+        if (!this.mute) {
+          this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
+          this.ondata({ raw: "", type: "shell.kill" })
+        }
         cb()
       } else {
         kill(this.ptyProcess.pid, "SIGKILL", true)
@@ -1123,13 +1143,17 @@ class Shell {
         this.ptyProcess = undefined
         // automatically remove the shell from this.kernel.shells
         this.kernel.shell.rm(this.id)
-        this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
-        this.ondata({ raw: "", type: "shell.kill" })
+        if (!this.mute) {
+          this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
+          this.ondata({ raw: "", type: "shell.kill" })
+        }
       }
     } else {
       this.kernel.shell.rm(this.id)
-      this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
-      this.ondata({ raw: "", type: "shell.kill" })
+      if (!this.mute) {
+        this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
+        this.ondata({ raw: "", type: "shell.kill" })
+      }
     }
 
 

package/kernel/shell_parser.js

@@ -0,0 +1,267 @@
+class ShellParser {
+  constructor() {
+    this.buffer = '';
+    this.bufferMaxSize = 2000;
+    this.lastNotificationTime = 0;
+    this.debounceMs = 1000; // Prevent spam
+  }
+
+  /**
+   * Process terminal data and detect notification patterns
+   * @param {string} data - Raw terminal data chunk
+   * @returns {Array} Array of notification objects or empty array
+   */
+  processData(data) {
+    // Add to buffer
+    this.buffer += data;
+    
+    // Keep buffer manageable
+    if (this.buffer.length > this.bufferMaxSize) {
+      this.buffer = this.buffer.slice(-this.bufferMaxSize);
+    }
+
+    const notifications = [];
+    
+    // Check for each pattern type
+//    notifications.push(...this.detectBell(data));
+    notifications.push(...this.detectEscapeSequences(data));
+//    notifications.push(...this.detectTextPatterns(this.buffer));
+    
+    // Apply debouncing and return
+    return this.debounceNotifications(notifications);
+  }
+
+  /**
+   * Detect bell character (ASCII 7)
+   */
+  detectBell(data) {
+    const notifications = [];
+    if (data.includes('\x07')) {
+      notifications.push({
+        type: 'bell',
+        title: 'Terminal Bell',
+        message: 'Bell character detected',
+        timestamp: Date.now()
+      });
+    }
+    return notifications;
+  }
+
+  /**
+   * Detect iTerm2-style escape sequences
+   * Format: \x1b]9;[title];[message]\x07
+   */
+  //detectEscapeSequences(data) {
+  //  const notifications = [];
+  //  
+  //  // iTerm2 notification escape sequence
+  //  const escapeRegex = /\x1b\]9;([^;]*);?([^\x07]*)\x07/g;
+  //  let match;
+  //  
+  //  while ((match = escapeRegex.exec(data)) !== null) {
+  //    notifications.push({
+  //      type: 'escape_sequence',
+  //      title: match[1] || 'Terminal Notification',
+  //      message: match[2] || 'Notification from terminal',
+  //      timestamp: Date.now()
+  //    });
+  //  }
+
+  //  // Generic OSC (Operating System Command) sequences
+  //  const oscRegex = /\x1b\]([0-9]+);([^\x07\x1b]*)\x07/g;
+  //  while ((match = oscRegex.exec(data)) !== null) {
+  //    if (match[1] === '9') { // Notification OSC
+  //      notifications.push({
+  //        type: 'osc_notification',
+  //        title: 'System Notification',
+  //        message: match[2] || 'OSC notification',
+  //        timestamp: Date.now()
+  //      });
+  //    }
+  //  }
+
+  //  return notifications;
+  //}
+  detectEscapeSequences(data) {
+    const notifications = [];
+    
+    // OSC 9 - Notification sequences (used by iTerm2 and others)
+    const notificationRegex = /\x1b\]9;([^;]*);?([^\x07]*)\x07/g;
+    let match;
+    
+    while ((match = notificationRegex.exec(data)) !== null) {
+      notifications.push({
+        type: 'notification_escape',
+        title: match[1] || 'Terminal Notification',
+        message: match[2] || 'Notification from terminal',
+        timestamp: Date.now()
+      });
+    }
+
+    // Other OSC sequences (window title, etc.) - usually not notifications
+    const otherOscRegex = /\x1b\]([0-8]|[1-9][0-9]+);([^\x07\x1b]*)\x07/g;
+    while ((match = otherOscRegex.exec(data)) !== null) {
+      // Only log these for debugging, don't treat as notifications
+      console.debug(`OSC ${match[1]}: ${match[2]}`);
+    }
+
+    return notifications;
+  }
+
+  /**
+   * Detect text patterns that might indicate notifications
+   */
+  detectTextPatterns(buffer) {
+    const notifications = [];
+    
+    const patterns = [
+      {
+        regex: /\b(?:alert|notification|notify|attention)\b[^\n\r]*$/im,
+        type: 'text_alert',
+        title: 'Alert Detected',
+        extractMessage: true
+      },
+      {
+        regex: /\berror\b[^\n\r]*$/im,
+        type: 'error',
+        title: 'Error Detected',
+        extractMessage: true
+      },
+      {
+        regex: /\b(?:completed|finished|done|success)\b[^\n\r]*$/im,
+        type: 'completion',
+        title: 'Task Complete',
+        extractMessage: true
+      },
+      {
+        regex: /claude\s+code.*?(?:completed|finished|ready|done)[^\n\r]*$/im,
+        type: 'claude_code',
+        title: 'Claude Code',
+        extractMessage: true
+      },
+      {
+        regex: /✅[^\n\r]*$/im,
+        type: 'success_emoji',
+        title: 'Success',
+        extractMessage: true
+      },
+      {
+        regex: /❌[^\n\r]*$/im,
+        type: 'error_emoji', 
+        title: 'Error',
+        extractMessage: true
+      },
+      {
+        regex: /🔔[^\n\r]*$/im,
+        type: 'notification_emoji',
+        title: 'Notification',
+        extractMessage: true
+      }
+    ];
+
+    patterns.forEach(pattern => {
+      const match = buffer.match(pattern.regex);
+      if (match) {
+        let message = pattern.extractMessage ? 
+          match[0].trim().slice(0, 100) : 
+          `${pattern.title} detected`;
+        
+        // Clean up ANSI escape codes from message
+        message = this.stripAnsiCodes(message);
+        
+        notifications.push({
+          type: pattern.type,
+          title: pattern.title,
+          message: message,
+          timestamp: Date.now(),
+          rawMatch: match[0]
+        });
+      }
+    });
+
+    return notifications;
+  }
+
+  /**
+   * Remove ANSI escape codes from text
+   */
+  stripAnsiCodes(text) {
+    return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+  }
+
+  /**
+   * Apply debouncing to prevent notification spam
+   */
+  debounceNotifications(notifications) {
+    const now = Date.now();
+    if (notifications.length > 0 && (now - this.lastNotificationTime) > this.debounceMs) {
+      this.lastNotificationTime = now;
+      return notifications;
+    }
+    return [];
+  }
+
+  /**
+   * Reset the internal state
+   */
+  reset() {
+    this.buffer = '';
+    this.lastNotificationTime = 0;
+  }
+
+  /**
+   * Add custom pattern
+   */
+  addCustomPattern(regex, type, title) {
+    // This would require refactoring detectTextPatterns to use a dynamic array
+    // For now, patterns are hardcoded above
+  }
+}
+
+// Usage example:
+/*
+const detector = new TerminalNotificationDetector();
+
+// Simulate terminal data chunks
+const testData = [
+  'Running command...\n',
+  'Alert: Process completed successfully\x07',
+  '\x1b]9;Claude Code;File created successfully\x07',
+  'Error: File not found\n',
+  '✅ Build completed\n'
+];
+
+testData.forEach(chunk => {
+  const notifications = detector.processData(chunk);
+  notifications.forEach(notif => {
+    console.log(`[${notif.type}] ${notif.title}: ${notif.message}`);
+  });
+});
+*/
+module.exports = ShellParser
+
+// Example integration with node-pty:
+/*
+const pty = require('node-pty');
+const detector = new TerminalNotificationDetector();
+
+const ptyProcess = pty.spawn('bash', [], {
+  name: 'xterm-color',
+  cols: 80,
+  rows: 30,
+  cwd: process.cwd(),
+  env: process.env
+});
+
+ptyProcess.on('data', (data) => {
+  // Forward to stdout
+  process.stdout.write(data);
+  
+  // Check for notifications
+  const notifications = detector.processData(data);
+  notifications.forEach(notif => {
+    console.log(`\n🔔 [${notif.type}] ${notif.title}: ${notif.message}\n`);
+    // Here you could send to notification system, websocket, etc.
+  });
+});
+*/

package/kernel/shells.js

@@ -142,59 +142,66 @@ class Shells {
           }
         }
       */
-      if (params.on && Array.isArray(params.on)) {
-        for(let i=0; i<params.on.length; i++) {
-          let handler = params.on[i]
-          // regexify
-          //let matches = /^\/([^\/]+)\/([dgimsuy]*)$/.exec(handler.event)
-          if (handler.event) {
-            if (handler.notify) {
-              // notify is a special case. check by line
-              let matches = /^\/(.+)\/([dgimsuy]*)$/gs.exec(handler.event)
-              if (!/g/.test(matches[2])) {
-                matches[2] += "g"   // if g option is not included, include it (need it for matchAll)
-              }
-              let re = new RegExp(matches[1], matches[2])
-              let test = re.exec(sh.monitor)
-              if (test && test.length > 0) {
-                // reset monitor
-                sh.monitor = ""
-                let params = this.kernel.template.render(handler.notify, { event: test })
-                if (params.image) {
-                  params.contentImage = path.resolve(req.cwd, params.image)
+      try {
+        if (params.on && Array.isArray(params.on)) {
+          for(let i=0; i<params.on.length; i++) {
+            let handler = params.on[i]
+            // regexify
+            //let matches = /^\/([^\/]+)\/([dgimsuy]*)$/.exec(handler.event)
+            if (handler.event) {
+              if (handler.notify) {
+                // notify is a special case. check by line
+                let matches = /^\/(.+)\/([dgimsuy]*)$/gs.exec(handler.event)
+                if (!/g/.test(matches[2])) {
+                  matches[2] += "g"   // if g option is not included, include it (need it for matchAll)
                 }
-                Util.push(params)
-              }
-            } else {
-              let matches = /^\/(.+)\/([dgimsuy]*)$/gs.exec(handler.event)
-              if (!/g/.test(matches[2])) {
-                matches[2] += "g"   // if g option is not included, include it (need it for matchAll)
-              }
-              let re = new RegExp(matches[1], matches[2])
-              if (stream.cleaned) {
-                let line = stream.cleaned.replaceAll(/[\r\n]/g, "")
-                let rendered_event = [...line.matchAll(re)]
-                // 3. if the rendered expression is truthy, run the "run" script
-                if (rendered_event.length > 0) {
-                  stream.matches = rendered_event
-                  if (handler.kill) {
-                    m = rendered_event[0]
-                    matched_index = i
-                    sh.kill()
+                let re = new RegExp(matches[1], matches[2])
+                let test = re.exec(sh.monitor)
+                if (test && test.length > 0) {
+                  // reset monitor
+                  sh.monitor = ""
+                  let params = this.kernel.template.render(handler.notify, { event: test })
+                  if (params.image) {
+                    params.contentImage = path.resolve(req.cwd, params.image)
                   }
-                  if (handler.done) {
-                    m = rendered_event[0]
-                    matched_index = i
-                    sh.continue()
+                  Util.push(params)
+                }
+              } else {
+                let matches = /^\/(.+)\/([dgimsuy]*)$/gs.exec(handler.event)
+                if (!/g/.test(matches[2])) {
+                  matches[2] += "g"   // if g option is not included, include it (need it for matchAll)
+                }
+                let re = new RegExp(matches[1], matches[2])
+                if (stream.cleaned) {
+                  let line = stream.cleaned.replaceAll(/[\r\n]/g, "")
+                  let rendered_event = [...line.matchAll(re)]
+                  // 3. if the rendered expression is truthy, run the "run" script
+                  if (rendered_event.length > 0) {
+                    stream.matches = rendered_event
+                    if (handler.kill) {
+                      m = rendered_event[0]
+                      matched_index = i
+                      sh.kill()
+                    }
+                    if (handler.done) {
+                      m = rendered_event[0]
+                      matched_index = i
+                      sh.continue()
+                    }
                   }
                 }
               }
             }
           }
         }
-      }
-      if (ondata) {
-        ondata(stream)
+        if (ondata) {
+          ondata(stream)
+        }
+      } catch (e) {
+        console.log("Capture error", e)
+        ondata({ raw: e.stack })
+        sh.mute = true
+        sh.kill()
       }
     })
     /*

package/kernel/util.js

@@ -510,7 +510,11 @@ function p2u(localPath) {
     const path = match[2].replace(/\\/g, '/');
     return `/${drive}/${path}`;
   } else {
-    return `${localPath}`;
+    if (localPath.startsWith("/")) {
+      return localPath.slice(1)
+    } else {
+      return localPath
+    }
   }
 }
 function u2p(urlPath) {