idlewatch 0.1.0

package/src/gpu.js

@@ -0,0 +1,115 @@
+import { execSync } from 'child_process'
+
+function clampPct(value) {
+  if (!Number.isFinite(value)) return null
+  return Math.max(0, Math.min(100, Number(value.toFixed(2))))
+}
+
+function parseFirstPercent(text) {
+  if (!text) return null
+  const m = text.match(/(\d+\.?\d*)\s*%/)
+  return m ? clampPct(Number(m[1])) : null
+}
+
+function parseIoregGpuUtilization(text) {
+  if (!text) return null
+
+  const preferredKeys = [
+    'Device Utilization %',
+    'Renderer Utilization %',
+    'Tiler Utilization %'
+  ]
+
+  for (const key of preferredKeys) {
+    const re = new RegExp(`"${key.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}"\\s*=\\s*(\\d+\\.?\\d*)`, 'i')
+    const m = text.match(re)
+    if (m) return clampPct(Number(m[1]))
+  }
+
+  return null
+}
+
+function parseGpuPercent(text, source) {
+  if (source.startsWith('ioreg')) return parseIoregGpuUtilization(text)
+
+  if (source === 'top-grep') {
+    const gpuLines = text
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => /gpu/i.test(line) && /%/.test(line))
+      .join('\n')
+
+    return parseFirstPercent(gpuLines)
+  }
+
+  return parseFirstPercent(text)
+}
+
+export function gpuSampleDarwin(exec = execSync) {
+  const probes = [
+    {
+      cmd: '/usr/sbin/ioreg -r -d 1 -w0 -c AGXAccelerator',
+      source: 'ioreg-agx',
+      confidence: 'high',
+      sampleWindowMs: null,
+      timeoutMs: 1500
+    },
+    {
+      cmd: '/usr/sbin/ioreg -r -d 1 -w0 -c IOGPU',
+      source: 'ioreg-iogpu',
+      confidence: 'medium',
+      sampleWindowMs: null,
+      timeoutMs: 1500
+    },
+    {
+      cmd: 'powermetrics --samplers gpu_power -n 1 -i 1000',
+      source: 'powermetrics',
+      confidence: 'high',
+      sampleWindowMs: 1000,
+      timeoutMs: 1800
+    },
+    {
+      cmd: "top -l 1 | grep -i 'GPU'",
+      source: 'top-grep',
+      confidence: 'low',
+      sampleWindowMs: null,
+      timeoutMs: 1200
+    }
+  ]
+
+  for (const probe of probes) {
+    try {
+      const out = exec(probe.cmd, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: probe.timeoutMs
+      })
+
+      const pct = parseGpuPercent(out, probe.source)
+      if (pct !== null) {
+        return {
+          pct,
+          source: probe.source,
+          confidence: probe.confidence,
+          sampleWindowMs: probe.sampleWindowMs
+        }
+      }
+    } catch {
+      // ignore and continue
+    }
+  }
+
+  return {
+    pct: null,
+    source: 'unavailable',
+    confidence: 'none',
+    sampleWindowMs: null
+  }
+}
+
+export const __gpuTestUtils = {
+  parseFirstPercent,
+  parseIoregGpuUtilization,
+  parseGpuPercent,
+  clampPct
+}

package/src/memory.js

@@ -0,0 +1,67 @@
+import os from 'os'
+import { execSync } from 'child_process'
+
+function clampPct(value) {
+  if (!Number.isFinite(value)) return null
+  return Math.max(0, Math.min(100, Number(value.toFixed(2))))
+}
+
+function classifyPressure(pct) {
+  if (!Number.isFinite(pct)) return 'unavailable'
+  if (pct >= 90) return 'critical'
+  if (pct >= 75) return 'warning'
+  return 'normal'
+}
+
+export function parseMemoryPressurePct(raw) {
+  if (!raw) return null
+  const freeMatch = raw.match(/System-wide memory free percentage:\s*(\d+\.?\d*)%/i)
+  if (freeMatch) {
+    const freePct = Number(freeMatch[1])
+    if (Number.isFinite(freePct)) {
+      return clampPct(100 - freePct)
+    }
+  }
+
+  const pressureMatch = raw.match(/System-wide memory pressure:\s*(\d+\.?\d*)%/i)
+  if (pressureMatch) {
+    return clampPct(Number(pressureMatch[1]))
+  }
+
+  return null
+}
+
+export function memUsedPct() {
+  return clampPct(((os.totalmem() - os.freemem()) / os.totalmem()) * 100)
+}
+
+export function memoryPressureDarwin(exec = execSync) {
+  try {
+    const out = exec('/usr/bin/memory_pressure -Q', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1200
+    })
+    const pct = parseMemoryPressurePct(out)
+    if (pct !== null) {
+      return {
+        pct,
+        cls: classifyPressure(pct),
+        source: 'memory_pressure'
+      }
+    }
+  } catch {
+    // ignore and return unavailable
+  }
+
+  return {
+    pct: null,
+    cls: 'unavailable',
+    source: 'unavailable'
+  }
+}
+
+export const __memoryTestUtils = {
+  clampPct,
+  classifyPressure
+}

package/src/openclaw-cache.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+function isFiniteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+export function loadLastGoodUsageSnapshot(cachePath, nowMs = Date.now()) {
+  if (!cachePath) return null
+
+  try {
+    if (!fs.existsSync(cachePath)) return null
+    const raw = fs.readFileSync(cachePath, 'utf8')
+    const parsed = JSON.parse(raw)
+    if (!isFiniteNumber(parsed?.at) || typeof parsed?.usage !== 'object' || parsed.usage === null) return null
+
+    return {
+      at: parsed.at,
+      usage: parsed.usage,
+      ageMs: Math.max(0, nowMs - parsed.at)
+    }
+  } catch {
+    return null
+  }
+}
+
+export function persistLastGoodUsageSnapshot(cachePath, payload) {
+  if (!cachePath || !payload || !isFiniteNumber(payload.at) || typeof payload.usage !== 'object' || payload.usage === null) {
+    return false
+  }
+
+  const destination = cachePath
+  const dir = path.dirname(destination)
+  const tempPath = `${destination}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  const serialized = JSON.stringify({ at: payload.at, usage: payload.usage })
+
+  try {
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(tempPath, serialized, 'utf8')
+    fs.renameSync(tempPath, destination)
+    return true
+  } catch {
+    return false
+  } finally {
+    try {
+      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath)
+    } catch {
+      // best effort cleanup
+    }
+  }
+}