@omnitron-dev/omnitron 0.1.3 → 0.3.0

package/dist/orchestrator/port-conflict.js

@@ -0,0 +1,131 @@
+/**
+ * Who is holding the port an application could not bind.
+ *
+ * Measured on the development daemon, 06:05:56–06:06:27Z, four times in
+ * thirty-one seconds:
+ *
+ *     Restart failed — Netron service failed to start: listen EADDRINUSE:
+ *     address already in use 0.0.0.0:3005. The application cannot serve RPC,
+ *     so it is not started.
+ *
+ * `omnitron list` then reported the app `crashed, RST 5` with both children
+ * `stopped` and no pid, and `omnitron restart` answered `Max restarts
+ * exceeded`. All of that was true of the daemon's records and none of it was
+ * true of the machine: port 3005 was held by a LIVE process whose parent was
+ * the daemon itself — a child of its own it had stopped accounting for. The
+ * application was serving requests the whole time.
+ *
+ * The failure says which address it could not have. It does not say who has
+ * it, and that one fact is the difference between a three-minute
+ * investigation with `lsof` and a line in the log. Three readings compose
+ * it: the address out of the message, the holder out of the operating
+ * system, and the parent of the holder — because "somebody else's server" and
+ * "my own previous instance" call for opposite responses, and they look
+ * identical from inside the error.
+ *
+ * This module only reads and decides. Killing belongs to the janitor, which
+ * already reaps children the daemon has lost track of — and a holder that is
+ * our own unaccounted child is exactly what that sweep exists for.
+ */
+/**
+ * The address an `EADDRINUSE` refers to, or null when the message is about
+ * something else.
+ *
+ * Node writes `listen EADDRINUSE: address already in use 0.0.0.0:3005`, and
+ * every layer above wraps it in a sentence of its own, so the match is on
+ * the address rather than on the shape of the whole message.
+ */
+export function addressInUse(message) {
+    if (!message.includes('EADDRINUSE'))
+        return null;
+    // `host:port`, where the host may be IPv4, `::`, a bracketed IPv6 or a
+    // path-free empty string in some Node versions.
+    const match = /EADDRINUSE[^0-9[]*(\[[0-9a-fA-F:]+\]|[0-9.]+|::)?:(\d{1,5})\b/.exec(message);
+    if (!match)
+        return null;
+    const port = Number(match[2]);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return null;
+    return { host: match[1] ?? '', port };
+}
+/** What to run to find the listener, per platform. */
+export function holderCommand(port, platform) {
+    if (platform === 'linux') {
+        // `-H` drops the header; `-p` adds `users:(("node",pid=989927,fd=28))`.
+        return { file: 'ss', args: ['-ltnpH', `sport = :${port}`] };
+    }
+    // `-F` is lsof's machine-readable mode: one field per line, tagged.
+    return { file: 'lsof', args: ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-Fpc'] };
+}
+/**
+ * The listeners in that command's output.
+ *
+ * Both formats are parsed here rather than in the caller so that the shapes
+ * are pinned by tests against real output — `lsof -F` emits `p<pid>` and
+ * `c<command>` on separate lines and repeats them per process, and `ss`
+ * carries every listener's holders inside one `users:((...))` group.
+ */
+export function parseHolders(output, platform) {
+    const holders = [];
+    if (platform === 'linux') {
+        for (const m of output.matchAll(/\(\("([^"]+)",pid=(\d+),/g)) {
+            holders.push({ command: m[1], pid: Number(m[2]) });
+        }
+        return holders;
+    }
+    let pid = null;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('p')) {
+            const parsed = Number(line.slice(1));
+            pid = Number.isInteger(parsed) ? parsed : null;
+            continue;
+        }
+        if (line.startsWith('c') && pid !== null) {
+            holders.push({ pid, command: line.slice(1) });
+            pid = null;
+        }
+    }
+    return holders;
+}
+/**
+ * What the holder is to this daemon.
+ *
+ * `ours-unaccounted` is the case the measurement above describes and the only
+ * one where a restart can be made to work without a person: the process is a
+ * child of this daemon and no app handle, pool or process-manager record
+ * claims it, so it is a leftover of a restart that half-failed.
+ */
+export function explainConflict(input) {
+    const { port, holders, parentOf, daemonPid, owned } = input;
+    if (holders.length === 0) {
+        return {
+            kind: 'unknown',
+            because: `nothing is listening on ${port} now — the holder exited between the failure and this reading`,
+        };
+    }
+    const holder = holders[0];
+    const parent = parentOf(holder.pid);
+    if (parent !== daemonPid) {
+        return {
+            kind: 'foreign',
+            holder,
+            because: `port ${port} is held by pid ${holder.pid} (${holder.command}), whose parent is ` +
+                `${parent ?? 'unknown'} — not this daemon. Nothing here will touch it`,
+        };
+    }
+    if (owned.has(holder.pid)) {
+        return {
+            kind: 'ours-owned',
+            holder,
+            because: `port ${port} is held by pid ${holder.pid} (${holder.command}), a child this daemon ` +
+                `still accounts for — the restart raced its own predecessor's shutdown`,
+        };
+    }
+    return {
+        kind: 'ours-unaccounted',
+        holder,
+        because: `port ${port} is held by pid ${holder.pid} (${holder.command}), a child of this daemon ` +
+            `that no app, pool or process-manager record claims — a leftover of a restart that half-failed`,
+    };
+}
+//# sourceMappingURL=port-conflict.js.map

package/dist/orchestrator/port-conflict.js.map

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

package/dist/orchestrator/process-janitor.d.ts

@@ -0,0 +1,227 @@
+/**
+ * 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 type { ILogger } from '@omnitron-dev/titan/module/logger';
+export interface ProcessJanitorOptions {
+    /** Interval between sweeps. Default 30s. */
+    readonly intervalMs?: number;
+    /** Grace period after SIGTERM before SIGKILL. Default 3s. */
+    readonly gracefulMs?: number;
+    /**
+     * Minimum age (seconds) before a process can be classified as
+     * orphan. Protects newly-spawned fork-workers from being reaped
+     * during their startup window — supervisor.getChildNames() doesn't
+     * report a child until `supervisor.start()` resolves, and that can
+     * take 5–30s for apps that connect to DB/Redis/blockchain RPCs.
+     * Without this guard, the janitor would race and kill perfectly
+     * legitimate workers.
+     *
+     * Default 60s — safe envelope for slow init paths.
+     */
+    readonly minProcessAgeSeconds?: number;
+    /** Logger for diagnostics. */
+    readonly logger?: ILogger;
+    /**
+     * Returns the set of OS pids the orchestrator considers owned.
+     * The janitor calls this each sweep — must be cheap.
+     */
+    readonly getOwnedPids: () => ReadonlySet<number>;
+    /**
+     * Optional metric sink. The reaper calls this on each sweep so a
+     * Prometheus exporter (C10) can plot orphan counts.
+     */
+    readonly onMetrics?: (m: JanitorSweepMetrics) => void;
+    /**
+     * Override for the process listing (tests). Real implementation
+     * shells out to `ps -eo pid,ppid,args` and filters for fork-worker
+     * paths.
+     */
+    /**
+     * How to read the process table.
+     *
+     * `null` means the table could not be read — distinct from `[]`, which
+     * means it was read and holds no fork-workers. The two used to be one
+     * value and therefore one set of metrics, so a janitor that had not
+     * completed a sweep in hours reported clean ones.
+     */
+    readonly listProcesses?: () => readonly PsRow[] | null | Promise<readonly PsRow[] | null>;
+    /**
+     * How a process is signalled. Defaults to `process.kill`.
+     *
+     * Injectable because a janitor whose kill cannot be intercepted cannot be
+     * tested without killing: a test naming a pid it believes is imaginary
+     * sends a real signal to whatever holds that number on the machine
+     * running the suite. That is not hypothetical — it happened while writing
+     * the tests for this file, to a process holding a port on a live stand,
+     * and this repository has a previous incident of the same shape where a
+     * unit test reached `coldStartSweep` and killed six backends.
+     *
+     * A seam here makes the dangerous path unreachable from a test by
+     * construction, rather than by every future test remembering.
+     */
+    readonly kill?: (pid: number, signal: NodeJS.Signals) => void;
+    /**
+     * Override for the liveness probe (tests). Real implementation
+     * uses `process.kill(pid, 0)`.
+     */
+    readonly isAlive?: (pid: number) => boolean;
+}
+export interface PsRow {
+    readonly pid: number;
+    readonly ppid: number;
+    readonly command: string;
+    /** Seconds since process started (etimes from ps). 0 if unknown. */
+    readonly elapsedSeconds: number;
+}
+export interface JanitorSweepMetrics {
+    readonly scannedAt: Date;
+    /**
+     * False when `ps` could not be read at all.
+     *
+     * Without this a failed sweep reported `forkWorkersAlive: 0`, `orphansFound:
+     * 0` — a measurement of nothing, indistinguishable from a machine with
+     * nothing to reap. Measured on the development host: 990 sweeps skipped
+     * and every one of them recorded as a clean one.
+     */
+    readonly swept: boolean;
+    readonly forkWorkersAlive: number;
+    readonly ownedPids: number;
+    readonly orphansFound: number;
+    readonly orphansKilled: number;
+    readonly killErrors: number;
+}
+export declare class ProcessJanitor {
+    private readonly intervalMs;
+    private readonly gracefulMs;
+    private readonly minProcessAgeSeconds;
+    /** Sweeps that could not read the process table, in a row. */
+    private consecutiveSkips;
+    private readonly logger;
+    private readonly onMetrics;
+    private readonly getOwnedPids;
+    private readonly listProcesses;
+    private readonly kill;
+    private readonly isAlive;
+    private timer;
+    private inFlight;
+    constructor(options: ProcessJanitorOptions);
+    /**
+     * 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.
+     */
+    coldStartSweep(): Promise<number>;
+    /** Begin periodic sweeps. Idempotent. */
+    start(): void;
+    /** Stop periodic sweeps. Idempotent. */
+    stop(): void;
+    /** Run one sweep on demand. Useful for tests and manual triggering. */
+    runSweep(): Promise<JanitorSweepMetrics>;
+    /**
+     * 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.
+     */
+    private hasDeadParent;
+    /**
+     * 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.
+     */
+    private reap;
+    /**
+     * Wait for killed pids to leave the process table, up to a deadline.
+     * Returns whichever are still there when it expires.
+     */
+    private awaitDeath;
+}
+/**
+ * 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.
+ */
+declare function listForkWorkersFromPs(logger?: ILogger): Promise<PsRow[] | null>;
+/**
+ * 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
+ */
+declare function parseEtime(raw: string): number;
+declare function defaultIsAlive(pid: number): boolean;
+export declare const __test__: {
+    listForkWorkersFromPs: typeof listForkWorkersFromPs;
+    defaultIsAlive: typeof defaultIsAlive;
+    parseEtime: typeof parseEtime;
+};
+export {};
+//# sourceMappingURL=process-janitor.d.ts.map

package/dist/orchestrator/process-janitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-janitor.d.ts","sourceRoot":"","sources":["../../src/orchestrator/process-janitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAGjE,MAAM,WAAW,qBAAqB;IACpC,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,8BAA8B;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC;IACjD;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACtD;;;;OAIG;IACH;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,SAAS,KAAK,EAAE,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IAE1F;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC;IAC9D;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC7C;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiD;IAC3E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;IACzD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmE;IACjG,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgD;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAEnD,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,QAAQ,CAAS;IAEzB,YAAY,OAAO,EAAE,qBAAqB,EAUzC;IAED;;;;;;;OAOG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAuDtC;IAED,yCAAyC;IACzC,KAAK,IAAI,IAAI,CAkBZ;IAED,wCAAwC;IACxC,IAAI,IAAI,IAAI,CAKX;IAED,uEAAuE;IACjE,QAAQ,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAoF7C;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;OAIG;IACH;;;;;;;;;;;;;;;;;;OAkBG;YACW,IAAI;IA0DlB;;;OAGG;YACW,UAAU;CAUzB;AA2ED;;;;;;;;;;;;;;GAcG;AACH,iBAAe,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAyC9E;AAED;;;;;;;GAOG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAevC;AAOD,iBAAS,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5C;AAGD,eAAO,MAAM,QAAQ;;;;CAAwD,CAAC"}