pinokiod 7.5.7 → 7.5.8

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
+  }
+})