pinokiod 7.3.1 → 7.3.4

package/kernel/shell.js

@@ -20,6 +20,7 @@ const { applyWindowsNodePackageManagerEnv } = require('./windows_node_package_ma
 const ShellParser = require('./shell_parser')
 const AnsiStreamTracker = require('./ansi_stream_tracker')
 const ShellStateSync = require('./shell_state_sync')
+const ShellRunTemplate = require('./api/shell_run_template')
 const home = os.homedir()
 
 function normalizeComparablePath(filePath, platform) {
@@ -293,6 +294,8 @@ class Shell {
       }
     }
 
+    setDefaultEnvValue(this.env, "HF_HUB_DISABLE_UPDATE_CHECK", "1")
+
     if (this.platform === "win32") {
       // Hugging Face file symlinks regularly fail on non-admin Windows setups.
       // Default to no-symlink cache mode unless the user/app explicitly overrides it.
@@ -308,7 +311,7 @@ class Shell {
         delete this.env[key]
       }
       let val = this.env[key]
-      if (/[\r\n]/.test(val)) {
+      if (!ShellRunTemplate.isPinokioEnvArgKey(key) && /[\r\n]/.test(val)) {
         const replaced = val.replaceAll(/[\r\n]+/g, ' ');
         this.env[key] = replaced
 //        delete this.env[key]
@@ -362,6 +365,9 @@ class Shell {
   }
   quoteArgForShell(value, shellName=this.shell) {
     const input = value == null ? "" : String(value)
+    if (ShellRunTemplate.hasEnvArgMarker(input)) {
+      return ShellRunTemplate.quoteEnvArgComposite(input, shellName)
+    }
     if (this.isCmdShell(shellName)) {
       return `"${input.replace(/([()%!^"<>&|])/g, '^$1')}"`
     }
@@ -409,6 +415,7 @@ class Shell {
     this.userActive = false
     this.decsyncBuffer = ''
     this.stateSync.reset()
+    this.envArgsPreviewed = false
 
     /*
       params := {
@@ -540,6 +547,9 @@ class Shell {
         //}
       }
     }
+    if (params._pinokio_cmd_delayed_expansion && this.isCmdShell(this.shell) && !this.args.includes("/V:ON")) {
+      this.args.push("/V:ON")
+    }
 
     // 3. path => path can be http, relative, absolute
     this.path = params.path
@@ -757,6 +767,16 @@ class Shell {
     }
     this.stateSync.invalidate({ clearTail: true })
   }
+  emitEnvArgsPreview(params) {
+    if (!params || !Array.isArray(params._pinokio_env_args) || params._pinokio_env_args.length === 0 || this.envArgsPreviewed) {
+      return
+    }
+    this.envArgsPreviewed = true
+    const raw = ShellRunTemplate.formatEnvArgsPreview(params._pinokio_env_args)
+    if (raw && this.ondata) {
+      this.ondata({ raw })
+    }
+  }
   async run(params, cb) {
     let r = await this.request(params, cb)
     return r
@@ -1362,6 +1382,7 @@ class Shell {
   }
   async exec(params) {
     this.parser = new ShellParser()
+    this.emitEnvArgsPreview(params)
     params = await this.activate(params)
     this.cmd = this.build(params)
     let res = await new Promise((resolve, reject) => {
@@ -1729,7 +1750,7 @@ class Shell {
       cmd: this.cmd,
       index: this.index,
       group: this.group,
-      env: this.env,
+      env: ShellRunTemplate.redactEnvArgs(this.env),
       done: this.done,
       ready: this.ready,
       id: this.id,

package/kernel/shells.js

@@ -96,6 +96,47 @@ class Shells {
       }
     })
   }
+  isPathWithin(parentPath, childPath) {
+    if (!parentPath || !childPath) {
+      return false
+    }
+    const relative = path.relative(parentPath, childPath)
+    if (!relative) {
+      return true
+    }
+    return !relative.startsWith("..") && !path.isAbsolute(relative)
+  }
+  resourceRootsByWorkspace(apiRoot) {
+    if (typeof apiRoot !== "string" || !apiRoot) {
+      return new Map()
+    }
+    const groups = new Map()
+    const normalizedApiRoot = path.resolve(apiRoot)
+    for (const shell of this.shells) {
+      if (!shell || shell.done || !shell.ptyProcess || !shell.ptyProcess.pid) {
+        continue
+      }
+      const shellPath = typeof shell.path === "string" && shell.path ? path.resolve(shell.path) : ""
+      if (!shellPath || !this.isPathWithin(normalizedApiRoot, shellPath)) {
+        continue
+      }
+      const relative = path.relative(normalizedApiRoot, shellPath)
+      const workspaceName = relative.split(path.sep).filter(Boolean)[0]
+      if (!workspaceName) {
+        continue
+      }
+      if (!groups.has(workspaceName)) {
+        groups.set(workspaceName, [])
+      }
+      groups.get(workspaceName).push({
+        id: shell.id,
+        group: shell.group,
+        path: shellPath,
+        pid: shell.ptyProcess.pid
+      })
+    }
+    return groups
+  }
   async ensureBracketedPasteSupport(shellName) {
     if (!shellName) {
       return

package/kernel/sysinfo.js

@@ -1,6 +1,10 @@
 const system = require('systeminformation')
 const fs = require('fs')
 const path = require('path')
+const nvidia = require("./gpu/nvidia")
+const amd = require("./gpu/amd")
+const apple = require("./gpu/apple")
+const intel = require("./gpu/intel")
 class Sysinfo {
   async init(kernel) {
     this.kernel = kernel
@@ -52,21 +56,33 @@ class Sysinfo {
       gpus = []
     }
 
-    let is_nvidia = gpus.find(gpu => /nvidia/i.test(gpu.name))
-    let is_amd = gpus.find(gpu => /(amd|advanced micro devices)/i.test(gpu.name))
-    let is_apple = gpus.find(gpu => /apple/i.test(gpu.name))
+    let bestByVram = (items) => {
+      return items.reduce((best, item) => {
+        let bestVram = Number(best && best.vram) || 0
+        let itemVram = Number(item && item.vram) || 0
+        return itemVram > bestVram ? item : best
+      }, items[0])
+    }
+    let model = (controller) => {
+      return (controller && controller.model ? controller.model : "").toLowerCase()
+    }
+
+    let is_nvidia = controllers.find(x => /nvidia/i.test(x.vendor || ""))
+    let is_amd = bestByVram(controllers.filter(x => /(amd|advanced micro devices)/i.test(x.vendor || "")))
+    let is_apple = controllers.find(x => /apple/i.test(x.vendor || ""))
+    let is_intel = controllers.find(x => /intel/i.test(x.vendor || ""))
 
     let gpu
     let gpu_model
     if (is_nvidia) {
       gpu = "nvidia"
-      gpu_model = is_nvidia.model
+      gpu_model = model(is_nvidia)
     } else if (is_amd) {
       gpu = "amd"
-      gpu_model = is_amd.model
+      gpu_model = model(is_amd)
     } else if (is_apple) {
       gpu = "apple"
-      gpu_model = is_apple.model
+      gpu_model = model(is_apple)
     } else if (gpus.length > 0) {
       gpu = gpus[0].name
       gpu_model = gpus[0].model
@@ -76,24 +92,61 @@ class Sysinfo {
 
     let primaryController
     if (is_nvidia) {
-      primaryController = controllers.find(x => /nvidia/i.test(x.vendor || ""))
+      primaryController = is_nvidia
     } else if (is_amd) {
-      primaryController = controllers.find(x => /(amd|advanced micro devices)/i.test(x.vendor || ""))
+      primaryController = is_amd
     } else if (is_apple) {
-      primaryController = controllers.find(x => /apple/i.test(x.vendor || ""))
+      primaryController = is_apple
     } else if (controllers.length > 0) {
       primaryController = controllers[0]
     }
 
     let vramMB = primaryController && primaryController.vram ? primaryController.vram : 0
     let vramGB = vramMB > 0 ? Math.round(vramMB / 1024) : 0
+    let torch_backend = await this.torch_backend({ is_nvidia, is_amd, is_apple, is_intel, gpu_model })
 
     this.info.graphics = g
     this.info.gpus = gpus
     this.info.gpu = gpu
     this.info.gpu_model = gpu_model
+    this.info.torch_backend = torch_backend
     this.info.vram = vramGB
   }
+  // Read CPU brand only when generic iGPU names need CPU fallback matching.
+  async cpu_brand() {
+    let cpu = this.info.cpu
+    if (!cpu) {
+      try {
+        cpu = await system.cpu()
+      } catch (e) {
+        cpu = null
+      }
+    }
+    return cpu && cpu.brand
+  }
+  // Select the PyTorch backend install target from detected hardware identity.
+  async torch_backend(detected) {
+    // Do not require runtime probes such as rocminfo, hipInfo, ze_info, or
+    // an existing torch install here.
+    if (nvidia.supports_torch_backend(detected.is_nvidia, process.platform)) {
+      return "cuda"
+    } else if (apple.supports_torch_backend(detected.is_apple, process.platform)) {
+      return "mps"
+    } else if (
+      detected.is_amd &&
+      process.platform !== "darwin" &&
+      await amd.supports_torch_backend(detected.gpu_model, () => this.cpu_brand())
+    ) {
+      return "rocm"
+    } else if (
+      detected.is_intel &&
+      await intel.supports_torch_backend(detected.is_intel.model, () => this.cpu_brand())
+    ) {
+      return "xpu"
+    } else {
+      return "cpu"
+    }
+  }
 //  async time() {
 //    this.info.time = await system.time()
 //  }

package/kernel/util.js

@@ -434,6 +434,65 @@ const openURL = (url) => {
     console.warn('[Util.openURL] exec failed:', err && err.message ? err.message : err)
   }
 }
+const openURI = async (uri) => {
+  const platform = os.platform()
+  const launch = (command, args) => {
+    return new Promise((resolve, reject) => {
+      let settled = false
+      const settle = (fn, value) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        fn(value)
+      }
+      const timer = setTimeout(() => {
+        settle(resolve, {
+          ok: true,
+          command,
+          status: 'started'
+        })
+      }, 3000)
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore'
+      })
+      child.on('error', (error) => {
+        settle(reject, error)
+      })
+      child.on('close', (code) => {
+        if (code) {
+          settle(reject, new Error(`${command} exited with code ${code}`))
+        } else {
+          settle(resolve, {
+            ok: true,
+            command,
+            status: 'exited'
+          })
+        }
+      })
+      child.unref()
+    })
+  }
+  try {
+    if (platform === 'darwin') {
+      return await launch('open', [uri])
+    } else if (platform === 'win32') {
+      try {
+        return await launch('rundll32.exe', ['url.dll,FileProtocolHandler', uri])
+      } catch (error) {
+        console.warn('[Util.openURI] rundll32 failed, falling back to explorer:', error && error.message ? error.message : error)
+        return await launch('explorer.exe', [uri])
+      }
+    }
+    return await launch('xdg-open', [uri])
+  } catch (err) {
+    console.warn('[Util.openURI] spawn failed:', err && err.message ? err.message : err)
+    return {
+      ok: false,
+      error: err && err.message ? err.message : String(err)
+    }
+  }
+}
 const openfs = (dirPath, options, kernel) => {
   let command = '';
   const platform = os.platform()
@@ -1197,6 +1256,7 @@ module.exports = {
   find_venv,
   fill_object,
   run,
+  openURI,
   openURL,
   u2p,
   p2u,

package/package.json

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