pinokiod 7.4.2 → 7.5.0

package/kernel/bin/cuda.js

@@ -5,7 +5,7 @@ const { glob } = require('glob')
 class Cuda {
   description = "Installs CUDA and cuDNN libraries for NVIDIA GPU workloads."
   async hasNvTargetHeader() {
-    const prefix = this.kernel.bin.path("miniconda")
+    const prefix = this.kernel.bin.path("miniforge")
     const patterns = [
       "Library/include/nv/target",
       "include/nv/target",
@@ -33,7 +33,7 @@ class Cuda {
     if (this.kernel.platform !== "win32") {
       return
     }
-    const script = this.kernel.bin.path("miniconda/etc/conda/activate.d/pinokio/~cuda-nvcc_activate.bat")
+    const script = this.kernel.bin.path("miniforge/etc/conda/activate.d/pinokio/~cuda-nvcc_activate.bat")
     let content
     try {
       content = await fs.promises.readFile(script, "utf8")
@@ -68,7 +68,7 @@ class Cuda {
     if (this.kernel.platform !== "win32") {
       return
     }
-    const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
+    const folder = this.kernel.bin.path("miniforge/etc/conda/activate.d")
     const stash = path.resolve(folder, "pinokio")
     await fs.promises.mkdir(stash, { recursive: true }).catch(() => {})
     const scripts = [
@@ -149,10 +149,10 @@ class Cuda {
                 "vs2019_compiler_vars.bat",
                 "vs2022_compiler_vars.bat",
               ]
-              const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
+              const folder = this.kernel.bin.path("miniforge/etc/conda/activate.d")
               let at_least_one_exists = false
               for(let item of deactivate_list) {
-                let exists = await this.kernel.exists("bin/miniconda/etc/conda/activate.d/" + item)
+                let exists = await this.kernel.exists("bin/miniforge/etc/conda/activate.d/" + item)
                 if (exists) {
                   // break if at least one exists
                   at_least_one_exists = true
@@ -190,11 +190,11 @@ class Cuda {
   env() {
     if (this.kernel.platform === 'win32') {
       return {
-        CUDA_HOME: this.kernel.bin.path("miniconda/Library")
+        CUDA_HOME: this.kernel.bin.path("miniforge/Library")
       }
     } else {
       return {
-        CUDA_HOME: this.kernel.bin.path("miniconda")
+        CUDA_HOME: this.kernel.bin.path("miniforge")
       }
     }
   }

package/kernel/bin/ffmpeg.js

@@ -9,28 +9,11 @@ class Ffmpeg {
     return CONDA_SPEC
   }
 
-  condaInstallFlags() {
-    if (this.kernel.platform === "win32") {
-      return `-y --solver=classic ${CONDA_CHANNEL_FLAGS}`
-    }
-    return `-y ${CONDA_CHANNEL_FLAGS}`
-  }
-
-  solverRepairCommands() {
-    if (this.kernel.platform !== "win32") {
-      return []
-    }
-    return [
-      `conda install -y --solver=classic ${CONDA_CHANNEL_FLAGS} "conda-libmamba-solver>=25.4.0" libmamba libmambapy libsolv libarchive`
-    ]
-  }
-
   async install(req, ondata) {
     await this.kernel.bin.exec({
       message: [
         "conda clean -y --all",
-        ...this.solverRepairCommands(),
-        `conda install ${this.condaInstallFlags()} ${this.cmd()}`
+        `conda install -y ${CONDA_CHANNEL_FLAGS} ${this.cmd()}`
       ]
     }, ondata)
   }

package/kernel/bin/index.js

@@ -23,8 +23,8 @@ const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { buildCondaListFromMeta } = require('./conda-meta')
 const {
+  isExpectedPythonPinned,
   isExpectedSqlitePinned,
-  isWindowsPythonSslFixed,
 } = require('./conda-pins')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
@@ -360,9 +360,9 @@ class Bin {
     // if importlib_metadata || uvicorn || fastapi exist in the base environment, this.correct_conda = false
     let site_packages_path
     if (this.platform === "win32") {
-      site_packages_path = path.resolve(this.kernel.homedir, "bin/miniconda/Lib/site-packages")
+      site_packages_path = path.resolve(this.kernel.homedir, "bin/miniforge/Lib/site-packages")
     } else {
-      site_packages_path = path.resolve(this.kernel.homedir, "bin/miniconda/lib/python3.10/site-packages")
+      site_packages_path = path.resolve(this.kernel.homedir, "bin/miniforge/lib/python3.10/site-packages")
     }
 //    // check if any of 'uvicorn', 'importlib_metadata', 'fastapi' exists
 //    let module_paths = ["fastapi", "uvicorn", "importlib_metadata"].map((name) => {
@@ -384,7 +384,7 @@ class Bin {
     if (to_reset_exists) {
       this.correct_conda = false
     } else {
-      let res = await buildCondaListFromMeta(this.kernel.bin.path("miniconda"))
+      let res = await buildCondaListFromMeta(this.kernel.bin.path("miniforge"))
       let lines = res.response.split(/[\r\n]+/)
       for(let line of lines) {
         if (start) {
@@ -400,11 +400,8 @@ class Bin {
               conda_check.conda = true
             }
             if (name === "conda-libmamba-solver") {
-              //if (String(version) === "24.7.0") {
-              let channel = chunks[3]
               let coerced = semver.coerce(version)
               let mamba_requirement = ">=25.4.0"
-              //if (semver.satisfies(coerced, mamba_requirement) && channel === "conda-forge") {
               if (semver.satisfies(coerced, mamba_requirement)) {
                 conda_check.mamba = true
               }
@@ -417,7 +414,7 @@ class Bin {
               }
             }
             if (name === "python") {
-              conda_check.python = this.platform !== "win32" || isWindowsPythonSslFixed(version, build)
+              conda_check.python = isExpectedPythonPinned(this.platform, version, build)
             }
           }
         } else {
@@ -427,8 +424,7 @@ class Bin {
         }
       }
 
-      if (conda_check.conda && conda_check.mamba && conda_check.sqlite && (this.platform !== "win32" || conda_check.python)) {
-      //if (conda_check.conda && conda_check.mamba) {
+      if (conda_check.conda && conda_check.mamba && conda_check.sqlite && conda_check.python) {
         this.correct_conda = true
       }
     }
@@ -449,7 +445,7 @@ class Bin {
     // 1. conda
 
     // check conda location and see if it exists. only run if it exists
-    let conda_path = path.resolve(this.kernel.homedir, "bin", "miniconda")
+    let conda_path = path.resolve(this.kernel.homedir, "bin", "miniforge")
     let conda_exists = await this.exists(conda_path)
 
     let start
@@ -513,7 +509,7 @@ class Bin {
     }
 
 //    /// B. base path initialization
-//    let conda_meta_path = this.kernel.bin.path("miniconda", "conda-meta")
+//    let conda_meta_path = this.kernel.bin.path("miniforge", "conda-meta")
 //    const metaFiles = await glob("*.json", {
 //      cwd: conda_meta_path
 //    })

package/kernel/connect/providers/huggingface/index.js

@@ -39,11 +39,11 @@ class Huggingface {
   }
   hfPath() {
     const candidates = this.kernel.platform === "win32" ? [
-      this.kernel.path("bin", "miniconda", "Scripts", "hf.exe"),
-      this.kernel.path("bin", "miniconda", "Scripts", "hf"),
-      this.kernel.path("bin", "miniconda", "bin", "hf"),
+      this.kernel.path("bin", "miniforge", "Scripts", "hf.exe"),
+      this.kernel.path("bin", "miniforge", "Scripts", "hf"),
+      this.kernel.path("bin", "miniforge", "bin", "hf"),
     ] : [
-      this.kernel.path("bin", "miniconda", "bin", "hf"),
+      this.kernel.path("bin", "miniforge", "bin", "hf"),
     ]
     for (const candidate of candidates) {
       if (fs.existsSync(candidate)) {

package/kernel/index.js

@@ -43,7 +43,6 @@ const AppLauncher = require('./app_launcher')
 const ReadyState = require('./ready')
 const Autolaunch = require('./autolaunch')
 const LaunchRequirements = require('./launch_requirements')
-const LegacyCleanup = require('./legacy_cleanup')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
@@ -101,7 +100,6 @@ class Kernel {
     this.launchRequirements = new LaunchRequirements(this)
     this.autolaunch = new Autolaunch(this)
     this.autolaunch_status = this.autolaunch.startupStatus()
-    this.legacyCleanup = new LegacyCleanup(this)
     this.sysReady = new Promise((resolve) => {
       this._resolveSysReady = resolve
     })
@@ -1194,11 +1192,6 @@ class Kernel {
         await Environment.ensurePinokioCacheDirs(this, {
           throwOnFailure: true
         })
-        await this.legacyCleanup.runOnce((event) => {
-          if (event && typeof event.raw === "string") {
-            console.log(event.raw.trimEnd())
-          }
-        })
 
         // if key.json doesn't exist, create an empty json file
         let ee = await this.exists(this.homedir, "key.json")

package/kernel/shell.js

@@ -21,6 +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 home = os.homedir()
 
 function normalizeComparablePath(filePath, platform) {
@@ -959,7 +960,7 @@ class Shell {
   conda_hook () {
     if (this.platform === "win32") {
       if (/bash/i.test(this.shell)) {
-        const conda_sh = this.kernel.path("bin/miniconda/etc/profile.d/conda.sh")
+        const conda_sh = this.kernel.path("bin/miniforge/etc/profile.d/conda.sh")
         return `source ${this.quoteArgForShell(Util.p2u(conda_sh))}`
       } else {
         return "conda_hook"
@@ -986,7 +987,7 @@ class Shell {
     // 1. conda
     let conda_path
     let conda_name
-    let conda_python = "python=3.10"
+    let conda_python = PYTHON_INSTALL_SPEC
     let conda_args
     let conda_activate
 
@@ -1106,7 +1107,7 @@ class Shell {
 //          timeout,
         ]
       } else {
-        let envs_path = this.kernel.bin.path("miniconda/envs")
+        let envs_path = this.kernel.bin.path("miniforge/envs")
         let env_path = path.resolve(envs_path, conda_name)
         let env_exists = await this.exists(env_path)
         if (env_exists) {
@@ -1185,7 +1186,7 @@ class Shell {
             console.log(`Unsupported arch: os.arch()=${architecture}, process.arch=${armArchitecture}`)
           }
 
-          const activate_root = this.kernel.bin.path("miniconda/etc/conda/activate.d")
+          const activate_root = this.kernel.bin.path("miniforge/etc/conda/activate.d")
           const logDir = this.kernel.path("cache", "logs")
           await fs.promises.mkdir(logDir, { recursive: true }).catch(() => {})
           const logSuffix = this.id || Date.now()

package/kernel/sysinfo.js

@@ -206,7 +206,7 @@ class Sysinfo {
 //    console.log(_res)
 //    console.log("############### DEBUGGING ENV FINISH")
 
-    let conda_path = path.resolve(this.kernel.homedir, "bin", "miniconda")
+    let conda_path = path.resolve(this.kernel.homedir, "bin", "miniforge")
     let conda_exists = await this.exists(conda_path)
 
     let res

package/kernel/util.js

@@ -199,9 +199,9 @@ const filepicker = async(req, ondata, kernel) => {
     let picker_path = kernel.path("bin/py/picker.py")
     let python
     if (kernel.platform === "win32") {
-      python = kernel.path("bin/miniconda/python")
+      python = kernel.path("bin/miniforge/python")
     } else {
-      python = kernel.path("bin/miniconda/bin/python")
+      python = kernel.path("bin/miniforge/bin/python")
     }
     const proc = spawn(python, [picker_path])
 

package/package.json

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

package/server/index.js

@@ -501,7 +501,7 @@ class Server {
     if (this.kernel.platform !== "win32") {
       return null
     }
-    const bashPath = this.kernel.path("bin/miniconda/Library/bin/bash.exe")
+    const bashPath = this.kernel.path("bin/miniforge/Library/bin/bash.exe")
     return await this.exists(bashPath) ? bashPath : null
   }
   running_dynamic (name, menu, selected_query) {
@@ -6013,7 +6013,7 @@ class Server {
         this.kernel.store.set("version", this.version.pinokiod)
         console.log("[DONE] Updating to the new version")
         console.log("not up to date. update py.")
-        // remove ~/bin/miniconda/py
+        // remove ~/bin/py
         let p = path.resolve(home, "bin/py")
         console.log(`[TRY] reset ${p}`)
         await fse.remove(p)
@@ -10034,7 +10034,6 @@ class Server {
         return
       }
       // check bin folder
-//      let bin_path = this.kernel.path("bin/miniconda")
 //      let bin_exists = await this.exists(bin_path)
 //      if (!bin_exists) {
 //        res.redirect("/setup")
@@ -11730,7 +11729,7 @@ class Server {
         managedLaunchOverrides.conda = { skip: true }
       }
       if (isWindowsPlatform && (provider.key === "codex" || provider.key === "claude")) {
-        const gitBashPath = this.kernel.path("bin/miniconda/Library/bin/bash.exe")
+        const gitBashPath = this.kernel.path("bin/miniforge/Library/bin/bash.exe")
         const bashExists = await fs.promises.access(gitBashPath, fs.constants.F_OK).then(() => true).catch(() => false)
         if (bashExists) {
           if (provider.key === "claude") {

package/system/plugin/claude/pinokio.js

@@ -7,12 +7,12 @@ module.exports = {
     id: "run",
     method: "shell.run",
     params: {
-      shell: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}",
+      shell: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}",
       conda: {
         skip: true
       },
       env: {
-        CLAUDE_CODE_GIT_BASH_PATH: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}"
+        CLAUDE_CODE_GIT_BASH_PATH: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}"
       },
       message: {
         _: [

package/system/plugin/claude-auto/pinokio.js

@@ -8,12 +8,12 @@ module.exports = {
     id: "run",
     method: "shell.run",
     params: {
-      shell: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}",
+      shell: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}",
       conda: {
         skip: true
       },
       env: {
-        CLAUDE_CODE_GIT_BASH_PATH: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}",
+        CLAUDE_CODE_GIT_BASH_PATH: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}",
         CLAUBBIT: "true"
       },
       message: {

package/system/plugin/codex/pinokio.js

@@ -7,7 +7,7 @@ module.exports = {
     id: "run",
     method: "shell.run",
     params: {
-      shell: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}",
+      shell: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}",
       conda: {
         skip: true
       },

package/system/plugin/codex-auto/pinokio.js

@@ -8,7 +8,7 @@ module.exports = {
     id: "run",
     method: "shell.run",
     params: {
-      shell: "{{kernel.path('bin/miniconda/Library/bin/bash.exe')}}",
+      shell: "{{kernel.path('bin/miniforge/Library/bin/bash.exe')}}",
       conda: {
         skip: true
       },

package/test/conda-bin.test.js

@@ -0,0 +1,254 @@
+const assert = require('node:assert/strict')
+const fsModule = require('node:fs')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+
+const Conda = require('../kernel/bin/conda')
+const {
+  PYTHON_INSTALL_SPEC,
+  WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isExpectedPythonPinned,
+} = require('../kernel/bin/conda-pins')
+
+async function pathExists(target) {
+  return fs.access(target).then(() => true).catch(() => false)
+}
+
+function createKernel(root, platform = 'win32') {
+  return {
+    arch: 'x64',
+    homedir: root,
+    platform,
+    path: (...parts) => path.join(root, ...parts),
+    exists: async (...parts) => pathExists(path.join(root, ...parts)),
+    bin: {
+      correct_conda: true,
+      path: (...parts) => path.join(root, 'bin', ...parts),
+      exists: async (target) => pathExists(path.join(root, 'bin', target)),
+    },
+  }
+}
+
+async function createCondaRoot(root, name) {
+  const condaRoot = path.join(root, 'bin', name)
+  await fs.mkdir(path.join(condaRoot, 'Scripts'), { recursive: true })
+  await fs.writeFile(path.join(condaRoot, 'Scripts', 'conda.exe'), 'fake conda\n')
+  return condaRoot
+}
+
+async function createMiniforge(root) {
+  return createCondaRoot(root, 'miniforge')
+}
+
+async function createLegacyMiniconda(root) {
+  return createCondaRoot(root, 'miniconda')
+}
+
+async function writeCurrentRuntimeStamp(root) {
+  await fs.writeFile(
+    path.join(root, 'bin', 'miniforge', '.pinokio-runtime.json'),
+    `${JSON.stringify({
+      distribution: 'miniforge',
+      release: '26.3.2-3',
+      epoch: 1,
+    }, null, 2)}\n`
+  )
+}
+
+function createConda(kernel) {
+  const conda = new Conda()
+  conda.kernel = kernel
+  return conda
+}
+
+test('Conda uses Miniforge assets and writes conda-forge-only config', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-miniforge-config-'))
+  const conda = createConda(createKernel(root))
+
+  assert.equal(
+    conda.urls.win32.x64,
+    'https://github.com/conda-forge/miniforge/releases/download/26.3.2-3/Miniforge3-Windows-x86_64.exe'
+  )
+
+  await conda.init()
+  const condarc = await fs.readFile(path.join(root, 'condarc'), 'utf8')
+
+  assert.match(condarc, /^channels:\n  - conda-forge\n/m)
+  assert.match(condarc, /  - python=3\.10\.20\n/)
+  assert.match(condarc, /bin\/miniforge\/envs/)
+  assert.doesNotMatch(condarc, /bin\/miniconda\/envs/)
+  assert.doesNotMatch(condarc, /\bdefaults\b/)
+  assert.doesNotMatch(condarc, /auto_accept_tos/)
+})
+
+test('Conda pins Python 3.10.20 consistently across platforms', async () => {
+  assert.equal(PYTHON_INSTALL_SPEC, 'python=3.10.20')
+  assert.equal(WINDOWS_PYTHON_SSL_FIX_SPEC, 'python=3.10.20=*_1_cpython')
+
+  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)
+  assert.equal(isExpectedPythonPinned('darwin', '3.11.0', 'cpython'), false)
+  assert.equal(isExpectedPythonPinned('win32', '3.10.20', 'h4de0772_0_cpython'), false)
+  assert.equal(isExpectedPythonPinned('win32', '3.10.20', 'h4de0772_1_cpython'), true)
+})
+
+test('Conda install requests the Python 3.10.20 pin on macOS/Linux', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-python-pin-darwin-'))
+  const kernel = createKernel(root, 'darwin')
+  const calls = []
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.rm = async () => {}
+  kernel.bin.exec = async (payload) => {
+    calls.push(payload)
+    if (payload && payload.conda && payload.conda.skip) {
+      await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+    }
+  }
+
+  await createConda(kernel)._install({ dependencies: [] }, () => {})
+
+  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[1],
+    'conda install -y --override-channels -c conda-forge "python=3.10.20" "sqlite=3.47.2" "conda-libmamba-solver>=25.4.0"'
+  )
+})
+
+test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-python-pin-win32-'))
+  const kernel = createKernel(root, 'win32')
+  const calls = []
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.rm = async () => {}
+  kernel.bin.exec = async (payload) => {
+    calls.push(payload)
+    if (payload && payload.conda && payload.conda.skip) {
+      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')
+    }
+  }
+
+  await createConda(kernel)._install({ dependencies: [] }, () => {})
+
+  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[1],
+    'conda install -y --override-channels -c conda-forge "python=3.10.20=*_1_cpython" "sqlite=3.53.2" "conda-libmamba-solver>=25.4.0"'
+  )
+})
+
+test('Conda install replaces legacy miniconda with a compatibility alias to miniforge', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-miniforge-alias-'))
+  const legacy = await createLegacyMiniconda(root)
+  await fs.writeFile(path.join(legacy, 'legacy.txt'), 'old runtime\n')
+  const kernel = createKernel(root, 'darwin')
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.rm = async () => {}
+  kernel.bin.exec = async (payload) => {
+    if (payload && payload.conda && payload.conda.skip) {
+      await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+    }
+  }
+
+  await createConda(kernel)._install({ dependencies: [] }, () => {})
+
+  const miniforge = path.join(root, 'bin', 'miniforge')
+  const miniconda = path.join(root, 'bin', 'miniconda')
+  assert.equal(await pathExists(path.join(miniconda, 'legacy.txt')), false)
+  assert.equal(await fs.realpath(miniconda), await fs.realpath(miniforge))
+})
+
+test('Conda install removes legacy miniconda symlinks without deleting their target', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-legacy-symlink-'))
+  const external = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-external-'))
+  await fs.writeFile(path.join(external, 'keep.txt'), 'do not delete\n')
+  await fs.mkdir(path.join(root, 'bin'), { recursive: true })
+  await fs.symlink(external, path.join(root, 'bin', 'miniconda'), 'dir')
+  const kernel = createKernel(root, 'darwin')
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.rm = async () => {}
+  kernel.bin.exec = async (payload) => {
+    if (payload && payload.conda && payload.conda.skip) {
+      await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+    }
+  }
+
+  await createConda(kernel)._install({ dependencies: [] }, () => {})
+
+  assert.equal(await pathExists(path.join(external, 'keep.txt')), true)
+  assert.equal(await fs.realpath(path.join(root, 'bin', 'miniconda')), await fs.realpath(path.join(root, 'bin', 'miniforge')))
+})
+
+test('Conda installed stays false when metadata check already marked Conda invalid', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-metadata-invalid-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root)
+  kernel.bin.correct_conda = false
+
+  assert.equal(await createConda(kernel).installed(), false)
+})
+
+test('Conda installed returns false for old Conda runtimes without the Miniforge stamp', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-runtime-stale-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root)
+
+  assert.equal(await createConda(kernel).installed(), false)
+})
+
+test('Conda install keeps the old runtime when the replacement installer download fails', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-download-fails-'))
+  const miniconda = await createLegacyMiniconda(root)
+  const kernel = createKernel(root)
+
+  kernel.bin.download = async () => {
+    throw new Error('download failed')
+  }
+
+  await assert.rejects(
+    createConda(kernel)._install({ dependencies: [] }, () => {}),
+    /download failed/
+  )
+  assert.equal(await pathExists(miniconda), true)
+  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge')), false)
+})
+
+test('Conda install reports manual recovery when the old runtime cannot be removed', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-runtime-locked-'))
+  await createLegacyMiniconda(root)
+  const kernel = createKernel(root)
+  kernel.bin.download = async () => {}
+  const conda = createConda(kernel)
+  const originalRm = fsModule.promises.rm
+
+  fsModule.promises.rm = async () => {
+    const error = new Error('resource busy')
+    error.code = 'EBUSY'
+    throw error
+  }
+
+  try {
+    await assert.rejects(
+      conda._install({ dependencies: [] }, () => {}),
+      /delete that folder manually/
+    )
+  } finally {
+    fsModule.promises.rm = originalRm
+  }
+})

package/test/ffmpeg-bin.test.js

@@ -34,14 +34,13 @@ test('FFmpeg bin installs pinned ffmpeg into base Conda on Windows', async () =>
   assert.equal(calls.length, 1)
   assert.deepEqual(calls[0].message, [
     'conda clean -y --all',
-    'conda install -y --solver=classic --override-channels -c conda-forge "conda-libmamba-solver>=25.4.0" libmamba libmambapy libsolv libarchive',
-    'conda install -y --solver=classic --override-channels -c conda-forge ffmpeg=8.1.2',
+    'conda install -y --override-channels -c conda-forge ffmpeg=8.1.2',
   ])
   assert.equal(calls[0].env, undefined)
   assert.equal(calls[0].message.some((command) => /ffmpeg-env|conda create|-p /.test(command)), false)
 })
 
-test('FFmpeg bin installs pinned ffmpeg into base Conda without Windows solver repair elsewhere', async () => {
+test('FFmpeg bin installs pinned ffmpeg into base Conda consistently across platforms', async () => {
   const calls = []
   const kernel = createKernel('darwin')
   kernel.bin.exec = async (payload) => {