pinokiod 7.4.3 → 7.5.1

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.3",
+  "version": "7.5.1",
   "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) {
@@ -11730,7 +11730,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,249 @@
+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')
+}
+
+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/)
+  assert.equal(await pathExists(path.join(root, 'bin', 'miniforge')), false)
+})
+
+test('Conda init writes activation hooks only after Miniforge exists', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-init-hooks-'))
+  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+  const conda = createConda(createKernel(root))
+
+  await conda.init()
+
+  assert.equal(
+    await pathExists(path.join(root, 'bin', 'miniforge', 'etc', 'conda', 'activate.d', 'zz_pinokio_unset_ssl_cert_dir-win.bat')),
+    true
+  )
+})
+
+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 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/kernel/legacy_cleanup/ffmpeg.js

@@ -1,133 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-
-const LEGACY_FFMPEG_HOOK_NAMES = [
-  'zz_pinokio_ffmpeg.sh',
-  'zz_pinokio_ffmpeg.bat',
-  'zz_pinokio_ffmpeg.ps1',
-]
-
-const REMOVE_RETRY_COUNT = 5
-const REMOVE_RETRY_DELAY_MS = 100
-
-async function pathExists(target) {
-  return fs.promises.access(target).then(() => true).catch(() => false)
-}
-
-function legacyFfmpegRuntimePaths(kernel) {
-  if (!kernel || !kernel.bin || typeof kernel.bin.path !== 'function') {
-    return []
-  }
-  return [
-    kernel.bin.path('ffmpeg-env'),
-    kernel.bin.path('ffmpeg-pkgs'),
-    kernel.bin.path('ffmpeg'),
-    kernel.bin.path('ffmpeg-tmp'),
-  ]
-}
-
-function legacyFfmpegHookFiles(kernel) {
-  if (!kernel || !kernel.bin || typeof kernel.bin.path !== 'function') {
-    return []
-  }
-  const dirs = [
-    kernel.bin.path('miniconda', 'etc', 'conda', 'activate.d'),
-    kernel.bin.path('miniconda', 'etc', 'conda', 'deactivate.d'),
-  ]
-  return dirs.flatMap((dir) => LEGACY_FFMPEG_HOOK_NAMES.map((name) => path.resolve(dir, name)))
-}
-
-function manualFfmpegHookCleanupMessage(failures) {
-  const files = failures.map((failure) => failure.target)
-  return [
-    'Pinokio could not remove old FFmpeg Conda activation hooks.',
-    '',
-    'These old hooks can break the base Conda environment by adding the removed ffmpeg-env runtime to PATH.',
-    '',
-    'Close all Pinokio windows and any terminals using Pinokio, then delete these files if they exist:',
-    ...files.map((file) => `- ${file}`),
-    '',
-    'After deleting them, reopen Pinokio.',
-  ].join('\n')
-}
-
-class LegacyFfmpegCleanupError extends Error {
-  constructor(failures) {
-    super(manualFfmpegHookCleanupMessage(failures))
-    this.name = 'LegacyFfmpegCleanupError'
-    this.failures = failures
-  }
-}
-
-async function hasAnyPath(paths) {
-  for (const target of paths) {
-    if (await pathExists(target)) {
-      return true
-    }
-  }
-  return false
-}
-
-async function hasCleanupTargets(kernel) {
-  return await hasAnyPath(legacyFfmpegHookFiles(kernel)) ||
-    await hasAnyPath(legacyFfmpegRuntimePaths(kernel))
-}
-
-async function removeLegacyPath(target, ondata) {
-  const existed = await pathExists(target)
-  if (!existed) {
-    return { target, found: false, removed: false }
-  }
-
-  try {
-    await fs.promises.rm(target, {
-      recursive: true,
-      force: true,
-      maxRetries: REMOVE_RETRY_COUNT,
-      retryDelay: REMOVE_RETRY_DELAY_MS,
-    })
-  } catch (error) {
-    if (ondata) {
-      const reason = error && (error.code || error.message) ? error.code || error.message : String(error)
-      ondata({ raw: `could not remove legacy path: ${target} (${reason})\r\n` })
-    }
-    return { target, found: true, removed: false, error }
-  }
-
-  if (ondata) {
-    ondata({ raw: `removed legacy path: ${target}\r\n` })
-  }
-  return { target, found: true, removed: true }
-}
-
-async function run(kernel, ondata) {
-  const results = []
-  const hookFailures = []
-
-  for (const target of legacyFfmpegHookFiles(kernel)) {
-    const result = await removeLegacyPath(target, ondata)
-    results.push(result)
-    if (result.found && !result.removed) {
-      hookFailures.push(result)
-    }
-  }
-
-  if (hookFailures.length > 0) {
-    throw new LegacyFfmpegCleanupError(hookFailures)
-  }
-
-  for (const target of legacyFfmpegRuntimePaths(kernel)) {
-    results.push(await removeLegacyPath(target, ondata))
-  }
-
-  return results
-}
-
-module.exports = {
-  LegacyFfmpegCleanupError,
-  hasCleanupTargets,
-  legacyFfmpegHookFiles,
-  legacyFfmpegRuntimePaths,
-  name: 'ffmpeg',
-  run,
-}