pinokiod 7.3.11 → 7.3.13

package/kernel/shells.js

@@ -415,7 +415,6 @@ class Shells {
         .replaceAll(/\r\n/g, "\n")
         .replaceAll(/\r/g, "\n")
     }
-
     // if error doesn't exist, add default "error:" event
     if (!params.on) {
       params.on = []
@@ -436,6 +435,56 @@ class Shells {
     }]
     params.on = params.on.concat(defaultHandlers)
 
+    const collectBreakErrors = (text) => {
+      const errors = new Set()
+      if (!text || !params.on || !Array.isArray(params.on)) {
+        return errors
+      }
+      let line = text.replaceAll(/[\r\n]/g, "")
+      // 1. find all break event handlers
+      let breakPoints = params.on.filter((x) => {
+        return x.event && x.hasOwnProperty("break")
+      })
+
+      // 2. first find the `break: false` handlers and replace the patterns with blank => so they won't be matched in the next step
+      //let line = response.replaceAll(/[\r\n]/g, "")
+      for(let handler of breakPoints) {
+        if (handler.event) {
+          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])
+
+          // only the "break: false" ones => these need to be ignored
+          if (!handler.break) {
+            line = line.replaceAll(re, "")
+          }
+        }
+      }
+      // 3. Now with all the `break: false` (ignored patterns) gone, look for the `break: true` patterns
+      for(let handler of breakPoints) {
+        if (handler.event) {
+          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])
+
+          // only the "break: true" ones
+          if (handler.break) {
+            let match;
+            // Keep executing the regex on the text until no more matches are found
+            while ((match = re.exec(line)) !== null) {
+              errors.add(match[0])
+              // errors.add(match.slice(1));
+            }
+          }
+        }
+      }
+      return errors
+    }
+
     if (!isParentRequestActive()) {
       return ""
     }
@@ -519,8 +568,10 @@ class Shells {
                     const lastMatch = rendered_event[rendered_event.length - 1]
                     handlerLastMatchEnd.set(i, liveEventBufferStart + lastMatch.index + lastMatch[0].length)
                     const triggerAction = typeof handler.trigger === "string" ? handler.trigger.trim() : ""
+                    const isBreakHandler = handler.break === true
+                    const liveErrors = isBreakHandler ? collectBreakErrors(liveEventBuffer) : null
                     const shouldCaptureEvent =
-                      handler.break !== false
+                      (handler.break !== false && (!isBreakHandler || liveErrors.size > 0))
                       || handler.done
                       || handler.kill
                       || !!triggerAction
@@ -542,6 +593,11 @@ class Shells {
                       liveEventHandlersClosed = true
                       break
                     }
+                    if (isBreakHandler && liveErrors.size > 0) {
+                      sh.continue(liveEventBuffer)
+                      liveEventHandlersClosed = true
+                      break
+                    }
                     if (handler.done) {
                       sh.continue()
                       liveEventHandlersClosed = true
@@ -589,54 +645,7 @@ class Shells {
       - TEMPLATE: parse the template 
     */
 
-    let errors = new Set()
-    if (response) {
-      if (params.on && Array.isArray(params.on)) {
-
-        let line = response.replaceAll(/[\r\n]/g, "")
-        // 1. find all break event handlers
-        let breakPoints = params.on.filter((x) => {
-          return x.event && x.hasOwnProperty("break")
-        })
-
-        // 2. first find the `break: false` handlers and replace the patterns with blank => so they won't be matched in the next step
-        //let line = response.replaceAll(/[\r\n]/g, "")
-        for(let handler of breakPoints) {
-          if (handler.event) {
-            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])
-
-            // only the "break: false" ones => these need to be ignored
-            if (!handler.break) {
-              line = line.replaceAll(re, "")
-            }
-          }
-        }
-        // 3. Now with all the `break: false` (ignored patterns) gone, look for the `break: true` patterns
-        for(let handler of breakPoints) {
-          if (handler.event) {
-            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])
-
-            // only the "break: true" ones
-            if (handler.break) {
-              let match;
-              // Keep executing the regex on the text until no more matches are found
-              while ((match = re.exec(line)) !== null) {
-                errors.add(match[0])
-                // errors.add(match.slice(1));
-              }
-            }
-          }
-        }
-      }
-    }
+    let errors = collectBreakErrors(response)
 
 
     if (ondata) {

package/package.json

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

package/test/shells-live-error.test.js

@@ -0,0 +1,143 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const Module = require('node:module')
+
+async function runWithFakeShell ({ platform = 'win32', chunks, response, waitForBreak = false }) {
+  class FakeShell {
+    constructor () {
+      this.id = 'fake-shell'
+      this.monitor = ''
+      this.breakResolver = null
+      this.resolved = undefined
+    }
+
+    stripAnsi (value) {
+      return value
+    }
+
+    kill (message) {
+      this.resolved = message || response
+      if (this.breakResolver) {
+        this.breakResolver(this.resolved)
+      }
+    }
+
+    continue (message) {
+      this.resolved = message || response
+      if (this.breakResolver) {
+        this.breakResolver(this.resolved)
+      }
+    }
+
+    async start (_params, onstream) {
+      let breakPromise = null
+      if (waitForBreak) {
+        breakPromise = new Promise((resolve) => {
+          this.breakResolver = resolve
+        })
+      }
+      for (const chunk of chunks) {
+        await onstream({ raw: chunk })
+        if (this.resolved !== undefined) {
+          return this.resolved
+        }
+      }
+      if (waitForBreak) {
+        return await breakPromise
+      }
+      return response
+    }
+  }
+
+  const shellsModulePath = require.resolve('../kernel/shells')
+  delete require.cache[shellsModulePath]
+
+  const originalLoad = Module._load
+  Module._load = function (request, parent, isMain) {
+    if (request === './shell' && parent && /kernel[\\/]shells\.js$/.test(parent.filename)) {
+      return FakeShell
+    }
+    return originalLoad.apply(this, arguments)
+  }
+
+  try {
+    const Shells = require('../kernel/shells')
+    const kernel = {
+      platform,
+      homedir: '/tmp/pinokio-home',
+      bracketedPasteSupport: { 'cmd.exe': true },
+      bin: { envs: (env) => env || {} },
+      api: {
+        resolvePath: (_cwd, execPath) => execPath,
+        running: {}
+      },
+      which: () => null
+    }
+    const output = []
+    const shells = new Shells(kernel)
+    const result = await shells.run({ message: 'python wgp.py' }, { cwd: '/tmp/app' }, (stream) => {
+      output.push(stream.raw || '')
+    })
+
+    return { output, result }
+  } finally {
+    Module._load = originalLoad
+    delete require.cache[shellsModulePath]
+  }
+}
+
+test('shell.run promotes a live break match to an error when the final response loses it', async () => {
+  const { output, result } = await runWithFakeShell({
+    chunks: [
+      "Traceback (most recent call last):\r\n",
+      "ModuleNotFoundError: No module named 'torch'\r\n"
+    ],
+    response: "(env) (base) C:\\pinokio\\api\\wan2gp-amd.git\\app>"
+  })
+
+  assert.equal(output.some((chunk) => chunk.includes('# input.event')), true)
+  assert.deepEqual(result.event[0], 'Error:')
+  assert.deepEqual(result.error, ['Error:'])
+})
+
+test('shell.run promotes a live argparse error to an error when the final response loses it', async () => {
+  const { output, result } = await runWithFakeShell({
+    platform: 'darwin',
+    chunks: [
+      "usage: x-voice_infer-gradio [-h] [--port PORT] [--host HOST]\n",
+      "x-voice_infer-gradio: error: argument --port: invalid int value: 'aaaa'\n"
+    ],
+    response: "(/Users/x/pinokio/api/X-Voice.git2/app/conda_env) <<PINOKIO_SHELL>>"
+  })
+
+  assert.equal(output.some((chunk) => chunk.includes('# input.event')), true)
+  assert.deepEqual(result.event[0], 'error:')
+  assert.deepEqual(result.error, ['error:'])
+})
+
+test('shell.run resolves an interactive run on a real live break match', async () => {
+  const { output, result } = await runWithFakeShell({
+    platform: 'darwin',
+    chunks: [
+      "x-voice_infer-gradio: error: argument --port: invalid int value: 'aaaa'\n"
+    ],
+    response: "(/Users/x/pinokio/api/X-Voice.git2/app/conda_env) <<PINOKIO_SHELL>>",
+    waitForBreak: true
+  })
+
+  assert.equal(output.some((chunk) => chunk.includes('# input.event')), true)
+  assert.deepEqual(result.event[0], 'error:')
+  assert.deepEqual(result.error, ['error:'])
+})
+
+test('shell.run does not return an error for a live match covered by break:false', async () => {
+  const { result } = await runWithFakeShell({
+    platform: 'darwin',
+    chunks: [
+      "error: triton is not available, continuing without it\n"
+    ],
+    response: "error: triton is not available, continuing without it\nready"
+  })
+
+  assert.equal(result.error, undefined)
+})