agentplane 0.3.15 → 0.3.17

package/dist/runner/process-supervision/run.js

@@ -0,0 +1,351 @@
+import { appendFileSync } from "node:fs";
+import { startProcess } from "@agentplaneorg/core";
+import { appendRunnerEvent, evolveRunnerRunState, readRunnerRunState, writeRunnerRunState, } from "../artifacts.js";
+import { finalizeTraceArtifact, redactTraceText } from "../trace-artifacts.js";
+import { createRunnerTraceEvent, serializeRunnerTraceEvent } from "../trace.js";
+import { isProcessAlive, normalizeSignal } from "./signals.js";
+import { buildInvocationEventData, mergeSupervisionState, renderInvocationCommand, } from "./state.js";
+import { appendTail, splitCompletedLines } from "./streams.js";
+export async function runSupervisedProcess(opts) {
+    return await new Promise((resolve, reject) => {
+        const [command, ...args] = opts.invocation.argv;
+        if (!command) {
+            reject(new Error("Runner invocation is missing the executable command"));
+            return;
+        }
+        const child = startProcess({
+            command,
+            args,
+            cwd: opts.invocation.run_dir,
+            env: { ...process.env, ...opts.invocation.env },
+            stdin: "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const pid = typeof child.pid === "number" ? child.pid : null;
+        const started_at = new Date().toISOString();
+        let heartbeat_at = started_at;
+        let stdout_tail = "";
+        let stderr_tail = "";
+        let stdout_bytes = 0;
+        let stderr_bytes = 0;
+        let stdout_buffer = "";
+        let stderr_buffer = "";
+        let trace_seq = 0;
+        let settled = false;
+        const tracePolicy = opts.invocation.trace_policy;
+        const timeoutPolicy = opts.invocation.timeout_policy;
+        const traceMode = tracePolicy.mode;
+        const captureStderr = tracePolicy.capture_stderr;
+        const maxTailBytes = tracePolicy.max_tail_bytes;
+        const redactPatterns = tracePolicy.redact_patterns ?? [];
+        let timeoutReason = null;
+        let timeoutRequestedAt = null;
+        let terminateSentAt = null;
+        let killSentAt = null;
+        let idleTimer = null;
+        let wallTimer = null;
+        let killTimer = null;
+        const queueAppend = (kind, text) => {
+            if (kind === "trace" && traceMode !== "raw")
+                return;
+            if (kind === "stderr" && !captureStderr)
+                return;
+            const path = kind === "trace" ? opts.invocation.trace_path : opts.invocation.stderr_path;
+            try {
+                appendFileSync(path, text, "utf8");
+            }
+            catch (err) {
+                finishWithError(err);
+            }
+        };
+        const writeTraceLine = (stream, raw) => {
+            trace_seq += 1;
+            queueAppend("trace", serializeRunnerTraceEvent(createRunnerTraceEvent({
+                ts: new Date().toISOString(),
+                seq: trace_seq,
+                stream,
+                adapter_id: opts.invocation.adapter_id,
+                raw,
+            })));
+        };
+        const flushTraceBuffer = (buffer, stream) => {
+            const { lines, remainder } = splitCompletedLines(buffer);
+            for (const line of lines) {
+                writeTraceLine(stream, line);
+            }
+            return remainder;
+        };
+        const clearTimers = () => {
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (wallTimer)
+                clearTimeout(wallTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            idleTimer = null;
+            wallTimer = null;
+            killTimer = null;
+        };
+        const patchRunningSupervision = async (patch) => {
+            const currentState = await readRunnerRunState(opts.invocation.state_path);
+            if (!currentState)
+                return;
+            await writeRunnerRunState({
+                state_path: opts.invocation.state_path,
+                state: evolveRunnerRunState({
+                    state: currentState,
+                    status: currentState.status,
+                    updated_at: new Date().toISOString(),
+                    supervision: mergeSupervisionState(currentState.supervision, patch),
+                }),
+            });
+        };
+        const requestTimeout = (reason) => {
+            if (settled || timeoutReason)
+                return;
+            timeoutReason = reason;
+            timeoutRequestedAt = new Date().toISOString();
+            terminateSentAt = timeoutRequestedAt;
+            void patchRunningSupervision({
+                timeout_reason: reason,
+                timeout_requested_at: timeoutRequestedAt,
+                terminate_sent_at: terminateSentAt,
+                heartbeat_at: timeoutRequestedAt,
+            }).catch(finishWithError);
+            void appendRunnerEvent({
+                events_path: opts.invocation.events_path,
+                event: {
+                    at: timeoutRequestedAt,
+                    type: "runner_timeout_requested",
+                    message: `runner timeout requested (${reason})`,
+                    data: {
+                        reason,
+                        pid,
+                        timeout_policy: timeoutPolicy,
+                    },
+                },
+            }).catch(finishWithError);
+            if (pid && isProcessAlive(pid)) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch (err) {
+                    const code = err?.code;
+                    if (code !== "ESRCH") {
+                        finishWithError(err);
+                        return;
+                    }
+                }
+            }
+            const graceMs = timeoutPolicy.terminate_grace_ms;
+            if (graceMs <= 0) {
+                killSentAt = new Date().toISOString();
+                void patchRunningSupervision({
+                    timeout_reason: reason,
+                    timeout_requested_at: timeoutRequestedAt,
+                    terminate_sent_at: terminateSentAt,
+                    kill_sent_at: killSentAt,
+                    force_killed: true,
+                    heartbeat_at: killSentAt,
+                }).catch(finishWithError);
+                if (pid && isProcessAlive(pid)) {
+                    try {
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch (err) {
+                        const code = err?.code;
+                        if (code !== "ESRCH") {
+                            finishWithError(err);
+                        }
+                    }
+                }
+                return;
+            }
+            killTimer = setTimeout(() => {
+                if (settled || !timeoutReason)
+                    return;
+                killSentAt = new Date().toISOString();
+                void patchRunningSupervision({
+                    timeout_reason: timeoutReason,
+                    timeout_requested_at: timeoutRequestedAt,
+                    terminate_sent_at: terminateSentAt,
+                    kill_sent_at: killSentAt,
+                    force_killed: true,
+                    heartbeat_at: killSentAt,
+                }).catch(finishWithError);
+                void appendRunnerEvent({
+                    events_path: opts.invocation.events_path,
+                    event: {
+                        at: killSentAt,
+                        type: "runner_timeout_force_kill",
+                        message: `runner force-killed after timeout (${timeoutReason})`,
+                        data: {
+                            reason: timeoutReason,
+                            pid,
+                            timeout_policy: timeoutPolicy,
+                        },
+                    },
+                }).catch(finishWithError);
+                if (pid && isProcessAlive(pid)) {
+                    try {
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch (err) {
+                        const code = err?.code;
+                        if (code !== "ESRCH") {
+                            finishWithError(err);
+                        }
+                    }
+                }
+            }, graceMs);
+        };
+        const resetIdleTimer = () => {
+            if (timeoutPolicy.idle_ms <= 0 || settled || timeoutReason)
+                return;
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => {
+                requestTimeout("idle");
+            }, timeoutPolicy.idle_ms);
+        };
+        const updateRunningState = async () => {
+            const initialState = await readRunnerRunState(opts.invocation.state_path);
+            if (!initialState)
+                return;
+            const supervision = mergeSupervisionState(initialState.supervision, {
+                pid,
+                command: renderInvocationCommand(opts.invocation),
+                started_at,
+                heartbeat_at,
+                exit_signal: null,
+                timeout_reason: null,
+            });
+            await writeRunnerRunState({
+                state_path: opts.invocation.state_path,
+                state: evolveRunnerRunState({
+                    state: initialState,
+                    status: "running",
+                    updated_at: started_at,
+                    supervision,
+                }),
+            });
+            await appendRunnerEvent({
+                events_path: opts.invocation.events_path,
+                event: {
+                    at: started_at,
+                    type: "runner_execute_start",
+                    message: opts.start_message,
+                    data: buildInvocationEventData(opts.invocation, pid),
+                },
+            });
+        };
+        const finishWithError = (err) => {
+            if (settled)
+                return;
+            clearTimers();
+            settled = true;
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        void updateRunningState().catch((err) => {
+            if (pid && isProcessAlive(pid)) {
+                try {
+                    process.kill(pid, "SIGKILL");
+                }
+                catch {
+                    // best effort
+                }
+            }
+            finishWithError(err);
+        });
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString();
+            const persistedText = redactTraceText(text, redactPatterns);
+            heartbeat_at = new Date().toISOString();
+            resetIdleTimer();
+            stdout_bytes += Buffer.byteLength(text, "utf8");
+            stdout_tail = appendTail(stdout_tail, persistedText, maxTailBytes);
+            stdout_buffer = flushTraceBuffer(`${stdout_buffer}${persistedText}`, "stdout");
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            const persistedText = redactTraceText(text, redactPatterns);
+            heartbeat_at = new Date().toISOString();
+            resetIdleTimer();
+            stderr_bytes += Buffer.byteLength(text, "utf8");
+            stderr_tail = appendTail(stderr_tail, persistedText, maxTailBytes);
+            stderr_buffer = flushTraceBuffer(`${stderr_buffer}${persistedText}`, "stderr");
+            queueAppend("stderr", persistedText);
+        });
+        void child.on("error", finishWithError);
+        void child.on("close", (code, signal) => {
+            void (async () => {
+                if (settled)
+                    return;
+                clearTimers();
+                const ended_at = new Date().toISOString();
+                if (stdout_buffer) {
+                    writeTraceLine("stdout", stdout_buffer);
+                }
+                if (stderr_buffer) {
+                    writeTraceLine("stderr", stderr_buffer);
+                }
+                if (settled)
+                    return;
+                const normalizedSignal = normalizeSignal(signal);
+                const currentState = await readRunnerRunState(opts.invocation.state_path);
+                const supervision = currentState?.supervision;
+                const runStatus = supervision?.cancel_requested_at
+                    ? "cancelled"
+                    : timeoutReason
+                        ? "failed"
+                        : code === 0
+                            ? "success"
+                            : "failed";
+                const [traceArtifact, stderrArtifact] = await Promise.all([
+                    finalizeTraceArtifact({
+                        file_path: opts.invocation.trace_path,
+                        policy: tracePolicy,
+                        run_status: runStatus,
+                    }),
+                    finalizeTraceArtifact({
+                        file_path: opts.invocation.stderr_path,
+                        policy: tracePolicy,
+                        run_status: runStatus,
+                    }),
+                ]);
+                settled = true;
+                resolve({
+                    exit_code: code,
+                    exit_signal: normalizedSignal,
+                    stdout_tail,
+                    stderr_tail,
+                    stdout_bytes,
+                    stderr_bytes,
+                    pid,
+                    started_at,
+                    ended_at,
+                    cancel_requested_at: supervision?.cancel_requested_at ?? null,
+                    cancel_signal: supervision?.cancel_signal ?? null,
+                    timeout_reason: supervision?.timeout_reason ?? timeoutReason,
+                    timeout_requested_at: supervision?.timeout_requested_at ?? timeoutRequestedAt,
+                    terminate_sent_at: supervision?.terminate_sent_at ?? terminateSentAt,
+                    kill_sent_at: supervision?.kill_sent_at ?? killSentAt,
+                    force_killed: supervision?.force_killed === true || killSentAt !== null,
+                    heartbeat_at: heartbeat_at || ended_at,
+                    trace_artifact_path: traceArtifact.artifact_path,
+                    trace_archive_path: traceArtifact.archive_path,
+                    stderr_artifact_path: stderrArtifact.artifact_path,
+                    stderr_archive_path: stderrArtifact.archive_path,
+                });
+            })().catch(finishWithError);
+        });
+        if (timeoutPolicy.wall_clock_ms > 0) {
+            wallTimer = setTimeout(() => {
+                requestTimeout("wall_clock");
+            }, timeoutPolicy.wall_clock_ms);
+        }
+        resetIdleTimer();
+        child.stdin?.end(opts.stdin_text);
+    });
+}

package/dist/runner/process-supervision/signals.d.ts

@@ -0,0 +1,16 @@
+import type { RunnerProcessSignal } from "../types.js";
+export type ObservedProcessIdentity = {
+    pid: number;
+    command: string | null;
+    started_at: string | null;
+};
+export declare function normalizeSignal(signal: NodeJS.Signals | null): RunnerProcessSignal | null;
+export declare function exitCodeForSignal(signal: RunnerProcessSignal | null): number | null;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function readObservedProcessIdentity(pid: number): Promise<ObservedProcessIdentity | null>;
+export declare function waitForProcessExit(opts: {
+    pid: number;
+    timeout_ms: number;
+    poll_ms?: number;
+}): Promise<boolean>;
+//# sourceMappingURL=signals.d.ts.map

package/dist/runner/process-supervision/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../../src/runner/process-supervision/signals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAUvD,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAAG,mBAAmB,GAAG,IAAI,CAKzF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAOnF;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CA+BzC;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAQnB"}

package/dist/runner/process-supervision/signals.js

@@ -0,0 +1,85 @@
+import { runProcess } from "@agentplaneorg/core";
+const SUPPORTED_SIGNALS = new Set([
+    "SIGHUP",
+    "SIGINT",
+    "SIGQUIT",
+    "SIGTERM",
+    "SIGKILL",
+]);
+export function normalizeSignal(signal) {
+    if (!signal)
+        return null;
+    return SUPPORTED_SIGNALS.has(signal)
+        ? signal
+        : null;
+}
+export function exitCodeForSignal(signal) {
+    if (signal === "SIGINT")
+        return 130;
+    if (signal === "SIGTERM")
+        return 143;
+    if (signal === "SIGKILL")
+        return 137;
+    if (signal === "SIGHUP")
+        return 129;
+    if (signal === "SIGQUIT")
+        return 131;
+    return null;
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ESRCH")
+            return false;
+        if (code === "EPERM")
+            return true;
+        throw err;
+    }
+}
+export async function readObservedProcessIdentity(pid) {
+    try {
+        const { stdout } = await runProcess({
+            command: "ps",
+            args: ["-o", "lstart=,command=", "-p", String(pid)],
+            encoding: "utf8",
+        });
+        const line = String(stdout)
+            .split("\n")
+            .map((entry) => entry.trim())
+            .find((entry) => entry.length > 0);
+        if (!line)
+            return null;
+        const match = /^([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d{1,2}\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.*)$/u.exec(line);
+        const startedAtRaw = match?.[1]?.trim() ?? null;
+        const command = match?.[2]?.trim() ?? null;
+        const parsedStartedAt = startedAtRaw && !Number.isNaN(Date.parse(startedAtRaw))
+            ? new Date(startedAtRaw).toISOString()
+            : null;
+        return {
+            pid,
+            command,
+            started_at: parsedStartedAt,
+        };
+    }
+    catch (err) {
+        const errno = err?.code;
+        const exitCode = err?.code;
+        if (errno === "ESRCH" || exitCode === 1)
+            return null;
+        throw err;
+    }
+}
+export async function waitForProcessExit(opts) {
+    const started = Date.now();
+    const poll_ms = opts.poll_ms ?? 100;
+    while (Date.now() - started < opts.timeout_ms) {
+        if (!isProcessAlive(opts.pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, poll_ms));
+    }
+    return !isProcessAlive(opts.pid);
+}

package/dist/runner/process-supervision/state.d.ts

@@ -0,0 +1,10 @@
+import type { RunnerInvocation, RunnerRunState, RunnerSupervisionState } from "../types.js";
+export declare function renderInvocationCommand(invocation: RunnerInvocation): string | null;
+export declare function mergeSupervisionState(current: RunnerSupervisionState | undefined, patch: Partial<RunnerSupervisionState>): RunnerSupervisionState;
+export declare function buildInvocationEventData(invocation: RunnerInvocation, pid: number | null): Record<string, unknown>;
+export declare function waitForRunnerStateStop(opts: {
+    state_path: string;
+    timeout_ms: number;
+    poll_ms?: number;
+}): Promise<RunnerRunState | null>;
+//# sourceMappingURL=state.d.ts.map

package/dist/runner/process-supervision/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/runner/process-supervision/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE5F,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAMnF;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,GAAG,SAAS,EAC3C,KAAK,EAAE,OAAO,CAAC,sBAAsB,CAAC,GACrC,sBAAsB,CAKxB;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAUjC"}

package/dist/runner/process-supervision/state.js

@@ -0,0 +1,42 @@
+import { readRunnerRunState } from "../artifacts.js";
+export function renderInvocationCommand(invocation) {
+    const commandLine = invocation.argv
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join(" ");
+    return commandLine.length > 0 ? commandLine : null;
+}
+export function mergeSupervisionState(current, patch) {
+    return {
+        ...current,
+        ...Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined)),
+    };
+}
+export function buildInvocationEventData(invocation, pid) {
+    return {
+        executable: invocation.argv[0] ?? null,
+        argv_count: invocation.argv.length,
+        cwd: invocation.run_dir,
+        env_keys: Object.keys(invocation.env).toSorted(),
+        has_bootstrap_path: typeof invocation.bootstrap_path === "string" && invocation.bootstrap_path.trim().length > 0,
+        has_output_last_message_path: typeof invocation.output_last_message_path === "string" &&
+            invocation.output_last_message_path.trim().length > 0,
+        has_trace_path: typeof invocation.trace_path === "string" && invocation.trace_path.trim().length > 0,
+        has_stderr_path: typeof invocation.stderr_path === "string" && invocation.stderr_path.trim().length > 0,
+        trace_policy: invocation.trace_policy,
+        timeout_policy: invocation.timeout_policy,
+        pid,
+    };
+}
+export async function waitForRunnerStateStop(opts) {
+    const started = Date.now();
+    const poll_ms = opts.poll_ms ?? 100;
+    while (Date.now() - started < opts.timeout_ms) {
+        const state = await readRunnerRunState(opts.state_path);
+        if (state && state.status !== "running")
+            return state;
+        await new Promise((resolve) => setTimeout(resolve, poll_ms));
+    }
+    const state = await readRunnerRunState(opts.state_path);
+    return state && state.status !== "running" ? state : null;
+}

package/dist/runner/process-supervision/streams.d.ts

@@ -0,0 +1,6 @@
+export declare function appendTail(current: string, incoming: string, maxBytes: number): string;
+export declare function splitCompletedLines(buffer: string): {
+    lines: string[];
+    remainder: string;
+};
+//# sourceMappingURL=streams.d.ts.map

package/dist/runner/process-supervision/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../../src/runner/process-supervision/streams.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAItF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgB1F"}

package/dist/runner/process-supervision/streams.js

@@ -0,0 +1,23 @@
+export function appendTail(current, incoming, maxBytes) {
+    const combined = Buffer.from(`${current}${incoming}`, "utf8");
+    if (combined.length <= maxBytes)
+        return combined.toString("utf8");
+    return combined.subarray(combined.length - maxBytes).toString("utf8");
+}
+export function splitCompletedLines(buffer) {
+    const lines = [];
+    let start = 0;
+    while (start < buffer.length) {
+        const newlineIndex = buffer.indexOf("\n", start);
+        if (newlineIndex === -1) {
+            return { lines, remainder: buffer.slice(start) };
+        }
+        let line = buffer.slice(start, newlineIndex);
+        if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
+        }
+        lines.push(line);
+        start = newlineIndex + 1;
+    }
+    return { lines, remainder: "" };
+}

package/dist/runner/process-supervision.d.ts

@@ -1,48 +1,6 @@
-import type { RunnerInvocation, RunnerProcessSignal, RunnerRunState, RunnerTimeoutReason } from "./types.js";
-export type SupervisedProcessResult = {
-    exit_code: number | null;
-    exit_signal: RunnerProcessSignal | null;
-    stdout_tail: string;
-    stderr_tail: string;
-    stdout_bytes: number;
-    stderr_bytes: number;
-    pid: number | null;
-    started_at: string;
-    ended_at: string;
-    cancel_requested_at: string | null;
-    cancel_signal: RunnerProcessSignal | null;
-    timeout_reason: RunnerTimeoutReason | null;
-    timeout_requested_at: string | null;
-    terminate_sent_at: string | null;
-    kill_sent_at: string | null;
-    force_killed: boolean;
-    heartbeat_at: string;
-    trace_artifact_path: string | null;
-    trace_archive_path: string | null;
-    stderr_artifact_path: string | null;
-    stderr_archive_path: string | null;
-};
-export type ObservedProcessIdentity = {
-    pid: number;
-    command: string | null;
-    started_at: string | null;
-};
-export declare function exitCodeForSignal(signal: RunnerProcessSignal | null): number | null;
-export declare function isProcessAlive(pid: number): boolean;
-export declare function readObservedProcessIdentity(pid: number): Promise<ObservedProcessIdentity | null>;
-export declare function waitForProcessExit(opts: {
-    pid: number;
-    timeout_ms: number;
-    poll_ms?: number;
-}): Promise<boolean>;
-export declare function runSupervisedProcess(opts: {
-    invocation: RunnerInvocation;
-    stdin_text: string;
-    start_message: string;
-}): Promise<SupervisedProcessResult>;
-export declare function waitForRunnerStateStop(opts: {
-    state_path: string;
-    timeout_ms: number;
-    poll_ms?: number;
-}): Promise<RunnerRunState | null>;
+export type { SupervisedProcessResult } from "./process-supervision/run.js";
+export { runSupervisedProcess } from "./process-supervision/run.js";
+export type { ObservedProcessIdentity } from "./process-supervision/signals.js";
+export { exitCodeForSignal, isProcessAlive, readObservedProcessIdentity, waitForProcessExit, } from "./process-supervision/signals.js";
+export { waitForRunnerStateStop } from "./process-supervision/state.js";
 //# sourceMappingURL=process-supervision.d.ts.map

package/dist/runner/process-supervision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"process-supervision.d.ts","sourceRoot":"","sources":["../../src/runner/process-supervision.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EAEd,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAapB,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,aAAa,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1C,cAAc,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC3C,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AA2EF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAOnF;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CA6BzC;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAQnB;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA+UnC;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAUjC"}
+{"version":3,"file":"process-supervision.d.ts","sourceRoot":"","sources":["../../src/runner/process-supervision.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,YAAY,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAChF,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC"}