pinokiod 7.5.29 → 7.5.30

package/kernel/bin/conda-meta.js

@@ -69,15 +69,27 @@ async function runCondaList(minicondaPath) {
   })
 }
 
-function resolveCondaBinary(minicondaPath) {
-  if (process.platform === 'win32') {
+async function managedCondaRuns(minicondaPath, platform = process.platform) {
+  const condaBinary = resolveCondaBinary(minicondaPath, platform, false)
+  if (!condaBinary) {
+    return false
+  }
+  return await new Promise((resolve) => {
+    execFile(condaBinary, ['--version'], { windowsHide: true, timeout: 15000 }, (err) => {
+      resolve(!err)
+    })
+  })
+}
+
+function resolveCondaBinary(minicondaPath, platform = process.platform, allowFallback = true) {
+  if (platform === 'win32') {
     if (minicondaPath) {
       const scriptPath = path.join(minicondaPath, 'Scripts', 'conda.exe')
       if (fs.existsSync(scriptPath)) {
         return scriptPath
       }
     }
-    return 'conda'
+    return allowFallback ? 'conda' : null
   }
   if (minicondaPath) {
     const binPath = path.join(minicondaPath, 'bin', 'conda')
@@ -85,9 +97,10 @@ function resolveCondaBinary(minicondaPath) {
       return binPath
     }
   }
-  return 'conda'
+  return allowFallback ? 'conda' : null
 }
 
 module.exports = {
-  buildCondaListFromMeta
+  buildCondaListFromMeta,
+  managedCondaRuns,
 }

package/kernel/bin/conda.js

@@ -2,7 +2,7 @@ const fs = require('fs')
 const path = require('path')
 const { glob } = require('glob')
 const semver = require('semver')
-const { buildCondaListFromMeta } = require('./conda-meta')
+const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
 const {
   CONDA_PIN_VERSION,
   PYTHON_INSTALL_SPEC,
@@ -73,33 +73,45 @@ class Conda {
     if (this.kernel.platform !== "win32") {
       return
     }
-    if (!(await this.hasCondaMeta())) {
+    const condaRootDirs = []
+    for (const rootDir of [CONDA_ROOT_DIR, LEGACY_CONDA_ROOT_DIR]) {
+      if (await this.kernel.exists(`bin/${rootDir}/conda-meta`)) {
+        condaRootDirs.push(rootDir)
+      }
+    }
+    if (condaRootDirs.length === 0) {
       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(
-      path.resolve(activateDir, "zz_pinokio_unset_ssl_cert_dir-win.bat"),
-      `@echo off
+    const hookFiles = {
+      "zz_pinokio_unset_ssl_cert_dir-win.bat": `@echo off
 if "%__CONDA_OPENSSL_CERT_DIR_SET%"=="1" (
     set "SSL_CERT_DIR="
+    set "__CONDA_OPENSSL_CERT_DIR_SET="
 )
-`
-    )
-    await fs.promises.writeFile(
-      path.resolve(activateDir, "zz_pinokio_unset_ssl_cert_dir-win.ps1"),
-      `if ($Env:__CONDA_OPENSSL_CERT_DIR_SET -eq "1") {
+`,
+      "zz_pinokio_unset_ssl_cert_dir-win.ps1": `if ($Env:__CONDA_OPENSSL_CERT_DIR_SET -eq "1") {
   Remove-Item -Path Env:\\SSL_CERT_DIR -ErrorAction SilentlyContinue
+  Remove-Item -Path Env:\\__CONDA_OPENSSL_CERT_DIR_SET -ErrorAction SilentlyContinue
 }
-`
-    )
-    await fs.promises.writeFile(
-      path.resolve(activateDir, "zz_pinokio_unset_ssl_cert_dir-win.sh"),
-      `if [[ "\${__CONDA_OPENSSL_CERT_DIR_SET:-}" == "1" ]]; then
+`,
+      "zz_pinokio_unset_ssl_cert_dir-win.sh": `if [[ "\${__CONDA_OPENSSL_CERT_DIR_SET:-}" == "1" ]]; then
   unset SSL_CERT_DIR
+  unset __CONDA_OPENSSL_CERT_DIR_SET
 fi
-`
-    )
+`,
+    }
+    for (const rootDir of condaRootDirs) {
+      const hookDirs = [
+        this.kernel.bin.path(`${rootDir}/etc/conda/activate.d`),
+        this.kernel.bin.path(`${rootDir}/etc/conda/deactivate.d`),
+      ]
+      for (const hookDir of hookDirs) {
+        await fs.promises.mkdir(hookDir, { recursive: true }).catch(() => {})
+        for (const [filename, content] of Object.entries(hookFiles)) {
+          await fs.promises.writeFile(path.resolve(hookDir, filename), content)
+        }
+      }
+    }
   }
   async init() {
     if (this.kernel.homedir) {
@@ -120,9 +132,9 @@ report_errors: false`)
       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()
     }
   }
   async check() {
@@ -170,7 +182,10 @@ report_errors: false`)
     this.kernel.bin.installed.conda = conda
     this.kernel.bin.installed.conda_versions = conda_versions
     this.kernel.bin.installed.conda_builds = conda_builds
-    return conda_check.conda && conda_check.mamba && conda_check.python
+    if (!(conda_check.conda && conda_check.mamba && conda_check.python)) {
+      return false
+    }
+    return await managedCondaRuns(this.kernel.bin.path(CONDA_ROOT_DIR), this.kernel.platform)
   }
   async install(req, ondata) {
     for(let i=0; i<5; i++) {

package/kernel/bin/index.js

@@ -21,7 +21,7 @@ const LLVM = require('./llvm')
 const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
-const { buildCondaListFromMeta } = require('./conda-meta')
+const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
 const {
   isExpectedPythonPinned,
 } = require('./conda-pins')
@@ -412,7 +412,7 @@ class Bin {
       }
 
       if (conda_check.conda && conda_check.mamba && conda_check.python) {
-        this.correct_conda = true
+        this.correct_conda = await managedCondaRuns(this.kernel.bin.path("miniforge"), this.platform)
       }
     }
     this.installed.conda = conda

package/package.json

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

package/server/public/style.css

@@ -1284,6 +1284,10 @@ body.main-sidebar-page .navheader {
   box-shadow: none;
   isolation: isolate;
 }
+body.main-sidebar-page > header.navheader h1,
+body.app-page > header.navheader h1 {
+  gap: 6px;
+}
 body.main-sidebar-page .navheader .sidebar-toggle {
   color: #0f172a;
   position: relative;

package/test/conda-bin.test.js

@@ -25,12 +25,38 @@ function createKernel(root, platform = 'win32') {
     exists: async (...parts) => pathExists(path.join(root, ...parts)),
     bin: {
       correct_conda: true,
+      installed: {},
       path: (...parts) => path.join(root, 'bin', ...parts),
       exists: async (target) => pathExists(path.join(root, 'bin', target)),
     },
   }
 }
 
+async function writeCondaMeta(root, name, version, build = 'py_0') {
+  const metaDir = path.join(root, 'bin', 'miniforge', 'conda-meta')
+  await fs.mkdir(metaDir, { recursive: true })
+  await fs.writeFile(
+    path.join(metaDir, `${name}-${version}.json`),
+    JSON.stringify({ name, version, build_string: build, channel: 'conda-forge' })
+  )
+}
+
+async function writeHealthyCondaMeta(root, platform = 'win32') {
+  await writeCondaMeta(root, 'conda', '26.3.2', '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 writeFakeManagedConda(root, platform = 'win32') {
+  const condaPath = platform === 'win32'
+    ? path.join(root, 'bin', 'miniforge', 'Scripts', 'conda.exe')
+    : path.join(root, 'bin', 'miniforge', 'bin', 'conda')
+  await fs.mkdir(path.dirname(condaPath), { recursive: true })
+  await fs.copyFile(process.execPath, condaPath)
+  await fs.chmod(condaPath, 0o755)
+  return condaPath
+}
+
 async function createCondaRoot(root, name) {
   const condaRoot = path.join(root, 'bin', name)
   await fs.mkdir(path.join(condaRoot, 'Scripts'), { recursive: true })
@@ -73,17 +99,59 @@ test('Conda uses Miniforge assets and writes conda-forge-only config', async ()
   assert.equal(await pathExists(path.join(root, 'bin', 'miniforge')), false)
 })
 
-test('Conda init writes activation hooks only after Miniforge exists', async () => {
+test('Conda init writes SSL_CERT_DIR neutralizing 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
+  const hookRelativePaths = [
+    path.join('activate.d', 'zz_pinokio_unset_ssl_cert_dir-win.bat'),
+    path.join('activate.d', 'zz_pinokio_unset_ssl_cert_dir-win.ps1'),
+    path.join('activate.d', 'zz_pinokio_unset_ssl_cert_dir-win.sh'),
+    path.join('deactivate.d', 'zz_pinokio_unset_ssl_cert_dir-win.bat'),
+    path.join('deactivate.d', 'zz_pinokio_unset_ssl_cert_dir-win.ps1'),
+    path.join('deactivate.d', 'zz_pinokio_unset_ssl_cert_dir-win.sh'),
+  ]
+  for (const hookRelativePath of hookRelativePaths) {
+    assert.equal(
+      await pathExists(path.join(root, 'bin', 'miniforge', 'etc', 'conda', hookRelativePath)),
+      true
+    )
+  }
+
+  const batHook = await fs.readFile(
+    path.join(root, 'bin', 'miniforge', 'etc', 'conda', 'activate.d', 'zz_pinokio_unset_ssl_cert_dir-win.bat'),
+    'utf8'
   )
+  assert.match(batHook, /set "SSL_CERT_DIR="/)
+  assert.match(batHook, /set "__CONDA_OPENSSL_CERT_DIR_SET="/)
+  assert.doesNotMatch(batHook, /SSL_CERT_FILE/)
+})
+
+test('Conda init writes SSL_CERT_DIR neutralizing hooks for legacy Miniconda roots', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-legacy-init-hooks-'))
+  await fs.mkdir(path.join(root, 'bin', 'miniconda', 'conda-meta'), { recursive: true })
+  const conda = createConda(createKernel(root))
+
+  await conda.init()
+
+  const batHookPath = path.join(
+    root,
+    'bin',
+    'miniconda',
+    'etc',
+    'conda',
+    'deactivate.d',
+    'zz_pinokio_unset_ssl_cert_dir-win.bat'
+  )
+  assert.equal(await pathExists(batHookPath), true)
+
+  const batHook = await fs.readFile(batHookPath, 'utf8')
+  assert.match(batHook, /set "SSL_CERT_DIR="/)
+  assert.match(batHook, /set "__CONDA_OPENSSL_CERT_DIR_SET="/)
+  assert.doesNotMatch(batHook, /SSL_CERT_FILE/)
 })
 
 test('Conda pins Python 3.10.20 consistently across platforms', async () => {
@@ -207,6 +275,21 @@ test('Conda installed stays false when metadata check already marked Conda inval
   assert.equal(await createConda(kernel).installed(), false)
 })
 
+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')
+
+  assert.equal(await createConda(createKernel(root, 'win32')).check(), false)
+})
+
+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')
+
+  assert.equal(await createConda(createKernel(root, 'win32')).check(), true)
+})
+
 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)