pinokiod 8.0.2 → 8.0.3

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
@@ -220,6 +214,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 +239,8 @@ 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)
   }
   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.3",
   "description": "",
   "main": "index.js",
   "scripts": {

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,8 @@ 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 install replaces legacy miniconda with a compatibility alias to miniforge', async () => {
@@ -329,14 +320,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 +336,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 +374,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 +396,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 () => {