@evident-ai/cli 3.3.1-dev.181ad3f → 3.3.1-dev.25e01b7

package/README.md

@@ -106,10 +106,10 @@ Options:
   Claude credential is ever read. An unrecognized value falls back to `auto` with
   a warning. Env: `EVIDENT_CLAUDE_USAGE_REPORTING`.
 - `--no-resource-usage-reporting` — Don't report this machine's CPU
-  utilization, total and available memory, and core count to Evident, so it
-  shows on the runner page. On by default; nothing else about the machine
-  leaves it. Env: `EVIDENT_RESOURCE_USAGE_REPORTING=off` (the flag wins if
-  both are set).
+  utilization, total and available memory, core count, disk space, and the
+  OpenCode session-store size to Evident, so it shows on the runner page. On
+  by default; nothing else about the machine leaves it. Env:
+  `EVIDENT_RESOURCE_USAGE_REPORTING=off` (the flag wins if both are set).
 - `--json` — Output in JSON format (forces non-interactive mode).
 - `--session-cleanup-max-age <duration>` — Delete OpenCode sessions idle longer
   than this window (format `<number><unit>`, unit one of `s, m, h, d` — e.g.

package/dist/index.js

@@ -756,7 +756,10 @@ async function reportResourceUsage(agentId, authHeader, usage) {
         cpu_percent: usage.cpuPercent,
         cpu_count: usage.cpuCount,
         memory_total_bytes: usage.memoryTotalBytes,
-        memory_available_bytes: usage.memoryAvailableBytes
+        memory_available_bytes: usage.memoryAvailableBytes,
+        disk_total_bytes: usage.diskTotalBytes,
+        disk_free_bytes: usage.diskFreeBytes,
+        opencode_db_bytes: usage.opencodeDbBytes
       }),
       signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
@@ -3061,6 +3064,53 @@ function resolveResourceUsageReportingEnabled(flagValue, env) {
 
 // src/lib/resource-usage.ts
 import { cpus, totalmem, freemem } from "os";
+import { statfsSync as statfsSync2 } from "fs";
+
+// src/lib/ecs-task-metadata.ts
+var ECS_METADATA_TIMEOUT_MS = 2e3;
+function parseEcsTaskLimits(payload) {
+  if (typeof payload !== "object" || payload === null) return null;
+  const limits = payload.Limits;
+  if (typeof limits !== "object" || limits === null) return null;
+  const cpu = limits.CPU;
+  const memory = limits.Memory;
+  if (typeof cpu !== "number" || !Number.isFinite(cpu) || cpu <= 0) return null;
+  if (typeof memory !== "number" || !Number.isFinite(memory) || memory <= 0) return null;
+  return {
+    cpuCount: Math.max(1, Math.round(cpu)),
+    memoryTotalBytes: memory * 1024 * 1024
+  };
+}
+async function readEcsTaskLimits(env) {
+  const uri = env.ECS_CONTAINER_METADATA_URI_V4;
+  if (!uri) {
+    return { limits: null };
+  }
+  const url = `${uri}/task`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(ECS_METADATA_TIMEOUT_MS) });
+    if (!response.ok) {
+      return {
+        limits: null,
+        warning: `ECS task metadata fetch (${url}) returned HTTP ${response.status}`
+      };
+    }
+    const payload = await response.json();
+    const limits = parseEcsTaskLimits(payload);
+    if (limits === null) {
+      return {
+        limits: null,
+        warning: `ECS task metadata fetch (${url}) returned an unexpected payload`
+      };
+    }
+    return { limits };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return { limits: null, warning: `ECS task metadata fetch (${url}) failed: ${message}` };
+  }
+}
+
+// src/lib/resource-usage.ts
 function readCpuSample() {
   let busyMs = 0;
   let idleMs = 0;
@@ -3077,17 +3127,66 @@ function cpuPercentBetween(previous, current) {
   if (total === 0) return null;
   return Math.round((deltaBusy / total * 100 + Number.EPSILON) * 100) / 100;
 }
-function createResourceUsageCollector() {
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function round2(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function readDisk(homeDir) {
+  try {
+    const stats = statfsSync2(homeDir);
+    return {
+      totalBytes: stats.bsize * stats.blocks,
+      freeBytes: stats.bsize * stats.bavail
+    };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return {
+      totalBytes: null,
+      freeBytes: null,
+      warning: `Could not read disk usage for ${homeDir}: ${message}`
+    };
+  }
+}
+function createResourceUsageCollector(homeDir) {
   let previous = readCpuSample();
-  return () => {
+  return async () => {
     const current = readCpuSample();
-    const cpuPercent = cpuPercentBetween(previous, current);
+    const hostCpuPercent = cpuPercentBetween(previous, current);
+    const hostCpuCount = cpus().length;
     previous = current;
+    const disk = readDisk(homeDir);
+    const opencodeDbBytes = statSessionDbBytes(homeDir);
+    const { limits, warning: ecsWarning } = await readEcsTaskLimits(process.env);
+    const warnings = [];
+    if (disk.warning) warnings.push(disk.warning);
+    if (ecsWarning) warnings.push(ecsWarning);
+    let cpuPercent = hostCpuPercent;
+    let cpuCount = hostCpuCount;
+    let memoryTotalBytes = totalmem();
+    let memoryAvailableBytes = freemem();
+    if (limits !== null) {
+      cpuCount = limits.cpuCount;
+      memoryTotalBytes = limits.memoryTotalBytes;
+      memoryAvailableBytes = clamp(
+        limits.memoryTotalBytes - (totalmem() - freemem()),
+        0,
+        limits.memoryTotalBytes
+      );
+      cpuPercent = hostCpuPercent === null ? null : clamp(round2(hostCpuPercent * hostCpuCount / limits.cpuCount), 0, 100);
+    }
     return {
-      cpuPercent,
-      cpuCount: cpus().length,
-      memoryTotalBytes: totalmem(),
-      memoryAvailableBytes: freemem()
+      usage: {
+        cpuPercent,
+        cpuCount,
+        memoryTotalBytes,
+        memoryAvailableBytes,
+        diskTotalBytes: disk.totalBytes,
+        diskFreeBytes: disk.freeBytes,
+        opencodeDbBytes
+      },
+      warnings
     };
   };
 }
@@ -7993,11 +8092,18 @@ function scheduleResourceUsageReporting(state, options) {
     });
     return;
   }
-  const collect = createResourceUsageCollector();
+  const collect = createResourceUsageCollector(homedir3());
   let consecutiveFailures = 0;
   const tick = async () => {
     try {
-      const usage = collect();
+      const { usage, warnings: collectWarnings } = await collect();
+      for (const warning2 of collectWarnings) {
+        logActivity(state, {
+          type: "info",
+          level: "debug",
+          message: `Resource usage collection: ${warning2}`
+        });
+      }
       const result = await reportResourceUsage(state.agentId, state.authHeader, usage);
       if (result.ok) {
         if (consecutiveFailures > 0) {