import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
import { randomUUID } from 'crypto';
import * as React from 'react';
import { BashModeProgress } from 'src/components/BashModeProgress.js';
import type { SetToolJSXFn } from 'src/Tool.js';
import { BashTool } from 'src/tools/BashTool/BashTool.js';
import type { AttachmentMessage, SystemMessage, UserMessage } from 'src/types/message.js';
import type { ShellProgress } from 'src/types/tools.js';
import { logEvent } from '../../services/analytics/index.js';
import { errorMessage, ShellError } from '../errors.js';
import { createSyntheticUserCaveatMessage, createUserInterruptionMessage, createUserMessage, prepareUserContent } from '../messages.js';
import { resolveDefaultShell } from '../shell/resolveDefaultShell.js';
import { isPowerShellToolEnabled } from '../shell/shellToolUtils.js';
import { processToolResultBlock } from '../toolResultStorage.js';
import { escapeXml } from '../xml.js';
import type { ProcessUserInputContext } from './processUserInput.js';
export async function processBashCommand(inputString: string, precedingInputBlocks: ContentBlockParam[], attachmentMessages: AttachmentMessage[], context: ProcessUserInputContext, setToolJSX: SetToolJSXFn): Promise<{
  messages: (UserMessage | AttachmentMessage | SystemMessage)[];
  shouldQuery: boolean;
}> {
  // Shell routing (docs/design/ps-shell-selection.md §5.2): consult
  // defaultShell, fall back to bash. isPowerShellToolEnabled() applies the
  // same platform + env-var gate as tools.ts so input-box routing matches
  // tool-list visibility. Computed up front so telemetry records the
  // actual shell, not the raw setting.
  const usePowerShell = isPowerShellToolEnabled() && resolveDefaultShell() === 'powershell';
  logEvent('tengu_input_bash', {
    powershell: usePowerShell
  });
  const userMessage = createUserMessage({
    content: prepareUserContent({
      inputString: `<bash-input>${inputString}</bash-input>`,
      precedingInputBlocks
    })
  });

  // ctrl+b to background indicator
  let jsx: React.ReactNode;

  // Just show initial UI
  setToolJSX({
    jsx: <BashModeProgress input={inputString} progress={null} verbose={context.options.verbose} />,
    shouldHidePromptInput: false
  });
  try {
    const bashModeContext: ProcessUserInputContext = {
      ...context,
      // TODO: Clean up this hack
      setToolJSX: _ => {
        jsx = _?.jsx;
      }
    };

    // Progress UI — shared across both shell backends (both emit ShellProgress)
    const onProgress = (progress: {
      data: ShellProgress;
    }) => {
      setToolJSX({
        jsx: <>
            <BashModeProgress input={inputString!} progress={progress.data} verbose={context.options.verbose} />
            {jsx}
          </>,
        shouldHidePromptInput: false,
        showSpinner: false
      });
    };

    // User-initiated `!` commands run outside sandbox. Both shell tools honor
    // dangerouslyDisableSandbox (checked against areUnsandboxedCommandsAllowed()
    // in shouldUseSandbox.ts). PS sandbox is Linux/macOS/WSL2 only — on Windows
    // native, shouldUseSandbox() returns false regardless (unsupported platform).
    // Lazy-require PowerShellTool so its ~300KB chunk only loads when the
    // user has actually selected the powershell default shell.
    type PSMod = typeof import('src/tools/PowerShellTool/PowerShellTool.js');
    let PowerShellTool: PSMod['PowerShellTool'] | null = null;
    if (usePowerShell) {
      /* eslint-disable @typescript-eslint/no-require-imports */
      PowerShellTool = (require('src/tools/PowerShellTool/PowerShellTool.js') as PSMod).PowerShellTool;
      /* eslint-enable @typescript-eslint/no-require-imports */
    }
    const shellTool = PowerShellTool ?? BashTool;
    const response = PowerShellTool ? await PowerShellTool.call({
      command: inputString,
      dangerouslyDisableSandbox: true
    }, bashModeContext, undefined, undefined, onProgress) : await BashTool.call({
      command: inputString,
      dangerouslyDisableSandbox: true
    }, bashModeContext, undefined, undefined, onProgress);
    const data = response.data;
    if (!data) {
      throw new Error('No result received from shell command');
    }
    const stderr = data.stderr;
    // Reuse the same formatting pipeline as inline !`cmd` bash (promptShellExecution)
    // and model-initiated Bash. When BashTool.call() persists large output to disk,
    // data.persistedOutputPath is set and the formatter wraps in <persisted-output>.
    // Pass stderr:'' to keep it separate for the <bash-stderr> UI tag.
    const mapped = await processToolResultBlock(shellTool, {
      ...data,
      stderr: ''
    }, randomUUID());
    // mapped.content may contain our own <persisted-output> wrapper (trusted
    // XML from buildLargeToolResultMessage). Escaping it would turn structural
    // tags into &lt;persisted-output&gt;, breaking the model's parse and
    // UserBashOutputMessage's extractTag. Escape the raw fallback only.
    const stdout = typeof mapped.content === 'string' ? mapped.content : escapeXml(data.stdout);
    return {
      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
        content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${escapeXml(stderr)}</bash-stderr>`
      })],
      shouldQuery: false
    };
  } catch (e) {
    if (e instanceof ShellError) {
      if (e.interrupted) {
        return {
          messages: [createSyntheticUserCaveatMessage(), userMessage, createUserInterruptionMessage({
            toolUse: false
          }), ...attachmentMessages],
          shouldQuery: false
        };
      }
      return {
        messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
          content: `<bash-stdout>${escapeXml(e.stdout)}</bash-stdout><bash-stderr>${escapeXml(e.stderr)}</bash-stderr>`
        })],
        shouldQuery: false
      };
    }
    return {
      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
        content: `<bash-stderr>Command failed: ${escapeXml(errorMessage(e))}</bash-stderr>`
      })],
      shouldQuery: false
    };
  } finally {
    setToolJSX(null);
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ContentBlockParam","randomUUID","React","BashModeProgress","SetToolJSXFn","BashTool","AttachmentMessage","SystemMessage","UserMessage","ShellProgress","logEvent","errorMessage","ShellError","createSyntheticUserCaveatMessage","createUserInterruptionMessage","createUserMessage","prepareUserContent","resolveDefaultShell","isPowerShellToolEnabled","processToolResultBlock","escapeXml","ProcessUserInputContext","processBashCommand","inputString","precedingInputBlocks","attachmentMessages","context","setToolJSX","Promise","messages","shouldQuery","usePowerShell","powershell","userMessage","content","jsx","ReactNode","options","verbose","shouldHidePromptInput","bashModeContext","_","onProgress","progress","data","showSpinner","PSMod","PowerShellTool","require","shellTool","response","call","command","dangerouslyDisableSandbox","undefined","Error","stderr","mapped","stdout","e","interrupted","toolUse"],"sources":["processBashCommand.tsx"],"sourcesContent":["import type { ContentBlockParam } from '@anthropic-ai/sdk/resources'\nimport { randomUUID } from 'crypto'\nimport * as React from 'react'\nimport { BashModeProgress } from 'src/components/BashModeProgress.js'\nimport type { SetToolJSXFn } from 'src/Tool.js'\nimport { BashTool } from 'src/tools/BashTool/BashTool.js'\nimport type {\n  AttachmentMessage,\n  SystemMessage,\n  UserMessage,\n} from 'src/types/message.js'\nimport type { ShellProgress } from 'src/types/tools.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { errorMessage, ShellError } from '../errors.js'\nimport {\n  createSyntheticUserCaveatMessage,\n  createUserInterruptionMessage,\n  createUserMessage,\n  prepareUserContent,\n} from '../messages.js'\nimport { resolveDefaultShell } from '../shell/resolveDefaultShell.js'\nimport { isPowerShellToolEnabled } from '../shell/shellToolUtils.js'\nimport { processToolResultBlock } from '../toolResultStorage.js'\nimport { escapeXml } from '../xml.js'\nimport type { ProcessUserInputContext } from './processUserInput.js'\n\nexport async function processBashCommand(\n  inputString: string,\n  precedingInputBlocks: ContentBlockParam[],\n  attachmentMessages: AttachmentMessage[],\n  context: ProcessUserInputContext,\n  setToolJSX: SetToolJSXFn,\n): Promise<{\n  messages: (UserMessage | AttachmentMessage | SystemMessage)[]\n  shouldQuery: boolean\n}> {\n  // Shell routing (docs/design/ps-shell-selection.md §5.2): consult\n  // defaultShell, fall back to bash. isPowerShellToolEnabled() applies the\n  // same platform + env-var gate as tools.ts so input-box routing matches\n  // tool-list visibility. Computed up front so telemetry records the\n  // actual shell, not the raw setting.\n  const usePowerShell =\n    isPowerShellToolEnabled() && resolveDefaultShell() === 'powershell'\n\n  logEvent('tengu_input_bash', { powershell: usePowerShell })\n\n  const userMessage = createUserMessage({\n    content: prepareUserContent({\n      inputString: `<bash-input>${inputString}</bash-input>`,\n      precedingInputBlocks,\n    }),\n  })\n\n  // ctrl+b to background indicator\n  let jsx: React.ReactNode\n\n  // Just show initial UI\n  setToolJSX({\n    jsx: (\n      <BashModeProgress\n        input={inputString}\n        progress={null}\n        verbose={context.options.verbose}\n      />\n    ),\n    shouldHidePromptInput: false,\n  })\n\n  try {\n    const bashModeContext: ProcessUserInputContext = {\n      ...context,\n      // TODO: Clean up this hack\n      setToolJSX: _ => {\n        jsx = _?.jsx\n      },\n    }\n\n    // Progress UI — shared across both shell backends (both emit ShellProgress)\n    const onProgress = (progress: { data: ShellProgress }) => {\n      setToolJSX({\n        jsx: (\n          <>\n            <BashModeProgress\n              input={inputString!}\n              progress={progress.data}\n              verbose={context.options.verbose}\n            />\n            {jsx}\n          </>\n        ),\n        shouldHidePromptInput: false,\n        showSpinner: false,\n      })\n    }\n\n    // User-initiated `!` commands run outside sandbox. Both shell tools honor\n    // dangerouslyDisableSandbox (checked against areUnsandboxedCommandsAllowed()\n    // in shouldUseSandbox.ts). PS sandbox is Linux/macOS/WSL2 only — on Windows\n    // native, shouldUseSandbox() returns false regardless (unsupported platform).\n    // Lazy-require PowerShellTool so its ~300KB chunk only loads when the\n    // user has actually selected the powershell default shell.\n    type PSMod = typeof import('src/tools/PowerShellTool/PowerShellTool.js')\n    let PowerShellTool: PSMod['PowerShellTool'] | null = null\n    if (usePowerShell) {\n      /* eslint-disable @typescript-eslint/no-require-imports */\n      PowerShellTool = (\n        require('src/tools/PowerShellTool/PowerShellTool.js') as PSMod\n      ).PowerShellTool\n      /* eslint-enable @typescript-eslint/no-require-imports */\n    }\n    const shellTool = PowerShellTool ?? BashTool\n\n    const response = PowerShellTool\n      ? await PowerShellTool.call(\n          { command: inputString, dangerouslyDisableSandbox: true },\n          bashModeContext,\n          undefined,\n          undefined,\n          onProgress,\n        )\n      : await BashTool.call(\n          {\n            command: inputString,\n            dangerouslyDisableSandbox: true,\n          },\n          bashModeContext,\n          undefined,\n          undefined,\n          onProgress,\n        )\n    const data = response.data\n\n    if (!data) {\n      throw new Error('No result received from shell command')\n    }\n\n    const stderr = data.stderr\n    // Reuse the same formatting pipeline as inline !`cmd` bash (promptShellExecution)\n    // and model-initiated Bash. When BashTool.call() persists large output to disk,\n    // data.persistedOutputPath is set and the formatter wraps in <persisted-output>.\n    // Pass stderr:'' to keep it separate for the <bash-stderr> UI tag.\n    const mapped = await processToolResultBlock(\n      shellTool,\n      { ...data, stderr: '' },\n      randomUUID(),\n    )\n    // mapped.content may contain our own <persisted-output> wrapper (trusted\n    // XML from buildLargeToolResultMessage). Escaping it would turn structural\n    // tags into &lt;persisted-output&gt;, breaking the model's parse and\n    // UserBashOutputMessage's extractTag. Escape the raw fallback only.\n    const stdout =\n      typeof mapped.content === 'string'\n        ? mapped.content\n        : escapeXml(data.stdout)\n    return {\n      messages: [\n        createSyntheticUserCaveatMessage(),\n        userMessage,\n        ...attachmentMessages,\n        createUserMessage({\n          content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${escapeXml(stderr)}</bash-stderr>`,\n        }),\n      ],\n      shouldQuery: false,\n    }\n  } catch (e) {\n    if (e instanceof ShellError) {\n      if (e.interrupted) {\n        return {\n          messages: [\n            createSyntheticUserCaveatMessage(),\n            userMessage,\n            createUserInterruptionMessage({ toolUse: false }),\n            ...attachmentMessages,\n          ],\n          shouldQuery: false,\n        }\n      }\n      return {\n        messages: [\n          createSyntheticUserCaveatMessage(),\n          userMessage,\n          ...attachmentMessages,\n          createUserMessage({\n            content: `<bash-stdout>${escapeXml(e.stdout)}</bash-stdout><bash-stderr>${escapeXml(e.stderr)}</bash-stderr>`,\n          }),\n        ],\n        shouldQuery: false,\n      }\n    }\n    return {\n      messages: [\n        createSyntheticUserCaveatMessage(),\n        userMessage,\n        ...attachmentMessages,\n        createUserMessage({\n          content: `<bash-stderr>Command failed: ${escapeXml(errorMessage(e))}</bash-stderr>`,\n        }),\n      ],\n      shouldQuery: false,\n    }\n  } finally {\n    setToolJSX(null)\n  }\n}\n"],"mappings":"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","ignoreList":[]}