@wardby/cli 0.7.0 → 0.9.0

package/dist/core/run-steps/last-step.d.ts

@@ -0,0 +1,15 @@
+/** Each run's newest step, for get_run and cross-agent list_runs (the runs pane's one-line "now"). */
+import { type PrismaClient } from "#prisma";
+export interface LastStep {
+    seq: number;
+    at: string;
+    kind: string;
+    tool: string | null;
+    summary: string;
+    status: string | null;
+    /** "Bash: npm test (exit 1)", "said: Running the tests." */
+    line: string;
+}
+export declare function stepLine(step: Pick<LastStep, "kind" | "tool" | "summary" | "status">): string;
+/** One indexed DISTINCT ON query. Best effort: a failure lists the runs without it, never an error. */
+export declare function loadLastSteps(db: Pick<PrismaClient, "$queryRaw">, runIds: readonly string[]): Promise<Map<string, LastStep>>;

package/dist/core/run-steps/last-step.js

@@ -0,0 +1,35 @@
+/** Each run's newest step, for get_run and cross-agent list_runs (the runs pane's one-line "now"). */
+import { Prisma } from "#prisma";
+import { logger } from "../logger.js";
+const lastStepLog = logger.child({ module: "run-steps" });
+export function stepLine(step) {
+    const head = step.kind === "tool" ? `${step.tool ?? "tool"}: ${step.summary}` : `said: ${step.summary}`;
+    return step.status && step.status !== "ok" ? `${head} (${step.status})` : head;
+}
+/** One indexed DISTINCT ON query. Best effort: a failure lists the runs without it, never an error. */
+export async function loadLastSteps(db, runIds) {
+    if (runIds.length === 0)
+        return new Map();
+    try {
+        const rows = await db.$queryRaw `
+      SELECT DISTINCT ON ("runId") "runId", "seq", "at", "kind", "tool", "summary", "status"
+      FROM "RunStep" WHERE "runId" IN (${Prisma.join([...runIds])})
+      ORDER BY "runId", "seq" DESC`;
+        return new Map(rows.map((row) => [
+            row.runId,
+            {
+                seq: row.seq,
+                at: row.at.toISOString(),
+                kind: row.kind,
+                tool: row.tool,
+                summary: row.summary,
+                status: row.status,
+                line: stepLine(row),
+            },
+        ]));
+    }
+    catch (err) {
+        lastStepLog.warn({ event: "run_steps_last_step_failed", errorName: err instanceof Error ? err.name : typeof err }, "could not read runs' last steps; listing them without");
+        return new Map();
+    }
+}

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

@@ -0,0 +1,48 @@
+import type { EngineTurnEvent } from "../../providers/engine/types.js";
+import type { LlmMessage, LlmStreamEvent } from "../../providers/llm/types.js";
+import { type ExtractedResult, type ExtractedStep, type RunStepBatch, type RunStepSink, type StepStatus } from "./types.js";
+export declare function nativeToolStatus(content: string): StepStatus;
+/** A native tool result's text for the detail level: the untrusted-output wrapper removed, its end only. */
+export declare function nativeResultOutput(content: string): {
+    output: string;
+    outputCut: boolean;
+};
+export declare function nativeTurnSteps(turnKey: string, text: string, toolCalls: readonly {
+    id: string;
+    name: string;
+    argsJson: string;
+}[]): ExtractedStep[];
+export declare function nativeToolResults(toolCalls: readonly {
+    id: string;
+}[], results: readonly string[]): ExtractedResult[];
+/** The results a model request carries for the previous turn: the `tool` messages after the last assistant one. */
+export declare function nativeRequestResults(messages: readonly LlmMessage[]): ExtractedResult[];
+/** How long a gateway's stream end waits for its steps to be written; past it the write goes on alone. */
+export declare const STREAM_STEPS_BOUND_MS = 2000;
+/**
+ * Collects one model call's steps from its events. The said step's id is a hash of `callId` (the
+ * worker-chosen request id), so no worker text is stored as an id.
+ */
+export declare class NativeStreamSteps {
+    private text;
+    private truncated;
+    private readonly calls;
+    private readonly key;
+    constructor(callId: string);
+    observe(event: LlmStreamEvent): void;
+    steps(): ExtractedStep[];
+}
+/**
+ * A native gateway's stream end: records the call's steps and the results its request carries for
+ * the previous turn, so the next call's results find these steps. Never throws, and waits at most
+ * `boundMs`: past it the stream ends and the write finishes in the background (the writer logs its
+ * own failures, name only).
+ */
+export declare function recordStreamSteps(sink: RunStepSink | undefined, runId: string, tap: Pick<NativeStreamSteps, "steps"> | undefined, messages: readonly LlmMessage[], extraSecretValues?: readonly string[], boundMs?: number): Promise<void>;
+/** One engine turn event's batch: a turn's said and tool steps, or its tool calls' results. */
+export declare function nativeTurnBatch(event: EngineTurnEvent): RunStepBatch;
+/**
+ * The engine's `onTurn` for a run: hands each non-empty batch to the writer and does not wait for
+ * it. A throw here reaches the engine, which logs it by name and goes on.
+ */
+export declare function runStepsHook(sink: RunStepSink | undefined, runId: string): ((event: EngineTurnEvent) => void) | undefined;

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

@@ -0,0 +1,164 @@
+/**
+ * Steps of native runs. The in-process engine knows each call's result; the native gateways see
+ * the model's events and, in the next request, the trailing `role: "tool"` messages. A tool
+ * result's content is kept only as a bounded tail for the writer, which stores it only for a run
+ * at the detail level, redacted. Its status is whether it starts as the runner's JSON error.
+ */
+import { createHash } from "node:crypto";
+import { logger } from "../logger.js";
+import { UNTRUSTED_TOOL_OUTPUT_TAG } from "../untrusted-content.js";
+import { bounded, displayToolName, toolStepText } from "./summarize.js";
+import { MAX_STEP_TEXT_CHARS, tailOf, } from "./types.js";
+const stepsLog = logger.child({ module: "run-steps" });
+const UNTRUSTED_OPEN = `<${UNTRUSTED_TOOL_OUTPUT_TAG}>\n`;
+const UNTRUSTED_CLOSE = `\n</${UNTRUSTED_TOOL_OUTPUT_TAG}>`;
+/** runSandboxTool's failure shape: `{"error": ...}` (src/providers/engine/types.ts). */
+const ERROR_RESULT = /^\s*\{\s*"error"\s*:/;
+export function nativeToolStatus(content) {
+    const raw = content.startsWith(UNTRUSTED_OPEN) ? content.slice(UNTRUSTED_OPEN.length) : content;
+    return ERROR_RESULT.test(raw.slice(0, 64)) ? "error" : "ok";
+}
+/** A native tool result's text for the detail level: the untrusted-output wrapper removed, its end only. */
+export function nativeResultOutput(content) {
+    let raw = content.startsWith(UNTRUSTED_OPEN) ? content.slice(UNTRUSTED_OPEN.length) : content;
+    if (raw.endsWith(UNTRUSTED_CLOSE))
+        raw = raw.slice(0, -UNTRUSTED_CLOSE.length);
+    // Upstream caps (the MCP client's) keep a result's head and drop its end, after redacting the
+    // whole result (core/mcp-client/results.ts redacts before it cuts), so no secret is split
+    // there; only this cut drops a head, so only it sets outputCut.
+    const tail = tailOf(raw);
+    return { output: tail.text, outputCut: tail.cut };
+}
+export function nativeTurnSteps(turnKey, text, toolCalls) {
+    const steps = [];
+    if (text.trim())
+        steps.push({ kind: "said", callId: `said:${turnKey}`, ...bounded(text) });
+    for (const call of toolCalls) {
+        const tool = displayToolName(call.name);
+        steps.push({
+            kind: "tool",
+            callId: call.id,
+            tool,
+            ...toolStepText(tool, call.argsJson),
+            input: call.argsJson.slice(0, MAX_STEP_TEXT_CHARS),
+            inputTruncated: call.argsJson.length > MAX_STEP_TEXT_CHARS,
+        });
+    }
+    return steps;
+}
+export function nativeToolResults(toolCalls, results) {
+    return toolCalls.map((call, index) => {
+        const content = results[index] ?? "";
+        return { callId: call.id, status: nativeToolStatus(content), ...nativeResultOutput(content) };
+    });
+}
+/** The results a model request carries for the previous turn: the `tool` messages after the last assistant one. */
+export function nativeRequestResults(messages) {
+    let lastAssistant = -1;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        if (messages[index].role === "assistant") {
+            lastAssistant = index;
+            break;
+        }
+    }
+    const results = [];
+    // A trailing non-tool message (the engine's wind-down `user` message) does not hide the results.
+    for (const message of messages.slice(lastAssistant + 1)) {
+        if (message.role === "tool" && message.toolCallId) {
+            results.push({
+                callId: message.toolCallId,
+                status: nativeToolStatus(message.content),
+                ...nativeResultOutput(message.content),
+            });
+        }
+    }
+    return results;
+}
+/** How long a gateway's stream end waits for its steps to be written; past it the write goes on alone. */
+export const STREAM_STEPS_BOUND_MS = 2_000;
+/**
+ * Collects one model call's steps from its events. The said step's id is a hash of `callId` (the
+ * worker-chosen request id), so no worker text is stored as an id.
+ */
+export class NativeStreamSteps {
+    text = "";
+    truncated = false;
+    calls = [];
+    key;
+    constructor(callId) {
+        this.key = createHash("sha256").update(callId).digest("hex").slice(0, 32);
+    }
+    observe(event) {
+        try {
+            if (event.type === "text") {
+                if (this.text.length + event.delta.length > MAX_STEP_TEXT_CHARS) {
+                    this.text = (this.text + event.delta).slice(0, MAX_STEP_TEXT_CHARS);
+                    this.truncated = true;
+                }
+                else
+                    this.text += event.delta;
+            }
+            else if (event.type === "tool_call") {
+                this.calls.push({ id: event.id, name: event.name, argsJson: event.argsJson });
+            }
+        }
+        catch {
+            // A step is dropped, never the stream.
+        }
+    }
+    steps() {
+        const steps = nativeTurnSteps(this.key, this.text, this.calls);
+        if (this.truncated && steps[0]?.kind === "said")
+            steps[0] = { ...steps[0], truncated: true };
+        return steps;
+    }
+}
+/**
+ * A native gateway's stream end: records the call's steps and the results its request carries for
+ * the previous turn, so the next call's results find these steps. Never throws, and waits at most
+ * `boundMs`: past it the stream ends and the write finishes in the background (the writer logs its
+ * own failures, name only).
+ */
+export async function recordStreamSteps(sink, runId, tap, messages, extraSecretValues = [], boundMs = STREAM_STEPS_BOUND_MS) {
+    if (!sink || !tap)
+        return;
+    let write;
+    try {
+        const batch = { steps: tap.steps(), results: nativeRequestResults(messages) };
+        write = Promise.resolve(sink.record(runId, batch, extraSecretValues)).catch(() => undefined);
+    }
+    catch (err) {
+        stepsLog.warn({ runId, event: "run_steps_write_failed", errorName: err instanceof Error ? err.name : typeof err }, "could not record a run's steps; they were dropped");
+        return;
+    }
+    let timer;
+    const bound = new Promise((resolve) => {
+        timer = setTimeout(resolve, boundMs);
+    });
+    try {
+        await Promise.race([write, bound]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** One engine turn event's batch: a turn's said and tool steps, or its tool calls' results. */
+export function nativeTurnBatch(event) {
+    return event.kind === "turn"
+        ? { steps: nativeTurnSteps(`turn:${event.turn}`, event.text, event.toolCalls), results: [] }
+        : { steps: [], results: nativeToolResults(event.toolCalls, event.results) };
+}
+/**
+ * The engine's `onTurn` for a run: hands each non-empty batch to the writer and does not wait for
+ * it. A throw here reaches the engine, which logs it by name and goes on.
+ */
+export function runStepsHook(sink, runId) {
+    if (!sink)
+        return undefined;
+    return (event) => {
+        const batch = nativeTurnBatch(event);
+        if (batch.steps.length === 0 && batch.results.length === 0)
+            return;
+        void sink.record(runId, batch);
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * The coding proxy's memory of which tool results it already handed over, per proxy session: every
+ * request resends the history, so the same result arrives many times. Bounded (oldest sessions and
+ * ids forgotten first); the control plane's writer ignores a repeat anyway (first status wins).
+ */
+export declare class SeenIds {
+    private readonly maxSessions;
+    private readonly maxIdsPerSession;
+    private readonly bySession;
+    constructor(maxSessions?: number, maxIdsPerSession?: number);
+    fresh<T extends {
+        callId: string;
+    }>(sessionId: string, items: readonly T[]): T[];
+    /** Drops a session's ids: called when its proxy session has ended. */
+    forget(sessionId: string): void;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * The coding proxy's memory of which tool results it already handed over, per proxy session: every
+ * request resends the history, so the same result arrives many times. Bounded (oldest sessions and
+ * ids forgotten first); the control plane's writer ignores a repeat anyway (first status wins).
+ */
+export class SeenIds {
+    maxSessions;
+    maxIdsPerSession;
+    bySession = new Map();
+    constructor(maxSessions = 512, maxIdsPerSession = 1024) {
+        this.maxSessions = maxSessions;
+        this.maxIdsPerSession = maxIdsPerSession;
+    }
+    fresh(sessionId, items) {
+        let seen = this.bySession.get(sessionId);
+        if (!seen) {
+            if (this.bySession.size >= this.maxSessions)
+                this.bySession.delete(this.bySession.keys().next().value);
+            seen = new Set();
+            this.bySession.set(sessionId, seen);
+        }
+        const ids = seen;
+        const out = items.filter((item) => !ids.has(item.callId));
+        for (const item of out) {
+            ids.add(item.callId);
+            if (ids.size > this.maxIdsPerSession)
+                ids.delete(ids.values().next().value);
+        }
+        return out;
+    }
+    /** Drops a session's ids: called when its proxy session has ended. */
+    forget(sessionId) {
+        this.bySession.delete(sessionId);
+    }
+}

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

@@ -0,0 +1,57 @@
+import { type ExtractedStep } from "./types.js";
+/** Claude Code's one shell tool through the coding proxy (src/providers/coding-proxy/proxy.ts). */
+export declare const CLAUDE_COMMAND_TOOL = "mcp__wardby_tools__run_command";
+export declare function bounded(text: string): {
+    text: string;
+    truncated: boolean;
+};
+/** A tool's name as a step shows it; anything that isn't a plain name becomes "tool". */
+export declare function displayToolName(name: string, namespace?: string): string;
+/** The text a tool step's summary is cut from: the command, the path, the pattern, or the first argument. */
+export declare function toolInputText(tool: string, input: unknown): string;
+/** A tool step's text from its JSON arguments (complete or cut off). */
+export declare function toolStepText(tool: string, argsJson: string): {
+    text: string;
+    truncated: boolean;
+};
+/** Claude Code's tool for a coding run's final answer (the coding proxy allows it by this name). */
+export declare const CLAUDE_RESULT_TOOL = "StructuredOutput";
+/** A final answer's step when it has no summary of its own. */
+export declare const FINISHED_STEP_TEXT = "Finished";
+/**
+ * A coding run's final structured answer (`{"schemaVersion":1,...,"summary":"..."}`: Claude Code's
+ * StructuredOutput input, Codex's last message) as the text of one said step: the answer's own
+ * summary, else a fixed Finished line. `undefined` when the text is not such an answer. A cut answer
+ * gives its summary as far as it goes, marked truncated. The text is redacted later, with every
+ * other step's, by stepSummarizer.
+ */
+export declare function codingResultStepText(json: string): {
+    text: string;
+    truncated: boolean;
+} | undefined;
+export declare const collapseWhitespace: (text: string) => string;
+/**
+ * Every form a secret value can take in a collapsed step text, longest first: each value as
+ * written and whitespace-collapsed (the model wrote it with other whitespace), each of those
+ * JSON-escaped (withEscapedForms: a value inside JSON text), and each of those collapsed.
+ */
+export declare function secretForms(secretValues: readonly string[]): string[];
+/**
+ * The longest proper prefix of any form (at least the minimum length) that `text` ends with, or
+ * "" if none. Linear in the text per form (a KMP scan), whatever the forms look like. `tables`
+ * holds each form's failure table, built the first time a cut text needs it.
+ */
+export declare function secretTail(text: string, forms: readonly string[], tables: Map<string, Int32Array>): string;
+/**
+ * Summaries for one batch, against every secret value delivered to the run (the agent's and the
+ * run's own, such as its capability). The forms are built once per batch. Each step's text (at
+ * most 16 KiB) is whitespace collapsed, then redacted once with the shared redactor
+ * (redactSecrets: the union of every occurrence of every form, then token shapes), then cut to 100
+ * characters (tool) or 120 (said). Any text may end in the start of a secret (it was cut, or a
+ * stream stopped early without saying so), so on every step the longest such start (secretTail,
+ * on the collapsed text before any masking) is redacted in the same pass as one more exact value,
+ * so it merges with any whole secret it overlaps.
+ */
+export declare function stepSummarizer(secretValues: readonly string[]): (step: Pick<ExtractedStep, "kind" | "text" | "truncated">) => string;
+/** One step's stored summary (stepSummarizer, for a single step). */
+export declare function stepSummary(step: Pick<ExtractedStep, "kind" | "text" | "truncated">, secretValues: readonly string[]): string;