@wardby/cli 0.7.0 → 0.9.0

package/dist/core/run-steps/extract.js

@@ -0,0 +1,467 @@
+/**
+ * Run steps from the model traffic the coding proxy relays: one extractor per wire format, one
+ * output shape (ExtractedStep / ExtractedResult). Nothing here throws for any input; a frame or body
+ * it can't read gives no step. A tool result's content is never kept below the detail level; at
+ * detail only its end (MAX_RESULT_OUTPUT_CHARS) is. Its status comes from its first lines. Each request resends the whole history, so results are read from the newest turn
+ * only.
+ */
+import { bounded, CLAUDE_RESULT_TOOL, codingResultStepText, displayToolName, FINISHED_STEP_TEXT, toolStepText, } from "./summarize.js";
+import { MAX_RESULT_OUTPUT_CHARS, MAX_STEP_TEXT_CHARS, tailOf } from "./types.js";
+/** Anthropic stop reasons that cut a reply off mid-output. */
+const CUT_STOP_REASONS = new Set(["max_tokens", "model_context_window_exceeded"]);
+/** Marks the reply's last step truncated when it was cut and that step is text being written. */
+function markCut(steps, cut) {
+    const last = steps.at(-1);
+    if (cut && last?.kind === "said" && !last.truncated)
+        steps[steps.length - 1] = { ...last, truncated: true };
+    return steps;
+}
+export const MAX_RESULTS_PER_REQUEST = 64;
+const STATUS_HEAD_CHARS = 512;
+const EXIT_LINE = /^(?:exit_code=|Exit code: |Process exited with code )(-?\d{1,6})\s*$/m;
+const SCRIPT_FAILED = /^\s*Script (?:failed|terminated|error)\b/;
+const OUTPUT_ITEMS = new Set(["function_call_output", "custom_tool_call_output"]);
+/** Items of a turn's run of tool calls (their outputs are OUTPUT_ITEMS). */
+const CALL_ITEMS = new Set(["function_call", "custom_tool_call", "tool_search_call"]);
+const obj = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+const str = (value) => (typeof value === "string" ? value : undefined);
+function sseData(frame) {
+    const data = frame
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data || data === "[DONE]")
+        return undefined;
+    try {
+        return obj(JSON.parse(data));
+    }
+    catch {
+        return undefined;
+    }
+}
+function append(block, piece) {
+    if (block.truncated)
+        return;
+    const room = MAX_STEP_TEXT_CHARS - block.buffer.length;
+    if (piece.length > room) {
+        block.buffer += piece.slice(0, room);
+        block.truncated = true;
+    }
+    else
+        block.buffer += piece;
+}
+/** A coding run's final answer (Claude Code's StructuredOutput call) as one said step, never its arguments. */
+function resultStep(callId, argsJson, cut) {
+    const answer = codingResultStepText(argsJson) ?? { text: FINISHED_STEP_TEXT, truncated: false };
+    return { kind: "said", callId, text: answer.text, truncated: answer.truncated || cut };
+}
+function closeBlock(block, options) {
+    if (block.kind === "said") {
+        return block.buffer.trim()
+            ? { kind: "said", callId: block.id, text: block.buffer, truncated: block.truncated }
+            : undefined;
+    }
+    if (block.name === CLAUDE_RESULT_TOOL)
+        return resultStep(block.id, block.buffer || "{}", block.truncated);
+    const tool = displayToolName(block.name);
+    const text = toolStepText(tool, block.buffer || "{}");
+    return {
+        kind: "tool",
+        callId: block.id,
+        tool,
+        text: text.text,
+        truncated: text.truncated || block.truncated,
+        ...(options?.detail ? { input: block.buffer || "{}", inputTruncated: block.truncated } : {}),
+    };
+}
+let streamCount = 0;
+const MAX_OPEN_BLOCKS = 64;
+/** Anthropic Messages streams: input_json_delta assembled per block index, emitted on content_block_stop. */
+export class AnthropicStreamSteps {
+    options;
+    messageId = `msg${++streamCount}`;
+    blocks = new Map();
+    done = [];
+    stopped = false;
+    cutStop = false;
+    constructor(options) {
+        this.options = options;
+    }
+    consume(frame) {
+        try {
+            this.read(frame);
+        }
+        catch {
+            // A step is dropped, never the relay.
+        }
+    }
+    take() {
+        const out = this.done;
+        this.done = [];
+        return out;
+    }
+    finish() {
+        try {
+            const cut = !this.stopped || this.cutStop;
+            for (const [index, open] of [...this.blocks].sort(([a], [b]) => a - b)) {
+                this.blocks.delete(index);
+                if (open.kind !== "said")
+                    continue;
+                const step = closeBlock({ ...open, truncated: true }, this.options);
+                if (step)
+                    this.done.push(step);
+            }
+            return markCut(this.take(), cut);
+        }
+        catch {
+            return [];
+        }
+    }
+    read(frame) {
+        if (!frame.includes("message_") && !frame.includes("content_block_"))
+            return;
+        const event = sseData(frame);
+        if (!event)
+            return;
+        const index = typeof event.index === "number" ? event.index : undefined;
+        switch (event.type) {
+            case "message_stop":
+                this.stopped = true;
+                return;
+            case "message_delta": {
+                const reason = str(obj(event.delta)?.stop_reason);
+                if (reason && CUT_STOP_REASONS.has(reason))
+                    this.cutStop = true;
+                return;
+            }
+            case "message_start":
+                this.messageId = str(obj(event.message)?.id) ?? this.messageId;
+                return;
+            case "content_block_start": {
+                const block = obj(event.content_block);
+                if (index === undefined || !block)
+                    return;
+                if (!this.blocks.has(index) && this.blocks.size >= MAX_OPEN_BLOCKS)
+                    return;
+                const id = str(block.id);
+                const name = str(block.name);
+                if (block.type === "tool_use" && id && name) {
+                    this.blocks.set(index, { kind: "tool", id, name, buffer: "", truncated: false });
+                }
+                else if (block.type === "text") {
+                    const open = {
+                        kind: "said",
+                        id: `said:${this.messageId}:${index}`,
+                        name: "",
+                        buffer: "",
+                        truncated: false,
+                    };
+                    append(open, str(block.text) ?? "");
+                    this.blocks.set(index, open);
+                }
+                return;
+            }
+            case "content_block_delta": {
+                const open = index === undefined ? undefined : this.blocks.get(index);
+                const delta = obj(event.delta);
+                if (!open || !delta)
+                    return;
+                const piece = open.kind === "tool" ? str(delta.partial_json) : str(delta.text);
+                if (piece)
+                    append(open, piece);
+                return;
+            }
+            case "content_block_stop": {
+                const open = index === undefined ? undefined : this.blocks.get(index);
+                if (!open || index === undefined)
+                    return;
+                this.blocks.delete(index);
+                const step = closeBlock(open, this.options);
+                if (step)
+                    this.done.push(step);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+}
+/** One Responses output item as a step: function_call, custom_tool_call, or an assistant message. */
+export function openAiItemStep(value, options) {
+    const item = obj(value);
+    if (!item)
+        return undefined;
+    const callId = str(item.call_id);
+    const name = str(item.name);
+    switch (item.type) {
+        case "function_call": {
+            if (!callId || !name)
+                return undefined;
+            const tool = displayToolName(name, str(item.namespace));
+            const args = str(item.arguments) ?? "{}";
+            return {
+                kind: "tool",
+                callId,
+                tool,
+                ...toolStepText(tool, args),
+                ...(options?.detail
+                    ? { input: args.slice(0, MAX_STEP_TEXT_CHARS), inputTruncated: args.length > MAX_STEP_TEXT_CHARS }
+                    : {}),
+            };
+        }
+        case "custom_tool_call": {
+            if (!callId || !name)
+                return undefined;
+            const tool = displayToolName(name);
+            const input = str(item.input) ?? "";
+            // The input is free-form text: as a JSON string it takes toolStepText's free-form path, which
+            // marks the step cut when later lines are dropped.
+            const text = toolStepText(tool, JSON.stringify(input.slice(0, MAX_STEP_TEXT_CHARS)));
+            return {
+                kind: "tool",
+                callId,
+                tool,
+                text: text.text,
+                truncated: text.truncated || input.length > MAX_STEP_TEXT_CHARS,
+                ...(options?.detail
+                    ? { input: input.slice(0, MAX_STEP_TEXT_CHARS), inputTruncated: input.length > MAX_STEP_TEXT_CHARS }
+                    : {}),
+            };
+        }
+        case "message": {
+            const id = str(item.id);
+            if (!id || (item.role !== undefined && item.role !== "assistant"))
+                return undefined;
+            const parts = Array.isArray(item.content) ? item.content : [];
+            const text = parts
+                .map((part) => obj(part))
+                .filter((part) => part?.type === "output_text")
+                .map((part) => str(part?.text) ?? "")
+                .join("\n");
+            if (!text.trim())
+                return undefined;
+            // Codex's last message is its final answer as JSON: said as the answer's summary.
+            const out = codingResultStepText(text) ?? bounded(text);
+            return {
+                kind: "said",
+                callId: `said:${id}`,
+                text: out.text,
+                truncated: out.truncated || item.status === "incomplete",
+            };
+        }
+        default:
+            return undefined;
+    }
+}
+/** OpenAI Responses streams: one step per response.output_item.done. */
+export class OpenAiStreamSteps {
+    options;
+    done = [];
+    completed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    consume(frame) {
+        try {
+            if (!frame.includes("response.output_item.done") && !frame.includes("response.completed"))
+                return;
+            const event = sseData(frame);
+            if (event?.type === "response.completed") {
+                if (obj(event.response)?.status !== "incomplete")
+                    this.completed = true;
+                return;
+            }
+            if (event?.type !== "response.output_item.done")
+                return;
+            const step = openAiItemStep(event.item, this.options);
+            if (step)
+                this.done.push(step);
+        }
+        catch {
+            // A step is dropped, never the relay.
+        }
+    }
+    take() {
+        const out = this.done;
+        this.done = [];
+        return out;
+    }
+    finish() {
+        try {
+            // Anything but response.completed (incomplete, failed, an error or a cut stream) ended it early.
+            return markCut(this.take(), !this.completed);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export function streamStepExtractor(protocol, options) {
+    return protocol === "anthropic-messages" ? new AnthropicStreamSteps(options) : new OpenAiStreamSteps(options);
+}
+/** A whole (non-stream) reply's steps. */
+export function stepsFromJson(protocol, value, options) {
+    try {
+        const body = obj(value);
+        if (!body)
+            return [];
+        if (protocol === "openai-responses") {
+            const steps = (Array.isArray(body.output) ? body.output : []).flatMap((item) => openAiItemStep(item, options) ?? []);
+            return markCut(steps, body.status === "incomplete" || obj(body.incomplete_details) !== undefined);
+        }
+        const messageId = str(body.id) ?? "msg";
+        const steps = [];
+        (Array.isArray(body.content) ? body.content : []).forEach((value, index) => {
+            const block = obj(value);
+            const id = str(block?.id);
+            const name = str(block?.name);
+            const text = str(block?.text);
+            if (block?.type === "tool_use" && id && name === CLAUDE_RESULT_TOOL) {
+                steps.push(resultStep(id, JSON.stringify(block.input ?? {}), false));
+            }
+            else if (block?.type === "tool_use" && id && name) {
+                const tool = displayToolName(name);
+                const inputJson = JSON.stringify(block.input ?? {});
+                steps.push({
+                    kind: "tool",
+                    callId: id,
+                    tool,
+                    ...toolStepText(tool, inputJson),
+                    ...(options?.detail
+                        ? { input: inputJson.slice(0, MAX_STEP_TEXT_CHARS), inputTruncated: inputJson.length > MAX_STEP_TEXT_CHARS }
+                        : {}),
+                });
+            }
+            else if (block?.type === "text" && text?.trim()) {
+                steps.push({ kind: "said", callId: `said:${messageId}:${index}`, ...bounded(text) });
+            }
+        });
+        const reason = str(body.stop_reason);
+        return markCut(steps, reason !== undefined && CUT_STOP_REASONS.has(reason));
+    }
+    catch {
+        return [];
+    }
+}
+/** A result's status from its first lines: an exit line wins, else the error flag. */
+export function statusFromOutput(head, isError) {
+    const lines = head.slice(0, STATUS_HEAD_CHARS).split("\n").slice(0, 8).join("\n");
+    const match = EXIT_LINE.exec(lines);
+    if (!match)
+        return isError || SCRIPT_FAILED.test(lines) ? "error" : "ok";
+    const code = Number(match[1]);
+    if (code === 0)
+        return "ok";
+    return code > 0 && code < 1000 ? `exit ${code}` : "error";
+}
+/** The first STATUS_HEAD_CHARS of a result's text parts; images and other parts are skipped. */
+function contentHead(content) {
+    if (typeof content === "string")
+        return content.slice(0, STATUS_HEAD_CHARS);
+    if (!Array.isArray(content))
+        return "";
+    let head = "";
+    for (const part of content) {
+        const text = str(obj(part)?.text);
+        if (text === undefined)
+            continue;
+        head += head ? `\n${text}` : text;
+        if (head.length >= STATUS_HEAD_CHARS)
+            break;
+    }
+    return head.slice(0, STATUS_HEAD_CHARS);
+}
+/** The end of a result's text parts (images and other parts skipped), for the detail level. */
+function contentTail(content) {
+    if (typeof content === "string") {
+        const tail = tailOf(content);
+        return { output: tail.text, outputCut: tail.cut };
+    }
+    if (!Array.isArray(content))
+        return undefined;
+    const parts = [];
+    let size = 0;
+    let cut = false;
+    for (let index = content.length - 1; index >= 0; index--) {
+        const text = str(obj(content[index])?.text);
+        if (text === undefined)
+            continue;
+        if (size >= MAX_RESULT_OUTPUT_CHARS) {
+            cut = true;
+            break;
+        }
+        parts.unshift(text);
+        size += text.length + 1;
+    }
+    if (parts.length === 0)
+        return undefined;
+    const tail = tailOf(parts.join("\n"));
+    return { output: tail.text, outputCut: cut || tail.cut };
+}
+/** The results a request carries for the turn before it: the newest part of the history only. */
+export function resultsFromRequest(protocol, value, options) {
+    try {
+        const body = obj(value);
+        if (!body)
+            return [];
+        if (protocol === "anthropic-messages") {
+            const messages = Array.isArray(body.messages) ? body.messages : [];
+            const results = [];
+            // Every user message after the last assistant message: results may be split from a following text.
+            for (let index = messages.length - 1; index >= 0; index--) {
+                const message = obj(messages[index]);
+                if (message?.role === "system")
+                    continue;
+                if (message?.role !== "user")
+                    break;
+                if (!Array.isArray(message.content))
+                    continue;
+                for (let at = message.content.length - 1; at >= 0; at--) {
+                    const block = obj(message.content[at]);
+                    const callId = str(block?.tool_use_id);
+                    if (block?.type !== "tool_result" || !callId)
+                        continue;
+                    results.push({
+                        callId,
+                        status: statusFromOutput(contentHead(block.content), block.is_error === true),
+                        ...(options?.detail ? (contentTail(block.content) ?? {}) : {}),
+                    });
+                }
+            }
+            return results.slice(0, MAX_RESULTS_PER_REQUEST).reverse();
+        }
+        const input = Array.isArray(body.input) ? body.input : [];
+        // The newest turn: past trailing user/developer messages, the run of calls and their outputs
+        // (they interleave), back to a reasoning item, an assistant message or anything else.
+        let end = input.length;
+        while (end > 0) {
+            const item = obj(input[end - 1]);
+            if (item?.type === "message" && (item.role === "user" || item.role === "developer"))
+                end--;
+            else
+                break;
+        }
+        const results = [];
+        for (let index = end - 1; index >= 0 && results.length < MAX_RESULTS_PER_REQUEST; index--) {
+            const item = obj(input[index]);
+            const type = str(item?.type);
+            if (type && OUTPUT_ITEMS.has(type)) {
+                const callId = str(item?.call_id);
+                if (callId) {
+                    results.push({
+                        callId,
+                        status: statusFromOutput(contentHead(item?.output), false),
+                        ...(options?.detail ? (contentTail(item?.output) ?? {}) : {}),
+                    });
+                }
+            }
+            else if (!type || !CALL_ITEMS.has(type))
+                break;
+        }
+        return results.reverse();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/core/run-steps/ingress.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The control plane's run-steps listener (WARDBY_RUN_STEPS_LISTEN, `wardby serve` only): the coding
+ * proxy posts each coding run's steps here with the step text unmasked, and this process redacts
+ * them by exact value (RunStepWriter, the same stepSummarizer path as native runs) before anything
+ * is stored. A listener of its own, so the MCP endpoint's canonical-Host check and its public
+ * exposure are untouched.
+ *
+ * Each request is authenticated by the run capability (`rrp_…`), found by its hash in the run's
+ * proxy session, from the headers alone: the body is read only for a live session. The run's worker
+ * and the proxy both hold this capability (it is also the worker's model API key), so it does not
+ * tell the proxy from the worker: it limits a caller to its own run (a batch naming any other run
+ * is refused, run_mismatch), and only the deployment's network policy keeps workers off this port.
+ * The capability is handed to the writer as one more exact value to redact,
+ * so a copy of it the model wrote, glued to other text or cut off at the end of a step, is masked
+ * like the agent's own secrets. The run's MCP token (`rmt_…`) can't be passed the same way: only
+ * its hash is stored, and the value leaves the control plane's memory once the job is launched; it
+ * is masked by its token shape instead.
+ *
+ * Secrets: the request body, the step text and the Authorization value are never logged, echoed or
+ * stored by this module. Log lines carry a fixed event, a status and an error's name only (never an
+ * error's message: a database or writer error may quote the lookup or the text); every response
+ * body is a fixed code.
+ */
+import { type Server } from "node:http";
+import type { PrismaClient } from "#prisma";
+import { type ListenAddress } from "../listen-address.js";
+import { type RunStepSink } from "./types.js";
+/** Open connections at once; Node accepts and then closes any beyond this (they do not wait in the listen backlog). */
+export declare const MAX_INGRESS_CONNECTIONS = 64;
+export interface RunStepIngressDeps {
+    db: Pick<PrismaClient, "codingProxySession">;
+    sink: RunStepSink;
+    now?: () => Date;
+    log?: {
+        warn(fields: Record<string, unknown>, message: string): void;
+    };
+    /** Tests only; HTTP_LIMITS.requestMs (15 s, under the forwarder's 20 s) otherwise. */
+    requestTimeoutMs?: number;
+}
+export interface RunStepIngressResponse {
+    status: number;
+    body: {
+        ok: true;
+    } | {
+        error: string;
+    };
+}
+export declare function handleRunStepPost(deps: RunStepIngressDeps, authorization: string | undefined, body: string): Promise<RunStepIngressResponse>;
+/** WARDBY_RUN_STEPS_LISTEN: `host:port` or `:port`; unset or blank = no listener. */
+export declare function parseRunStepsListen(value: string | undefined): ListenAddress | undefined;
+export declare function startRunStepIngress(listen: ListenAddress, deps: RunStepIngressDeps): Promise<Server>;

package/dist/core/run-steps/ingress.js

@@ -0,0 +1,160 @@
+/**
+ * The control plane's run-steps listener (WARDBY_RUN_STEPS_LISTEN, `wardby serve` only): the coding
+ * proxy posts each coding run's steps here with the step text unmasked, and this process redacts
+ * them by exact value (RunStepWriter, the same stepSummarizer path as native runs) before anything
+ * is stored. A listener of its own, so the MCP endpoint's canonical-Host check and its public
+ * exposure are untouched.
+ *
+ * Each request is authenticated by the run capability (`rrp_…`), found by its hash in the run's
+ * proxy session, from the headers alone: the body is read only for a live session. The run's worker
+ * and the proxy both hold this capability (it is also the worker's model API key), so it does not
+ * tell the proxy from the worker: it limits a caller to its own run (a batch naming any other run
+ * is refused, run_mismatch), and only the deployment's network policy keeps workers off this port.
+ * The capability is handed to the writer as one more exact value to redact,
+ * so a copy of it the model wrote, glued to other text or cut off at the end of a step, is masked
+ * like the agent's own secrets. The run's MCP token (`rmt_…`) can't be passed the same way: only
+ * its hash is stored, and the value leaves the control plane's memory once the job is launched; it
+ * is masked by its token shape instead.
+ *
+ * Secrets: the request body, the step text and the Authorization value are never logged, echoed or
+ * stored by this module. Log lines carry a fixed event, a status and an error's name only (never an
+ * error's message: a database or writer error may quote the lookup or the text); every response
+ * body is a fixed code.
+ */
+import { createServer } from "node:http";
+import { deriveRegistryToken } from "../../coding/registry/token.js";
+import { capabilityHash } from "../../providers/coding-proxy/capability-hash.js";
+import { HTTP_LIMITS, HttpBoundaryError, readBody } from "../../mcp/transport/http-limits.js";
+import { parseListenAddress } from "../listen-address.js";
+import { logger } from "../logger.js";
+import { MAX_RUN_STEPS_POST_BYTES, RUN_STEPS_INGRESS_PATH } from "./types.js";
+import { parseRunStepPost } from "./wire.js";
+const ingressLog = logger.child({ module: "run-steps" });
+/** `rrp_` + 32 random bytes, base64url (CodingProxy.createSession). */
+const CAPABILITY = /^rrp_[A-Za-z0-9_-]{43}$/;
+/** A reply that finished just before the session's deadline may still be in the forwarder's queue. */
+const SESSION_GRACE_MS = 10 * 60_000;
+/** Open connections at once; Node accepts and then closes any beyond this (they do not wait in the listen backlog). */
+export const MAX_INGRESS_CONNECTIONS = 64;
+/** How often Node checks requestTimeout and headersTimeout (its default, 30 s, would let a slow client stay). */
+const CONNECTIONS_CHECK_MS = 2_000;
+/** Fixed codes for the HTTP boundary's refusals; any other status is "bad_request". */
+const BOUNDARY_CODES = { 413: "payload_too_large", 415: "unsupported_encoding" };
+class RequestTimeoutError extends Error {
+    name = "TimeoutError";
+}
+/** From the Authorization header alone: the caller's live session, or the refusal. */
+async function authenticate(deps, authorization) {
+    const token = /^Bearer (\S+)$/.exec(authorization ?? "")?.[1];
+    if (!token || !CAPABILITY.test(token))
+        return { status: 401, body: { error: "unauthorized" } };
+    const session = await deps.db.codingProxySession.findUnique({
+        where: { capabilityHash: capabilityHash(token) },
+        select: { runId: true, deadlineAt: true },
+    });
+    if (!session)
+        return { status: 401, body: { error: "unauthorized" } };
+    // Only the deadline counts (a cancelled session's last steps still land): bounded by the grace.
+    const now = (deps.now ?? (() => new Date()))();
+    if (session.deadlineAt.getTime() + SESSION_GRACE_MS < now.getTime()) {
+        return { status: 403, body: { error: "session_ended" } };
+    }
+    return { runId: session.runId, capability: token };
+}
+/** An authenticated caller's body: parsed, bound to its run, then written. */
+async function accept(deps, caller, body) {
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return { status: 400, body: { error: "invalid_json" } };
+    }
+    const post = parseRunStepPost(value);
+    if (!post)
+        return { status: 400, body: { error: "invalid_batch" } };
+    // A capability names one run: a batch for any other run is refused, never written there.
+    if (post.runId !== caller.runId)
+        return { status: 403, body: { error: "run_mismatch" } };
+    await deps.sink.record(caller.runId, post.batch, [caller.capability, deriveRegistryToken(caller.capability)]);
+    return { status: 202, body: { ok: true } };
+}
+export async function handleRunStepPost(deps, authorization, body) {
+    const caller = await authenticate(deps, authorization);
+    return "status" in caller ? caller : accept(deps, caller, body);
+}
+/** WARDBY_RUN_STEPS_LISTEN: `host:port` or `:port`; unset or blank = no listener. */
+export function parseRunStepsListen(value) {
+    return parseListenAddress("WARDBY_RUN_STEPS_LISTEN", value);
+}
+/**
+ * Writes a fixed answer. A refusal also closes the connection once the answer is out: its body
+ * may be unread, and is never drained.
+ */
+function send(res, status, body) {
+    const refusal = status >= 300;
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "cache-control": "no-store",
+        ...(refusal ? { connection: "close" } : {}),
+    });
+    if (refusal)
+        res.once("finish", () => res.socket?.destroy());
+    res.end(JSON.stringify(body));
+}
+const errorName = (err) => (err instanceof Error ? err.name : typeof err);
+export function startRunStepIngress(listen, deps) {
+    const log = deps.log ?? ingressLog;
+    const limitMs = deps.requestTimeoutMs ?? HTTP_LIMITS.requestMs;
+    const serve = async (req, res) => {
+        if (req.method !== "POST" || req.url !== RUN_STEPS_INGRESS_PATH)
+            return send(res, 404, { error: "not_found" });
+        // One limit for the whole request (lookup, body, write), so the forwarder always gets an answer.
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), limitMs);
+        const timedOut = new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(new RequestTimeoutError()), { once: true }));
+        const work = (async () => {
+            const caller = await authenticate(deps, req.headers.authorization);
+            if ("status" in caller)
+                return caller;
+            const body = await readBody(req, MAX_RUN_STEPS_POST_BYTES, controller.signal);
+            return accept(deps, caller, body);
+        })();
+        // After a timeout answer, a failure that lands later is logged by name only (the body read's
+        // own abort is not a failure).
+        work.catch((err) => {
+            if (controller.signal.aborted && !(err instanceof HttpBoundaryError)) {
+                log.warn({ event: "run_steps_ingress_late_failure", errorName: errorName(err) }, "run steps request failed late");
+            }
+        });
+        try {
+            const result = await Promise.race([work, timedOut]);
+            send(res, result.status, result.body);
+        }
+        catch (err) {
+            const timeout = err instanceof RequestTimeoutError;
+            const status = timeout ? 503 : err instanceof HttpBoundaryError ? err.status : 500;
+            const code = timeout ? "timeout" : status === 500 ? "internal" : (BOUNDARY_CODES[status] ?? "bad_request");
+            log.warn({ event: "run_steps_ingress_failed", status, errorName: errorName(err) }, "run steps request failed");
+            if (!res.headersSent)
+                send(res, status, { error: code });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    const server = createServer({
+        maxHeaderSize: 16 * 1024,
+        requestTimeout: limitMs,
+        headersTimeout: Math.min(HTTP_LIMITS.headersMs, limitMs),
+        connectionsCheckingInterval: Math.min(CONNECTIONS_CHECK_MS, limitMs),
+    }, (req, res) => void serve(req, res));
+    server.maxConnections = MAX_INGRESS_CONNECTIONS;
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(listen.port, listen.host, () => {
+            server.off("error", reject);
+            resolve(server);
+        });
+    });
+}