@omnitron-dev/omnitron 0.1.3 → 0.3.0

package/dist/orchestrator/process-janitor.js

@@ -0,0 +1,495 @@
+/**
+ * ProcessJanitor — kills leaked fork-worker processes.
+ *
+ * The leak: when an app restart sequence partially fails (esbuild
+ * rebuild failure, supervisor mid-spawn crash), the children spawned
+ * by an earlier attempt can survive the cleanup path. The orchestrator
+ * loses its reference to them; from its perspective the app is in
+ * `errored` state with no children. From the OS's perspective there
+ * are still `fork-worker.js` processes alive, holding sockets and DB
+ * connections.
+ *
+ * The janitor is the safety net. It does NOT replace correct cleanup
+ * in process-spawner / supervisor; it catches what slips through.
+ *
+ * Algorithm (every `intervalMs`, default 30s):
+ *   1. Walk `ps` for every running `fork-worker.js` process.
+ *   2. Build the set of PIDs the orchestrator currently owns by
+ *      iterating every handle's supervisor children.
+ *   3. Any fork-worker PID NOT in the owned set is an orphan:
+ *      - if its ppid points at a non-existent process (init parent
+ *        adopted), the parent daemon died; kill it (cold-start case).
+ *      - if its ppid is THIS daemon but it's not in the owned set,
+ *        we lost it during a restart cycle; kill it.
+ *   4. SIGTERM first, then SIGKILL after `gracefulMs`.
+ *
+ * Cold-start mode: on daemon boot, before any apps register, do a
+ * single scan and kill every fork-worker whose parent is gone — a
+ * previous daemon that really is dead. A worker whose parent is ALIVE
+ * and is not us belongs to somebody else and is left alone, which is
+ * the same rule the periodic sweep applies.
+ */
+import { execFile } from 'node:child_process';
+import { setTimeout as wait } from 'node:timers/promises';
+import { isProcessAlive } from '@omnitron-dev/titan/utils';
+export class ProcessJanitor {
+    intervalMs;
+    gracefulMs;
+    minProcessAgeSeconds;
+    /** Sweeps that could not read the process table, in a row. */
+    consecutiveSkips = 0;
+    logger;
+    onMetrics;
+    getOwnedPids;
+    listProcesses;
+    kill;
+    isAlive;
+    timer = null;
+    inFlight = false;
+    constructor(options) {
+        this.intervalMs = options.intervalMs ?? 30_000;
+        this.gracefulMs = options.gracefulMs ?? 3_000;
+        this.minProcessAgeSeconds = options.minProcessAgeSeconds ?? 60;
+        this.logger = options.logger;
+        this.onMetrics = options.onMetrics;
+        this.getOwnedPids = options.getOwnedPids;
+        this.listProcesses = options.listProcesses ?? (() => listForkWorkersFromPs(this.logger));
+        this.kill = options.kill ?? ((pid, signal) => process.kill(pid, signal));
+        this.isAlive = options.isAlive ?? defaultIsAlive;
+    }
+    /**
+     * Cold-start sweep — call BEFORE any apps register. Kills every
+     * `fork-worker.js` whose ppid is not the current daemon (i.e.
+     * adopted by init after a previous daemon died).
+     *
+     * Synchronous-feeling — uses SIGTERM then waits a fixed grace
+     * before SIGKILL. Returns the count of processes reaped.
+     */
+    async coldStartSweep() {
+        const myPid = process.pid;
+        const listed = await this.listProcesses();
+        if (listed === null) {
+            this.logger?.error?.('janitor: cold start could not read the process table — leftovers from a previous daemon are not being reaped');
+            return 0;
+        }
+        const all = listed;
+        // A foreign parent is not evidence of a dead one.
+        //
+        // This read `row.ppid !== myPid` — reap anything not parented by ME —
+        // on the assumption that only the daemon ever calls this, and only at
+        // boot. Nothing enforces that assumption, and when it is wrong the cost
+        // is every running app on the machine. Measured 2026-09-12: one unit
+        // test constructing an `OrchestratorService` and calling `startApp`
+        // reached `ensureBootReconciled` → `coldStartSweep`, where
+        // `process.pid` was the vitest worker's, and killed all six backends of
+        // the live dev stand. The daemon itself survived, so `omnitron ls`
+        // reported `crashed` for apps nothing had crashed.
+        //
+        // `runSweep` below already had the right rule and this did not: "some
+        // other parent — not ours, leave alone". The two halves of one janitor
+        // disagreed about what an orphan is, and only the cheap half ran at the
+        // moment nothing else was there to object.
+        //
+        // But `!isAlive(ppid)` cannot answer the question this sweep exists for.
+        // When a parent dies its children are REPARENTED — to launchd on macOS,
+        // to init or a subreaper on Linux — so an orphan's `ppid` becomes 1, and
+        // pid 1 is alive on every running system. The test therefore returned
+        // `false` for precisely the processes the docblock above promises to
+        // kill, and the sweep could not reap a single one of them.
+        //
+        // Measured 2026-09-14, minutes after a daemon restart: seven
+        // `fork-worker.js` processes with `ppid = 1`, the oldest four and a half
+        // hours old, still holding their TCP ports. Their supervised replacements
+        // could not bind, failed to start, burned their whole restart budget on
+        // `EADDRINUSE` and gave up — so the console reported the APPLICATIONS as
+        // crashed, and the cause was the supervisor's own leftovers. They also
+        // ignored SIGTERM and needed SIGKILL, which is what `reap` already does.
+        //
+        // `ppid === REAPER_PID` is the orphan signature, and it is the one case
+        // where "not my child" really is evidence of a dead parent.
+        const stale = all.filter((row) => row.ppid !== myPid && this.hasDeadParent(row));
+        if (stale.length === 0) {
+            this.logger?.debug?.({ scanned: all.length }, 'janitor: cold start — no stale fork-workers');
+            return 0;
+        }
+        this.logger?.warn?.({ count: stale.length, pids: stale.slice(0, 10).map((r) => r.pid) }, 'janitor: cold start — reaping stale fork-workers from a previous daemon');
+        return this.reap(stale.map((r) => r.pid));
+    }
+    /** Begin periodic sweeps. Idempotent. */
+    start() {
+        if (this.timer)
+            return;
+        const sweep = async () => {
+            if (this.inFlight)
+                return;
+            this.inFlight = true;
+            try {
+                await this.runSweep();
+            }
+            catch (err) {
+                this.logger?.error?.({ err }, 'janitor: sweep failed');
+            }
+            finally {
+                this.inFlight = false;
+            }
+        };
+        this.timer = setInterval(() => {
+            void sweep();
+        }, this.intervalMs);
+        // Don't keep the daemon alive on the timer alone.
+        this.timer.unref();
+    }
+    /** Stop periodic sweeps. Idempotent. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** Run one sweep on demand. Useful for tests and manual triggering. */
+    async runSweep() {
+        const owned = this.getOwnedPids();
+        const listed = await this.listProcesses();
+        const myPid = process.pid;
+        if (listed === null) {
+            // A sweep that could not look is not a sweep that found nothing. Both
+            // used to produce the same metrics and the same silence, so a janitor
+            // disabled for hours was indistinguishable from a tidy machine.
+            this.consecutiveSkips += 1;
+            // The first skip is noise; a run of them is a janitor that has stopped
+            // working, and the number is what makes that visible.
+            const level = this.consecutiveSkips >= 5 ? 'error' : 'warn';
+            this.logger?.[level]?.({ consecutiveSkips: this.consecutiveSkips, intervalMs: this.intervalMs }, this.consecutiveSkips >= 5
+                ? 'janitor: has not completed a sweep in several attempts — orphaned workers are not being reaped'
+                : 'janitor: sweep skipped, could not read the process table');
+            const skipped = {
+                scannedAt: new Date(),
+                swept: false,
+                forkWorkersAlive: 0,
+                ownedPids: owned.size,
+                orphansFound: 0,
+                orphansKilled: 0,
+                killErrors: 0,
+            };
+            this.onMetrics?.(skipped);
+            return skipped;
+        }
+        this.consecutiveSkips = 0;
+        const all = listed;
+        const orphans = all.filter((row) => {
+            // Owned by the orchestrator → not an orphan.
+            if (owned.has(row.pid))
+                return false;
+            // Newly-spawned workers that haven't yet finished startup are
+            // NOT yet in supervisor.getChildNames() — guard them with a
+            // minimum-age threshold so the janitor doesn't kill them in
+            // mid-init.
+            if (row.elapsedSeconds < this.minProcessAgeSeconds)
+                return false;
+            // Process whose parent is THIS daemon, but the daemon doesn't
+            // claim it → orphan from a partial restart.
+            if (row.ppid === myPid)
+                return true;
+            // Process adopted by the reaper (parent is gone) → orphan from a
+            // previous daemon that died. Reap it.
+            //
+            // This read `!this.isAlive(row.ppid)` and could therefore never fire.
+            // The two halves of this janitor disagreed about what an orphan is:
+            // `coldStartSweep` was corrected to test the reaper pid and this was
+            // left behind, so the branch its own comment describes was unreachable
+            // here for as long as the daemon ran. Measured 2026-09-14 minutes after
+            // a restart: a `fork-worker.js` with `ppid = 1`, five minutes old,
+            // surveyed by every sweep and reaped by none.
+            if (this.hasDeadParent(row))
+                return true;
+            // Some other parent — not ours, leave alone.
+            return false;
+        });
+        let killed = 0;
+        let killErrors = 0;
+        if (orphans.length > 0) {
+            this.logger?.warn?.({ count: orphans.length, pids: orphans.slice(0, 10).map((r) => r.pid) }, 'janitor: orphan fork-workers detected');
+            const result = await this.reap(orphans.map((r) => r.pid));
+            killed = result;
+            killErrors = orphans.length - result;
+        }
+        const metrics = {
+            scannedAt: new Date(),
+            swept: true,
+            forkWorkersAlive: all.length,
+            ownedPids: owned.size,
+            orphansFound: orphans.length,
+            orphansKilled: killed,
+            killErrors,
+        };
+        this.onMetrics?.(metrics);
+        return metrics;
+    }
+    /**
+     * Whether this row's parent is gone.
+     *
+     * One statement, used by both sweeps, because they have already disagreed
+     * about it once: when a parent dies its children are REPARENTED — to
+     * launchd on macOS, to init or a subreaper elsewhere — so an orphan's
+     * `ppid` becomes 1, and pid 1 is alive on every running system. Asking
+     * `isAlive(ppid)` therefore answers "the parent is fine" for precisely the
+     * processes both sweeps exist to reap, and the liveness test is kept only
+     * for the case where a ppid points at something that really has vanished
+     * without reparenting.
+     */
+    hasDeadParent(row) {
+        return row.ppid === REAPER_PID || !this.isAlive(row.ppid);
+    }
+    /**
+     * SIGTERM all pids → wait `gracefulMs` → SIGKILL any survivor.
+     * Returns the number of pids successfully terminated (including
+     * those killed forcefully).
+     */
+    /**
+     * SIGTERM, a grace period, then SIGKILL for whatever is still there.
+     *
+     * Three things this used to get wrong, and all three were invisible:
+     *
+     *  - **A process was counted twice.** One that answered `ESRCH` to SIGTERM
+     *    (already gone) scored a success, and then scored a second one in the
+     *    SIGKILL pass for not being alive. `Math.min(success, pids.length)` at
+     *    the end hid it — for the BATCH, not per process: one double-count plus
+     *    one process that genuinely refused to die still clamped to "all
+     *    reaped". A clamp is not a count.
+     *  - **SIGKILL was assumed to have worked.** Success was recorded when the
+     *    signal was SENT. A process that does not die is exactly the one worth
+     *    knowing about, and it was the one that reported success.
+     *  - **The escalation was silent.** Measured 2026-09-14: every orphan
+     *    holding a port ignored SIGTERM and needed SIGKILL. "Died politely" and
+     *    "had to be killed" produced identical logs, so the fact that these
+     *    processes do not respond to TERM could not be learned from the record.
+     */
+    async reap(pids) {
+        const pending = [];
+        for (const pid of pids) {
+            try {
+                this.kill(pid, 'SIGTERM');
+                pending.push(pid);
+            }
+            catch (err) {
+                const e = err;
+                if (e.code !== 'ESRCH') {
+                    // Not "already gone" — a permission problem, most likely. It will
+                    // not die on SIGKILL either, so it is not pending.
+                    this.logger?.warn?.({ pid, err }, 'janitor: SIGTERM failed');
+                }
+            }
+        }
+        if (pending.length === 0)
+            return pids.length;
+        await wait(this.gracefulMs);
+        const stubborn = pending.filter((pid) => this.isAlive(pid));
+        if (stubborn.length > 0) {
+            this.logger?.warn?.({ pids: stubborn.slice(0, 10), gracefulMs: this.gracefulMs }, 'janitor: processes ignored SIGTERM — escalating to SIGKILL');
+        }
+        for (const pid of stubborn) {
+            try {
+                this.kill(pid, 'SIGKILL');
+            }
+            catch (err) {
+                const e = err;
+                if (e.code !== 'ESRCH')
+                    this.logger?.error?.({ pid, err }, 'janitor: SIGKILL failed');
+            }
+        }
+        // Confirm. A signal sent is not a process gone.
+        //
+        // Polled rather than checked once. SIGKILL is delivered immediately but
+        // the process is not reaped until the kernel can tear it down, and one in
+        // uninterruptible sleep — blocked on disk, which is the state a machine
+        // under load puts them in — takes longer than any single sample. The
+        // first version waited 500 ms and then reported at ERROR level that the
+        // process had "survived SIGKILL"; observed 2026-09-14 on a pid that was
+        // gone moments later. An alarm that fires on a normal delay teaches its
+        // reader to disregard the case it exists to report.
+        const survivors = await this.awaitDeath(stubborn);
+        if (survivors.length > 0) {
+            this.logger?.error?.({ pids: survivors.slice(0, 10), waitedMs: KILL_CONFIRM_TIMEOUT_MS }, 'janitor: processes survived SIGKILL — still holding whatever they hold');
+        }
+        return pids.length - survivors.length;
+    }
+    /**
+     * Wait for killed pids to leave the process table, up to a deadline.
+     * Returns whichever are still there when it expires.
+     */
+    async awaitDeath(pids) {
+        if (pids.length === 0)
+            return [];
+        const deadline = Date.now() + KILL_CONFIRM_TIMEOUT_MS;
+        let remaining = pids;
+        while (remaining.length > 0 && Date.now() < deadline) {
+            await wait(KILL_CONFIRM_POLL_MS);
+            remaining = remaining.filter((pid) => this.isAlive(pid));
+        }
+        return remaining;
+    }
+}
+// ---------------------------------------------------------------------------
+// Process-table helpers (production defaults)
+// ---------------------------------------------------------------------------
+/**
+ * The pid a dead parent's children are handed to.
+ *
+ * 1 on every Unix this runs on — launchd on macOS, init or a subreaper
+ * elsewhere. A `fork-worker.js` parented here was started by a daemon that no
+ * longer exists.
+ */
+const REAPER_PID = 1;
+/** How long the janitor waits for `ps` before giving up on a sweep. */
+/**
+ * How long `ps` may take.
+ *
+ * This was ten seconds, and `ps -eo pid,ppid,etime,args` over a thousand
+ * processes takes 0.07. The deadline was not protecting against a slow `ps`;
+ * it was firing because the DAEMON'S event loop was too busy to read the
+ * result, and `execFile`'s timer — also on that loop — eventually killed a
+ * process that had already finished.
+ *
+ * Measured on the development host: 990 sweeps killed their own `ps` and
+ * skipped, while 36 fork-workers accumulated as children of a daemon that
+ * claimed none of them. The janitor stops working exactly when the machine
+ * is loaded, which is exactly when orphans appear.
+ *
+ * Sixty seconds is protection against a `ps` that genuinely hangs — an NFS
+ * mount, a wedged process table — and not against a control plane doing
+ * its job. It is a third of the sweep interval, so a slow sweep still
+ * finishes before the next one starts.
+ */
+const PS_TIMEOUT_MS = 60_000;
+/** How long a SIGKILLed process is given to actually leave the process table. */
+const KILL_CONFIRM_TIMEOUT_MS = 5_000;
+/** How often that is rechecked. */
+const KILL_CONFIRM_POLL_MS = 100;
+/**
+ * `ps`, asynchronously and with a deadline.
+ *
+ * This was `execSync('ps -eo …')` with no timeout, called from a 30-second
+ * `setInterval` on the daemon's own event loop. A synchronous spawn blocks
+ * that loop completely: while it runs the daemon answers no RPC, writes no
+ * log line, and services no socket. With no timeout, "while it runs" has no
+ * upper bound.
+ *
+ * That is not hypothetical. Observed 2026-09-14 on the development daemon:
+ * the main thread parked in `SyncProcessRunner::Spawn`, reached from
+ * `Environment::RunTimers`, for eight minutes and counting — `omnitron ping`,
+ * `omnitron ls` and every console request hung, the log stopped mid-second,
+ * and the seventeen supervised app processes ran on with nothing watching
+ * them. One `ps` that does not return takes the entire control plane with it.
+ *
+ * Asynchronous, so a slow `ps` costs a sweep rather than the daemon; and
+ * timed out, so it costs a bounded one.
+ */
+function runPs() {
+    return new Promise((resolve, reject) => {
+        execFile('ps', ['-eo', 'pid,ppid,etime,args'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024, timeout: PS_TIMEOUT_MS, killSignal: 'SIGKILL' }, (err, stdout) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stdout);
+        });
+    });
+}
+/**
+ * Walk `ps -eo pid,ppid,etime,args` and pick rows whose command
+ * path contains `titan-pm/dist/fork-worker.js`. We match on the path
+ * substring rather than the basename so we don't catch unrelated
+ * `fork-worker.js` files belonging to other tools.
+ *
+ * `etime` is the formatted elapsed-time field, available on both
+ * Linux and macOS (unlike `etimes` which is Linux-only). Format:
+ *   `MM:SS`            — under an hour
+ *   `HH:MM:SS`         — under a day
+ *   `DD-HH:MM:SS`      — multi-day
+ * Parsed to seconds in `parseEtime` below — used to protect newly-
+ * spawned workers from the orphan reaper while their
+ * supervisor.getChildNames() is still empty.
+ */
+async function listForkWorkersFromPs(logger) {
+    let raw;
+    try {
+        raw = await runPs();
+    }
+    catch (err) {
+        // A `ps` that was KILLED for exceeding the deadline and one that failed
+        // in a millisecond are the same empty result and, without this, the same
+        // log line — so the condition that used to hang the daemon would leave
+        // no trace that it had happened at all. `killed` is what `execFile` sets
+        // when its own timeout fires.
+        const e = err;
+        if (e.killed) {
+            logger?.error?.({ timeoutMs: PS_TIMEOUT_MS }, 'janitor: ps exceeded its deadline and was killed — sweep skipped');
+        }
+        else {
+            logger?.warn?.({ err: e.message }, 'janitor: ps failed');
+        }
+        // `null`, not `[]`. An empty list is an answer — "nothing is running" —
+        // and returning it for a sweep that could not look reported 990 clean
+        // sweeps on a host where 36 fork-workers were accumulating.
+        return null;
+    }
+    const rows = [];
+    for (const line of raw.split('\n')) {
+        if (!line.includes('titan-pm/dist/fork-worker.js'))
+            continue;
+        const trimmed = line.trim();
+        // pid, ppid, etime (no whitespace), then args
+        const match = /^(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(trimmed);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const ppid = Number(match[2]);
+        const elapsedSeconds = parseEtime(match[3] ?? '0');
+        const command = match[4] ?? '';
+        if (!Number.isFinite(pid) || !Number.isFinite(ppid))
+            continue;
+        // Don't include the daemon itself if it somehow matched.
+        if (pid === process.pid)
+            continue;
+        rows.push({ pid, ppid, command, elapsedSeconds });
+    }
+    return rows;
+}
+/**
+ * Parse ps's `etime` format → seconds.
+ * Supported shapes:
+ *   `SS`          — seconds (rare; some ps variants emit on first second)
+ *   `MM:SS`       — minutes + seconds
+ *   `HH:MM:SS`    — hours + minutes + seconds
+ *   `DD-HH:MM:SS` — days + hours + minutes + seconds
+ */
+function parseEtime(raw) {
+    if (!raw)
+        return 0;
+    let days = 0;
+    let rest = raw;
+    const dashIdx = rest.indexOf('-');
+    if (dashIdx >= 0) {
+        days = Number(rest.slice(0, dashIdx)) || 0;
+        rest = rest.slice(dashIdx + 1);
+    }
+    const parts = rest.split(':').map((p) => Number(p) || 0);
+    let total = days * 86400;
+    if (parts.length === 1)
+        total += parts[0];
+    else if (parts.length === 2)
+        total += parts[0] * 60 + parts[1];
+    else if (parts.length === 3)
+        total += parts[0] * 3600 + parts[1] * 60 + parts[2];
+    return total;
+}
+// Thin delegate to the shared helper in @omnitron-dev/titan/utils.
+// Kept as a named local so `__test__` exports continue to point at
+// a callable, but the actual liveness logic (EPERM-as-alive,
+// invalid-pid-as-dead) lives in exactly one place across the
+// monorepo now.
+function defaultIsAlive(pid) {
+    return isProcessAlive(pid);
+}
+// Re-exported for tests — same logic without the spawning side effects.
+export const __test__ = { listForkWorkersFromPs, defaultIsAlive, parseEtime };
+//# sourceMappingURL=process-janitor.js.map

package/dist/orchestrator/process-janitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-janitor.js","sourceRoot":"","sources":["../../src/orchestrator/process-janitor.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator/ps-metrics.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reading `ps` output.
+ *
+ * Two things live here that were previously inline and inconsistent between
+ * the batch path and the single-pid path:
+ *
+ * **Parsing.** `ps -o pid=,rss=,%cpu=` prints fixed columns, but a pid that
+ * has exited between the query and the read prints nothing, and a `ps` under
+ * memory pressure can print a partial line. `parseFloat('')` is `NaN`, and a
+ * NaN CPU reading renders as `NaN%` in the console and poisons any total it
+ * is summed into.
+ *
+ * **What failure means.** The batch path left its map empty on error, with a
+ * comment saying "no reading is honest, a zero reading is not". The
+ * single-pid path — used for every classic-mode app — returned
+ * `{ cpu: 0, memory: 0 }` on exactly the same failure, and the caller
+ * overwrote `handle.lastMetrics` with it. So a `ps` that timed out under
+ * load made a running app read as idle, indistinguishable from one that
+ * genuinely is. The two paths now agree: absence is `null`.
+ */
+export interface ProcessSample {
+    cpu: number;
+    memory: number;
+}
+/**
+ * Parse one `ps` line of the form `<pid> <rss-kb> <cpu-percent>`.
+ *
+ * @returns null when the line does not carry all three fields as numbers —
+ *          a partial line is not a zero reading.
+ */
+export declare function parsePsLine(line: string): {
+    pid: number;
+    sample: ProcessSample;
+} | null;
+/** Parse the whole of a `ps` batch response. Unreadable lines are skipped. */
+export declare function parsePsBatch(output: string): Map<number, ProcessSample>;
+//# sourceMappingURL=ps-metrics.d.ts.map

package/dist/orchestrator/ps-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-metrics.d.ts","sourceRoot":"","sources":["../../src/orchestrator/ps-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAAG,IAAI,CAUvF;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAOvE"}

package/dist/orchestrator/ps-metrics.js

@@ -0,0 +1,60 @@
+/**
+ * Reading `ps` output.
+ *
+ * Two things live here that were previously inline and inconsistent between
+ * the batch path and the single-pid path:
+ *
+ * **Parsing.** `ps -o pid=,rss=,%cpu=` prints fixed columns, but a pid that
+ * has exited between the query and the read prints nothing, and a `ps` under
+ * memory pressure can print a partial line. `parseFloat('')` is `NaN`, and a
+ * NaN CPU reading renders as `NaN%` in the console and poisons any total it
+ * is summed into.
+ *
+ * **What failure means.** The batch path left its map empty on error, with a
+ * comment saying "no reading is honest, a zero reading is not". The
+ * single-pid path — used for every classic-mode app — returned
+ * `{ cpu: 0, memory: 0 }` on exactly the same failure, and the caller
+ * overwrote `handle.lastMetrics` with it. So a `ps` that timed out under
+ * load made a running app read as idle, indistinguishable from one that
+ * genuinely is. The two paths now agree: absence is `null`.
+ */
+/**
+ * Parse one `ps` line of the form `<pid> <rss-kb> <cpu-percent>`.
+ *
+ * @returns null when the line does not carry all three fields as numbers —
+ *          a partial line is not a zero reading.
+ */
+export function parsePsLine(line) {
+    const [pidText, rssText, cpuText] = line.trim().split(/\s+/);
+    const pid = Number.parseInt(pidText ?? '', 10);
+    const rssKb = Number.parseInt(rssText ?? '', 10);
+    const cpu = Number.parseFloat(cpuText ?? '');
+    if (!Number.isFinite(pid) || !Number.isFinite(rssKb) || !Number.isFinite(cpu))
+        return null;
+    if (pid <= 0 || rssKb < 0 || cpu < 0)
+        return null;
+    return { pid, sample: { cpu, memory: rssKb * 1024 } };
+}
+/** Parse the whole of a `ps` batch response. Unreadable lines are skipped. */
+export function parsePsBatch(output) {
+    const out = new Map();
+    for (const line of output.split('\n')) {
+        const parsed = parsePsLine(line);
+        if (parsed)
+            out.set(parsed.pid, parsed.sample);
+    }
+    return out;
+}
+/*
+ * The rule that a failed read must not overwrite a known reading — `null` is
+ * not zero — deliberately lives at its two call sites in
+ * orchestrator.service.ts (`sampleAppMetrics`, and the classic branch of the
+ * metrics timer), not in a helper here.
+ *
+ * A `mergeSample(previous, fresh)` helper did sit here, exported and tested,
+ * with no caller: both paths implemented the rule inline and correctly. A
+ * third copy that looks like the canonical one but is reached by nothing is
+ * worse than no helper at all — the next reader adopts it, believes the rule
+ * is now centralised, and the two real sites keep their own.
+ */
+//# sourceMappingURL=ps-metrics.js.map

package/dist/orchestrator/ps-metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-metrics.js","sourceRoot":"","sources":["../../src/orchestrator/ps-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAOH;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7D,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IACjD,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IAE7C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3F,IAAI,GAAG,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAElD,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,EAAE,EAAE,CAAC;AACxD,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,YAAY,CAAC,MAAc;IACzC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAyB,CAAC;IAC7C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,MAAM;YAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;GAWG"}