pinokiod 8.2.13 → 8.2.15

package/kernel/bin/setup.js

@@ -30,7 +30,6 @@ module.exports = {
     requirements = requirements.concat([
       { name: "git", },
       { name: "node", },
-      { name: "bun", },
       { name: "cli", },
       { name: "ffmpeg", },
 //      { name: "caddy", }
@@ -165,7 +164,6 @@ module.exports = {
     requirements = requirements.concat([
       { name: "git", },
       { name: "node", },
-      { name: "bun", },
       { name: "cli", },
       { name: "uv", },
       { name: "py", },

package/kernel/clear_module.js

@@ -0,0 +1,88 @@
+// Local copy of clear-module 4.1.2 with one logic correction.
+// Fix deep recursive clearing: reuse cached filenames instead of resolving them
+// through parent-module, whose caller lookup fails when V8 truncates the stack.
+// https://github.com/sindresorhus/clear-module/issues/21
+
+'use strict';
+const path = require('path');
+const resolveFrom = require('resolve-from');
+const parentModule = require('parent-module');
+
+const resolve = moduleId => {
+	try {
+		return resolveFrom(path.dirname(parentModule(__filename)), moduleId);
+	} catch (_) {}
+};
+
+const clear = moduleId => {
+	if (typeof moduleId !== 'string') {
+		throw new TypeError(`Expected a \`string\`, got \`${typeof moduleId}\``);
+	}
+
+	const filePath = require.cache[moduleId] ? moduleId : resolve(moduleId);
+
+	if (!filePath) {
+		return;
+	}
+
+	// Delete itself from module parent
+	if (require.cache[filePath] && require.cache[filePath].parent) {
+		let i = require.cache[filePath].parent.children.length;
+
+		while (i--) {
+			if (require.cache[filePath].parent.children[i].id === filePath) {
+				require.cache[filePath].parent.children.splice(i, 1);
+			}
+		}
+	}
+
+	// Remove all descendants from cache as well
+	if (require.cache[filePath]) {
+		const children = require.cache[filePath].children.map(child => child.id);
+
+		// Delete module from cache
+		delete require.cache[filePath];
+
+		for (const id of children) {
+			clear(id);
+		}
+	}
+};
+
+clear.all = () => {
+	const directory = path.dirname(parentModule(__filename));
+
+	for (const moduleId of Object.keys(require.cache)) {
+		delete require.cache[resolveFrom(directory, moduleId)];
+	}
+};
+
+clear.match = regex => {
+	for (const moduleId of Object.keys(require.cache)) {
+		if (regex.test(moduleId)) {
+			clear(moduleId);
+		}
+	}
+};
+
+clear.single = moduleId => {
+	if (typeof moduleId !== 'string') {
+		throw new TypeError(`Expected a \`string\`, got \`${typeof moduleId}\``);
+	}
+
+	delete require.cache[resolve(moduleId)];
+};
+
+module.exports = clear;
+
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/

package/kernel/loader.js

@@ -2,7 +2,7 @@ const fs = require("fs")
 const { parse } = require("csv-parse")
 const YAML = require("yaml")
 const path = require("path")
-const clearModule = require('clear-module');
+const clearModule = require('./clear_module');
 
 class Loader {
   async load(_path) {

package/kernel/shell.js

@@ -627,23 +627,25 @@ class Shell {
         // Modify process.env (and need to immediately revert it back to original process.env so as to not affect other logic)
         let old_env = process.env
         process.env = this.env
-        sudo.exec(params.message, options, (err, stdout, stderr) => {
-          if (err) {
-            console.log("SUDOPROMPT ERR", err)
-            // even when there's an error, just log the error, and don't throw the error. Instead, print the stdout so it displays what happened
-            resolve(stdout)
+        try {
+          sudo.exec(params.message, options, (err, stdout, stderr) => {
+            if (err) {
+              console.log("SUDOPROMPT ERR", err)
+              // even when there's an error, just log the error, and don't throw the error. Instead, print the stdout so it displays what happened
+              resolve(stdout)
 //            reject(err)
-          } else if (stderr) {
-            console.log("SUDOPROMPT STDERR", stderr)
-            resolve(stdout)
+            } else if (stderr) {
+              console.log("SUDOPROMPT STDERR", stderr)
+              resolve(stdout)
 //            reject(stderr)
-          } else {
-            resolve(stdout)
-          }
-        });
-
-        // Immediately revert env back to original
-        process.env = old_env
+            } else {
+              resolve(stdout)
+            }
+          });
+        } finally {
+          // Restore the environment even if the elevation helper throws.
+          process.env = old_env
+        }
       })
       if (ondata) ondata({
         id: this.id,

package/kernel/util.js

@@ -30,7 +30,8 @@ const {
 const platform = os.platform()
 const WINDOWS_TOAST_APP_ID = process.env.PINOKIO_WINDOWS_APP_ID || 'computer.pinokio'
 const DEFAULT_CHIME_URL_PATH = '/chime.mp3'
-const pushListeners = new Set()
+// Process listeners survive reloads of this module.
+const PUSH_EVENT = 'pinokio:push'
 let cachedMacNotifierPath
 
 function resolveAsarPath(p) {
@@ -67,15 +68,15 @@ function registerPushListener(listener) {
   if (typeof listener !== 'function') {
     throw new TypeError('push listener must be a function')
   }
-  pushListeners.add(listener)
-  return () => pushListeners.delete(listener)
+  if (!process.listeners(PUSH_EVENT).includes(listener)) process.on(PUSH_EVENT, listener)
+  return () => process.removeListener(PUSH_EVENT, listener)
 }
 
 function emitPushEvent(event) {
   if (!event) {
     return
   }
-  pushListeners.forEach((listener) => {
+  process.listeners(PUSH_EVENT).forEach((listener) => {
     try {
       listener(event)
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.2.13",
+  "version": "8.2.15",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,6 @@
     "axios": "^1.4.0",
     "batch": "^0.6.1",
     "better-sqlite3": "12.11.1",
-    "clear-module": "^4.1.2",
     "compressing": "^1.10.0",
     "cookie-parser": "^1.4.6",
     "copy-paste": "^2.2.0",
@@ -68,6 +67,7 @@
     "node-gradio-client": "^0.14.6",
     "normalize-path": "^3.0.0",
     "p-limit": "^3.1.0",
+    "parent-module": "^2.0.0",
     "parseurl": "^1.3.3",
     "pdrive": "^0.0.27",
     "portfinder-cp": "^1.0.34",
@@ -75,11 +75,12 @@
     "qrcode": "^1.5.3",
     "querystring": "^0.2.1",
     "random-useragent": "^0.5.0",
+    "resolve-from": "^5.0.0",
     "rimraf": "^5.0.0",
     "sanitize-filename": "^1.6.3",
     "semver": "^7.5.4",
     "shell-path": "^2.0.0",
-    "sudo-prompt-programfiles-x86": "^9.2.10",
+    "sudo-prompt-programfiles-x86": "^9.2.11",
     "symlink-dir": "^5.2.1",
     "systeminformation": "^5.31.1",
     "toasted-notifier": "^10.1.0",

package/server/lib/content_validation.js

@@ -1,6 +1,6 @@
 const fs = require("fs")
 const path = require("path")
-const clearModule = require("clear-module")
+const clearModule = require("../../kernel/clear_module")
 const PluginSources = require("../../kernel/plugin_sources")
 
 const {

package/test/conda-bin.test.js

@@ -195,7 +195,7 @@ test('Conda uses Miniforge assets and writes conda-forge-only config', async ()
 
   assert.equal(
     conda.urls.win32.x64,
-    'https://github.com/conda-forge/miniforge/releases/download/26.9.4-0/Miniforge3-Windows-x86_64.exe'
+    'https://github.com/conda-forge/miniforge/releases/download/26.3.2-3/Miniforge3-Windows-x86_64.exe'
   )
 
   await conda.init()

package/test/module-reload.test.js

@@ -0,0 +1,131 @@
+const assert = require('node:assert/strict')
+const { execFileSync } = require('node:child_process')
+const path = require('node:path')
+const test = require('node:test')
+
+function isolated(source) {
+  execFileSync(process.execPath, ['-e', `
+    const assert = require('node:assert/strict')
+    const fs = require('node:fs')
+    const os = require('node:os')
+    const path = require('node:path')
+    const root = process.argv[1]
+    const from = require('node:module').createRequire(root + '/kernel/bin/index.js')
+    const Loader = from(root + '/kernel/loader.js')
+    const loader = new Loader()
+    const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'pinokio-reload-'))
+    ;(async () => {
+      try { ${source} }
+      finally { fs.rmSync(fixture, { recursive: true, force: true }) }
+    })().catch(error => { console.error(error); process.exitCode = 1 })
+  `, path.resolve(__dirname, '..')], { timeout: 30000, stdio: 'pipe' })
+}
+
+test('managed module reloads preserve compiler, Python and venv discovery', () => {
+  isolated(`
+    from(root + '/kernel/bin/index.js')
+    const compiler = '2019/BuildTools/VC/Tools/MSVC'
+    fs.mkdirSync(path.join(fixture, compiler), { recursive: true })
+    const bin = process.platform === 'win32' ? 'Scripts' : 'bin'
+    const python = process.platform === 'win32' ? 'python.exe' : 'python'
+    fs.mkdirSync(path.join(fixture, 'env', bin), { recursive: true })
+    fs.writeFileSync(path.join(fixture, 'env', bin, python), '')
+    const files = fs.readdirSync(root + '/kernel/bin').filter(file =>
+      file.endsWith('.js') && file !== 'index.js' && file !== 'cmake.js')
+    for (let round = 0; round < 2; round++) {
+      for (const file of files) {
+        await loader.load(root + '/kernel/bin/' + file)
+        assert.equal((await from('glob').glob('**/VC/Tools/MSVC', { cwd: fixture })).length, 1, file)
+        const util = from(root + '/kernel/util.js')
+        assert.equal((await util.find_python(fixture)).length, 1, file)
+        assert.deepEqual(await util.find_venv(fixture), [path.join(fixture, 'env')], file)
+      }
+      // Exercise the delayed path resolver before the next reload cycle.
+      await from(root + '/kernel/bin/conda-meta.js')
+        .runPipSeedRepair(path.join(fixture, 'missing-python'), 'unused').catch(() => {})
+    }
+    for (const api of ['push', 'fs', 'shell', 'load', 'json', 'set', 'rm']) {
+      for (let round = 0; round < 2; round++) {
+        await loader.load(root + '/kernel/api/' + api)
+        assert.equal((await from('glob').glob('**/VC/Tools/MSVC', { cwd: fixture })).length, 1, api)
+        assert.equal((await from(root + '/kernel/util.js').find_python(fixture)).length, 1, api)
+      }
+    }
+  `)
+})
+
+test('browser push delivery and listener disposal survive API reloads', () => {
+  isolated(`
+    const Socket = from(root + '/server/socket.js')
+    const socket = Object.create(Socket.prototype)
+    const messages = []
+    const client = { readyState: 1, send: frame => messages.push(JSON.parse(frame)) }
+    socket.notificationChannel = 'kernel.notifications'
+    socket.subscriptions = new Map([[socket.notificationChannel, new Set([client])]])
+    socket.ensureNotificationBridge()
+    try {
+      for (let round = 0; round < 3; round++) {
+        const push = (await loader.load(root + '/kernel/api/push')).resolved
+        await push({ cwd: fixture, params: { title: 'Fixture', message: String(round), host: false, sound: false } })
+      }
+      assert.deepEqual(messages.map(message => message.data.message), ['0', '1', '2'])
+      socket.subscriptions.clear()
+      socket.checkNotificationBridge()
+      const util = from(root + '/kernel/util.js')
+      util.push({ host: false, sound: false, message: 'disposed' })
+      assert.equal(messages.length, 3)
+
+      let delivered = 0
+      const listener = () => delivered++
+      const dispose = util.registerPushListener(listener)
+      const reloaded = (await loader.load(root + '/kernel/util.js')).resolved
+      const disposeAgain = reloaded.registerPushListener(listener)
+      reloaded.emitPushEvent({ fixture: true })
+      assert.equal(delivered, 1, 'duplicate registration remains deduplicated')
+      dispose()
+      reloaded.emitPushEvent({ fixture: true })
+      assert.equal(delivered, 1, 'old disposer removes a listener after reload')
+      disposeAgain()
+    } finally {
+      if (socket.notificationBridgeDispose) socket.notificationBridgeDispose()
+    }
+  `)
+})
+
+test('launcher loading and validation reload sibling helpers and app-owned packages', () => {
+  isolated(`
+    const app = path.join(fixture, 'app')
+    const vendor = path.join(app, 'node_modules/fixture-lib/index.js')
+    fs.mkdirSync(path.dirname(vendor), { recursive: true })
+    const helper = path.join(fixture, 'helper.js')
+    const launcher = path.join(app, 'pinokio.js')
+    const glob = from('glob')
+    fs.writeFileSync(launcher, "require(" + JSON.stringify(from.resolve('glob')) + "); module.exports = { title: require('../helper').title + require('./node_modules/fixture-lib').version }")
+    fs.writeFileSync(helper, "module.exports = { title: 'before' }")
+    fs.writeFileSync(vendor, "module.exports = { version: '1' }")
+    assert.equal((await loader.load(launcher)).resolved.title, 'before1')
+    fs.writeFileSync(helper, "module.exports = { title: 'after' }")
+    fs.writeFileSync(vendor, "module.exports = { version: '2' }")
+    assert.equal((await loader.load(launcher)).resolved.title, 'after2')
+    const kernel = { path: () => app, api: { launcher_path: async () => app } }
+    const validation = from(root + '/server/lib/content_validation.js').createContentValidationService({ kernel })
+    fs.writeFileSync(helper, "module.exports = { title: 'validated' }")
+    assert.equal((await validation.validateAppByName('fixture')).subjectTitle, 'validated2')
+    assert.notEqual(from('glob'), glob, 'shared dependencies retain recursive reload behavior')
+  `)
+})
+
+test('recursive clearing reloads dependencies beyond the caller stack limit', () => {
+  isolated(`
+    Error.stackTraceLimit = 10
+    for (let index = 0; index < 25; index++) {
+      fs.writeFileSync(path.join(fixture, index + '.js'), index === 24
+        ? 'module.exports = 1'
+        : "module.exports = require('./" + (index + 1) + ".js')")
+    }
+    const entry = path.join(fixture, '0.js')
+    assert.equal((await loader.load(entry)).resolved, 1)
+    fs.writeFileSync(path.join(fixture, '24.js'), 'module.exports = 2')
+    assert.equal((await loader.load(entry)).resolved, 2)
+  `)
+})

package/test/sudo-prompt.test.js

@@ -0,0 +1,105 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+const vm = require('node:vm')
+
+function windowsPrompt(root, exitCode = 0) {
+  const scripts = []
+  const module = { exports: {} }
+  const processStub = { platform: 'win32', env: process.env, cwd: () => root, title: 'Pinokio' }
+  const child = {
+    exec(command, options, callback) {
+      const directory = path.join(root, fs.readdirSync(root)[0])
+      if (command.startsWith('rmdir ')) {
+        assert.equal(command, `rmdir /s /q "${directory}"`)
+        fs.rmSync(directory, { recursive: true })
+        queueMicrotask(() => callback(null, '', ''))
+        return
+      }
+      scripts.push(fs.readFileSync(path.join(directory, 'command.bat'), 'utf8'))
+      fs.writeFileSync(path.join(directory, 'stdout'), 'fixture output')
+      fs.writeFileSync(path.join(directory, 'stderr'), exitCode ? 'fixture failure' : '')
+      fs.writeFileSync(path.join(directory, 'status'), exitCode + '\r\n')
+      queueMicrotask(() => callback(null, '', ''))
+      return { stdin: { end() {} } }
+    }
+  }
+  vm.runInNewContext(fs.readFileSync(require.resolve('sudo-prompt-programfiles-x86'), 'utf8'), {
+    module, process: processStub, setTimeout, console: { log() {} },
+    require(name) {
+      if (name === 'util') return {} // Node 24 no longer provides util.isObject/isFunction.
+      if (name === 'os') return { tmpdir: () => root }
+      if (name === 'child_process') return child
+      return require(name)
+    }
+  })
+  return { exec: module.exports.exec, scripts }
+}
+
+test('elevation accepts both callback signatures without removed Node utilities', () => {
+  const sudo = require('sudo-prompt-programfiles-x86')
+  for (const options of [null, { name: 'Pinokio' }]) {
+    let called = false
+    const callback = error => {
+      called = true
+      assert.match(error.message, /should not be prefixed/)
+    }
+    // Validation must finish before any platform elevation or prompt is attempted.
+    if (options) sudo.exec('sudo echo fixture', options, callback)
+    else sudo.exec('sudo echo fixture', callback)
+    assert.equal(called, true)
+  }
+})
+
+test('Windows elevation backend writes requested environment and reports success or failure', async t => {
+  for (const code of [0, 7]) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pinokio-sudo-'))
+    t.after(() => fs.rmSync(root, { recursive: true, force: true }))
+    const prompt = windowsPrompt(root, code)
+    const result = await new Promise(resolve => prompt.exec('echo fixture', {
+      name: 'Pinokio', env: { PATH: 'fixture-path', 'ProgramFiles(x86)': 'C:\\Program Files (x86)' }
+    }, (error, stdout, stderr) => resolve({ error, stdout, stderr })))
+    assert.equal(prompt.scripts.length, 1)
+    assert.match(prompt.scripts[0], /set PATH=fixture-path/)
+    assert.ok(prompt.scripts[0].includes('set ProgramFiles(x86)=C:^\\Program Files (x86)'))
+    assert.match(prompt.scripts[0], /echo fixture/)
+    assert.equal(result.stdout, 'fixture output')
+    assert.equal(result.stderr, code ? 'fixture failure' : '')
+    if (code) {
+      assert.equal(result.error.code, code)
+      assert.match(result.error.message, /fixture failure/)
+    } else {
+      assert.equal(result.error, undefined)
+      assert.equal(result.stdout, 'fixture output')
+    }
+  }
+})
+
+test('Shell restores its process environment and preserves elevation error output', async t => {
+  const Shell = require('../kernel/shell')
+  const sudo = require('sudo-prompt-programfiles-x86')
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pinokio-sudo-shell-'))
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }))
+  for (const synchronous of [true, false]) {
+    const originalEnv = process.env
+    const error = new Error('fixture elevation failure')
+    const shell = new Shell({ shell: { add() {} } })
+    shell.init_env = async () => { shell.env = { ...process.env, TEMP: root, 'ProgramFiles(x86)': 'fixture programs' } }
+    const mock = t.mock.method(sudo, 'exec', (command, options, callback) => {
+      assert.equal(process.env['ProgramFiles(x86)'], 'fixture programs')
+      if (synchronous) throw error
+      callback(error, 'fixture output', 'fixture stderr')
+    })
+    try {
+      const run = () => shell.start({ path: root, message: 'echo fixture', sudo: true }, () => {})
+      if (synchronous) await assert.rejects(run(), failure => failure === error)
+      else assert.equal(await run(), 'fixture output')
+      assert.equal(process.env, originalEnv)
+    } finally {
+      mock.mock.restore()
+      if (shell.vt) shell.vt.dispose()
+    }
+  }
+})