@kruntime/komputer 0.1.0

package/dist/vprocess.js

@@ -0,0 +1,756 @@
+import { id, now, sleep } from "./utils.js";
+const MAX_CAPTURED_PROCESS_OUTPUT_CHARS = 64 * 1024;
+const MAX_PROCESS_OUTPUT_CHUNK_CHARS = 16 * 1024;
+export class VProcessTable {
+    kstate;
+    sessionId;
+    eventLog;
+    emitEvent;
+    defaultRemote;
+    remoteByName;
+    active;
+    constructor(kstate, sessionId, eventLog, defaultRemote, remoteByName = () => undefined, emitEvent = (event) => eventLog.emit(event)) {
+        this.kstate = kstate;
+        this.sessionId = sessionId;
+        this.eventLog = eventLog;
+        this.emitEvent = emitEvent;
+        this.defaultRemote = defaultRemote;
+        this.remoteByName = remoteByName;
+        this.active = new Map();
+    }
+    processesName() {
+        return 'processes/processes.jsonl';
+    }
+    jobsName() {
+        return 'processes/jobs.jsonl';
+    }
+    stdoutName(vpid) {
+        return `processes/io/${vpid}.stdout.log`;
+    }
+    stderrName(vpid) {
+        return `processes/io/${vpid}.stderr.log`;
+    }
+    async spawnShell(script, { cwd, env, stdin, foreground = true, remote = this.defaultRemote, limits, sandbox } = {}) {
+        if (!remote.shell)
+            throw new Error(`remote ${remote.name} does not provide shell execution`);
+        if (!remote.shell.spawn)
+            return this.execShellWithoutProcess(script, { cwd, env, stdin, foreground, remote, limits, sandbox });
+        const vpid = id('vpid');
+        const jobId = id('job');
+        const pgrp = jobId;
+        const startedAt = now();
+        const proc = await remote.shell.spawn({
+            script,
+            cwd,
+            env,
+            stdin,
+            foreground,
+            limits,
+            sandbox,
+        });
+        const record = {
+            vpid,
+            jobId,
+            pgrp,
+            kind: 'remote',
+            status: 'running',
+            foreground,
+            cwd,
+            argv: ['bash', '-lc', script],
+            remote: { name: remote.name, ref: proc.ref || {}, fencingToken: id('fence') },
+            sandbox: sandbox || proc.sandbox ? { request: sandbox, attestation: proc.sandbox } : undefined,
+            startedAt,
+            restartPolicy: 'never',
+        };
+        const startupFailure = sandboxStartupFailure(sandbox, proc.sandbox);
+        if (startupFailure) {
+            await this.stopUntrustedProcess(remote, proc);
+            const endedAt = now();
+            const failed = {
+                ...record,
+                status: 'failed',
+                endedAt,
+                exitCode: startupFailure.code,
+                signal: startupFailure.signal,
+                error: startupFailure.stderr,
+            };
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), failed);
+            await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId,
+                pgrp,
+                command: script,
+                processIds: [vpid],
+                foreground,
+                status: 'failed',
+                startedAt,
+                endedAt,
+            });
+            return { vpid, jobId, background: false, ...startupFailure };
+        }
+        const startWrites = Promise.all([
+            this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), record),
+            this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId,
+                pgrp,
+                command: script,
+                processIds: [vpid],
+                foreground,
+                status: 'running',
+                startedAt,
+            }),
+        ]);
+        let stdout = '';
+        let stderr = '';
+        let detached = false;
+        const stdoutLimit = outputLimit(limits?.stdoutChars ?? limits?.outputChars);
+        const stderrLimit = outputLimit(limits?.stderrChars ?? limits?.outputChars);
+        const stdoutTask = this.consumeProcessStream(proc.stdout, vpid, 'stdout', startWrites, (text) => { stdout = appendBoundedOutput(stdout, text, stdoutLimit); }, () => detached);
+        const stderrTask = this.consumeProcessStream(proc.stderr, vpid, 'stderr', startWrites, (text) => { stderr = appendBoundedOutput(stderr, text, stderrLimit); }, () => detached);
+        await startWrites;
+        const done = (async () => {
+            const result = enforceSandboxAttestation(sandbox, await proc.done);
+            await Promise.all([stdoutTask, stderrTask]);
+            if (detached)
+                return { code: 0, signal: 'SIGDETACH', stdout: '', stderr: '', sandbox: result.sandbox };
+            const status = result.code === 0 ? 'exited' : 'failed';
+            const endedAt = now();
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), {
+                ...record,
+                sandbox: { ...record.sandbox, attestation: result.sandbox },
+                status,
+                endedAt,
+                exitCode: result.code ?? null,
+                signal: result.signal ?? null,
+            });
+            await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId,
+                pgrp,
+                command: script,
+                processIds: [vpid],
+                foreground,
+                status,
+                startedAt,
+                endedAt,
+            });
+            return {
+                code: result.code ?? 1,
+                signal: result.signal ?? null,
+                stdout: appendBoundedOutput(stdout, result.stdout || '', stdoutLimit),
+                stderr: appendBoundedOutput(stderr, result.stderr || '', stderrLimit),
+                timedOut: result.timedOut,
+                sandbox: result.sandbox,
+            };
+        })();
+        if (!foreground) {
+            this.trackActive(vpid, jobId, {
+                done,
+                detach: () => {
+                    detached = true;
+                    proc.detach?.();
+                    proc.unref?.();
+                },
+            });
+            proc.unref?.();
+            return { vpid, jobId, background: true, code: undefined, done, sandbox: proc.sandbox };
+        }
+        const result = await done;
+        return { vpid, jobId, background: false, ...result };
+    }
+    async spawnVirtual(script, run, { cwd, foreground = true } = {}) {
+        const vpid = id('vpid');
+        const jobId = id('job');
+        const pgrp = jobId;
+        const startedAt = now();
+        const record = {
+            vpid,
+            jobId,
+            pgrp,
+            kind: 'k',
+            status: 'running',
+            foreground,
+            cwd,
+            argv: ['k', script],
+            startedAt,
+            restartPolicy: 'never',
+        };
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), record);
+        await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+            jobId,
+            pgrp,
+            command: script,
+            processIds: [vpid],
+            foreground,
+            status: 'running',
+            startedAt,
+        });
+        const controller = new AbortController();
+        let abortedSignal = null;
+        let detached = false;
+        const done = (async () => {
+            let result;
+            try {
+                result = await run(controller.signal);
+            }
+            catch (error) {
+                if (detached)
+                    return { code: 0, signal: 'SIGDETACH', stdout: '', stderr: '' };
+                result = controller.signal.aborted
+                    ? { code: 130, signal: abortedSignal || 'SIGTERM', stdout: '', stderr: '' }
+                    : { code: 1, signal: null, stdout: '', stderr: error instanceof Error ? error.message : String(error) };
+            }
+            if (detached)
+                return { code: 0, signal: 'SIGDETACH', stdout: '', stderr: '' };
+            if (result.stdout)
+                await this.recordOutput(vpid, 'stdout', result.stdout);
+            if (result.stderr)
+                await this.recordOutput(vpid, 'stderr', result.stderr);
+            const stdout = appendBoundedOutput('', result.stdout);
+            const stderr = appendBoundedOutput('', result.stderr);
+            const code = result.code ?? 0;
+            const status = code === 0 ? 'exited' : 'failed';
+            const endedAt = now();
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), { ...record, status, endedAt, exitCode: code, signal: result.signal ?? null });
+            await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId,
+                pgrp,
+                command: script,
+                processIds: [vpid],
+                foreground,
+                status,
+                startedAt,
+                endedAt,
+            });
+            return { code, signal: result.signal ?? null, stdout, stderr };
+        })();
+        const abort = (signal) => {
+            abortedSignal = signal;
+            controller.abort(new Error(signal));
+        };
+        if (!foreground) {
+            this.trackActive(vpid, jobId, {
+                done,
+                abort,
+                detach: () => {
+                    detached = true;
+                    controller.abort(new Error('detached'));
+                },
+            });
+            return { vpid, jobId, background: true, done };
+        }
+        const result = await done;
+        return { vpid, jobId, background: false, ...result };
+    }
+    async execShellWithoutProcess(script, { cwd, env, stdin, foreground = true, remote = this.defaultRemote, limits, sandbox }) {
+        if (!foreground)
+            throw new Error(`remote ${remote.name} does not support background shell processes`);
+        const vpid = id('vpid');
+        const jobId = id('job');
+        const pgrp = jobId;
+        const startedAt = now();
+        const record = {
+            vpid,
+            jobId,
+            pgrp,
+            kind: 'remote',
+            status: 'running',
+            foreground,
+            cwd,
+            argv: ['shell', script],
+            remote: { name: remote.name, ref: {}, fencingToken: id('fence') },
+            sandbox: sandbox ? { request: sandbox } : undefined,
+            startedAt,
+            restartPolicy: 'never',
+        };
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), record);
+        await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+            jobId,
+            pgrp,
+            command: script,
+            processIds: [vpid],
+            foreground,
+            status: 'running',
+            startedAt,
+        });
+        const result = enforceSandboxAttestation(sandbox, await remote.shell.exec({ script, cwd, env, stdin, foreground, limits, sandbox }));
+        if (result.stdout)
+            await this.recordOutput(vpid, 'stdout', result.stdout);
+        if (result.stderr)
+            await this.recordOutput(vpid, 'stderr', result.stderr);
+        const status = result.code === 0 ? 'exited' : 'failed';
+        const endedAt = now();
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), {
+            ...record,
+            sandbox: { ...record.sandbox, attestation: result.sandbox },
+            status,
+            endedAt,
+            exitCode: result.code ?? null,
+            signal: result.signal ?? null,
+        });
+        await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+            jobId,
+            pgrp,
+            command: script,
+            processIds: [vpid],
+            foreground,
+            status,
+            startedAt,
+            endedAt,
+        });
+        return {
+            vpid,
+            jobId,
+            background: false,
+            code: result.code,
+            signal: result.signal,
+            stdout: appendBoundedOutput('', result.stdout || '', outputLimit(limits?.stdoutChars ?? limits?.outputChars)),
+            stderr: appendBoundedOutput('', result.stderr || '', outputLimit(limits?.stderrChars ?? limits?.outputChars)),
+            timedOut: result.timedOut,
+            sandbox: result.sandbox,
+        };
+    }
+    async consumeProcessStream(stream, vpid, name, ready, onText, detached = () => false) {
+        try {
+            for await (const text of stream) {
+                if (detached())
+                    break;
+                onText(text);
+                await ready;
+                if (detached())
+                    break;
+                await this.recordOutput(vpid, name, text);
+            }
+        }
+        catch (error) {
+            if (!detached())
+                throw error;
+        }
+    }
+    async recordOutput(vpid, name, text) {
+        for (const chunk of splitOutputChunks(text)) {
+            await this.kstate.appendSessionJsonl(this.sessionId, name === 'stdout' ? this.stdoutName(vpid) : this.stderrName(vpid), { at: now(), text: chunk });
+            await this.emitEvent({ type: 'process', status: 'output', text: chunk, stream: name, opId: vpid, vpid });
+        }
+    }
+    async stopUntrustedProcess(remote, proc) {
+        try {
+            if (proc.ref)
+                await remote.shell?.kill?.(proc.ref, 'SIGKILL');
+        }
+        catch {
+            // Startup attestation failure is already fail-closed; kill failures remain audit-visible through the failed vProcess row.
+        }
+        proc.unref?.();
+        proc.done.catch(() => undefined);
+    }
+    async recover() {
+        const rows = await this.kstate.readSessionJsonl(this.sessionId, this.processesName());
+        const latest = new Map();
+        for (const row of rows)
+            latest.set(row.vpid, row);
+        const recovered = [];
+        for (const record of latest.values()) {
+            if (record.status !== 'running')
+                continue;
+            if (record.kind === 'k') {
+                const resumed = await this.recoverDeterministicVirtualProcess(record);
+                if (resumed) {
+                    recovered.push(resumed);
+                    continue;
+                }
+                const uncertain = { ...record, status: 'uncertain', endedAt: now(), reconcile: { needed: true } };
+                recovered.push(uncertain);
+                await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), uncertain);
+                await this.appendJobForProcess(uncertain);
+                continue;
+            }
+            const pid = record.remote?.ref?.pid;
+            if (!pid) {
+                const uncertain = {
+                    ...record,
+                    status: 'uncertain',
+                    endedAt: now(),
+                    error: 'remote process outcome is unknown after worker recovery; this worker cannot reattach its streams or completion handle',
+                    reconcile: { needed: true },
+                };
+                recovered.push(uncertain);
+                await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), uncertain);
+                await this.appendJobForProcess(uncertain);
+                continue;
+            }
+            try {
+                const remote = record.remote?.name ? this.remoteByName(record.remote.name) : this.defaultRemote;
+                const alive = remote?.shell?.isRunning?.({ pid }) ?? false;
+                if (!alive)
+                    throw new Error('process is not alive');
+                const uncertain = {
+                    ...record,
+                    status: 'uncertain',
+                    endedAt: now(),
+                    error: 'remote process is still alive, but this worker cannot reattach its streams or completion handle',
+                    reconcile: { needed: true },
+                };
+                recovered.push(uncertain);
+                await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), uncertain);
+                await this.appendJobForProcess(uncertain);
+            }
+            catch {
+                const uncertain = {
+                    ...record,
+                    status: 'uncertain',
+                    endedAt: now(),
+                    error: 'remote process outcome is unknown after worker recovery; this worker cannot reattach its streams or completion handle',
+                    reconcile: { needed: true },
+                };
+                recovered.push(uncertain);
+                await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), uncertain);
+                await this.appendJobForProcess(uncertain);
+            }
+        }
+        return recovered;
+    }
+    async recoverDeterministicVirtualProcess(record) {
+        if (this.active.has(record.vpid))
+            return record;
+        const sleepMs = recoverableSleepMs(record);
+        if (sleepMs === undefined)
+            return undefined;
+        const startedAtMs = Date.parse(record.startedAt);
+        if (!Number.isFinite(startedAtMs))
+            return undefined;
+        const remainingMs = Math.max(0, sleepMs - (Date.now() - startedAtMs));
+        if (remainingMs <= 0) {
+            const exited = { ...record, status: 'exited', endedAt: now(), exitCode: 0, signal: null };
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), exited);
+            await this.appendJobForProcess(exited);
+            return exited;
+        }
+        const recovered = { ...record, recovered: true };
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), recovered);
+        const controller = new AbortController();
+        let abortedSignal = null;
+        let detached = false;
+        const done = (async () => {
+            let code = 0;
+            let signal = null;
+            try {
+                await sleep(remainingMs, controller.signal);
+            }
+            catch {
+                if (detached)
+                    return { code: 0, signal: 'SIGDETACH', stdout: '', stderr: '' };
+                code = 130;
+                signal = abortedSignal || 'SIGTERM';
+            }
+            if (detached)
+                return { code: 0, signal: 'SIGDETACH', stdout: '', stderr: '' };
+            const status = code === 0 ? 'exited' : 'failed';
+            const endedAt = now();
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), { ...recovered, status, endedAt, exitCode: code, signal });
+            await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId: record.jobId,
+                pgrp: record.pgrp,
+                command: record.argv.slice(1).join(' '),
+                processIds: [record.vpid],
+                foreground: record.foreground,
+                status,
+                startedAt: record.startedAt,
+                endedAt,
+            });
+            return { code, signal, stdout: '', stderr: '' };
+        })();
+        this.trackActive(record.vpid, record.jobId, {
+            done,
+            abort: (signal) => {
+                abortedSignal = signal;
+                controller.abort(new Error(signal));
+            },
+            detach: () => {
+                detached = true;
+                controller.abort(new Error('detached'));
+            },
+            recovered: true,
+        });
+        await this.emitEvent({
+            type: 'signal',
+            name: 'process.recovered',
+            data: { vpid: record.vpid, jobId: record.jobId, kind: 'k.sleep', remainingMs },
+            level: 'info',
+        });
+        return recovered;
+    }
+    async processes() {
+        return latestById(await this.kstate.readSessionJsonl(this.sessionId, this.processesName()), 'vpid');
+    }
+    localActiveProcessCount() {
+        return new Set(this.active.values()).size;
+    }
+    detachActive() {
+        const active = new Set(this.active.values());
+        this.active.clear();
+        for (const handle of active) {
+            handle.detach?.();
+            handle.done.catch(() => undefined);
+        }
+    }
+    async jobs() {
+        const jobs = latestById(await this.kstate.readSessionJsonl(this.sessionId, this.jobsName()), 'jobId');
+        const processes = await this.processes();
+        return jobs.map((job) => projectJobFromProcesses(job, processes));
+    }
+    async kill(idOrJob, signal = 'SIGTERM') {
+        const targets = (await this.processes())
+            .filter((record) => record.status === 'running' || record.status === 'uncertain')
+            .filter((record) => record.vpid === idOrJob || record.jobId === idOrJob);
+        const updated = [];
+        for (const record of targets) {
+            const active = this.active.get(record.vpid) || this.active.get(record.jobId);
+            let killed = false;
+            if (record.remote) {
+                const remote = this.remoteByName(record.remote.name) || this.defaultRemote;
+                killed = Boolean(await remote.shell?.kill?.(record.remote.ref, signal));
+            }
+            else if (record.kind === 'k' && active?.abort) {
+                active.abort(signal);
+                killed = true;
+            }
+            const next = killed
+                ? { ...record, status: 'uncertain', endedAt: now(), signal, reconcile: { needed: true } }
+                : { ...record, status: 'uncertain', endedAt: now(), signal, error: `unable to signal process with ${signal}`, reconcile: { needed: true } };
+            await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), next);
+            await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+                jobId: record.jobId,
+                pgrp: record.pgrp,
+                command: record.argv.join(' '),
+                processIds: [record.vpid],
+                foreground: record.foreground,
+                status: next.status,
+                startedAt: record.startedAt,
+                endedAt: next.endedAt,
+            });
+            await this.emitEvent({ type: 'signal', name: 'process.signaled', data: { vpid: record.vpid, jobId: record.jobId, signal, killed: Boolean(killed) }, level: killed ? 'info' : 'warn' });
+            updated.push(next);
+        }
+        return updated;
+    }
+    async wait(idOrJob) {
+        const record = await this.findProcess(idOrJob);
+        if (!record)
+            throw new Error(`no process or job matched: ${idOrJob}`);
+        const active = this.active.get(record.vpid) || this.active.get(record.jobId);
+        if (active) {
+            const result = await active.done;
+            const output = await this.processOutput(record.vpid);
+            return {
+                ...result,
+                stdout: result.stdout || output.stdout,
+                stderr: result.stderr || output.stderr,
+                status: result.signal === 'SIGDETACH' ? 'uncertain' : result.code === 0 ? 'exited' : 'failed',
+                vpid: record.vpid,
+                jobId: record.jobId,
+                receiptId: record.receiptId,
+                recovered: active.recovered || record.recovered,
+            };
+        }
+        const output = await this.processOutput(record.vpid);
+        if (record.status === 'running') {
+            return {
+                code: 125,
+                signal: null,
+                stdout: output.stdout,
+                stderr: output.stderr || 'process is still running, but this worker cannot wait on its live handle\n',
+                status: 'uncertain',
+                vpid: record.vpid,
+                jobId: record.jobId,
+                receiptId: record.receiptId,
+                recovered: Boolean(record.recovered),
+            };
+        }
+        return {
+            code: record.exitCode ?? (record.status === 'failed' ? 1 : record.status === 'uncertain' ? 125 : 0),
+            signal: record.signal ?? null,
+            stdout: output.stdout,
+            stderr: output.stderr || (record.error ? `${record.error}\n` : record.status === 'uncertain' ? 'process outcome is uncertain; recovery must reconcile it\n' : ''),
+            status: record.status,
+            vpid: record.vpid,
+            jobId: record.jobId,
+            receiptId: record.receiptId,
+            recovered: Boolean(record.recovered),
+        };
+    }
+    async foreground(idOrJob) {
+        const record = await this.findProcess(idOrJob);
+        if (!record)
+            throw new Error(`no process or job matched: ${idOrJob}`);
+        const active = this.active.get(record.vpid) || this.active.get(record.jobId);
+        if (!active && (record.status === 'running' || record.status === 'uncertain'))
+            return this.wait(record.vpid);
+        await this.markForeground(record, true);
+        await this.emitEvent({ type: 'signal', name: 'process.foreground', data: { vpid: record.vpid, jobId: record.jobId }, level: 'info' });
+        return this.wait(record.vpid);
+    }
+    async background(idOrJob) {
+        const record = await this.findProcess(idOrJob);
+        if (!record)
+            throw new Error(`no process or job matched: ${idOrJob}`);
+        const next = await this.markForeground(record, false);
+        await this.emitEvent({ type: 'signal', name: 'process.background', data: { vpid: record.vpid, jobId: record.jobId }, level: 'info' });
+        return next;
+    }
+    async attachReceipt(vpid, receiptId) {
+        const record = await this.findProcess(vpid);
+        if (!record || record.receiptId === receiptId)
+            return;
+        const next = { ...record, receiptId };
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), next);
+    }
+    trackActive(vpid, jobId, active) {
+        this.active.set(vpid, active);
+        this.active.set(jobId, active);
+        active.done.finally(() => {
+            this.active.delete(vpid);
+            this.active.delete(jobId);
+        }).catch(() => undefined);
+    }
+    async findProcess(idOrJob) {
+        return (await this.processes()).find((record) => record.vpid === idOrJob || record.jobId === idOrJob);
+    }
+    async processOutput(vpid) {
+        const [stdout, stderr] = await Promise.all([
+            this.readOutputLog(this.stdoutName(vpid)),
+            this.readOutputLog(this.stderrName(vpid)),
+        ]);
+        return { stdout, stderr };
+    }
+    async readOutputLog(name) {
+        const rows = await this.kstate.readSessionJsonl(this.sessionId, name);
+        let output = '';
+        for (const row of rows) {
+            if (typeof row.text === 'string')
+                output = appendBoundedOutput(output, row.text);
+        }
+        return output;
+    }
+    async markForeground(record, foreground) {
+        const next = { ...record, foreground };
+        await this.kstate.appendSessionJsonl(this.sessionId, this.processesName(), next);
+        await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), {
+            jobId: record.jobId,
+            pgrp: record.pgrp,
+            command: record.argv.join(' '),
+            processIds: [record.vpid],
+            foreground,
+            status: record.status,
+            startedAt: record.startedAt,
+            endedAt: record.endedAt,
+        });
+        return next;
+    }
+    async appendJobForProcess(record) {
+        await this.kstate.appendSessionJsonl(this.sessionId, this.jobsName(), jobFromProcess(record));
+    }
+}
+function latestById(rows, key) {
+    const latest = new Map();
+    for (const row of rows)
+        latest.set(row[key], row);
+    return [...latest.values()];
+}
+function jobFromProcess(record) {
+    return {
+        jobId: record.jobId,
+        pgrp: record.pgrp,
+        command: record.argv.join(' '),
+        processIds: [record.vpid],
+        foreground: record.foreground,
+        status: record.status,
+        startedAt: record.startedAt,
+        endedAt: record.endedAt,
+    };
+}
+function projectJobFromProcesses(job, processes) {
+    const members = processes.filter((process) => job.processIds.includes(process.vpid));
+    if (!members.length)
+        return job;
+    const status = aggregateProcessStatus(members);
+    const foreground = members.some((process) => process.foreground);
+    const endedAt = members
+        .map((process) => process.endedAt)
+        .filter((value) => Boolean(value))
+        .sort()
+        .at(-1);
+    return {
+        ...job,
+        foreground,
+        status,
+        endedAt: status === 'running' ? undefined : endedAt || job.endedAt,
+    };
+}
+function aggregateProcessStatus(processes) {
+    if (processes.some((process) => process.status === 'running'))
+        return 'running';
+    if (processes.some((process) => process.status === 'uncertain'))
+        return 'uncertain';
+    if (processes.some((process) => process.status === 'failed'))
+        return 'failed';
+    return 'exited';
+}
+function enforceSandboxAttestation(request, result) {
+    if (request?.enforcement !== 'hard')
+        return result;
+    if (result.sandbox?.enforcement === 'hard')
+        return result;
+    return {
+        ...result,
+        code: result.code && result.code !== 0 ? result.code : 126,
+        stderr: appendBoundedOutput(result.stderr || '', 'remote shell did not provide hard sandbox attestation\n'),
+    };
+}
+function sandboxStartupFailure(request, attestation) {
+    if (request?.enforcement !== 'hard')
+        return undefined;
+    if (attestation?.enforcement === 'hard')
+        return undefined;
+    return {
+        code: 126,
+        signal: null,
+        stdout: '',
+        stderr: 'remote shell did not provide hard sandbox attestation\n',
+        sandbox: attestation,
+    };
+}
+function appendBoundedOutput(current, next, limit = MAX_CAPTURED_PROCESS_OUTPUT_CHARS) {
+    if (!next)
+        return current;
+    const combined = `${current}${next}`;
+    if (combined.length <= limit)
+        return combined;
+    return combined.slice(combined.length - limit);
+}
+function outputLimit(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return MAX_CAPTURED_PROCESS_OUTPUT_CHARS;
+    const integer = Math.trunc(value);
+    return integer > 0 ? Math.min(integer, MAX_CAPTURED_PROCESS_OUTPUT_CHARS) : MAX_CAPTURED_PROCESS_OUTPUT_CHARS;
+}
+function splitOutputChunks(text) {
+    if (!text)
+        return [];
+    const chunks = [];
+    for (let offset = 0; offset < text.length; offset += MAX_PROCESS_OUTPUT_CHUNK_CHARS) {
+        chunks.push(text.slice(offset, offset + MAX_PROCESS_OUTPUT_CHUNK_CHARS));
+    }
+    return chunks;
+}
+function recoverableSleepMs(record) {
+    if (record.argv[0] !== 'k')
+        return undefined;
+    const script = record.argv.slice(1).join(' ').trim();
+    const match = script.match(/^sleep\s+((?:\d+(?:\.\d+)?)|(?:\.\d+))$/);
+    if (!match)
+        return undefined;
+    const seconds = Number(match[1]);
+    if (!Number.isFinite(seconds) || seconds < 0)
+        return undefined;
+    return Math.max(0, seconds) * 1000;
+}
+//# sourceMappingURL=vprocess.js.map