@proagentstore/cli 0.4.75 → 0.4.77

package/dist/browser-runner/coding/headless.js

@@ -295,6 +295,10 @@ export class HeadlessSession {
     get lastTurn() {
         return this.turnReport;
     }
+    /** The engine process's pid while one is running — what per-session resource attribution reads (#924). */
+    get pid() {
+        return this.procAlive ? (this.proc?.pid ?? null) : null;
+    }
     /** Is a process running THIS instant? The persistent engine's liveness, and the spawn guard. */
     get procAlive() {
         return this.proc !== null && this.proc.exitCode === null && this.proc.signalCode === null;

package/dist/browser-runner/coding/inspect.js

@@ -159,8 +159,15 @@ export class InspectError extends Error {
 }
 const DEFAULT_MAX_FILE_BYTES = 64 * 1024;
 const HARD_MAX_FILE_BYTES = 128 * 1024;
-/** Read a text file inside the repo. Rejects traversal, oversize, and binary files. */
-export function readRepoFile(workDir, relPath, maxBytes) {
+/**
+ * Read a text file inside the repo. Rejects traversal and binary files; returns at most `maxBytes`.
+ *
+ * Ranged from #954: `startLine`/`startColumn` say where the returned bytes begin, so no part of a file
+ * is out of reach — before it, a read always began at byte 0 and nothing past the cap could be read.
+ * `firstLine`/`firstColumn`/`totalLines` are always present, which is how the cloud tells a runner that
+ * honours the range from an older one that silently started at the top.
+ */
+export function readRepoFile(workDir, relPath, maxBytes, from = {}) {
     const abs = resolveInside(workDir, relPath, { checkSymlink: true });
     const st = statSync(abs);
     if (!st.isFile())
@@ -171,8 +178,31 @@ export function readRepoFile(workDir, relPath, maxBytes) {
     const head = buf.subarray(0, 8192);
     if (head.includes(0))
         return { path: relPath, size: st.size, truncated: false, binary: true };
-    const truncated = buf.length > cap;
-    return { path: relPath, size: st.size, truncated, content: buf.subarray(0, cap).toString("utf-8") };
+    let newlines = 0;
+    for (let i = buf.indexOf(10); i !== -1; i = buf.indexOf(10, i + 1))
+        newlines++;
+    const totalLines = newlines + (buf.length > 0 && buf[buf.length - 1] !== 10 ? 1 : 0);
+    const firstLine = Math.max(1, Math.trunc(Number(from.startLine) || 1));
+    const firstColumn = Math.max(1, Math.trunc(Number(from.startColumn) || 1));
+    const ranged = { firstLine, firstColumn, totalLines };
+    if (firstLine > totalLines)
+        return { path: relPath, size: st.size, truncated: false, content: "", ...ranged };
+    // The byte where line `firstLine` begins…
+    let start = 0;
+    for (let line = 1; line < firstLine; line++)
+        start = buf.indexOf(10, start) + 1;
+    // …and, for a column past the first, where that CHARACTER begins — counted on the decoded line, so
+    // a multi-byte character is never split.
+    if (firstColumn > 1) {
+        const eol = buf.indexOf(10, start);
+        const lineText = buf.subarray(start, eol === -1 ? buf.length : eol).toString("utf-8");
+        start += Buffer.byteLength(lineText.slice(0, firstColumn - 1), "utf-8");
+    }
+    let end = Math.min(buf.length, start + cap);
+    // Never end inside a multi-byte character: it would decode as U+FFFD at the cut.
+    while (end < buf.length && end > start && (buf[end] & 0xc0) === 0x80)
+        end--;
+    return { path: relPath, size: st.size, truncated: end < buf.length, content: buf.subarray(start, end).toString("utf-8"), ...ranged };
 }
 /** Run a whitelisted read-only git command in the repo. Never uses a shell. */
 export function runRepoGit(workDir, cmd, opts = {}) {

package/dist/browser-runner/coding/runtime.js

@@ -53,7 +53,7 @@ export class CodingRuntime {
     }
     /** Read one file inside the session's repo (traversal-guarded, size-capped). */
     readFile(input) {
-        return readRepoFile(this.resolveWorkDir(input), input.path, input.maxBytes);
+        return readRepoFile(this.resolveWorkDir(input), input.path, input.maxBytes, { startLine: input.startLine, startColumn: input.startColumn });
     }
     /** Run a whitelisted read-only git command in the session's repo. */
     git(input) {
@@ -286,6 +286,10 @@ export class CodingRuntime {
             runState: s.runState(),
         }));
     }
+    /** Every session with a live engine process, and its pid — the roots resource attribution walks (#924). */
+    enginePids() {
+        return [...this.sessions.entries()].flatMap(([sessionId, s]) => (s.pid ? [{ sessionId, engineLabel: s.engineLabel, pid: s.pid }] : []));
+    }
     /** Rich diagnostics for every tracked session — the console's transparency view. */
     diagnostics() {
         return [...this.sessions.entries()].map(([sessionId, s]) => ({

package/dist/browser-runner/coding/session-resources.js

@@ -0,0 +1,67 @@
+/**
+ * Which coding session is using the machine (#924).
+ *
+ * The heartbeat says a machine is loaded; this says WHICH agent is loading it. Each session's engine
+ * is a child process that spawns its own (an engine's tools, a test runner, a build), so a session's
+ * share is its engine process plus every descendant. One `ps` per heartbeat reads the whole process
+ * table — the attribution is computed here from it, never by a `ps` per session.
+ *
+ * Not on Windows (no `ps`): the reading is absent there, which the platform reports as "not
+ * reported", never as zero.
+ */
+import { execFileSync } from "node:child_process";
+/** `ps -A -o pid=,ppid=,rss=,pcpu=` output → rows. A line that does not parse is skipped. */
+export function parsePs(text) {
+    const rows = [];
+    for (const line of text.split("\n")) {
+        const [pid, ppid, rss, cpu] = line.trim().split(/\s+/).map(Number);
+        if ([pid, ppid, rss, cpu].every((n) => Number.isFinite(n)))
+            rows.push({ pid, ppid, rssKb: rss, cpuPct: cpu });
+    }
+    return rows;
+}
+/** Each root's own row plus all its descendants', summed. Pure, so the tree walk is testable. */
+export function attribute(rows, roots) {
+    const children = new Map();
+    const byPid = new Map();
+    for (const r of rows) {
+        byPid.set(r.pid, r);
+        children.set(r.ppid, [...(children.get(r.ppid) ?? []), r]);
+    }
+    return roots.flatMap((root) => {
+        const top = byPid.get(root.pid);
+        if (!top)
+            return [];
+        let processes = 0;
+        let rssKb = 0;
+        let cpuPct = 0;
+        const seen = new Set();
+        const stack = [top];
+        while (stack.length) {
+            const r = stack.pop();
+            if (seen.has(r.pid))
+                continue;
+            seen.add(r.pid);
+            processes++;
+            rssKb += r.rssKb;
+            cpuPct += r.cpuPct;
+            stack.push(...(children.get(r.pid) ?? []));
+        }
+        return [{ sessionId: root.sessionId, engineLabel: root.engineLabel, pid: root.pid, processes, rssBytes: rssKb * 1024, cpuPct: Math.round(cpuPct * 10) / 10 }];
+    });
+}
+/** Read the process table once and attribute it to the live engines. Null when it cannot be read. */
+export function readSessionResources(roots) {
+    if (process.platform === "win32")
+        return null;
+    if (!roots.length)
+        return [];
+    try {
+        const out = execFileSync("ps", ["-A", "-o", "pid=,ppid=,rss=,pcpu="], { encoding: "utf-8", timeout: 2000, maxBuffer: 8 * 1024 * 1024 });
+        return attribute(parsePs(out), roots);
+    }
+    catch {
+        // A `ps` that failed or timed out is "not read this beat", which the null says — never zeros.
+        return null;
+    }
+}

package/dist/browser-runner/server.js

@@ -199,6 +199,11 @@ async function route(runner, req, res) {
     if (req.method === "GET" && path === "/coding/sessions") {
         return json(res, 200, { sessions: runner.coding.list() });
     }
+    // Per-session CPU and memory, for the heartbeat (#924): which agent is loading this machine.
+    if (req.method === "GET" && path === "/coding/resources") {
+        const { readSessionResources } = await import("./coding/session-resources.js");
+        return json(res, 200, { sessions: readSessionResources(runner.coding.enginePids()) });
+    }
     if ((req.method === "GET" || req.method === "POST") && path === "/coding/diagnostics") {
         // No tmux figures here any more (#247). The coding engine spawns a child process
         // directly, so `pagsTmuxTotal` was structurally always 0 and `tmuxTotal` counted the

package/dist/index.js

@@ -1205,10 +1205,40 @@ async function waitForLocalRunner(opts, timeoutMs = 15e3) {
 import { hostname as hostname3 } from "os";
 
 // src/commands/runner/resources.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, statfsSync, writeFileSync as writeFileSync4 } from "fs";
 import os from "os";
-function sampleResources(read = os, now = Date.now()) {
+import { dirname as dirname2, join as join6 } from "path";
+var CHECKOUT_ROOT = join6(os.homedir(), ".config", "proagentstore", "repos");
+function sampleDisk(path = CHECKOUT_ROOT, statfs = statfsSync) {
+  for (const p of [path, os.homedir()]) {
+    try {
+      const s = statfs(p);
+      return { path: p, totalBytes: Number(s.blocks) * Number(s.bsize), freeBytes: Number(s.bavail) * Number(s.bsize), inodesTotal: Number(s.files), inodesFree: Number(s.ffree) };
+    } catch {
+    }
+  }
+  return null;
+}
+var STARTS_FILE = join6(os.homedir(), ".config", "proagentstore", "runner-starts.json");
+function recordRunnerStart(now = Date.now(), file = STARTS_FILE) {
+  let starts = [];
+  try {
+    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
+    if (Array.isArray(parsed)) starts = parsed.filter((t) => typeof t === "number" && Number.isFinite(t));
+  } catch {
+  }
+  starts = [...starts.filter((t) => now - t < 24 * 60 * 60 * 1e3), now].slice(-200);
+  try {
+    mkdirSync4(dirname2(file), { recursive: true });
+    writeFileSync4(file, JSON.stringify(starts));
+  } catch {
+  }
+  return starts.length;
+}
+function sampleResources(read = os, now = Date.now(), extra = {}) {
   const [l1 = 0, l5 = 0, l15 = 0] = read.loadavg();
   return {
+    ...Object.fromEntries(Object.entries(extra).filter(([, v]) => v !== void 0)),
     loadAvg: [l1, l5, l15],
     // `availableParallelism` would be better, but `cpus()` is what every supported Node has.
     cpus: Math.max(1, read.cpus().length),
@@ -1413,6 +1443,9 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }
   };
   const attached = /* @__PURE__ */ new Map();
+  const processStartedAt = Date.now();
+  const starts24h = recordRunnerStart(processStartedAt);
+  let relayReconnects = 0;
   const blocked = /* @__PURE__ */ new Set();
   let syncing = Promise.resolve();
   const forceNext = /* @__PURE__ */ new Set();
@@ -1528,6 +1561,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         // and taken when it did not — which is how a register lost to a boot-time
         // `fetch failed` finally gets a second chance.
         async (openedId, reconnect) => {
+          if (reconnect) relayReconnects++;
           if (!shouldRegisterOnOpen(reconnect, registered.has(openedId))) return;
           await registerRuntime(openedId, reconnect ? false : force);
           reportRegistration();
@@ -1559,7 +1593,14 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const heartbeat = () => {
     const timer = setTimeout(async () => {
       let failure = null;
-      const resources = sampleResources();
+      const first = attached.values().next().value;
+      const [relayRttMs, sessions] = await Promise.all([first ? first.probeRtt() : Promise.resolve(null), readSessionResources(localUrl, runnerToken)]);
+      const resources = sampleResources(void 0, void 0, {
+        disk: sampleDisk() ?? void 0,
+        runner: { startedAt: processStartedAt, uptimeSec: Math.round(process.uptime()), starts24h, relayReconnects },
+        relayRttMs,
+        sessions: sessions ?? void 0
+      });
       for (const id of [...attached.keys()]) {
         try {
           await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime/heartbeat`, opts, { runnerNode, resources });
@@ -1639,6 +1680,18 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     tick();
   }
 }
+async function readSessionResources(localUrl, runnerToken) {
+  try {
+    const res = await fetch(`${localUrl}/coding/resources`, { headers: { Authorization: `Bearer ${runnerToken}` }, signal: AbortSignal.timeout(3e3) });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return Array.isArray(body.sessions) ? body.sessions : null;
+  } catch {
+    return null;
+  }
+}
+var RTT_PROBE_PREFIX = "rtt:";
+var RTT_ECHO_PREFIX = "rtt-echo:";
 function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3()) {
   let backoffMs = 1e3;
   let reconnecting = false;
@@ -1646,6 +1699,7 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
   let opened = false;
   let socket = null;
   let retryTimer = null;
+  const rttWaiters = /* @__PURE__ */ new Map();
   const connect = async () => {
     if (closed) return;
     let relayToken;
@@ -1686,6 +1740,10 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
         }
         return;
       }
+      if (text.startsWith(RTT_ECHO_PREFIX)) {
+        rttWaiters.get(text.slice(RTT_ECHO_PREFIX.length))?.(Date.now());
+        return;
+      }
       let cmd;
       try {
         cmd = JSON.parse(text);
@@ -1766,6 +1824,31 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
       } catch {
       }
       socket = null;
+    },
+    probeRtt(timeoutMs = 5e3) {
+      const ws = socket;
+      if (!ws || ws.readyState !== WebSocket.OPEN) return Promise.resolve(null);
+      const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const sentAt = Date.now();
+      return new Promise((resolveRtt) => {
+        const timer = setTimeout(() => {
+          rttWaiters.delete(id);
+          resolveRtt(null);
+        }, timeoutMs);
+        timer.unref?.();
+        rttWaiters.set(id, (echoedAt) => {
+          clearTimeout(timer);
+          rttWaiters.delete(id);
+          resolveRtt(echoedAt - sentAt);
+        });
+        try {
+          ws.send(`${RTT_PROBE_PREFIX}${id}`);
+        } catch {
+          clearTimeout(timer);
+          rttWaiters.delete(id);
+          resolveRtt(null);
+        }
+      });
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.75",
+  "version": "0.4.77",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",