pinokiod 7.3.1 → 7.3.4

package/kernel/resource_usage/gpu.js

@@ -0,0 +1,349 @@
+"use strict"
+
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execFileText, normalizePid } = require("./process_tree")
+
+const DEFAULT_GPU_TTL_MS = 10000
+const DEFAULT_GPU_TIMEOUT_MS = 2500
+const MIB = 1024 * 1024
+
+function unique(values) {
+  const seen = new Set()
+  const next = []
+  for (const value of values) {
+    if (!value || seen.has(value)) continue
+    seen.add(value)
+    next.push(value)
+  }
+  return next
+}
+
+function pathExists(filepath) {
+  try {
+    fs.accessSync(filepath, fs.constants.X_OK)
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+function executableCandidates(candidates) {
+  return unique(candidates).filter((candidate) => {
+    if (!candidate) return false
+    if (path.isAbsolute(candidate)) {
+      return pathExists(candidate)
+    }
+    return true
+  })
+}
+
+function getPinokioCondaCandidates(kernel, names) {
+  if (!kernel || !kernel.homedir) {
+    return []
+  }
+  const prefix = path.resolve(kernel.homedir, "bin", "miniconda")
+  const suffixes = os.platform() === "win32"
+    ? ["", ".exe"]
+    : [""]
+  const folders = os.platform() === "win32"
+    ? ["Library/bin", "Scripts", ""]
+    : ["bin", "Library/bin", ""]
+  const candidates = []
+  for (const name of names) {
+    for (const folder of folders) {
+      for (const suffix of suffixes) {
+        candidates.push(path.resolve(prefix, folder, `${name}${suffix}`))
+      }
+    }
+  }
+  return candidates
+}
+
+function parseMemoryToBytes(value, defaultUnit = "") {
+  if (value == null) return null
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) return null
+    if (defaultUnit === "mib") return Math.round(value * MIB)
+    if (defaultUnit === "kb") return Math.round(value * 1024)
+    return Math.round(value)
+  }
+  const raw = String(value).trim()
+  if (!raw || /N\/A|not supported|none/i.test(raw)) {
+    return null
+  }
+  const match = /(-?\d+(?:\.\d+)?)\s*([KMGT]?i?B|[KMGT]B|bytes?)?/i.exec(raw)
+  if (!match) return null
+  const amount = Number.parseFloat(match[1])
+  if (!Number.isFinite(amount) || amount < 0) return null
+  const unit = (match[2] || defaultUnit || "bytes").toLowerCase()
+  if (unit === "mib" || unit === "mb") return Math.round(amount * MIB)
+  if (unit === "gib" || unit === "gb") return Math.round(amount * 1024 * MIB)
+  if (unit === "kib" || unit === "kb") return Math.round(amount * 1024)
+  if (unit === "tib" || unit === "tb") return Math.round(amount * 1024 * 1024 * MIB)
+  return Math.round(amount)
+}
+
+function addGpuProcess(processes, pid, bytes) {
+  const normalizedPid = normalizePid(pid)
+  if (!normalizedPid || !Number.isFinite(bytes) || bytes < 0) {
+    return
+  }
+  const current = processes.get(normalizedPid) || {
+    pid: normalizedPid,
+    usedGpuMemoryBytes: 0
+  }
+  current.usedGpuMemoryBytes += bytes
+  processes.set(normalizedPid, current)
+}
+
+function parseNvidiaCsv(stdout) {
+  const processes = new Map()
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    const parts = trimmed.split(",").map((part) => part.trim())
+    const pid = normalizePid(parts[0])
+    const bytes = parseMemoryToBytes(parts[1], "mib")
+    addGpuProcess(processes, pid, bytes)
+  }
+  return processes
+}
+
+function findObjectValue(object, predicate) {
+  if (!object || typeof object !== "object" || Array.isArray(object)) {
+    return null
+  }
+  for (const [key, value] of Object.entries(object)) {
+    if (predicate(key, value)) {
+      return value
+    }
+  }
+  return null
+}
+
+function extractAmdProcessesFromJson(value, processes = new Map()) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      extractAmdProcessesFromJson(item, processes)
+    }
+    return processes
+  }
+  if (!value || typeof value !== "object") {
+    return processes
+  }
+
+  const pidValue = findObjectValue(value, (key) => /(^|[_\s-])pid$|process[_\s-]*id/i.test(key))
+  const memoryValue = findObjectValue(value, (key) => {
+    const normalized = key.toLowerCase()
+    if (/total|free|available|limit/.test(normalized)) return false
+    return /vram|memory/.test(normalized) && /usage|used|mem|size/.test(normalized)
+  })
+  const pid = normalizePid(pidValue)
+  const bytes = parseMemoryToBytes(memoryValue)
+  addGpuProcess(processes, pid, bytes)
+
+  for (const child of Object.values(value)) {
+    if (child && typeof child === "object") {
+      extractAmdProcessesFromJson(child, processes)
+    }
+  }
+  return processes
+}
+
+function parseAmdJson(stdout) {
+  const parsed = JSON.parse(stdout || "[]")
+  return extractAmdProcessesFromJson(parsed)
+}
+
+class GpuSampler {
+  constructor(options = {}) {
+    this.kernel = options.kernel || null
+    this.ttlMs = options.ttlMs || DEFAULT_GPU_TTL_MS
+    this.timeoutMs = options.timeoutMs || DEFAULT_GPU_TIMEOUT_MS
+    this.current = null
+    this.inFlight = null
+    this.providerBackoff = new Map()
+  }
+
+  nvidiaCandidates() {
+    const platform = os.platform()
+    const candidates = [
+      process.env.NVIDIA_SMI,
+      "nvidia-smi",
+      ...getPinokioCondaCandidates(this.kernel, ["nvidia-smi"])
+    ]
+    if (platform === "win32") {
+      candidates.push(
+        "C:\\Program Files\\NVIDIA Corporation\\NVSMI\\nvidia-smi.exe",
+        "C:\\Windows\\System32\\nvidia-smi.exe"
+      )
+    } else if (platform === "linux") {
+      candidates.push(
+        "/usr/bin/nvidia-smi",
+        "/usr/local/bin/nvidia-smi",
+        "/usr/local/nvidia/bin/nvidia-smi",
+        "/usr/local/cuda/bin/nvidia-smi"
+      )
+    }
+    return executableCandidates(candidates)
+  }
+
+  amdCandidates() {
+    const candidates = [
+      process.env.AMD_SMI,
+      "amd-smi",
+      ...getPinokioCondaCandidates(this.kernel, ["amd-smi"])
+    ]
+    if (os.platform() === "linux") {
+      candidates.push("/opt/rocm/bin/amd-smi", "/usr/bin/amd-smi", "/usr/local/bin/amd-smi")
+    }
+    return executableCandidates(candidates)
+  }
+
+  isBackedOff(provider) {
+    const until = this.providerBackoff.get(provider) || 0
+    return Date.now() < until
+  }
+
+  backoff(provider, ms = 60000) {
+    this.providerBackoff.set(provider, Date.now() + ms)
+  }
+
+  async collectNvidia() {
+    if (this.isBackedOff("nvidia")) {
+      return null
+    }
+    const args = [
+      "--query-compute-apps=pid,used_gpu_memory",
+      "--format=csv,noheader,nounits"
+    ]
+    let lastError = null
+    for (const command of this.nvidiaCandidates()) {
+      try {
+        const { stdout } = await execFileText(command, args, { timeoutMs: this.timeoutMs })
+        return {
+          provider: "nvidia-smi",
+          processes: parseNvidiaCsv(stdout),
+          error: null
+        }
+      } catch (error) {
+        lastError = error
+        if (error && error.code === "ENOENT") {
+          continue
+        }
+        break
+      }
+    }
+    this.backoff("nvidia", 60000)
+    return {
+      provider: "nvidia-smi",
+      processes: new Map(),
+      error: lastError && lastError.message ? lastError.message : "nvidia-smi unavailable"
+    }
+  }
+
+  async collectAmd() {
+    if (os.platform() !== "linux" || this.isBackedOff("amd")) {
+      return null
+    }
+    let lastError = null
+    for (const command of this.amdCandidates()) {
+      try {
+        const { stdout } = await execFileText(command, ["process", "--json", "-G"], { timeoutMs: this.timeoutMs })
+        return {
+          provider: "amd-smi",
+          processes: parseAmdJson(stdout),
+          error: null
+        }
+      } catch (error) {
+        lastError = error
+        if (error && error.code === "ENOENT") {
+          continue
+        }
+        break
+      }
+    }
+    this.backoff("amd", 90000)
+    return {
+      provider: "amd-smi",
+      processes: new Map(),
+      error: lastError && lastError.message ? lastError.message : "amd-smi unavailable"
+    }
+  }
+
+  async collect() {
+    const results = []
+    const nvidia = await this.collectNvidia()
+    if (nvidia) results.push(nvidia)
+    const amd = await this.collectAmd()
+    if (amd) results.push(amd)
+
+    const processes = new Map()
+    const providers = []
+    const errors = []
+    for (const result of results) {
+      if (!result) continue
+      if (result.provider) providers.push(result.provider)
+      if (result.error) errors.push({ provider: result.provider, error: result.error })
+      for (const entry of result.processes.values()) {
+        addGpuProcess(processes, entry.pid, entry.usedGpuMemoryBytes)
+      }
+    }
+    return {
+      available: providers.length > 0 && errors.length < providers.length,
+      stale: false,
+      collectedAt: Date.now(),
+      providers,
+      processes,
+      errors
+    }
+  }
+
+  async getSnapshot() {
+    const now = Date.now()
+    if (this.current && now - this.current.collectedAt < this.ttlMs) {
+      return this.current
+    }
+    if (this.inFlight) {
+      return this.inFlight
+    }
+    this.inFlight = this.collect().then((snapshot) => {
+      this.current = snapshot
+      return snapshot
+    }).catch((error) => {
+      if (this.current) {
+        return { ...this.current, stale: true }
+      }
+      return {
+        available: false,
+        stale: false,
+        collectedAt: Date.now(),
+        providers: [],
+        processes: new Map(),
+        errors: [{ provider: "gpu", error: error && error.message ? error.message : String(error) }]
+      }
+    }).finally(() => {
+      this.inFlight = null
+    })
+    return this.inFlight
+  }
+}
+
+function sumGpuMemory(snapshot, pids) {
+  const processes = snapshot && snapshot.processes instanceof Map ? snapshot.processes : new Map()
+  let bytes = 0
+  for (const pid of pids || []) {
+    const entry = processes.get(pid)
+    if (!entry) continue
+    bytes += entry.usedGpuMemoryBytes || 0
+  }
+  return { bytes }
+}
+
+module.exports = {
+  GpuSampler,
+  parseMemoryToBytes,
+  sumGpuMemory
+}

package/kernel/resource_usage/index.js

@@ -0,0 +1,322 @@
+"use strict"
+
+const os = require("os")
+const { GpuSampler, sumGpuMemory } = require("./gpu")
+const { MacFootprintSampler } = require("./macos_footprint")
+const { ProcessSampler, getDescendantPids, sumProcessMetrics } = require("./process_tree")
+const { ResourceUsagePreferences } = require("./preferences")
+
+function formatBytes(bytes) {
+  const value = Number(bytes)
+  if (!Number.isFinite(value) || value < 0) {
+    return "--"
+  }
+  const k = 1024
+  if (value >= k * k * k) {
+    return `${Math.floor((value / k / k / k) * 100) / 100} GB`
+  }
+  if (value >= k * k) {
+    return `${Math.floor((value / k / k) * 100) / 100} MB`
+  }
+  if (value >= k) {
+    return `${Math.floor((value / k) * 100) / 100} KB`
+  }
+  return `${Math.floor(value)} B`
+}
+
+function normalizeWorkspaceName(value) {
+  if (typeof value !== "string") {
+    return ""
+  }
+  const trimmed = value.trim()
+  if (!trimmed || trimmed.includes("/") || trimmed.includes("\\") || trimmed === "." || trimmed === "..") {
+    return ""
+  }
+  return trimmed
+}
+
+class ResourceUsageService {
+  constructor(options = {}) {
+    if (!options.kernel) {
+      throw new Error("ResourceUsageService requires kernel")
+    }
+    this.kernel = options.kernel
+    this.platform = this.kernel.platform || os.platform()
+    this.preferences = new ResourceUsagePreferences({ kernel: this.kernel })
+    this.processSampler = new ProcessSampler({
+      platform: this.platform,
+      ttlMs: 4000,
+      timeoutMs: 2500
+    })
+    this.macFootprintSampler = new MacFootprintSampler({
+      platform: this.platform,
+      ttlMs: 15000,
+      timeoutMs: 2000
+    })
+    this.gpuSampler = new GpuSampler({
+      kernel: this.kernel,
+      ttlMs: 10000,
+      timeoutMs: 2500
+    })
+    this.cpuAverages = new Map()
+    this.workspaceCache = new Map()
+    this.collectInFlight = null
+    this.lastGlobalCollectAt = 0
+    this.globalTtlMs = options.globalTtlMs || 5000
+  }
+
+  async getPreferences() {
+    return this.preferences.read()
+  }
+
+  async updatePreferences(updates = {}) {
+    const preferences = await this.preferences.update(updates)
+    this.workspaceCache.clear()
+    this.lastGlobalCollectAt = 0
+    return preferences
+  }
+
+  getShellRootGroups() {
+    if (!this.kernel || !this.kernel.shell || typeof this.kernel.path !== "function") {
+      return new Map()
+    }
+    const apiRoot = this.kernel.path("api")
+    if (typeof this.kernel.shell.resourceRootsByWorkspace === "function") {
+      return this.kernel.shell.resourceRootsByWorkspace(apiRoot)
+    }
+    return new Map()
+  }
+
+  smoothCpu(workspaceName, value) {
+    if (!Number.isFinite(value)) {
+      this.cpuAverages.delete(workspaceName)
+      return null
+    }
+    const now = Date.now()
+    const previous = this.cpuAverages.get(workspaceName)
+    let smoothed = value
+    if (previous && Number.isFinite(previous.value) && now - previous.updatedAt < 30000) {
+      smoothed = (previous.value * 0.55) + (value * 0.45)
+    }
+    this.cpuAverages.set(workspaceName, { value: smoothed, updatedAt: now })
+    return smoothed
+  }
+
+  metric(enabled, available, value = {}) {
+    return {
+      enabled: !!enabled,
+      available: !!available,
+      ...value
+    }
+  }
+
+  selectFootprintPids(pids) {
+    return Array.from(pids || []).sort((a, b) => a - b)
+  }
+
+  emptyWorkspaceUsage(name, preferences, options = {}) {
+    const updatedAt = options.updatedAt || Date.now()
+    return {
+      ok: true,
+      workspace: name,
+      running: false,
+      updated_at: new Date(updatedAt).toISOString(),
+      stale: !!options.stale,
+      preferences,
+      metrics: {
+        ram: this.metric(preferences.show_ram, false, {
+          bytes: 0,
+          formatted: "0 B"
+        }),
+        cpu: this.metric(preferences.show_cpu, false, {
+          percent: null
+        }),
+        vram: this.metric(preferences.show_vram, false, {
+          bytes: 0,
+          formatted: "0 MB"
+        })
+      }
+    }
+  }
+
+  sumFootprintBytes(footprintSnapshot, pids) {
+    const perPid = footprintSnapshot && footprintSnapshot.perPid instanceof Map ? footprintSnapshot.perPid : new Map()
+    let bytes = 0
+    for (const pid of pids || []) {
+      bytes += perPid.get(pid) || 0
+    }
+    return bytes
+  }
+
+  buildWorkspaceUsage(name, preferences, roots, processSnapshot, processData, gpuSnapshot, footprintSnapshot) {
+    const pids = processData && processData.pids instanceof Set ? processData.pids : new Set()
+    const processSummary = processData && processData.summary ? processData.summary : {
+      processCount: 0,
+      rssBytes: 0,
+      cpuPercent: null,
+      cpuPercentCores: null
+    }
+
+    let ramBytes = processSummary.rssBytes
+    const footprintBytes = preferences.show_ram && this.platform === "darwin"
+      ? this.sumFootprintBytes(footprintSnapshot, pids)
+      : 0
+    if (footprintBytes > 0) {
+      ramBytes = footprintBytes
+    }
+
+    const smoothedCpu = preferences.show_cpu
+      ? this.smoothCpu(name, processSummary.cpuPercent)
+      : null
+
+    const gpuSummary = preferences.show_vram && pids.size > 0
+      ? sumGpuMemory(gpuSnapshot, pids)
+      : {
+        bytes: 0
+      }
+
+    const rootPids = roots.map((root) => root.pid).filter((pid) => Number.isFinite(pid))
+    const running = rootPids.length > 0 && (processSummary.processCount > 0 || pids.size > 0)
+    const processAvailable = !!(processSnapshot && processSnapshot.available)
+    const ramAvailable = running && !!(processAvailable || footprintBytes > 0)
+    const gpuAvailable = !!(gpuSnapshot && gpuSnapshot.available)
+    const updatedAt = Math.max(
+      processSnapshot && processSnapshot.collectedAt ? processSnapshot.collectedAt : 0,
+      footprintSnapshot && footprintSnapshot.collectedAt ? footprintSnapshot.collectedAt : 0,
+      gpuSnapshot && gpuSnapshot.collectedAt ? gpuSnapshot.collectedAt : 0,
+      Date.now()
+    )
+
+    return {
+      ok: true,
+      workspace: name,
+      running,
+      updated_at: new Date(updatedAt).toISOString(),
+      stale: !!((processSnapshot && processSnapshot.stale) || (footprintSnapshot && footprintSnapshot.stale) || (gpuSnapshot && gpuSnapshot.stale)),
+      preferences,
+      metrics: {
+        ram: this.metric(preferences.show_ram, ramAvailable, {
+          bytes: ramBytes,
+          formatted: formatBytes(ramBytes)
+        }),
+        cpu: this.metric(preferences.show_cpu, Number.isFinite(smoothedCpu), {
+          percent: Number.isFinite(smoothedCpu) ? Math.max(0, Math.round(smoothedCpu * 10) / 10) : null
+        }),
+        vram: this.metric(preferences.show_vram, gpuAvailable && running, {
+          bytes: gpuSummary.bytes,
+          formatted: gpuSummary.bytes > 0 ? formatBytes(gpuSummary.bytes) : "0 MB"
+        })
+      }
+    }
+  }
+
+  async collectGlobalUsage(preferencesOverride = null) {
+    const preferences = preferencesOverride || await this.getPreferences()
+    const rootGroups = this.getShellRootGroups()
+    const hasRoots = rootGroups.size > 0
+    const shouldCollectProcesses = hasRoots && (
+      preferences.show_ram ||
+      preferences.show_cpu ||
+      preferences.show_vram
+    )
+
+    const processSnapshot = shouldCollectProcesses ? await this.processSampler.getSnapshot() : null
+    const workspaceProcesses = new Map()
+    const allPids = new Set()
+
+    for (const [name, roots] of rootGroups.entries()) {
+      const rootPids = roots.map((root) => root.pid).filter((pid) => Number.isFinite(pid))
+      const pids = processSnapshot ? getDescendantPids(processSnapshot, rootPids) : new Set()
+      const summary = processSnapshot ? sumProcessMetrics(processSnapshot, pids) : {
+        processCount: 0,
+        rssBytes: 0,
+        cpuPercent: null,
+        cpuPercentCores: null
+      }
+      workspaceProcesses.set(name, { pids, summary })
+      for (const pid of pids) {
+        allPids.add(pid)
+      }
+    }
+
+    const footprintSnapshot = preferences.show_ram && this.platform === "darwin" && allPids.size > 0
+      ? await this.macFootprintSampler.getFootprintByPid(this.selectFootprintPids(allPids))
+      : null
+
+    const gpuSnapshot = preferences.show_vram && allPids.size > 0
+      ? await this.gpuSampler.getSnapshot()
+      : null
+
+    const nextCache = new Map()
+    for (const [name, roots] of rootGroups.entries()) {
+      const usage = this.buildWorkspaceUsage(
+        name,
+        preferences,
+        roots,
+        processSnapshot,
+        workspaceProcesses.get(name),
+        gpuSnapshot,
+        footprintSnapshot
+      )
+      nextCache.set(name, usage)
+    }
+    for (const name of this.cpuAverages.keys()) {
+      if (!rootGroups.has(name)) {
+        this.cpuAverages.delete(name)
+      }
+    }
+
+    this.workspaceCache = nextCache
+    this.lastGlobalCollectAt = Date.now()
+    return nextCache
+  }
+
+  async ensureGlobalRefresh(options = {}) {
+    const force = !!options.force
+    const wait = !!options.wait
+    const now = Date.now()
+    if (!force && this.lastGlobalCollectAt && now - this.lastGlobalCollectAt < this.globalTtlMs) {
+      return this.workspaceCache
+    }
+    if (!this.collectInFlight) {
+      this.collectInFlight = this.collectGlobalUsage().catch(() => {
+        this.lastGlobalCollectAt = Date.now()
+        return this.workspaceCache
+      }).finally(() => {
+        this.collectInFlight = null
+      })
+    }
+    if (wait) {
+      return this.collectInFlight
+    }
+    return this.workspaceCache
+  }
+
+  markCachedUsage(usage) {
+    if (!usage) return usage
+    const stale = !!(this.lastGlobalCollectAt && Date.now() - this.lastGlobalCollectAt >= this.globalTtlMs)
+    return stale ? { ...usage, stale: true } : usage
+  }
+
+  async getWorkspaceUsage(workspaceName) {
+    const name = normalizeWorkspaceName(workspaceName)
+    if (!name) {
+      return {
+        ok: false,
+        error: "Invalid workspace",
+        preferences: await this.getPreferences()
+      }
+    }
+
+    const cached = this.workspaceCache.get(name)
+    await this.ensureGlobalRefresh({ wait: !cached })
+    const updated = this.workspaceCache.get(name)
+    if (updated) {
+      return this.markCachedUsage(updated)
+    }
+    const preferences = await this.getPreferences()
+    return this.emptyWorkspaceUsage(name, preferences, { updatedAt: this.lastGlobalCollectAt || Date.now() })
+  }
+}
+
+module.exports = ResourceUsageService