pinokiod 8.2.3 → 8.2.4

package/Dockerfile

@@ -1,5 +1,5 @@
 # Production image for pinokiod with required system tooling
-FROM node:20 AS build
+FROM node:24.22.1 AS build
 WORKDIR /app
 
 RUN apt-get update \
@@ -9,12 +9,13 @@ RUN apt-get update \
 COPY package*.json ./
 RUN npm ci --omit=dev && npm cache clean --force
 
-FROM node:20 AS runtime
+FROM node:24.22.1 AS runtime
 ENV NODE_ENV=production
 WORKDIR /app
 
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \
+        ca-certificates \
         bluez \
         curl \
         git \

package/kernel/anywhere/index.js

@@ -187,8 +187,11 @@ class Anywhere {
   async autostart() {
     // a pid file left behind by a crash or reboot must never point at an unrelated process
     if (!(await this.daemonAlive())) fs.rmSync(this.pidPath(), { force: true })
+    if (!(await this.installed())) {
+      await this.stop()
+      return false
+    }
     if (!(await this.enabled())) return false
-    if (!(await this.installed())) return false
     await this.start()
     return true
   }
@@ -199,6 +202,11 @@ class Anywhere {
   }
   async _start() {
     this.error = null
+    if (!(await this.installed())) {
+      await this.stop()
+      this.error = "Update the tailscaled tool before starting Pinokio Anywhere."
+      throw new Error(this.error)
+    }
     await this.loadConfig()
     await fs.promises.mkdir(this.stateDir(), { recursive: true })
     const bin = this.binPath()

package/kernel/bin/bun.js

@@ -1,7 +1,7 @@
 const semver = require("semver")
 const Util = require("../util")
 
-const BUN_VERSION = "1.3.11"
+const BUN_VERSION = "1.4.4"
 
 class Bun {
   description = "Installs Bun, a fast JavaScript runtime and package manager."

package/kernel/bin/conda-meta.js

@@ -2,6 +2,8 @@ const fs = require('fs')
 const path = require('path')
 const { execFile } = require('child_process')
 const { managedPythonEnv } = require('../python_env')
+const semver = require('semver')
+const { PIP_MIN_VERSION } = require('./conda-pins')
 
 async function buildCondaListFromMeta(minicondaPath, useCondaList) {
   if (!useCondaList) {
@@ -108,7 +110,20 @@ function resolveCondaBinary(minicondaPath, platform = process.platform, allowFal
   return allowFallback ? 'conda' : null
 }
 
+async function hasSecureManagedPip(prefix, platform = process.platform) {
+  const python = path.join(prefix, platform === 'win32' ? 'python.exe' : 'bin/python')
+  return await new Promise(resolve => {
+    execFile(python, ['-I', '-c', 'from importlib.metadata import version; print(version("pip"))'], {
+      env: managedPythonEnv(), windowsHide: true, timeout: 15000,
+    }, (error, stdout) => {
+      const version = !error && semver.valid(String(stdout).trim())
+      resolve(!!version && semver.gte(version, PIP_MIN_VERSION))
+    })
+  })
+}
+
 module.exports = {
   buildCondaListFromMeta,
   managedCondaRuns,
+  hasSecureManagedPip,
 }

package/kernel/bin/conda-pins.js

@@ -1,6 +1,22 @@
 const semver = require('semver')
 
 const CONDA_PIN_VERSION = "26.5.3"
+// Conda 26.9.4 has no Python 3.10 builds. Apply its CA-bundle requirements
+// explicitly while retaining the managed Python version required by apps.
+const TLS_PACKAGE_MINIMUMS = {
+  'ca-certificates': '2026.10.19',
+  certifi: '2026.10.19',
+}
+// conda-forge's patched pip requires Python 3.11; this official wheel supports 3.10.
+// Bootstrap URL and hash: https://discuss.python.org/t/109576
+const PIP_MIN_VERSION = '26.2.2'
+const PIP_INSTALL_SPEC = 'pip @ https://files.pythonhosted.org/packages/3f/06/3e4420302363fbb71be3c7f35ce042f54bfca330e3e66b3a2e3c4cca579f/pip-26.2.2-py3-none-any.whl#sha256=fd7f4dfa8190e014013b9f08f3e973f4e4c26ffd179a204895533a7254813a70'
+const PIP_INSTALL_COMMAND = `python -I -m pip --isolated --disable-pip-version-check install --no-index --no-deps "${PIP_INSTALL_SPEC}"`
+const TLS_PACKAGE_SPECS = Object.entries(TLS_PACKAGE_MINIMUMS).map(([name, version]) => `${name}>=${version}`)
+const hasSecureTlsPackages = (versions = {}) => Object.entries(TLS_PACKAGE_MINIMUMS).every(([name, minimum]) => {
+  const version = semver.coerce(versions[name])
+  return version && semver.gte(version, minimum)
+})
 const PYTHON_PIN_VERSION = "3.10.20"
 const PYTHON_INSTALL_SPEC = `python=${PYTHON_PIN_VERSION}`
 const WINDOWS_PYTHON_SSL_FIX_SPEC = `${PYTHON_INSTALL_SPEC}=*_1_cpython`
@@ -30,6 +46,12 @@ const isExpectedPythonPinned = (platform, version, build) => {
 
 module.exports = {
   CONDA_PIN_VERSION,
+  TLS_PACKAGE_MINIMUMS,
+  PIP_MIN_VERSION,
+  PIP_INSTALL_SPEC,
+  PIP_INSTALL_COMMAND,
+  TLS_PACKAGE_SPECS,
+  hasSecureTlsPackages,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
   isExpectedCondaPinned,

package/kernel/bin/conda.js

@@ -1,18 +1,37 @@
 const fs = require('fs')
 const { glob } = require('glob')
 const semver = require('semver')
+const { createHash } = require('crypto')
+const { execFile } = require('child_process')
+const { managedPythonEnv } = require('../python_env')
 const { isPathRemovalBlockedError, removePath } = require('../path_removal')
-const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
+const { buildCondaListFromMeta, managedCondaRuns, hasSecureManagedPip } = require('./conda-meta')
 const {
   CONDA_PIN_VERSION,
+  PIP_INSTALL_COMMAND,
+  TLS_PACKAGE_MINIMUMS,
+  TLS_PACKAGE_SPECS,
+  hasSecureTlsPackages,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
   isExpectedCondaPinned,
   isExpectedPythonPinned,
 } = require('./conda-pins')
 
-const MINIFORGE_RELEASE = "26.3.2-3"
+const MINIFORGE_RELEASE = "26.9.4-0"
 const MINIFORGE_BASE_URL = `https://github.com/conda-forge/miniforge/releases/download/${MINIFORGE_RELEASE}`
+// GitHub's published SHA-256 asset digests for Miniforge 26.9.4-0.
+const MINIFORGE_SHA256 = {
+  darwin: {
+    x64: '4bf8d162f90a9ae79fbe1c3b152a9957b6cf4e7385758fa21e0340229d444df1',
+    arm64: '85512f5495465644e09655d84bc1df79d978353abd9ef0d0a8f3df75da44c760',
+  },
+  linux: {
+    x64: '621428f40496a90702753b09237794518a081d9979d9f845a525de761b6056f7',
+    arm64: 'd265b10be348403a3bb8d475ff989beba48db9baa5fe7ee28eb38213538056bb',
+  },
+  win32: { x64: '43638698f5ee811debae27b0dc3ab5c0300129bd400a847376c4bd2f6be15ceb' },
+}
 const CONDA_ROOT_DIR = "miniforge"
 const LEGACY_CONDA_ROOT_DIR = "miniconda"
 
@@ -44,11 +63,22 @@ class Conda {
   pinnedPackages() {
     return [
       `conda ==${CONDA_PIN_VERSION}`,
+      ...TLS_PACKAGE_SPECS,
     ].join("\n")
   }
   async hasCondaMeta() {
     return await this.kernel.exists(`bin/${CONDA_ROOT_DIR}/conda-meta`)
   }
+  async verifyInstaller(installer) {
+    const expected = MINIFORGE_SHA256[this.kernel.platform]?.[this.kernel.arch]
+    const hash = createHash('sha256')
+    for await (const chunk of fs.createReadStream(this.kernel.bin.path(installer))) {
+      hash.update(chunk)
+    }
+    if (!expected || hash.digest('hex') !== expected) {
+      throw new Error('Miniforge installer SHA-256 verification failed. The installer was not run and existing environments were preserved.')
+    }
+  }
   env() {
     let base = {
       CONDA_PREFIX: this.kernel.bin.path(CONDA_ROOT_DIR),
@@ -78,6 +108,7 @@ class Conda {
 channel_priority: flexible
 create_default_packages:
   - ${PYTHON_INSTALL_SPEC}
+${TLS_PACKAGE_SPECS.map(spec => `  - ${spec}`).join("\n")}
 envs_dirs:
   - ${this.kernel.bin.path(`${CONDA_ROOT_DIR}/envs`)}
 pkgs_dirs:
@@ -138,12 +169,37 @@ report_errors: false`)
     this.kernel.bin.installed.conda = conda
     this.kernel.bin.installed.conda_versions = conda_versions
     this.kernel.bin.installed.conda_builds = conda_builds
-    if (!(conda_check.conda && conda_check.mamba && conda_check.python)) {
+    if (!(conda_check.conda && conda_check.mamba && conda_check.python && hasSecureTlsPackages(conda_versions))) {
       return false
     }
-    return await managedCondaRuns(this.kernel.bin.path(CONDA_ROOT_DIR), this.kernel.platform)
+    return await hasSecureManagedPip(this.kernel.bin.path(CONDA_ROOT_DIR), this.kernel.platform) && await managedCondaRuns(this.kernel.bin.path(CONDA_ROOT_DIR), this.kernel.platform)
   }
   async install(req, ondata) {
+    await this.check()
+    const { conda_versions: versions, conda_builds: builds } = this.kernel.bin.installed
+    if (isExpectedCondaPinned(versions.conda) &&
+        isExpectedPythonPinned(this.kernel.platform, versions.python, builds.python) &&
+        await managedCondaRuns(this.kernel.bin.path(CONDA_ROOT_DIR), this.kernel.platform)) {
+      // Refresh a working runtime in place, preserving named app environments.
+      await this.init()
+      const bootstrap = await this.kernel.bin.exec({
+        message: [PIP_INSTALL_COMMAND, `python -I -m pip --isolated install --no-deps --only-binary=:all: --index-url https://pypi.org/simple "certifi>=${TLS_PACKAGE_MINIMUMS.certifi}"`],
+      }, ondata)
+      if (bootstrap?.error?.length) throw new Error("Conda certificate bootstrap failed; existing environments were preserved.")
+      const python = this.kernel.bin.path(CONDA_ROOT_DIR, this.kernel.platform === 'win32' ? 'python.exe' : 'bin/python')
+      const output = await new Promise((resolve, reject) => execFile(python,
+        ['-I', '-c', 'import certifi; from importlib.metadata import version; print(certifi.where()); print(version("certifi"))'],
+        { env: managedPythonEnv(), windowsHide: true, timeout: 15000 },
+        (error, stdout) => error ? reject(error) : resolve(stdout.trim())))
+      const [caFile, certifiVersion] = output.split(/[\r\n]+/)
+      if (!semver.valid(certifiVersion) || !semver.gte(certifiVersion, TLS_PACKAGE_MINIMUMS.certifi)) throw new Error("The certificate bootstrap did not complete.")
+      const result = await this.kernel.bin.exec({
+        message: [`conda install -y --override-channels -c conda-forge "${this.kernel.platform === "win32" ? WINDOWS_PYTHON_SSL_FIX_SPEC : PYTHON_INSTALL_SPEC}" "conda-libmamba-solver>=25.4.0" pip ${TLS_PACKAGE_SPECS.map(spec => `"${spec}"`).join(" ")}`, PIP_INSTALL_COMMAND],
+        env: { CONDA_SSL_VERIFY: caFile },
+      }, ondata)
+      if (result?.error?.length || !(await this.check())) throw new Error("Conda certificate update failed; existing environments were preserved.")
+      return
+    }
     for(let i=0; i<5; i++) {
       await this._install(req, ondata)
       let installed = await this.check()
@@ -170,6 +226,7 @@ report_errors: false`)
 
     ondata({ raw: `downloading installer: ${installer_url}...\r\n` })
     await this.kernel.bin.download(installer_url, installer, ondata)
+    await this.verifyInstaller(installer)
 
     const caddy = this.kernel.bin.mod && this.kernel.bin.mod.caddy
     if (caddy && typeof caddy.running === "function" && await caddy.running()) {
@@ -227,13 +284,16 @@ report_errors: false`)
       `"conda=${CONDA_PIN_VERSION}"`,
       this.kernel.platform === "win32" ? `"${WINDOWS_PYTHON_SSL_FIX_SPEC}"` : `"${PYTHON_INSTALL_SPEC}"`,
       `"conda-libmamba-solver>=25.4.0"`,
+      "pip",
+      ...TLS_PACKAGE_SPECS.map(spec => `"${spec}"`),
     ]
 
     let cmds = [
       "conda clean -y --all",
       `conda install -y --override-channels -c conda-forge ${condaPackages.join(" ")} ${mods}`.trim(),
+      PIP_INSTALL_COMMAND,
     ]
-    await this.kernel.bin.exec({
+    const result = await this.kernel.bin.exec({
       message: cmds,
       env: {
         PIP_REQUIRE_VIRTUALENV: "false"
@@ -241,6 +301,7 @@ report_errors: false`)
     }, (stream) => {
       ondata(stream)
     })
+    if (result?.error?.length) throw new Error("Conda package or pip installation failed.")
     if (this.kernel.platform === "win32") {
       // copy python.exe to python3.exe so you can run with both python3 and python
       await fs.promises.copyFile(

package/kernel/bin/index.js

@@ -21,10 +21,11 @@ const LLVM = require('./llvm')
 const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
-const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
+const { buildCondaListFromMeta, managedCondaRuns, hasSecureManagedPip } = require('./conda-meta')
 const {
   isExpectedCondaPinned,
   isExpectedPythonPinned,
+  hasSecureTlsPackages,
 } = require('./conda-pins')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
@@ -412,8 +413,8 @@ class Bin {
         }
       }
 
-      if (conda_check.conda && conda_check.mamba && conda_check.python) {
-        this.correct_conda = await managedCondaRuns(this.kernel.bin.path("miniforge"), this.platform)
+      if (conda_check.conda && conda_check.mamba && conda_check.python && hasSecureTlsPackages(conda_versions)) {
+        this.correct_conda = await hasSecureManagedPip(this.kernel.bin.path("miniforge"), this.platform) && await managedCondaRuns(this.kernel.bin.path("miniforge"), this.platform)
       }
     }
     this.installed.conda = conda

package/kernel/bin/node.js

@@ -2,7 +2,7 @@ const fs = require('fs')
 const fetch = require('cross-fetch')
 const { rimraf } = require('rimraf')
 const decompress = require('decompress');
-const NODE_VERSION = "24.18.0"
+const NODE_VERSION = "24.22.1"
 const PNPM_VERSION = "11.9.0"
 
 const normalizeVersion = (version) => {

package/kernel/bin/tailscaled.js

@@ -3,8 +3,8 @@ const semver = require('semver')
 
 // conda-forge ships only the daemon binary (no `tailscale` CLI); Pinokio
 // drives it over its LocalAPI (see kernel/anywhere).
-const TAILSCALED_SPEC = "tailscaled=1.104.1"
-const TAILSCALED_REQUIREMENT = ">=1.104.0"   // 1.104 added --windows-mode=dev
+const TAILSCALED_SPEC = "tailscaled=1.104.2"
+const TAILSCALED_REQUIREMENT = ">=1.104.2"   // Blocks the compromised eMudhra intermediate keys.
 
 class Tailscaled {
   description = "Installs the Tailscale daemon for Pinokio Anywhere: reach this Pinokio and its apps from your phone or another computer over a private network."
@@ -18,6 +18,7 @@ class Tailscaled {
     return this.kernel.bin.path("miniforge", "bin", "tailscaled")
   }
   async install(req, ondata) {
+    if (this.kernel.anywhere) await this.kernel.anywhere.stop()
     await this.kernel.bin.exec({
       message: [
         // a stale libmamba index cache reports the package as missing even

package/kernel/bin/uv.js

@@ -1,4 +1,4 @@
-const UV_VERSION = "0.11.23"
+const UV_VERSION = "0.13.4"
 
 const normalizeVersion = (version) => {
   const match = String(version || "").match(/^\d+\.\d+\.\d+/)

package/kernel/shell.js

@@ -21,7 +21,7 @@ const ShellParser = require('./shell_parser')
 const AnsiStreamTracker = require('./ansi_stream_tracker')
 const ShellStateSync = require('./shell_state_sync')
 const ShellRunTemplate = require('./api/shell_run_template')
-const { PYTHON_INSTALL_SPEC } = require('./bin/conda-pins')
+const { PYTHON_INSTALL_SPEC, PIP_INSTALL_COMMAND, PIP_MIN_VERSION } = require('./bin/conda-pins')
 const CondaRuntimeGuard = require('./shell_conda_runtime_guard')
 const home = os.homedir()
 const WINDOWS_CMD_CONDA_COMMAND_PATTERN = /(?:^|[&|()]\s*)@?\s*(?:call\s+)?(?:"[^"]*[\\/]conda(?:\.bat|\.exe)?"|(?:[a-z]:)?[^&|()\s"]*[\\/]conda(?:\.bat|\.exe)?|conda(?:\.bat|\.exe)?)\s+/i
@@ -1399,10 +1399,17 @@ class Shell {
               deactivate_path,
 //              timeout,
               activate_command,
+              this.isPowerShell()
+                ? `${PIP_INSTALL_COMMAND}; if ($LASTEXITCODE -ne 0) { exit 1 }`
+                : `${PIP_INSTALL_COMMAND} || exit 1`,
 //              timeout,
             ]
           }
         }
+        if (!use_uv) {
+          const checkPip = `python -I -c "from importlib.metadata import distributions; assert all(tuple(map(int, d.version.split('.')[:3])) >= (${PIP_MIN_VERSION.split(".").join(", ")}) for d in distributions(name='pip')), 'Update pip in this app environment before running it.'"`
+          venv_activation.push(this.isPowerShell() ? `${checkPip}; if ($LASTEXITCODE -ne 0) { exit 1 }` : `${checkPip} || exit 1`)
+        }
       } else {
         venv_activation = []
       }

package/package.json

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

package/test/anywhere.test.js

@@ -59,17 +59,20 @@ test('anywhere preset requires tailscaled but not caddy', () => {
   assert.ok(!preset.conda_requirements.includes('caddy'))
 })
 
-test('tailscaled bin module pins 1.104.1 and checks the installed version', async () => {
+test('tailscaled bin module pins 1.104.2 and checks the installed version', async () => {
   const mod = new Tailscaled()
-  assert.equal(mod.cmd(), 'tailscaled=1.104.1')
+  assert.equal(mod.cmd(), 'tailscaled=1.104.2')
   mod.kernel = {
     platform: 'darwin',
     bin: {
-      installed: { conda: new Set(['tailscaled']), conda_versions: { tailscaled: '1.104.1' } },
+      installed: { conda: new Set(['tailscaled']), conda_versions: { tailscaled: '1.104.2' } },
       path: (...segments) => segments.join('/'),
     },
   }
   assert.equal(await mod.installed(), true)
+  mod.kernel.bin.installed.conda_versions.tailscaled = '1.104.1'
+  assert.equal(await mod.installed(), false)
+  mod.kernel.bin.installed.conda_versions.tailscaled = '1.104.2'
   assert.equal(mod.binPath(), 'miniforge/bin/tailscaled')
   mod.kernel.bin.installed.conda_versions.tailscaled = '1.98.5'
   assert.equal(await mod.installed(), false, 'older than 1.104 (no --windows-mode=dev) is not accepted')
@@ -441,3 +444,18 @@ test('sign-out resets the login state, and a link the server rejected is replace
     fs.rmSync(tmp, { recursive: true, force: true })
   }
 })
+
+
+test('old Tailscale daemons are stopped and cannot be adopted through direct start', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-anywhere-version-'))
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }))
+  const anywhere = new Anywhere(fakeKernel(root, { installed: false }))
+  let stopped = 0
+  anywhere.daemonAlive = async () => true
+  anywhere.enabled = async () => true
+  anywhere.stop = async () => { stopped++ }
+  assert.equal(await anywhere.autostart(), false)
+  assert.equal(stopped, 1)
+  await assert.rejects(anywhere.start(), /Update the tailscaled tool/)
+  assert.equal(stopped, 2)
+})

package/test/conda-bin.test.js

@@ -6,16 +6,40 @@ const os = require('node:os')
 const path = require('node:path')
 const test = require('node:test')
 
-const Bin = require('../kernel/bin')
-const Conda = require('../kernel/bin/conda')
+let Bin
+let Conda
 const {
   CONDA_PIN_VERSION,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
   isExpectedCondaPinned,
   isExpectedPythonPinned,
+  TLS_PACKAGE_MINIMUMS,
+  TLS_PACKAGE_SPECS,
+  PIP_INSTALL_SPEC,
+  PIP_MIN_VERSION,
 } = require('../kernel/bin/conda-pins')
 
+test.beforeEach(t => {
+  const realExecFile = childProcess.execFile.bind(childProcess)
+  t.mock.method(childProcess, 'execFile', (binary, args, options, done) => {
+    if (args[0] !== '-I' || args[1] !== '-c') return realExecFile(binary, args, options, done)
+    const prefix = path.basename(binary) === 'python.exe' ? path.dirname(binary) : path.dirname(path.dirname(binary))
+    if (args[2].includes('certifi.where()')) {
+      done(null, path.join(prefix, 'certificates.pem') + '\n2026.10.19\n')
+      return
+    }
+    fs.readFile(path.join(prefix, 'test-pip-version'), 'utf8').then(
+      version => done(null, version), error => done(error, '')
+    )
+  })
+  for (const file of ['../kernel/bin/conda-meta', '../kernel/bin/conda', '../kernel/bin']) {
+    delete require.cache[require.resolve(file)]
+  }
+  Bin = require('../kernel/bin')
+  Conda = require('../kernel/bin/conda')
+})
+
 async function pathExists(target) {
   return fs.access(target).then(() => true).catch(() => false)
 }
@@ -49,6 +73,10 @@ async function writeHealthyCondaMeta(root, platform = 'win32', condaVersion = CO
   await writeCondaMeta(root, 'conda', condaVersion, 'py310')
   await writeCondaMeta(root, 'conda-libmamba-solver', '25.4.0', 'pyhd3eb1b0_0')
   await writeCondaMeta(root, 'python', '3.10.20', platform === 'win32' ? 'h4de0772_1_cpython' : 'cpython')
+  for (const [name, version] of Object.entries(TLS_PACKAGE_MINIMUMS)) {
+    await writeCondaMeta(root, name, version)
+  }
+  await fs.writeFile(path.join(root, 'bin/miniforge/test-pip-version'), PIP_MIN_VERSION)
 }
 
 async function writeFakeManagedConda(root, platform = 'win32') {
@@ -87,6 +115,7 @@ function restoreEnv(name, value) {
 function createConda(kernel) {
   const conda = new Conda()
   conda.kernel = kernel
+  conda.verifyInstaller = async () => {} // Installer lifecycle tests mock the download.
   return conda
 }
 
@@ -161,7 +190,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.3.2-3/Miniforge3-Windows-x86_64.exe'
+    'https://github.com/conda-forge/miniforge/releases/download/26.9.4-0/Miniforge3-Windows-x86_64.exe'
   )
 
   await conda.init()
@@ -201,7 +230,7 @@ test('Conda init writes the current Conda pin into an existing runtime', async (
 
   assert.equal(
     await fs.readFile(path.join(root, 'bin', 'miniforge', 'conda-meta', 'pinned'), 'utf8'),
-    'conda ==26.5.3'
+    ['conda ==26.5.3', ...TLS_PACKAGE_SPECS].join('\n')
   )
 })
 
@@ -253,13 +282,14 @@ test('Conda install requests the Python 3.10.20 pin on macOS/Linux', async () =>
   assert.equal(await pathExists(path.join(root, 'bin', 'miniconda')), true)
   const condaInstall = calls.find((call) => Array.isArray(call.message))
   assert.ok(condaInstall)
+  assert.equal(condaInstall.message[2], `python -I -m pip --isolated --disable-pip-version-check install --no-index --no-deps "${PIP_INSTALL_SPEC}"`)
   assert.equal(
     condaInstall.message[1],
-    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20" "conda-libmamba-solver>=25.4.0"'
+    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20" "conda-libmamba-solver>=25.4.0" pip "ca-certificates>=2026.10.19" "certifi>=2026.10.19"'
   )
   assert.equal(
     await fs.readFile(path.join(root, 'bin', 'miniforge', 'conda-meta', 'pinned'), 'utf8'),
-    'conda ==26.5.3'
+    ['conda ==26.5.3', ...TLS_PACKAGE_SPECS].join('\n')
   )
 })
 
@@ -287,7 +317,7 @@ test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async
   assert.ok(condaInstall)
   assert.equal(
     condaInstall.message[1],
-    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20=*_1_cpython" "conda-libmamba-solver>=25.4.0"'
+    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20=*_1_cpython" "conda-libmamba-solver>=25.4.0" pip "ca-certificates>=2026.10.19" "certifi>=2026.10.19"'
   )
 })
 
@@ -319,7 +349,7 @@ test('Conda install replaces the stale runtime and rebuilds declared Conda modul
   assert.ok(condaInstall)
   assert.equal(
     condaInstall.message[1],
-    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20" "conda-libmamba-solver>=25.4.0" uv=0.11.23 nodejs=22.21.1 pnpm'
+    'conda install -y --override-channels -c conda-forge "conda=26.5.3" "python=3.10.20" "conda-libmamba-solver>=25.4.0" pip "ca-certificates>=2026.10.19" "certifi>=2026.10.19" uv=0.11.23 nodejs=22.21.1 pnpm'
   )
 })
 
@@ -583,3 +613,91 @@ test('Conda install reports recovery details when the old runtime cannot be remo
     fsModule.promises.rm = originalRm
   }
 })
+
+
+test('stale certificate packages trigger the existing Conda setup checks', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-certs-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await writeHealthyCondaMeta(root, 'darwin')
+  await writeFakeManagedConda(root, 'darwin')
+  for (const [name, version] of Object.entries(TLS_PACKAGE_MINIMUMS)) {
+    await fs.rm(path.join(root, 'bin/miniforge/conda-meta', `${name}-${version}.json`))
+    await writeCondaMeta(root, name, '2026.4.22')
+  }
+  assert.equal(await createConda(createKernel(root, 'darwin')).check(), false)
+  const bin = createBin(root, 'darwin')
+  await bin.tryList()
+  assert.equal(bin.correct_conda, false)
+})
+
+test('tampered Miniforge installers leave the existing runtime untouched', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-hash-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await createMiniforge(root)
+  const kernel = createKernel(root, 'darwin')
+  kernel.bin.download = async () => fs.writeFile(path.join(root, 'bin/installer.sh'), 'tampered')
+  const conda = new Conda()
+  conda.kernel = kernel
+  await assert.rejects(conda._install({}, () => {}), /SHA-256 verification failed/)
+  assert.equal(await pathExists(path.join(root, 'bin/miniforge/Scripts/conda.exe')), true)
+})
+
+
+test('old pip cannot pass Conda readiness even with current CA packages', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-pip-ready-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await writeHealthyCondaMeta(root, 'darwin')
+  await writeFakeManagedConda(root, 'darwin')
+  await fs.writeFile(path.join(root, 'bin/miniforge/test-pip-version'), '26.2.1')
+  assert.equal(await createConda(createKernel(root, 'darwin')).check(), false)
+  const bin = createBin(root, 'darwin')
+  await bin.tryList()
+  assert.equal(bin.correct_conda, false)
+})
+
+test('certificate refresh preserves named environments and uses the new CA bundle', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-ca-refresh-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await writeHealthyCondaMeta(root, 'darwin')
+  await writeFakeManagedConda(root, 'darwin')
+  const marker = path.join(root, 'bin/miniforge/envs/app/keep')
+  await fs.mkdir(path.dirname(marker), { recursive: true })
+  await fs.writeFile(marker, 'existing app')
+  const kernel = createKernel(root, 'darwin')
+  const calls = []
+  kernel.bin.download = async () => assert.fail('must not replace a working runtime')
+  kernel.bin.exec = async payload => { calls.push(payload); return {} }
+  await createConda(kernel).install({}, () => {})
+  assert.equal(await fs.readFile(marker, 'utf8'), 'existing app')
+  assert.equal(calls.length, 2)
+  assert.equal(calls[1].env.CONDA_SSL_VERIFY, path.join(root, 'bin/miniforge/certificates.pem'))
+})
+
+test('failed pip bootstrap stops certificate refresh without replacing environments', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-ca-failed-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await writeHealthyCondaMeta(root, 'darwin')
+  await writeFakeManagedConda(root, 'darwin')
+  const kernel = createKernel(root, 'darwin')
+  kernel.bin.exec = async () => ({ error: ['ERROR: hash verification failed'] })
+  kernel.bin.download = async () => assert.fail('must preserve the runtime')
+  await assert.rejects(createConda(kernel).install({}, () => {}), /bootstrap failed/)
+  assert.equal(await pathExists(path.join(root, 'bin/miniforge/conda-meta')), true)
+})
+
+test('fresh installation does not report a failed pip bootstrap as finished', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-install-failed-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await fs.mkdir(path.join(root, 'bin'), { recursive: true })
+  const kernel = createKernel(root, 'darwin')
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.exec = async payload => {
+    if (payload.conda?.skip) {
+      await fs.mkdir(path.join(root, 'bin/miniforge/conda-meta'), { recursive: true })
+      return {}
+    }
+    return { error: ['ERROR: pip download failed'] }
+  }
+  await assert.rejects(createConda(kernel)._install({}, () => {}), /pip installation failed/)
+})

package/test/node-bin.test.js

@@ -3,7 +3,7 @@ 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 } = {}) {
+function createNode({ nodeVersion = '24.22.1', pnpmVersion = '11.9.0', hasNode = true, hasPnpm = true } = {}) {
   const node = new Node()
   const conda = new Set()
   if (hasNode) conda.add('nodejs')
@@ -23,12 +23,12 @@ function createNode({ nodeVersion = '24.18.0', pnpmVersion = '11.9.0', hasNode =
 }
 
 test('Node bin pins Node.js 24 LTS and matching pnpm', () => {
-  assert.equal(createNode().cmd(), 'nodejs=24.18.0 pnpm=11.9.0')
+  assert.equal(createNode().cmd(), 'nodejs=24.22.1 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({ nodeVersion: '24.22.1-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)

package/test/shell-run-template.test.js

@@ -377,3 +377,49 @@ test('redactEnvArgs summarizes protected argv env values', () => {
     truncated: false
   })
 })
+
+
+test('new venv bootstrap failure prevents app commands even with chain:*', { skip: process.platform === 'win32' }, async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-venv-bootstrap-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  const kernel = createKernel(root)
+  kernel.bin = { path: (...parts) => path.join(root, 'bin', ...parts) }
+  const shell = createShell(kernel)
+  shell.shell = 'bash'
+  shell.env = {}
+  shell.conda_hook = () => ':'
+  const fakeBin = path.join(root, 'fake-bin')
+  await fs.mkdir(fakeBin)
+  await fs.writeFile(path.join(fakeBin, 'python'), '#!/bin/sh\nif [ "$1" = "-m" ]; then mkdir -p "$3/bin"; touch "$3/bin/activate"; exit 0; fi\nexit 19\n', { mode: 0o755 })
+  const params = await shell.activate({ path: root, conda: { skip: true }, venv: 'env', chain: '*', message: `touch '${root}/app-ran'` })
+  const result = require('node:child_process').spawnSync('bash', ['--noprofile', '--norc', '-c', shell.build(params)], { env: { ...process.env, PATH: fakeBin + ':' + process.env.PATH }, encoding: 'utf8' })
+  assert.notEqual(result.status, 0, result.stderr)
+  assert.equal(await fs.access(path.join(root, 'app-ran')).then(() => true, () => false), false)
+})
+
+test('existing app environments do not run the creation-only pip bootstrap', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-existing-env-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await fs.mkdir(path.join(root, 'env'))
+  const shell = createShell(createKernel(root))
+  shell.shell = 'bash'
+  const params = await shell.activate({ path: root, conda: { skip: true }, venv: 'env', message: 'echo app' })
+  assert.doesNotMatch(shell.build(params), /pip.*install/)
+})
+
+
+test('existing venv with outdated pip cannot bypass the guard on a retry', { skip: process.platform === 'win32' }, async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-venv-retry-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  await fs.mkdir(path.join(root, 'env/bin'), { recursive: true })
+  await fs.writeFile(path.join(root, 'env/bin/activate'), '')
+  const fakeBin = path.join(root, 'fake-bin')
+  await fs.mkdir(fakeBin)
+  await fs.writeFile(path.join(fakeBin, 'python'), '#!/bin/sh\nexit 19\n', { mode: 0o755 })
+  const shell = createShell(createKernel(root))
+  shell.shell = 'bash'
+  const params = await shell.activate({ path: root, conda: { skip: true }, venv: 'env', chain: '*', message: `touch '${root}/app-ran'` })
+  const result = require('node:child_process').spawnSync('bash', ['--noprofile', '--norc', '-c', shell.build(params)], { env: { ...process.env, PATH: fakeBin + ':' + process.env.PATH }, encoding: 'utf8' })
+  assert.notEqual(result.status, 0, result.stderr)
+  assert.equal(await fs.access(path.join(root, 'app-ran')).then(() => true, () => false), false)
+})

package/test/uv-bin.test.js

@@ -16,13 +16,13 @@ function createUV(version) {
   return uv
 }
 
-test('UV bin pins uv to 0.11.23', () => {
-  assert.equal(createUV('0.11.23').cmd(), 'uv=0.11.23')
+test('UV bin pins uv to 0.13.4', () => {
+  assert.equal(createUV('0.13.4').cmd(), 'uv=0.13.4')
 })
 
-test('UV.installed accepts exactly uv 0.11.23', async () => {
-  assert.equal(await createUV('0.11.23').installed(), true)
-  assert.equal(await createUV('0.11.23-h1234567_0').installed(), true)
+test('UV.installed accepts exactly uv 0.13.4', async () => {
+  assert.equal(await createUV('0.13.4').installed(), true)
+  assert.equal(await createUV('0.13.4-h1234567_0').installed(), true)
   assert.equal(await createUV('0.11.22').installed(), false)
   assert.equal(await createUV('0.12.0').installed(), false)
   assert.equal(await createUV(null).installed(), false)