@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/utils/process.js

@@ -1,593 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { spawn } from 'node:child_process';
-import { constants as osConstants } from 'node:os';
-import { StringDecoder } from 'node:string_decoder';
-import { ExecTimeoutError } from '../errors/base.js';
-import { buildChildEnv } from './child-env.js';
-import { toError } from './errors.js';
-import { dispatchCompleteLines } from './line-dispatch.js';
-import { killProcessTree, sweepProcessGroup } from './process-group.js';
-// 50 MB cap per stream to prevent OOM. Large toolchain builds (e.g. Firefox, Chromium)
-// can easily blow past this, so we truncate rather than let the buffer grow unbounded.
-// Callers for whom truncation is unacceptable (e.g. the archive-safety preflight
-// scanning a full `tar -tvf` listing) must check `wasTruncated` and fail hard.
-const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
-function createStreamCollector(mirror) {
-    const chunks = [];
-    let totalLength = 0;
-    let truncated = false;
-    // A per-stream StringDecoder keeps multibyte UTF-8 characters split across
-    // pipe chunk boundaries intact. Per-chunk `Buffer.toString()` turned a
-    // straddling character into two U+FFFD replacement chars, which silently
-    // broke regex matching over captured output (smoke-run allowlists, mach
-    // error hints) whenever a non-ASCII path or localized message landed on a
-    // 64 KB chunk boundary.
-    const decoder = new StringDecoder('utf8');
-    return {
-        onData: (data) => {
-            const chunk = decoder.write(data);
-            if (chunk.length === 0)
-                return;
-            mirror?.write(chunk);
-            if (truncated)
-                return;
-            const remaining = MAX_OUTPUT_SIZE - totalLength;
-            if (chunk.length > remaining) {
-                chunks.push(chunk.slice(0, remaining));
-                chunks.push('\n[truncated — output exceeded 50 MB]');
-                totalLength = MAX_OUTPUT_SIZE;
-                truncated = true;
-            }
-            else {
-                chunks.push(chunk);
-                totalLength += chunk.length;
-            }
-        },
-        getText: () => chunks.join(''),
-        wasTruncated: () => truncated,
-    };
-}
-function buildSignalFromTimeout(timeout) {
-    if (timeout === undefined)
-        return undefined;
-    return AbortSignal.timeout(timeout);
-}
-/**
- * Maps a child-process `error` event to the rejection the caller sees.
- * When the caller set a `timeout` and the error is the AbortError produced
- * by `AbortSignal.timeout` firing, rejects with a typed
- * {@link ExecTimeoutError} naming the command and budget instead of Node's
- * opaque `AbortError: The operation was aborted`.
- */
-function toExecRejection(error, command, args, timeout, output) {
-    if (timeout !== undefined && error.name === 'AbortError') {
-        return new ExecTimeoutError(command, args, timeout, error, output);
-    }
-    return error;
-}
-/**
- * Snapshot of what two collectors hold, for carrying onto a timeout
- * rejection. Without it a `git add -A` killed at its budget rejected with
- * nothing but the budget: the partial stdout/stderr that said what git was
- * doing when it died was already collected and simply dropped.
- */
-function collectedOutput(out, err) {
-    return {
-        stdout: out.getText(),
-        stderr: err.getText(),
-        truncated: out.wasTruncated() || err.wasTruncated(),
-    };
-}
-/** A child's exit code, with a signal death mapped to 128 + its number. */
-export function exitCodeFromClose(code, signal) {
-    if (code !== null) {
-        return code;
-    }
-    if (signal) {
-        const signalNumber = osConstants.signals[signal];
-        if (typeof signalNumber === 'number') {
-            return 128 + signalNumber;
-        }
-    }
-    return 1;
-}
-/**
- * Executes a command and returns its output.
- * @param command - Command to execute
- * @param args - Command arguments
- * @param options - Execution options
- * @returns Execution result with stdout, stderr, and exit code
- */
-export async function exec(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            env: buildChildEnv(options),
-            stdio: ['ignore', 'pipe', 'pipe'],
-            signal: buildSignalFromTimeout(options.timeout),
-        });
-        const out = createStreamCollector();
-        const err = createStreamCollector();
-        child.stdout.on('data', out.onData);
-        child.stderr.on('data', err.onData);
-        child.on('error', (error) => {
-            reject(toExecRejection(error, command, args, options.timeout, collectedOutput(out, err)));
-        });
-        child.on('close', (code, signal) => {
-            resolve({
-                stdout: out.getText(),
-                stderr: err.getText(),
-                exitCode: exitCodeFromClose(code, signal),
-                stdoutTruncated: out.wasTruncated(),
-                stderrTruncated: err.wasTruncated(),
-            });
-        });
-    });
-}
-/**
- * The shared body of every spawn wrapper that outlives its call: detach
- * decision, shutdown forwarding, closure tracking, process-group sweep and
- * typed timeout rejection.
- *
- * `execStream`, `execInherit` and `execInheritCapture` each hand-rolled this
- * sequence, and the copies drifted: `execStream` was the one that omitted
- * {@link trackChildClosure}, so the bin signal handler did not wait for
- * `runMachStream`'s children on Ctrl+C and the forwarder's SIGTERM → grace →
- * SIGKILL escalation could not finish before the parent exited. That was the
- * exact failure the tracking set was introduced to fix, left unwired in one
- * copy. Keeping the sequence in one place is what stops that recurring.
- *
- * `exec` deliberately stays outside: it neither forwards signals nor tracks
- * closure, because it is for short-lived helpers that no one Ctrl+Cs through.
- * `execSmokeRun` also stays outside: its deadline owns the SIGTERM → grace →
- * SIGKILL escalation directly, so it shares no forwarder with the others.
- *
- * @param spec - The variant's stdio, stream wiring, grace budget and result shape
- * @returns Whatever `spec.result` builds from the child's `close` event
- */
-async function spawnTracked(spec) {
-    const { command, args, options } = spec;
-    return new Promise((resolve, reject) => {
-        const usesProcessGroup = options.processGroup === true && process.platform !== 'win32';
-        const child = spec.spawnChild({
-            cwd: options.cwd,
-            env: buildChildEnv(options),
-            signal: buildSignalFromTimeout(options.timeout),
-            detached: usesProcessGroup,
-        });
-        const groupPid = usesProcessGroup ? child.pid : undefined;
-        if (groupPid !== undefined)
-            options.onProcessGroup?.(groupPid);
-        spec.attach?.(child);
-        // Group-aware kills route to the whole tree. A non-group child is killed
-        // directly by the forwarder's own `child.kill`.
-        const killTarget = options.processGroup === true
-            ? (signal) => {
-                killProcessTree(child, signal, usesProcessGroup);
-            }
-            : undefined;
-        const forwarder = spec.forwardWithoutProcessGroup || options.processGroup === true
-            ? installGracefulShutdownForwarder(child, spec.graceMs, killTarget)
-            : undefined;
-        const closure = trackChildClosure();
-        let rejection;
-        child.on('error', (error) => {
-            // Abort/startup failure: make sure a partially-started tree does not
-            // outlive the dispatch (a mach dying at startup would otherwise strand
-            // multiprocessing workers).
-            if (options.processGroup === true) {
-                killProcessTree(child, 'SIGKILL', usesProcessGroup);
-            }
-            // An abort emits error before close. Keep the dispatch tracked until
-            // the child closes and both teardown sweeps finish, including on timeout.
-            rejection = toExecRejection(error, command, args, options.timeout, spec.rejectionOutput?.());
-        });
-        child.on('close', (code, signal) => {
-            forwarder?.dispose();
-            const finish = () => {
-                closure.settle();
-                if (rejection)
-                    reject(rejection);
-                else {
-                    try {
-                        resolve(spec.result(code, signal));
-                    }
-                    catch (error) {
-                        reject(toError(error));
-                    }
-                }
-            };
-            // Group sweep first (it takes the helpers that stayed in the group),
-            // then the caller's own sweep (the ones that did not), then settle.
-            const callerSweep = () => {
-                const sweep = options.postCloseSweep;
-                if (sweep === undefined) {
-                    finish();
-                    return;
-                }
-                Promise.resolve().then(sweep).then(finish, finish);
-            };
-            if (groupPid !== undefined) {
-                sweepProcessGroup(groupPid).then(callerSweep, callerSweep);
-            }
-            else {
-                callerSweep();
-            }
-        });
-    });
-}
-/**
- * Executes a command and streams its output.
- * @param command - Command to execute
- * @param args - Command arguments
- * @param options - Execution options
- * @returns Exit code of the process
- */
-export async function execStream(command, args, options = {}) {
-    return spawnTracked({
-        command,
-        args,
-        options,
-        graceMs: 1500,
-        // A detached group leader does not receive the terminal's Ctrl+C, so
-        // the forwarder is mandatory (not just graceful-UX) when processGroup
-        // is set. A plain streamed child does not get one.
-        forwardWithoutProcessGroup: false,
-        spawnChild: (base) => spawn(command, args, { ...base, stdio: ['ignore', 'pipe', 'pipe'] }),
-        attach: (child) => {
-            const stdoutDecoder = new StringDecoder('utf8');
-            const stderrDecoder = new StringDecoder('utf8');
-            child.stdout.on('data', (data) => {
-                const chunk = stdoutDecoder.write(data);
-                if (chunk.length > 0)
-                    options.onStdout?.(chunk);
-            });
-            child.stderr.on('data', (data) => {
-                const chunk = stderrDecoder.write(data);
-                if (chunk.length > 0)
-                    options.onStderr?.(chunk);
-            });
-        },
-        result: exitCodeFromClose,
-    });
-}
-/**
- * Close-promises of children whose shutdown the CLI must wait for when a
- * termination signal arrives. A bin signal handler that calls `process.exit`
- * within a microtask of the first Ctrl+C makes `execInherit`'s documented
- * SIGTERM → grace → SIGKILL escalation unreachable: the parent is gone
- * before the 1500 ms grace timer can fire, so a hung Firefox is orphaned
- * forever instead of being SIGKILLed and a healthy one loses its
- * AsyncShutdown flush window.
- */
-const activeChildClosures = new Set();
-/**
- * Registers a child with {@link waitForActiveChildShutdown}.
- *
- * Exported for the one legitimate spawn outside this module:
- * `core/marionette-preflight.ts` keeps its own `spawn` because it needs the
- * live `ChildProcess` mid-run, returns while the child is still running, and
- * aborts on a TCP byte rather than a deadline, none of which any wrapper
- * here can express. It still needs the shutdown contract, and a second
- * hand-rolled copy is what lets a Ctrl+C orphan the whole mach → Firefox
- * tree.
- */
-/**
- * Registers a child whose shutdown {@link waitForActiveChildShutdown} must
- * wait for, and returns the handle that deregisters it.
- *
- * @returns `settle()`. Call after child closure and required teardown finish.
- *   An abort's `error` event does not prove closure; do not settle there.
- *   A failed start may settle when no live child or teardown remains.
- */
-export function trackChildClosure() {
-    let resolveClosed;
-    const closed = new Promise((resolve) => {
-        resolveClosed = resolve;
-    });
-    activeChildClosures.add(closed);
-    return {
-        settle: () => {
-            resolveClosed?.();
-            activeChildClosures.delete(closed);
-        },
-    };
-}
-/**
- * Waits (bounded) for every tracked child process to close. Called by the
- * bin signal handler after forwarding SIGINT/SIGTERM, so the parent stays
- * alive long enough for the grace-then-SIGKILL escalation to actually run.
- * Resolves immediately when no children are active.
- */
-export async function waitForActiveChildShutdown(timeoutMs) {
-    if (activeChildClosures.size === 0)
-        return;
-    await Promise.race([
-        Promise.allSettled([...activeChildClosures]),
-        new Promise((resolve) => {
-            const timer = setTimeout(resolve, timeoutMs);
-            timer.unref();
-        }),
-    ]);
-}
-/**
- * Executes a command and inherits stdio (shows output directly).
- *
- * Graceful shutdown: when the FireForge process receives SIGINT/SIGTERM, the
- * signal is forwarded to the child as SIGTERM and a short grace timer (default
- * 1500ms) runs before escalating to SIGKILL. A second matching signal during
- * the grace period triggers an immediate SIGKILL, matching the usual
- * "hit Ctrl-C again to force-quit" UX. Without this, Firefox's AsyncShutdown
- * / profileBeforeChange blockers (which flush in-memory state to disk) can be
- * racing the OS child-exit path, losing the last few seconds of edits.
- *
- * @param command - Command to execute
- * @param args - Command arguments
- * @param options - Execution options
- * @returns Exit code of the process
- */
-export async function execInherit(command, args, options = {}) {
-    return spawnTracked({
-        command,
-        args,
-        options,
-        graceMs: options.shutdownGraceMs ?? 1500,
-        forwardWithoutProcessGroup: true,
-        spawnChild: (base) => spawn(command, args, { ...base, stdio: 'inherit' }),
-        result: exitCodeFromClose,
-    });
-}
-/**
- * Wires parent-process SIGINT/SIGTERM to a child: first signal → child.kill
- * (SIGTERM) + grace timer. A second matching signal → immediate SIGKILL.
- * Grace timer expiry → SIGKILL. Returns a `dispose()` that clears the
- * listeners and any outstanding timer. Callers must invoke `dispose()` from both the child's
- * `close` and `error` handlers so the process does not accumulate signal
- * listeners across repeated spawns.
- */
-export function installGracefulShutdownForwarder(child, graceMs, killTarget) {
-    let graceTimer;
-    const forwarded = new Set();
-    const sendKill = (signal) => {
-        if (killTarget) {
-            killTarget(signal);
-            return;
-        }
-        child.kill(signal);
-    };
-    const escalate = () => {
-        if (child.exitCode !== null || child.signalCode !== null)
-            return;
-        try {
-            sendKill('SIGKILL');
-        }
-        catch {
-            // Child is already gone, nothing to do.
-        }
-    };
-    const handleSignal = (signal) => {
-        if (forwarded.has(signal)) {
-            // Second receipt of the same signal while still running: escalate now.
-            escalate();
-            return;
-        }
-        forwarded.add(signal);
-        try {
-            sendKill('SIGTERM');
-        }
-        catch {
-            // If the child can't accept SIGTERM (already dead), nothing to do.
-            return;
-        }
-        graceTimer = setTimeout(escalate, graceMs);
-        graceTimer.unref();
-    };
-    const onSigint = () => {
-        handleSignal('SIGINT');
-    };
-    const onSigterm = () => {
-        handleSignal('SIGTERM');
-    };
-    process.on('SIGINT', onSigint);
-    process.on('SIGTERM', onSigterm);
-    const dispose = () => {
-        process.off('SIGINT', onSigint);
-        process.off('SIGTERM', onSigterm);
-        if (graceTimer) {
-            clearTimeout(graceTimer);
-            graceTimer = undefined;
-        }
-    };
-    return { dispose };
-}
-/**
- * Executes a command while inheriting stdin, streaming stdout/stderr live,
- * and capturing the emitted output for diagnostics.
- * @param command - Command to execute
- * @param args - Command arguments
- * @param options - Execution options
- * @returns Execution result with stdout, stderr, and exit code
- */
-export async function execInheritCapture(command, args, options = {}) {
-    const out = createStreamCollector(options.mirror?.stdout ?? process.stdout);
-    const err = createStreamCollector(options.mirror?.stderr ?? process.stderr);
-    return spawnTracked({
-        command,
-        args,
-        options,
-        graceMs: options.shutdownGraceMs ?? 1500,
-        forwardWithoutProcessGroup: true,
-        spawnChild: (base) => spawn(command, args, { ...base, stdio: ['inherit', 'pipe', 'pipe'] }),
-        attach: (child) => {
-            child.stdout.on('data', out.onData);
-            child.stderr.on('data', err.onData);
-        },
-        result: (code, signal) => ({
-            stdout: out.getText(),
-            stderr: err.getText(),
-            exitCode: exitCodeFromClose(code, signal),
-            stdoutTruncated: out.wasTruncated(),
-            stderrTruncated: err.wasTruncated(),
-        }),
-        rejectionOutput: () => collectedOutput(out, err),
-    });
-}
-/**
- * Spawns `command` with `args` in its own process group (POSIX), streams
- * stdout/stderr line-by-line to the caller, enforces a deadline by
- * SIGTERMing the whole group when it elapses, and returns the captured
- * output alongside a `timedOut` flag.
- *
- * Process-group semantics matter here because `mach run` execs a Python
- * wrapper that then forks Firefox, which itself spawns content processes.
- * Sending SIGTERM only to the Python PID leaves an orphan Firefox tree
- * behind. Running the child as a process-group leader (`detached: true`
- * on POSIX) and signalling `-pid` routes the kill to every descendant
- * that inherited the group.
- *
- * Windows fallback: `detached: true` does not create an equivalent group
- * there, so we kill the descendant tree with `taskkill /pid <pid> /T /F`
- * instead. taskkill has no graceful-signal equivalent, so both the deadline
- * and the grace re-invocation are forced kills and Windows children get
- * no shutdown window. This is best-effort and Windows is untested, see
- * README.
- * `child.kill()` is still sent as a direct-child fallback in case
- * taskkill itself is unavailable.
- */
-export async function execSmokeRun(command, args, options) {
-    return new Promise((resolve, reject) => {
-        const usesProcessGroup = process.platform !== 'win32';
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            env: buildChildEnv(options),
-            stdio: ['ignore', 'pipe', 'pipe'],
-            // A new process group on POSIX lets us signal the whole descendant
-            // tree at once, which is essential for mach → python → firefox →
-            // content-process chains. On Windows spawn ignores this for our
-            // purposes and we fall back to a taskkill /T tree kill below.
-            detached: usesProcessGroup,
-        });
-        const out = createStreamCollector(options.mirror?.stdout);
-        const err = createStreamCollector(options.mirror?.stderr);
-        const stdoutLineDecoder = new StringDecoder('utf8');
-        const stderrLineDecoder = new StringDecoder('utf8');
-        let stdoutBuffer = '';
-        let stderrBuffer = '';
-        child.stdout.on('data', (data) => {
-            out.onData(data);
-            stdoutBuffer += stdoutLineDecoder.write(data);
-            stdoutBuffer = dispatchCompleteLines(stdoutBuffer, options.onStdoutLine);
-        });
-        child.stderr.on('data', (data) => {
-            err.onData(data);
-            stderrBuffer += stderrLineDecoder.write(data);
-            stderrBuffer = dispatchCompleteLines(stderrBuffer, options.onStderrLine);
-        });
-        let timedOut = false;
-        let graceTimer;
-        let signalGraceTimer;
-        const signalChildGroup = (signal) => {
-            killProcessTree(child, signal, usesProcessGroup);
-        };
-        const deadlineTimer = setTimeout(() => {
-            timedOut = true;
-            signalChildGroup('SIGTERM');
-            graceTimer = setTimeout(() => {
-                signalChildGroup('SIGKILL');
-            }, options.killGraceMs ?? 10000);
-            graceTimer.unref();
-        }, options.smokeTimeoutMs);
-        deadlineTimer.unref();
-        // Forward parent SIGINT/SIGTERM to the whole child process group. The
-        // smoke child is a group leader (detached), so it does not receive the
-        // terminal's Ctrl+C SIGINT. Without this forwarder, the parent exits
-        // and the entire mach → firefox tree is orphaned. Second signal (or
-        // grace expiry) escalates to a group SIGKILL.
-        const forwardedSignals = new Set();
-        const onParentSignal = (signal) => {
-            if (forwardedSignals.has(signal)) {
-                signalChildGroup('SIGKILL');
-                return;
-            }
-            forwardedSignals.add(signal);
-            signalChildGroup('SIGTERM');
-            signalGraceTimer = setTimeout(() => {
-                signalChildGroup('SIGKILL');
-            }, options.killGraceMs ?? 10000);
-            signalGraceTimer.unref();
-        };
-        const onSigint = () => {
-            onParentSignal('SIGINT');
-        };
-        const onSigterm = () => {
-            onParentSignal('SIGTERM');
-        };
-        process.on('SIGINT', onSigint);
-        process.on('SIGTERM', onSigterm);
-        const closure = trackChildClosure();
-        const cleanupSignalForwarding = () => {
-            process.off('SIGINT', onSigint);
-            process.off('SIGTERM', onSigterm);
-            if (signalGraceTimer)
-                clearTimeout(signalGraceTimer);
-            closure.settle();
-        };
-        child.on('error', (error) => {
-            clearTimeout(deadlineTimer);
-            if (graceTimer)
-                clearTimeout(graceTimer);
-            cleanupSignalForwarding();
-            reject(error);
-        });
-        child.on('close', (code, signal) => {
-            clearTimeout(deadlineTimer);
-            if (graceTimer)
-                clearTimeout(graceTimer);
-            cleanupSignalForwarding();
-            // Flush any remaining partial line (child ended without a trailing newline).
-            if (stdoutBuffer.length > 0)
-                options.onStdoutLine?.(stdoutBuffer);
-            if (stderrBuffer.length > 0)
-                options.onStderrLine?.(stderrBuffer);
-            resolve({
-                stdout: out.getText(),
-                stderr: err.getText(),
-                exitCode: exitCodeFromClose(code, signal),
-                stdoutTruncated: out.wasTruncated(),
-                stderrTruncated: err.wasTruncated(),
-                timedOut,
-            });
-        });
-    });
-}
-/**
- * Finds an executable in the system PATH.
- * @param name - Name of the executable
- * @returns Full path to the executable, or undefined if not found
- */
-export async function findExecutable(name) {
-    const command = process.platform === 'win32' ? 'where' : 'which';
-    try {
-        const result = await exec(command, [name]);
-        if (result.exitCode === 0 && result.stdout.trim()) {
-            // Return the first line (first match)
-            return result.stdout
-                .split(/\r?\n/)
-                .map((line) => line.trim())
-                .find((line) => line.length > 0);
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Checks if an executable exists in the system PATH.
- * @param name - Name of the executable
- * @returns True if the executable exists
- */
-export async function executableExists(name) {
-    const path = await findExecutable(name);
-    return path !== undefined;
-}

package/dist/src/utils/ps-duration.d.ts

@@ -1,31 +0,0 @@
-/**
- * Parser for the duration fields `ps` prints.
- *
- * Two different columns share one grammar, which is why this lives apart
- * from either consumer: `time=` (accumulated CPU) and `etime=` (elapsed
- * wall clock). One parser handles both: a second hand-rolled copy is how
- * the two would drift, and the darwin dialect is the half that is easy to
- * get wrong.
- *
- * Dialects:
- *   - linux `[dd-]hh:mm:ss` (e.g. `26-03:14:12`, `03:14:12`)
- *   - darwin/BSD `mm:ss.cc`, whose minutes field accumulates without
- *     wrapping (e.g. `38412:07.55`)
- *
- * Returns `NaN` for anything else, so callers must treat an unrecognized
- * shape as "unknown" rather than as zero. A browser reported as 0 seconds
- * old would be exactly the wrong attribution.
- */
-/**
- * Parses a `ps` duration field into whole seconds.
- *
- * @param value - Raw field text, e.g. `03:14:12` or `38412:07.55`
- * @returns Seconds, or `NaN` when the shape is not recognized
- */
-export declare function parsePsDuration(value: string): number;
-/**
- * Renders a duration for an operator-facing line: `4s`, `3m12s`, `2h05m`.
- * Returns `undefined` for `NaN`, so a caller can omit the clause entirely
- * rather than print "unknown" noise.
- */
-export declare function formatPsDuration(seconds: number): string | undefined;

package/dist/src/utils/ps-duration.js

@@ -1,70 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Parser for the duration fields `ps` prints.
- *
- * Two different columns share one grammar, which is why this lives apart
- * from either consumer: `time=` (accumulated CPU) and `etime=` (elapsed
- * wall clock). One parser handles both: a second hand-rolled copy is how
- * the two would drift, and the darwin dialect is the half that is easy to
- * get wrong.
- *
- * Dialects:
- *   - linux `[dd-]hh:mm:ss` (e.g. `26-03:14:12`, `03:14:12`)
- *   - darwin/BSD `mm:ss.cc`, whose minutes field accumulates without
- *     wrapping (e.g. `38412:07.55`)
- *
- * Returns `NaN` for anything else, so callers must treat an unrecognized
- * shape as "unknown" rather than as zero. A browser reported as 0 seconds
- * old would be exactly the wrong attribution.
- */
-/**
- * Parses a `ps` duration field into whole seconds.
- *
- * @param value - Raw field text, e.g. `03:14:12` or `38412:07.55`
- * @returns Seconds, or `NaN` when the shape is not recognized
- */
-export function parsePsDuration(value) {
-    const trimmed = value.trim();
-    let days = 0;
-    let rest = trimmed;
-    const dayMatch = /^(\d+)-(.*)$/.exec(trimmed);
-    if (dayMatch) {
-        days = Number(dayMatch[1]);
-        rest = dayMatch[2] ?? '';
-    }
-    const parts = rest.split(':');
-    if (parts.length === 3) {
-        // hh:mm:ss on linux. Seconds may not carry fractions but tolerate them.
-        const [h, m, s] = parts.map(Number);
-        if ([h, m, s].some((n) => Number.isNaN(n)))
-            return NaN;
-        return days * 86400 + (h ?? 0) * 3600 + (m ?? 0) * 60 + (s ?? 0);
-    }
-    if (parts.length === 2) {
-        // mm:ss.cc on darwin. The minutes field accumulates without wrapping.
-        const [m, s] = parts.map(Number);
-        if ([m, s].some((n) => Number.isNaN(n)))
-            return NaN;
-        return days * 86400 + (m ?? 0) * 60 + (s ?? 0);
-    }
-    return NaN;
-}
-/**
- * Renders a duration for an operator-facing line: `4s`, `3m12s`, `2h05m`.
- * Returns `undefined` for `NaN`, so a caller can omit the clause entirely
- * rather than print "unknown" noise.
- */
-export function formatPsDuration(seconds) {
-    if (Number.isNaN(seconds) || seconds < 0)
-        return undefined;
-    if (seconds < 60)
-        return `${Math.floor(seconds)}s`;
-    if (seconds < 3600) {
-        const m = Math.floor(seconds / 60);
-        const s = Math.floor(seconds % 60);
-        return `${m}m${String(s).padStart(2, '0')}s`;
-    }
-    const h = Math.floor(seconds / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    return `${h}h${String(m).padStart(2, '0')}m`;
-}