pinokiod 8.0.2 → 8.0.4

package/kernel/bin/caddy.js

@@ -8,6 +8,7 @@ const Util = require('../util')
 const ADMIN_READY_TIMEOUT_MS = 30000
 const ADMIN_START_TIMEOUT_MS = 5000
 const ADMIN_POLL_INTERVAL_MS = 250
+const ADMIN_STOP_TIMEOUT_MS = 5000
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
@@ -29,6 +30,35 @@ class Caddy {
       return false
     }
   }
+  async waitForStopped(timeout = ADMIN_STOP_TIMEOUT_MS, interval = ADMIN_POLL_INTERVAL_MS) {
+    const started = Date.now()
+    while ((Date.now() - started) < timeout) {
+      if (!(await this.running())) {
+        return true
+      }
+      await sleep(interval)
+    }
+    return !(await this.running())
+  }
+  async stop() {
+    if (!(await this.running())) {
+      return false
+    }
+    try {
+      await axios.post('http://127.0.0.1:2019/stop', null, {
+        timeout: ADMIN_STOP_TIMEOUT_MS
+      })
+    } catch (error) {
+      if (await this.running()) {
+        throw error
+      }
+    }
+    const stopped = await this.waitForStopped()
+    if (!stopped) {
+      throw new Error("Pinokio could not stop Caddy before replacing the managed Conda runtime.")
+    }
+    return true
+  }
   async start() {
     // if peer.https_active is true,
     // 1. kill existing caddy

package/kernel/bin/conda-pins.js

@@ -1,11 +1,12 @@
 const semver = require('semver')
 
-const CONDA_PIN_VERSION = "26.3.2"
-const CONDA_RUNTIME_MARKER = ".pinokio-runtime-v1"
+const CONDA_PIN_VERSION = "26.5.3"
 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`
 
+const isExpectedCondaPinned = (version) => String(version) === CONDA_PIN_VERSION
+
 const condaBuildNumber = (build) => {
   const chunks = String(build || "").split("_").reverse()
   const buildNumber = chunks.find((chunk) => /^\d+$/.test(chunk))
@@ -29,8 +30,8 @@ const isExpectedPythonPinned = (platform, version, build) => {
 
 module.exports = {
   CONDA_PIN_VERSION,
-  CONDA_RUNTIME_MARKER,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isExpectedCondaPinned,
   isExpectedPythonPinned,
 }

package/kernel/bin/conda.js

@@ -4,9 +4,9 @@ const semver = require('semver')
 const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
 const {
   CONDA_PIN_VERSION,
-  CONDA_RUNTIME_MARKER,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isExpectedCondaPinned,
   isExpectedPythonPinned,
 } = require('./conda-pins')
 
@@ -48,9 +48,6 @@ class Conda {
   async hasCondaMeta() {
     return await this.kernel.exists(`bin/${CONDA_ROOT_DIR}/conda-meta`)
   }
-  async hasRuntimeMarker() {
-    return await this.kernel.exists(`bin/${CONDA_ROOT_DIR}/${CONDA_RUNTIME_MARKER}`)
-  }
   env() {
     let base = {
       CONDA_PREFIX: this.kernel.bin.path(CONDA_ROOT_DIR),
@@ -96,9 +93,6 @@ report_errors: false`)
     }
   }
   async check() {
-    if (!(await this.hasRuntimeMarker())) {
-      return false
-    }
     let res = await buildCondaListFromMeta(this.kernel.bin.path(CONDA_ROOT_DIR))
 
     let lines = res.response.split(/[\r\n]+/)
@@ -118,7 +112,7 @@ report_errors: false`)
           conda_versions[name] = version
           conda_builds[name] = build
           if (name === "conda") {
-            conda_check.conda = true
+            conda_check.conda = isExpectedCondaPinned(version)
           }
           // check conda-libmamba-solver is up to date
           // sometimes it just fails silently so need to check
@@ -176,6 +170,16 @@ report_errors: false`)
     ondata({ raw: `downloading installer: ${installer_url}...\r\n` })
     await this.kernel.bin.download(installer_url, installer, ondata)
 
+    const caddy = this.kernel.bin.mod && this.kernel.bin.mod.caddy
+    let caddyWasRunning = false
+    if (caddy && typeof caddy.running === "function") {
+      caddyWasRunning = await caddy.running()
+    }
+    if (caddyWasRunning) {
+      ondata({ raw: `stopping Home Server before replacing Miniforge...\r\n` })
+      await caddy.stop()
+    }
+
     legacy_path_exists = await this.kernel.exists(`bin/${LEGACY_CONDA_ROOT_DIR}`)
     if (legacy_path_exists) {
       console.log("Removing legacy install path...", legacy_path)
@@ -208,8 +212,12 @@ report_errors: false`)
       await fs.promises.writeFile(this.kernel.path(`bin/${CONDA_ROOT_DIR}/conda-meta/pinned`), this.pinnedPackages())
     }
 
+    const dependencies = new Set(Array.isArray(req.dependencies) ? req.dependencies : [])
+    if (caddyWasRunning) {
+      dependencies.add("caddy")
+    }
     let mods = this.kernel.bin.mods.filter((m) => {
-      return req.dependencies.includes(m.name)
+      return dependencies.has(m.name)
     }).map((m) => {
       if (m.mod.cmd) {
         return m.mod.cmd()
@@ -220,6 +228,7 @@ report_errors: false`)
     console.log("Conda dependencies to install", { mods })
 
     let condaPackages = [
+      `"conda=${CONDA_PIN_VERSION}"`,
       this.kernel.platform === "win32" ? `"${WINDOWS_PYTHON_SSL_FIX_SPEC}"` : `"${PYTHON_INSTALL_SPEC}"`,
       `"conda-libmamba-solver>=25.4.0"`,
     ]
@@ -244,9 +253,12 @@ report_errors: false`)
       )
     }
     await this.ensureCompatibilityAlias()
-    await this.kernel.bin.rm(installer, ondata)
-    await fs.promises.writeFile(this.kernel.bin.path(CONDA_ROOT_DIR, CONDA_RUNTIME_MARKER), "")
     ondata({ raw: `Install finished\r\n` })
+    await this.kernel.bin.rm(installer, ondata)
+    if (caddyWasRunning) {
+      ondata({ raw: `restarting Home Server after replacing Miniforge...\r\n` })
+      await caddy.start()
+    }
   }
   async removeInstallPath(target) {
     try {

package/kernel/bin/index.js

@@ -23,7 +23,7 @@ const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
 const {
-  CONDA_RUNTIME_MARKER,
+  isExpectedCondaPinned,
   isExpectedPythonPinned,
 } = require('./conda-pins')
 const { glob } = require('glob')
@@ -350,10 +350,6 @@ class Bin {
     let conda_builds = {}
     this.correct_conda = false
 
-    const runtimeMarkerExists = await fs.promises.access(
-      this.kernel.bin.path("miniforge", CONDA_RUNTIME_MARKER)
-    ).then(() => true).catch(() => false)
-
     //////////////////////////////////////////////////////////////////
     // exception handling
     // if importlib_metadata || uvicorn || fastapi exist in the base environment, this.correct_conda = false
@@ -380,7 +376,7 @@ class Bin {
 
     let to_reset_exists = false
 
-    if (!runtimeMarkerExists || to_reset_exists) {
+    if (to_reset_exists) {
       this.correct_conda = false
     } else {
       let res = await buildCondaListFromMeta(this.kernel.bin.path("miniforge"))
@@ -396,7 +392,7 @@ class Bin {
             conda_versions[name] = version
             conda_builds[name] = build
             if (name === "conda") {
-              conda_check.conda = true
+              conda_check.conda = isExpectedCondaPinned(version)
             }
             if (name === "conda-libmamba-solver") {
               let coerced = semver.coerce(version)

package/package.json

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

package/test/caddy-install.test.js

@@ -51,3 +51,68 @@ test('caddy admin wait returns true when admin responds', async () => {
   assert.equal(ready, true)
   assert.equal(checks, 2)
 })
+
+test('caddy start uses the normal shell execution contract', async () => {
+  const caddy = new Caddy()
+  let running = false
+  let launch
+  caddy.kernel = {
+    homedir: '/tmp/pinokio',
+    peer: {
+      https_active: true,
+      announce() {}
+    },
+    processes: {},
+    exec(params, ondata) {
+      launch = params
+      running = true
+      ondata({ raw: '', cleaned: 'admin endpoint started' })
+    }
+  }
+  caddy.running = async () => running
+  caddy.installed = async () => true
+
+  await caddy.start()
+
+  assert.equal(launch.message, 'caddy run --watch')
+  assert.deepEqual(Object.keys(launch).sort(), ['message', 'path'])
+})
+
+test('caddy stop uses the native admin API only when Caddy is running', async () => {
+  const caddy = new Caddy()
+  let running = true
+  caddy.running = async () => running
+  const originalPost = require('axios').post
+  const calls = []
+  require('axios').post = async (...args) => {
+    calls.push(args)
+    running = false
+  }
+
+  try {
+    assert.equal(await caddy.stop(), true)
+    assert.equal(await caddy.stop(), false)
+  } finally {
+    require('axios').post = originalPost
+  }
+
+  assert.equal(calls.length, 1)
+  assert.equal(calls[0][0], 'http://127.0.0.1:2019/stop')
+})
+
+test('caddy stop refuses to continue when native shutdown is not confirmed', async () => {
+  const caddy = new Caddy()
+  caddy.running = async () => true
+  caddy.waitForStopped = async () => false
+  const originalPost = require('axios').post
+  require('axios').post = async () => {}
+
+  try {
+    await assert.rejects(
+      caddy.stop(),
+      /could not stop Caddy/
+    )
+  } finally {
+    require('axios').post = originalPost
+  }
+})

package/test/conda-bin.test.js

@@ -9,9 +9,9 @@ const Bin = require('../kernel/bin')
 const Conda = require('../kernel/bin/conda')
 const {
   CONDA_PIN_VERSION,
-  CONDA_RUNTIME_MARKER,
   PYTHON_INSTALL_SPEC,
   WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isExpectedCondaPinned,
   isExpectedPythonPinned,
 } = require('../kernel/bin/conda-pins')
 
@@ -44,19 +44,12 @@ async function writeCondaMeta(root, name, version, build = 'py_0') {
   )
 }
 
-async function writeHealthyCondaMeta(root, platform = 'win32') {
-  await writeCondaMeta(root, 'conda', CONDA_PIN_VERSION, 'py310')
+async function writeHealthyCondaMeta(root, platform = 'win32', condaVersion = CONDA_PIN_VERSION) {
+  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')
 }
 
-async function writeRuntimeMarker(root) {
-  const marker = path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)
-  await fs.mkdir(path.dirname(marker), { recursive: true })
-  await fs.writeFile(marker, '')
-  return marker
-}
-
 async function writeFakeManagedConda(root, platform = 'win32') {
   const condaPath = platform === 'win32'
     ? path.join(root, 'bin', 'miniforge', 'Scripts', 'conda.exe')
@@ -123,11 +116,13 @@ test('Conda uses Miniforge assets and writes conda-forge-only config', async ()
 })
 
 test('Conda pins the managed Conda and Python versions consistently', async () => {
-  assert.equal(CONDA_PIN_VERSION, '26.3.2')
-  assert.equal(CONDA_RUNTIME_MARKER, '.pinokio-runtime-v1')
+  assert.equal(CONDA_PIN_VERSION, '26.5.3')
   assert.equal(PYTHON_INSTALL_SPEC, 'python=3.10.20')
   assert.equal(WINDOWS_PYTHON_SSL_FIX_SPEC, 'python=3.10.20=*_1_cpython')
 
+  assert.equal(isExpectedCondaPinned('26.5.3'), true)
+  assert.equal(isExpectedCondaPinned('26.3.2'), false)
+
   assert.equal(isExpectedPythonPinned('darwin', '3.10.20', 'cpython'), true)
   assert.equal(isExpectedPythonPinned('linux', '3.10.20', 'cpython'), true)
   assert.equal(isExpectedPythonPinned('darwin', '3.10.21', 'cpython'), false)
@@ -136,17 +131,16 @@ test('Conda pins the managed Conda and Python versions consistently', async () =
   assert.equal(isExpectedPythonPinned('win32', '3.10.20', 'h4de0772_1_cpython'), true)
 })
 
-test('Conda init does not mark an existing runtime as rebuilt', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-marker-init-'))
+test('Conda init writes the current Conda pin into an existing runtime', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-pin-init-'))
   await createMiniforge(root)
   await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
 
   await createConda(createKernel(root, 'darwin')).init()
 
-  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)), false)
   assert.equal(
     await fs.readFile(path.join(root, 'bin', 'miniforge', 'conda-meta', 'pinned'), 'utf8'),
-    'conda ==26.3.2'
+    'conda ==26.5.3'
   )
 })
 
@@ -200,13 +194,12 @@ test('Conda install requests the Python 3.10.20 pin on macOS/Linux', async () =>
   assert.ok(condaInstall)
   assert.equal(
     condaInstall.message[1],
-    'conda install -y --override-channels -c conda-forge "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"'
   )
   assert.equal(
     await fs.readFile(path.join(root, 'bin', 'miniforge', 'conda-meta', 'pinned'), 'utf8'),
-    'conda ==26.3.2'
+    'conda ==26.5.3'
   )
-  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)), true)
 })
 
 test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async () => {
@@ -233,9 +226,8 @@ 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 "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"'
   )
-  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)), true)
 })
 
 test('Conda install replaces the stale runtime and rebuilds declared Conda modules', async () => {
@@ -266,9 +258,62 @@ 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 "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" uv=0.11.23 nodejs=22.21.1 pnpm'
   )
-  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)), true)
+})
+
+test('Conda replacement stops, preserves, and restarts a running managed Caddy', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-caddy-lifecycle-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root, 'win32')
+  const events = []
+  let caddyRunning = true
+  let condaInstall
+
+  const caddy = {
+    cmd: () => 'caddy=2.9.1',
+    running: async () => caddyRunning,
+    stop: async () => {
+      events.push('caddy-stop')
+      caddyRunning = false
+    },
+    start: async () => {
+      events.push('caddy-start')
+      caddyRunning = true
+    },
+  }
+  kernel.bin.installed.conda = new Set(['caddy'])
+  kernel.bin.mod = { caddy }
+  kernel.bin.mods = [{ name: 'caddy', mod: caddy }]
+  kernel.bin.download = async () => events.push('download')
+  kernel.bin.rm = async () => events.push('installer-cleanup')
+  kernel.bin.exec = async (payload) => {
+    if (payload && payload.conda && payload.conda.skip) {
+      events.push('bootstrap')
+      const miniforge = path.join(root, 'bin', 'miniforge')
+      await fs.mkdir(path.join(miniforge, 'conda-meta'), { recursive: true })
+      await fs.writeFile(path.join(miniforge, 'python.exe'), 'fake python\n')
+      return
+    }
+    events.push('conda-install')
+    condaInstall = payload
+  }
+
+  const conda = createConda(kernel)
+  const removeInstallPath = conda.removeInstallPath.bind(conda)
+  conda.removeInstallPath = async (target) => {
+    assert.equal(caddyRunning, false)
+    events.push('remove-miniforge')
+    await removeInstallPath(target)
+  }
+
+  await conda._install({ dependencies: [] }, () => {})
+
+  assert.ok(events.indexOf('caddy-stop') < events.indexOf('remove-miniforge'))
+  assert.ok(events.indexOf('remove-miniforge') < events.indexOf('bootstrap'))
+  assert.ok(events.indexOf('conda-install') < events.indexOf('caddy-start'))
+  assert.match(condaInstall.message[1], / caddy=2\.9\.1$/)
+  assert.equal(caddyRunning, true)
 })
 
 test('Conda install replaces legacy miniconda with a compatibility alias to miniforge', async () => {
@@ -329,14 +374,13 @@ test('Conda installed stays false when metadata check already marked Conda inval
 test('Conda check rejects metadata-only Windows installs', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-smoke-missing-'))
   await writeHealthyCondaMeta(root, 'win32')
-  await writeRuntimeMarker(root)
 
   assert.equal(await createConda(createKernel(root, 'win32')).check(), false)
 })
 
-test('Conda check rejects an otherwise healthy runtime without the runtime marker', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-marker-stale-'))
-  await writeHealthyCondaMeta(root, 'win32')
+test('Conda check rejects a runnable runtime with the previous Conda version', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-version-stale-'))
+  await writeHealthyCondaMeta(root, 'win32', '26.3.2')
   await writeFakeManagedConda(root, 'win32')
 
   assert.equal(await createConda(createKernel(root, 'win32')).check(), false)
@@ -346,24 +390,26 @@ test('Conda check accepts a runnable managed Windows conda executable', async ()
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-smoke-runnable-'))
   await writeHealthyCondaMeta(root, 'win32')
   await writeFakeManagedConda(root, 'win32')
-  await writeRuntimeMarker(root)
 
   assert.equal(await createConda(createKernel(root, 'win32')).check(), true)
 })
 
-test('Bin readiness rejects a runtime without the marker and accepts it once marked', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-bin-conda-marker-'))
-  await writeHealthyCondaMeta(root, 'win32')
-  await writeFakeManagedConda(root, 'win32')
-  const bin = createBin(root, 'win32')
+test('Bin readiness rejects the previous Conda version and accepts the pinned version', async () => {
+  const staleRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-bin-conda-version-stale-'))
+  await writeHealthyCondaMeta(staleRoot, 'win32', '26.3.2')
+  await writeFakeManagedConda(staleRoot, 'win32')
+  const staleBin = createBin(staleRoot, 'win32')
 
-  await bin.tryList()
-  assert.equal(bin.correct_conda, false)
+  await staleBin.tryList()
+  assert.equal(staleBin.correct_conda, false)
 
-  await writeRuntimeMarker(root)
+  const currentRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-bin-conda-version-current-'))
+  await writeHealthyCondaMeta(currentRoot, 'win32')
+  await writeFakeManagedConda(currentRoot, 'win32')
+  const currentBin = createBin(currentRoot, 'win32')
 
-  await bin.tryList()
-  assert.equal(bin.correct_conda, true)
+  await currentBin.tryList()
+  assert.equal(currentBin.correct_conda, true)
 })
 
 test('Conda install keeps the old runtime when the replacement installer download fails', async () => {
@@ -382,10 +428,9 @@ test('Conda install keeps the old runtime when the replacement installer downloa
     /download failed/
   )
   assert.equal(await pathExists(oldRuntimeFile), true)
-  assert.equal(await pathExists(path.join(miniforge, CONDA_RUNTIME_MARKER)), false)
 })
 
-test('Conda install leaves the runtime unmarked when bootstrap fails after replacement', async () => {
+test('Conda install propagates bootstrap failure after replacing the runtime', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-bootstrap-fails-'))
   await createMiniforge(root)
   const kernel = createKernel(root, 'darwin')
@@ -405,7 +450,6 @@ test('Conda install leaves the runtime unmarked when bootstrap fails after repla
     createConda(kernel)._install({ dependencies: [] }, () => {}),
     /bootstrap failed/
   )
-  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge', CONDA_RUNTIME_MARKER)), false)
 })
 
 test('Conda install reports manual recovery when the old runtime cannot be removed', async () => {