pinokiod 8.2.24 → 8.2.26

package/kernel/api/exec/index.js

@@ -1,4 +1,5 @@
 const child_process = require('child_process')
+const Environment = require('../../environment')
 module.exports = async (req, ondata, kernel) => {
   /*
     req := {
@@ -50,6 +51,7 @@ module.exports = async (req, ondata, kernel) => {
       req.params.cwd = req.params.path
     }
     req.params.env = Object.assign({}, kernel.envs, req.params.env)
+    Environment.applyHfTokenPath(req.params.env, kernel)
     console.log("env", JSON.stringify(req.params.env, null, 2))
     ondata({ raw: `██ Exec: ${req.params.message}\r\n` })
     let response = await new Promise((resolve, reject) => {

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

@@ -46,7 +46,6 @@ class Huggingface {
     let env
     if (context.parentPath) {
       env = await Environment.get2(context.parentPath, this.kernel)
-      if (env.HF_TOKEN_PATH === this.kernel.path("cache", "HF_AUTH", "anonymous")) env.HF_TOKEN_PATH = this.defaultTokenPath()
     } else {
       let systemEnv = {}
       try {
@@ -60,11 +59,8 @@ class Huggingface {
       env = Object.assign(env, context.env)
     }
     env = managedPythonEnv(env)
-    if (!env.HF_TOKEN_PATH) {
-      env.HF_TOKEN_PATH = this.defaultTokenPath()
-    } else if (!path.isAbsolute(env.HF_TOKEN_PATH)) {
-      env.HF_TOKEN_PATH = path.resolve(this.requestCwd(context), env.HF_TOKEN_PATH)
-    }
+    // Login and all auth operations use the same Pinokio-managed credential file.
+    Environment.applyHfTokenPath(env, this.kernel, { auth: true })
     if (!env.HF_HUB_DISABLE_UPDATE_CHECK) {
       env.HF_HUB_DISABLE_UPDATE_CHECK = "1"
     }

package/kernel/environment.js

@@ -11,6 +11,17 @@ const SCRIPT_AUTOLAUNCH_KEY = "PINOKIO_SCRIPT_AUTOLAUNCH"
 const SCRIPT_AUTOLAUNCH_ENABLED_KEY = "PINOKIO_SCRIPT_AUTOLAUNCH_ENABLED"
 const SCRIPT_REQUIREMENTS_KEY = "PINOKIO_SCRIPT_REQUIRES"
 
+const applyHfTokenPath = (env, kernel, { auth = false } = {}) => {
+  for (const key of Object.keys(env)) {
+    if (key.toUpperCase() === "HF_TOKEN_PATH") delete env[key]
+  }
+  const authDir = path.resolve(kernel.homedir, "cache", "HF_AUTH")
+  const anonymousPath = path.join(authDir, "anonymous")
+  env.HF_TOKEN_PATH = !auth && kernel.envs?.HF_TOKEN_PATH === anonymousPath
+    ? anonymousPath
+    : path.join(authDir, "token")
+}
+
 const parseBooleanFlag = (value) => {
   if (typeof value !== "string") {
     return null
@@ -602,7 +613,8 @@ const ENV = async (type, homedir, kernel) => {
     for(let key in system_env) {
       if (!keys.has(key)) {
         // the key has not been processed, need to add to the lines
-        if (irrelevant_keys.includes(key)) {
+        // HF_TOKEN_PATH is supplied by Pinokio at runtime, never copied into apps.
+        if (irrelevant_keys.includes(key) || key.toUpperCase() === "HF_TOKEN_PATH") {
         } else {
           let val = system_env[key]
           let kv = `${key}=${val}`
@@ -1021,4 +1033,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root, SCRIPT_AUTOLAUNCH_KEY, SCRIPT_AUTOLAUNCH_ENABLED_KEY, SCRIPT_REQUIREMENTS_KEY, getScriptAutolaunch, getScriptAutolaunchEnabled, parseAutolaunchList, formatAutolaunchList, getScriptRequirements  }
+module.exports = { ENV, get, get2, applyHfTokenPath, init_folders, ensurePinokioCacheDirs, requirements, init, get_root, SCRIPT_AUTOLAUNCH_KEY, SCRIPT_AUTOLAUNCH_ENABLED_KEY, SCRIPT_REQUIREMENTS_KEY, getScriptAutolaunch, getScriptAutolaunchEnabled, parseAutolaunchList, formatAutolaunchList, getScriptRequirements  }

package/kernel/shell.js

@@ -307,7 +307,6 @@ class Shell {
     }
     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"))
 
     // Point every app's Python HTTPS trust (httpx, requests, pip, the ssl module) at the
     // managed CA bundle instead of the certifi copy frozen inside each environment.
@@ -350,6 +349,8 @@ class Shell {
         targetPath: params && params.path ? params.path : this.kernel.homedir,
       })
     }
+    // Apply last so config overrides and -env cannot disconnect apps from login.
+    Environment.applyHfTokenPath(this.env, this.kernel)
   }
   isCmdShell(shellName=this.shell) {
     const name = (shellName || '').toLowerCase()

package/package.json

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

package/server/views/anywhere.ejs

@@ -49,6 +49,14 @@ body.dark .anywhere-card { border-color: rgba(255,255,255,0.1); background: rgba
 }
 body.dark .anywhere-address { background: rgba(255,255,255,0.08); }
 .anywhere-address a { color: inherit; text-decoration: none; }
+.anywhere-copy { min-height: 44px; }
+.anywhere-copy:focus-visible { outline: 2px solid currentColor; outline-offset: 3px; }
+.anywhere-copy-manual { width: 100%; min-width: 0; }
+.anywhere-copy-manual input {
+  box-sizing: border-box; width: 100%; min-height: 44px; padding: 8px;
+  font-size: 16px; color: inherit; background: transparent; border: 1px solid currentColor;
+  border-radius: 8px; user-select: text; -webkit-user-select: text;
+}
 .anywhere-btn {
   display: inline-flex; align-items: center; gap: 8px;
   padding: 10px 16px; border-radius: 8px; border: none; cursor: pointer;
@@ -201,6 +209,11 @@ document.addEventListener('DOMContentLoaded', function() {
               <div class='anywhere-qr'>
                 <img id='anywhere-qr' alt='QR code to connect' src=''>
                 <div class='anywhere-address'><a id='anywhere-address' href='#' target='_blank' rel='noopener'></a></div>
+                <button type='button' class='anywhere-btn secondary anywhere-copy' id='anywhere-copy' disabled><i class='fa-regular fa-copy' aria-hidden='true'></i> Copy URL</button>
+                <div id='anywhere-copy-status' class='anywhere-muted' role='status' aria-live='polite'></div>
+                <div id='anywhere-copy-manual' class='anywhere-copy-manual' hidden>
+                  <input id='anywhere-copy-value' type='text' readonly aria-label='Remote URL' aria-describedby='anywhere-copy-status'>
+                </div>
                 <div class='anywhere-muted'>signed in as <b id='anywhere-account'></b></div>
                 <div class='anywhere-waiting' id='anywhere-waiting'><i class="fa-solid fa-circle-notch fa-spin"></i> Waiting for another device to join…</div>
               </div>
@@ -254,8 +267,54 @@ document.addEventListener('DOMContentLoaded', function() {
   const switchEl = document.getElementById('anywhere-switch')
   const switchLabel = document.getElementById('anywhere-switch-label')
   const agent = document.body.getAttribute('data-agent')
+  const copyButton = document.getElementById('anywhere-copy')
+  const copyStatus = document.getElementById('anywhere-copy-status')
+  const copyManual = document.getElementById('anywhere-copy-manual')
+  const copyValue = document.getElementById('anywhere-copy-value')
   let current = <%- JSON.stringify(status || {}).replace(/</g, '\\u003c') %>
   let busy = false
+  let copying = false
+
+  copyButton.addEventListener('click', async () => {
+    const url = current.address
+    if (copying || current.phase !== 'ready' || !url) return
+    const previousFocus = document.activeElement
+    copying = true
+    copyButton.disabled = true
+    copyStatus.textContent = 'Copying…'
+    const stillCurrent = () => current.phase === 'ready' && current.address === url
+    let copied = false
+    try {
+      // Call directly from the click: Safari requires a user gesture.
+      if (navigator.clipboard && typeof navigator.clipboard.writeText === 'function') {
+        await navigator.clipboard.writeText(url)
+        copied = true
+      }
+    } catch (_) { /* Try selection-based copying when clipboard access is denied. */ }
+    if (stillCurrent()) {
+      if (!copied) {
+        copyValue.value = url
+        copyManual.hidden = false
+        copyStatus.textContent = 'Automatic copy is unavailable. Touch and hold the URL to copy it, or press Ctrl+C / ⌘C.'
+        try {
+          copyValue.focus({ preventScroll: true })
+          copyValue.select()
+          copyValue.setSelectionRange(0, url.length)
+          copied = document.execCommand('copy') === true
+        } catch (_) { /* Leave the visible URL available for manual copying. */ }
+      }
+      if (copied) {
+        copyManual.hidden = true
+        copyStatus.textContent = 'URL copied.'
+      }
+    }
+    copying = false
+    copyButton.disabled = current.phase !== 'ready' || !current.address
+    if (copied && stillCurrent() && previousFocus &&
+        (document.activeElement === copyValue || document.activeElement === document.body)) {
+      previousFocus.focus({ preventScroll: true })
+    }
+  })
 
   const esc = (value) => String(value == null ? '' : value).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
   const openExternal = (href) => {
@@ -292,7 +351,12 @@ document.addEventListener('DOMContentLoaded', function() {
   }
 
   const render = (status) => {
+    if (current.address !== (status || {}).address || current.phase !== (status || {}).phase) {
+      copyManual.hidden = true
+      copyStatus.textContent = ''
+    }
     current = status || {}
+    copyButton.disabled = copying || current.phase !== 'ready' || !current.address
     const phase = current.phase && current.phase !== 'setup' ? current.phase : 'starting'
     const on = !!current.enabled && phase !== 'off' && phase !== 'setup'
     switchEl.dataset.on = on ? 'true' : 'false'

package/test/anywhere-clipboard.test.js

@@ -0,0 +1,184 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+const test = require('node:test')
+const ejs = require('ejs')
+const { JSDOM, VirtualConsole } = require('jsdom')
+
+const filename = path.resolve(__dirname, '../server/views/anywhere.ejs')
+const template = fs.readFileSync(filename, 'utf8')
+const address = 'https://pinokio-1.tail123.ts.net'
+const tick = () => new Promise((resolve) => setImmediate(resolve))
+
+function createHarness(t, options = {}) {
+  const state = { status: { phase: 'ready', enabled: true, address }, timers: [], opened: [] }
+  Object.assign(state.status, options.status)
+  const html = ejs.render(template, {
+    theme: 'light', agent: options.agent || 'browser', status: state.status
+  }, { filename, includer: () => ({ template: ' ' }) })
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on('jsdomError', (error) => { throw error })
+  const dom = new JSDOM(html, {
+    url: options.origin || 'http://127.0.0.1:42000/',
+    runScripts: 'dangerously', pretendToBeVisual: true, virtualConsole,
+    beforeParse(window) {
+      if (options.clipboard) {
+        Object.defineProperty(window.navigator, 'clipboard', { value: options.clipboard })
+      }
+      window.document.execCommand = options.execCommand
+      window.setTimeout = (callback, delay) => state.timers.push({ callback, delay })
+      window.fetch = async (url) => {
+        assert.equal(url, '/anywhere/status', 'copying must not use the server clipboard')
+        return { ok: true, json: async () => ({ ...state.status }) }
+      }
+      window.open = (...args) => state.opened.push(args)
+    }
+  })
+  t.after(() => dom.window.close())
+  const document = dom.window.document
+  return {
+    state, document,
+    button: document.getElementById('anywhere-copy'),
+    feedback: document.getElementById('anywhere-copy-status'),
+    manual: document.getElementById('anywhere-copy-manual'),
+    input: document.getElementById('anywhere-copy-value'),
+    poll: () => state.timers.shift().callback()
+  }
+}
+
+for (const agent of ['browser', 'electron']) {
+  test(`Remote copies the full URL directly from the ${agent} click without opening a window`, async (t) => {
+    const copied = []
+    const h = createHarness(t, {
+      agent,
+      clipboard: { writeText: async (text) => { copied.push(text) } },
+      execCommand: () => assert.fail('modern clipboard succeeded')
+    })
+    h.button.focus()
+    h.button.click()
+    assert.deepEqual(copied, [address], 'clipboard is invoked synchronously in the click')
+    assert.equal(h.button.disabled, true)
+    h.button.click()
+    await tick()
+    assert.deepEqual(copied, [address], 'pending copies are not duplicated')
+    assert.equal(h.feedback.textContent, 'URL copied.')
+    assert.equal(h.manual.hidden, true)
+    assert.equal(h.button.disabled, false)
+    assert.equal(h.document.activeElement, h.button)
+    assert.deepEqual(h.state.opened, [])
+    assert.equal(h.document.getElementById('anywhere-address').getAttribute('href'), address)
+    assert.equal(h.feedback.getAttribute('role'), 'status')
+    if (agent === 'electron') {
+      h.document.getElementById('anywhere-address').click()
+      assert.deepEqual(h.state.opened, [[address + '/', '_blank', 'browser']])
+    }
+  })
+}
+
+for (const scenario of ['insecure LAN', 'denied', 'synchronous failure', 'electron']) {
+  test(`Remote falls back to selected text copying: ${scenario}`, async (t) => {
+    const copied = []
+    let h
+    h = createHarness(t, {
+      agent: scenario === 'electron' ? 'electron' : 'browser',
+      origin: scenario === 'insecure LAN' ? 'http://192.168.1.10:42000/' : 'https://pinokio.tail123.ts.net/',
+      clipboard: scenario === 'denied'
+        ? { writeText: async () => { throw new Error('NotAllowedError') } }
+        : scenario === 'synchronous failure'
+          ? { writeText: () => { throw new Error('clipboard unavailable') } }
+          : undefined,
+      execCommand(command) {
+        assert.equal(command, 'copy')
+        assert.equal(h.document.activeElement, h.input)
+        assert.equal(h.input.readOnly, true)
+        assert.equal(h.manual.hidden, false)
+        copied.push(h.input.value.slice(h.input.selectionStart, h.input.selectionEnd))
+        return true
+      }
+    })
+    h.button.focus()
+    h.button.click()
+    await tick()
+    assert.deepEqual(copied, [address])
+    assert.equal(h.feedback.textContent, 'URL copied.')
+    assert.equal(h.manual.hidden, true)
+    assert.equal(h.document.activeElement, h.button)
+    assert.deepEqual(h.state.opened, [])
+  })
+}
+
+for (const failure of ['false', 'undefined', 'throws', 'unavailable']) {
+  test(`Remote offers selected manual copy without false success when execCommand ${failure}`, async (t) => {
+    const h = createHarness(t, {
+      clipboard: { writeText: async () => { throw new Error('denied') } },
+      execCommand: failure === 'unavailable' ? undefined : () => {
+        if (failure === 'throws') throw new Error('denied')
+        return failure === 'false' ? false : undefined
+      }
+    })
+    h.button.click()
+    await tick()
+    assert.equal(h.manual.hidden, false)
+    assert.equal(h.input.value, address)
+    assert.equal(h.input.selectionStart, 0)
+    assert.equal(h.input.selectionEnd, address.length)
+    assert.equal(h.document.activeElement, h.input)
+    assert.match(h.feedback.textContent, /Touch and hold.*Ctrl\+C \/ ⌘C/)
+    assert.doesNotMatch(h.feedback.textContent, /URL copied/)
+    assert.equal(h.button.disabled, false)
+    await h.poll()
+    assert.equal(h.manual.hidden, false, 'routine polling preserves the manual copy field')
+    assert.equal(h.input.selectionEnd, address.length)
+    h.state.status.address = 'https://renamed.tail123.ts.net'
+    await h.poll()
+    assert.equal(h.manual.hidden, true, 'a changed URL clears the stale manual field')
+    assert.equal(h.feedback.textContent, '')
+  })
+}
+
+test('Remote does not copy a placeholder or an unavailable address', async (t) => {
+  const h = createHarness(t, {
+    status: { address: '' },
+    clipboard: { writeText: () => assert.fail('no URL to copy') },
+    execCommand: () => assert.fail('no URL to copy')
+  })
+  assert.equal(h.button.disabled, true)
+  h.button.click()
+  await tick()
+  assert.equal(h.feedback.textContent, '')
+  h.state.status.address = address
+  await h.poll()
+  assert.equal(h.button.disabled, false)
+  h.state.status.phase = 'off'
+  await h.poll()
+  assert.equal(h.button.disabled, true)
+})
+
+test('Remote restores keyboard focus after disabling the button during modern copy', async (t) => {
+  let h
+  h = createHarness(t, {
+    clipboard: { writeText: async () => { h.button.blur() } }
+  })
+  h.button.focus()
+  h.button.click()
+  await tick()
+  assert.equal(h.document.activeElement, h.button)
+})
+
+test('Remote ignores a pending copy result if the address changes or Remote stops', async (t) => {
+  for (const change of [{ address: 'https://new.tail123.ts.net' }, { phase: 'off' }]) {
+    let rejectCopy
+    const h = createHarness(t, {
+      clipboard: { writeText: () => new Promise((resolve, reject) => { rejectCopy = reject }) },
+      execCommand: () => assert.fail('must not select a stale URL')
+    })
+    h.button.click()
+    Object.assign(h.state.status, change)
+    await h.poll()
+    rejectCopy(new Error('denied'))
+    await tick()
+    assert.equal(h.manual.hidden, true)
+    assert.equal(h.feedback.textContent, '')
+    assert.equal(h.button.disabled, change.phase === 'off')
+  }
+})

package/test/huggingface-connect.test.js

@@ -56,7 +56,7 @@ test('Hugging Face connect parses managed hf agent login instructions', () => {
   })
 })
 
-test('Hugging Face connect preserves configured HF paths and ignores ambient HF_TOKEN', async () => {
+test('Hugging Face connect preserves HF_HOME but uses managed credentials', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-'))
   await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'HF_HOME=./custom/hf-home\nHF_TOKEN_PATH=./custom/hf-token\n')
   const oldToken = process.env.HF_TOKEN
@@ -66,7 +66,7 @@ test('Hugging Face connect preserves configured HF paths and ignores ambient HF_
     const env = await provider.authEnv()
 
     assert.equal(env.HF_HOME, path.join(root, 'custom', 'hf-home'))
-    assert.equal(env.HF_TOKEN_PATH, path.join(root, 'custom', 'hf-token'))
+    assert.equal(env.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
     assert.equal(env.HF_TOKEN, undefined)
     assert.equal(env.HF_HUB_DISABLE_UPDATE_CHECK, '1')
   } finally {
@@ -114,11 +114,11 @@ test('Hugging Face connect isolates its managed Python from external packages',
   }
 })
 
-test('Hugging Face connect uses the app token path for its managed CLI', async () => {
+test('Hugging Face connect ignores app and command token paths in its managed CLI', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-app-env-'))
   const appDir = path.join(root, 'api', 'demo')
   const scriptPath = path.join(appDir, 'start.js')
-  const tokenPath = path.join(appDir, 'auth', 'token')
+  const tokenPath = path.join(root, 'cache', 'HF_AUTH', 'token')
   await fs.mkdir(appDir, { recursive: true })
   await fs.writeFile(scriptPath, '')
   await fs.writeFile(
@@ -148,10 +148,7 @@ test('Hugging Face connect uses the app token path for its managed CLI', async (
     assert.equal(env.HF_HOME, path.join(appDir, 'cache', 'huggingface'))
     assert.equal(env.HF_TOKEN_PATH, tokenPath)
     assert.equal(await fs.readFile(tokenPath, 'utf8'), 'hf_app_token')
-    await assert.rejects(
-      fs.access(path.join(root, 'cache', 'HF_AUTH', 'token')),
-      { code: 'ENOENT' }
-    )
+    await assert.rejects(fs.access(path.join(appDir, 'auth')), { code: 'ENOENT' })
 
     const commandTokenPath = path.join(appDir, 'command-auth', 'token')
     const commandContext = {
@@ -164,8 +161,9 @@ test('Hugging Face connect uses the app token path for its managed CLI', async (
       'require("node:fs").writeFileSync(process.env.HF_TOKEN_PATH, "hf_command_token")'
     ], {}, commandContext)
 
-    assert.equal(commandResult.env.HF_TOKEN_PATH, commandTokenPath)
-    assert.equal(await fs.readFile(commandTokenPath, 'utf8'), 'hf_command_token')
+    assert.equal(commandResult.env.HF_TOKEN_PATH, tokenPath)
+    assert.equal(await fs.readFile(tokenPath, 'utf8'), 'hf_command_token')
+    await assert.rejects(fs.access(commandTokenPath), { code: 'ENOENT' })
   } finally {
     await fs.rm(root, { recursive: true, force: true })
   }

package/test/huggingface-managed-env.test.js

@@ -0,0 +1,124 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+const Environment = require('../kernel/environment')
+const Huggingface = require('../kernel/connect/providers/huggingface')
+const Shell = require('../kernel/shell')
+const Exec = require('../kernel/api/exec')
+const dotenv = require('dotenv')
+
+async function withHome(fn) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-managed-'))
+  const kernel = {
+    homedir: root,
+    platform: process.platform,
+    path: (...parts) => path.join(root, ...parts),
+    exists: target => fs.access(target).then(() => true, () => false),
+    which: () => null,
+    envs: {},
+  }
+  try {
+    await fn(kernel)
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+}
+
+test('app generation excludes token paths without changing global configuration', async (t) => {
+  for (const eol of ['\n', '\r\n']) {
+    await t.test(JSON.stringify(eol), () => withHome(async kernel => {
+      const content = [
+        '\uFEFF# HF_TOKEN_PATH and all original content stay in the global file',
+        'HF_TOKEN_PATH=./cache/HF_AUTH/token',
+        '  export HF_TOKEN_PATH = "/custom/token" # duplicate',
+        'Hf_Token_Path=another-token',
+        'CUSTOM=keep',
+        'HF_TOKEN_PATH_EXTRA=keep',
+        'HF_HOME=./cache/HF_HOME',
+        'FREEFORM="line one',
+        'line two"',
+      ].join(eol)
+      const envPath = kernel.path('ENVIRONMENT')
+      await fs.writeFile(envPath, content)
+      const generated = await Environment.ENV('app', kernel.homedir, kernel)
+      const appEnv = dotenv.parse(generated)
+      assert.equal(appEnv.HF_TOKEN_PATH, undefined)
+      assert.equal(appEnv.Hf_Token_Path, undefined)
+      assert.equal(appEnv.CUSTOM, 'keep')
+      assert.equal(appEnv.HF_TOKEN_PATH_EXTRA, 'keep')
+      assert.equal(appEnv.HF_HOME, './cache/HF_HOME')
+      assert.equal(await fs.readFile(envPath, 'utf8'), content)
+      // Exclusion is limited to inheritance; ordinary global reads are unchanged.
+      assert.equal((await Environment.get(kernel.homedir, kernel)).HF_TOKEN_PATH, '/custom/token')
+    }))
+  }
+})
+
+test('stale global/app/command paths cannot separate downloads from managed login', () => withHome(async kernel => {
+  const stale = 'HF_TOKEN_PATH=./cache/HF_AUTH/token\n'
+  const app = kernel.path('api', 'minijam.git')
+  const scriptPath = path.join(app, 'install.js')
+  await fs.mkdir(app, { recursive: true })
+  await fs.writeFile(kernel.path('ENVIRONMENT'), stale)
+  await fs.writeFile(path.join(app, 'ENVIRONMENT'), `HF_HOME=./cache/HF_HOME\n${stale}`)
+  await fs.writeFile(scriptPath, '')
+  assert.equal(dotenv.parse(await Environment.ENV('app', kernel.homedir, kernel)).HF_TOKEN_PATH, undefined)
+  const provider = new Huggingface(kernel, {})
+  const tokenPath = provider.defaultTokenPath()
+  const anonymousPath = kernel.path('cache', 'HF_AUTH', 'anonymous')
+  // A connection check succeeds after login; the existing fallback is then cleared.
+  kernel.envs.HF_TOKEN_PATH = anonymousPath
+  const existingShell = new Shell(kernel)
+  await existingShell.init_env({ $parent: { path: scriptPath }, '-env': ['HF_TOKEN_PATH'] })
+  assert.equal(existingShell.env.HF_TOKEN_PATH, anonymousPath)
+
+  provider.hfPath = () => process.execPath
+  const context = {
+    parentPath: scriptPath,
+    cwd: app,
+    env: { HF_TOKEN_PATH: './command-token', Hf_Token_Path: './mixed-case-token' },
+  }
+  await provider.runHf(['-e', 'require("node:fs").writeFileSync(process.env.HF_TOKEN_PATH, "synthetic-login-token")'], {}, context)
+  assert.equal(await fs.readFile(tokenPath, 'utf8'), 'synthetic-login-token')
+  assert.equal(await kernel.exists(path.join(app, 'command-token')), false)
+  assert.equal(await kernel.exists(path.join(app, 'mixed-case-token')), false)
+
+  for (const platform of ['win32', 'linux', 'darwin']) {
+    kernel.platform = platform
+    // Simulate a successful whoami command without contacting Hugging Face.
+    const originalRunHf = provider.runHf
+    provider.runHf = async () => ({ env: await provider.authEnv(context) })
+    assert.equal(await provider.connected(), true)
+    provider.runHf = originalRunHf
+    assert.equal(kernel.envs.HF_TOKEN_PATH, tokenPath)
+
+    const shell = new Shell(kernel)
+    shell.platform = platform
+    await shell.init_env({ $parent: { path: scriptPath }, env: context.env, '-env': ['HF_TOKEN_PATH'] })
+    assert.equal(shell.env.HF_TOKEN_PATH, tokenPath)
+    assert.equal(shell.env.Hf_Token_Path, undefined)
+    assert.equal(shell.env.HF_HOME, path.join(app, 'cache', 'HF_HOME'))
+    const authEnv = await provider.authEnv(context)
+    assert.equal(authEnv.HF_TOKEN_PATH, tokenPath)
+    assert.equal(authEnv.Hf_Token_Path, undefined)
+  }
+  assert.equal(existingShell.env.HF_TOKEN_PATH, anonymousPath)
+  assert.equal(await fs.readFile(kernel.path('ENVIRONMENT'), 'utf8'), stale)
+  assert.equal(await fs.readFile(path.join(app, 'ENVIRONMENT'), 'utf8'), `HF_HOME=./cache/HF_HOME\n${stale}`)
+  assert.equal(await kernel.exists(path.join(app, 'cache', 'HF_AUTH', 'token')), false)
+}))
+
+test('exec children receive the managed path despite command overrides', () => withHome(async kernel => {
+  for (const state of ['token', 'anonymous']) {
+    const tokenPath = kernel.path('cache', 'HF_AUTH', state)
+    kernel.envs.HF_TOKEN_PATH = tokenPath
+    const result = await Exec({ params: {
+      message: `"${process.execPath}" -p "process.env.HF_TOKEN_PATH"`,
+      env: { HF_TOKEN_PATH: '/wrong/token', Hf_Token_Path: '/another/wrong/token' },
+    } }, () => {}, kernel)
+    assert.equal(result.error, null)
+    assert.equal(result.stdout.trim(), tokenPath)
+  }
+}))

package/test/huggingface-token-validity.test.js

@@ -213,7 +213,7 @@ test('a broken CLI executable path does not disable saved credentials at startup
   }
 })
 
-test('provider login ignores only Pinokio\'s inherited anonymous path', async () => {
+test('provider login always uses the managed token path, including after anonymous fallback', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-context-'))
   const appDir = path.join(root, 'api', 'demo')
   const scriptPath = path.join(appDir, 'start.js')
@@ -230,14 +230,14 @@ test('provider login ignores only Pinokio\'s inherited anonymous path', async ()
     assert.equal((await provider.authEnv(context)).HF_TOKEN_PATH, provider.defaultTokenPath())
     assert.equal(
       (await provider.authEnv({ ...context, env: { HF_TOKEN_PATH: './custom-token' } })).HF_TOKEN_PATH,
-      path.join(appDir, 'custom-token')
+      provider.defaultTokenPath()
     )
   } finally {
     await fs.rm(root, { recursive: true, force: true })
   }
 })
 
-test('invalid managed tokens are replaced once without overriding apps', async () => {
+test('invalid managed tokens select anonymous credentials even with app overrides', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-shells-'))
   await fs.writeFile(path.join(root, 'ENVIRONMENT'), '')
   let checks = 0
@@ -268,7 +268,7 @@ test('invalid managed tokens are replaced once without overriding apps', async (
 
     const appShell = new Shell(kernel)
     await appShell.init_env({ env: { HF_TOKEN_PATH: '/tmp/app-hf-token' } })
-    assert.equal(appShell.env.HF_TOKEN_PATH, '/tmp/app-hf-token')
+    assert.equal(appShell.env.HF_TOKEN_PATH, anonymousPath)
   } finally {
     await fs.rm(root, { recursive: true, force: true })
   }

package/test/shell-run-template.test.js

@@ -280,10 +280,10 @@ test('Shell.init_env disables Hugging Face hub update checks by default without
     }
   })
   assert.equal(overrideShell.env.HF_HUB_DISABLE_UPDATE_CHECK, '0')
-  assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(root, 'custom', 'hf-token'))
+  assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
 })
 
-test('Shell.init_env preserves an app HF_HOME without changing the shared token default', async () => {
+test('Shell.init_env preserves app HF_HOME while ignoring app token paths', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-hf-app-env-'))
   const appDir = path.join(root, 'api', 'demo')
   const scriptPath = path.join(appDir, 'start.js')
@@ -313,7 +313,7 @@ test('Shell.init_env preserves an app HF_HOME without changing the shared token
   })
 
   assert.equal(overrideShell.env.HF_HOME, path.join(appDir, 'cache', 'huggingface'))
-  assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(appDir, 'auth', 'token'))
+  assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
 })
 
 test('Shell.init_env keeps Windows Hugging Face symlink defaults scoped to win32', async () => {