pinokiod 7.5.0 → 7.5.1

package/kernel/bin/conda-meta.js

@@ -2,21 +2,21 @@ const fs = require('fs')
 const path = require('path')
 const { execFile } = require('child_process')
 
-async function buildCondaListFromMeta(condaRootPath, useCondaList) {
+async function buildCondaListFromMeta(minicondaPath, useCondaList) {
   if (!useCondaList) {
-    const metaOutput = await readFromMeta(condaRootPath)
+    const metaOutput = await readFromMeta(minicondaPath)
     if (metaOutput) {
       return { response: metaOutput, source: 'conda-meta' }
     }
   }
-  return await runCondaList(condaRootPath)
+  return await runCondaList(minicondaPath)
 }
 
-async function readFromMeta(condaRootPath) {
-  if (!condaRootPath) {
+async function readFromMeta(minicondaPath) {
+  if (!minicondaPath) {
     return null
   }
-  const metaDir = path.join(condaRootPath, 'conda-meta')
+  const metaDir = path.join(minicondaPath, 'conda-meta')
   let entries
   try {
     entries = await fs.promises.readdir(metaDir, { withFileTypes: true })
@@ -53,8 +53,8 @@ async function readFromMeta(condaRootPath) {
   return lines.join('\n')
 }
 
-async function runCondaList(condaRootPath) {
-  const condaBinary = resolveCondaBinary(condaRootPath)
+async function runCondaList(minicondaPath) {
+  const condaBinary = resolveCondaBinary(minicondaPath)
   if (!condaBinary) {
     return { response: '', source: 'conda-list' }
   }
@@ -69,18 +69,18 @@ async function runCondaList(condaRootPath) {
   })
 }
 
-function resolveCondaBinary(condaRootPath) {
+function resolveCondaBinary(minicondaPath) {
   if (process.platform === 'win32') {
-    if (condaRootPath) {
-      const scriptPath = path.join(condaRootPath, 'Scripts', 'conda.exe')
+    if (minicondaPath) {
+      const scriptPath = path.join(minicondaPath, 'Scripts', 'conda.exe')
       if (fs.existsSync(scriptPath)) {
         return scriptPath
       }
     }
     return 'conda'
   }
-  if (condaRootPath) {
-    const binPath = path.join(condaRootPath, 'bin', 'conda')
+  if (minicondaPath) {
+    const binPath = path.join(minicondaPath, 'bin', 'conda')
     if (fs.existsSync(binPath)) {
       return binPath
     }

package/kernel/bin/conda.js

@@ -16,12 +16,7 @@ const {
 const MINIFORGE_RELEASE = "26.3.2-3"
 const MINIFORGE_BASE_URL = `https://github.com/conda-forge/miniforge/releases/download/${MINIFORGE_RELEASE}`
 const CONDA_ROOT_DIR = "miniforge"
-const CONDA_COMPAT_ROOT_DIR = "miniconda"
-const PINOKIO_CONDA_RUNTIME = {
-  distribution: "miniforge",
-  release: MINIFORGE_RELEASE,
-  epoch: 1,
-}
+const LEGACY_CONDA_ROOT_DIR = "miniconda"
 
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
@@ -54,26 +49,8 @@ class Conda {
       sqlitePinnedSpec(this.kernel.platform),
     ].join("\n")
   }
-  runtimeStampPath() {
-    return this.kernel.bin.path(CONDA_ROOT_DIR, ".pinokio-runtime.json")
-  }
-  async hasCurrentRuntimeStamp() {
-    try {
-      const value = await fs.promises.readFile(this.runtimeStampPath(), "utf8")
-      const runtime = JSON.parse(value)
-      return !!(runtime &&
-        runtime.distribution === PINOKIO_CONDA_RUNTIME.distribution &&
-        runtime.release === PINOKIO_CONDA_RUNTIME.release &&
-        runtime.epoch === PINOKIO_CONDA_RUNTIME.epoch)
-    } catch (e) {
-      return false
-    }
-  }
-  async writeRuntimeStamp() {
-    await fs.promises.writeFile(
-      this.runtimeStampPath(),
-      `${JSON.stringify(PINOKIO_CONDA_RUNTIME, null, 2)}\n`
-    )
+  async hasCondaMeta() {
+    return await this.kernel.exists(`bin/${CONDA_ROOT_DIR}/conda-meta`)
   }
   env() {
     let base = {
@@ -100,6 +77,9 @@ class Conda {
     if (this.kernel.platform !== "win32") {
       return
     }
+    if (!(await this.hasCondaMeta())) {
+      return
+    }
     const activateDir = this.kernel.bin.path(`${CONDA_ROOT_DIR}/etc/conda/activate.d`)
     await fs.promises.mkdir(activateDir, { recursive: true }).catch(() => {})
     await fs.promises.writeFile(
@@ -141,12 +121,12 @@ remote_connect_timeout_secs: 20.0
 remote_read_timeout_secs: 300.0
 remote_max_retries: 6
 report_errors: false`)
-      let pinned_exists = await this.kernel.exists(`bin/${CONDA_ROOT_DIR}/conda-meta`)
+      let pinned_exists = await this.hasCondaMeta()
       if (pinned_exists) {
         await fs.promises.writeFile(this.kernel.path(`bin/${CONDA_ROOT_DIR}/conda-meta/pinned`), this.pinnedPackages())
+        await this.ensureSslCertDirOverride()
+        await this.ensureCompatibilityAlias()
       }
-      await this.ensureSslCertDirOverride()
-      await this.ensureCompatibilityAlias()
     }
   }
   async check() {
@@ -228,10 +208,10 @@ report_errors: false`)
     const installer_url = this.urls[this.kernel.platform][this.kernel.arch]
     const installer = this.installer[this.kernel.platform]
     const install_path = this.kernel.bin.path(CONDA_ROOT_DIR)
-    const compat_path = this.kernel.bin.path(CONDA_COMPAT_ROOT_DIR)
+    const legacy_path = this.kernel.bin.path(LEGACY_CONDA_ROOT_DIR)
     let install_path_exists = await this.kernel.exists(`bin/${CONDA_ROOT_DIR}`)
-    let compat_path_exists = await this.kernel.exists(`bin/${CONDA_COMPAT_ROOT_DIR}`)
-    if (install_path_exists || compat_path_exists) {
+    let legacy_path_exists = await this.kernel.exists(`bin/${LEGACY_CONDA_ROOT_DIR}`)
+    if (install_path_exists || legacy_path_exists) {
       console.log("Install path already exists. Will replace after installer download...", install_path)
     } else {
       console.log("Install path does not exist. Installing...")
@@ -240,10 +220,10 @@ report_errors: false`)
     ondata({ raw: `downloading installer: ${installer_url}...\r\n` })
     await this.kernel.bin.download(installer_url, installer, ondata)
 
-    compat_path_exists = await this.kernel.exists(`bin/${CONDA_COMPAT_ROOT_DIR}`)
-    if (compat_path_exists) {
-      console.log("Removing compatibility install path...", compat_path)
-      await this.removeInstallPath(compat_path)
+    legacy_path_exists = await this.kernel.exists(`bin/${LEGACY_CONDA_ROOT_DIR}`)
+    if (legacy_path_exists) {
+      console.log("Removing legacy install path...", legacy_path)
+      await this.removeInstallPath(legacy_path)
     }
     install_path_exists = await this.kernel.exists(`bin/${CONDA_ROOT_DIR}`)
     if (install_path_exists) {
@@ -309,7 +289,6 @@ report_errors: false`)
       )
     }
     await this.ensureSslCertDirOverride()
-    await this.writeRuntimeStamp()
     await this.ensureCompatibilityAlias()
     ondata({ raw: `Install finished\r\n` })
     await this.kernel.bin.rm(installer, ondata)
@@ -346,9 +325,8 @@ report_errors: false`)
   }
   async ensureCompatibilityAlias() {
     const target = this.kernel.bin.path(CONDA_ROOT_DIR)
-    const alias = this.kernel.bin.path(CONDA_COMPAT_ROOT_DIR)
-    const targetExists = await fs.promises.access(target).then(() => true).catch(() => false)
-    if (!targetExists) {
+    const alias = this.kernel.bin.path(LEGACY_CONDA_ROOT_DIR)
+    if (!(await this.hasCondaMeta())) {
       return
     }
     const aliasExists = await fs.promises.lstat(alias).then(() => true).catch(() => false)
@@ -378,10 +356,6 @@ report_errors: false`)
     for(let p of this.paths[this.kernel.platform]) {
       let e = await this.kernel.bin.exists(p)
       if (e && this.kernel.bin.correct_conda) {
-        if (!(await this.hasCurrentRuntimeStamp())) {
-          console.log("Pinokio Conda runtime changed; marking Conda invalid")
-          return false
-        }
         return true
       }
     }
@@ -389,7 +363,7 @@ report_errors: false`)
   }
 
   async uninstall(req, ondata) {
-    await this.kernel.bin.rm(CONDA_COMPAT_ROOT_DIR, ondata)
+    await this.kernel.bin.rm(LEGACY_CONDA_ROOT_DIR, ondata)
     return this.kernel.bin.rm(CONDA_ROOT_DIR, ondata)
   }
 

package/package.json

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

package/server/index.js

@@ -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/py
+        // remove ~/bin/miniconda/py
         let p = path.resolve(home, "bin/py")
         console.log(`[TRY] reset ${p}`)
         await fse.remove(p)
@@ -10034,6 +10034,7 @@ 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")

package/test/conda-bin.test.js

@@ -46,17 +46,6 @@ 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
@@ -81,6 +70,20 @@ test('Conda uses Miniforge assets and writes conda-forge-only config', async ()
   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 () => {
@@ -204,14 +207,6 @@ test('Conda installed stays false when metadata check already marked Conda inval
   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)