@travisennis/acai 0.0.11 → 0.0.13

package/dist/tui/utils.js

@@ -123,6 +123,20 @@ function truncateSimple(text, targetWidth, maxWidth) {
         visibleSoFar: state.visibleSoFar,
     };
 }
+/**
+ * Find the end of the current text segment (until tab or ANSI code).
+ */
+function findSegmentEnd(text, start) {
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            return end;
+        }
+        end++;
+    }
+    return end;
+}
 function truncateComplex(text, targetWidth, maxWidth) {
     const state = createInitialState();
     let i = 0;
@@ -140,14 +154,7 @@ function truncateComplex(text, targetWidth, maxWidth) {
             continue;
         }
         // Find end of current text segment (until tab or ANSI)
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
+        const end = findSegmentEnd(text, i);
         // Process graphemes in this segment
         for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
             if (processGraphemeSegment(state, segment, targetWidth, maxWidth)) {
@@ -192,12 +199,24 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     }
     // Fast path: pure ASCII printable
     if (isPrintableAscii(text)) {
-        if (text.length <= maxWidth) {
-            return pad ? text + " ".repeat(maxWidth - text.length) : text;
-        }
-        const targetWidth = maxWidth - ellipsisWidth;
-        return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+        return truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+    }
+    return truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+}
+/**
+ * Truncate ASCII-only text with ellipsis.
+ */
+function truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
+    if (text.length <= maxWidth) {
+        return pad ? text + " ".repeat(maxWidth - text.length) : text;
     }
+    const targetWidth = maxWidth - ellipsisWidth;
+    return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+ * Truncate text that may contain ANSI codes, tabs, or Unicode wide characters.
+ */
+function truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
     const targetWidth = maxWidth - ellipsisWidth;
     const hasAnsi = text.includes("\x1b");
     const hasTabs = text.includes("\t");
@@ -221,31 +240,71 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     return finalizeTruncatedResult(truncatedResult.result, truncatedResult.keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
 }
 /**
- * Truncate a single fragment to a maximum width.
+ * Truncate text that contains only graphemes (no ANSI, no tabs) by
+ * iterating grapheme clusters up to maxWidth.
  */
-function truncateFragmentToWidth(text, maxWidth) {
-    if (maxWidth <= 0 || text.length === 0) {
-        return { text: "", width: 0 };
+function truncateGraphemesOnly(text, maxWidth) {
+    let result = "";
+    let width = 0;
+    for (const { segment } of getSegmenter().segment(text)) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            break;
+        }
+        result += segment;
+        width += w;
     }
-    if (isPrintableAscii(text)) {
-        const clipped = text.slice(0, maxWidth);
-        return { text: clipped, width: clipped.length };
+    return { text: result, width };
+}
+/**
+ * Process a contiguous text segment (no tabs, no ANSI codes) within the
+ * larger ANSI/tab-aware truncation loop. Returns the consumed portion and
+ * updated state.
+ */
+function processTextSegment(text, start, maxWidth, currentWidth, pendingAnsi) {
+    // Find end of current text segment (until tab or ANSI code)
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            break;
+        }
+        end++;
     }
-    const hasAnsi = text.includes("\x1b");
-    const hasTabs = text.includes("\t");
-    if (!hasAnsi && !hasTabs) {
-        let result = "";
-        let width = 0;
-        for (const { segment } of getSegmenter().segment(text)) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                break;
-            }
-            result += segment;
-            width += w;
+    let result = "";
+    let width = currentWidth;
+    let pending = pendingAnsi;
+    for (const { segment } of getSegmenter().segment(text.slice(start, end))) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            return {
+                text: result,
+                width,
+                pendingAnsi: pending,
+                nextIndex: end,
+                exhausted: true,
+            };
+        }
+        if (pending) {
+            result += pending;
+            pending = "";
         }
-        return { text: result, width };
+        result += segment;
+        width += w;
     }
+    return {
+        text: result,
+        width,
+        pendingAnsi: pending,
+        nextIndex: end,
+        exhausted: false,
+    };
+}
+/**
+ * Truncate text that contains ANSI codes and/or tab characters,
+ * correctly measuring visible width.
+ */
+function truncateWithAnsiAndTabs(text, maxWidth) {
     let result = "";
     let width = 0;
     let i = 0;
@@ -270,30 +329,35 @@ function truncateFragmentToWidth(text, maxWidth) {
             i++;
             continue;
         }
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
-        for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                return { text: result, width };
-            }
-            if (pendingAnsi) {
-                result += pendingAnsi;
-                pendingAnsi = "";
-            }
-            result += segment;
-            width += w;
+        const segmentResult = processTextSegment(text, i, maxWidth, width, pendingAnsi);
+        result += segmentResult.text;
+        width = segmentResult.width;
+        pendingAnsi = segmentResult.pendingAnsi;
+        i = segmentResult.nextIndex;
+        if (segmentResult.exhausted) {
+            break;
         }
-        i = end;
     }
     return { text: result, width };
 }
+/**
+ * Truncate a single fragment to a maximum width.
+ */
+export function truncateFragmentToWidth(text, maxWidth) {
+    if (maxWidth <= 0 || text.length === 0) {
+        return { text: "", width: 0 };
+    }
+    if (isPrintableAscii(text)) {
+        const clipped = text.slice(0, maxWidth);
+        return { text: clipped, width: clipped.length };
+    }
+    const hasAnsi = text.includes("\x1b");
+    const hasTabs = text.includes("\t");
+    if (!hasAnsi && !hasTabs) {
+        return truncateGraphemesOnly(text, maxWidth);
+    }
+    return truncateWithAnsiAndTabs(text, maxWidth);
+}
 /**
  * Finalize a truncated result with proper ANSI reset codes.
  * Only adds reset codes if the prefix contains ANSI sequences.

package/dist/utils/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAuJA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiDtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAkNA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBtC;AAiFD,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAaF,CAAC;AA8EF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}

package/dist/utils/bash.js

@@ -81,6 +81,33 @@ function isFullyQuoted(token) {
     const last = token[token.length - 1];
     return (first === '"' && last === '"') || (first === "'" && last === "'");
 }
+// Process a single git message flag token and update skip mask
+// Returns true if the token was recognized as a message flag
+function processGitMessageToken(tokens, i, t, skip) {
+    // --message=<msg> - skip this entire token
+    if (t.startsWith("--message=")) {
+        skip[i] = true;
+        return true;
+    }
+    // -m<msg> (attached message) - skip this entire token
+    if (/^-m.+/.test(t)) {
+        skip[i] = true;
+        return true;
+    }
+    // -m or --message consumes next token
+    if (t === "-m" || t === "--message") {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    // Combined short opts containing m, e.g. -am, -avm
+    if (/^-[^-]+$/.test(t) && t.includes("m")) {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    return false;
+}
 // Compute which tokens should be skipped from path validation
 function computeSkipTokenMask(tokens) {
     const skip = new Array(tokens.length).fill(false);
@@ -88,41 +115,52 @@ function computeSkipTokenMask(tokens) {
     const sub = stripQuotes(tokens[1] ?? "");
     // Commands where -m/--message is a string argument (not a path)
     const gitMessageSubs = new Set(["commit", "merge", "tag", "revert", "notes"]);
-    if (bin === "git" && gitMessageSubs.has(sub)) {
-        let seenDoubleDash = false;
-        for (let i = 2; i < tokens.length; i++) {
-            const t = stripQuotes(tokens[i] ?? "");
-            if (t === "--") {
-                seenDoubleDash = true;
-                continue;
-            }
-            if (seenDoubleDash)
-                continue;
-            // --message=<msg> - skip this entire token
-            if (t.startsWith("--message=")) {
-                skip[i] = true;
-                continue;
-            }
-            // -m<msg> (attached message) - skip this entire token
-            if (/^-m.+/.test(t)) {
-                skip[i] = true;
-                continue;
-            }
-            // -m or --message consumes next token
-            if (t === "-m" || t === "--message") {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-                continue;
-            }
-            // Combined short opts containing m, e.g. -am, -avm
-            if (/^-[^-]+$/.test(t) && t.includes("m")) {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-            }
+    if (bin !== "git" || !gitMessageSubs.has(sub)) {
+        return skip;
+    }
+    let seenDoubleDash = false;
+    for (let i = 2; i < tokens.length; i++) {
+        const t = stripQuotes(tokens[i] ?? "");
+        if (t === "--") {
+            seenDoubleDash = true;
+            continue;
         }
+        if (seenDoubleDash)
+            continue;
+        processGitMessageToken(tokens, i, t, skip);
     }
     return skip;
 }
+function validateToken(token, allowedDirs, cwd) {
+    // Skip fully quoted tokens - they're string arguments, not paths
+    // (paths are typically unquoted or only quoted to handle spaces)
+    if (isFullyQuoted(token) && token.includes("\n")) {
+        return { isValid: true };
+    }
+    // Remove quotes for path checking
+    const cleanToken = stripQuotes(token);
+    // Skip if it's clearly not a path
+    if (cleanToken.startsWith("-") ||
+        cleanToken.includes("://") ||
+        (!cleanToken.includes("/") && cleanToken !== "~")) {
+        return { isValid: true };
+    }
+    try {
+        // Expand ~ to home directory for proper validation
+        const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
+            ? path.join(os.homedir(), cleanToken.slice(1))
+            : cleanToken;
+        const resolvedPath = path.resolve(cwd, expandedToken);
+        if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
+            return {
+                isValid: false,
+                error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
+            };
+        }
+    }
+    catch (_e) { }
+    return { isValid: true };
+}
 // Validate path arguments to ensure they're within the project
 export function validatePaths(command, allowedDirs, cwd) {
     const tokens = tokenizeShellWords(command);
@@ -135,75 +173,52 @@ export function validatePaths(command, allowedDirs, cwd) {
         // Skip tokens marked by command-aware logic
         if (skip[i])
             continue;
-        // Skip fully quoted tokens - they're string arguments, not paths
-        // (paths are typically unquoted or only quoted to handle spaces)
-        if (isFullyQuoted(token) && token.includes("\n")) {
-            continue;
-        }
-        // Remove quotes for path checking
-        const cleanToken = stripQuotes(token);
-        // Skip if it's clearly not a path
-        if (cleanToken.startsWith("-") ||
-            cleanToken.includes("://") ||
-            (!cleanToken.includes("/") && cleanToken !== "~")) {
-            continue;
-        }
-        try {
-            // Expand ~ to home directory for proper validation
-            const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
-                ? path.join(os.homedir(), cleanToken.slice(1))
-                : cleanToken;
-            const resolvedPath = path.resolve(cwd, expandedToken);
-            if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
-                return {
-                    isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
-                };
-            }
-        }
-        catch (_e) { }
+        const result = validateToken(token, allowedDirs, cwd);
+        if (!result.isValid)
+            return result;
     }
     return { isValid: true };
 }
-export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
-    // Determine which directory to use as the base for resolving relative paths
-    // If allowedDirs is provided and non-empty, use the first allowed directory
-    // Otherwise use the workingDir parameter (backward compatibility)
+function resolveBaseDir(allowedDirs, workingDir) {
     const baseDirForResolution = allowedDirs && allowedDirs.length > 0 ? allowedDirs[0] : workingDir;
     const projectRootAbs = path.resolve(baseDirForResolution);
-    let projectRoot = projectRootAbs;
     try {
-        projectRoot = fs.realpathSync(projectRootAbs);
+        return fs.realpathSync(projectRootAbs);
     }
     catch {
-        // Fallback to resolved path
+        return projectRootAbs;
     }
-    const raw = typeof cwdInput === "string" && cwdInput.trim() !== ""
-        ? cwdInput.trim()
-        : projectRoot;
-    const abs = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw);
-    let target = abs;
+}
+function resolveRawCwd(cwdInput, projectRoot) {
+    if (typeof cwdInput === "string" && cwdInput.trim() !== "") {
+        const trimmed = cwdInput.trim();
+        return path.isAbsolute(trimmed)
+            ? trimmed
+            : path.resolve(projectRoot, trimmed);
+    }
+    return projectRoot;
+}
+function resolveRealTarget(raw) {
     try {
-        target = fs.realpathSync(abs);
+        return fs.realpathSync(raw);
     }
     catch {
-        // If the path doesn't exist entirely, validate intended path
+        return raw;
     }
-    // Check if within allowed directories if provided, otherwise check project root
-    if (allowedDirs && allowedDirs.length > 0) {
-        if (!isPathWithinAllowedDirs(target, allowedDirs)) {
-            throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinAllowedDirs(target, allowedDirs, cwdInput) {
+    if (!isPathWithinAllowedDirs(target, allowedDirs)) {
+        throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    else {
-        // Fallback to original behavior: check within project root
-        const rel = path.relative(projectRoot, target);
-        const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-        if (!inside) {
-            throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinProjectRoot(target, projectRoot, cwdInput) {
+    const rel = path.relative(projectRoot, target);
+    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    if (!inside) {
+        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    // Check existence and that it's a directory
+}
+function assertDirectoryExists(target) {
     let stats;
     try {
         stats = fs.statSync(target);
@@ -211,13 +226,26 @@ export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
     catch (err) {
         const error = err;
         if (error.code === "ENOENT") {
-            throw new Error(`Working directory does not exist: ${target} (from ${cwdInput ?? "<default>"})`);
+            throw new Error(`Working directory does not exist: ${target}`);
         }
         throw error;
     }
     if (!stats.isDirectory()) {
         throw new Error(`Working directory is not a directory: ${target}`);
     }
+    return stats;
+}
+export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
+    const projectRoot = resolveBaseDir(allowedDirs, workingDir);
+    const raw = resolveRawCwd(cwdInput, projectRoot);
+    const target = resolveRealTarget(raw);
+    if (allowedDirs && allowedDirs.length > 0) {
+        assertWithinAllowedDirs(target, allowedDirs, cwdInput);
+    }
+    else {
+        assertWithinProjectRoot(target, projectRoot, cwdInput);
+    }
+    assertDirectoryExists(target);
     return target;
 };
 const mutatingBinaries = new Set([
@@ -278,27 +306,16 @@ function isSegmentMutating(seg) {
     const bin = tokens[0];
     if (!bin)
         return false;
-    if (tokens.some((t) => actionMutating.has(t))) {
+    if (tokens.some((t) => actionMutating.has(t)))
         return true;
-    }
-    if (bin === "sed" && tokens.some((t) => /^-i/.test(t))) {
+    if (bin === "sed" && tokens.some((t) => /^-i/.test(t)))
         return true;
-    }
-    if (mutatingBinaries.has(bin)) {
+    if (mutatingBinaries.has(bin))
+        return true;
+    if (bin === "git" && tokens[1] && gitMutating.has(tokens[1]))
+        return true;
+    if (packageManagers.has(bin) && tokens[1] && npmMutating.has(tokens[1]))
         return true;
-    }
-    if (bin === "git" && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && gitMutating.has(sub)) {
-            return true;
-        }
-    }
-    if (packageManagers.has(bin) && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && npmMutating.has(sub)) {
-            return true;
-        }
-    }
     return false;
 }
 export const isMutatingCommand = (rawCommand) => {

package/dist/utils/binary-output.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Binary output handling for Bash tool
+ *
+ * Detects binary output from commands and saves it to temp files
+ * with helpful metadata for the user.
+ */
+/**
+ * Check if output appears to be binary data
+ * Binary is detected by:
+ * - Null bytes (most reliable indicator)
+ * - High ratio of non-printable characters
+ */
+export declare function isBinaryOutput(output: string): boolean;
+/**
+ * Result of saving binary output
+ */
+export interface BinarySaveResult {
+    success: boolean;
+    path?: string;
+    size?: number;
+    mimeType?: string;
+    error?: string;
+}
+/**
+ * Save binary output to a temp file and detect its MIME type
+ */
+export declare function saveBinaryOutput(output: string): BinarySaveResult;
+/**
+ * Format a user-friendly message for binary output
+ */
+export declare function formatBinaryMessage(result: BinarySaveResult): string;
+//# sourceMappingURL=binary-output.d.ts.map

package/dist/utils/binary-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-output.d.ts","sourceRoot":"","sources":["../../source/utils/binary-output.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4BtD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CA4CjE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAqBpE"}

package/dist/utils/binary-output.js

@@ -0,0 +1,127 @@
+/**
+ * Binary output handling for Bash tool
+ *
+ * Detects binary output from commands and saves it to temp files
+ * with helpful metadata for the user.
+ */
+import { execSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Threshold for checking binary content (check first N bytes)
+ */
+const BINARY_CHECK_BYTES = 8192;
+/**
+ * Check if output appears to be binary data
+ * Binary is detected by:
+ * - Null bytes (most reliable indicator)
+ * - High ratio of non-printable characters
+ */
+export function isBinaryOutput(output) {
+    if (output.length === 0) {
+        return false;
+    }
+    // Check first N bytes for null bytes (strongest binary indicator)
+    const checkLength = Math.min(output.length, BINARY_CHECK_BYTES);
+    const sample = output.slice(0, checkLength);
+    // Null byte is definitive binary indicator
+    if (sample.includes("\0")) {
+        return true;
+    }
+    // Count non-printable characters (excluding common whitespace)
+    let nonPrintable = 0;
+    for (let i = 0; i < sample.length; i++) {
+        const code = sample.charCodeAt(i);
+        // Allow printable ASCII (32-126), newlines (10), tabs (9), and carriage returns (13)
+        // Also allow extended ASCII/UTF-8 (127+)
+        if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+            nonPrintable++;
+        }
+    }
+    // If more than 30% non-printable in the sample, treat as binary
+    const ratio = nonPrintable / sample.length;
+    return ratio > 0.3;
+}
+/**
+ * Save binary output to a temp file and detect its MIME type
+ */
+export function saveBinaryOutput(output) {
+    try {
+        // Generate unique filename
+        const id = randomBytes(8).toString("hex");
+        const filePath = `/tmp/acai/bash_binary_${id}`;
+        // Ensure directory exists
+        mkdirSync(dirname(filePath), { recursive: true });
+        // Convert string back to buffer for accurate binary writing
+        // Note: Some data loss may have occurred during UTF-8 decoding
+        const buffer = Buffer.from(output, "utf8");
+        writeFileSync(filePath, buffer);
+        const size = buffer.length;
+        // Detect MIME type using `file` command
+        let mimeType = "application/octet-stream";
+        try {
+            const fileOutput = execSync(`file --mime-type -b "${filePath}"`, {
+                encoding: "utf8",
+                timeout: 5000,
+            }).trim();
+            if (fileOutput && fileOutput !== "cannot open") {
+                mimeType = fileOutput;
+            }
+        }
+        catch {
+            // `file` command not available or failed, use default
+        }
+        return {
+            success: true,
+            path: filePath,
+            size,
+            mimeType,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Format a user-friendly message for binary output
+ */
+export function formatBinaryMessage(result) {
+    if (!result.success) {
+        return `⚠️ Binary output detected but could not be saved: ${result.error ?? "Unknown error"}`;
+    }
+    const sizeStr = formatBytes(result.size ?? 0);
+    const lines = [
+        "📦 Binary output detected",
+        "",
+        `**Size:** ${sizeStr}`,
+        `**Type:** ${result.mimeType}`,
+        `**Saved to:** \`${result.path}\``,
+        "",
+        "**To inspect this file, you can use:**",
+        "  • `file <path>` - Detect file type",
+        "  • `xxd <path>` - Hex dump",
+        "  • `hexdump -C <path>` - Hex dump with ASCII",
+        "  • `head -c 100 <path> | xxd` - Preview first 100 bytes",
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format bytes as human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 bytes";
+    const units = ["bytes", "KB", "MB", "GB"];
+    const unitIndex = Math.floor(Math.log(bytes) / Math.log(1024));
+    const size = bytes / 1024 ** unitIndex;
+    // Show decimal for KB and up, whole number for bytes
+    if (unitIndex === 0) {
+        return `${bytes} bytes`;
+    }
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+}