@xelauvas/xela-cli 0.1.0

package/src/components/permissions/BashPermissionRequest/BashPermissionRequest.tsx

@@ -0,0 +1,482 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import figures from 'figures';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text, useTheme } from '../../../ink.js';
+import { useKeybinding } from '../../../keybindings/useKeybinding.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../../services/analytics/growthbook.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../../services/analytics/index.js';
+import { sanitizeToolNameForAnalytics } from '../../../services/analytics/metadata.js';
+import { useAppState } from '../../../state/AppState.js';
+import { BashTool } from '../../../tools/BashTool/BashTool.js';
+import { getFirstWordPrefix, getSimpleCommandPrefix } from '../../../tools/BashTool/bashPermissions.js';
+import { getDestructiveCommandWarning } from '../../../tools/BashTool/destructiveCommandWarning.js';
+import { parseSedEditCommand } from '../../../tools/BashTool/sedEditParser.js';
+import { shouldUseSandbox } from '../../../tools/BashTool/shouldUseSandbox.js';
+import { getCompoundCommandPrefixesStatic } from '../../../utils/bash/prefix.js';
+import { createPromptRuleContent, generateGenericDescription, getBashPromptAllowDescriptions, isClassifierPermissionsEnabled } from '../../../utils/permissions/bashClassifier.js';
+import { extractRules } from '../../../utils/permissions/PermissionUpdate.js';
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js';
+import { SandboxManager } from '../../../utils/sandbox/sandbox-adapter.js';
+import { Select } from '../../CustomSelect/select.js';
+import { ShimmerChar } from '../../Spinner/ShimmerChar.js';
+import { useShimmerAnimation } from '../../Spinner/useShimmerAnimation.js';
+import { type UnaryEvent, usePermissionRequestLogging } from '../hooks.js';
+import { PermissionDecisionDebugInfo } from '../PermissionDecisionDebugInfo.js';
+import { PermissionDialog } from '../PermissionDialog.js';
+import { PermissionExplainerContent, usePermissionExplainerUI } from '../PermissionExplanation.js';
+import type { PermissionRequestProps } from '../PermissionRequest.js';
+import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js';
+import { SedEditPermissionRequest } from '../SedEditPermissionRequest/SedEditPermissionRequest.js';
+import { useShellPermissionFeedback } from '../useShellPermissionFeedback.js';
+import { logUnaryPermissionEvent } from '../utils.js';
+import { bashToolUseOptions } from './bashToolUseOptions.js';
+const CHECKING_TEXT = 'Attempting to auto-approve\u2026';
+
+// Isolates the 20fps shimmer clock from BashPermissionRequestInner. Before this
+// extraction, useShimmerAnimation lived inside the 535-line Inner body, so every
+// 50ms clock tick re-rendered the entire dialog (PermissionDialog + Select +
+// all children) for the ~1-3 seconds the classifier typically takes. Inner also
+// has a Compiler bailout (see below), so nothing was auto-memoized — the full
+// JSX tree was reconstructed 20-60 times per classifier check.
+function ClassifierCheckingSubtitle() {
+  const $ = _c(6);
+  const [ref, glimmerIndex] = useShimmerAnimation("requesting", CHECKING_TEXT, false);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [...CHECKING_TEXT];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] !== glimmerIndex) {
+    t1 = <Text>{t0.map((char, i) => <ShimmerChar key={i} char={char} index={i} glimmerIndex={glimmerIndex} messageColor="inactive" shimmerColor="subtle" />)}</Text>;
+    $[1] = glimmerIndex;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== ref || $[4] !== t1) {
+    t2 = <Box ref={ref}>{t1}</Box>;
+    $[3] = ref;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+export function BashPermissionRequest(props) {
+  const $ = _c(21);
+  const {
+    toolUseConfirm,
+    toolUseContext,
+    onDone,
+    onReject,
+    verbose,
+    workerBadge
+  } = props;
+  let command;
+  let description;
+  let t0;
+  if ($[0] !== toolUseConfirm.input) {
+    ({
+      command,
+      description
+    } = BashTool.inputSchema.parse(toolUseConfirm.input));
+    t0 = parseSedEditCommand(command);
+    $[0] = toolUseConfirm.input;
+    $[1] = command;
+    $[2] = description;
+    $[3] = t0;
+  } else {
+    command = $[1];
+    description = $[2];
+    t0 = $[3];
+  }
+  const sedInfo = t0;
+  if (sedInfo) {
+    let t1;
+    if ($[4] !== onDone || $[5] !== onReject || $[6] !== sedInfo || $[7] !== toolUseConfirm || $[8] !== toolUseContext || $[9] !== verbose || $[10] !== workerBadge) {
+      t1 = <SedEditPermissionRequest toolUseConfirm={toolUseConfirm} toolUseContext={toolUseContext} onDone={onDone} onReject={onReject} verbose={verbose} workerBadge={workerBadge} sedInfo={sedInfo} />;
+      $[4] = onDone;
+      $[5] = onReject;
+      $[6] = sedInfo;
+      $[7] = toolUseConfirm;
+      $[8] = toolUseContext;
+      $[9] = verbose;
+      $[10] = workerBadge;
+      $[11] = t1;
+    } else {
+      t1 = $[11];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[12] !== command || $[13] !== description || $[14] !== onDone || $[15] !== onReject || $[16] !== toolUseConfirm || $[17] !== toolUseContext || $[18] !== verbose || $[19] !== workerBadge) {
+    t1 = <BashPermissionRequestInner toolUseConfirm={toolUseConfirm} toolUseContext={toolUseContext} onDone={onDone} onReject={onReject} verbose={verbose} workerBadge={workerBadge} command={command} description={description} />;
+    $[12] = command;
+    $[13] = description;
+    $[14] = onDone;
+    $[15] = onReject;
+    $[16] = toolUseConfirm;
+    $[17] = toolUseContext;
+    $[18] = verbose;
+    $[19] = workerBadge;
+    $[20] = t1;
+  } else {
+    t1 = $[20];
+  }
+  return t1;
+}
+
+// Inner component that uses hooks - only called for non-MCP CLI commands
+function BashPermissionRequestInner({
+  toolUseConfirm,
+  toolUseContext,
+  onDone,
+  onReject,
+  verbose: _verbose,
+  workerBadge,
+  command,
+  description
+}: PermissionRequestProps & {
+  command: string;
+  description?: string;
+}): React.ReactNode {
+  const [theme] = useTheme();
+  const toolPermissionContext = useAppState(s => s.toolPermissionContext);
+  const explainerState = usePermissionExplainerUI({
+    toolName: toolUseConfirm.tool.name,
+    toolInput: toolUseConfirm.input,
+    toolDescription: toolUseConfirm.description,
+    messages: toolUseContext.messages
+  });
+  const {
+    yesInputMode,
+    noInputMode,
+    yesFeedbackModeEntered,
+    noFeedbackModeEntered,
+    acceptFeedback,
+    rejectFeedback,
+    setAcceptFeedback,
+    setRejectFeedback,
+    focusedOption,
+    handleInputModeToggle,
+    handleReject,
+    handleFocus
+  } = useShellPermissionFeedback({
+    toolUseConfirm,
+    onDone,
+    onReject,
+    explainerVisible: explainerState.visible
+  });
+  const [showPermissionDebug, setShowPermissionDebug] = useState(false);
+  const [classifierDescription, setClassifierDescription] = useState(description || '');
+  // Track whether the initial description (from prop or async generation) was empty.
+  // Once we receive a non-empty description, this stays false.
+  const [initialClassifierDescriptionEmpty, setInitialClassifierDescriptionEmpty] = useState(!description?.trim());
+
+  // Asynchronously generate a generic description for the classifier
+  useEffect(() => {
+    if (!isClassifierPermissionsEnabled()) return;
+    const abortController = new AbortController();
+    generateGenericDescription(command, description, abortController.signal).then(generic => {
+      if (generic && !abortController.signal.aborted) {
+        setClassifierDescription(generic);
+        setInitialClassifierDescriptionEmpty(false);
+      }
+    }).catch(() => {}); // Keep original on error
+    return () => abortController.abort();
+  }, [command, description]);
+
+  // GH#11380: For compound commands (cd src && git status && npm test), the
+  // backend already computed correct per-subcommand suggestions via tree-sitter
+  // split + per-subcommand permission checks. decisionReason.type ===
+  // 'subcommandResults' marks this path. The sync prefix heuristics below
+  // (getSimpleCommandPrefix/getFirstWordPrefix) operate on the FULL compound
+  // string and pick the first two words — producing dead rules like
+  // `Bash(cd src:*)` or `Bash(./script.sh && npm test)` that never match again.
+  // Users accumulate 150+ of these in settings.local.json.
+  //
+  // When compound with exactly one Bash rule (e.g. `cd src && npm test` where
+  // cd is read-only → only npm test needs approval), seed the editable input
+  // from the backend rule. When compound with 2+ rules, editablePrefix stays
+  // undefined so bashToolUseOptions falls through to yes-apply-suggestions,
+  // which saves all per-subcommand rules atomically.
+  const isCompound = toolUseConfirm.permissionResult.decisionReason?.type === 'subcommandResults';
+
+  // Editable prefix — initialize synchronously with the best prefix we can
+  // extract without tree-sitter, then refine via tree-sitter for compound
+  // commands. The sync path matters because TREE_SITTER_BASH is gated
+  // ant-only: in external builds the async refinement below always resolves
+  // to [] and this initial value is what the user sees.
+  //
+  // Lazy initializer: this runs regex + split on every render if left in
+  // the render body; it's only needed for initial state.
+  const [editablePrefix, setEditablePrefix] = useState<string | undefined>(() => {
+    if (isCompound) {
+      // Backend suggestion is the source of truth for compound commands.
+      // Single rule → seed the editable input so the user can refine it.
+      // Multiple/zero rules → undefined → yes-apply-suggestions handles it.
+      const backendBashRules = extractRules('suggestions' in toolUseConfirm.permissionResult ? toolUseConfirm.permissionResult.suggestions : undefined).filter(r => r.toolName === BashTool.name && r.ruleContent);
+      return backendBashRules.length === 1 ? backendBashRules[0]!.ruleContent : undefined;
+    }
+    const two = getSimpleCommandPrefix(command);
+    if (two) return `${two}:*`;
+    const one = getFirstWordPrefix(command);
+    if (one) return `${one}:*`;
+    return command;
+  });
+  const hasUserEditedPrefix = useRef(false);
+  const onEditablePrefixChange = useCallback((value: string) => {
+    hasUserEditedPrefix.current = true;
+    setEditablePrefix(value);
+  }, []);
+  useEffect(() => {
+    // Skip async refinement for compound commands — the backend already ran
+    // the full per-subcommand analysis and its suggestion is correct.
+    if (isCompound) return;
+    let cancelled = false;
+    getCompoundCommandPrefixesStatic(command, subcmd => BashTool.isReadOnly({
+      command: subcmd
+    })).then(prefixes => {
+      if (cancelled || hasUserEditedPrefix.current) return;
+      if (prefixes.length > 0) {
+        setEditablePrefix(`${prefixes[0]}:*`);
+      }
+    }).catch(() => {}); // Keep sync prefix on tree-sitter failure
+    return () => {
+      cancelled = true;
+    };
+  }, [command, isCompound]);
+
+  // Track whether classifier check was ever in progress (persists after completion).
+  // classifierCheckInProgress is set once at queue-push time (interactiveHandler)
+  // and only ever transitions true→false, so capturing the mount-time value is
+  // sufficient — no latch/ref needed. The feature() ternary keeps the property
+  // read out of external builds (forbidden-string check).
+  const [classifierWasChecking] = useState(feature('BASH_CLASSIFIER') ? !!toolUseConfirm.classifierCheckInProgress : false);
+
+  // These derive solely from the tool input (fixed for the dialog lifetime).
+  // The shimmer clock used to live in this component and re-render it at 20fps
+  // while the classifier ran (see ClassifierCheckingSubtitle above for the
+  // extraction). React Compiler can't auto-memoize imported functions (can't
+  // prove side-effect freedom), so this useMemo still guards against any
+  // re-render source (e.g. Inner state updates). Same pattern as PR#20730.
+  const {
+    destructiveWarning: destructiveWarning_0,
+    sandboxingEnabled: sandboxingEnabled_0,
+    isSandboxed: isSandboxed_0
+  } = useMemo(() => {
+    const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE('tengu_destructive_command_warning', false) ? getDestructiveCommandWarning(command) : null;
+    const sandboxingEnabled = SandboxManager.isSandboxingEnabled();
+    const isSandboxed = sandboxingEnabled && shouldUseSandbox(toolUseConfirm.input);
+    return {
+      destructiveWarning,
+      sandboxingEnabled,
+      isSandboxed
+    };
+  }, [command, toolUseConfirm.input]);
+  const unaryEvent = useMemo<UnaryEvent>(() => ({
+    completion_type: 'tool_use_single',
+    language_name: 'none'
+  }), []);
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent);
+  const existingAllowDescriptions = useMemo(() => getBashPromptAllowDescriptions(toolPermissionContext), [toolPermissionContext]);
+  const options = useMemo(() => bashToolUseOptions({
+    suggestions: toolUseConfirm.permissionResult.behavior === 'ask' ? toolUseConfirm.permissionResult.suggestions : undefined,
+    decisionReason: toolUseConfirm.permissionResult.decisionReason,
+    onRejectFeedbackChange: setRejectFeedback,
+    onAcceptFeedbackChange: setAcceptFeedback,
+    onClassifierDescriptionChange: setClassifierDescription,
+    classifierDescription,
+    initialClassifierDescriptionEmpty,
+    existingAllowDescriptions,
+    yesInputMode,
+    noInputMode,
+    editablePrefix,
+    onEditablePrefixChange
+  }), [toolUseConfirm, classifierDescription, initialClassifierDescriptionEmpty, existingAllowDescriptions, yesInputMode, noInputMode, editablePrefix, onEditablePrefixChange]);
+
+  // Toggle permission debug info with keybinding
+  const handleToggleDebug = useCallback(() => {
+    setShowPermissionDebug(prev => !prev);
+  }, []);
+  useKeybinding('permission:toggleDebug', handleToggleDebug, {
+    context: 'Confirmation'
+  });
+
+  // Allow Esc to dismiss the checkmark after auto-approval
+  const handleDismissCheckmark = useCallback(() => {
+    toolUseConfirm.onDismissCheckmark?.();
+  }, [toolUseConfirm]);
+  useKeybinding('confirm:no', handleDismissCheckmark, {
+    context: 'Confirmation',
+    isActive: feature('BASH_CLASSIFIER') ? !!toolUseConfirm.classifierAutoApproved : false
+  });
+  function onSelect(value_0: string) {
+    // Map options to numeric values for analytics (strings not allowed in logEvent)
+    let optionIndex: Record<string, number> = {
+      yes: 1,
+      'yes-apply-suggestions': 2,
+      'yes-prefix-edited': 2,
+      no: 3
+    };
+    if (feature('BASH_CLASSIFIER')) {
+      optionIndex = {
+        yes: 1,
+        'yes-apply-suggestions': 2,
+        'yes-prefix-edited': 2,
+        'yes-classifier-reviewed': 3,
+        no: 4
+      };
+    }
+    logEvent('tengu_permission_request_option_selected', {
+      option_index: optionIndex[value_0],
+      explainer_visible: explainerState.visible
+    });
+    const toolNameForAnalytics = sanitizeToolNameForAnalytics(toolUseConfirm.tool.name) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+    if (value_0 === 'yes-prefix-edited') {
+      const trimmedPrefix = (editablePrefix ?? '').trim();
+      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept');
+      if (!trimmedPrefix) {
+        toolUseConfirm.onAllow(toolUseConfirm.input, []);
+      } else {
+        const prefixUpdates: PermissionUpdate[] = [{
+          type: 'addRules',
+          rules: [{
+            toolName: BashTool.name,
+            ruleContent: trimmedPrefix
+          }],
+          behavior: 'allow',
+          destination: 'localSettings'
+        }];
+        toolUseConfirm.onAllow(toolUseConfirm.input, prefixUpdates);
+      }
+      onDone();
+      return;
+    }
+    if (feature('BASH_CLASSIFIER') && value_0 === 'yes-classifier-reviewed') {
+      const trimmedDescription = classifierDescription.trim();
+      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept');
+      if (!trimmedDescription) {
+        toolUseConfirm.onAllow(toolUseConfirm.input, []);
+      } else {
+        const permissionUpdates: PermissionUpdate[] = [{
+          type: 'addRules',
+          rules: [{
+            toolName: BashTool.name,
+            ruleContent: createPromptRuleContent(trimmedDescription)
+          }],
+          behavior: 'allow',
+          destination: 'session'
+        }];
+        toolUseConfirm.onAllow(toolUseConfirm.input, permissionUpdates);
+      }
+      onDone();
+      return;
+    }
+    switch (value_0) {
+      case 'yes':
+        {
+          const trimmedFeedback_0 = acceptFeedback.trim();
+          logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept');
+          // Log accept submission with feedback context
+          logEvent('tengu_accept_submitted', {
+            toolName: toolNameForAnalytics,
+            isMcp: toolUseConfirm.tool.isMcp ?? false,
+            has_instructions: !!trimmedFeedback_0,
+            instructions_length: trimmedFeedback_0.length,
+            entered_feedback_mode: yesFeedbackModeEntered
+          });
+          toolUseConfirm.onAllow(toolUseConfirm.input, [], trimmedFeedback_0 || undefined);
+          onDone();
+          break;
+        }
+      case 'yes-apply-suggestions':
+        {
+          logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept');
+          // Extract suggestions if present (works for both 'ask' and 'passthrough' behaviors)
+          const permissionUpdates_0 = 'suggestions' in toolUseConfirm.permissionResult ? toolUseConfirm.permissionResult.suggestions || [] : [];
+          toolUseConfirm.onAllow(toolUseConfirm.input, permissionUpdates_0);
+          onDone();
+          break;
+        }
+      case 'no':
+        {
+          const trimmedFeedback = rejectFeedback.trim();
+
+          // Log reject submission with feedback context
+          logEvent('tengu_reject_submitted', {
+            toolName: toolNameForAnalytics,
+            isMcp: toolUseConfirm.tool.isMcp ?? false,
+            has_instructions: !!trimmedFeedback,
+            instructions_length: trimmedFeedback.length,
+            entered_feedback_mode: noFeedbackModeEntered
+          });
+
+          // Process rejection (with or without feedback)
+          handleReject(trimmedFeedback || undefined);
+          break;
+        }
+    }
+  }
+  const classifierSubtitle = feature('BASH_CLASSIFIER') ? toolUseConfirm.classifierAutoApproved ? <Text>
+        <Text color="success">{figures.tick} Auto-approved</Text>
+        {toolUseConfirm.classifierMatchedRule && <Text dimColor>
+            {' \u00b7 matched "'}
+            {toolUseConfirm.classifierMatchedRule}
+            {'"'}
+          </Text>}
+      </Text> : toolUseConfirm.classifierCheckInProgress ? <ClassifierCheckingSubtitle /> : classifierWasChecking ? <Text dimColor>Requires manual approval</Text> : undefined : undefined;
+  return <PermissionDialog workerBadge={workerBadge} title={sandboxingEnabled_0 && !isSandboxed_0 ? 'Bash command (unsandboxed)' : 'Bash command'} subtitle={classifierSubtitle}>
+      <Box flexDirection="column" paddingX={2} paddingY={1}>
+        <Text dimColor={explainerState.visible}>
+          {BashTool.renderToolUseMessage({
+          command,
+          description
+        }, {
+          theme,
+          verbose: true
+        } // always show the full command
+        )}
+        </Text>
+        {!explainerState.visible && <Text dimColor>{toolUseConfirm.description}</Text>}
+        <PermissionExplainerContent visible={explainerState.visible} promise={explainerState.promise} />
+      </Box>
+      {showPermissionDebug ? <>
+          <PermissionDecisionDebugInfo permissionResult={toolUseConfirm.permissionResult} toolName="Bash" />
+          {toolUseContext.options.debug && <Box justifyContent="flex-end" marginTop={1}>
+              <Text dimColor>Ctrl-D to hide debug info</Text>
+            </Box>}
+        </> : <>
+          <Box flexDirection="column">
+            <PermissionRuleExplanation permissionResult={toolUseConfirm.permissionResult} toolType="command" />
+            {destructiveWarning_0 && <Box marginBottom={1}>
+                <Text color="warning" dimColor={feature('BASH_CLASSIFIER') ? toolUseConfirm.classifierAutoApproved : false}>
+                  {destructiveWarning_0}
+                </Text>
+              </Box>}
+            <Text dimColor={feature('BASH_CLASSIFIER') ? toolUseConfirm.classifierAutoApproved : false}>
+              Do you want to proceed?
+            </Text>
+            <Select options={feature('BASH_CLASSIFIER') ? toolUseConfirm.classifierAutoApproved ? options.map(o => ({
+          ...o,
+          disabled: true
+        })) : options : options} isDisabled={feature('BASH_CLASSIFIER') ? toolUseConfirm.classifierAutoApproved : false} inlineDescriptions onChange={onSelect} onCancel={() => handleReject()} onFocus={handleFocus} onInputModeToggle={handleInputModeToggle} />
+          </Box>
+          <Box justifyContent="space-between" marginTop={1}>
+            <Text dimColor>
+              Esc to cancel
+              {(focusedOption === 'yes' && !yesInputMode || focusedOption === 'no' && !noInputMode) && ' · Tab to amend'}
+              {explainerState.enabled && ` · ctrl+e to ${explainerState.visible ? 'hide' : 'explain'}`}
+            </Text>
+            {toolUseContext.options.debug && <Text dimColor>Ctrl+d to show debug info</Text>}
+          </Box>
+        </>}
+    </PermissionDialog>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","figures","React","useCallback","useEffect","useMemo","useRef","useState","Box","Text","useTheme","useKeybinding","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","sanitizeToolNameForAnalytics","useAppState","BashTool","getFirstWordPrefix","getSimpleCommandPrefix","getDestructiveCommandWarning","parseSedEditCommand","shouldUseSandbox","getCompoundCommandPrefixesStatic","createPromptRuleContent","generateGenericDescription","getBashPromptAllowDescriptions","isClassifierPermissionsEnabled","extractRules","PermissionUpdate","SandboxManager","Select","ShimmerChar","useShimmerAnimation","UnaryEvent","usePermissionRequestLogging","PermissionDecisionDebugInfo","PermissionDialog","PermissionExplainerContent","usePermissionExplainerUI","PermissionRequestProps","PermissionRuleExplanation","SedEditPermissionRequest","useShellPermissionFeedback","logUnaryPermissionEvent","bashToolUseOptions","CHECKING_TEXT","ClassifierCheckingSubtitle","$","_c","ref","glimmerIndex","t0","Symbol","for","t1","map","char","i","t2","BashPermissionRequest","props","toolUseConfirm","toolUseContext","onDone","onReject","verbose","workerBadge","command","description","input","inputSchema","parse","sedInfo","BashPermissionRequestInner","_verbose","ReactNode","theme","toolPermissionContext","s","explainerState","toolName","tool","name","toolInput","toolDescription","messages","yesInputMode","noInputMode","yesFeedbackModeEntered","noFeedbackModeEntered","acceptFeedback","rejectFeedback","setAcceptFeedback","setRejectFeedback","focusedOption","handleInputModeToggle","handleReject","handleFocus","explainerVisible","visible","showPermissionDebug","setShowPermissionDebug","classifierDescription","setClassifierDescription","initialClassifierDescriptionEmpty","setInitialClassifierDescriptionEmpty","trim","abortController","AbortController","signal","then","generic","aborted","catch","abort","isCompound","permissionResult","decisionReason","type","editablePrefix","setEditablePrefix","backendBashRules","suggestions","undefined","filter","r","ruleContent","length","two","one","hasUserEditedPrefix","onEditablePrefixChange","value","current","cancelled","subcmd","isReadOnly","prefixes","classifierWasChecking","classifierCheckInProgress","destructiveWarning","sandboxingEnabled","isSandboxed","isSandboxingEnabled","unaryEvent","completion_type","language_name","existingAllowDescriptions","options","behavior","onRejectFeedbackChange","onAcceptFeedbackChange","onClassifierDescriptionChange","handleToggleDebug","prev","context","handleDismissCheckmark","onDismissCheckmark","isActive","classifierAutoApproved","onSelect","optionIndex","Record","yes","no","option_index","explainer_visible","toolNameForAnalytics","trimmedPrefix","onAllow","prefixUpdates","rules","destination","trimmedDescription","permissionUpdates","trimmedFeedback","isMcp","has_instructions","instructions_length","entered_feedback_mode","classifierSubtitle","tick","classifierMatchedRule","renderToolUseMessage","promise","debug","o","disabled","enabled"],"sources":["BashPermissionRequest.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport figures from 'figures'\nimport React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { Box, Text, useTheme } from '../../../ink.js'\nimport { useKeybinding } from '../../../keybindings/useKeybinding.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../../../services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../../services/analytics/index.js'\nimport { sanitizeToolNameForAnalytics } from '../../../services/analytics/metadata.js'\nimport { useAppState } from '../../../state/AppState.js'\nimport { BashTool } from '../../../tools/BashTool/BashTool.js'\nimport {\n  getFirstWordPrefix,\n  getSimpleCommandPrefix,\n} from '../../../tools/BashTool/bashPermissions.js'\nimport { getDestructiveCommandWarning } from '../../../tools/BashTool/destructiveCommandWarning.js'\nimport { parseSedEditCommand } from '../../../tools/BashTool/sedEditParser.js'\nimport { shouldUseSandbox } from '../../../tools/BashTool/shouldUseSandbox.js'\nimport { getCompoundCommandPrefixesStatic } from '../../../utils/bash/prefix.js'\nimport {\n  createPromptRuleContent,\n  generateGenericDescription,\n  getBashPromptAllowDescriptions,\n  isClassifierPermissionsEnabled,\n} from '../../../utils/permissions/bashClassifier.js'\nimport { extractRules } from '../../../utils/permissions/PermissionUpdate.js'\nimport type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'\nimport { SandboxManager } from '../../../utils/sandbox/sandbox-adapter.js'\nimport { Select } from '../../CustomSelect/select.js'\nimport { ShimmerChar } from '../../Spinner/ShimmerChar.js'\nimport { useShimmerAnimation } from '../../Spinner/useShimmerAnimation.js'\nimport { type UnaryEvent, usePermissionRequestLogging } from '../hooks.js'\nimport { PermissionDecisionDebugInfo } from '../PermissionDecisionDebugInfo.js'\nimport { PermissionDialog } from '../PermissionDialog.js'\nimport {\n  PermissionExplainerContent,\n  usePermissionExplainerUI,\n} from '../PermissionExplanation.js'\nimport type { PermissionRequestProps } from '../PermissionRequest.js'\nimport { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'\nimport { SedEditPermissionRequest } from '../SedEditPermissionRequest/SedEditPermissionRequest.js'\nimport { useShellPermissionFeedback } from '../useShellPermissionFeedback.js'\nimport { logUnaryPermissionEvent } from '../utils.js'\nimport { bashToolUseOptions } from './bashToolUseOptions.js'\n\nconst CHECKING_TEXT = 'Attempting to auto-approve\\u2026'\n\n// Isolates the 20fps shimmer clock from BashPermissionRequestInner. Before this\n// extraction, useShimmerAnimation lived inside the 535-line Inner body, so every\n// 50ms clock tick re-rendered the entire dialog (PermissionDialog + Select +\n// all children) for the ~1-3 seconds the classifier typically takes. Inner also\n// has a Compiler bailout (see below), so nothing was auto-memoized — the full\n// JSX tree was reconstructed 20-60 times per classifier check.\nfunction ClassifierCheckingSubtitle(): React.ReactNode {\n  const [ref, glimmerIndex] = useShimmerAnimation(\n    'requesting',\n    CHECKING_TEXT,\n    false,\n  )\n  return (\n    <Box ref={ref}>\n      <Text>\n        {[...CHECKING_TEXT].map((char, i) => (\n          <ShimmerChar\n            key={i}\n            char={char}\n            index={i}\n            glimmerIndex={glimmerIndex}\n            messageColor=\"inactive\"\n            shimmerColor=\"subtle\"\n          />\n        ))}\n      </Text>\n    </Box>\n  )\n}\n\nexport function BashPermissionRequest(\n  props: PermissionRequestProps,\n): React.ReactNode {\n  const {\n    toolUseConfirm,\n    toolUseContext,\n    onDone,\n    onReject,\n    verbose,\n    workerBadge,\n  } = props\n\n  const { command, description } = BashTool.inputSchema.parse(\n    toolUseConfirm.input,\n  )\n\n  // Detect sed in-place edit commands and delegate to SedEditPermissionRequest\n  // This renders sed edits like file edits with a diff view\n  const sedInfo = parseSedEditCommand(command)\n\n  if (sedInfo) {\n    return (\n      <SedEditPermissionRequest\n        toolUseConfirm={toolUseConfirm}\n        toolUseContext={toolUseContext}\n        onDone={onDone}\n        onReject={onReject}\n        verbose={verbose}\n        workerBadge={workerBadge}\n        sedInfo={sedInfo}\n      />\n    )\n  }\n\n  // Regular bash command - render with hooks\n  return (\n    <BashPermissionRequestInner\n      toolUseConfirm={toolUseConfirm}\n      toolUseContext={toolUseContext}\n      onDone={onDone}\n      onReject={onReject}\n      verbose={verbose}\n      workerBadge={workerBadge}\n      command={command}\n      description={description}\n    />\n  )\n}\n\n// Inner component that uses hooks - only called for non-MCP CLI commands\nfunction BashPermissionRequestInner({\n  toolUseConfirm,\n  toolUseContext,\n  onDone,\n  onReject,\n  verbose: _verbose,\n  workerBadge,\n  command,\n  description,\n}: PermissionRequestProps & {\n  command: string\n  description?: string\n}): React.ReactNode {\n  const [theme] = useTheme()\n  const toolPermissionContext = useAppState(s => s.toolPermissionContext)\n  const explainerState = usePermissionExplainerUI({\n    toolName: toolUseConfirm.tool.name,\n    toolInput: toolUseConfirm.input,\n    toolDescription: toolUseConfirm.description,\n    messages: toolUseContext.messages,\n  })\n  const {\n    yesInputMode,\n    noInputMode,\n    yesFeedbackModeEntered,\n    noFeedbackModeEntered,\n    acceptFeedback,\n    rejectFeedback,\n    setAcceptFeedback,\n    setRejectFeedback,\n    focusedOption,\n    handleInputModeToggle,\n    handleReject,\n    handleFocus,\n  } = useShellPermissionFeedback({\n    toolUseConfirm,\n    onDone,\n    onReject,\n    explainerVisible: explainerState.visible,\n  })\n  const [showPermissionDebug, setShowPermissionDebug] = useState(false)\n  const [classifierDescription, setClassifierDescription] = useState(\n    description || '',\n  )\n  // Track whether the initial description (from prop or async generation) was empty.\n  // Once we receive a non-empty description, this stays false.\n  const [\n    initialClassifierDescriptionEmpty,\n    setInitialClassifierDescriptionEmpty,\n  ] = useState(!description?.trim())\n\n  // Asynchronously generate a generic description for the classifier\n  useEffect(() => {\n    if (!isClassifierPermissionsEnabled()) return\n\n    const abortController = new AbortController()\n    generateGenericDescription(command, description, abortController.signal)\n      .then(generic => {\n        if (generic && !abortController.signal.aborted) {\n          setClassifierDescription(generic)\n          setInitialClassifierDescriptionEmpty(false)\n        }\n      })\n      .catch(() => {}) // Keep original on error\n    return () => abortController.abort()\n  }, [command, description])\n\n  // GH#11380: For compound commands (cd src && git status && npm test), the\n  // backend already computed correct per-subcommand suggestions via tree-sitter\n  // split + per-subcommand permission checks. decisionReason.type ===\n  // 'subcommandResults' marks this path. The sync prefix heuristics below\n  // (getSimpleCommandPrefix/getFirstWordPrefix) operate on the FULL compound\n  // string and pick the first two words — producing dead rules like\n  // `Bash(cd src:*)` or `Bash(./script.sh && npm test)` that never match again.\n  // Users accumulate 150+ of these in settings.local.json.\n  //\n  // When compound with exactly one Bash rule (e.g. `cd src && npm test` where\n  // cd is read-only → only npm test needs approval), seed the editable input\n  // from the backend rule. When compound with 2+ rules, editablePrefix stays\n  // undefined so bashToolUseOptions falls through to yes-apply-suggestions,\n  // which saves all per-subcommand rules atomically.\n  const isCompound =\n    toolUseConfirm.permissionResult.decisionReason?.type === 'subcommandResults'\n\n  // Editable prefix — initialize synchronously with the best prefix we can\n  // extract without tree-sitter, then refine via tree-sitter for compound\n  // commands. The sync path matters because TREE_SITTER_BASH is gated\n  // ant-only: in external builds the async refinement below always resolves\n  // to [] and this initial value is what the user sees.\n  //\n  // Lazy initializer: this runs regex + split on every render if left in\n  // the render body; it's only needed for initial state.\n  const [editablePrefix, setEditablePrefix] = useState<string | undefined>(\n    () => {\n      if (isCompound) {\n        // Backend suggestion is the source of truth for compound commands.\n        // Single rule → seed the editable input so the user can refine it.\n        // Multiple/zero rules → undefined → yes-apply-suggestions handles it.\n        const backendBashRules = extractRules(\n          'suggestions' in toolUseConfirm.permissionResult\n            ? toolUseConfirm.permissionResult.suggestions\n            : undefined,\n        ).filter(r => r.toolName === BashTool.name && r.ruleContent)\n        return backendBashRules.length === 1\n          ? backendBashRules[0]!.ruleContent\n          : undefined\n      }\n      const two = getSimpleCommandPrefix(command)\n      if (two) return `${two}:*`\n      const one = getFirstWordPrefix(command)\n      if (one) return `${one}:*`\n      return command\n    },\n  )\n  const hasUserEditedPrefix = useRef(false)\n  const onEditablePrefixChange = useCallback((value: string) => {\n    hasUserEditedPrefix.current = true\n    setEditablePrefix(value)\n  }, [])\n  useEffect(() => {\n    // Skip async refinement for compound commands — the backend already ran\n    // the full per-subcommand analysis and its suggestion is correct.\n    if (isCompound) return\n    let cancelled = false\n    getCompoundCommandPrefixesStatic(command, subcmd =>\n      BashTool.isReadOnly({ command: subcmd }),\n    )\n      .then(prefixes => {\n        if (cancelled || hasUserEditedPrefix.current) return\n        if (prefixes.length > 0) {\n          setEditablePrefix(`${prefixes[0]}:*`)\n        }\n      })\n      .catch(() => {}) // Keep sync prefix on tree-sitter failure\n    return () => {\n      cancelled = true\n    }\n  }, [command, isCompound])\n\n  // Track whether classifier check was ever in progress (persists after completion).\n  // classifierCheckInProgress is set once at queue-push time (interactiveHandler)\n  // and only ever transitions true→false, so capturing the mount-time value is\n  // sufficient — no latch/ref needed. The feature() ternary keeps the property\n  // read out of external builds (forbidden-string check).\n  const [classifierWasChecking] = useState(\n    feature('BASH_CLASSIFIER')\n      ? !!toolUseConfirm.classifierCheckInProgress\n      : false,\n  )\n\n  // These derive solely from the tool input (fixed for the dialog lifetime).\n  // The shimmer clock used to live in this component and re-render it at 20fps\n  // while the classifier ran (see ClassifierCheckingSubtitle above for the\n  // extraction). React Compiler can't auto-memoize imported functions (can't\n  // prove side-effect freedom), so this useMemo still guards against any\n  // re-render source (e.g. Inner state updates). Same pattern as PR#20730.\n  const { destructiveWarning, sandboxingEnabled, isSandboxed } = useMemo(() => {\n    const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE(\n      'tengu_destructive_command_warning',\n      false,\n    )\n      ? getDestructiveCommandWarning(command)\n      : null\n\n    const sandboxingEnabled = SandboxManager.isSandboxingEnabled()\n    const isSandboxed =\n      sandboxingEnabled && shouldUseSandbox(toolUseConfirm.input)\n\n    return { destructiveWarning, sandboxingEnabled, isSandboxed }\n  }, [command, toolUseConfirm.input])\n\n  const unaryEvent = useMemo<UnaryEvent>(\n    () => ({ completion_type: 'tool_use_single', language_name: 'none' }),\n    [],\n  )\n\n  usePermissionRequestLogging(toolUseConfirm, unaryEvent)\n\n  const existingAllowDescriptions = useMemo(\n    () => getBashPromptAllowDescriptions(toolPermissionContext),\n    [toolPermissionContext],\n  )\n\n  const options = useMemo(\n    () =>\n      bashToolUseOptions({\n        suggestions:\n          toolUseConfirm.permissionResult.behavior === 'ask'\n            ? toolUseConfirm.permissionResult.suggestions\n            : undefined,\n        decisionReason: toolUseConfirm.permissionResult.decisionReason,\n        onRejectFeedbackChange: setRejectFeedback,\n        onAcceptFeedbackChange: setAcceptFeedback,\n        onClassifierDescriptionChange: setClassifierDescription,\n        classifierDescription,\n        initialClassifierDescriptionEmpty,\n        existingAllowDescriptions,\n        yesInputMode,\n        noInputMode,\n        editablePrefix,\n        onEditablePrefixChange,\n      }),\n    [\n      toolUseConfirm,\n      classifierDescription,\n      initialClassifierDescriptionEmpty,\n      existingAllowDescriptions,\n      yesInputMode,\n      noInputMode,\n      editablePrefix,\n      onEditablePrefixChange,\n    ],\n  )\n\n  // Toggle permission debug info with keybinding\n  const handleToggleDebug = useCallback(() => {\n    setShowPermissionDebug(prev => !prev)\n  }, [])\n  useKeybinding('permission:toggleDebug', handleToggleDebug, {\n    context: 'Confirmation',\n  })\n\n  // Allow Esc to dismiss the checkmark after auto-approval\n  const handleDismissCheckmark = useCallback(() => {\n    toolUseConfirm.onDismissCheckmark?.()\n  }, [toolUseConfirm])\n  useKeybinding('confirm:no', handleDismissCheckmark, {\n    context: 'Confirmation',\n    isActive: feature('BASH_CLASSIFIER')\n      ? !!toolUseConfirm.classifierAutoApproved\n      : false,\n  })\n\n  function onSelect(value: string) {\n    // Map options to numeric values for analytics (strings not allowed in logEvent)\n    let optionIndex: Record<string, number> = {\n      yes: 1,\n      'yes-apply-suggestions': 2,\n      'yes-prefix-edited': 2,\n      no: 3,\n    }\n    if (feature('BASH_CLASSIFIER')) {\n      optionIndex = {\n        yes: 1,\n        'yes-apply-suggestions': 2,\n        'yes-prefix-edited': 2,\n        'yes-classifier-reviewed': 3,\n        no: 4,\n      }\n    }\n    logEvent('tengu_permission_request_option_selected', {\n      option_index: optionIndex[value],\n      explainer_visible: explainerState.visible,\n    })\n\n    const toolNameForAnalytics = sanitizeToolNameForAnalytics(\n      toolUseConfirm.tool.name,\n    ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n\n    if (value === 'yes-prefix-edited') {\n      const trimmedPrefix = (editablePrefix ?? '').trim()\n      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n      if (!trimmedPrefix) {\n        toolUseConfirm.onAllow(toolUseConfirm.input, [])\n      } else {\n        const prefixUpdates: PermissionUpdate[] = [\n          {\n            type: 'addRules',\n            rules: [\n              {\n                toolName: BashTool.name,\n                ruleContent: trimmedPrefix,\n              },\n            ],\n            behavior: 'allow',\n            destination: 'localSettings',\n          },\n        ]\n        toolUseConfirm.onAllow(toolUseConfirm.input, prefixUpdates)\n      }\n      onDone()\n      return\n    }\n\n    if (feature('BASH_CLASSIFIER') && value === 'yes-classifier-reviewed') {\n      const trimmedDescription = classifierDescription.trim()\n      logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n      if (!trimmedDescription) {\n        toolUseConfirm.onAllow(toolUseConfirm.input, [])\n      } else {\n        const permissionUpdates: PermissionUpdate[] = [\n          {\n            type: 'addRules',\n            rules: [\n              {\n                toolName: BashTool.name,\n                ruleContent: createPromptRuleContent(trimmedDescription),\n              },\n            ],\n            behavior: 'allow',\n            destination: 'session',\n          },\n        ]\n        toolUseConfirm.onAllow(toolUseConfirm.input, permissionUpdates)\n      }\n      onDone()\n      return\n    }\n\n    switch (value) {\n      case 'yes': {\n        const trimmedFeedback = acceptFeedback.trim()\n        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n        // Log accept submission with feedback context\n        logEvent('tengu_accept_submitted', {\n          toolName: toolNameForAnalytics,\n          isMcp: toolUseConfirm.tool.isMcp ?? false,\n          has_instructions: !!trimmedFeedback,\n          instructions_length: trimmedFeedback.length,\n          entered_feedback_mode: yesFeedbackModeEntered,\n        })\n        toolUseConfirm.onAllow(\n          toolUseConfirm.input,\n          [],\n          trimmedFeedback || undefined,\n        )\n        onDone()\n        break\n      }\n      case 'yes-apply-suggestions': {\n        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n        // Extract suggestions if present (works for both 'ask' and 'passthrough' behaviors)\n        const permissionUpdates =\n          'suggestions' in toolUseConfirm.permissionResult\n            ? toolUseConfirm.permissionResult.suggestions || []\n            : []\n        toolUseConfirm.onAllow(toolUseConfirm.input, permissionUpdates)\n        onDone()\n        break\n      }\n      case 'no': {\n        const trimmedFeedback = rejectFeedback.trim()\n\n        // Log reject submission with feedback context\n        logEvent('tengu_reject_submitted', {\n          toolName: toolNameForAnalytics,\n          isMcp: toolUseConfirm.tool.isMcp ?? false,\n          has_instructions: !!trimmedFeedback,\n          instructions_length: trimmedFeedback.length,\n          entered_feedback_mode: noFeedbackModeEntered,\n        })\n\n        // Process rejection (with or without feedback)\n        handleReject(trimmedFeedback || undefined)\n        break\n      }\n    }\n  }\n\n  const classifierSubtitle = feature('BASH_CLASSIFIER') ? (\n    toolUseConfirm.classifierAutoApproved ? (\n      <Text>\n        <Text color=\"success\">{figures.tick} Auto-approved</Text>\n        {toolUseConfirm.classifierMatchedRule && (\n          <Text dimColor>\n            {' \\u00b7 matched \"'}\n            {toolUseConfirm.classifierMatchedRule}\n            {'\"'}\n          </Text>\n        )}\n      </Text>\n    ) : toolUseConfirm.classifierCheckInProgress ? (\n      <ClassifierCheckingSubtitle />\n    ) : classifierWasChecking ? (\n      <Text dimColor>Requires manual approval</Text>\n    ) : undefined\n  ) : undefined\n\n  return (\n    <PermissionDialog\n      workerBadge={workerBadge}\n      title={\n        sandboxingEnabled && !isSandboxed\n          ? 'Bash command (unsandboxed)'\n          : 'Bash command'\n      }\n      subtitle={classifierSubtitle}\n    >\n      <Box flexDirection=\"column\" paddingX={2} paddingY={1}>\n        <Text dimColor={explainerState.visible}>\n          {BashTool.renderToolUseMessage(\n            { command, description },\n            { theme, verbose: true }, // always show the full command\n          )}\n        </Text>\n        {!explainerState.visible && (\n          <Text dimColor>{toolUseConfirm.description}</Text>\n        )}\n        <PermissionExplainerContent\n          visible={explainerState.visible}\n          promise={explainerState.promise}\n        />\n      </Box>\n      {showPermissionDebug ? (\n        <>\n          <PermissionDecisionDebugInfo\n            permissionResult={toolUseConfirm.permissionResult}\n            toolName=\"Bash\"\n          />\n          {toolUseContext.options.debug && (\n            <Box justifyContent=\"flex-end\" marginTop={1}>\n              <Text dimColor>Ctrl-D to hide debug info</Text>\n            </Box>\n          )}\n        </>\n      ) : (\n        <>\n          <Box flexDirection=\"column\">\n            <PermissionRuleExplanation\n              permissionResult={toolUseConfirm.permissionResult}\n              toolType=\"command\"\n            />\n            {destructiveWarning && (\n              <Box marginBottom={1}>\n                <Text\n                  color=\"warning\"\n                  dimColor={\n                    feature('BASH_CLASSIFIER')\n                      ? toolUseConfirm.classifierAutoApproved\n                      : false\n                  }\n                >\n                  {destructiveWarning}\n                </Text>\n              </Box>\n            )}\n            <Text\n              dimColor={\n                feature('BASH_CLASSIFIER')\n                  ? toolUseConfirm.classifierAutoApproved\n                  : false\n              }\n            >\n              Do you want to proceed?\n            </Text>\n            <Select\n              options={\n                feature('BASH_CLASSIFIER')\n                  ? toolUseConfirm.classifierAutoApproved\n                    ? options.map(o => ({ ...o, disabled: true }))\n                    : options\n                  : options\n              }\n              isDisabled={\n                feature('BASH_CLASSIFIER')\n                  ? toolUseConfirm.classifierAutoApproved\n                  : false\n              }\n              inlineDescriptions\n              onChange={onSelect}\n              onCancel={() => handleReject()}\n              onFocus={handleFocus}\n              onInputModeToggle={handleInputModeToggle}\n            />\n          </Box>\n          <Box justifyContent=\"space-between\" marginTop={1}>\n            <Text dimColor>\n              Esc to cancel\n              {((focusedOption === 'yes' && !yesInputMode) ||\n                (focusedOption === 'no' && !noInputMode)) &&\n                ' · Tab to amend'}\n              {explainerState.enabled &&\n                ` · ctrl+e to ${explainerState.visible ? 'hide' : 'explain'}`}\n            </Text>\n            {toolUseContext.options.debug && (\n              <Text dimColor>Ctrl+d to show debug info</Text>\n            )}\n          </Box>\n        </>\n      )}\n    </PermissionDialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}