@xelauvas/xela-cli 0.1.0

package/src/tools/BashTool/BashToolResultMessage.tsx

@@ -0,0 +1,191 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { removeSandboxViolationTags } from 'src/utils/sandbox/sandbox-ui-utils.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { OutputLine } from '../../components/shell/OutputLine.js';
+import { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js';
+import { Box, Text } from '../../ink.js';
+import type { Out as BashOut } from './BashTool.js';
+type Props = {
+  content: Omit<BashOut, 'interrupted'>;
+  verbose: boolean;
+  timeoutMs?: number;
+};
+
+// Pattern to match "Shell cwd was reset to <path>" message
+// Use (?:^|\n) to match either start of string or after a newline
+const SHELL_CWD_RESET_PATTERN = /(?:^|\n)(Shell cwd was reset to .+)$/;
+
+/**
+ * Extracts sandbox violations from stderr if present
+ * Returns both the cleaned stderr and the violations content
+ */
+function extractSandboxViolations(stderr: string): {
+  cleanedStderr: string;
+} {
+  const violationsMatch = stderr.match(/<sandbox_violations>([\s\S]*?)<\/sandbox_violations>/);
+  if (!violationsMatch) {
+    return {
+      cleanedStderr: stderr
+    };
+  }
+
+  // Remove the sandbox violations section from stderr
+  const cleanedStderr = removeSandboxViolationTags(stderr).trim();
+  return {
+    cleanedStderr
+  };
+}
+
+/**
+ * Extracts the "Shell cwd was reset" warning message from stderr
+ * Returns the cleaned stderr and the warning message separately
+ */
+function extractCwdResetWarning(stderr: string): {
+  cleanedStderr: string;
+  cwdResetWarning: string | null;
+} {
+  const match = stderr.match(SHELL_CWD_RESET_PATTERN);
+  if (!match) {
+    return {
+      cleanedStderr: stderr,
+      cwdResetWarning: null
+    };
+  }
+
+  // Extract the warning message from capture group 1
+  const cwdResetWarning = match[1] ?? null;
+  // Remove the warning from stderr (replace the full match)
+  const cleanedStderr = stderr.replace(SHELL_CWD_RESET_PATTERN, '').trim();
+  return {
+    cleanedStderr,
+    cwdResetWarning
+  };
+}
+export default function BashToolResultMessage(t0) {
+  const $ = _c(34);
+  const {
+    content: t1,
+    verbose,
+    timeoutMs
+  } = t0;
+  const {
+    stdout: t2,
+    stderr: t3,
+    isImage,
+    returnCodeInterpretation,
+    noOutputExpected,
+    backgroundTaskId
+  } = t1;
+  const stdout = t2 === undefined ? "" : t2;
+  const stdErrWithViolations = t3 === undefined ? "" : t3;
+  let T0;
+  let cwdResetWarning;
+  let stderr;
+  let t4;
+  let t5;
+  let t6;
+  let t7;
+  if ($[0] !== isImage || $[1] !== stdErrWithViolations || $[2] !== stdout || $[3] !== verbose) {
+    t7 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const {
+        cleanedStderr: stderrWithoutViolations
+      } = extractSandboxViolations(stdErrWithViolations);
+      ({
+        cleanedStderr: stderr,
+        cwdResetWarning
+      } = extractCwdResetWarning(stderrWithoutViolations));
+      if (isImage) {
+        let t8;
+        if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+          t8 = <MessageResponse height={1}><Text dimColor={true}>[Image data detected and sent to Claude]</Text></MessageResponse>;
+          $[11] = t8;
+        } else {
+          t8 = $[11];
+        }
+        t7 = t8;
+        break bb0;
+      }
+      T0 = Box;
+      t4 = "column";
+      if ($[12] !== stdout || $[13] !== verbose) {
+        t5 = stdout !== "" ? <OutputLine content={stdout} verbose={verbose} /> : null;
+        $[12] = stdout;
+        $[13] = verbose;
+        $[14] = t5;
+      } else {
+        t5 = $[14];
+      }
+      t6 = stderr.trim() !== "" ? <OutputLine content={stderr} verbose={verbose} isError={true} /> : null;
+    }
+    $[0] = isImage;
+    $[1] = stdErrWithViolations;
+    $[2] = stdout;
+    $[3] = verbose;
+    $[4] = T0;
+    $[5] = cwdResetWarning;
+    $[6] = stderr;
+    $[7] = t4;
+    $[8] = t5;
+    $[9] = t6;
+    $[10] = t7;
+  } else {
+    T0 = $[4];
+    cwdResetWarning = $[5];
+    stderr = $[6];
+    t4 = $[7];
+    t5 = $[8];
+    t6 = $[9];
+    t7 = $[10];
+  }
+  if (t7 !== Symbol.for("react.early_return_sentinel")) {
+    return t7;
+  }
+  let t8;
+  if ($[15] !== cwdResetWarning) {
+    t8 = cwdResetWarning ? <MessageResponse><Text dimColor={true}>{cwdResetWarning}</Text></MessageResponse> : null;
+    $[15] = cwdResetWarning;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== backgroundTaskId || $[18] !== cwdResetWarning || $[19] !== noOutputExpected || $[20] !== returnCodeInterpretation || $[21] !== stderr || $[22] !== stdout) {
+    t9 = stdout === "" && stderr.trim() === "" && !cwdResetWarning ? <MessageResponse height={1}><Text dimColor={true}>{backgroundTaskId ? <>Running in the background{" "}<KeyboardShortcutHint shortcut={"\u2193"} action="manage" parens={true} /></> : returnCodeInterpretation || (noOutputExpected ? "Done" : "(No output)")}</Text></MessageResponse> : null;
+    $[17] = backgroundTaskId;
+    $[18] = cwdResetWarning;
+    $[19] = noOutputExpected;
+    $[20] = returnCodeInterpretation;
+    $[21] = stderr;
+    $[22] = stdout;
+    $[23] = t9;
+  } else {
+    t9 = $[23];
+  }
+  let t10;
+  if ($[24] !== timeoutMs) {
+    t10 = timeoutMs && <MessageResponse><ShellTimeDisplay timeoutMs={timeoutMs} /></MessageResponse>;
+    $[24] = timeoutMs;
+    $[25] = t10;
+  } else {
+    t10 = $[25];
+  }
+  let t11;
+  if ($[26] !== T0 || $[27] !== t10 || $[28] !== t4 || $[29] !== t5 || $[30] !== t6 || $[31] !== t8 || $[32] !== t9) {
+    t11 = <T0 flexDirection={t4}>{t5}{t6}{t8}{t9}{t10}</T0>;
+    $[26] = T0;
+    $[27] = t10;
+    $[28] = t4;
+    $[29] = t5;
+    $[30] = t6;
+    $[31] = t8;
+    $[32] = t9;
+    $[33] = t11;
+  } else {
+    t11 = $[33];
+  }
+  return t11;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","removeSandboxViolationTags","KeyboardShortcutHint","MessageResponse","OutputLine","ShellTimeDisplay","Box","Text","Out","BashOut","Props","content","Omit","verbose","timeoutMs","SHELL_CWD_RESET_PATTERN","extractSandboxViolations","stderr","cleanedStderr","violationsMatch","match","trim","extractCwdResetWarning","cwdResetWarning","replace","BashToolResultMessage","t0","$","_c","t1","stdout","t2","t3","isImage","returnCodeInterpretation","noOutputExpected","backgroundTaskId","undefined","stdErrWithViolations","T0","t4","t5","t6","t7","Symbol","for","bb0","stderrWithoutViolations","t8","t9","t10","t11"],"sources":["BashToolResultMessage.tsx"],"sourcesContent":["import React from 'react'\nimport { removeSandboxViolationTags } from 'src/utils/sandbox/sandbox-ui-utils.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { OutputLine } from '../../components/shell/OutputLine.js'\nimport { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js'\nimport { Box, Text } from '../../ink.js'\nimport type { Out as BashOut } from './BashTool.js'\n\ntype Props = {\n  content: Omit<BashOut, 'interrupted'>\n  verbose: boolean\n  timeoutMs?: number\n}\n\n// Pattern to match \"Shell cwd was reset to <path>\" message\n// Use (?:^|\\n) to match either start of string or after a newline\nconst SHELL_CWD_RESET_PATTERN = /(?:^|\\n)(Shell cwd was reset to .+)$/\n\n/**\n * Extracts sandbox violations from stderr if present\n * Returns both the cleaned stderr and the violations content\n */\nfunction extractSandboxViolations(stderr: string): {\n  cleanedStderr: string\n} {\n  const violationsMatch = stderr.match(\n    /<sandbox_violations>([\\s\\S]*?)<\\/sandbox_violations>/,\n  )\n\n  if (!violationsMatch) {\n    return { cleanedStderr: stderr }\n  }\n\n  // Remove the sandbox violations section from stderr\n  const cleanedStderr = removeSandboxViolationTags(stderr).trim()\n\n  return {\n    cleanedStderr,\n  }\n}\n\n/**\n * Extracts the \"Shell cwd was reset\" warning message from stderr\n * Returns the cleaned stderr and the warning message separately\n */\nfunction extractCwdResetWarning(stderr: string): {\n  cleanedStderr: string\n  cwdResetWarning: string | null\n} {\n  const match = stderr.match(SHELL_CWD_RESET_PATTERN)\n  if (!match) {\n    return { cleanedStderr: stderr, cwdResetWarning: null }\n  }\n\n  // Extract the warning message from capture group 1\n  const cwdResetWarning = match[1] ?? null\n  // Remove the warning from stderr (replace the full match)\n  const cleanedStderr = stderr.replace(SHELL_CWD_RESET_PATTERN, '').trim()\n\n  return { cleanedStderr, cwdResetWarning }\n}\n\nexport default function BashToolResultMessage({\n  content: {\n    stdout = '',\n    stderr: stdErrWithViolations = '',\n    isImage,\n    returnCodeInterpretation,\n    noOutputExpected,\n    backgroundTaskId,\n  },\n  verbose,\n  timeoutMs,\n}: Props): React.ReactNode {\n  // Extract sandbox violations from stderr as it feels cleaner on the UI\n  // We want the model to see the violations, so it can explain what went wrong, and the\n  // user can access them in the violation logs\n  const { cleanedStderr: stderrWithoutViolations } =\n    extractSandboxViolations(stdErrWithViolations)\n\n  // Extract \"Shell cwd was reset\" warning to render it with warning color instead of error\n  const { cleanedStderr: stderr, cwdResetWarning } = extractCwdResetWarning(\n    stderrWithoutViolations,\n  )\n\n  // If this is an image, we don't want to truncate it in the UI\n  if (isImage) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>[Image data detected and sent to Claude]</Text>\n      </MessageResponse>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {stdout !== '' ? <OutputLine content={stdout} verbose={verbose} /> : null}\n      {stderr.trim() !== '' ? (\n        <OutputLine content={stderr} verbose={verbose} isError />\n      ) : null}\n      {cwdResetWarning ? (\n        <MessageResponse>\n          <Text dimColor>{cwdResetWarning}</Text>\n        </MessageResponse>\n      ) : null}\n      {stdout === '' && stderr.trim() === '' && !cwdResetWarning ? (\n        <MessageResponse height={1}>\n          <Text dimColor>\n            {backgroundTaskId ? (\n              <>\n                Running in the background{' '}\n                <KeyboardShortcutHint shortcut=\"↓\" action=\"manage\" parens />\n              </>\n            ) : (\n              returnCodeInterpretation ||\n              (noOutputExpected ? 'Done' : '(No output)')\n            )}\n          </Text>\n        </MessageResponse>\n      ) : null}\n      {timeoutMs && (\n        <MessageResponse>\n          <ShellTimeDisplay timeoutMs={timeoutMs} />\n        </MessageResponse>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/tools/BashTool/UI.tsx

@@ -0,0 +1,185 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { ShellProgressMessage } from '../../components/shell/ShellProgressMessage.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js';
+import { useAppStateStore, useSetAppState } from '../../state/AppState.js';
+import type { Tool } from '../../Tool.js';
+import { backgroundAll } from '../../tasks/LocalShellTask/LocalShellTask.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { env } from '../../utils/env.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { getDisplayPath } from '../../utils/file.js';
+import { isFullscreenEnvEnabled } from '../../utils/fullscreen.js';
+import type { ThemeName } from '../../utils/theme.js';
+import type { BashProgress, BashToolInput, Out } from './BashTool.js';
+import BashToolResultMessage from './BashToolResultMessage.js';
+import { extractBashCommentLabel } from './commentLabel.js';
+import { parseSedEditCommand } from './sedEditParser.js';
+
+// Constants for command display
+const MAX_COMMAND_DISPLAY_LINES = 2;
+const MAX_COMMAND_DISPLAY_CHARS = 160;
+
+// Simple component to show background hint and handle ctrl+b
+// When ctrl+b is pressed, backgrounds ALL running foreground commands
+export function BackgroundHint(t0) {
+  const $ = _c(9);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === undefined ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const {
+    onBackground
+  } = t1;
+  const store = useAppStateStore();
+  const setAppState = useSetAppState();
+  let t2;
+  if ($[2] !== onBackground || $[3] !== setAppState || $[4] !== store) {
+    t2 = () => {
+      backgroundAll(() => store.getState(), setAppState);
+      onBackground?.();
+    };
+    $[2] = onBackground;
+    $[3] = setAppState;
+    $[4] = store;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const handleBackground = t2;
+  let t3;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = {
+      context: "Task"
+    };
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  useKeybinding("task:background", handleBackground, t3);
+  const baseShortcut = useShortcutDisplay("task:background", "Task", "ctrl+b");
+  const shortcut = env.terminal === "tmux" && baseShortcut === "ctrl+b" ? "ctrl+b ctrl+b (twice)" : baseShortcut;
+  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)) {
+    return null;
+  }
+  let t4;
+  if ($[7] !== shortcut) {
+    t4 = <Box paddingLeft={5}><Text dimColor={true}><KeyboardShortcutHint shortcut={shortcut} action="run in background" parens={true} /></Text></Box>;
+    $[7] = shortcut;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+export function renderToolUseMessage(input: Partial<BashToolInput>, {
+  verbose,
+  theme: _theme
+}: {
+  verbose: boolean;
+  theme: ThemeName;
+}): React.ReactNode {
+  const {
+    command
+  } = input;
+  if (!command) {
+    return null;
+  }
+
+  // Render sed in-place edits like file edits (show file path only)
+  const sedInfo = parseSedEditCommand(command);
+  if (sedInfo) {
+    return verbose ? sedInfo.filePath : getDisplayPath(sedInfo.filePath);
+  }
+  if (!verbose) {
+    const lines = command.split('\n');
+    if (isFullscreenEnvEnabled()) {
+      const label = extractBashCommentLabel(command);
+      if (label) {
+        return label.length > MAX_COMMAND_DISPLAY_CHARS ? label.slice(0, MAX_COMMAND_DISPLAY_CHARS) + '…' : label;
+      }
+    }
+    const needsLineTruncation = lines.length > MAX_COMMAND_DISPLAY_LINES;
+    const needsCharTruncation = command.length > MAX_COMMAND_DISPLAY_CHARS;
+    if (needsLineTruncation || needsCharTruncation) {
+      let truncated = command;
+
+      // First truncate by lines if needed
+      if (needsLineTruncation) {
+        truncated = lines.slice(0, MAX_COMMAND_DISPLAY_LINES).join('\n');
+      }
+
+      // Then truncate by chars if still too long
+      if (truncated.length > MAX_COMMAND_DISPLAY_CHARS) {
+        truncated = truncated.slice(0, MAX_COMMAND_DISPLAY_CHARS);
+      }
+      return <Text>{truncated.trim()}…</Text>;
+    }
+  }
+  return command;
+}
+export function renderToolUseProgressMessage(progressMessagesForMessage: ProgressMessage<BashProgress>[], {
+  verbose,
+  tools: _tools,
+  terminalSize: _terminalSize,
+  inProgressToolCallCount: _inProgressToolCallCount
+}: {
+  tools: Tool[];
+  verbose: boolean;
+  terminalSize?: {
+    columns: number;
+    rows: number;
+  };
+  inProgressToolCallCount?: number;
+}): React.ReactNode {
+  const lastProgress = progressMessagesForMessage.at(-1);
+  if (!lastProgress || !lastProgress.data) {
+    return <MessageResponse height={1}>
+        <Text dimColor>Running…</Text>
+      </MessageResponse>;
+  }
+  const data = lastProgress.data;
+  return <ShellProgressMessage fullOutput={data.fullOutput} output={data.output} elapsedTimeSeconds={data.elapsedTimeSeconds} totalLines={data.totalLines} totalBytes={data.totalBytes} timeoutMs={data.timeoutMs} taskId={data.taskId} verbose={verbose} />;
+}
+export function renderToolUseQueuedMessage(): React.ReactNode {
+  return <MessageResponse height={1}>
+      <Text dimColor>Waiting…</Text>
+    </MessageResponse>;
+}
+export function renderToolResultMessage(content: Out, progressMessagesForMessage: ProgressMessage<BashProgress>[], {
+  verbose,
+  theme: _theme,
+  tools: _tools,
+  style: _style
+}: {
+  verbose: boolean;
+  theme: ThemeName;
+  tools: Tool[];
+  style?: 'condensed';
+}): React.ReactNode {
+  const lastProgress = progressMessagesForMessage.at(-1);
+  const timeoutMs = lastProgress?.data?.timeoutMs;
+  return <BashToolResultMessage content={content} verbose={verbose} timeoutMs={timeoutMs} />;
+}
+export function renderToolUseErrorMessage(result: ToolResultBlockParam['content'], {
+  verbose,
+  progressMessagesForMessage: _progressMessagesForMessage,
+  tools: _tools
+}: {
+  verbose: boolean;
+  progressMessagesForMessage: ProgressMessage<BashProgress>[];
+  tools: Tool[];
+}): React.ReactNode {
+  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","React","KeyboardShortcutHint","FallbackToolUseErrorMessage","MessageResponse","ShellProgressMessage","Box","Text","useKeybinding","useShortcutDisplay","useAppStateStore","useSetAppState","Tool","backgroundAll","ProgressMessage","env","isEnvTruthy","getDisplayPath","isFullscreenEnvEnabled","ThemeName","BashProgress","BashToolInput","Out","BashToolResultMessage","extractBashCommentLabel","parseSedEditCommand","MAX_COMMAND_DISPLAY_LINES","MAX_COMMAND_DISPLAY_CHARS","BackgroundHint","t0","$","_c","t1","undefined","onBackground","store","setAppState","t2","getState","handleBackground","t3","Symbol","for","context","baseShortcut","shortcut","terminal","process","CLAUDE_CODE_DISABLE_BACKGROUND_TASKS","t4","renderToolUseMessage","input","Partial","verbose","theme","_theme","ReactNode","command","sedInfo","filePath","lines","split","label","length","slice","needsLineTruncation","needsCharTruncation","truncated","join","trim","renderToolUseProgressMessage","progressMessagesForMessage","tools","_tools","terminalSize","_terminalSize","inProgressToolCallCount","_inProgressToolCallCount","columns","rows","lastProgress","at","data","fullOutput","output","elapsedTimeSeconds","totalLines","totalBytes","timeoutMs","taskId","renderToolUseQueuedMessage","renderToolResultMessage","content","style","_style","renderToolUseErrorMessage","result","_progressMessagesForMessage"],"sources":["UI.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { ShellProgressMessage } from '../../components/shell/ShellProgressMessage.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js'\nimport { useAppStateStore, useSetAppState } from '../../state/AppState.js'\nimport type { Tool } from '../../Tool.js'\nimport { backgroundAll } from '../../tasks/LocalShellTask/LocalShellTask.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { env } from '../../utils/env.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { getDisplayPath } from '../../utils/file.js'\nimport { isFullscreenEnvEnabled } from '../../utils/fullscreen.js'\nimport type { ThemeName } from '../../utils/theme.js'\nimport type { BashProgress, BashToolInput, Out } from './BashTool.js'\nimport BashToolResultMessage from './BashToolResultMessage.js'\nimport { extractBashCommentLabel } from './commentLabel.js'\nimport { parseSedEditCommand } from './sedEditParser.js'\n\n// Constants for command display\nconst MAX_COMMAND_DISPLAY_LINES = 2\nconst MAX_COMMAND_DISPLAY_CHARS = 160\n\n// Simple component to show background hint and handle ctrl+b\n// When ctrl+b is pressed, backgrounds ALL running foreground commands\nexport function BackgroundHint({\n  onBackground,\n}: {\n  onBackground?: () => void\n} = {}): React.ReactElement | null {\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n\n  // Handler for task:background - background all foreground tasks\n  const handleBackground = React.useCallback(() => {\n    // Background ALL foreground bash tasks\n    backgroundAll(() => store.getState(), setAppState)\n    // Also call the optional callback (used for non-bash tasks like agents)\n    onBackground?.()\n  }, [store, setAppState, onBackground])\n\n  useKeybinding('task:background', handleBackground, {\n    context: 'Task',\n  })\n\n  // Get the configured shortcut for task:background\n  const baseShortcut = useShortcutDisplay('task:background', 'Task', 'ctrl+b')\n  // In tmux, ctrl+b is the prefix key, so users need to press it twice to send ctrl+b\n  const shortcut =\n    env.terminal === 'tmux' && baseShortcut === 'ctrl+b'\n      ? 'ctrl+b ctrl+b (twice)'\n      : baseShortcut\n\n  // Don't show background hint if background tasks are disabled\n  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)) {\n    return null\n  }\n\n  return (\n    <Box paddingLeft={5}>\n      <Text dimColor>\n        <KeyboardShortcutHint\n          shortcut={shortcut}\n          action=\"run in background\"\n          parens\n        />\n      </Text>\n    </Box>\n  )\n}\n\nexport function renderToolUseMessage(\n  input: Partial<BashToolInput>,\n  { verbose, theme: _theme }: { verbose: boolean; theme: ThemeName },\n): React.ReactNode {\n  const { command } = input\n  if (!command) {\n    return null\n  }\n\n  // Render sed in-place edits like file edits (show file path only)\n  const sedInfo = parseSedEditCommand(command)\n  if (sedInfo) {\n    return verbose ? sedInfo.filePath : getDisplayPath(sedInfo.filePath)\n  }\n\n  if (!verbose) {\n    const lines = command.split('\\n')\n\n    if (isFullscreenEnvEnabled()) {\n      const label = extractBashCommentLabel(command)\n      if (label) {\n        return label.length > MAX_COMMAND_DISPLAY_CHARS\n          ? label.slice(0, MAX_COMMAND_DISPLAY_CHARS) + '…'\n          : label\n      }\n    }\n\n    const needsLineTruncation = lines.length > MAX_COMMAND_DISPLAY_LINES\n    const needsCharTruncation = command.length > MAX_COMMAND_DISPLAY_CHARS\n\n    if (needsLineTruncation || needsCharTruncation) {\n      let truncated = command\n\n      // First truncate by lines if needed\n      if (needsLineTruncation) {\n        truncated = lines.slice(0, MAX_COMMAND_DISPLAY_LINES).join('\\n')\n      }\n\n      // Then truncate by chars if still too long\n      if (truncated.length > MAX_COMMAND_DISPLAY_CHARS) {\n        truncated = truncated.slice(0, MAX_COMMAND_DISPLAY_CHARS)\n      }\n\n      return <Text>{truncated.trim()}…</Text>\n    }\n  }\n\n  return command\n}\n\nexport function renderToolUseProgressMessage(\n  progressMessagesForMessage: ProgressMessage<BashProgress>[],\n  {\n    verbose,\n    tools: _tools,\n    terminalSize: _terminalSize,\n    inProgressToolCallCount: _inProgressToolCallCount,\n  }: {\n    tools: Tool[]\n    verbose: boolean\n    terminalSize?: { columns: number; rows: number }\n    inProgressToolCallCount?: number\n  },\n): React.ReactNode {\n  const lastProgress = progressMessagesForMessage.at(-1)\n\n  if (!lastProgress || !lastProgress.data) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>Running…</Text>\n      </MessageResponse>\n    )\n  }\n\n  const data = lastProgress.data\n\n  return (\n    <ShellProgressMessage\n      fullOutput={data.fullOutput}\n      output={data.output}\n      elapsedTimeSeconds={data.elapsedTimeSeconds}\n      totalLines={data.totalLines}\n      totalBytes={data.totalBytes}\n      timeoutMs={data.timeoutMs}\n      taskId={data.taskId}\n      verbose={verbose}\n    />\n  )\n}\n\nexport function renderToolUseQueuedMessage(): React.ReactNode {\n  return (\n    <MessageResponse height={1}>\n      <Text dimColor>Waiting…</Text>\n    </MessageResponse>\n  )\n}\n\nexport function renderToolResultMessage(\n  content: Out,\n  progressMessagesForMessage: ProgressMessage<BashProgress>[],\n  {\n    verbose,\n    theme: _theme,\n    tools: _tools,\n    style: _style,\n  }: {\n    verbose: boolean\n    theme: ThemeName\n    tools: Tool[]\n    style?: 'condensed'\n  },\n): React.ReactNode {\n  const lastProgress = progressMessagesForMessage.at(-1)\n  const timeoutMs = lastProgress?.data?.timeoutMs\n  return (\n    <BashToolResultMessage\n      content={content}\n      verbose={verbose}\n      timeoutMs={timeoutMs}\n    />\n  )\n}\n\nexport function renderToolUseErrorMessage(\n  result: ToolResultBlockParam['content'],\n  {\n    verbose,\n    progressMessagesForMessage: _progressMessagesForMessage,\n    tools: _tools,\n  }: {\n    verbose: boolean\n    progressMessagesForMessage: ProgressMessage<BashProgress>[]\n    tools: Tool[]\n  },\n): React.ReactNode {\n  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />\n}\n"],"mappings":"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","ignoreList":[]}