pinokiod 8.0.4 → 8.0.6

package/kernel/api/hf/index.js

@@ -168,6 +168,13 @@ class HF {
     }
     await this.htmlModal.close(this.modalRequest(req, this.modalId(req)), ondata, kernel)
   }
+  authContext(req = {}, params = {}) {
+    return {
+      parentPath: req.parent && req.parent.path,
+      cwd: req.cwd,
+      env: params.env,
+    }
+  }
   async cancelLogin(connect, params) {
     if (connect && typeof connect.cancelLogin === "function") {
       await connect.cancelLogin("huggingface", params || {})
@@ -201,9 +208,10 @@ class HF {
     const shouldWait = params.wait !== false
     const timeout = positiveNumber(params.timeout, 120000)
     const interval = positiveNumber(params.interval, 2000)
+    const authContext = this.authContext(req, params)
 
     if (!force) {
-      const existing = await connect.keys("huggingface")
+      const existing = await connect.keys("huggingface", authContext)
       if (existing && existing.access_token) {
         return {
           status: "success",
@@ -216,7 +224,7 @@ class HF {
     if (typeof connect.login !== "function") {
       throw new Error("Hugging Face connect login is not available")
     }
-    const response = await connect.login("huggingface", params)
+    const response = await connect.login("huggingface", params, authContext)
     if (!response || response.status === "error") {
       return response
     }
@@ -262,7 +270,7 @@ class HF {
 
     const startedAt = Date.now()
     while (Date.now() - startedAt < timeout) {
-      const keys = await connect.keys("huggingface")
+      const keys = await connect.keys("huggingface", authContext)
       if (keys && keys.access_token) {
         if (useModal) {
           await this.closeLoginModal(req, ondata, kernel)
@@ -293,7 +301,8 @@ class HF {
   */
   async logout(req, ondata, kernel) {
     const connect = this.connect(kernel, "logout")
-    await connect.logout("huggingface", req.params || {})
+    const params = req.params || {}
+    await connect.logout("huggingface", params, this.authContext(req, params))
     return { status: "success" }
   }
   /*

package/kernel/connect/index.js

@@ -24,12 +24,12 @@ class Connect {
       return null
     }
   }
-  async login(provider, req) {
-    let res = await this.clients[provider].login(req)
+  async login(provider, params, context) {
+    let res = await this.clients[provider].login(params, context)
     return res
   }
-  async logout(provider, req) {
-    let res = await this.clients[provider].logout(req)
+  async logout(provider, params, context) {
+    let res = await this.clients[provider].logout(params, context)
     return res
   }
   async cancelLogin(provider, req) {
@@ -38,9 +38,15 @@ class Connect {
     }
     return null
   }
-  async keys(provider) {
-    let res = await this.clients[provider].keys()
+  async keys(provider, context) {
+    let res = await this.clients[provider].keys(context)
     return res
   }
+  async connected(provider, options) {
+    if (this.clients[provider] && this.clients[provider].connected) {
+      return await this.clients[provider].connected(options)
+    }
+    return false
+  }
 }
 module.exports = Connect

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

@@ -18,23 +18,55 @@ class Huggingface {
   defaultTokenPath() {
     return this.kernel.path("cache", "HF_AUTH", "token")
   }
-  async authEnv() {
-    let systemEnv = {}
+  requestCwd(context = {}) {
+    if (context.cwd) {
+      return path.resolve(context.cwd)
+    }
+    if (context.parentPath) {
+      return path.dirname(path.resolve(context.parentPath))
+    }
+    return this.kernel.homedir
+  }
+  async repairTokenPath(tokenPath) {
     try {
-      systemEnv = await Environment.get(this.kernel.homedir, this.kernel)
-    } catch (_) {
-      systemEnv = {}
+      const stat = await fs.promises.lstat(tokenPath)
+      if (stat.isDirectory()) {
+        await fs.promises.rm(tokenPath, { recursive: true, force: true })
+      }
+    } catch (error) {
+      if (!error || error.code !== "ENOENT") {
+        throw error
+      }
+    }
+    await fs.promises.mkdir(path.dirname(tokenPath), { recursive: true })
+  }
+  async authEnv(context = {}) {
+    let env
+    if (context.parentPath) {
+      env = await Environment.get2(context.parentPath, this.kernel)
+    } else {
+      let systemEnv = {}
+      try {
+        systemEnv = await Environment.get(this.kernel.homedir, this.kernel)
+      } catch (_) {
+        systemEnv = {}
+      }
+      env = Object.assign({}, process.env, systemEnv)
+    }
+    if (context.env && typeof context.env === "object") {
+      env = Object.assign(env, context.env)
     }
-    const env = Object.assign({}, process.env, systemEnv)
     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)
     }
     if (!env.HF_HUB_DISABLE_UPDATE_CHECK) {
       env.HF_HUB_DISABLE_UPDATE_CHECK = "1"
     }
     delete env.HF_TOKEN
     delete env.HUGGING_FACE_HUB_TOKEN
-    await fs.promises.mkdir(path.dirname(env.HF_TOKEN_PATH), { recursive: true }).catch(() => {})
+    await this.repairTokenPath(env.HF_TOKEN_PATH)
     return env
   }
   hfPath() {
@@ -52,12 +84,13 @@ class Huggingface {
     }
     return candidates[0]
   }
-  async runHf(args) {
-    const env = await this.authEnv()
+  async runHf(args, options = {}, context = {}) {
+    const env = await this.authEnv(context)
     return new Promise((resolve, reject) => {
       execFile(this.hfPath(), args, {
-        cwd: this.kernel.homedir,
+        cwd: this.requestCwd(context),
         env,
+        timeout: Number.isFinite(options.timeout) ? options.timeout : undefined,
         maxBuffer: 1024 * 1024,
       }, (error, stdout, stderr) => {
         if (error) {
@@ -114,11 +147,18 @@ class Huggingface {
       expires_in: expiresMatch ? Number(expiresMatch[1]) : null,
     }
   }
-  async login() {
+  async login(_params = {}, context = {}) {
+    const env = await this.authEnv(context)
     if (this.loginSession && this.loginSession.status === "pending") {
+      if (this.loginSession.tokenPath !== env.HF_TOKEN_PATH) {
+        return {
+          status: "error",
+          error: `A Hugging Face login is already pending for ${this.loginSession.tokenPath}`,
+          token_path: env.HF_TOKEN_PATH,
+        }
+      }
       return this.serializeLoginSession(this.loginSession)
     }
-    const env = await this.authEnv()
     const session = {
       status: "pending",
       login: null,
@@ -148,7 +188,7 @@ class Huggingface {
       }
     }
     const child = spawn(this.hfPath(), ["auth", "login", "--format", "agent", "--force"], {
-      cwd: this.kernel.homedir,
+      cwd: this.requestCwd(context),
       env,
       windowsHide: false,
     })
@@ -184,12 +224,15 @@ class Huggingface {
     }
     return this.serializeLoginSession(session)
   }
-  async keys() {
+  async keys(context = {}) {
     if (this.loginSession && this.loginSession.status === "pending") {
-      return this.serializeLoginSession(this.loginSession)
+      const env = await this.authEnv(context)
+      if (this.loginSession.tokenPath === env.HF_TOKEN_PATH) {
+        return this.serializeLoginSession(this.loginSession)
+      }
     }
     try {
-      const { stdout, env } = await this.runHf(["auth", "token", "--format", "quiet"])
+      const { stdout, env } = await this.runHf(["auth", "token", "--format", "quiet"], {}, context)
       const access_token = stripAnsi(stdout).trim().split(/\r?\n/).find(Boolean)
       if (!access_token) {
         return null
@@ -199,6 +242,14 @@ class Huggingface {
       return null
     }
   }
+  async connected(options = {}) {
+    try {
+      await this.runHf(["auth", "whoami", "--format", "quiet"], options)
+      return true
+    } catch (_) {
+      return false
+    }
+  }
   async profile() {
     const keys = await this.keys()
     if (!keys || !keys.access_token) {
@@ -219,12 +270,12 @@ class Huggingface {
     await this.config.profile.cache(response, connectPath).catch(() => {})
     return this.config.profile.render(response)
   }
-  async destroy() {
+  async destroy(context = {}) {
     if (this.loginSession && this.loginSession.child && this.loginSession.status === "pending") {
       this.loginSession.child.kill()
     }
     this.loginSession = null
-    await this.runHf(["auth", "logout"]).catch(() => {})
+    await this.runHf(["auth", "logout"], {}, context).catch(() => {})
     await fs.promises.rm(this.kernel.path("connect", "huggingface"), { recursive: true, force: true }).catch(() => {})
   }
   async cancelLogin() {
@@ -241,8 +292,8 @@ class Huggingface {
       this.loginSession = null
     }
   }
-  async logout() {
-    await this.destroy()
+  async logout(_params = {}, context = {}) {
+    await this.destroy(context)
   }
 }
 

package/kernel/environment.js

@@ -489,21 +489,6 @@ const ENVS = async () => {
       "#",
       "##########################################################################",
     ],
-  }, {
-    type: ["system"],
-    key: "HF_TOKEN_PATH",
-    val: "./cache/HF_AUTH/token",
-    comment: [
-      "##########################################################################",
-      "#",
-      "# HF_TOKEN_PATH",
-      "#",
-      "# Hugging Face authentication token file",
-      "# Pinokio keeps this shared across apps so each app can customize HF_HOME",
-      "# for model/cache files without changing the logged-in Hugging Face account.",
-      "#",
-      "##########################################################################",
-    ],
   }, {
     type: ["system", "app"],
     key: "TORCH_HOME",

package/package.json

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

package/server/index.js

@@ -28,6 +28,7 @@ const system = require('systeminformation')
 const serveIndex = require('./serveIndex')
 const registerFileRoutes = require('./routes/files')
 const registerAppRoutes = require('./routes/apps')
+const registerConnectRoutes = require('./routes/connect')
 const ServerAutolaunch = require('./autolaunch')
 const Git = require("../kernel/git")
 const TerminalApi = require('../kernel/api/terminal')
@@ -1500,7 +1501,7 @@ class Server {
       )
     })
   }
-  async get_github_connection() {
+  async get_github_connection(options = {}) {
     if (this._githubConnectionPromise) {
       return this._githubConnectionPromise
     }
@@ -1511,7 +1512,9 @@ class Server {
       let gcmError = null
 
       try {
-        const stdout = await this.github_gcm(['list'], { timeout: 10000 })
+        const stdout = await this.github_gcm(['list'], {
+          timeout: Number.isFinite(options.timeout) ? options.timeout : 10000
+        })
         accounts = stdout
           .split(/\r?\n/)
           .map((line) => line.trim())
@@ -1550,7 +1553,7 @@ class Server {
       ? "echo P^INOKIO_GITHUB_LOGIN_DONE"
       : "(GCM_DONE=INOKIO_GITHUB_LOGIN_DONE; printf 'P%s\\n' \"$GCM_DONE\")"
     const loginCommand = [
-      "git credential-manager github login --web --force",
+      "git credential-manager github login --device --force",
       verifyCommand,
       doneCommand
     ].join(" && ")
@@ -12668,80 +12671,19 @@ class Server {
 
     /*
     GET /connect => display connection options
+    - huggingface
     - github
-    - x
     */
-    this.app.get("/connect", ex(async (req, res) => {
-      let list = this.getPeers()
-      let current_urls = await this.current_urls(req.originalUrl.slice(1))
-      let items = [{
-//        image: "/pinokio-black.png",
-//        name: "pinokio",
-//        title: "pinokio.co",
-//        description: "Connect with pinokio.co",
-//        url: "/connect/pinokio"
-//      }, {
-        icon: "fa-brands fa-hugging-face",
-        name: "huggingface",
-        title: "huggingface.co",
-        description: "Connect with huggingface.co",
-        url: "/connect/huggingface"
-      }, {
-        icon: "fa-brands fa-github",
-        name: "github",
-        title: "github.com",
-        description: "Connect with GitHub.com",
-        url: "/github"
-      }, {
-        icon: "fa-brands fa-square-x-twitter",
-        name: "x",
-        title: "x.com",
-        description: "Connect with X.com",
-        url: "/connect/x",
-        hidden: true
-      }]
-      let github_hosts = await this.get_github_hosts()
-      for(let i=0; i<items.length; i++) {
-        try {
-          if (items[i].name === "github") {
-            if (github_hosts.length > 0) {
-              items[i].profile = {
-                icon: "fa-brands fa-github",
-                items: [{
-                  key: "config",
-                  val: github_hosts
-                }]
-              }
-              items[i].description = `<i class="fa-solid fa-circle-check"></i> Connected with ${items[i].title}`
-              items[i].connected = true
-            }
-          } else {
-            const config = this.kernel.connect.config[items[i].name]
-            if (config) {
-              let profile = await this.kernel.connect.profile(items[i].name)
-              if (profile) {
-                items[i].profile = profile 
-                items[i].description = `<i class="fa-solid fa-circle-check"></i> Connected with ${items[i].title}`
-                items[i].connected = true
-              }
-            }
-          }
-        } catch (e) {
-        }
-      }
-      const peerAccess = await this.composePeerAccessPayload()
-      res.render(`connect`, {
-        current_urls,
-        current_host: this.kernel.peer.host,
-        ...peerAccess,
-        list,
+    registerConnectRoutes(this.app, {
+      getPageContext: (req) => ({
         portal: this.portal,
         logo: this.logo,
         theme: this.theme,
-        agent: req.agent,
-        items: items.filter((item) => !item.hidden),
-      })
-    }))
+        agent: req.agent
+      }),
+      getGithubConnection: (options) => this.get_github_connection(options),
+      getProviderConnection: (provider, options) => this.kernel.connect.connected(provider, options)
+    })
     /*
     *  GET /connect/x
     *  GET /connect/discord
@@ -13514,6 +13456,7 @@ class Server {
     }))
     this.app.get("/github/login", ex(async (req, res) => {
       let id = "gh_login"
+      this.kernel.shell.kill({ id: `shell/${id}` })
       let params = new URLSearchParams()
       const { doneMarker, message } = this.github_login_params()
       params.set("message", encodeURIComponent(message))

package/server/public/task-launcher.css

@@ -2618,6 +2618,10 @@ body.connect-page .connect-service-status {
   font-weight: 700;
 }
 
+body.connect-page .connect-service-status[hidden] {
+  display: none;
+}
+
 body.connect-page .connect-service-open {
   color: var(--task-muted);
   font-size: 15px;

package/server/routes/connect.js

@@ -0,0 +1,49 @@
+const CONNECT_STATUS_TIMEOUT_MS = 3000
+
+const CONNECT_ITEMS = [{
+  icon: "fa-brands fa-hugging-face",
+  name: "huggingface",
+  title: "huggingface.co",
+  description: "Connect with huggingface.co",
+  url: "/connect/huggingface"
+}, {
+  icon: "fa-brands fa-github",
+  name: "github",
+  title: "github.com",
+  description: "Connect with GitHub.com",
+  url: "/github"
+}]
+
+module.exports = function registerConnectRoutes(app, options = {}) {
+  const getPageContext = options.getPageContext || (() => ({}))
+  const getGithubConnection = options.getGithubConnection
+  const getProviderConnection = options.getProviderConnection
+  const statusTimeoutMs = Number.isFinite(options.statusTimeoutMs)
+    ? options.statusTimeoutMs
+    : CONNECT_STATUS_TIMEOUT_MS
+
+  app.get("/connect", (req, res) => {
+    res.render("connect", {
+      ...getPageContext(req),
+      items: CONNECT_ITEMS
+    })
+  })
+
+  app.get("/connect/status/:provider", async (req, res) => {
+    const provider = String(req.params.provider || "")
+    let connected = false
+    try {
+      if (provider === "github" && typeof getGithubConnection === "function") {
+        const connection = await getGithubConnection({ timeout: statusTimeoutMs })
+        connected = Boolean(connection && connection.connected)
+      } else if (provider === "huggingface" && typeof getProviderConnection === "function") {
+        connected = await getProviderConnection(provider, { timeout: statusTimeoutMs })
+      } else {
+        res.status(404).json({ provider, error: "Unknown provider" })
+        return
+      }
+    } catch (_) {}
+    res.set("Cache-Control", "no-store")
+    res.json({ provider, connected: Boolean(connected) })
+  })
+}

package/server/views/connect.ejs

@@ -818,56 +818,31 @@ body.dark .profile td {
         <% } else { %>
           <div class='connect-service-list'>
       <% items.forEach((item) => { %>
-        <% if (item.profile) { %>
-          <a href="<%=item.url%>" class="connect-service-card connect-service-card-connected">
-            <div class='connect-service-head'>
-              <div class='connect-service-icon'>
-                <% if (item.image) { %>
-                  <img class="connect-service-icon-image" src="<%=item.image%>" alt="">
-                <% } else if (item.icon) { %>
-                  <i class="<%=item.icon%>"></i>
-                <% } else if (item.emoji) { %>
-                  <span><%=item.emoji%></span>
-                <% } else { %>
-                  <i class="fa-solid fa-plug"></i>
-                <% } %>
-              </div>
-              <div class='connect-service-copy'>
-                <div class='connect-service-title-row'>
-                  <h2 class='connect-service-title'><%=item.title%></h2>
-                  <span class='connect-service-status'>Connected</span>
-                </div>
-                <div class='connect-service-description'><%- item.description %></div>
-              </div>
-              <div class='connect-service-open' aria-hidden='true'>
-                <i class="fa-solid fa-chevron-right"></i>
-              </div>
+        <a href="<%=item.url%>" class="connect-service-card" data-connect-provider="<%=item.name%>">
+          <div class='connect-service-head'>
+            <div class='connect-service-icon'>
+              <% if (item.image) { %>
+                <img class="connect-service-icon-image" src="<%=item.image%>" alt="">
+              <% } else if (item.icon) { %>
+                <i class="<%=item.icon%>"></i>
+              <% } else if (item.emoji) { %>
+                <span><%=item.emoji%></span>
+              <% } else { %>
+                <i class="fa-solid fa-plug"></i>
+              <% } %>
             </div>
-          </a>
-        <% } else { %>
-          <a href="<%=item.url%>" class="connect-service-card">
-            <div class='connect-service-head'>
-              <div class='connect-service-icon'>
-                <% if (item.image) { %>
-                  <img class="connect-service-icon-image" src="<%=item.image%>" alt="">
-                <% } else if (item.icon) { %>
-                  <i class="<%=item.icon%>"></i>
-                <% } else if (item.emoji) { %>
-                  <span><%=item.emoji%></span>
-                <% } else { %>
-                  <i class="fa-solid fa-plug"></i>
-                <% } %>
-              </div>
-              <div class='connect-service-copy'>
+            <div class='connect-service-copy'>
+              <div class='connect-service-title-row'>
                 <h2 class='connect-service-title'><%=item.title%></h2>
-                <div class="connect-service-description"><%=item.description%></div>
-              </div>
-              <div class="connect-service-open" aria-hidden='true'>
-                <i class="fa-solid fa-chevron-right"></i>
+                <span class='connect-service-status' data-connect-status aria-live="polite">Checking...</span>
               </div>
+              <div class="connect-service-description" data-connect-description><%=item.description%></div>
             </div>
-          </a>
-        <% } %>
+            <div class="connect-service-open" aria-hidden='true'>
+              <i class="fa-solid fa-chevron-right"></i>
+            </div>
+          </div>
+        </a>
       <% }) %>
           </div>
         <% } %>
@@ -878,5 +853,50 @@ body.dark .profile td {
 <%- include('partials/main_sidebar', { selected: 'connect' }) %>
 </main>
 <%- include('partials/app_common_scripts') %>
+<script>
+  (() => {
+    const cards = document.querySelectorAll("[data-connect-provider]")
+    cards.forEach((card) => {
+      const provider = card.dataset.connectProvider
+      const status = card.querySelector("[data-connect-status]")
+      const description = card.querySelector("[data-connect-description]")
+      const title = card.querySelector(".connect-service-title")
+      const controller = new AbortController()
+      const timer = window.setTimeout(() => controller.abort(), 4000)
+
+      fetch(`/connect/status/${encodeURIComponent(provider)}`, {
+        cache: "no-store",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      }).then((response) => {
+        if (!response.ok) {
+          throw new Error(`Status request failed: ${response.status}`)
+        }
+        return response.json()
+      }).then((result) => {
+        const connected = Boolean(result && result.connected)
+        if (!connected) {
+          if (status) {
+            status.hidden = true
+          }
+          return
+        }
+        if (status) {
+          status.textContent = "Connected"
+          status.hidden = false
+        }
+        if (description && title) {
+          description.textContent = `Connected with ${title.textContent}`
+        }
+      }).catch(() => {
+        if (status) {
+          status.hidden = true
+        }
+      }).finally(() => {
+        window.clearTimeout(timer)
+      })
+    })
+  })()
+</script>
 </body>
 </html>

package/server/views/install.ejs

@@ -64,6 +64,9 @@ body.install-page > .terminal-container {
   height: 100%;
   min-height: 0;
 }
+body.install-page #terminal .xterm {
+  padding-top: 10px !important;
+}
 .line2 {
   display: flex;
   align-items: center;

package/test/connect-page-route.test.js

@@ -0,0 +1,143 @@
+const assert = require('node:assert/strict')
+const http = require('node:http')
+const path = require('node:path')
+const test = require('node:test')
+const express = require('express')
+const registerConnectRoutes = require('../server/routes/connect')
+
+const viewsPath = path.resolve(__dirname, '..', 'server', 'views')
+
+async function startConnectServer(options = {}) {
+  const app = express()
+  app.set('views', viewsPath)
+  app.set('view engine', 'ejs')
+  registerConnectRoutes(app, {
+    getPageContext: () => ({
+      portal: '',
+      logo: '',
+      theme: 'light',
+      agent: 'test'
+    }),
+    getGithubConnection: options.getGithubConnection,
+    getProviderConnection: options.getProviderConnection,
+    statusTimeoutMs: options.statusTimeoutMs
+  })
+  app.use((error, req, res, next) => {
+    res.status(500).send(error.message)
+  })
+
+  const server = http.createServer(app)
+  await new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  const address = server.address()
+  return {
+    baseUrl: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve())
+    })
+  }
+}
+
+async function fetchWithin(url, timeoutMs = 500) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(url, { signal: controller.signal })
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+test('/connect renders without invoking provider status checks', async () => {
+  let githubCalls = 0
+  let huggingfaceCalls = 0
+  const fixture = await startConnectServer({
+    getGithubConnection: async () => {
+      githubCalls += 1
+      return await new Promise(() => {})
+    },
+    getProviderConnection: async () => {
+      huggingfaceCalls += 1
+      return await new Promise(() => {})
+    }
+  })
+
+  try {
+    const response = await fetchWithin(`${fixture.baseUrl}/connect`)
+    const html = await response.text()
+
+    assert.equal(response.status, 200)
+    assert.equal(githubCalls, 0)
+    assert.equal(huggingfaceCalls, 0)
+    assert.match(html, /data-connect-provider="huggingface"/)
+    assert.match(html, /data-connect-provider="github"/)
+    assert.match(html, /Checking\.\.\./)
+  } finally {
+    await fixture.close()
+  }
+})
+
+test('/connect status endpoints check providers independently with bounded options', async () => {
+  const calls = []
+  const fixture = await startConnectServer({
+    statusTimeoutMs: 75,
+    getGithubConnection: async (options) => {
+      calls.push({ provider: 'github', options })
+      return { connected: true }
+    },
+    getProviderConnection: async (provider, options) => {
+      calls.push({ provider, options })
+      return false
+    }
+  })
+
+  try {
+    const [githubResponse, huggingfaceResponse] = await Promise.all([
+      fetch(`${fixture.baseUrl}/connect/status/github`),
+      fetch(`${fixture.baseUrl}/connect/status/huggingface`)
+    ])
+    const github = await githubResponse.json()
+    const huggingface = await huggingfaceResponse.json()
+
+    assert.deepEqual(github, { provider: 'github', connected: true })
+    assert.deepEqual(huggingface, { provider: 'huggingface', connected: false })
+    assert.deepEqual(calls, [{
+      provider: 'github',
+      options: { timeout: 75 }
+    }, {
+      provider: 'huggingface',
+      options: { timeout: 75 }
+    }])
+    assert.match(githubResponse.headers.get('cache-control'), /no-store/)
+  } finally {
+    await fixture.close()
+  }
+})
+
+test('/connect status endpoints degrade provider errors to disconnected', async () => {
+  const fixture = await startConnectServer({
+    statusTimeoutMs: 30,
+    getGithubConnection: async () => {
+      throw new Error('github unavailable')
+    },
+    getProviderConnection: async () => {
+      throw new Error('huggingface unavailable')
+    }
+  })
+
+  try {
+    const [githubResponse, huggingfaceResponse] = await Promise.all([
+      fetch(`${fixture.baseUrl}/connect/status/github`),
+      fetch(`${fixture.baseUrl}/connect/status/huggingface`)
+    ])
+
+    assert.equal(githubResponse.status, 200)
+    assert.equal(huggingfaceResponse.status, 200)
+    assert.deepEqual(await githubResponse.json(), { provider: 'github', connected: false })
+    assert.deepEqual(await huggingfaceResponse.json(), { provider: 'huggingface', connected: false })
+  } finally {
+    await fixture.close()
+  }
+})

package/test/github-connection.test.js

@@ -36,6 +36,19 @@ test('GitHub connection reports GCM accounts as connected', async () => {
   assert.equal(connection.display, 'github.com: octocat')
 })
 
+test('GitHub connection forwards a bounded timeout to GCM status checks', async () => {
+  let receivedOptions
+  await Server.prototype.get_github_connection.call({
+    get_legacy_github_hosts: async () => '',
+    github_gcm: async (args, options) => {
+      receivedOptions = options
+      return ''
+    },
+  }, { timeout: 2500 })
+
+  assert.deepEqual(receivedOptions, { timeout: 2500 })
+})
+
 test('GitHub connection coalesces only concurrent GCM checks', async () => {
   let calls = 0
   const context = {
@@ -66,8 +79,9 @@ test('GitHub login only emits completion marker after credential verification',
   })
 
   assert.equal(doneMarker, 'PINOKIO_GITHUB_LOGIN_DONE')
-  assert.match(message, /git credential-manager github login --web --force && printf 'protocol=https\\nhost=github\.com\\n\\n' \| GIT_TERMINAL_PROMPT=0 GCM_INTERACTIVE=never git credential fill >\/dev\/null && \(GCM_DONE=INOKIO_GITHUB_LOGIN_DONE; printf 'P%s\\n' "\$GCM_DONE"\)/)
-  assert.doesNotMatch(message, /git credential-manager github login --web --force\s*;/)
+  assert.match(message, /git credential-manager github login --device --force && printf 'protocol=https\\nhost=github\.com\\n\\n' \| GIT_TERMINAL_PROMPT=0 GCM_INTERACTIVE=never git credential fill >\/dev\/null && \(GCM_DONE=INOKIO_GITHUB_LOGIN_DONE; printf 'P%s\\n' "\$GCM_DONE"\)/)
+  assert.doesNotMatch(message, /git credential-manager github login --device --force\s*;/)
+  assert.doesNotMatch(message, /--web/)
   assert.doesNotMatch(message, /PINOKIO_GITHUB_LOGIN_DONE/)
 })
 
@@ -76,7 +90,8 @@ test('GitHub login uses success-only credential verification on Windows', () =>
     kernel: { platform: 'win32' }
   })
 
-  assert.match(message, /git credential-manager github login --web --force && powershell\.exe -NoProfile -Command "\$env:GIT_TERMINAL_PROMPT='0'; \$env:GCM_INTERACTIVE='never'; @\('protocol=https','host=github\.com',''\) \| git credential fill > \$null; exit \$LASTEXITCODE" && echo P\^INOKIO_GITHUB_LOGIN_DONE/)
+  assert.match(message, /git credential-manager github login --device --force && powershell\.exe -NoProfile -Command "\$env:GIT_TERMINAL_PROMPT='0'; \$env:GCM_INTERACTIVE='never'; @\('protocol=https','host=github\.com',''\) \| git credential fill > \$null; exit \$LASTEXITCODE" && echo P\^INOKIO_GITHUB_LOGIN_DONE/)
+  assert.doesNotMatch(message, /--web/)
   assert.doesNotMatch(message, /PINOKIO_GITHUB_LOGIN_DONE/)
 })
 

package/test/hf-api.test.js

@@ -17,12 +17,14 @@ test('hf.login shows a modal, waits for the user to open Hugging Face, then clos
   const originalOpenURI = Util.openURI
   const originalClipboard = Util.clipboard
   let keyReads = 0
+  const keyContexts = []
   const loginCalls = []
   const waitCalls = []
   const kernel = {
     connect: {
-      async keys(provider) {
+      async keys(provider, context) {
         assert.equal(provider, 'huggingface')
+        keyContexts.push(context)
         keyReads += 1
         if (keyReads < 3) {
           return null
@@ -32,8 +34,8 @@ test('hf.login shows a modal, waits for the user to open Hugging Face, then clos
           token_path: '/tmp/pinokio/hf-token'
         }
       },
-      async login(provider, params) {
-        loginCalls.push({ provider, params })
+      async login(provider, params, context) {
+        loginCalls.push({ provider, params, context })
         return {
           status: 'pending',
           login,
@@ -58,15 +60,28 @@ test('hf.login shows a modal, waits for the user to open Hugging Face, then clos
   }
 
   try {
-    const result = await hf.login({
+    const request = {
       parent: { id: 'test-script', path: '/pinokio/api/test/hf-login.js' },
       params: {
         timeout: 100,
         interval: 1
       }
-    }, (stream, type) => packets.push({ type, stream }), kernel)
+    }
+    const result = await hf.login(request, (stream, type) => packets.push({ type, stream }), kernel)
 
-    assert.deepEqual(loginCalls, [{ provider: 'huggingface', params: { timeout: 100, interval: 1 } }])
+    const authContext = {
+      parentPath: '/pinokio/api/test/hf-login.js',
+      cwd: undefined,
+      env: undefined
+    }
+    assert.deepEqual(loginCalls, [{
+      provider: 'huggingface',
+      params: request.params,
+      context: authContext
+    }])
+    assert.equal(loginCalls[0].params, request.params)
+    assert.equal(keyContexts.length, 3)
+    assert.equal(keyContexts.every((context) => context === loginCalls[0].context), true)
     assert.deepEqual(waitCalls, ['/pinokio/api/test/hf-login.js'])
     assert.deepEqual(actions, [{
       type: 'clipboard',
@@ -185,9 +200,14 @@ test('hf.login can use the non-modal browser fallback when modal is disabled', a
         assert.equal(provider, 'huggingface')
         return null
       },
-      async login(provider, params) {
+      async login(provider, params, context) {
         assert.equal(provider, 'huggingface')
         assert.deepEqual(params, { modal: false, wait: false })
+        assert.deepEqual(context, {
+          parentPath: undefined,
+          cwd: undefined,
+          env: undefined
+        })
         return {
           status: 'pending',
           login,
@@ -396,8 +416,8 @@ test('hf.logout delegates to the Hugging Face connect provider and returns succe
   const calls = []
   const kernel = {
     connect: {
-      async logout(provider, params) {
-        calls.push({ method: 'logout', provider, params })
+      async logout(provider, params, context) {
+        calls.push({ method: 'logout', provider, params, context })
       }
     }
   }
@@ -405,7 +425,16 @@ test('hf.logout delegates to the Hugging Face connect provider and returns succe
   const result = await hf.logout(req, () => {}, kernel)
 
   assert.deepEqual(result, { status: 'success' })
-  assert.deepEqual(calls, [{ method: 'logout', provider: 'huggingface', params: req.params }])
+  assert.deepEqual(calls, [{
+    method: 'logout',
+    provider: 'huggingface',
+    params: req.params,
+    context: {
+      parentPath: undefined,
+      cwd: undefined,
+      env: undefined
+    }
+  }])
 })
 
 test('hf.upload runs hf upload through shell.run with Hugging Face CLI args', async () => {

package/test/huggingface-connect.test.js

@@ -5,6 +5,7 @@ const path = require('node:path')
 const test = require('node:test')
 
 const HuggingfaceConnect = require('../kernel/connect/providers/huggingface')
+const Environment = require('../kernel/environment')
 
 function createKernel(root) {
   return {
@@ -23,6 +24,11 @@ function createKernel(root) {
   }
 }
 
+test('system environment does not persist the default Hugging Face token path', async () => {
+  const content = await Environment.ENV('system', '/tmp/pinokio', {})
+  assert.doesNotMatch(content, /^HF_TOKEN_PATH=/m)
+})
+
 test('Hugging Face connect parses managed hf JSON device login events', () => {
   const provider = new HuggingfaceConnect(createKernel('/tmp/pinokio'), {})
   const parsed = provider.parseDeviceLogin(
@@ -50,15 +56,16 @@ test('Hugging Face connect parses managed hf agent login instructions', () => {
   })
 })
 
-test('Hugging Face connect uses shared HF_TOKEN_PATH and ignores ambient HF_TOKEN', async () => {
+test('Hugging Face connect preserves configured HF paths and ignores ambient HF_TOKEN', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-'))
-  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'HF_TOKEN_PATH=./custom/hf-token\n')
+  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
   process.env.HF_TOKEN = 'hf_should_not_win'
   try {
     const provider = new HuggingfaceConnect(createKernel(root), {})
     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, undefined)
     assert.equal(env.HF_HUB_DISABLE_UPDATE_CHECK, '1')
@@ -72,6 +79,156 @@ test('Hugging Face connect uses shared HF_TOKEN_PATH and ignores ambient HF_TOKE
   }
 })
 
+test('Hugging Face connect uses the app token path for 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')
+  await fs.mkdir(appDir, { recursive: true })
+  await fs.writeFile(scriptPath, '')
+  await fs.writeFile(
+    path.join(appDir, 'ENVIRONMENT'),
+    'HF_HOME=./cache/huggingface\n'
+  )
+  try {
+    const provider = new HuggingfaceConnect(createKernel(root), {})
+    const context = {
+      parentPath: scriptPath,
+      cwd: appDir,
+    }
+    const sharedEnv = await provider.authEnv(context)
+    assert.equal(sharedEnv.HF_HOME, path.join(appDir, 'cache', 'huggingface'))
+    assert.equal(sharedEnv.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
+
+    await fs.writeFile(
+      path.join(appDir, 'ENVIRONMENT'),
+      'HF_HOME=./cache/huggingface\nHF_TOKEN_PATH=./auth/token\n'
+    )
+    provider.hfPath = () => process.execPath
+    const { env } = await provider.runHf([
+      '-e',
+      'require("node:fs").writeFileSync(process.env.HF_TOKEN_PATH, "hf_app_token")'
+    ], {}, context)
+
+    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' }
+    )
+
+    const commandTokenPath = path.join(appDir, 'command-auth', 'token')
+    const commandContext = {
+      parentPath: scriptPath,
+      cwd: appDir,
+      env: { HF_TOKEN_PATH: './command-auth/token' }
+    }
+    const commandResult = await provider.runHf([
+      '-e',
+      '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')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('Hugging Face connect verifies status with bounded whoami', async () => {
+  const provider = new HuggingfaceConnect(createKernel('/tmp/pinokio'), {})
+  let receivedArgs
+  let receivedOptions
+  provider.runHf = async (args, options) => {
+    receivedArgs = args
+    receivedOptions = options
+  }
+
+  const connected = await provider.connected({ timeout: 2500 })
+
+  assert.deepEqual(receivedArgs, ['auth', 'whoami', '--format', 'quiet'])
+  assert.deepEqual(receivedOptions, { timeout: 2500 })
+  assert.equal(connected, true)
+
+  provider.runHf = async () => {
+    throw new Error('not logged in')
+  }
+  assert.equal(await provider.connected({ timeout: 2500 }), false)
+})
+
+test('Hugging Face connect supplies the shared token path when none is configured', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-default-'))
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'OTHER=value\n')
+  try {
+    const provider = new HuggingfaceConnect(createKernel(root), {})
+    const env = await provider.authEnv()
+
+    assert.equal(env.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
+    await assert.doesNotReject(fs.access(path.join(root, 'cache', 'HF_AUTH')))
+    await assert.rejects(fs.access(env.HF_TOKEN_PATH), { code: 'ENOENT' })
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('Hugging Face connect repairs an empty directory at the token file path', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-repair-'))
+  const tokenPath = path.join(root, 'cache', 'HF_AUTH', 'token')
+  await fs.mkdir(tokenPath, { recursive: true })
+  try {
+    const provider = new HuggingfaceConnect(createKernel(root), {})
+    const env = await provider.authEnv()
+
+    assert.equal(env.HF_TOKEN_PATH, tokenPath)
+    await assert.rejects(fs.access(tokenPath), { code: 'ENOENT' })
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('Hugging Face connect leaves existing token and refresh files unchanged', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-existing-login-'))
+  const authDir = path.join(root, 'cache', 'HF_AUTH')
+  await fs.mkdir(authDir, { recursive: true })
+  await fs.writeFile(path.join(authDir, 'token'), 'hf_existing_token')
+  await fs.writeFile(path.join(authDir, 'stored_tokens'), 'existing stored tokens')
+  try {
+    const provider = new HuggingfaceConnect(createKernel(root), {})
+    const env = await provider.authEnv()
+
+    assert.equal(env.HF_TOKEN_PATH, path.join(authDir, 'token'))
+    assert.equal(await fs.readFile(path.join(authDir, 'token'), 'utf8'), 'hf_existing_token')
+    assert.equal(await fs.readFile(path.join(authDir, 'stored_tokens'), 'utf8'), 'existing stored tokens')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('Hugging Face connect removes a non-empty token directory', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-invalid-dir-'))
+  const authDir = path.join(root, 'cache', 'HF_AUTH')
+  const tokenPath = path.join(authDir, 'token')
+  await fs.mkdir(tokenPath, { recursive: true })
+  await fs.writeFile(path.join(tokenPath, 'leftover.txt'), 'leftover')
+  await fs.writeFile(path.join(authDir, 'stored_tokens'), 'refresh state')
+  try {
+    const provider = new HuggingfaceConnect(createKernel(root), {})
+    await Promise.all([provider.authEnv(), provider.authEnv()])
+    provider.hfPath = () => process.execPath
+    const { env } = await provider.runHf([
+      '-e',
+      'require("node:fs").writeFileSync(process.env.HF_TOKEN_PATH, "hf_replacement_token")'
+    ])
+
+    assert.equal(env.HF_TOKEN_PATH, tokenPath)
+    assert.equal(await fs.readFile(tokenPath, 'utf8'), 'hf_replacement_token')
+    assert.equal(await fs.readFile(path.join(authDir, 'stored_tokens'), 'utf8'), 'refresh state')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
 test('Hugging Face connect cancelLogin only stops a pending login session', async () => {
   const provider = new HuggingfaceConnect(createKernel('/tmp/pinokio'), {})
   let killed = false

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

@@ -172,6 +172,39 @@ test('Shell.init_env disables Hugging Face hub update checks by default without
   assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(root, 'custom', 'hf-token'))
 })
 
+test('Shell.init_env preserves an app HF_HOME without changing the shared token default', 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')
+  await fs.mkdir(appDir, { recursive: true })
+  await fs.writeFile(scriptPath, '')
+  await fs.writeFile(path.join(appDir, 'ENVIRONMENT'), 'HF_HOME=./cache/huggingface\n')
+
+  const shell = createShell(createKernel(root))
+  await shell.init_env({
+    path: appDir,
+    $parent: { path: scriptPath },
+    env: {}
+  })
+
+  assert.equal(shell.env.HF_HOME, path.join(appDir, 'cache', 'huggingface'))
+  assert.equal(shell.env.HF_TOKEN_PATH, path.join(root, 'cache', 'HF_AUTH', 'token'))
+
+  await fs.writeFile(
+    path.join(appDir, 'ENVIRONMENT'),
+    'HF_HOME=./cache/huggingface\nHF_TOKEN_PATH=./auth/token\n'
+  )
+  const overrideShell = createShell(createKernel(root))
+  await overrideShell.init_env({
+    path: appDir,
+    $parent: { path: scriptPath },
+    env: {}
+  })
+
+  assert.equal(overrideShell.env.HF_HOME, path.join(appDir, 'cache', 'huggingface'))
+  assert.equal(overrideShell.env.HF_TOKEN_PATH, path.join(appDir, 'auth', 'token'))
+})
+
 test('Shell.init_env keeps Windows Hugging Face symlink defaults scoped to win32', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-hf-win-'))
   await fs.mkdir(path.join(root, 'api'), { recursive: true })