@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/coding-agent/core/system-prompt.js

@@ -0,0 +1,146 @@
+/**
+ * System prompt construction and project context loading
+ */
+import { andorraGetSystemMessageText } from "../../ai/index.js";
+import { andorraGetDocsPath, andorraGetExamplesPath, andorraGetReadmePath } from "../config.js";
+import { andorraFormatSkillsForPrompt } from "./skills.js";
+const SYSTEM_PROMPT_SECTION_NAME = /^[a-z][a-z0-9_-]*$/;
+/** Normalize prompt input into the mutable, collection-complete shape exposed to extensions. */
+export function andorraNormalizeBuildSystemPromptOptions(input) {
+    return {
+        customPrompt: input.customPrompt,
+        forceSystemPrompt: input.forceSystemPrompt,
+        selectedTools: [...(input.selectedTools ?? ["read", "bash", "edit", "write"])],
+        toolSnippets: { ...(input.toolSnippets ?? {}) },
+        toolGuidelines: Object.fromEntries(Object.entries(input.toolGuidelines ?? {}).map(([name, guidelines]) => [name, [...guidelines]])),
+        promptGuidelines: [...(input.promptGuidelines ?? [])],
+        appendSystemPrompt: input.appendSystemPrompt ?? "",
+        sections: { ...(input.sections ?? {}) },
+        cwd: input.cwd,
+        contextFiles: (input.contextFiles ?? []).map((file) => ({ ...file })),
+        skills: (input.skills ?? []).map((skill) => ({ ...skill })),
+    };
+}
+function andorraRenderProjectContext(contextFiles) {
+    return [
+        "Project-specific instructions and guidelines:",
+        ...contextFiles.map(({ path, content }) => `<project_instructions path="${path}">\n${content}\n</project_instructions>`),
+    ].join("\n\n");
+}
+function andorraBuildRules(selectedTools, toolGuidelines, promptGuidelines) {
+    const rules = [];
+    const seen = new Set();
+    const andorraAddRule = (rule) => {
+        const normalized = rule.trim();
+        if (!normalized || seen.has(normalized))
+            return;
+        seen.add(normalized);
+        rules.push(normalized);
+    };
+    const hasBash = selectedTools.includes("bash");
+    const hasPowerShell = selectedTools.includes("powershell");
+    const hasGrep = selectedTools.includes("grep");
+    const hasFind = selectedTools.includes("find");
+    const hasLs = selectedTools.includes("ls");
+    if ((hasBash || hasPowerShell) && !hasGrep && !hasFind && !hasLs) {
+        if (hasBash && hasPowerShell) {
+            andorraAddRule("Use bash or PowerShell for file operations like listing, searching, and finding files");
+        }
+        else if (hasPowerShell) {
+            andorraAddRule("Use PowerShell for file operations like listing, searching, and finding files");
+        }
+        else {
+            andorraAddRule("Use bash for file operations like ls, rg, find");
+        }
+    }
+    for (const name of selectedTools) {
+        for (const rule of toolGuidelines[name] ?? [])
+            andorraAddRule(rule);
+    }
+    for (const rule of promptGuidelines)
+        andorraAddRule(rule);
+    andorraAddRule("Be concise in your responses");
+    andorraAddRule("Show file paths clearly when working with files");
+    return rules.map((rule) => `- ${rule}`).join("\n");
+}
+/** Build the ordered, independently replaceable sections of the structured system prompt. */
+export function andorraBuildSystemPromptSections(input) {
+    const options = andorraNormalizeBuildSystemPromptOptions(input);
+    const { customPrompt, selectedTools, toolSnippets, toolGuidelines, promptGuidelines, appendSystemPrompt, sections: customSections, cwd, contextFiles, skills, } = options;
+    for (const name of Object.keys(customSections)) {
+        if (!SYSTEM_PROMPT_SECTION_NAME.test(name) || name === "preamble") {
+            throw new Error(`Invalid system prompt section name: ${name}`);
+        }
+    }
+    const promptSections = {};
+    if (customPrompt) {
+        promptSections.preamble = customPrompt;
+    }
+    else {
+        promptSections.preamble =
+            "You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
+        const visibleTools = selectedTools.filter((name) => !!toolSnippets[name]);
+        const tools = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
+        promptSections.tools = `${tools}\n\nIn addition to the tools above, you may have access to other custom tools depending on the project.`;
+        promptSections.rules = andorraBuildRules(selectedTools, toolGuidelines, promptGuidelines);
+        promptSections.docs = `Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
+- Main documentation: ${andorraGetReadmePath()}
+- Additional docs: ${andorraGetDocsPath()}
+- Examples: ${andorraGetExamplesPath()} (extensions, custom tools, SDK)
+- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
+- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md), environment variables (docs/environment-variables.md)
+- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
+- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+    }
+    if (appendSystemPrompt)
+        promptSections.addendum = appendSystemPrompt;
+    if (contextFiles.length > 0)
+        promptSections.project_context = andorraRenderProjectContext(contextFiles);
+    const skillFileReadTool = ["read", "bash"].find((tool) => selectedTools.includes(tool));
+    if (skillFileReadTool && skills.length > 0) {
+        const skillsPrompt = andorraFormatSkillsForPrompt(skills, skillFileReadTool).trim();
+        if (skillsPrompt)
+            promptSections.skills = skillsPrompt;
+    }
+    promptSections.cwd = cwd.replace(/\\/g, "/");
+    for (const [name, content] of Object.entries(customSections)) {
+        if (content)
+            promptSections[name] = content;
+    }
+    const sections = { preamble: promptSections.preamble };
+    for (const [name, content] of Object.entries(promptSections)) {
+        if (name !== "preamble")
+            sections[name] = `<${name}>\n${content}\n</${name}>`;
+    }
+    return sections;
+}
+/**
+ * The complete prompt state for `input`. A forced prompt is opaque and lives in `content`
+ * with no sections; otherwise `content` is empty and the structured sections carry the prompt.
+ */
+export function andorraBuildSystemPromptState(input) {
+    if (input.forceSystemPrompt !== undefined)
+        return { content: input.forceSystemPrompt };
+    return { content: "", sections: andorraBuildSystemPromptSections(input) };
+}
+/** Build the system prompt text, rendered exactly as the transcript's system message replays it. */
+export function andorraBuildSystemPrompt(input) {
+    return andorraGetSystemMessageText({ role: "system", ...andorraBuildSystemPromptState(input), timestamp: 0 });
+}
+/**
+ * Diff the sections the model currently has (replayed from the transcript, so never null)
+ * against the desired ones. Returns a `SystemMessage.sections` patch, or undefined when
+ * nothing changed.
+ */
+export function andorraDiffSystemPromptSections(previous, current) {
+    const patch = {};
+    for (const [name, text] of Object.entries(current)) {
+        if (previous[name] !== text)
+            patch[name] = text;
+    }
+    for (const name of Object.keys(previous)) {
+        if (current[name] === undefined)
+            patch[name] = null;
+    }
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}

package/dist/vendor/engine/runtime/coding-agent/core/telemetry.d.ts

@@ -0,0 +1,2 @@
+import type { AndorraSettingsManager } from "./settings-manager.js";
+export declare function andorraIsInstallTelemetryEnabled(settingsManager: AndorraSettingsManager, telemetryEnv?: string | undefined): boolean;

package/dist/vendor/engine/runtime/coding-agent/core/telemetry.js

@@ -0,0 +1,8 @@
+function andorraIsTruthyEnvFlag(value) {
+    if (!value)
+        return false;
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+export function andorraIsInstallTelemetryEnabled(settingsManager, telemetryEnv = process.env.ANDORRA_ENGINE_TELEMETRY) {
+    return telemetryEnv !== undefined ? andorraIsTruthyEnvFlag(telemetryEnv) : settingsManager.getEnableInstallTelemetry();
+}

package/dist/vendor/engine/runtime/coding-agent/core/timings.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with ANDORRA_ENGINE_TIMING=1 environment variable.
+ */
+type TimingLabel = "main" | "extensions";
+export declare function andorraResetTimings(namespace?: TimingLabel): void;
+export declare function andorraTime(label: string, namespace?: TimingLabel): void;
+export declare function andorraPrintTimings(): void;
+export {};

package/dist/vendor/engine/runtime/coding-agent/core/timings.js

@@ -0,0 +1,40 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with ANDORRA_ENGINE_TIMING=1 environment variable.
+ */
+const ENABLED = process.env.ANDORRA_ENGINE_TIMING === "1";
+const timingNamespaces = new Map();
+export function andorraResetTimings(namespace = "main") {
+    if (!ENABLED)
+        return;
+    timingNamespaces.set(namespace, { timings: [], lastTime: Date.now() });
+}
+export function andorraTime(label, namespace = "main") {
+    if (!ENABLED)
+        return;
+    const now = Date.now();
+    if (!timingNamespaces.has(namespace)) {
+        andorraResetTimings(namespace);
+    }
+    const timingNamespace = timingNamespaces.get(namespace);
+    timingNamespace.timings.push({ label, ms: now - timingNamespace.lastTime });
+    timingNamespace.lastTime = now;
+}
+function andorraPrintTimingGroup(title, timings) {
+    const printableTimings = timings.filter((timing) => timing.ms >= 0);
+    if (printableTimings.length === 0)
+        return;
+    console.error(`\n--- ${title} ---`);
+    for (const t of printableTimings) {
+        console.error(`  ${t.label}: ${t.ms}ms`);
+    }
+    console.error(`  TOTAL: ${printableTimings.reduce((a, b) => a + b.ms, 0)}ms`);
+    console.error(`${"-".repeat(title.length + 8)}\n`);
+}
+export function andorraPrintTimings() {
+    if (!ENABLED)
+        return;
+    for (const [namespace, timingNamespace] of timingNamespaces) {
+        andorraPrintTimingGroup(`Startup Timings: ${namespace}`, timingNamespace.timings);
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/core/tools/bash.d.ts

@@ -0,0 +1,89 @@
+import type { AgentTool } from "../../../agent/index.js";
+import { type Static, Type } from "typebox";
+import { type ShellConfig } from "../../utils/shell.js";
+import type { ToolDefinition } from "../extensions/types.js";
+import { type TruncationResult } from "./truncate.js";
+declare const bashSchema: Type.TObject<{
+    command: Type.TString;
+    timeout: Type.TOptional<Type.TNumber>;
+}>;
+export declare const bashToolSystemPromptContribution: {
+    readonly snippet: "Execute bash commands (ls, grep, find, etc.)";
+    readonly guidelines: readonly ["You can inspect ANDORRA_ENGINE_* environment variables for current model and session details."];
+};
+export type BashToolInput = Static<typeof bashSchema>;
+export interface BashToolDetails {
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Pluggable operations for the bash tool.
+ * Override these to delegate command execution to remote systems (for example SSH).
+ */
+export interface BashOperations {
+    /**
+     * Execute a command and stream output.
+     * @param command The command to execute
+     * @param cwd Working directory
+     * @param options Execution options
+     * @returns Promise resolving to the exit code. Report signal terminations as 128 + signal number;
+     * a null exit code is treated as a failed command.
+     */
+    exec: (command: string, cwd: string, options: {
+        onData: (data: Buffer) => void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        exitCode: number | null;
+    }>;
+}
+/** Shared process execution used by the built-in shell tools. */
+export declare function andorraCreateLocalShellOperations(shellName: string, resolveShellConfig: () => ShellConfig): BashOperations;
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export declare function andorraCreateLocalBashOperations(options?: {
+    shellPath?: string;
+}): BashOperations;
+export interface BashSpawnContext {
+    command: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
+export interface BashToolOptions {
+    /** Explicit opt-in to saving unredacted full command output on disk. Default: false. */
+    persistOutput?: boolean;
+    /** Custom operations for command execution. Default: local shell */
+    operations?: BashOperations;
+    /** Command prefix prepended to every command (for example shell setup commands) */
+    commandPrefix?: string;
+    /** Optional explicit shell path from settings */
+    shellPath?: string;
+    /** Expose current Andorra session metadata as ANDORRA_ENGINE_* environment variables. Default: true */
+    exposeSessionEnvironment?: boolean;
+    /** Hook to adjust command, cwd, or env before execution */
+    spawnHook?: BashSpawnHook;
+}
+export type BashRenderState = {
+    startedAt: number | undefined;
+    endedAt: number | undefined;
+    interval: NodeJS.Timeout | undefined;
+};
+export interface ShellToolConfig {
+    name: string;
+    label: string;
+    shellName: string;
+    prompt: string;
+    promptSnippet: string;
+    promptGuidelines?: readonly string[];
+    tempFilePrefix: string;
+}
+export declare function andorraCreateShellToolDefinition(cwd: string, config: ShellToolConfig, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
+export declare function andorraCreateBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
+export declare function andorraCreateBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/core/tools/bash.js

@@ -0,0 +1,303 @@
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import { constants as osConstants } from "node:os";
+import { spawn } from "child_process";
+import { Type } from "typebox";
+import { andorraWaitForChildProcess } from "../../utils/child-process.js";
+import { andorraGetShellConfig, andorraGetShellEnv, andorraKillProcessTree, andorraTrackDetachedChildPid, andorraUntrackDetachedChildPid, } from "../../utils/shell.js";
+import { AndorraOutputAccumulator } from "./output-accumulator.js";
+import { BASH_UPDATE_THROTTLE_MS, andorraCreateShellRenderers } from "./renderers/bash.js";
+import { andorraWrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, andorraFormatSize } from "./truncate.js";
+const MAX_TIMEOUT_MS = 2_147_483_647;
+const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
+function andorraResolveTimeoutMs(timeout) {
+    if (timeout === undefined)
+        return undefined;
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+        throw new Error("Invalid timeout: must be a finite number of seconds");
+    }
+    const timeoutMs = timeout * 1000;
+    if (timeoutMs > MAX_TIMEOUT_MS) {
+        throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+    }
+    return timeoutMs;
+}
+const bashSchema = Type.Object({
+    command: Type.String({ description: "Shell command to execute" }),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+export const bashToolSystemPromptContribution = {
+    snippet: "Execute bash commands (ls, grep, find, etc.)",
+    guidelines: ["You can inspect ANDORRA_ENGINE_* environment variables for current model and session details."],
+};
+/** Shared process execution used by the built-in shell tools. */
+export function andorraCreateLocalShellOperations(shellName, resolveShellConfig) {
+    return {
+        exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const timeoutMs = andorraResolveTimeoutMs(timeout);
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
+            const shellConfig = resolveShellConfig();
+            try {
+                await fsAccess(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute ${shellName} commands.`);
+            }
+            const commandFromStdin = shellConfig.commandTransport === "stdin";
+            const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
+                cwd,
+                detached: process.platform !== "win32",
+                env: env ?? andorraGetShellEnv(),
+                stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            if (commandFromStdin) {
+                child.stdin?.on("error", () => { });
+                child.stdin?.end(command);
+            }
+            if (child.pid)
+                andorraTrackDetachedChildPid(child.pid);
+            let timedOut = false;
+            let timeoutHandle;
+            const andorraOnAbort = () => {
+                if (child.pid)
+                    andorraKillProcessTree(child.pid);
+            };
+            try {
+                // Set timeout if provided.
+                if (timeoutMs !== undefined) {
+                    timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        if (child.pid)
+                            andorraKillProcessTree(child.pid);
+                    }, timeoutMs);
+                }
+                // Stream stdout and stderr.
+                child.stdout?.on("data", onData);
+                child.stderr?.on("data", onData);
+                // Handle abort signal by killing the entire process tree.
+                if (signal) {
+                    if (signal.aborted)
+                        andorraOnAbort();
+                    else
+                        signal.addEventListener("abort", andorraOnAbort, { once: true });
+                }
+                // Handle shell spawn errors and wait for the process to terminate without hanging
+                // on inherited stdio handles held by detached descendants.
+                const exitCode = await andorraWaitForChildProcess(child);
+                if (signal?.aborted) {
+                    throw new Error("aborted");
+                }
+                if (timedOut) {
+                    throw new Error(`timeout:${timeout}`);
+                }
+                // A signal-killed shell has no exit code. Use the standard shell convention so
+                // callers do not mistake the termination for a successful command.
+                const signalCode = child.signalCode;
+                return { exitCode: exitCode ?? (signalCode ? 128 + (osConstants.signals[signalCode] ?? 0) : 1) };
+            }
+            finally {
+                if (child.pid)
+                    andorraUntrackDetachedChildPid(child.pid);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", andorraOnAbort);
+            }
+        },
+    };
+}
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export function andorraCreateLocalBashOperations(options) {
+    return andorraCreateLocalShellOperations("bash", () => andorraGetShellConfig(options?.shellPath));
+}
+function andorraResolveSpawnContext(command, cwd, spawnHook, exposeSessionEnvironment, ctx) {
+    const env = { ...andorraGetShellEnv() };
+    delete env.ANDORRA_ENGINE_SESSION_ID;
+    delete env.ANDORRA_ENGINE_SESSION_FILE;
+    delete env.ANDORRA_ENGINE_PROVIDER;
+    delete env.ANDORRA_ENGINE_MODEL;
+    delete env.ANDORRA_ENGINE_REASONING_LEVEL;
+    if (exposeSessionEnvironment && ctx) {
+        const model = ctx.model;
+        env.ANDORRA_ENGINE_SESSION_ID = ctx.sessionManager.getSessionId();
+        const sessionFile = ctx.sessionManager.getSessionFile();
+        if (sessionFile)
+            env.ANDORRA_ENGINE_SESSION_FILE = sessionFile;
+        if (model) {
+            env.ANDORRA_ENGINE_PROVIDER = model.provider;
+            env.ANDORRA_ENGINE_MODEL = model.id;
+        }
+        if (ctx.thinkingLevel)
+            env.ANDORRA_ENGINE_REASONING_LEVEL = ctx.thinkingLevel;
+    }
+    const baseContext = { command, cwd, env };
+    return spawnHook ? spawnHook(baseContext) : baseContext;
+}
+export function andorraCreateShellToolDefinition(cwd, config, options) {
+    const ops = options?.operations ?? andorraCreateLocalBashOperations({ shellPath: options?.shellPath });
+    const commandPrefix = options?.commandPrefix;
+    const exposeSessionEnvironment = options?.exposeSessionEnvironment ?? true;
+    const spawnHook = options?.spawnHook;
+    return {
+        name: config.name,
+        label: config.label,
+        description: `Execute a ${config.shellName} command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Full output is saved only when persistence is explicitly enabled. Optionally provide a timeout in seconds.`,
+        promptSnippet: config.promptSnippet,
+        promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
+        parameters: bashSchema,
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
+        async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = andorraResolveSpawnContext(resolvedCommand, ctx?.cwd || cwd, spawnHook, exposeSessionEnvironment, ctx);
+            const output = new AndorraOutputAccumulator({ tempFilePrefix: config.tempFilePrefix, persistOutput: options?.persistOutput });
+            let acceptingOutput = true;
+            let updateTimer;
+            let updateDirty = false;
+            let lastUpdateAt = 0;
+            const andorraEmitOutputUpdate = () => {
+                if (!onUpdate || !updateDirty)
+                    return;
+                updateDirty = false;
+                lastUpdateAt = Date.now();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                onUpdate({
+                    content: [{ type: "text", text: snapshot.content || "" }],
+                    details: {
+                        truncation: snapshot.truncation.truncated ? snapshot.truncation : undefined,
+                        fullOutputPath: snapshot.fullOutputPath,
+                    },
+                });
+            };
+            const andorraClearUpdateTimer = () => {
+                if (updateTimer) {
+                    clearTimeout(updateTimer);
+                    updateTimer = undefined;
+                }
+            };
+            const andorraScheduleOutputUpdate = () => {
+                if (!onUpdate)
+                    return;
+                updateDirty = true;
+                const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+                if (delay <= 0) {
+                    andorraClearUpdateTimer();
+                    andorraEmitOutputUpdate();
+                    return;
+                }
+                updateTimer ??= setTimeout(() => {
+                    updateTimer = undefined;
+                    andorraEmitOutputUpdate();
+                }, delay);
+            };
+            if (onUpdate) {
+                onUpdate({ content: [], details: undefined });
+            }
+            const andorraHandleData = (data) => {
+                if (!acceptingOutput)
+                    return;
+                output.append(data);
+                andorraScheduleOutputUpdate();
+            };
+            const andorraFinishOutput = async () => {
+                acceptingOutput = false;
+                output.finish();
+                andorraClearUpdateTimer();
+                andorraEmitOutputUpdate();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                await output.closeTempFile();
+                return snapshot;
+            };
+            const andorraFormatOutput = (snapshot, emptyText = "(no output)") => {
+                const truncation = snapshot.truncation;
+                let text = snapshot.content || emptyText;
+                let details;
+                if (truncation.truncated) {
+                    details = { truncation, fullOutputPath: snapshot.fullOutputPath };
+                    const startLine = truncation.totalLines - truncation.outputLines + 1;
+                    const endLine = truncation.totalLines;
+                    if (truncation.lastLinePartial) {
+                        const lastLineSize = andorraFormatSize(output.getLastLineBytes());
+                        text += `\n\n[Showing last ${andorraFormatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else if (truncation.truncatedBy === "lines") {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${andorraFormatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                }
+                if (!snapshot.fullOutputPath)
+                    text = text.replaceAll('Full output: undefined', 'Full output was not persisted');
+                return { text, details };
+            };
+            const andorraAppendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: andorraHandleData,
+                        signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    const snapshot = await andorraFinishOutput();
+                    const { text } = andorraFormatOutput(snapshot, "");
+                    if (err instanceof Error && err.message === "aborted") {
+                        throw new Error(andorraAppendStatus(text, "Command aborted"));
+                    }
+                    if (err instanceof Error && err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        throw new Error(andorraAppendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
+                    }
+                    throw err;
+                }
+                const snapshot = await andorraFinishOutput();
+                const { text: outputText, details } = andorraFormatOutput(snapshot);
+                if (exitCode === null) {
+                    throw new Error(andorraAppendStatus(outputText, "Command terminated without an exit code"));
+                }
+                if (exitCode !== 0) {
+                    throw new Error(andorraAppendStatus(outputText, `Command exited with code ${exitCode}`));
+                }
+                return { content: [{ type: "text", text: outputText }], details };
+            }
+            finally {
+                andorraClearUpdateTimer();
+            }
+        },
+        ...andorraCreateShellRenderers(config.prompt),
+    };
+}
+const bashToolConfig = {
+    name: "bash",
+    label: "bash",
+    shellName: "bash",
+    prompt: "$",
+    promptSnippet: bashToolSystemPromptContribution.snippet,
+    promptGuidelines: bashToolSystemPromptContribution.guidelines,
+    tempFilePrefix: "andorra-bash",
+};
+export function andorraCreateBashToolDefinition(cwd, options) {
+    return andorraCreateShellToolDefinition(cwd, bashToolConfig, options);
+}
+export function andorraCreateBashTool(cwd, options) {
+    const definition = andorraCreateBashToolDefinition(cwd, options);
+    const tool = andorraWrapToolDefinition(definition);
+    Object.assign(tool, {
+        promptSnippet: definition.promptSnippet,
+        promptGuidelines: definition.promptGuidelines,
+    });
+    return tool;
+}