@wenrwa/marketplace-cli 0.8.6 → 0.8.7

package/dist/__tests__/bridge-process-cpu.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bridge-process-cpu.test.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const processCpu_1 = require("../bridge/processCpu");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+/**
+ * Activity-based sleep — the bridge tells the backend which sessions are
+ * burning CPU with no output (a silent build), so a box is never suspended
+ * mid-work; an idle dev server (alive, ~0 CPU) never holds a box awake.
+ */
+const stat = (pid, ppid, utime, stime = 0, cutime = 0, cstime = 0, comm = 'node') => `${pid} (${comm}) S ${ppid} ${pid} ${pid} 0 -1 4194560 100 0 0 0 ${utime} ${stime} ${cutime} ${cstime} 20 0 1 0 100 1000 100`;
+describe('parseProcStat', () => {
+    it('reads ppid and utime+stime+cutime+cstime', () => {
+        expect((0, processCpu_1.parseProcStat)(stat(10, 1, 5, 6, 7, 8))).toEqual({ ppid: 1, ticks: 26 });
+    });
+    it('survives a command name with spaces and parentheses', () => {
+        expect((0, processCpu_1.parseProcStat)(stat(10, 3, 1, 1, 0, 0, 'tmux: (server) x'))).toEqual({ ppid: 3, ticks: 2 });
+    });
+    it('rejects garbage', () => {
+        expect((0, processCpu_1.parseProcStat)('nonsense')).toBeNull();
+        expect((0, processCpu_1.parseProcStat)('1 (x) S 0')).toBeNull();
+    });
+});
+describe('treeTicks', () => {
+    it('sums the root and every descendant, nothing else', () => {
+        const t = new Map([
+            [100, { ppid: 1, ticks: 10 }], // pty shell
+            [101, { ppid: 100, ticks: 20 }], // claude
+            [102, { ppid: 101, ticks: 300 }], // npm test
+            [200, { ppid: 1, ticks: 999 }], // another session
+        ]);
+        expect((0, processCpu_1.treeTicks)(t, 100)).toBe(330);
+        expect((0, processCpu_1.treeTicks)(t, 200)).toBe(999);
+        expect((0, processCpu_1.treeTicks)(t, 404)).toBe(0);
+    });
+});
+describe('createCpuBusyTracker', () => {
+    const tracker = (tables, times) => {
+        let i = 0;
+        let j = 0;
+        return (0, processCpu_1.createCpuBusyTracker)({ readTable: () => tables[i++], now: () => times[j++], clkTck: 100, thresholdPct: 20 });
+    };
+    it('first sight only sets a baseline; then ≥20% of a core is busy, an idle tree is not', () => {
+        const tr = tracker([
+            new Map([[100, { ppid: 1, ticks: 0 }], [200, { ppid: 1, ticks: 0 }]]),
+            // 30s later: session A's tree used 15s CPU (50%), B's 1s (3%: an idle dev server)
+            new Map([[100, { ppid: 1, ticks: 0 }], [101, { ppid: 100, ticks: 1500 }], [200, { ppid: 1, ticks: 100 }]]),
+        ], [0, 30_000]);
+        const sessions = [{ id: 'A', pid: 100 }, { id: 'B', pid: 200 }];
+        expect(tr.sample(sessions)).toEqual([]);
+        expect(tr.sample(sessions)).toEqual(['A']);
+    });
+    it('a reaped child lowering the total never reads as negative or busy', () => {
+        const tr = tracker([new Map([[100, { ppid: 1, ticks: 5000 }]]), new Map([[100, { ppid: 1, ticks: 10 }]])], [0, 30_000]);
+        tr.sample([{ id: 'A', pid: 100 }]);
+        expect(tr.sample([{ id: 'A', pid: 100 }])).toEqual([]);
+    });
+    it('a session with no pid, or a pid no longer running, is skipped', () => {
+        const tr = tracker([new Map(), new Map()], [0, 30_000]);
+        expect(tr.sample([{ id: 'A', pid: undefined }, { id: 'B', pid: 9 }])).toEqual([]);
+    });
+    it('a respawned PTY (new pid) starts a fresh baseline', () => {
+        const tr = tracker([new Map([[100, { ppid: 1, ticks: 0 }]]), new Map([[300, { ppid: 1, ticks: 9000 }]])], [0, 30_000]);
+        tr.sample([{ id: 'A', pid: 100 }]);
+        expect(tr.sample([{ id: 'A', pid: 300 }])).toEqual([]);
+    });
+});
+describe('`sessions` frame carries busy only when a tracker is wired', () => {
+    class FakePty {
+        pid;
+        constructor(pid) {
+            this.pid = pid;
+        }
+        write() { }
+        resize() { }
+        kill() { }
+        onData() { }
+        onExit() { }
+    }
+    let nextPid = 100;
+    const factory = { spawn: () => new FakePty(nextPid++) };
+    const fakeSocket = () => {
+        const handlers = new Map();
+        const sock = {
+            readyState: 1,
+            sent: [],
+            send(raw) { sock.sent.push(JSON.parse(raw)); },
+            close() { handlers.get('close')?.(1006); },
+            terminate() { handlers.get('close')?.(1006); },
+            on(event, cb) { handlers.set(event, cb); },
+            fire(event, ...a) { handlers.get(event)?.(...a); },
+        };
+        return sock;
+    };
+    const start = (cpuBusyTracker) => {
+        const socket = fakeSocket();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const intervals = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: 'ws://relay.test',
+            relayToken: 'tok',
+            sessions,
+            wsFactory: () => socket,
+            reportSessions: true,
+            cpuBusyTracker,
+            setSessionsIntervalFn: (cb) => { intervals.push(cb); return intervals.length; },
+            clearSessionsIntervalFn: () => { },
+            setTimeoutFn: () => 0,
+            clearTimeoutFn: () => { },
+        });
+        return { socket, sessions, handle, tick: () => intervals.forEach((cb) => cb()) };
+    };
+    it('with a tracker: the frame lists the busy ids, and the tracker sees each session pid', () => {
+        const seen = [];
+        const { socket, sessions, handle, tick } = start({ sample: (s) => { seen.push(s); return ['agt-1']; } });
+        socket.fire('open');
+        sessions.open({ cols: 80, rows: 24, id: 'agt-1' });
+        tick();
+        expect(socket.sent.filter((f) => f.t === 'sessions').at(-1)).toEqual({ t: 'sessions', ids: ['agt-1'], busy: ['agt-1'] });
+        expect(seen.at(-1)).toEqual([{ id: 'agt-1', pid: expect.any(Number) }]);
+        handle.close();
+    });
+    it('a tracker that throws still sends the inventory, without busy', () => {
+        const { socket, handle } = start({ sample: () => { throw new Error('proc gone'); } });
+        socket.fire('open');
+        expect(socket.sent.filter((f) => f.t === 'sessions').at(-1)).toEqual({ t: 'sessions', ids: [] });
+        handle.close();
+    });
+    it('no tracker (local bridge, non-Linux) → byte-identical frame', () => {
+        const { socket, handle } = start(null);
+        socket.fire('open');
+        expect(socket.sent.filter((f) => f.t === 'sessions').at(-1)).toEqual({ t: 'sessions', ids: [] });
+        handle.close();
+    });
+});

package/dist/bridge/processCpu.d.ts

@@ -0,0 +1,29 @@
+export interface ProcEntry {
+    ppid: number;
+    /** utime + stime + cutime + cstime, in clock ticks. */
+    ticks: number;
+}
+/** Parse one /proc/<pid>/stat line. The command name sits in parentheses and
+ *  may itself contain spaces or parentheses, so split after the LAST ')'. */
+export declare function parseProcStat(line: string): ProcEntry | null;
+export declare function readProcTable(procRoot?: string): Map<number, ProcEntry>;
+/** Total ticks of `root` and every live descendant. */
+export declare function treeTicks(table: Map<number, ProcEntry>, root: number): number;
+export interface CpuBusyTrackerOptions {
+    readTable?: () => Map<number, ProcEntry>;
+    now?: () => number;
+    /** Clock ticks per second (Linux USER_HZ — 100 on every mainstream kernel). */
+    clkTck?: number;
+    /** Busy at or above this share of one core, averaged since the last sample. */
+    thresholdPct?: number;
+}
+export interface CpuBusyTracker {
+    /** Session ids whose tree used ≥ threshold CPU since the previous sample.
+     *  A session seen for the first time only sets its baseline. */
+    sample(sessions: Array<{
+        id: string;
+        pid: number | undefined;
+    }>): string[];
+}
+export declare const DEFAULT_BUSY_CPU_PCT = 20;
+export declare function createCpuBusyTracker(opts?: CpuBusyTrackerOptions): CpuBusyTracker | null;

package/dist/bridge/processCpu.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BUSY_CPU_PCT = void 0;
+exports.parseProcStat = parseProcStat;
+exports.readProcTable = readProcTable;
+exports.treeTicks = treeTicks;
+exports.createCpuBusyTracker = createCpuBusyTracker;
+/**
+ * Activity-based sleep — which PTY sessions are doing work nobody can see?
+ *
+ * The backend suspends an idle box (HT_ACTIVITY_IDLE=1). Output and keystrokes
+ * already count as activity; this covers the silent rest: a build, a test run
+ * or an install a backgrounded shell runs while the agent sits at its prompt.
+ * We measure CPU, not "is a child process alive", on purpose: an idle dev
+ * server is alive forever and must not hold a box awake, but one actually
+ * serving requests burns CPU and does.
+ *
+ * Linux only (reads /proc). Elsewhere `createCpuBusyTracker` returns null and
+ * the `sessions` frame carries no `busy` field, which the backend reads as
+ * unknown — never as busy.
+ *
+ * A session's cost is its whole process tree: utime+stime of every live
+ * process under the PTY, plus cutime+cstime, which already holds the CPU of
+ * children that have exited and been reaped (an install's short-lived compiler
+ * runs). A reaped intermediate parent takes its children's time with it; the
+ * delta is clamped at 0, so that can only under-report.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Parse one /proc/<pid>/stat line. The command name sits in parentheses and
+ *  may itself contain spaces or parentheses, so split after the LAST ')'. */
+function parseProcStat(line) {
+    const close = line.lastIndexOf(')');
+    if (close < 0)
+        return null;
+    const f = line.slice(close + 2).trim().split(/\s+/);
+    // f[0]=state f[1]=ppid … f[11]=utime f[12]=stime f[13]=cutime f[14]=cstime
+    if (f.length < 15)
+        return null;
+    const nums = [f[1], f[11], f[12], f[13], f[14]].map(Number);
+    if (nums.some((n) => !Number.isFinite(n)))
+        return null;
+    return { ppid: nums[0], ticks: nums[1] + nums[2] + nums[3] + nums[4] };
+}
+function readProcTable(procRoot = '/proc') {
+    const table = new Map();
+    let names;
+    try {
+        names = fs.readdirSync(procRoot);
+    }
+    catch {
+        return table;
+    }
+    for (const name of names) {
+        if (!/^\d+$/.test(name))
+            continue;
+        try {
+            const e = parseProcStat(fs.readFileSync(path.join(procRoot, name, 'stat'), 'utf8'));
+            if (e)
+                table.set(Number(name), e);
+        }
+        catch { /* exited between readdir and read */ }
+    }
+    return table;
+}
+/** Total ticks of `root` and every live descendant. */
+function treeTicks(table, root) {
+    const children = new Map();
+    for (const [pid, e] of table) {
+        const list = children.get(e.ppid);
+        if (list)
+            list.push(pid);
+        else
+            children.set(e.ppid, [pid]);
+    }
+    let total = 0;
+    const stack = [root];
+    const seen = new Set();
+    while (stack.length) {
+        const pid = stack.pop();
+        if (seen.has(pid))
+            continue;
+        seen.add(pid);
+        const e = table.get(pid);
+        if (e)
+            total += e.ticks;
+        for (const c of children.get(pid) ?? [])
+            stack.push(c);
+    }
+    return total;
+}
+exports.DEFAULT_BUSY_CPU_PCT = 20;
+function createCpuBusyTracker(opts = {}) {
+    const readTable = opts.readTable ?? (process.platform === 'linux' && fs.existsSync('/proc/self/stat') ? () => readProcTable() : null);
+    if (!readTable)
+        return null;
+    const now = opts.now ?? Date.now;
+    const clkTck = opts.clkTck ?? 100;
+    const thresholdPct = opts.thresholdPct ?? (Number(process.env.HIVEOP_BUSY_CPU_PCT) || exports.DEFAULT_BUSY_CPU_PCT);
+    const last = new Map();
+    return {
+        sample(sessions) {
+            const table = readTable();
+            const at = now();
+            const busy = [];
+            const live = new Set();
+            for (const { id, pid } of sessions) {
+                if (typeof pid !== 'number' || !table.has(pid))
+                    continue;
+                live.add(id);
+                const ticks = treeTicks(table, pid);
+                const prev = last.get(id);
+                last.set(id, { pid, ticks, at });
+                if (!prev || prev.pid !== pid || at <= prev.at)
+                    continue;
+                const cpuSeconds = Math.max(0, ticks - prev.ticks) / clkTck;
+                const pct = (cpuSeconds / ((at - prev.at) / 1000)) * 100;
+                if (pct >= thresholdPct)
+                    busy.push(id);
+            }
+            for (const id of [...last.keys()])
+                if (!live.has(id))
+                    last.delete(id);
+            return busy;
+        },
+    };
+}

package/dist/bridge/realPty.js

@@ -98,6 +98,7 @@ function realPtyFactory() {
                 kill: () => proc.kill(),
                 onData: (cb) => proc.onData(cb),
                 onExit: (cb) => proc.onExit(({ exitCode }) => cb(exitCode)),
+                pid: typeof proc.pid === 'number' ? proc.pid : undefined,
             };
         },
     };

package/dist/bridge/relayClient.d.ts

@@ -1,6 +1,7 @@
 import { type OpencodeLaunchInput } from './agentLaunch';
 import type { PreparedLaunch } from './opencodeBinary';
 import { SessionManager } from './sessionManager';
+import type { CpuBusyTracker } from './processCpu';
 import { MemInfo } from './containerMemory';
 import { BrowserDriver } from './browserDriver';
 import { BrowserIdleTracker } from './browserIdle';
@@ -404,6 +405,14 @@ export interface RelayClientOpts {
      * — see cli/src/commands/bridge.ts's relay branch.
      */
     reportSessions?: boolean;
+    /**
+     * Activity-based sleep — add `busy` (ids whose process tree burned CPU
+     * since the previous report) to every `sessions` frame, so the backend does
+     * not suspend a box mid silent build. Rides the inventory report, so it
+     * needs reportSessions too. Absent/null (the default, and any non-Linux
+     * host) → the frame is byte-identical to before. See processCpu.ts.
+     */
+    cpuBusyTracker?: CpuBusyTracker | null;
     /**
      * tchp-02 — opt IN to per-session working-tree change detection (`changes`
      * frame). Mirrors reportSessions exactly: absent (the default) → no

package/dist/bridge/relayClient.js

@@ -596,7 +596,17 @@ function startRelayClient(opts) {
         // machine the platform is not supposed to see.
         if (opts.onlyRelayOwnedSessions)
             ids = ids.filter((id) => relayOwned.has(id));
-        send(ws, { t: 'sessions', ids });
+        let busy;
+        if (opts.cpuBusyTracker) {
+            try {
+                const pidOf = opts.sessions.pidOf?.bind(opts.sessions);
+                busy = opts.cpuBusyTracker.sample(ids.map((id) => ({ id, pid: pidOf?.(id) })));
+            }
+            catch {
+                busy = undefined; // a failed sample must never drop the inventory
+            }
+        }
+        send(ws, busy ? { t: 'sessions', ids, busy } : { t: 'sessions', ids });
     }
     /**
      * tchp-02 — the ACTIVE sessions worth polling for working-tree changes:

package/dist/bridge/sessionManager.d.ts

@@ -7,6 +7,9 @@ export interface PtyLike {
     kill(): void;
     onData(cb: (data: string) => void): void;
     onExit(cb: (code: number) => void): void;
+    /** OS process id of the PTY's child, when the factory knows it (node-pty
+     *  does). Read by the CPU-busy report (processCpu.ts). */
+    readonly pid?: number;
 }
 export interface PtyFactory {
     /**
@@ -198,6 +201,9 @@ export declare class SessionManager {
     private recoverSerializeWedge;
     close(sessionId: string): void;
     list(): string[];
+    /** The PTY child's pid, or undefined (unknown session, or a factory that
+     *  does not expose one). */
+    pidOf(sessionId: string): number | undefined;
     /**
      * fcct-34 — READ-ONLY look at what a session currently shows.
      *

package/dist/bridge/sessionManager.js

@@ -367,6 +367,11 @@ class SessionManager {
     list() {
         return [...this.sessions.keys()];
     }
+    /** The PTY child's pid, or undefined (unknown session, or a factory that
+     *  does not expose one). */
+    pidOf(sessionId) {
+        return this.sessions.get(sessionId)?.pty.pid;
+    }
     /**
      * fcct-34 — READ-ONLY look at what a session currently shows.
      *

package/dist/commands/bridge.js

@@ -52,6 +52,7 @@ exports.resolveBridgeInstallEnv = resolveBridgeInstallEnv;
  * inside the terminal (their subscription, Anthropic's client) — this
  * process never drives it (ADR-0028 in wenrwa-arena).
  */
+const processCpu_1 = require("../bridge/processCpu");
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -650,6 +651,9 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // Deliberately NOT set on the local bridge below — a local agent has no
             // hosted lifecycle to reconcile.
             reportSessions: true,
+            // Activity-based sleep: which sessions are burning CPU with no output
+            // (a silent build) — null off Linux, which sends no `busy` at all.
+            cpuBusyTracker: (0, processCpu_1.createCpuBusyTracker)(),
             // tchp-02 — per-session working-tree change detector (`changes`
             // frame). Same posture as reportSessions just above: this IS the
             // hosted container bridge, so every session is relay-owned by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",