pinokiod 7.3.1 → 7.3.4

package/kernel/environment.js

@@ -1,9 +1,172 @@
 const path = require('path')
 const portfinder = require('portfinder-cp')
-const os = require('os')
 const fs = require('fs')
 const Util = require('./util')
-const platform = os.platform()
+const ManagedSkills = require('./managed_skills')
+const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
+const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
+const CACHE_PREFLIGHT_KEYS = TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)
+
+const formatCachePreflightError = (error) => {
+  if (!error) {
+    return ""
+  }
+  const parts = []
+  if (error.code) {
+    parts.push(`code=${error.code}`)
+  }
+  if (typeof error.errno !== "undefined") {
+    parts.push(`errno=${error.errno}`)
+  }
+  if (error.syscall) {
+    parts.push(`syscall=${error.syscall}`)
+  }
+  if (error.path) {
+    parts.push(`path=${error.path}`)
+  }
+  if (error.dest) {
+    parts.push(`dest=${error.dest}`)
+  }
+  if (error.message) {
+    parts.push(`message=${error.message}`)
+  }
+  return parts.join(" ")
+}
+
+const logCachePreflight = (message) => {
+  console.log(`[Pinokio cache preflight] ${message}`)
+}
+
+const probeCacheDir = async (dirPath) => {
+  const probeDir = path.resolve(
+    dirPath,
+    `.pinokio-cache-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  )
+  const probeFile = path.resolve(probeDir, "probe.tmp")
+  const renamedFile = path.resolve(probeDir, "probe-renamed.tmp")
+  const steps = [
+    ["create probe directory", () => fs.promises.mkdir(probeDir, { recursive: false })],
+    ["write probe file", () => fs.promises.writeFile(probeFile, "pinokio")],
+    ["append probe file", () => fs.promises.appendFile(probeFile, "-cache-probe")],
+    ["rename probe file", () => fs.promises.rename(probeFile, renamedFile)],
+    ["delete probe file", () => fs.promises.unlink(renamedFile)],
+    ["remove probe directory", () => fs.promises.rmdir(probeDir)]
+  ]
+
+  for (const [step, run] of steps) {
+    try {
+      await run()
+    } catch (error) {
+      await fs.promises.rm(probeDir, { recursive: true, force: true }).catch(() => {})
+      return { ok: false, step, error }
+    }
+  }
+  return { ok: true }
+}
+
+const managedCacheEnvDefaults = () => {
+  const defaults = {}
+  for (const key of CACHE_PREFLIGHT_KEYS) {
+    defaults[key] = `./cache/${key}`
+  }
+  return defaults
+}
+
+const ensureCachePreflightDir = async (key, targetPath) => {
+  logCachePreflight(`${key}: target=${targetPath}`)
+  try {
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: mkdir ok`)
+  } catch (error) {
+    logCachePreflight(`${key}: mkdir failed ${formatCachePreflightError(error)}`)
+  }
+
+  const firstProbe = await probeCacheDir(targetPath)
+  if (firstProbe.ok) {
+    logCachePreflight(`${key}: probe ok`)
+    return { key, path: targetPath, repaired: false, ok: true }
+  }
+
+  logCachePreflight(`${key}: probe failed step="${firstProbe.step}" ${formatCachePreflightError(firstProbe.error)}`)
+  logCachePreflight(`${key}: repair delete start path=${targetPath}`)
+
+  try {
+    await fs.promises.rm(targetPath, { recursive: true, force: true })
+    logCachePreflight(`${key}: repair delete ok`)
+  } catch (error) {
+    logCachePreflight(`${key}: repair delete failed ${formatCachePreflightError(error)}`)
+    return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", error }
+  }
+
+  try {
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: repair mkdir ok`)
+  } catch (error) {
+    logCachePreflight(`${key}: repair mkdir failed ${formatCachePreflightError(error)}`)
+    return { key, path: targetPath, repaired: true, ok: false, step: "repair mkdir", error }
+  }
+
+  const secondProbe = await probeCacheDir(targetPath)
+  if (secondProbe.ok) {
+    logCachePreflight(`${key}: repair probe ok`)
+    return { key, path: targetPath, repaired: true, ok: true }
+  }
+
+  logCachePreflight(`${key}: repair probe failed step="${secondProbe.step}" ${formatCachePreflightError(secondProbe.error)}`)
+  return { key, path: targetPath, repaired: true, ok: false, step: secondProbe.step, error: secondProbe.error }
+}
+
+const ensurePinokioCacheDirs = async (kernel, options = {}) => {
+  if (!kernel || !kernel.homedir) {
+    return {}
+  }
+  const throwOnFailure = !!options.throwOnFailure
+  const root = path.resolve(kernel.homedir)
+  const cacheRoot = path.resolve(root, "cache")
+  const envPath = path.resolve(root, "ENVIRONMENT")
+  const defaults = managedCacheEnvDefaults()
+  logCachePreflight(`start root=${root}`)
+  await Util.update_env(envPath, defaults)
+  logCachePreflight(`ENVIRONMENT updated keys=${CACHE_PREFLIGHT_KEYS.join(",")}`)
+  try {
+    await fs.promises.mkdir(cacheRoot, { recursive: true })
+    logCachePreflight(`cache root mkdir ok path=${cacheRoot}`)
+  } catch (error) {
+    logCachePreflight(`cache root mkdir failed path=${cacheRoot} ${formatCachePreflightError(error)}`)
+  }
+
+  if (process.platform === "darwin") await fs.promises.writeFile(path.resolve(root, ".metadata_never_index"), "", { flag: "a" }).catch(() => {})
+
+  const errors = []
+  const results = []
+
+  for (const key of CACHE_PREFLIGHT_KEYS) {
+    const targetPath = path.resolve(cacheRoot, key)
+    const result = await ensureCachePreflightDir(key, targetPath)
+    results.push(result)
+    if (!result.ok) {
+      errors.push(result)
+    }
+  }
+
+  if (errors.length > 0) {
+    kernel.cacheDirErrors = errors
+    const message = errors
+      .map((error) => `${error.key}: ${error.path} (${error.step || "unknown"} ${formatCachePreflightError(error.error)})`)
+      .join(", ")
+    logCachePreflight(`failed ${message}`)
+    if (throwOnFailure) {
+      throw new Error(`Pinokio could not create writable cache directories: ${message}`)
+    }
+  } else {
+    kernel.cacheDirErrors = []
+    logCachePreflight(`complete ok checked=${results.length} repaired=${results.filter((result) => result.repaired).length}`)
+  }
+
+  kernel.cacheDirPreflight = results
+  const env = await get(root, kernel)
+  return { env, errors, results }
+}
 const ENVS = async () => {
 //  const primary_port = 80
 //  const secondary_port = 42000
@@ -438,18 +601,21 @@ const requirements = async (script, cwd, kernel) => {
   let requires_instantiation = false
   if (script) {
     let pre
-    if (script.pre) {
+    if (Array.isArray(script.pre)) {
       pre = script.pre
-    } else if (script.env) {
+    } else if (Array.isArray(script.env)) {
       pre = script.env
     }
     if (pre) {
       let env = await get2(cwd, kernel)
       for(let item of pre) {
+        if (!item || typeof item !== "object") {
+          continue
+        }
         let env_key
-        if (item.env) {
+        if (typeof item.env === "string" && item.env) {
           env_key = item.env
-        } else if (item.key) {
+        } else if (typeof item.key === "string" && item.key) {
           env_key = item.key
           item.env = item.key
         }
@@ -458,11 +624,20 @@ const requirements = async (script, cwd, kernel) => {
           if (!item.index) {
             item.index = 0
           }
-          if (item.host) {
-            const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(item.host);
-            const url = new URL(hasProtocol ? item.host : `https://${item.host}`);
-            item.host = url.host
-            item.val = await kernel.kv.get(item.host, item.index)
+          if (typeof item.host === "string" && item.host.trim()) {
+            const host = item.host.trim()
+            let parsedHost = ""
+            try {
+              const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(host);
+              const url = new URL(hasProtocol ? host : `https://${host}`);
+              parsedHost = url.host
+            } catch (e) {
+              item.host = ""
+            }
+            if (parsedHost) {
+              item.host = parsedHost
+              item.val = await kernel.kv.get(item.host, item.index)
+            }
           } else {
             item.host = ""
           }
@@ -527,21 +702,6 @@ const init = async (options, kernel) => {
   }
   const homeRoot = path.resolve(kernel.homedir)
   const isHomeRoot = path.resolve(root) === homeRoot
-  const writeSkillIfChanged = async (skillPath, content) => {
-    let shouldWrite = true
-    try {
-      const existingSkillContent = await fs.promises.readFile(skillPath, "utf8")
-      shouldWrite = existingSkillContent !== content
-    } catch (error) {
-      if (!(error && error.code === "ENOENT")) {
-        throw error
-      }
-    }
-
-    if (shouldWrite) {
-      await fs.promises.writeFile(skillPath, content, "utf8")
-    }
-  }
   const writeFileIfChanged = async (targetPath, content) => {
     let shouldWrite = true
     try {
@@ -581,68 +741,6 @@ const init = async (options, kernel) => {
     }
     await fs.promises.copyFile(targetPath, backupPath)
   }
-  const syncSkillToAgentRoots = async (skillName, content) => {
-    const home = os.homedir()
-    const targetDirs = [
-      path.resolve(home, ".agents", "skills", skillName),
-      path.resolve(home, ".claude", "skills", skillName),
-      path.resolve(home, ".hermes", "skills", skillName)
-    ]
-    for (let i = 0; i < targetDirs.length; i++) {
-      const skillDir = targetDirs[i]
-      const skillPath = path.resolve(skillDir, "SKILL.md")
-      await fs.promises.mkdir(skillDir, { recursive: true })
-      await writeSkillIfChanged(skillPath, content)
-    }
-  }
-  const syncGepetoSkillFromAgents = async () => {
-    if (!isHomeRoot) {
-      return
-    }
-
-    const agentsPath = path.resolve(homeRoot, "AGENTS.md")
-    const agentsExists = await kernel.exists(agentsPath)
-    if (!agentsExists) {
-      return
-    }
-
-    let agentsContent = ""
-    try {
-      agentsContent = await fs.promises.readFile(agentsPath, "utf8")
-    } catch (error) {
-      if (error && error.code === "ENOENT") {
-        return
-      }
-      throw error
-    }
-    const skillFrontmatter = [
-      "---",
-      "name: gepeto",
-      "description: Guide for building 1-click launchers and building apps with launchers built-in using Pinokio",
-      "---"
-    ].join("\n")
-    const desiredSkillContent = `${skillFrontmatter}\n\n${agentsContent}`
-    await syncSkillToAgentRoots("gepeto", desiredSkillContent)
-  }
-  const syncPinokioSkillFromTemplate = async () => {
-    if (!isHomeRoot) {
-      return
-    }
-
-    const templatePath = path.resolve(__dirname, "../prototype/system/SKILL_PINOKIO.md")
-    let templateContent
-    try {
-      templateContent = await fs.promises.readFile(templatePath, "utf8")
-    } catch (error) {
-      if (error && error.code === "ENOENT") {
-        return
-      }
-      throw error
-    }
-
-    await syncSkillToAgentRoots("pinokio", templateContent)
-  }
-
   let current = path.resolve(root, "ENVIRONMENT")
   let exists = await kernel.exists(current)
   if (exists) {
@@ -769,9 +867,14 @@ const init = async (options, kernel) => {
     }
   }
 
-  // Keep agent skills in sync for the Pinokio home root
-  await syncGepetoSkillFromAgents()
-  await syncPinokioSkillFromTemplate()
+  // Keep Pinokio-managed skills in sync for the home root.
+  if (isHomeRoot) {
+    try {
+      await ManagedSkills.syncManagedSkills(kernel)
+    } catch (error) {
+      console.warn("[managed skills] Failed to sync managed skills", error)
+    }
+  }
 
   const gitDir = path.resolve(root, ".git")
   const gitDirExists = await kernel.exists(gitDir)
@@ -828,4 +931,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, requirements, init, get_root  }
+module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root  }

package/kernel/git.js

@@ -2,10 +2,17 @@ const git = require('isomorphic-git')
 const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
+const { execFile } = require('child_process')
 const { glob, sync, hasMagic } = require('glob-gitignore')
 const http = require('isomorphic-git/http/node')
 const ini = require('ini')
 const Util = require('./util')
+const NON_INTERACTIVE_GIT_ENV = {
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_ASKPASS: "",
+  SSH_ASKPASS: "",
+  GCM_INTERACTIVE: "never"
+}
 class Git {
   constructor(kernel) {
     this.kernel = kernel
@@ -52,6 +59,68 @@ class Git {
     }
     return str
   }
+  parseCredentialOutput(stdout) {
+    const credential = {}
+    for (const line of String(stdout || "").split(/\r?\n/)) {
+      const index = line.indexOf("=")
+      if (index <= 0) continue
+      credential[line.slice(0, index)] = line.slice(index + 1)
+    }
+    return credential
+  }
+  credentialEnv() {
+    const env = this.kernel && this.kernel.envs ? { ...this.kernel.envs } : { ...process.env }
+    if (this.kernel && this.kernel.homedir && !env.GIT_CONFIG_GLOBAL) {
+      env.GIT_CONFIG_GLOBAL = path.resolve(this.kernel.homedir, "gitconfig")
+    }
+    return { ...env, ...NON_INTERACTIVE_GIT_ENV }
+  }
+  async getCredentialForUrl(rawUrl) {
+    let target
+    try {
+      target = new URL(rawUrl)
+    } catch (_) {
+      return null
+    }
+    if (!/^https?:$/.test(target.protocol) || target.hostname.toLowerCase() !== "github.com") {
+      return null
+    }
+    try {
+      await this.ensureDefaults()
+    } catch (_) {
+      return null
+    }
+    return new Promise((resolve) => {
+      const child = execFile(
+        "git",
+        ["credential", "fill"],
+        {
+          cwd: (this.kernel && this.kernel.homedir) || process.cwd(),
+          env: this.credentialEnv(),
+          timeout: 30000,
+          maxBuffer: 1024 * 1024,
+          windowsHide: true
+        },
+        (error, stdout) => {
+          if (error) {
+            resolve(null)
+            return
+          }
+          const credential = this.parseCredentialOutput(stdout)
+          resolve(credential.password ? credential : null)
+        }
+      )
+      child.stdin.end(`protocol=${target.protocol.slice(0, -1)}\nhost=${target.hostname}\n\n`)
+    })
+  }
+  async getIsomorphicGitAuth(rawUrl) {
+    const credential = await this.getCredentialForUrl(rawUrl)
+    if (!credential || !credential.password) return undefined
+    return {
+      username: credential.username || "x-access-token",
+      password: credential.password
+    }
+  }
   normalizeGitPerson(person) {
     if (!person || typeof person !== "object") return null
     const name = typeof person.name === "string" ? person.name : null
@@ -1087,6 +1156,46 @@ class Git {
       dirty = true
     }
 
+    const mergeMissing = (target, source) => {
+      for (const [key, value] of Object.entries(source)) {
+        const valueIsObject = typeof value === "object" && value !== null && !Array.isArray(value)
+        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+          target[key] = valueIsObject ? { ...value } : value
+          dirty = true
+          continue
+        }
+        if (valueIsObject && typeof target[key] === "object" && target[key] !== null && !Array.isArray(target[key])) {
+          mergeMissing(target[key], value)
+        }
+      }
+    }
+    const clone = (value) => {
+      if (typeof value !== "object" || value === null) return value
+      return JSON.parse(JSON.stringify(value))
+    }
+    const sameConfigValue = (a, b) => JSON.stringify(a) === JSON.stringify(b)
+    const isCredentialSection = (section) => section === "credential" || section.startsWith('credential "')
+    const resetCredentialDefaults = () => {
+      const templateCredentialSections = Object.fromEntries(
+        Object.entries(templateConfig).filter(([section]) => isCredentialSection(section))
+      )
+
+      for (const section of Object.keys(config)) {
+        if (!isCredentialSection(section)) continue
+        if (!Object.prototype.hasOwnProperty.call(templateCredentialSections, section)) {
+          delete config[section]
+          dirty = true
+        }
+      }
+
+      for (const [section, tplSection] of Object.entries(templateCredentialSections)) {
+        if (!sameConfigValue(config[section], tplSection)) {
+          config[section] = clone(tplSection)
+          dirty = true
+        }
+      }
+    }
+
     for (const [section, tplSection] of Object.entries(templateConfig)) {
       if (typeof tplSection !== "object" || tplSection === null) continue
       if (!config[section]) {
@@ -1094,12 +1203,7 @@ class Git {
         dirty = true
         continue
       }
-      for (const [key, value] of Object.entries(tplSection)) {
-        if (!Object.prototype.hasOwnProperty.call(config[section], key)) {
-          config[section][key] = value
-          dirty = true
-        }
-      }
+      mergeMissing(config[section], tplSection)
     }
 
     for (const { section, key, value } of required) {
@@ -1118,6 +1222,21 @@ class Git {
       dirty = true
     }
 
+    resetCredentialDefaults()
+
+    const githubCredentialSection = config['credential "https://github'] && config['credential "https://github']['com"']
+    if (githubCredentialSection && typeof githubCredentialSection === "object") {
+      if (!githubCredentialSection.provider) {
+        githubCredentialSection.provider = "github"
+        dirty = true
+      }
+      const helper = typeof githubCredentialSection.helper === "string" ? githubCredentialSection.helper : ""
+      if (!helper) {
+        githubCredentialSection.helper = "manager"
+        dirty = true
+      }
+    }
+
     if (dirty) {
       await fs.promises.writeFile(gitconfigPath, ini.stringify(config))
     }
@@ -1378,19 +1497,6 @@ class Git {
     const absoluteTarget = path.resolve(targetPath)
     const home = path.resolve(this.kernel.homedir)
     const managedTargets = [
-      {
-        kind: "plugin",
-        root: path.resolve(home, "plugin/code"),
-        matches: (root, target) => target === root || target.startsWith(`${root}${path.sep}`),
-        bootstrap: async () => {
-          await fs.promises.rm(path.resolve(home, "plugin/code"), { recursive: true, force: true })
-          this.dirs.delete(path.resolve(home, "plugin/code"))
-          if (this.kernel.plugin && typeof this.kernel.plugin.init === "function") {
-            await this.kernel.plugin.init()
-          }
-        },
-        exists: async () => this.kernel.exists("plugin/code")
-      },
       {
         kind: "prototype",
         root: path.resolve(home, "prototype/system"),
@@ -1531,6 +1637,7 @@ class Git {
         dir,
         remote,
         tags: false,
+        onAuth: (url) => this.getIsomorphicGitAuth(url),
       })
       if (fetchResult && fetchResult.defaultBranch) {
         addCandidate(`refs/remotes/${remote}/${fetchResult.defaultBranch}`)

package/kernel/gitconfig_template

@@ -9,6 +9,13 @@
   smudge = git-lfs smudge -- %f
   process = git-lfs filter-process
   required = true
+[credential]
+  helper = manager
+  gitHubAuthModes = oauth
+  namespace = pinokio
+[credential "https://github.com"]
+  helper = manager
+  provider = github
 [user]
   name = pinokio
   email = pinokio@localhost

package/kernel/gpu/amd.js

@@ -0,0 +1,72 @@
+const { normalize_model } = require("./common")
+
+// Detect uninformative AMD APU names that need CPU-brand fallback matching.
+const is_generic_gpu_model = (model) => {
+  let normalized = normalize_model(model)
+  return /^(amd )?radeon graphics$/.test(normalized)
+}
+
+// Resolve CPU brand lazily so discrete GPU matches do not trigger CPU probing.
+const resolve_cpu_brand = async (cpu_brand) => {
+  if (typeof cpu_brand === "function") {
+    return await cpu_brand()
+  } else {
+    return 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
+  }
+
+  // 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
+  }
+
+  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)
+  )
+}
+
+// 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
+  }
+  if (!is_generic_gpu_model(model)) {
+    return false
+  }
+  // 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))
+}
+
+module.exports = {
+  is_generic_gpu_model,
+  matches_rocm_torch_model,
+  supports_torch_backend
+}

package/kernel/gpu/apple.js

@@ -0,0 +1,8 @@
+// Apple GPU routes to the built-in PyTorch MPS backend on macOS.
+const supports_torch_backend = (controller, platform) => {
+  return !!controller && platform === "darwin"
+}
+
+module.exports = {
+  supports_torch_backend
+}

package/kernel/gpu/common.js

@@ -0,0 +1,12 @@
+// Normalize GPU/CPU names so matching works across vendor punctuation variants.
+const normalize_model = (model) => {
+  return (model || "")
+    .toLowerCase()
+    .replace(/\((tm|r)\)/g, "")
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()
+}
+
+module.exports = {
+  normalize_model
+}

package/kernel/gpu/intel.js

@@ -0,0 +1,47 @@
+const { normalize_model } = require("./common")
+
+// Resolve CPU brand lazily so clear GPU model matches do not trigger CPU probing.
+const resolve_cpu_brand = async (cpu_brand) => {
+  if (typeof cpu_brand === "function") {
+    return await cpu_brand()
+  } else {
+    return cpu_brand
+  }
+}
+
+// Match Intel GPU model names that Pinokio should route to PyTorch XPU wheels.
+const matches_xpu_torch_model = (model) => {
+  let normalized = normalize_model(model)
+  return (
+    // Intel Arc A-Series / B-Series, Arc Pro, and Core Ultra iGPUs when the
+    // GPU model itself includes Arc.
+    /\barc\b/.test(normalized) ||
+    // Intel Data Center GPU Max Series. Do not match generic Data Center GPU
+    // names because Data Center GPU Flex is not in current PyTorch XPU docs.
+    /\b(data center gpu max|gpu max|ponte vecchio)\b/.test(normalized)
+  )
+}
+
+// Detect uninformative Intel iGPU names that need CPU-brand fallback matching.
+const is_generic_gpu_model = (model) => {
+  let normalized = normalize_model(model)
+  return /^(intel )?graphics$/.test(normalized)
+}
+
+// Decide Intel XPU install intent, using CPU brand only for generic iGPU names.
+const supports_torch_backend = async (model, cpu_brand) => {
+  if (matches_xpu_torch_model(model)) {
+    return true
+  }
+  if (!is_generic_gpu_model(model)) {
+    return false
+  }
+  let brand = normalize_model(await resolve_cpu_brand(cpu_brand))
+  return /\bcore\s*ultra\b/.test(brand)
+}
+
+module.exports = {
+  is_generic_gpu_model,
+  matches_xpu_torch_model,
+  supports_torch_backend
+}