@better-fs-tools/shell 0.0.0-tegami-trusted-publish-setup → 0.1.0

package/dist/core/execute.js

@@ -0,0 +1,272 @@
+import { delay, unref } from "./abort.js";
+import { OutputCapture } from "./capture.js";
+import { isRecord } from "./input.js";
+import { extensionFailure } from "./stages.js";
+import { StageStop, errorNote, messageOf, warning } from "./stop.js";
+const DRAIN_AFTER_EXIT_MS = 1_000;
+const EXIT_WAIT_AFTER_KILL_GRACE_MS = 1_000;
+export async function execute(scope, runner, planned, env) {
+    const { deps } = scope;
+    const { limits, messages } = deps;
+    const spill = await openSpill(scope, planned);
+    const controller = new AbortController();
+    let stoppedBy = null;
+    let exited = false;
+    const stop = (reason) => {
+        if (exited || stoppedBy !== null)
+            return;
+        stoppedBy = reason;
+        controller.abort();
+    };
+    const { signal } = scope.call;
+    const onAbort = () => stop("abort");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => stop("timeout"), planned.timeoutMs);
+    unref(timer);
+    const release = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+    };
+    const started = Date.now();
+    let handle;
+    try {
+        handle = startRun(runner, {
+            command: planned.command,
+            cwd: planned.cwd,
+            env,
+            signal: controller.signal,
+            killGraceMs: limits.killGraceMs,
+        });
+    }
+    catch (error) {
+        release();
+        await spill?.close().catch(() => undefined);
+        throw startFailure(scope, messageOf(error));
+    }
+    if (signal?.aborted)
+        stop("abort");
+    const capture = new OutputCapture(limits);
+    const iterator = handle.output[Symbol.asyncIterator]();
+    let skippedChunks = 0;
+    let streamFailed = null;
+    let streamEnded = false;
+    let outputReleased = false;
+    const drain = (async () => {
+        try {
+            for (;;) {
+                const next = await iterator.next();
+                if (outputReleased)
+                    return;
+                if (next.done === true) {
+                    streamEnded = true;
+                    return;
+                }
+                const chunk = validChunk(next.value);
+                if (chunk === null) {
+                    skippedChunks += 1;
+                    continue;
+                }
+                capture.push(chunk);
+                spill?.write(chunk.bytes);
+                if (capture.totalBytes > limits.maxCaptureBytes)
+                    stop("output-cap");
+            }
+        }
+        catch (error) {
+            streamFailed = messageOf(error);
+        }
+    })();
+    const exitPromise = settleExit(handle.exit).then((exit) => {
+        exited = true;
+        release();
+        return exit;
+    });
+    const exit = await exitOrGiveUpAfterStop(exitPromise, controller.signal, limits.killGraceMs);
+    const drainMs = exit === null ? 0 : DRAIN_AFTER_EXIT_MS;
+    const drainWait = delay(drainMs);
+    await Promise.race([drain, drainWait.done]);
+    drainWait.cancel();
+    // A background child may still hold the output stream open.
+    outputReleased = true;
+    void Promise.resolve(iterator.return?.()).catch(() => undefined);
+    release();
+    const durationMs = Date.now() - started;
+    if (exit?.error !== undefined) {
+        await spill?.close().catch(() => undefined);
+        throw startError(scope, exit.error.reason, exit.error.detail ?? null, planned.cwd);
+    }
+    const spillRef = await (spill?.close() ?? Promise.resolve(null));
+    if (spill?.failed === true) {
+        scope.notes.push(warning("spill-failed", messages.spillFailed({ sink: deps.spill?.id ?? "unknown" })));
+    }
+    const reason = stoppedBy;
+    if (exit === null)
+        scope.notes.push(warning("unconfirmed-stop", messages.unconfirmedStop()));
+    // After a stop, a runner may end its stream early or with an error.
+    const failed = reason === null ? streamFailed : null;
+    const unfinished = reason === null && failed === null && !streamEnded ? drainMs : null;
+    if (failed !== null || unfinished !== null || skippedChunks > 0) {
+        scope.notes.push(warning("output-incomplete", messages.outputIncomplete({ detail: failed, skippedChunks, drainMs: unfinished }), {
+            skippedChunks,
+            ...(failed === null ? {} : { detail: failed }),
+            ...(unfinished === null ? {} : { drainMs: unfinished }),
+        }));
+    }
+    return {
+        run: {
+            command: planned.command,
+            cwd: planned.cwd,
+            timeoutMs: planned.timeoutMs,
+            exitCode: exit?.code ?? null,
+            signal: exit?.signal ?? null,
+            durationMs,
+            stoppedBy: reason,
+            unconfirmedStop: exit === null,
+        },
+        output: capture.view(limits, spillRef),
+        stop: runStop(scope, reason, durationMs),
+    };
+}
+function runStop(scope, reason, durationMs) {
+    const { messages, limits } = scope.deps;
+    if (reason === "abort") {
+        return new StageStop("ABORTED", "run", errorNote("ABORTED", messages.aborted({ durationMs })));
+    }
+    if (reason === "output-cap") {
+        const message = messages.outputCap({ limit: limits.maxCaptureBytes });
+        return new StageStop("OUTPUT_CAP", "run", errorNote("OUTPUT_CAP", message));
+    }
+    return null;
+}
+function startRun(runner, request) {
+    const handle = runner.run(request);
+    if (!isRecord(handle) ||
+        !isRecord(handle.output) ||
+        typeof handle.output[Symbol.asyncIterator] !==
+            "function" ||
+        !isRecord(handle.exit) ||
+        typeof handle.exit.then !== "function") {
+        throw new TypeError("the runner returned a malformed handle");
+    }
+    return handle;
+}
+async function exitOrGiveUpAfterStop(exit, stopped, killGraceMs) {
+    let onStop;
+    let giveUp;
+    const late = new Promise((resolve) => {
+        onStop = () => {
+            giveUp = delay(killGraceMs + EXIT_WAIT_AFTER_KILL_GRACE_MS);
+            void giveUp.done.then(() => resolve(null));
+        };
+        if (stopped.aborted)
+            onStop();
+        else
+            stopped.addEventListener("abort", onStop, { once: true });
+    });
+    try {
+        return await Promise.race([exit, late]);
+    }
+    finally {
+        if (onStop !== undefined)
+            stopped.removeEventListener("abort", onStop);
+        giveUp?.cancel();
+    }
+}
+async function settleExit(exit) {
+    try {
+        const value = await exit;
+        if (!isRecord(value))
+            throw new TypeError("malformed exit");
+        const code = typeof value.code === "number" ? value.code : null;
+        const signal = typeof value.signal === "string" ? value.signal : null;
+        const { error } = value;
+        if (isRecord(error) && typeof error.reason === "string") {
+            const reason = error.reason;
+            const detail = typeof error.detail === "string" ? error.detail : undefined;
+            return { code, signal, error: detail === undefined ? { reason } : { reason, detail } };
+        }
+        return { code, signal };
+    }
+    catch (error) {
+        return {
+            code: null,
+            signal: null,
+            error: { reason: "spawn-failed", detail: messageOf(error) },
+        };
+    }
+}
+function validChunk(value) {
+    if (!isRecord(value) || !(value.bytes instanceof Uint8Array))
+        return null;
+    return { stream: value.stream === "stderr" ? "stderr" : "stdout", bytes: value.bytes };
+}
+function startFailure(scope, detail) {
+    const message = scope.deps.messages.spawnFailed({ detail });
+    return new StageStop("SPAWN_FAILED", "run", errorNote("SPAWN_FAILED", message));
+}
+function startError(scope, reason, detail, cwd) {
+    const { messages } = scope.deps;
+    if (reason === "cwd-not-found") {
+        const message = messages.cwdNotFound({ cwd });
+        return new StageStop("CWD_NOT_FOUND", "run", errorNote("CWD_NOT_FOUND", message));
+    }
+    if (reason === "cwd-not-a-directory") {
+        const message = messages.cwdNotADirectory({ cwd });
+        return new StageStop("CWD_NOT_A_DIRECTORY", "run", errorNote("CWD_NOT_A_DIRECTORY", message));
+    }
+    return startFailure(scope, detail);
+}
+async function openSpill(scope, planned) {
+    const sink = scope.deps.spill;
+    if (sink === null)
+        return null;
+    let writer;
+    try {
+        writer = await sink.open(planned, scope.ctx);
+    }
+    catch {
+        throw extensionFailure(scope, sink, "spill");
+    }
+    if (!isRecord(writer) ||
+        typeof writer.write !== "function" ||
+        typeof writer.close !== "function") {
+        throw extensionFailure(scope, sink, "spill");
+    }
+    let chain = Promise.resolve();
+    let failed = false;
+    return {
+        get failed() {
+            return failed;
+        },
+        write(bytes) {
+            if (failed)
+                return;
+            const copy = bytes.slice();
+            chain = chain.then(async () => {
+                if (failed)
+                    return;
+                try {
+                    await writer.write(copy);
+                }
+                catch {
+                    failed = true;
+                }
+            });
+        },
+        async close() {
+            await chain;
+            try {
+                const ref = await writer.close();
+                if (failed || typeof ref !== "string") {
+                    failed = true;
+                    return null;
+                }
+                return ref;
+            }
+            catch {
+                failed = true;
+                return null;
+            }
+        },
+    };
+}

package/dist/core/input.d.ts

@@ -0,0 +1,12 @@
+import type { BashRequest } from "../contract/input.ts";
+import type { ShellLimits } from "../contract/limits.ts";
+/**
+ * Checks canonical input and fills defaults. Throws TypeError on bad input.
+ * `command` must hold a non-whitespace character and no NUL.
+ * `timeoutMs` must be a positive finite number. It is rounded up to a whole
+ * millisecond and clamped to maxTimeoutMs; the tool adds a clamped note.
+ * `cwd` must be a non-blank string without NUL.
+ */
+export declare function parseBashInput(input: unknown, limits: Readonly<ShellLimits>): BashRequest;
+export declare function clampedTimeout(input: unknown, request: BashRequest): number | null;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/core/input.js

@@ -0,0 +1,46 @@
+const KEYS = new Set(["command", "timeoutMs", "cwd"]);
+/**
+ * Checks canonical input and fills defaults. Throws TypeError on bad input.
+ * `command` must hold a non-whitespace character and no NUL.
+ * `timeoutMs` must be a positive finite number. It is rounded up to a whole
+ * millisecond and clamped to maxTimeoutMs; the tool adds a clamped note.
+ * `cwd` must be a non-blank string without NUL.
+ */
+export function parseBashInput(input, limits) {
+    if (!isRecord(input))
+        throw new TypeError("the input must be an object with a command");
+    for (const key of Object.keys(input)) {
+        if (!KEYS.has(key))
+            throw new TypeError(`unknown key ${key}. Expected command, timeoutMs, cwd`);
+    }
+    const { command, timeoutMs, cwd } = input;
+    if (typeof command !== "string" || command.trim() === "") {
+        throw new TypeError("command must be a non-blank string");
+    }
+    if (command.includes("\u0000"))
+        throw new TypeError("command must not hold a NUL character");
+    let timeout = limits.defaultTimeoutMs;
+    if (timeoutMs !== undefined) {
+        if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new TypeError("timeoutMs must be a positive number");
+        }
+        timeout = Math.min(Math.ceil(timeoutMs), limits.maxTimeoutMs);
+    }
+    let requestedCwd = null;
+    if (cwd !== undefined) {
+        if (typeof cwd !== "string" || cwd.trim() === "" || cwd.includes("\u0000")) {
+            throw new TypeError("cwd must be a non-blank string without NUL");
+        }
+        requestedCwd = cwd;
+    }
+    return Object.freeze({ command, timeoutMs: timeout, cwd: requestedCwd });
+}
+export function clampedTimeout(input, request) {
+    if (!isRecord(input) || typeof input.timeoutMs !== "number")
+        return null;
+    const requested = Math.ceil(input.timeoutMs);
+    return requested > request.timeoutMs ? requested : null;
+}
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/core/limits.d.ts

@@ -0,0 +1,10 @@
+import type { ShellLimits } from "../contract/limits.ts";
+/** Defaults, not ceilings. A host may raise any of these. */
+export declare const defaultShellLimits: Readonly<ShellLimits>;
+/**
+ * Merges key by key. Throws TypeError on an unknown key, on a value that is
+ * not a positive safe integer, on a headPercent over 100, or on a
+ * `defaultTimeoutMs` you set above `maxTimeoutMs`. The default
+ * `defaultTimeoutMs` over a `maxTimeoutMs` you set is lowered to it.
+ */
+export declare function resolveShellLimits(overrides?: Partial<ShellLimits>): Readonly<ShellLimits>;

package/dist/core/limits.js

@@ -0,0 +1,44 @@
+/** Defaults, not ceilings. A host may raise any of these. */
+export const defaultShellLimits = Object.freeze({
+    defaultTimeoutMs: 120_000,
+    maxTimeoutMs: 600_000,
+    killGraceMs: 2_000,
+    maxOutputBytes: 30_000,
+    maxOutputLines: 2_000,
+    headPercent: 20,
+    maxCaptureBytes: 10 * 1_024 * 1_024,
+});
+const LIMIT_KEYS = Object.keys(defaultShellLimits);
+/**
+ * Merges key by key. Throws TypeError on an unknown key, on a value that is
+ * not a positive safe integer, on a headPercent over 100, or on a
+ * `defaultTimeoutMs` you set above `maxTimeoutMs`. The default
+ * `defaultTimeoutMs` over a `maxTimeoutMs` you set is lowered to it.
+ */
+export function resolveShellLimits(overrides = {}) {
+    if (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)) {
+        throw new TypeError("limits must be an object");
+    }
+    const unknown = Object.keys(overrides).find((key) => !Object.hasOwn(defaultShellLimits, key));
+    if (unknown !== undefined)
+        throw new TypeError(`Unknown shell limit: ${unknown}`);
+    const resolved = { ...defaultShellLimits };
+    for (const key of LIMIT_KEYS) {
+        const value = overrides[key];
+        if (value === undefined)
+            continue;
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new TypeError(`${key} must be a positive safe integer`);
+        }
+        resolved[key] = value;
+    }
+    if (resolved.headPercent > 100)
+        throw new TypeError("headPercent must be 100 or less");
+    if (resolved.defaultTimeoutMs > resolved.maxTimeoutMs) {
+        if (overrides.defaultTimeoutMs !== undefined) {
+            throw new TypeError("defaultTimeoutMs must not be more than maxTimeoutMs");
+        }
+        resolved.defaultTimeoutMs = resolved.maxTimeoutMs;
+    }
+    return Object.freeze(resolved);
+}

package/dist/core/messages.d.ts

@@ -0,0 +1,12 @@
+import type { ShellMessageCatalog } from "../contract/messages.ts";
+/** "0.4 s", "12 s", "2 min 5 s". */
+export declare function formatDuration(ms: number): string;
+/** "812 B", "29.3 KB", "1.8 MB". Decimal units. */
+export declare function formatBytes(bytes: number): string;
+export declare const defaultShellMessages: Readonly<ShellMessageCatalog>;
+/**
+ * Merges key by key over the defaults. The default texts use the host's
+ * `param` and `duration`, so they show the host's names and units. Throws
+ * TypeError on an unknown key or a value that is not a function.
+ */
+export declare function resolveShellMessages(overrides?: Partial<ShellMessageCatalog>): Readonly<ShellMessageCatalog>;

package/dist/core/messages.js

@@ -0,0 +1,95 @@
+/** "0.4 s", "12 s", "2 min 5 s". */
+export function formatDuration(ms) {
+    if (ms < 10_000)
+        return `${(Math.round(ms / 100) / 10).toString()} s`;
+    const seconds = Math.round(ms / 1_000);
+    if (seconds < 120)
+        return `${seconds} s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return rest === 0 ? `${minutes} min` : `${minutes} min ${rest} s`;
+}
+/** "812 B", "29.3 KB", "1.8 MB". Decimal units. */
+export function formatBytes(bytes) {
+    if (bytes < 1_000)
+        return `${bytes} B`;
+    if (bytes < 1_000_000)
+        return `${(Math.round(bytes / 100) / 10).toString()} KB`;
+    return `${(Math.round(bytes / 100_000) / 10).toString()} MB`;
+}
+function catalogFor(param, duration) {
+    const cwdAdvice = () => {
+        const name = param("cwd");
+        return name === "" ? "" : ` Check the ${name} value.`;
+    };
+    return {
+        param,
+        duration,
+        pathRepaired: ({ from, to }) => `The requested directory ${JSON.stringify(from)} was repaired to ${JSON.stringify(to)}.`,
+        denied: ({ path, detail }) => `The command in ${path} was refused by policy${detail === null ? "" : ` (${detail})`}.`,
+        invalidInput: ({ detail }) => `The bash input was rejected: ${detail}`,
+        cwdNotFound: ({ cwd }) => `The working directory ${cwd} does not exist.${cwdAdvice()}`,
+        cwdNotADirectory: ({ cwd }) => `The working directory ${cwd} is not a directory.${cwdAdvice()}`,
+        refused: ({ hook }) => `The command was refused by the ${hook} check.`,
+        spawnFailed: ({ detail }) => `The command could not start${detail === null ? "" : ` (${detail})`}. This is a host problem, not a problem with the command.`,
+        extensionFailed: ({ extension, phase }) => `The ${extension} extension failed during the ${phase} phase. This is a host problem, not a problem with the command.`,
+        timeoutClamped: ({ requestedMs, maxMs }) => `The requested timeout of ${duration(requestedMs)} is over the maximum, so ${duration(maxMs)} was used.`,
+        exited: ({ code, signal, durationMs }) => {
+            const time = formatDuration(durationMs);
+            if (code !== null)
+                return `Exit code ${code} · ${time}`;
+            return `Ended by ${signal ?? "an unknown signal"} · ${time}`;
+        },
+        timedOut: ({ timeoutMs }) => `Timed out after ${formatDuration(timeoutMs)}. The process tree was stopped.`,
+        aborted: ({ durationMs }) => `Aborted after ${formatDuration(durationMs)}. The process tree was stopped.`,
+        outputCap: ({ limit }) => `The command wrote more than ${formatBytes(limit)} of output, so it was stopped. Send less output, for example with a filter, a count, or a redirect to a file.`,
+        unconfirmedStop: () => "The runner did not confirm that the process tree stopped. Processes may still be running.",
+        abortedBeforeStart: () => "The call was aborted before the command started.",
+        spillFailed: ({ sink }) => `The ${sink} spill sink failed, so the full output was not saved. The command was not affected.`,
+        outputIncomplete: ({ detail, skippedChunks, drainMs }) => {
+            const causes = [
+                ...(detail === null ? [] : [`the output stream failed (${detail})`]),
+                ...(drainMs === null
+                    ? []
+                    : [`the output had not ended ${drainMs} ms after the command exited`]),
+                ...(skippedChunks === 0
+                    ? []
+                    : [
+                        `the runner gave ${skippedChunks} malformed output ${skippedChunks === 1 ? "chunk" : "chunks"}, which ${skippedChunks === 1 ? "was" : "were"} skipped`,
+                    ]),
+            ];
+            return `The output may be incomplete: ${causes.join("; ")}. The exit status is still the command's.`;
+        },
+        noOutput: () => "(no output)",
+        omitted: ({ lines, bytes, spill }) => `[… ${lines} lines (${formatBytes(bytes)}) not shown]${spill === null ? "" : ` Full output: ${spill}`}`,
+    };
+}
+export const defaultShellMessages = Object.freeze(catalogFor((name) => name, formatDuration));
+const MESSAGE_KEYS = Object.keys(defaultShellMessages);
+/**
+ * Merges key by key over the defaults. The default texts use the host's
+ * `param` and `duration`, so they show the host's names and units. Throws
+ * TypeError on an unknown key or a value that is not a function.
+ */
+export function resolveShellMessages(overrides = {}) {
+    if (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)) {
+        throw new TypeError("messages must be an object");
+    }
+    for (const [key, value] of Object.entries(overrides)) {
+        if (!MESSAGE_KEYS.includes(key)) {
+            throw new TypeError(`Unknown shell message: ${key}`);
+        }
+        if (value !== undefined && typeof value !== "function") {
+            throw new TypeError(`messages.${key} must be a function`);
+        }
+    }
+    const param = overrides.param ?? defaultShellMessages.param;
+    const duration = overrides.duration ?? defaultShellMessages.duration;
+    const base = catalogFor(param, duration);
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return Object.freeze(merged);
+}

package/dist/core/pipeline.d.ts

@@ -0,0 +1,4 @@
+import type { ToolCallContext } from "@better-fs-tools/read";
+import type { ShellDependencies } from "../contract/deps.ts";
+import type { ShellResult } from "../contract/result.ts";
+export declare function runBash<THost>(deps: ShellDependencies<THost>, input: unknown, call: ToolCallContext<THost>): Promise<ShellResult>;

package/dist/core/pipeline.js

@@ -0,0 +1,185 @@
+import { defaultShellFormatter } from "../formatters/default.js";
+import { AbortStop } from "./abort.js";
+import { execute } from "./execute.js";
+import { clampedTimeout, isRecord, parseBashInput } from "./input.js";
+import { authorize, baseCwd, beforeRun, environment, extensionFailure, resolveCwd, runnerFor, } from "./stages.js";
+import { StageStop, errorNote, extensionId, info, isNoteList, messageOf, warning } from "./stop.js";
+export async function runBash(deps, input, call) {
+    const notes = [];
+    const { messages, limits } = deps;
+    let request;
+    try {
+        request = parseBashInput(input, limits);
+    }
+    catch (error) {
+        const note = errorNote("INVALID_INPUT", messages.invalidInput({ detail: messageOf(error) }));
+        return finish(deps, call, failedBeforeStart(null, new StageStop("INVALID_INPUT", "input", note), notes));
+    }
+    const requested = clampedTimeout(input, request);
+    if (requested !== null) {
+        const max = limits.maxTimeoutMs;
+        const message = messages.timeoutClamped({ requestedMs: requested, maxMs: max });
+        notes.push(info("clamped", message, { param: "timeoutMs", requested, max }));
+    }
+    const ctx = {
+        tool: "bash",
+        request,
+        limits,
+        messages,
+        digest: deps.digest,
+        clock: deps.clock,
+        call,
+    };
+    const scope = { deps, call, notes, ctx };
+    // A function, so TypeScript does not narrow the check away after an await.
+    const aborted = () => call.signal?.aborted === true;
+    try {
+        if (aborted())
+            throw new AbortStop("input");
+        const runner = runnerFor(deps, call);
+        const base = baseCwd(deps, call, runner);
+        const cwd = await resolveCwd(scope, base, request.cwd);
+        const run = await beforeRun(scope, {
+            command: request.command,
+            cwd,
+            timeoutMs: request.timeoutMs,
+        });
+        await authorize(scope, run, base);
+        const env = await environment(scope, run);
+        if (aborted())
+            throw new AbortStop("run");
+        const executed = await execute(scope, runner, run, env);
+        return finish(deps, call, await afterRun(scope, executed));
+    }
+    catch (error) {
+        if (error instanceof AbortStop) {
+            const note = errorNote("ABORTED", messages.abortedBeforeStart());
+            return finish(deps, call, failedBeforeStart(request, new StageStop("ABORTED", error.phase, note), notes));
+        }
+        if (error instanceof StageStop)
+            return finish(deps, call, failedBeforeStart(request, error, notes));
+        throw error;
+    }
+}
+function statusOf(run) {
+    if (run.stoppedBy === "timeout")
+        return "timeout";
+    return run.exitCode === 0 ? "ok" : "failed";
+}
+async function afterRun(scope, executed) {
+    const { run, stop } = executed;
+    const request = scope.ctx.request;
+    const error = stop === null ? null : errorOf(stop);
+    let output = executed.output;
+    let notes = stop === null ? [...scope.notes] : [stop.note, ...scope.notes];
+    const outcome = () => error === null
+        ? { status: statusOf(run), run, output, notes }
+        : { status: "error", error, run, output, notes };
+    for (const hook of scope.deps.afterRun) {
+        let next;
+        try {
+            next = await hook.afterRun(outcome(), scope.ctx);
+        }
+        catch {
+            return failedHook(scope, run, output, notes, hook);
+        }
+        if (!isRecord(next))
+            return failedHook(scope, run, output, notes, hook);
+        const nextOutput = next.output ?? output;
+        const nextNotes = next.notes ?? notes;
+        if (!isOutput(nextOutput) || !isNoteList(nextNotes)) {
+            return failedHook(scope, run, output, notes, hook);
+        }
+        output = nextOutput;
+        notes = nextNotes;
+    }
+    return error === null
+        ? ranReport(request, statusOf(run), run, output, notes)
+        : failureReport(request, error, run, output, notes);
+}
+function failedHook(scope, run, output, notes, hook) {
+    const failure = extensionFailure(scope, hook, "afterRun");
+    return failureReport(scope.ctx.request, errorOf(failure), run, output, [failure.note, ...notes]);
+}
+function isOutput(value) {
+    if (!isRecord(value))
+        return false;
+    const numbers = [
+        "totalBytes",
+        "totalLines",
+        "omittedBytes",
+        "omittedLines",
+        "stdoutBytes",
+        "stderrBytes",
+    ];
+    return (typeof value.head === "string" &&
+        (value.tail === null || typeof value.tail === "string") &&
+        (value.spill === null || typeof value.spill === "string") &&
+        numbers.every((key) => typeof value[key] === "number"));
+}
+function errorOf(stop) {
+    const { note } = stop;
+    return {
+        code: stop.code,
+        phase: stop.phase,
+        message: note.message,
+        ...(note.data === undefined ? {} : { data: note.data }),
+    };
+}
+function failedBeforeStart(request, stop, notes) {
+    return failureReport(request, errorOf(stop), null, null, [stop.note, ...notes]);
+}
+function ranReport(request, status, run, output, notes) {
+    return Object.freeze({
+        tool: "bash",
+        status,
+        request,
+        run,
+        output,
+        notes: Object.freeze([...notes]),
+    });
+}
+function failureReport(request, error, run, output, notes) {
+    return Object.freeze({
+        tool: "bash",
+        status: "error",
+        error,
+        request,
+        run,
+        output,
+        notes: Object.freeze([...notes]),
+    });
+}
+function finish(deps, call, done) {
+    const context = {
+        digest: deps.digest,
+        limits: deps.limits,
+        messages: deps.messages,
+        mode: "model",
+        call,
+    };
+    let content = null;
+    try {
+        content = toContent(deps.formatter.format(done, context));
+    }
+    catch { }
+    if (content !== null)
+        return Object.freeze({ ...done, content });
+    const id = extensionId(deps.formatter);
+    const note = warning("extension-failed", deps.messages.extensionFailed({ extension: id, phase: "format" }), { extension: "formatter", id });
+    const kept = Object.freeze({
+        ...done,
+        notes: Object.freeze([...done.notes, note]),
+    });
+    return Object.freeze({
+        ...kept,
+        content: toContent(defaultShellFormatter().format(kept, context)) ?? [],
+    });
+}
+function toContent(value) {
+    if (typeof value === "string")
+        return Object.freeze([{ type: "text", text: value }]);
+    if (Array.isArray(value))
+        return Object.freeze([...value]);
+    return null;
+}