pinokiod 7.5.14 → 7.5.16

package/kernel/api/hf/index.js

@@ -1,7 +1,301 @@
-const path = require('path')
 const unparse = require('yargs-unparser-custom-flag');
 const Shell = require('../shell')
+const Util = require('../../util')
+const HtmlModal = require('../htmlmodal')
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const positiveNumber = (value, fallback) => {
+  const number = Number(value)
+  return Number.isFinite(number) && number > 0 ? number : fallback
+}
+const escapeHtml = (value) => String(value == null ? "" : value)
+  .replace(/&/g, "&")
+  .replace(/</g, "&lt;")
+  .replace(/>/g, "&gt;")
+  .replace(/"/g, "&quot;")
+  .replace(/'/g, "&#39;")
+
 class HF {
+  constructor() {
+    this.htmlModal = new HtmlModal()
+  }
+  connect(kernel, method) {
+    if (!kernel || !kernel.connect || typeof kernel.connect[method] !== "function") {
+      throw new Error(`Hugging Face connect ${method} is not available`)
+    }
+    return kernel.connect
+  }
+  safeKeys(keys) {
+    if (!keys || !keys.access_token) {
+      return keys
+    }
+    return {
+      token_path: keys.token_path
+    }
+  }
+  async copyCode(login, ondata, options = {}) {
+    if (!login || !login.user_code) {
+      return null
+    }
+    try {
+      await Util.clipboard({
+        type: "copy",
+        text: login.user_code
+      })
+      if (ondata && !options.silent) {
+        ondata({ raw: `\r\nHugging Face code copied to clipboard: ${login.user_code}\r\n` })
+      }
+      return { ok: true }
+    } catch (error) {
+      const message = error && error.message ? error.message : String(error)
+      if (ondata && !options.silent) {
+        ondata({ raw: `\r\nCopy this Hugging Face code into the browser: ${login.user_code}\r\n` })
+        ondata({ raw: `Clipboard copy failed: ${message}\r\n` })
+      }
+      return { ok: false, error: message }
+    }
+  }
+  canDispatchModal(req, ondata, kernel) {
+    return !!(
+      ondata
+      && kernel
+      && kernel.api
+      && typeof kernel.api.wait === "function"
+      && req
+      && req.parent
+      && (req.parent.id || req.parent.path)
+    )
+  }
+  canUseModal(req, ondata, kernel, url) {
+    return !!(url && this.canDispatchModal(req, ondata, kernel))
+  }
+  modalRequest(req, modalId, params = {}) {
+    return {
+      params: Object.assign({ id: modalId }, params),
+      parent: req.parent,
+      cwd: req.cwd
+    }
+  }
+  modalId(req) {
+    const id = req && req.parent ? (req.parent.id || req.parent.path) : "hf-login"
+    return `hf-login:${id}`
+  }
+  loginModalHtml(login, clipboard) {
+    const code = escapeHtml(login.user_code || "")
+    const expires = login.expires_in
+      ? `<p class="hf-login-modal-note">Expires in ${escapeHtml(login.expires_in)} seconds.</p>`
+      : ""
+    let copyText = "Copy this code if Hugging Face asks for it."
+    let copyClass = "neutral"
+    if (clipboard && clipboard.ok) {
+      copyText = "The code has been copied to your clipboard."
+      copyClass = "success"
+    } else if (clipboard && clipboard.ok === false) {
+      copyText = `Clipboard copy failed. The code is displayed below.`
+      copyClass = "warning"
+    }
+    return `
+      <div class="hf-login-modal">
+        <div class="hf-login-modal-copy ${copyClass}">${escapeHtml(copyText)}</div>
+        <div class="hf-login-modal-code" aria-label="Hugging Face device code">${code}</div>
+        ${expires}
+        <p>Open Hugging Face to finish login. Pinokio will continue automatically.</p>
+      </div>
+    `
+  }
+  async promptLoginModal(req, ondata, kernel, login, clipboard) {
+    const modalId = this.modalId(req)
+    const response = await this.htmlModal.open(
+      this.modalRequest(req, modalId, {
+        title: "Log in to Hugging Face",
+        variant: "minimal",
+        html: this.loginModalHtml(login, clipboard),
+        status: { text: "Waiting for you to open Hugging Face.", waiting: false },
+        actions: [{
+          id: "open",
+          label: "Open Hugging Face",
+          type: "submit",
+          href: login.verification_uri_complete,
+          target: "_blank",
+          features: "browser",
+          primary: true,
+          close: false,
+          icon: "fa-solid fa-arrow-up-right-from-square"
+        }, {
+          id: "cancel",
+          label: "Cancel",
+          type: "submit",
+          variant: "secondary"
+        }],
+        actionsAlign: "end",
+        await: true,
+        dismissible: false
+      }),
+      ondata,
+      kernel
+    )
+
+    if (!response || response.action === "cancel" || response.action === "dismissed") {
+      await this.htmlModal.close(this.modalRequest(req, modalId), ondata, kernel)
+      throw new Error("Hugging Face login canceled.")
+    }
+
+    await this.htmlModal.update(
+      this.modalRequest(req, modalId, {
+        variant: "minimal",
+        status: { text: "Waiting for Hugging Face authorization to finish...", waiting: true },
+        actions: [{
+          id: "open-again",
+          label: "Open Again",
+          type: "link",
+          href: login.verification_uri_complete,
+          target: "_blank",
+          features: "browser",
+          variant: "secondary",
+          icon: "fa-solid fa-arrow-up-right-from-square"
+        }],
+        actionsAlign: "end",
+        dismissible: false
+      }),
+      ondata,
+      kernel
+    )
+    return response
+  }
+  async closeLoginModal(req, ondata, kernel) {
+    if (!this.canDispatchModal(req, ondata, kernel)) {
+      return
+    }
+    await this.htmlModal.close(this.modalRequest(req, this.modalId(req)), ondata, kernel)
+  }
+  async cancelLogin(connect, params) {
+    if (connect && typeof connect.cancelLogin === "function") {
+      await connect.cancelLogin("huggingface", params || {})
+    }
+  }
+  /*
+  {
+    "method": "hf.login",
+    "params": {
+      "force": false,
+      "open": true,
+      "modal": true,
+      "clipboard": true,
+      "wait": true,
+      "timeout": 120000,
+      "interval": 2000
+    }
+  }
+
+  Starts the existing Hugging Face device login provider. By default it shows a
+  blocking modal with the copied code and waits for the user to open the
+  verification URL before polling for the managed token.
+  */
+  async login(req, ondata, kernel) {
+    const connect = this.connect(kernel, "keys")
+    const params = req.params || {}
+    const force = params.force === true
+    const shouldOpen = params.open !== false
+    const shouldModal = params.modal !== false
+    const shouldCopy = params.clipboard !== false
+    const shouldWait = params.wait !== false
+    const timeout = positiveNumber(params.timeout, 120000)
+    const interval = positiveNumber(params.interval, 2000)
+
+    if (!force) {
+      const existing = await connect.keys("huggingface")
+      if (existing && existing.access_token) {
+        return {
+          status: "success",
+          already_logged_in: true,
+          ...this.safeKeys(existing)
+        }
+      }
+    }
+
+    if (typeof connect.login !== "function") {
+      throw new Error("Hugging Face connect login is not available")
+    }
+    const response = await connect.login("huggingface", params)
+    if (!response || response.status === "error") {
+      return response
+    }
+
+    const login = response.login || {}
+    const url = login.verification_uri_complete
+    const useModal = shouldModal && this.canUseModal(req, ondata, kernel, url)
+    if (shouldCopy && login.user_code) {
+      response.clipboard = await this.copyCode(login, ondata, { silent: useModal })
+    } else if (login.user_code && ondata && !useModal) {
+      ondata({ raw: `\r\nHugging Face code: ${login.user_code}\r\n` })
+    }
+
+    if (useModal) {
+      try {
+        response.open = await this.promptLoginModal(req, ondata, kernel, login, response.clipboard)
+      } catch (error) {
+        await this.cancelLogin(connect, params)
+        throw error
+      }
+    } else if (shouldOpen && url) {
+      if (ondata) {
+        if (!shouldModal) {
+          ondata({ raw: "\r\nHugging Face login modal disabled.\r\n" })
+        }
+        const codeHint = response.clipboard && response.clipboard.ok
+          ? "The code is already on your clipboard; paste it if Hugging Face asks."
+          : "If Hugging Face asks for a code, use the code printed above."
+        ondata({ raw: `Opening Hugging Face login: ${url}\r\n${codeHint}\r\n` })
+        if (response.clipboard && response.clipboard.ok === false) {
+          ondata({ raw: "The browser is opening even though clipboard copy failed.\r\n" })
+        }
+      }
+      response.open = await Util.openURI(url)
+    }
+
+    if (!shouldWait) {
+      if (useModal) {
+        await this.closeLoginModal(req, ondata, kernel)
+      }
+      return response
+    }
+
+    const startedAt = Date.now()
+    while (Date.now() - startedAt < timeout) {
+      const keys = await connect.keys("huggingface")
+      if (keys && keys.access_token) {
+        if (useModal) {
+          await this.closeLoginModal(req, ondata, kernel)
+        }
+        return {
+          ...response,
+          status: "success",
+          ...this.safeKeys(keys)
+        }
+      }
+      await delay(interval)
+    }
+
+    if (useModal) {
+      await this.closeLoginModal(req, ondata, kernel)
+    }
+    await this.cancelLogin(connect, params)
+    return {
+      ...response,
+      status: "timeout",
+      error: "Timed out waiting for Hugging Face login to finish."
+    }
+  }
+  /*
+  {
+    "method": "hf.logout"
+  }
+  */
+  async logout(req, ondata, kernel) {
+    const connect = this.connect(kernel, "logout")
+    await connect.logout("huggingface", req.params || {})
+    return { status: "success" }
+  }
   /*
   {
     "method": "hf.download",

package/kernel/connect/index.js

@@ -32,6 +32,12 @@ class Connect {
     let res = await this.clients[provider].logout(req)
     return res
   }
+  async cancelLogin(provider, req) {
+    if (this.clients[provider] && this.clients[provider].cancelLogin) {
+      return await this.clients[provider].cancelLogin(req)
+    }
+    return null
+  }
   async keys(provider) {
     let res = await this.clients[provider].keys()
     return res

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

@@ -227,6 +227,20 @@ class Huggingface {
     await this.runHf(["auth", "logout"]).catch(() => {})
     await fs.promises.rm(this.kernel.path("connect", "huggingface"), { recursive: true, force: true }).catch(() => {})
   }
+  async cancelLogin() {
+    const session = this.loginSession
+    if (!session || session.status !== "pending") {
+      return
+    }
+    session.status = "canceled"
+    session.error = "Hugging Face login canceled."
+    if (session.child) {
+      session.child.kill()
+    }
+    if (this.loginSession === session) {
+      this.loginSession = null
+    }
+  }
   async logout() {
     await this.destroy()
   }

package/kernel/gpu/amd.js

@@ -1,4 +1,19 @@
 const { normalize_model } = require("./common")
+const amd_gfx_targets = require("./amd_gfx_targets.json")
+
+const canonical_model_key = (model) => {
+  let key = normalize_model(model)
+  let previous
+  do {
+    previous = key
+    key = key
+      .replace(/^advanced micro devices\s+/, "")
+      .replace(/^amd\s+/, "")
+      .replace(/^instinct\s+/, "")
+      .trim()
+  } while (key !== previous)
+  return key
+}
 
 // Detect uninformative AMD APU names that need CPU-brand fallback matching.
 const is_generic_gpu_model = (model) => {
@@ -15,58 +30,30 @@ const resolve_cpu_brand = async (cpu_brand) => {
   }
 }
 
-// Match AMD GPU model names that Pinokio should route to PyTorch ROCm wheels.
-const matches_rocm_torch_model = (model) => {
-  let normalized = normalize_model(model)
-
-  // AMD PyTorch ROCm install policy. These checks are based on the
-  // hardware families Pinokio should route to ROCm-flavored PyTorch wheels,
-  // not on whether ROCm is already installed on the machine.
-
-  // Radeon RX 7600+:
-  // - RX 7600 / 7600 XT / 7600M / 7600M XT
-  // - RX 7700 / 7800 / 7900 families
-  // - RX 9000 families such as RX 9060 and RX 9070
-  // - Future RX 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let rx = normalized.match(/\brx\s*([7-9]\d{3})(?!\d)/)
-  if (rx && Number(rx[1]) >= 7600) {
-    return true
+const resolve_rocm_gfx_target = (model) => {
+  let key = canonical_model_key(model)
+  if (/^gfx[0-9a-f]+$/i.test(key)) {
+    return key.toLowerCase()
   }
-
-  // Radeon PRO W7700+:
-  // - PRO W7700 / W7800 / W7900
-  // - Future PRO W 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let pro = normalized.match(/\bpro\s*w\s*([7-9]\d{3})(?!\d)/)
-  if (pro && Number(pro[1]) >= 7700) {
-    return true
+  if (amd_gfx_targets.entries[key]) {
+    return amd_gfx_targets.entries[key]
   }
 
-  return (
-    // Radeon PRO V710
-    /\bpro\s*v\s*710\b/.test(normalized) ||
-    // Radeon AI PRO R9600/R9700 variants, including suffixes like R9700S.
-    /\bai\s*pro\s*r\s*9[67]\d{2}[a-z]?\b/.test(normalized) ||
-    // Supported APUs and codenames seen in PyTorch ROCm wheel support.
-    /\b(780m|820m|880m|890m|8050s|8060s|strix|phoenix|fire range)\b/.test(normalized)
-  )
+  return null
 }
 
-// Decide AMD ROCm install intent, using CPU brand only for generic APU GPU names.
-const supports_torch_backend = async (model, cpu_brand) => {
-  if (matches_rocm_torch_model(model)) {
-    return true
+const resolve_gpu_target = async (model, cpu_brand) => {
+  let target = resolve_rocm_gfx_target(model)
+  if (target) {
+    return target
   }
   if (!is_generic_gpu_model(model)) {
-    return false
+    return null
   }
-  // APU-only systems can report the GPU as just "AMD Radeon Graphics".
-  // In that generic case, use the CPU brand as a fallback because it often
-  // includes the Radeon model or codename, such as 8060S or Strix Halo.
-  return matches_rocm_torch_model(await resolve_cpu_brand(cpu_brand))
+  return resolve_rocm_gfx_target(await resolve_cpu_brand(cpu_brand))
 }
 
 module.exports = {
-  is_generic_gpu_model,
-  matches_rocm_torch_model,
-  supports_torch_backend
+  resolve_gpu_target,
+  resolve_rocm_gfx_target
 }

package/kernel/gpu/amd_gfx_targets.json

@@ -0,0 +1,67 @@
+{
+  "source": "https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst",
+  "generated_by": "script/update-amd-gfx-targets.js",
+  "entries": {
+    "mi100": "gfx908",
+    "mi210": "gfx90a",
+    "mi25": "gfx900",
+    "mi250": "gfx90a",
+    "mi250x": "gfx90a",
+    "mi300a": "gfx942",
+    "mi300x": "gfx942",
+    "mi325x": "gfx942",
+    "mi350x": "gfx950",
+    "mi355x": "gfx950",
+    "mi50 16gb": "gfx906",
+    "mi50 32gb": "gfx906",
+    "mi6": "gfx803",
+    "mi60": "gfx906",
+    "mi8": "gfx803",
+    "radeon 780m": "gfx1103",
+    "radeon 8060s": "gfx1151",
+    "radeon 860m": "gfx1152",
+    "radeon 890m": "gfx1150",
+    "radeon ai pro r9600d": "gfx1201",
+    "radeon ai pro r9700": "gfx1201",
+    "radeon pro v620": "gfx1030",
+    "radeon pro v710": "gfx1101",
+    "radeon pro vii": "gfx906",
+    "radeon pro w5500": "gfx1012",
+    "radeon pro w6600": "gfx1032",
+    "radeon pro w6800": "gfx1030",
+    "radeon pro w7700": "gfx1101",
+    "radeon pro w7800": "gfx1100",
+    "radeon pro w7800 48gb": "gfx1100",
+    "radeon pro w7900": "gfx1100",
+    "radeon pro w7900 dual slot": "gfx1100",
+    "radeon rx 6600": "gfx1032",
+    "radeon rx 6600 xt": "gfx1032",
+    "radeon rx 6650 xt": "gfx1032",
+    "radeon rx 6700": "gfx1031",
+    "radeon rx 6700 xt": "gfx1031",
+    "radeon rx 6750 xt": "gfx1031",
+    "radeon rx 6800": "gfx1030",
+    "radeon rx 6800 xt": "gfx1030",
+    "radeon rx 6900 xt": "gfx1030",
+    "radeon rx 6950 xt": "gfx1030",
+    "radeon rx 7600": "gfx1102",
+    "radeon rx 7700": "gfx1101",
+    "radeon rx 7700 xt": "gfx1101",
+    "radeon rx 7800 xt": "gfx1101",
+    "radeon rx 7900 gre": "gfx1100",
+    "radeon rx 7900 xt": "gfx1100",
+    "radeon rx 7900 xtx": "gfx1100",
+    "radeon rx 9060": "gfx1200",
+    "radeon rx 9060 xt": "gfx1200",
+    "radeon rx 9060 xt lp": "gfx1200",
+    "radeon rx 9070": "gfx1201",
+    "radeon rx 9070 gre": "gfx1201",
+    "radeon rx 9070 xt": "gfx1201",
+    "radeon vii": "gfx906",
+    "ryzen 7 7840u": "gfx1103",
+    "ryzen 9 270": "gfx1103",
+    "ryzen ai 9 hx 375": "gfx1150",
+    "ryzen ai max pro 395": "gfx1151",
+    "ryzen al 7 350": "gfx1152"
+  }
+}

package/kernel/gpu/nvidia.js

@@ -1,8 +1,94 @@
-// NVIDIA routes to CUDA PyTorch wheels on supported non-macOS platforms.
-const supports_torch_backend = (controller, platform) => {
-  return !!controller && platform !== "darwin"
+const { execFile } = require("node:child_process")
+
+const NVIDIA_SMI_COMPUTE_CAP_ARGS = [
+  "--query-gpu=pci.bus_id,compute_cap",
+  "--format=csv,noheader,nounits"
+]
+
+let cuda_sm_targets_promise = null
+
+const normalize_pci_bus = (bus) => {
+  let normalized = String(bus || "").trim().toLowerCase()
+  let match = /(?:[0-9a-f]{4,8}:)?([0-9a-f]{2}:[0-9a-f]{2}\.[0-7])$/.exec(normalized)
+  return match ? match[1] : normalized
+}
+
+const compute_cap_to_sm_target = (compute_cap) => {
+  let match = /^(\d+)\.(\d+)$/.exec(String(compute_cap || "").trim())
+  return match ? `sm_${match[1]}${match[2]}` : null
+}
+
+const parse_nvidia_smi_compute_caps = (stdout) => {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      let parts = line.split(",").map((part) => part.trim())
+      if (parts.length < 2) return null
+      let target = compute_cap_to_sm_target(parts[1])
+      if (!target) return null
+      return {
+        pci_bus: normalize_pci_bus(parts[0]),
+        target
+      }
+    })
+    .filter(Boolean)
+}
+
+const query_cuda_sm_targets = (exec_file = execFile) => {
+  return new Promise((resolve) => {
+    exec_file(
+      "nvidia-smi",
+      NVIDIA_SMI_COMPUTE_CAP_ARGS,
+      { windowsHide: true, timeout: 5000 },
+      (error, stdout) => {
+        if (error) {
+          resolve([])
+        } else {
+          resolve(parse_nvidia_smi_compute_caps(stdout))
+        }
+      }
+    )
+  })
+}
+
+const cached_cuda_sm_targets = () => {
+  if (!cuda_sm_targets_promise) {
+    cuda_sm_targets_promise = query_cuda_sm_targets()
+  }
+  return cuda_sm_targets_promise
+}
+
+const select_cuda_sm_target = (controller, records) => {
+  let targets = Array.isArray(records) ? records : []
+  if (targets.length === 0) {
+    return null
+  }
+
+  let controller_bus = normalize_pci_bus(controller && (controller.pciBus || controller.busAddress))
+  if (controller_bus) {
+    let match = targets.find((record) => record.pci_bus === controller_bus)
+    if (match) {
+      return match.target
+    }
+  }
+
+  return targets.length === 1 ? targets[0].target : null
+}
+
+const resolve_cuda_sm_target = async (controller) => {
+  if (!controller) {
+    return null
+  }
+  let records = await cached_cuda_sm_targets()
+  return select_cuda_sm_target(controller, records)
 }
 
 module.exports = {
-  supports_torch_backend
+  compute_cap_to_sm_target,
+  parse_nvidia_smi_compute_caps,
+  query_cuda_sm_targets,
+  resolve_cuda_sm_target,
+  select_cuda_sm_target
 }

package/kernel/index.js

@@ -92,10 +92,10 @@ class Kernel {
     this.pinokio_configs = {}
     this.shellpath = shellPath.sync()
     this.favicon = new Favicon()
-    this.torch_backend = "cpu"
     this.vram = 0
     this.ram = 0
     this.gpu_driver = null
+    this.gpu_target = null
     this.readyState = new ReadyState(this)
     this.app_ready_status = this.readyState.status
     this.launchRequirements = new LaunchRequirements(this)
@@ -824,6 +824,7 @@ class Kernel {
       procs: this.procs,
       gpu: this.gpu,
       gpus: this.gpus,
+      gpu_target: this.gpu_target,
       ...info
     }
 
@@ -1152,7 +1153,7 @@ class Kernel {
           system,
           platform: this.platform,
           arch: this.arch,
-          torch_backend: this.torch_backend,
+          gpu_target: this.gpu_target,
           vram: this.vram,
           ram: this.ram,
           proxy: (port) => {
@@ -1349,7 +1350,7 @@ class Kernel {
         this.gpu = info.gpu
         this.gpu_model = info.gpu_model
         this.gpu_driver = info.gpu_driver || null
-        this.torch_backend = info.torch_backend || "cpu"
+        this.gpu_target = info.gpu_target || null
         this.gpus = info.gpus
         this.vram = typeof info.vram === "number" ? info.vram : 0
         this.ram = typeof info.ram === "number" ? info.ram : 0