pinokiod 7.3.3 → 7.3.5

package/kernel/git.js

@@ -1169,6 +1169,32 @@ class Git {
         }
       }
     }
+    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
@@ -1196,6 +1222,8 @@ class Git {
       dirty = true
     }
 
+    resetCredentialDefaults()
+
     const githubCredentialSection = config['credential "https://github'] && config['credential "https://github']['com"']
     if (githubCredentialSection && typeof githubCredentialSection === "object") {
       if (!githubCredentialSection.provider) {
@@ -1203,7 +1231,7 @@ class Git {
         dirty = true
       }
       const helper = typeof githubCredentialSection.helper === "string" ? githubCredentialSection.helper : ""
-      if (!helper || /(^|\s|!)gh\s+auth\s+git-credential/i.test(helper)) {
+      if (!helper) {
         githubCredentialSection.helper = "manager"
         dirty = true
       }

package/kernel/resource_usage/gpu.js

@@ -7,6 +7,7 @@ const { execFileText, normalizePid } = require("./process_tree")
 
 const DEFAULT_GPU_TTL_MS = 10000
 const DEFAULT_GPU_TIMEOUT_MS = 2500
+const DEFAULT_WINDOWS_GPU_COUNTER_TTL_MS = 30000
 const MIB = 1024 * 1024
 
 function unique(values) {
@@ -98,6 +99,19 @@ function addGpuProcess(processes, pid, bytes) {
   processes.set(normalizedPid, current)
 }
 
+function mergeGpuProcess(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 = Math.max(current.usedGpuMemoryBytes || 0, bytes)
+  processes.set(normalizedPid, current)
+}
+
 function parseNvidiaCsv(stdout) {
   const processes = new Map()
   for (const line of String(stdout || "").split(/\r?\n/)) {
@@ -111,6 +125,55 @@ function parseNvidiaCsv(stdout) {
   return processes
 }
 
+function parseCsvLine(line) {
+  const values = []
+  let current = ""
+  let inQuotes = false
+  const text = String(line || "")
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i]
+    if (char === "\"") {
+      if (inQuotes && text[i + 1] === "\"") {
+        current += "\""
+        i += 1
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (char === "," && !inQuotes) {
+      values.push(current)
+      current = ""
+    } else {
+      current += char
+    }
+  }
+  values.push(current)
+  return values
+}
+
+function parseWindowsGpuProcessMemoryCsv(stdout) {
+  const rows = []
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed || !trimmed.startsWith("\"")) continue
+    const row = parseCsvLine(trimmed)
+    if (row.length > 1) rows.push(row)
+  }
+  if (rows.length < 2) {
+    return new Map()
+  }
+  const headers = rows[0]
+  const values = rows[rows.length - 1]
+  const processes = new Map()
+  for (let i = 1; i < headers.length && i < values.length; i += 1) {
+    const instanceName = String(headers[i] || "")
+    const match = /pid[_\s-]*(\d+)/i.exec(instanceName)
+    const pid = normalizePid(match && match[1])
+    const bytes = parseMemoryToBytes(values[i])
+    addGpuProcess(processes, pid, bytes)
+  }
+  return processes
+}
+
 function findObjectValue(object, predicate) {
   if (!object || typeof object !== "object" || Array.isArray(object)) {
     return null
@@ -160,26 +223,29 @@ function parseAmdJson(stdout) {
 class GpuSampler {
   constructor(options = {}) {
     this.kernel = options.kernel || null
+    this.platform = options.platform || (this.kernel && this.kernel.platform) || os.platform()
     this.ttlMs = options.ttlMs || DEFAULT_GPU_TTL_MS
     this.timeoutMs = options.timeoutMs || DEFAULT_GPU_TIMEOUT_MS
+    this.windowsCounterTtlMs = options.windowsCounterTtlMs || DEFAULT_WINDOWS_GPU_COUNTER_TTL_MS
     this.current = null
     this.inFlight = null
+    this.windowsCounterCurrent = null
+    this.windowsCounterInFlight = 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") {
+    if (this.platform === "win32") {
       candidates.push(
         "C:\\Program Files\\NVIDIA Corporation\\NVSMI\\nvidia-smi.exe",
         "C:\\Windows\\System32\\nvidia-smi.exe"
       )
-    } else if (platform === "linux") {
+    } else if (this.platform === "linux") {
       candidates.push(
         "/usr/bin/nvidia-smi",
         "/usr/local/bin/nvidia-smi",
@@ -190,13 +256,22 @@ class GpuSampler {
     return executableCandidates(candidates)
   }
 
+  windowsGpuCounterCandidates() {
+    return executableCandidates([
+      process.env.TYPEPERF,
+      "typeperf",
+      "C:\\Windows\\System32\\typeperf.exe",
+      "C:\\Windows\\Sysnative\\typeperf.exe"
+    ])
+  }
+
   amdCandidates() {
     const candidates = [
       process.env.AMD_SMI,
       "amd-smi",
       ...getPinokioCondaCandidates(this.kernel, ["amd-smi"])
     ]
-    if (os.platform() === "linux") {
+    if (this.platform === "linux") {
       candidates.push("/opt/rocm/bin/amd-smi", "/usr/bin/amd-smi", "/usr/local/bin/amd-smi")
     }
     return executableCandidates(candidates)
@@ -211,6 +286,63 @@ class GpuSampler {
     this.providerBackoff.set(provider, Date.now() + ms)
   }
 
+  async collectWindowsGpuProcessMemoryOnce() {
+    if (this.platform !== "win32" || this.isBackedOff("windows-gpu-process-memory")) {
+      return null
+    }
+    let lastError = null
+    for (const command of this.windowsGpuCounterCandidates()) {
+      try {
+        const { stdout } = await execFileText(command, [
+          "\\GPU Process Memory(*)\\Dedicated Usage",
+          "-sc",
+          "1"
+        ], { timeoutMs: Math.max(this.timeoutMs, 3000) })
+        return {
+          provider: "windows-gpu-process-memory",
+          processes: parseWindowsGpuProcessMemoryCsv(stdout),
+          error: null,
+          collectedAt: Date.now()
+        }
+      } catch (error) {
+        lastError = error
+        if (error && error.code === "ENOENT") {
+          continue
+        }
+        break
+      }
+    }
+    this.backoff("windows-gpu-process-memory", 60000)
+    return {
+      provider: "windows-gpu-process-memory",
+      processes: new Map(),
+      error: lastError && lastError.message ? lastError.message : "Windows GPU process memory counters unavailable",
+      collectedAt: Date.now()
+    }
+  }
+
+  async collectWindowsGpuProcessMemory() {
+    if (this.platform !== "win32" || this.isBackedOff("windows-gpu-process-memory")) {
+      return null
+    }
+    const now = Date.now()
+    if (this.windowsCounterCurrent && now - this.windowsCounterCurrent.collectedAt < this.windowsCounterTtlMs) {
+      return this.windowsCounterCurrent
+    }
+    if (this.windowsCounterInFlight) {
+      return this.windowsCounterInFlight
+    }
+    this.windowsCounterInFlight = this.collectWindowsGpuProcessMemoryOnce().then((result) => {
+      if (result && !result.error) {
+        this.windowsCounterCurrent = result
+      }
+      return result
+    }).finally(() => {
+      this.windowsCounterInFlight = null
+    })
+    return this.windowsCounterInFlight
+  }
+
   async collectNvidia() {
     if (this.isBackedOff("nvidia")) {
       return null
@@ -245,7 +377,7 @@ class GpuSampler {
   }
 
   async collectAmd() {
-    if (os.platform() !== "linux" || this.isBackedOff("amd")) {
+    if (this.platform !== "linux" || this.isBackedOff("amd")) {
       return null
     }
     let lastError = null
@@ -275,8 +407,15 @@ class GpuSampler {
 
   async collect() {
     const results = []
-    const nvidia = await this.collectNvidia()
-    if (nvidia) results.push(nvidia)
+
+    if (this.platform === "win32") {
+      const windowsGpuProcessMemory = await this.collectWindowsGpuProcessMemory()
+      if (windowsGpuProcessMemory) results.push(windowsGpuProcessMemory)
+    } else {
+      const nvidia = await this.collectNvidia()
+      if (nvidia) results.push(nvidia)
+    }
+
     const amd = await this.collectAmd()
     if (amd) results.push(amd)
 
@@ -288,7 +427,7 @@ class GpuSampler {
       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)
+        mergeGpuProcess(processes, entry.pid, entry.usedGpuMemoryBytes)
       }
     }
     return {
@@ -344,6 +483,8 @@ function sumGpuMemory(snapshot, pids) {
 
 module.exports = {
   GpuSampler,
+  parseNvidiaCsv,
   parseMemoryToBytes,
+  parseWindowsGpuProcessMemoryCsv,
   sumGpuMemory
 }

package/package.json

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

package/test/git-defaults.test.js

@@ -1,11 +1,14 @@
 const assert = require('node:assert/strict')
+const { execFile } = require('node:child_process')
 const fs = require('node:fs/promises')
 const os = require('node:os')
 const path = require('node:path')
 const test = require('node:test')
+const { promisify } = require('node:util')
 const ini = require('ini')
 
 const KernelGit = require('../kernel/git')
+const execFileAsync = promisify(execFile)
 
 async function withTempHome(fn) {
   const homedir = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-git-defaults-'))
@@ -67,6 +70,56 @@ test('Git defaults migrate the legacy gh GitHub helper to Git Credential Manager
   })
 })
 
+test('Git defaults reset credential sections to built-in defaults before Git reads config', async () => {
+  await withTempHome(async (homedir) => {
+    const staleHelpers = [
+      '!custom-helper auth git-credential',
+      '!gh auth git-credential',
+      '!gh.exe auth git-credential',
+      `!'${path.win32.join('Z:\\', 'Any Folder', 'bin', 'gh.exe')}' auth git-credential`,
+    ]
+
+    for (const [index, helper] of staleHelpers.entries()) {
+      const caseHome = path.join(homedir, `case-${index}`)
+      await fs.mkdir(caseHome)
+      const gitconfigPath = path.join(caseHome, 'gitconfig')
+      await fs.writeFile(gitconfigPath, [
+        '[credential "https://github.com"]',
+        `  helper = ${helper}`,
+        '  provider = github',
+        '[credential "https://gist.github.com"]',
+        `  helper = ${helper}`,
+        '[credential "https://enterprise.example"]',
+        `  helper = ${helper}`,
+        '[credential]',
+        `  helper = ${helper}`,
+        '  gitHubAuthModes = device',
+        '  namespace = stale',
+        '[user]',
+        '  name = custom',
+        '  email = custom@example.test',
+        '',
+      ].join('\n'))
+      const git = new KernelGit(createKernel(caseHome))
+
+      await git.ensureDefaults()
+
+      const content = await fs.readFile(gitconfigPath, 'utf8')
+      assert.doesNotMatch(content, /git-credential/i)
+      const { stdout } = await execFileAsync('git', ['config', '--file', gitconfigPath, '--list'])
+      assert.match(stdout, /credential\.helper=manager/)
+      assert.match(stdout, /credential\.githubauthmodes=oauth/)
+      assert.match(stdout, /credential\.namespace=pinokio/)
+      assert.match(stdout, /credential\.https:\/\/github\.com\.helper=manager/)
+      assert.doesNotMatch(stdout, /credential\.https:\/\/gist\.github\.com/)
+      assert.doesNotMatch(stdout, /credential\.https:\/\/enterprise\.example/)
+      const config = ini.parse(content)
+      assert.equal(config.user.name, 'custom')
+      assert.equal(config.user.email, 'custom@example.test')
+    }
+  })
+})
+
 test('Git isomorphic auth callback returns GCM credentials for GitHub URLs', async () => {
   const git = new KernelGit(createKernel('/tmp/pinokio'))
   let requestedUrl = ''

package/test/resource-usage-gpu.test.js

@@ -0,0 +1,126 @@
+const assert = require("node:assert/strict")
+const test = require("node:test")
+
+const {
+  GpuSampler,
+  parseNvidiaCsv,
+  parseWindowsGpuProcessMemoryCsv
+} = require("../kernel/resource_usage/gpu")
+
+const MIB = 1024 * 1024
+
+function gpuProcess(pid, bytes) {
+  return {
+    pid,
+    usedGpuMemoryBytes: bytes
+  }
+}
+
+test("parseNvidiaCsv treats nounits memory as MiB and sums duplicate PIDs", () => {
+  const processes = parseNvidiaCsv([
+    "1234, 256",
+    "1234, 128",
+    "5678, N/A"
+  ].join("\n"))
+
+  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
+  assert.equal(processes.has(5678), false)
+})
+
+test("parseWindowsGpuProcessMemoryCsv extracts dedicated GPU bytes from process counter instances", () => {
+  const processes = parseWindowsGpuProcessMemoryCsv([
+    "\"(PDH-CSV 4.0)\",\"\\\\HOST\\GPU Process Memory(pid_1234_luid_0x00000000_0x00011111_phys_0)\\Dedicated Usage\",\"\\\\HOST\\GPU Process Memory(pid_1234_luid_0x00000000_0x00011111_phys_1)\\Dedicated Usage\",\"\\\\HOST\\GPU Process Memory(_total)\\Dedicated Usage\"",
+    "\"06/18/2026 12:00:00.000\",\"268435456.000000\",\"134217728.000000\",\"1047527424.000000\"",
+    "The command completed successfully."
+  ].join("\r\n"))
+
+  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
+  assert.equal(processes.has(999), false)
+})
+
+test("GpuSampler uses Windows GPU counters before nvidia-smi on Windows", async () => {
+  const sampler = new GpuSampler({ platform: "win32" })
+  let nvidiaCalls = 0
+  sampler.collectWindowsGpuProcessMemory = async () => {
+    return {
+      provider: "windows-gpu-process-memory",
+      processes: new Map([
+        [1234, gpuProcess(1234, 500 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectNvidia = async () => {
+    nvidiaCalls += 1
+    return {
+      provider: "nvidia-smi",
+      processes: new Map([
+        [1234, gpuProcess(1234, 500 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectAmd = async () => null
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(nvidiaCalls, 0)
+  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
+  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
+})
+
+test("GpuSampler does not query nvidia-smi on Windows when OS counters fail", async () => {
+  const sampler = new GpuSampler({ platform: "win32" })
+  let nvidiaCalls = 0
+  sampler.collectWindowsGpuProcessMemory = async () => ({
+    provider: "windows-gpu-process-memory",
+    processes: new Map(),
+    error: "counter unavailable"
+  })
+  sampler.collectNvidia = async () => {
+    nvidiaCalls += 1
+    return {
+      provider: "nvidia-smi",
+      processes: new Map([
+        [1234, gpuProcess(1234, 300 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectAmd = async () => null
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(nvidiaCalls, 0)
+  assert.equal(snapshot.available, false)
+  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
+  assert.equal(snapshot.processes.has(1234), false)
+})
+
+test("GpuSampler merges overlapping provider samples by PID without double-counting", async () => {
+  const sampler = new GpuSampler({ platform: "linux" })
+  sampler.collectNvidia = async () => ({
+    provider: "nvidia-smi",
+    processes: new Map([
+      [1234, gpuProcess(1234, 300 * MIB)],
+      [3333, gpuProcess(3333, 200 * MIB)]
+    ]),
+    error: null
+  })
+  sampler.collectAmd = async () => ({
+    provider: "amd-smi",
+    processes: new Map([
+      [1234, gpuProcess(1234, 500 * MIB)],
+      [2222, gpuProcess(2222, 100 * MIB)]
+    ]),
+    error: null
+  })
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(snapshot.available, true)
+  assert.deepEqual(snapshot.providers, ["nvidia-smi", "amd-smi"])
+  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
+  assert.equal(snapshot.processes.get(2222).usedGpuMemoryBytes, 100 * MIB)
+  assert.equal(snapshot.processes.get(3333).usedGpuMemoryBytes, 200 * MIB)
+})