pinokiod 7.5.7 → 7.5.9

package/server/views/terminal.ejs

@@ -1639,6 +1639,8 @@ document.addEventListener("DOMContentLoaded", async () => {
       this.currentId = baseScriptId
       this.latestLogFallbackActive = false
       this.pendingInput = []
+      this.pendingTerminalWrite = ""
+      this.pendingTerminalWriteFrame = null
       this.inputBuffer = ""
       this.inputTracker = window.TerminalInputTracker ? new window.TerminalInputTracker({
         getFrameName: () => window.name || null,
@@ -1723,6 +1725,32 @@ document.addEventListener("DOMContentLoaded", async () => {
       }
       this.dirty = true
     }
+    flushPendingTerminalWrite() {
+      if (!this.pendingTerminalWrite) {
+        this.pendingTerminalWriteFrame = null
+        return
+      }
+      const text = this.pendingTerminalWrite
+      this.pendingTerminalWrite = ""
+      this.pendingTerminalWriteFrame = null
+      this.write(text)
+    }
+    writeBatched(text) {
+      if (text === "\u0007" || typeof text !== "string" || text.length === 0) {
+        return
+      }
+      this.pendingTerminalWrite += text
+      this.dirty = true
+      if (this.pendingTerminalWriteFrame !== null) {
+        return
+      }
+      const flush = () => this.flushPendingTerminalWrite()
+      if (typeof window.requestAnimationFrame === "function") {
+        this.pendingTerminalWriteFrame = window.requestAnimationFrame(flush)
+      } else {
+        this.pendingTerminalWriteFrame = window.setTimeout(flush, 16)
+      }
+    }
     finished() {
     /*
       n.Noty({
@@ -1921,13 +1949,13 @@ document.addEventListener("DOMContentLoaded", async () => {
               this.resizeSync.sendInitial()
             }
             if (packet.data.raw) {
-              this.write(packet.data.raw)
+              this.writeBatched(packet.data.raw)
             } else if (packet.data.json) {
-              this.write(JSON.stringify(packet.data.json).replace(/\n/g, "\r\n"))
-              this.write("\r\n")
+              this.writeBatched(JSON.stringify(packet.data.json).replace(/\n/g, "\r\n"))
+              this.writeBatched("\r\n")
             } else if (packet.data.json2) {
-              this.write(JSON.stringify(packet.data.json2, null, 2).replace(/\n/g, "\r\n"))
-              this.write("\r\n")
+              this.writeBatched(JSON.stringify(packet.data.json2, null, 2).replace(/\n/g, "\r\n"))
+              this.writeBatched("\r\n")
             }
             if (packet.data.type === "emit2") {
               // long text => still posting to the shell => show progress
@@ -1945,6 +1973,7 @@ document.addEventListener("DOMContentLoaded", async () => {
             refreshParent(packet)
             pluginTerminalDiscoveryRefresher.clear()
             reloadMemory()
+            this.flushPendingTerminalWrite()
             this.term.write("\r\nDisconnected...\r\n")
             document.querySelector("#status-window").innerHTML = "<b>Ready</b>"
             this.socket.close()

package/test/launch-settings-ui.test.js

@@ -74,6 +74,26 @@ test("launch settings visible labels use autolaunch wording", async () => {
   assert.doesNotMatch(sidebar, />Launch settings</)
 })
 
+test("autolaunch page presents launch script choices before requirements", async () => {
+  const globalView = await fs.readFile(path.resolve(root, "server/views/autolaunch.ejs"), "utf8")
+
+  const currentIndex = globalView.indexOf('<h3 class="autolaunch-section-title">Current</h3>')
+  const menuIndex = globalView.indexOf('${renderScriptSection("Menu scripts"')
+  const otherIndex = globalView.indexOf('${renderScriptSection("Other local scripts"')
+  const manualIndex = globalView.indexOf('<div class="autolaunch-manual">')
+  const requirementsIndex = globalView.indexOf('${renderDependencySection(app)}')
+
+  assert.notEqual(currentIndex, -1)
+  assert.notEqual(menuIndex, -1)
+  assert.notEqual(otherIndex, -1)
+  assert.notEqual(manualIndex, -1)
+  assert.notEqual(requirementsIndex, -1)
+  assert.ok(currentIndex < menuIndex)
+  assert.ok(menuIndex < otherIndex)
+  assert.ok(otherIndex < manualIndex)
+  assert.ok(manualIndex < requirementsIndex)
+})
+
 test("startup progress uses canonical ready-state progress instead of autolaunch mirrors", async () => {
   const kernelIndex = await fs.readFile(path.resolve(root, "kernel/index.js"), "utf8")
   const autolaunch = await fs.readFile(path.resolve(root, "kernel/autolaunch.js"), "utf8")

package/test/node-bin.test.js

@@ -0,0 +1,39 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const Node = require('../kernel/bin/node')
+
+function createNode({ nodeVersion = '24.18.0', pnpmVersion = '11.9.0', hasNode = true, hasPnpm = true } = {}) {
+  const node = new Node()
+  const conda = new Set()
+  if (hasNode) conda.add('nodejs')
+  if (hasPnpm) conda.add('pnpm')
+  node.kernel = {
+    bin: {
+      installed: {
+        conda,
+        conda_versions: {
+          nodejs: nodeVersion,
+          pnpm: pnpmVersion,
+        },
+      },
+    },
+  }
+  return node
+}
+
+test('Node bin pins Node.js 24 LTS and matching pnpm', () => {
+  assert.equal(createNode().cmd(), 'nodejs=24.18.0 pnpm=11.9.0')
+})
+
+test('Node.installed accepts exactly the pinned Node.js and pnpm versions', async () => {
+  assert.equal(await createNode().installed(), true)
+  assert.equal(await createNode({ nodeVersion: '24.18.0-h654b19f_0' }).installed(), true)
+  assert.equal(await createNode({ pnpmVersion: '11.9.0-h7c87c79_0' }).installed(), true)
+  assert.equal(await createNode({ nodeVersion: '22.21.1' }).installed(), false)
+  assert.equal(await createNode({ nodeVersion: '26.4.0' }).installed(), false)
+  assert.equal(await createNode({ pnpmVersion: '10.29.3' }).installed(), false)
+  assert.equal(await createNode({ pnpmVersion: '11.8.0' }).installed(), false)
+  assert.equal(await createNode({ hasNode: false }).installed(), false)
+  assert.equal(await createNode({ hasPnpm: false }).installed(), false)
+})

package/test/shell-api.test.js

@@ -2,6 +2,9 @@ const test = require('node:test')
 const assert = require('node:assert/strict')
 const path = require('node:path')
 const ShellAPI = require('../kernel/api/shell')
+const Shell = require('../kernel/shell')
+const Shells = require('../kernel/shells')
+const CondaRuntimeGuard = require('../kernel/shell_conda_runtime_guard')
 
 function createKernel () {
   const calls = []
@@ -10,23 +13,23 @@ function createKernel () {
     homedir: '/tmp/pinokio-home',
     shell: {
       start: async (params, options) => {
-        calls.push({ method: 'start', params: structuredClone(params), options: structuredClone(options) })
+        calls.push({ method: 'start', guard: params[CondaRuntimeGuard.SHELL_RUN_GUARD] === true, params: structuredClone(params), options: structuredClone(options) })
         return 'shell-id'
       },
       enter: async (params) => {
-        calls.push({ method: 'enter', params: structuredClone(params) })
+        calls.push({ method: 'enter', guard: params[CondaRuntimeGuard.SHELL_RUN_GUARD] === true, params: structuredClone(params) })
         return 'entered'
       },
       write: async (params) => {
-        calls.push({ method: 'write', params: structuredClone(params) })
+        calls.push({ method: 'write', guard: params[CondaRuntimeGuard.SHELL_RUN_GUARD] === true, params: structuredClone(params) })
         return 'written'
       },
       run: async (params, options) => {
-        calls.push({ method: 'run', params: structuredClone(params), options: structuredClone(options) })
+        calls.push({ method: 'run', guard: params[CondaRuntimeGuard.SHELL_RUN_GUARD] === true, params: structuredClone(params), options: structuredClone(options) })
         return { stdout: 'ok' }
       },
       kill: async (params) => {
-        calls.push({ method: 'kill', params: structuredClone(params) })
+        calls.push({ method: 'kill', guard: params[CondaRuntimeGuard.SHELL_RUN_GUARD] === true, params: structuredClone(params) })
       }
     }
   }
@@ -51,6 +54,7 @@ test('shell.start forwards defaults, client size, parent, and shell options', as
   assert.equal(result, 'shell-id')
   assert.deepEqual(kernel.calls, [{
     method: 'start',
+    guard: false,
     params: {
       id: cwd,
       path: cwd,
@@ -76,25 +80,28 @@ test('shell.enter, shell.write, and shell.stop target current cwd by default', a
   const cwd = path.join('/tmp', 'pinokio-shell-api')
   const parent = { path: path.join(cwd, 'script.js') }
 
-  assert.equal(await api.enter({ cwd, parent, params: { message: 'echo hi' } }, () => {}, kernel), 'entered')
-  assert.equal(await api.write({ cwd, params: { message: 'typed' } }, () => {}, kernel), 'written')
+  assert.equal(await api.enter({ cwd, parent, params: { message: 'conda install python=3.12 -y' } }, () => {}, kernel), 'entered')
+  assert.equal(await api.write({ cwd, params: { message: 'conda update --all' } }, () => {}, kernel), 'written')
   await api.stop({ cwd, params: {} }, () => {}, kernel)
 
   assert.deepEqual(kernel.calls, [{
     method: 'enter',
+    guard: false,
     params: {
-      message: 'echo hi',
+      message: 'conda install python=3.12 -y',
       id: cwd,
       $parent: parent
     }
   }, {
     method: 'write',
+    guard: false,
     params: {
-      message: 'typed',
+      message: 'conda update --all',
       id: cwd
     }
   }, {
     method: 'kill',
+    guard: false,
     params: {
       id: cwd
     }
@@ -118,6 +125,7 @@ test('shell.run applies deterministic defaults and forwards execution options',
   assert.deepEqual(result, { stdout: 'ok' })
   assert.deepEqual(kernel.calls, [{
     method: 'run',
+    guard: true,
     params: {
       message: 'echo ok',
       path: cwd,
@@ -132,3 +140,85 @@ test('shell.run applies deterministic defaults and forwards execution options',
     }
   }])
 })
+
+test('shell.run forwards typed stream events', async () => {
+  const api = new ShellAPI()
+  const events = []
+  const kernel = createKernel()
+  kernel.shell.run = async (params, options, ondata) => {
+    ondata({ html: 'notice', type: 'warning' }, 'notify')
+    return { stdout: 'ok' }
+  }
+
+  const result = await api.run({
+    cwd: path.join('/tmp', 'pinokio-shell-api'),
+    params: {
+      message: 'echo ok'
+    }
+  }, (stream, type) => {
+    events.push({ stream, type })
+  }, kernel)
+
+  assert.deepEqual(result, { stdout: 'ok' })
+  assert.deepEqual(events, [{
+    stream: {
+      html: 'notice',
+      type: 'warning'
+    },
+    type: 'notify'
+  }])
+})
+
+test('Shells.launch forwards typed stream events without live-output parsing', async () => {
+  const events = []
+  const originalStart = Shell.prototype.start
+  Shell.prototype.start = async function (_params, ondata) {
+    this.id = 'stub-shell'
+    await ondata({ html: 'notice', type: 'warning' }, 'notify')
+    return ''
+  }
+
+  try {
+    const root = path.join('/tmp', 'pinokio-shells-api')
+    const shells = new Shells({
+      homedir: root,
+      platform: 'darwin',
+      bracketedPasteSupport: { bash: true },
+      which: () => null,
+      path: (...parts) => path.join(root, ...parts),
+      bin: {
+        envs: (env = {}) => env
+      },
+      api: {
+        resolvePath: (cwd, target) => path.resolve(cwd, target),
+        running: {}
+      },
+      git: {
+        repos: async () => [],
+        restoreNewReposForActiveSnapshot: async () => {}
+      },
+      template: {
+        render: (value) => value
+      }
+    })
+
+    await shells.launch({
+      path: path.join(root, 'api', 'demo'),
+      message: 'echo ok'
+    }, {
+      cwd: root
+    }, (stream, type) => {
+      events.push({ stream, type })
+    })
+
+    assert.deepEqual(events, [{
+      stream: {
+        html: 'notice',
+        type: 'warning'
+      },
+      type: 'notify'
+    }])
+  } finally {
+    Shell.prototype.start = originalStart
+  }
+})