@sammorrowdrums/mcpi 0.70.8 → 0.85.0-bootstrap.0

package/dist/core/tools/bash.js

@@ -1,8 +1,6 @@
-import { randomBytes } from "node:crypto";
-import { createWriteStream, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Container, Text, truncateToWidth } from "@mariozechner/pi-tui";
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import { Container, Text, truncateToWidth } from "@sammorrowdrums/mcpi-tui";
 import { spawn } from "child_process";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
@@ -10,61 +8,86 @@ import { truncateToVisualLines } from "../../modes/interactive/components/visual
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { waitForChildProcess } from "../../utils/child-process.js";
 import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { getExperimentalToolSampling } from "../experimental.js";
+import { OutputAccumulator } from "./output-accumulator.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail } from "./truncate.js";
-/**
- * Generate a unique temp file path for bash output.
- */
-function getTempFilePath() {
-    const id = randomBytes(8).toString("hex");
-    return join(tmpdir(), `pi-bash-${id}.log`);
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const MAX_TIMEOUT_MS = 2_147_483_647;
+const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
+function resolveTimeoutMs(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: "Bash 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 PI_* environment variables for current model and session details."],
+};
 /**
- * Create bash operations using pi's built-in local shell execution backend.
+ * Create bash operations using mcpi's built-in local shell execution backend.
  *
- * This is useful for extensions that intercept user_bash and still want pi's
+ * This is useful for extensions that intercept user_bash and still want mcpi's
  * standard local shell behavior while wrapping or rewriting commands.
  */
 export function createLocalBashOperations(options) {
     return {
-        exec: (command, cwd, { onData, signal, timeout, env }) => {
-            return new Promise((resolve, reject) => {
-                const { shell, args } = getShellConfig(options?.shellPath);
-                if (!existsSync(cwd)) {
-                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
-                    return;
-                }
-                const child = spawn(shell, [...args, command], {
-                    cwd,
-                    detached: true,
-                    env: env ?? getShellEnv(),
-                    stdio: ["ignore", "pipe", "pipe"],
-                });
+        exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const timeoutMs = resolveTimeoutMs(timeout);
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
+            const shellConfig = getShellConfig(options?.shellPath);
+            try {
+                await fsAccess(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+            }
+            const commandFromStdin = shellConfig.commandTransport === "stdin";
+            const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
+                cwd,
+                detached: process.platform !== "win32",
+                env: env ?? getShellEnv(),
+                stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            if (commandFromStdin) {
+                child.stdin?.on("error", () => { });
+                child.stdin?.end(command);
+            }
+            if (child.pid)
+                trackDetachedChildPid(child.pid);
+            let timedOut = false;
+            let timeoutHandle;
+            const onAbort = () => {
                 if (child.pid)
-                    trackDetachedChildPid(child.pid);
-                let timedOut = false;
-                let timeoutHandle;
+                    killProcessTree(child.pid);
+            };
+            try {
                 // Set timeout if provided.
-                if (timeout !== undefined && timeout > 0) {
+                if (timeoutMs !== undefined) {
                     timeoutHandle = setTimeout(() => {
                         timedOut = true;
                         if (child.pid)
                             killProcessTree(child.pid);
-                    }, timeout * 1000);
+                    }, timeoutMs);
                 }
                 // Stream stdout and stderr.
                 child.stdout?.on("data", onData);
                 child.stderr?.on("data", onData);
                 // Handle abort signal by killing the entire process tree.
-                const onAbort = () => {
-                    if (child.pid)
-                        killProcessTree(child.pid);
-                };
                 if (signal) {
                     if (signal.aborted)
                         onAbort();
@@ -73,42 +96,51 @@ export function createLocalBashOperations(options) {
                 }
                 // Handle shell spawn errors and wait for the process to terminate without hanging
                 // on inherited stdio handles held by detached descendants.
-                waitForChildProcess(child)
-                    .then((code) => {
-                    if (child.pid)
-                        untrackDetachedChildPid(child.pid);
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    if (signal)
-                        signal.removeEventListener("abort", onAbort);
-                    if (signal?.aborted) {
-                        reject(new Error("aborted"));
-                        return;
-                    }
-                    if (timedOut) {
-                        reject(new Error(`timeout:${timeout}`));
-                        return;
-                    }
-                    resolve({ exitCode: code });
-                })
-                    .catch((err) => {
-                    if (child.pid)
-                        untrackDetachedChildPid(child.pid);
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    if (signal)
-                        signal.removeEventListener("abort", onAbort);
-                    reject(err);
-                });
-            });
+                const exitCode = await waitForChildProcess(child);
+                if (signal?.aborted) {
+                    throw new Error("aborted");
+                }
+                if (timedOut) {
+                    throw new Error(`timeout:${timeout}`);
+                }
+                return { exitCode };
+            }
+            finally {
+                if (child.pid)
+                    untrackDetachedChildPid(child.pid);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            }
         },
     };
 }
-function resolveSpawnContext(command, cwd, spawnHook) {
-    const baseContext = { command, cwd, env: { ...getShellEnv() } };
+function resolveSpawnContext(command, cwd, spawnHook, exposeSessionEnvironment, ctx) {
+    const env = { ...getShellEnv() };
+    delete env.MCPI_SESSION_ID;
+    delete env.MCPI_SESSION_FILE;
+    delete env.MCPI_PROVIDER;
+    delete env.MCPI_MODEL;
+    delete env.MCPI_REASONING_LEVEL;
+    if (exposeSessionEnvironment && ctx) {
+        const model = ctx.model;
+        env.MCPI_SESSION_ID = ctx.sessionManager.getSessionId();
+        const sessionFile = ctx.sessionManager.getSessionFile();
+        if (sessionFile)
+            env.MCPI_SESSION_FILE = sessionFile;
+        if (model) {
+            env.MCPI_PROVIDER = model.provider;
+            env.MCPI_MODEL = model.id;
+        }
+        if (ctx.thinkingLevel)
+            env.MCPI_REASONING_LEVEL = ctx.thinkingLevel;
+    }
+    const baseContext = { command, cwd, env };
     return spawnHook ? spawnHook(baseContext) : baseContext;
 }
 const BASH_PREVIEW_LINES = 5;
+const BASH_UPDATE_THROTTLE_MS = 100;
 class BashResultRenderComponent extends Container {
     state = {
         cachedWidth: undefined,
@@ -129,7 +161,15 @@ function formatBashCall(args) {
 function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
     const state = component.state;
     component.clear();
-    const output = getTextOutput(result, showImages).trim();
+    let output = getTextOutput(result, showImages).trim();
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+        const footerStart = output.lastIndexOf("\n\n[");
+        if (footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath)) {
+            output = output.slice(0, footerStart).trimEnd();
+        }
+    }
     if (output) {
         const styledOutput = output
             .split("\n")
@@ -149,7 +189,7 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
                     }
                     if (state.cachedSkipped && state.cachedSkipped > 0) {
                         const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
-                            ` ${keyHint("app.tools.expand", "to expand")})`;
+                            ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
                         return ["", truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
                     }
                     return ["", ...(state.cachedLines ?? [])];
@@ -162,8 +202,6 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
             });
         }
     }
-    const truncation = result.details?.truncation;
-    const fullOutputPath = result.details?.fullOutputPath;
     if (truncation?.truncated || fullOutputPath) {
         const warnings = [];
         if (fullOutputPath) {
@@ -188,137 +226,132 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
 export function createBashToolDefinition(cwd, options) {
     const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
     const commandPrefix = options?.commandPrefix;
+    const exposeSessionEnvironment = options?.exposeSessionEnvironment ?? true;
     const spawnHook = options?.spawnHook;
     return {
         name: "bash",
         label: "bash",
         description: `Execute a bash 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). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-        promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
+        promptSnippet: bashToolSystemPromptContribution.snippet,
+        promptGuidelines: exposeSessionEnvironment ? [...bashToolSystemPromptContribution.guidelines] : undefined,
         parameters: bashSchema,
-        async execute(_toolCallId, { command, timeout }, signal, onUpdate, _ctx) {
+        constrainedSampling: getExperimentalToolSampling(),
+        async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
-            const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook);
+            const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook, exposeSessionEnvironment, ctx);
+            const output = new OutputAccumulator({ tempFilePrefix: "mcpi-bash" });
+            let acceptingOutput = true;
+            let updateTimer;
+            let updateDirty = false;
+            let lastUpdateAt = 0;
+            const emitOutputUpdate = () => {
+                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 clearUpdateTimer = () => {
+                if (updateTimer) {
+                    clearTimeout(updateTimer);
+                    updateTimer = undefined;
+                }
+            };
+            const scheduleOutputUpdate = () => {
+                if (!onUpdate)
+                    return;
+                updateDirty = true;
+                const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+                if (delay <= 0) {
+                    clearUpdateTimer();
+                    emitOutputUpdate();
+                    return;
+                }
+                updateTimer ??= setTimeout(() => {
+                    updateTimer = undefined;
+                    emitOutputUpdate();
+                }, delay);
+            };
             if (onUpdate) {
                 onUpdate({ content: [], details: undefined });
             }
-            return new Promise((resolve, reject) => {
-                let tempFilePath;
-                let tempFileStream;
-                let totalBytes = 0;
-                const chunks = [];
-                let chunksBytes = 0;
-                const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
-                const ensureTempFile = () => {
-                    if (tempFilePath)
-                        return;
-                    tempFilePath = getTempFilePath();
-                    tempFileStream = createWriteStream(tempFilePath);
-                    for (const chunk of chunks)
-                        tempFileStream.write(chunk);
-                };
-                const handleData = (data) => {
-                    totalBytes += data.length;
-                    // Start writing to a temp file once output exceeds the in-memory threshold.
-                    if (totalBytes > DEFAULT_MAX_BYTES) {
-                        ensureTempFile();
-                    }
-                    // Write to temp file if we have one.
-                    if (tempFileStream)
-                        tempFileStream.write(data);
-                    // Keep a rolling buffer of recent output for tail truncation.
-                    chunks.push(data);
-                    chunksBytes += data.length;
-                    // Trim old chunks if the rolling buffer grows too large.
-                    while (chunksBytes > maxChunksBytes && chunks.length > 1) {
-                        const removed = chunks.shift();
-                        chunksBytes -= removed.length;
-                    }
-                    // Stream partial output using the rolling tail buffer.
-                    if (onUpdate) {
-                        const fullBuffer = Buffer.concat(chunks);
-                        const fullText = fullBuffer.toString("utf-8");
-                        const truncation = truncateTail(fullText);
-                        if (truncation.truncated) {
-                            ensureTempFile();
-                        }
-                        onUpdate({
-                            content: [{ type: "text", text: truncation.content || "" }],
-                            details: {
-                                truncation: truncation.truncated ? truncation : undefined,
-                                fullOutputPath: tempFilePath,
-                            },
-                        });
-                    }
-                };
-                ops.exec(spawnContext.command, spawnContext.cwd, {
-                    onData: handleData,
-                    signal,
-                    timeout,
-                    env: spawnContext.env,
-                })
-                    .then(({ exitCode }) => {
-                    // Combine the rolling buffer chunks.
-                    const fullBuffer = Buffer.concat(chunks);
-                    const fullOutput = fullBuffer.toString("utf-8");
-                    // Apply tail truncation for the final display payload.
-                    const truncation = truncateTail(fullOutput);
-                    if (truncation.truncated) {
-                        ensureTempFile();
-                    }
-                    // Close temp file stream before building the final result.
-                    if (tempFileStream)
-                        tempFileStream.end();
-                    let outputText = truncation.content || "(no output)";
-                    let details;
-                    if (truncation.truncated) {
-                        // Build truncation details and an actionable notice.
-                        details = { truncation, fullOutputPath: tempFilePath };
-                        const startLine = truncation.totalLines - truncation.outputLines + 1;
-                        const endLine = truncation.totalLines;
-                        if (truncation.lastLinePartial) {
-                            // Edge case: the last line alone is larger than the byte limit.
-                            const lastLineSize = formatSize(Buffer.byteLength(fullOutput.split("\n").pop() || "", "utf-8"));
-                            outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
-                        }
-                        else if (truncation.truncatedBy === "lines") {
-                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
-                        }
-                        else {
-                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
-                        }
+            const handleData = (data) => {
+                if (!acceptingOutput)
+                    return;
+                output.append(data);
+                scheduleOutputUpdate();
+            };
+            const finishOutput = async () => {
+                acceptingOutput = false;
+                output.finish();
+                clearUpdateTimer();
+                emitOutputUpdate();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                await output.closeTempFile();
+                return snapshot;
+            };
+            const formatOutput = (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 = formatSize(output.getLastLineBytes());
+                        text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
                     }
-                    if (exitCode !== 0 && exitCode !== null) {
-                        outputText += `\n\nCommand exited with code ${exitCode}`;
-                        reject(new Error(outputText));
+                    else if (truncation.truncatedBy === "lines") {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
                     }
                     else {
-                        resolve({ content: [{ type: "text", text: outputText }], details });
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${snapshot.fullOutputPath}]`;
                     }
-                })
-                    .catch((err) => {
-                    // Close temp file stream and include buffered output in the error message.
-                    if (tempFileStream)
-                        tempFileStream.end();
-                    const fullBuffer = Buffer.concat(chunks);
-                    let output = fullBuffer.toString("utf-8");
-                    if (err.message === "aborted") {
-                        if (output)
-                            output += "\n\n";
-                        output += "Command aborted";
-                        reject(new Error(output));
+                }
+                return { text, details };
+            };
+            const appendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: handleData,
+                        signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    const snapshot = await finishOutput();
+                    const { text } = formatOutput(snapshot, "");
+                    if (err instanceof Error && err.message === "aborted") {
+                        throw new Error(appendStatus(text, "Command aborted"));
                     }
-                    else if (err.message.startsWith("timeout:")) {
+                    if (err instanceof Error && err.message.startsWith("timeout:")) {
                         const timeoutSecs = err.message.split(":")[1];
-                        if (output)
-                            output += "\n\n";
-                        output += `Command timed out after ${timeoutSecs} seconds`;
-                        reject(new Error(output));
-                    }
-                    else {
-                        reject(err);
+                        throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
                     }
-                });
-            });
+                    throw err;
+                }
+                const snapshot = await finishOutput();
+                const { text: outputText, details } = formatOutput(snapshot);
+                if (exitCode !== 0 && exitCode !== null) {
+                    throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
+                }
+                return { content: [{ type: "text", text: outputText }], details };
+            }
+            finally {
+                clearUpdateTimer();
+            }
         },
         renderCall(args, _theme, context) {
             const state = context.state;
@@ -350,6 +383,12 @@ export function createBashToolDefinition(cwd, options) {
     };
 }
 export function createBashTool(cwd, options) {
-    return wrapToolDefinition(createBashToolDefinition(cwd, options));
+    const definition = createBashToolDefinition(cwd, options);
+    const tool = wrapToolDefinition(definition);
+    Object.assign(tool, {
+        promptSnippet: definition.promptSnippet,
+        promptGuidelines: definition.promptGuidelines,
+    });
+    return tool;
 }
 //# sourceMappingURL=bash.js.map