pinokiod 8.2.0 → 8.2.1

package/kernel/environment.js

@@ -3,6 +3,7 @@ const portfinder = require('portfinder-cp')
 const fs = require('fs')
 const Util = require('./util')
 const ManagedSkills = require('./managed_skills')
+const { pipConfigDisabledPath } = require('./pip_env')
 const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
 const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
 const CACHE_PREFLIGHT_KEYS = TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)
@@ -311,7 +312,7 @@ const ENVS = async () => {
     type: ["system"],
     key: "PIP_CONFIG_FILE",
     hidden: true,
-    val: "./pipconfig"
+    val: pipConfigDisabledPath(process.platform)
   }, {
     type: ["system"],
     key: "CONDARC",

package/kernel/pip_env.js

@@ -0,0 +1,30 @@
+const fs = require('fs/promises')
+const path = require('path')
+
+function pipConfigDisabledPath(platform) {
+  // pip compares this string exactly with Python's os.devnull.
+  return platform === 'win32' ? 'nul' : '/dev/null'
+}
+
+async function normalizeLegacyPipConfig(source, { platform, homedir }) {
+  if (typeof source.PIP_CONFIG_FILE !== 'string') return source
+  const legacyPath = path.resolve(homedir, 'pipconfig')
+  const configuredPath = path.resolve(source.PIP_CONFIG_FILE)
+  const comparable = value => platform === 'win32' ? value.toLowerCase() : value
+  if (comparable(configuredPath) !== comparable(legacyPath)) return source
+
+  try {
+    // The old config may have been replaced with a directory, device, or pipe.
+    if (!(await fs.stat(legacyPath)).isFile()) return source
+    const contents = await fs.readFile(legacyPath, 'utf8')
+    if (!/^\s*\[global\]\s+timeout\s*=\s*1000\s*$/.test(contents)) return source
+  } catch (error) {
+    // Failure to recognize the stock config must not prevent shell startup.
+    if (error.code !== 'ENOENT') return source
+  }
+  // Existing ENVIRONMENT files point at this generated timeout-only config.
+  // Retain customized configs as intentional overrides; never rewrite files.
+  return { ...source, PIP_CONFIG_FILE: pipConfigDisabledPath(platform) }
+}
+
+module.exports = { normalizeLegacyPipConfig, pipConfigDisabledPath }

package/kernel/shell.js

@@ -15,6 +15,7 @@ const sudo = require("sudo-prompt-programfiles-x86");
 const unparse = require('yargs-unparser-custom-flag');
 const Util = require('./util')
 const Environment = require('./environment')
+const { normalizeLegacyPipConfig, pipConfigDisabledPath } = require('./pip_env')
 const { applyWindowsNodePackageManagerEnv } = require('./windows_node_package_manager_env')
 const ShellParser = require('./shell_parser')
 const AnsiStreamTracker = require('./ansi_stream_tracker')
@@ -223,6 +224,10 @@ class Shell {
       let app_env = await Environment.get(api_path, this.kernel)
       this.env = Object.assign(this.env, app_env)
     }
+    this.env = await normalizeLegacyPipConfig(this.env, {
+      platform: this.platform,
+      homedir: this.kernel.homedir,
+    })
     stripInheritedCondaActivationState(this.env)
     let PATH_KEY = Object.keys(this.env).find((key) => key.toLowerCase() === "path") || "PATH";
     if (!this.env[PATH_KEY]) {
@@ -290,6 +295,14 @@ class Shell {
       }
     }
 
+    // An explicitly selected config supplies its own timeout defaults.
+    if (this.env.PIP_CONFIG_FILE === pipConfigDisabledPath(this.platform)) {
+      const hasPipTimeout = Object.keys(this.env).some(key => {
+        const name = this.platform === 'win32' ? key.toUpperCase() : key
+        return (name === 'PIP_TIMEOUT' || name === 'PIP_DEFAULT_TIMEOUT') && this.env[key] !== undefined
+      })
+      if (!hasPipTimeout) this.env.PIP_TIMEOUT = "1000"
+    }
     setDefaultEnvValue(this.env, "UV_HTTP_TIMEOUT", "60")
     setDefaultEnvValue(this.env, "HF_HUB_DISABLE_UPDATE_CHECK", "1")
     setDefaultEnvValue(this.env, "HF_TOKEN_PATH", this.kernel.envs?.HF_TOKEN_PATH || path.resolve(this.kernel.homedir, "cache", "HF_AUTH", "token"))

package/package.json

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

package/test/pip-env.test.js

@@ -0,0 +1,210 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+const test = require('node:test')
+const Shell = require('../kernel/shell')
+const Environment = require('../kernel/environment')
+const { pipConfigDisabledPath } = require('../kernel/pip_env')
+
+async function fixture(t) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-pip-env-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  const appDir = path.join(root, 'api', 'demo')
+  const script = path.join(appDir, 'install.js')
+  await fs.mkdir(appDir, { recursive: true })
+  await fs.writeFile(script, '')
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PIP_CONFIG_FILE=./pipconfig\nPIP_CACHE_DIR=./cache/PIP_CACHE_DIR\n')
+  await fs.writeFile(path.join(root, 'pipconfig'), '[global]\r\n  timeout = 1000\r\n')
+  const kernel = {
+    homedir: root,
+    envs: {},
+    bracketedPasteSupport: {},
+    connect: { keys: async () => null },
+    exists: async filepath => fs.access(filepath).then(() => true).catch(() => false),
+    which: () => null,
+    path: (...parts) => path.join(root, ...parts),
+  }
+  async function shell(platform = process.platform, env = {}) {
+    const shell = new Shell(kernel)
+    shell.platform = platform
+    await shell.init_env({ path: appDir, $parent: { path: script }, env })
+    return shell
+  }
+  return { root, appDir, kernel, shell }
+}
+
+test('managed shells preserve inherited pip options and migrate stock config without editing files', async t => {
+  const { root, shell } = await fixture(t)
+  const host = {
+    PIP_CONFIG_FILE: 'host.ini', PIP_INDEX_URL: 'https://host.invalid',
+    PIP_EXTRA_INDEX_URL: 'https://nvidia.invalid', PIP_TRUSTED_HOST: 'nvidia.invalid',
+    PIP_NO_CACHE_DIR: 'true', PIP_NO_INDEX: 'true', PIP_TARGET: 'host-target',
+    pip_constraint: 'host-constraints.txt', PIP_TIMEOUT: '1', PIP_CACHE_DIR: 'host-cache',
+    PIP_CERT: 'host-ca.pem', PIP_PROXY: 'http://host-proxy.invalid', PIP_TMPDIR: 'host-temp',
+  }
+  const before = Object.fromEntries(Object.keys(host).map(key => [key, process.env[key]]))
+  Object.assign(process.env, host)
+  t.after(() => {
+    for (const [key, value] of Object.entries(before)) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  })
+  for (const platform of ['win32', 'darwin', 'linux']) {
+    const managed = await shell(platform)
+    assert.equal(managed.env.PIP_CONFIG_FILE, platform === 'win32' ? 'nul' : '/dev/null')
+    assert.equal(managed.env.PIP_TIMEOUT, '1')
+    assert.equal(managed.env.PIP_CACHE_DIR, path.join(root, 'cache', 'PIP_CACHE_DIR'))
+    for (const key of Object.keys(host).filter(key => !['PIP_CONFIG_FILE', 'PIP_CACHE_DIR'].includes(key))) {
+      assert.equal(managed.env[key], host[key], key)
+    }
+  }
+  assert.equal(await fs.readFile(path.join(root, 'ENVIRONMENT'), 'utf8'), 'PIP_CONFIG_FILE=./pipconfig\nPIP_CACHE_DIR=./cache/PIP_CACHE_DIR\n')
+  assert.equal(await fs.readFile(path.join(root, 'pipconfig'), 'utf8'), '[global]\r\n  timeout = 1000\r\n')
+  for (const [key, value] of Object.entries(host)) assert.equal(process.env[key], value)
+})
+
+test('Pinokio, app and step settings override managed pip defaults in order', async t => {
+  const { root, appDir, shell } = await fixture(t)
+  await fs.appendFile(path.join(root, 'ENVIRONMENT'), 'PIP_INDEX_URL=https://mirror.invalid/simple\nPIP_TIMEOUT=120\n')
+  const system = await shell()
+  assert.equal(system.env.PIP_INDEX_URL, 'https://mirror.invalid/simple')
+  assert.equal(system.env.PIP_TIMEOUT, '120')
+  await fs.writeFile(path.join(appDir, 'ENVIRONMENT'), 'PIP_INDEX_URL=https://app.invalid/simple\nPIP_EXTRA_INDEX_URL=https://app-extra.invalid/simple\n')
+  assert.equal((await shell()).env.PIP_INDEX_URL, 'https://app.invalid/simple')
+  const step = await shell(process.platform, {
+    PIP_INDEX_URL: 'https://step.invalid/simple', PIP_CONFIG_FILE: path.join(root, 'explicit.ini'),
+    PIP_NO_CACHE_DIR: 'true', PIP_TIMEOUT: '60',
+  })
+  assert.equal(step.env.PIP_INDEX_URL, 'https://step.invalid/simple')
+  assert.equal(step.env.PIP_EXTRA_INDEX_URL, 'https://app-extra.invalid/simple')
+  assert.equal(step.env.PIP_CONFIG_FILE, path.join(root, 'explicit.ini'))
+  assert.equal(step.env.PIP_NO_CACHE_DIR, 'true')
+  assert.equal(step.env.PIP_TIMEOUT, '60')
+})
+
+test('migration retains custom pip configs and isolates missing stock configs', async t => {
+  const { root, appDir, shell } = await fixture(t)
+  await fs.writeFile(path.join(root, 'pipconfig'), '[global]\ntimeout = 120\nindex-url = https://mirror.invalid/simple\n')
+  const custom = await shell()
+  assert.equal(custom.env.PIP_CONFIG_FILE, path.join(root, 'pipconfig'))
+  assert.equal(custom.env.PIP_TIMEOUT, undefined)
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PIP_CONFIG_FILE=./custom.ini\n')
+  assert.equal((await shell()).env.PIP_CONFIG_FILE, path.join(root, 'custom.ini'))
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PIP_CONFIG_FILE=./pipconfig\n')
+  await fs.rm(path.join(root, 'pipconfig'))
+  await fs.writeFile(path.join(appDir, 'ENVIRONMENT'), `PIP_CONFIG_FILE=${path.join(root, 'pipconfig')}\n`)
+  assert.equal((await shell('win32')).env.PIP_CONFIG_FILE, 'nul')
+})
+
+test('new system ENVIRONMENT uses the null device instead of the legacy pipconfig', async t => {
+  const { root, kernel } = await fixture(t)
+  const generated = await Environment.ENV('system', root, kernel)
+  assert.ok(generated.split('\n').includes(`PIP_CONFIG_FILE=${process.platform === 'win32' ? 'nul' : '/dev/null'}`))
+})
+
+test('config isolation adds no cache/temp fallbacks and retains the timeout alias', async t => {
+  const { root, shell } = await fixture(t)
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PIP_CONFIG_FILE=./pipconfig\n')
+  const managed = await shell(process.platform, { PIP_DEFAULT_TIMEOUT: '120' })
+  assert.equal(managed.env.PIP_CACHE_DIR, process.env.PIP_CACHE_DIR)
+  assert.equal(managed.env.PIP_TMPDIR, process.env.PIP_TMPDIR)
+  assert.equal(managed.env.PIP_TIMEOUT, process.env.PIP_TIMEOUT)
+  assert.equal(managed.env.PIP_DEFAULT_TIMEOUT, '120')
+  assert.equal((await shell(process.platform, { PIP_TIMEOUT: 60 })).env.PIP_TIMEOUT, 60)
+  assert.equal((await shell(process.platform, { PIP_DEFAULT_TIMEOUT: 0 })).env.PIP_TIMEOUT, process.env.PIP_TIMEOUT)
+})
+
+test('an unreadable or non-file legacy pipconfig does not prevent shell startup', async t => {
+  const { root, shell } = await fixture(t)
+  const legacyPath = path.join(root, 'pipconfig')
+  const readFile = fs.readFile
+  const mock = t.mock.method(fs, 'readFile', async (filepath, ...args) => {
+    if (filepath === legacyPath) throw Object.assign(new Error('Access denied'), { code: 'EACCES' })
+    return readFile(filepath, ...args)
+  })
+  assert.equal((await shell()).env.PIP_CONFIG_FILE, legacyPath)
+  mock.mock.restore()
+  await fs.rm(legacyPath)
+  await fs.mkdir(legacyPath)
+  assert.equal((await shell()).env.PIP_CONFIG_FILE, legacyPath)
+})
+
+test('Windows timeout defaults respect mixed-case names and numeric values', async t => {
+  const { shell } = await fixture(t)
+  const timeout = await shell('win32', { PIP_TIMEOUT: undefined, PIP_DEFAULT_TIMEOUT: undefined, pip_timeout: 60 })
+  assert.equal(timeout.env.PIP_TIMEOUT, undefined)
+  assert.equal(timeout.env.pip_timeout, 60)
+  const alias = await shell('win32', { PIP_TIMEOUT: undefined, PIP_DEFAULT_TIMEOUT: undefined, pip_default_timeout: 0 })
+  assert.equal(alias.env.PIP_TIMEOUT, undefined)
+  assert.equal(alias.env.pip_default_timeout, 0)
+  const unix = await shell('darwin', { PIP_TIMEOUT: undefined, PIP_DEFAULT_TIMEOUT: undefined, pip_timeout: 60 })
+  assert.equal(unix.env.PIP_TIMEOUT, '1000')
+})
+
+test('an app custom config avoids inspecting the root legacy file', async t => {
+  const { root, appDir, shell } = await fixture(t)
+  await fs.writeFile(path.join(appDir, 'ENVIRONMENT'), 'PIP_CONFIG_FILE=./custom.ini\n')
+  const readFile = fs.readFile
+  let legacyReads = 0
+  t.mock.method(fs, 'readFile', async (filepath, ...args) => {
+    if (filepath === path.join(root, 'pipconfig')) legacyReads++
+    return readFile(filepath, ...args)
+  })
+  assert.equal((await shell()).env.PIP_CONFIG_FILE, path.join(appDir, 'custom.ini'))
+  assert.equal(legacyReads, 0)
+})
+
+test('real pip ignores global, user and site config while retaining cache, timeout and launcher flags', async t => {
+  const python = process.env.PINOKIO_TEST_PYTHON || (process.platform === 'win32' ? 'python' : 'python3')
+  const available = spawnSync(python, ['-m', 'pip', '--version'], { encoding: 'utf8' })
+  if (available.status !== 0) return t.skip('Python with pip is not available')
+  const { shell } = await fixture(t)
+  const managed = await shell()
+  const code = `
+import json, os, tempfile
+from pathlib import Path
+from unittest.mock import patch
+import pip._internal.configuration as cfg
+from pip._internal.commands import create_command
+with tempfile.TemporaryDirectory() as tmp:
+    root = Path(tmp)
+    locations = {}
+    snapshots = {}
+    for kind in ('global', 'user', 'site'):
+        target = root / (kind + '.ini')
+        target.write_text('[global]\\nextra-index-url = https://' + kind + '.invalid/simple\\ntrusted-host = nvidia.invalid\\nno-cache-dir = true\\n')
+        locations[kind] = [str(target)]
+        snapshots[target] = target.read_bytes()
+    for platform, sentinel in [('win32', 'nul'), ('darwin', '/dev/null'), ('linux', '/dev/null')]:
+        configured = json.loads(os.environ['PINOKIO_TEST_PIP_PATHS'])[platform]
+        # Model only the Windows os.devnull string; this is not native Windows execution.
+        with patch.object(cfg, 'get_configuration_files', return_value=locations), patch.object(cfg.os, 'devnull', sentinel):
+            with patch.dict(os.environ, {'PIP_CONFIG_FILE': configured}):
+                for flags in ([], ['--extra-index-url', 'https://download.pytorch.org/whl/cu130']):
+                    options, _ = create_command('install').parse_args(flags)
+                    assert options.index_url == 'https://pypi.org/simple', options.index_url
+                    assert options.extra_index_urls == ([] if not flags else [flags[1]]), options.extra_index_urls
+                    assert not options.trusted_hosts, options.trusted_hosts
+                    assert options.cache_dir == os.environ['PIP_CACHE_DIR'], options.cache_dir
+                    assert options.timeout == 1000, options.timeout
+                options, _ = create_command('install').parse_args(['--index-url', 'https://launcher.invalid/simple'])
+                assert options.index_url == 'https://launcher.invalid/simple'
+            if platform == 'win32':
+                # Negative control: the old uppercase value must NOT disable configs.
+                with patch.dict(os.environ, {'PIP_CONFIG_FILE': 'NUL'}):
+                    options, _ = create_command('install').parse_args([])
+                    assert options.extra_index_urls == ['https://site.invalid/simple']
+    for target, snapshot in snapshots.items():
+        assert target.read_bytes() == snapshot
+`
+  const env = Object.fromEntries(Object.entries(managed.env).filter(([key]) => !key.toUpperCase().startsWith('PIP_')))
+  Object.assign(env, {
+    PIP_CONFIG_FILE: managed.env.PIP_CONFIG_FILE, PIP_CACHE_DIR: managed.env.PIP_CACHE_DIR, PIP_TIMEOUT: '1000',
+    PINOKIO_TEST_PIP_PATHS: JSON.stringify(Object.fromEntries(['win32', 'darwin', 'linux'].map(platform => [platform, pipConfigDisabledPath(platform)]))),
+  })
+  const result = spawnSync(python, ['-c', code], { encoding: 'utf8', env })
+  assert.equal(result.status, 0, result.stderr || result.error?.message)
+})