@xelauvas/xela-cli 0.1.0

package/src/components/permissions/PermissionRequestTitle.tsx

@@ -0,0 +1,66 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import type { Theme } from '../../utils/theme.js';
+import type { WorkerBadgeProps } from './WorkerBadge.js';
+type Props = {
+  title: string;
+  subtitle?: React.ReactNode;
+  color?: keyof Theme;
+  workerBadge?: WorkerBadgeProps;
+};
+export function PermissionRequestTitle(t0) {
+  const $ = _c(13);
+  const {
+    title,
+    subtitle,
+    color: t1,
+    workerBadge
+  } = t0;
+  const color = t1 === undefined ? "permission" : t1;
+  let t2;
+  if ($[0] !== color || $[1] !== title) {
+    t2 = <Text bold={true} color={color}>{title}</Text>;
+    $[0] = color;
+    $[1] = title;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== workerBadge) {
+    t3 = workerBadge && <Text dimColor={true}>{"\xB7 "}@{workerBadge.name}</Text>;
+    $[3] = workerBadge;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t2 || $[6] !== t3) {
+    t4 = <Box flexDirection="row" gap={1}>{t2}{t3}</Box>;
+    $[5] = t2;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== subtitle) {
+    t5 = subtitle != null && (typeof subtitle === "string" ? <Text dimColor={true} wrap="truncate-start">{subtitle}</Text> : subtitle);
+    $[8] = subtitle;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== t4 || $[11] !== t5) {
+    t6 = <Box flexDirection="column">{t4}{t5}</Box>;
+    $[10] = t4;
+    $[11] = t5;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  return t6;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/permissions/PermissionRuleExplanation.tsx

@@ -0,0 +1,121 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import chalk from 'chalk';
+import React from 'react';
+import { Ansi, Box, Text } from '../../ink.js';
+import { useAppState } from '../../state/AppState.js';
+import type { PermissionDecision, PermissionDecisionReason } from '../../utils/permissions/PermissionResult.js';
+import { permissionRuleValueToString } from '../../utils/permissions/permissionRuleParser.js';
+import type { Theme } from '../../utils/theme.js';
+import ThemedText from '../design-system/ThemedText.js';
+export type PermissionRuleExplanationProps = {
+  permissionResult: PermissionDecision;
+  toolType: 'tool' | 'command' | 'edit' | 'read';
+};
+type DecisionReasonStrings = {
+  reasonString: string;
+  configString?: string;
+  /** When set, reasonString is plain text rendered with this theme color instead of <Ansi>. */
+  themeColor?: keyof Theme;
+};
+function stringsForDecisionReason(reason: PermissionDecisionReason | undefined, toolType: 'tool' | 'command' | 'edit' | 'read'): DecisionReasonStrings | null {
+  if (!reason) {
+    return null;
+  }
+  if ((feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) && reason.type === 'classifier') {
+    if (reason.classifier === 'auto-mode') {
+      return {
+        reasonString: `Auto mode classifier requires confirmation for this ${toolType}.\n${reason.reason}`,
+        configString: undefined,
+        themeColor: 'error'
+      };
+    }
+    return {
+      reasonString: `Classifier ${chalk.bold(reason.classifier)} requires confirmation for this ${toolType}.\n${reason.reason}`,
+      configString: undefined
+    };
+  }
+  switch (reason.type) {
+    case 'rule':
+      return {
+        reasonString: `Permission rule ${chalk.bold(permissionRuleValueToString(reason.rule.ruleValue))} requires confirmation for this ${toolType}.`,
+        configString: reason.rule.source === 'policySettings' ? undefined : '/permissions to update rules'
+      };
+    case 'hook':
+      {
+        const hookReasonString = reason.reason ? `:\n${reason.reason}` : '.';
+        const sourceLabel = reason.hookSource ? ` ${chalk.dim(`[${reason.hookSource}]`)}` : '';
+        return {
+          reasonString: `Hook ${chalk.bold(reason.hookName)} requires confirmation for this ${toolType}${hookReasonString}${sourceLabel}`,
+          configString: '/hooks to update'
+        };
+      }
+    case 'safetyCheck':
+    case 'other':
+      return {
+        reasonString: reason.reason,
+        configString: undefined
+      };
+    case 'workingDir':
+      return {
+        reasonString: reason.reason,
+        configString: '/permissions to update rules'
+      };
+    default:
+      return null;
+  }
+}
+export function PermissionRuleExplanation(t0) {
+  const $ = _c(11);
+  const {
+    permissionResult,
+    toolType
+  } = t0;
+  const permissionMode = useAppState(_temp);
+  const t1 = permissionResult?.decisionReason;
+  let t2;
+  if ($[0] !== t1 || $[1] !== toolType) {
+    t2 = stringsForDecisionReason(t1, toolType);
+    $[0] = t1;
+    $[1] = toolType;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const strings = t2;
+  if (!strings) {
+    return null;
+  }
+  const themeColor = strings.themeColor ?? (permissionResult?.decisionReason?.type === "hook" && permissionMode === "auto" ? "warning" : undefined);
+  let t3;
+  if ($[3] !== strings.reasonString || $[4] !== themeColor) {
+    t3 = themeColor ? <ThemedText color={themeColor}>{strings.reasonString}</ThemedText> : <Text><Ansi>{strings.reasonString}</Ansi></Text>;
+    $[3] = strings.reasonString;
+    $[4] = themeColor;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== strings.configString) {
+    t4 = strings.configString && <Text dimColor={true}>{strings.configString}</Text>;
+    $[6] = strings.configString;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== t3 || $[9] !== t4) {
+    t5 = <Box marginBottom={1} flexDirection="column">{t3}{t4}</Box>;
+    $[8] = t3;
+    $[9] = t4;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  return t5;
+}
+function _temp(s) {
+  return s.toolPermissionContext.mode;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","React","Ansi","Box","Text","useAppState","PermissionDecision","PermissionDecisionReason","permissionRuleValueToString","Theme","ThemedText","PermissionRuleExplanationProps","permissionResult","toolType","DecisionReasonStrings","reasonString","configString","themeColor","stringsForDecisionReason","reason","type","classifier","undefined","bold","rule","ruleValue","source","hookReasonString","sourceLabel","hookSource","dim","hookName","PermissionRuleExplanation","t0","$","_c","permissionMode","_temp","t1","decisionReason","t2","strings","t3","t4","t5","s","toolPermissionContext","mode"],"sources":["PermissionRuleExplanation.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport React from 'react'\nimport { Ansi, Box, Text } from '../../ink.js'\nimport { useAppState } from '../../state/AppState.js'\nimport type {\n  PermissionDecision,\n  PermissionDecisionReason,\n} from '../../utils/permissions/PermissionResult.js'\nimport { permissionRuleValueToString } from '../../utils/permissions/permissionRuleParser.js'\nimport type { Theme } from '../../utils/theme.js'\nimport ThemedText from '../design-system/ThemedText.js'\n\nexport type PermissionRuleExplanationProps = {\n  permissionResult: PermissionDecision\n  toolType: 'tool' | 'command' | 'edit' | 'read'\n}\n\ntype DecisionReasonStrings = {\n  reasonString: string\n  configString?: string\n  /** When set, reasonString is plain text rendered with this theme color instead of <Ansi>. */\n  themeColor?: keyof Theme\n}\n\nfunction stringsForDecisionReason(\n  reason: PermissionDecisionReason | undefined,\n  toolType: 'tool' | 'command' | 'edit' | 'read',\n): DecisionReasonStrings | null {\n  if (!reason) {\n    return null\n  }\n  if (\n    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&\n    reason.type === 'classifier'\n  ) {\n    if (reason.classifier === 'auto-mode') {\n      return {\n        reasonString: `Auto mode classifier requires confirmation for this ${toolType}.\\n${reason.reason}`,\n        configString: undefined,\n        themeColor: 'error',\n      }\n    }\n    return {\n      reasonString: `Classifier ${chalk.bold(reason.classifier)} requires confirmation for this ${toolType}.\\n${reason.reason}`,\n      configString: undefined,\n    }\n  }\n  switch (reason.type) {\n    case 'rule':\n      return {\n        reasonString: `Permission rule ${chalk.bold(\n          permissionRuleValueToString(reason.rule.ruleValue),\n        )} requires confirmation for this ${toolType}.`,\n        configString:\n          reason.rule.source === 'policySettings'\n            ? undefined\n            : '/permissions to update rules',\n      }\n    case 'hook': {\n      const hookReasonString = reason.reason ? `:\\n${reason.reason}` : '.'\n      const sourceLabel = reason.hookSource\n        ? ` ${chalk.dim(`[${reason.hookSource}]`)}`\n        : ''\n      return {\n        reasonString: `Hook ${chalk.bold(reason.hookName)} requires confirmation for this ${toolType}${hookReasonString}${sourceLabel}`,\n        configString: '/hooks to update',\n      }\n    }\n    case 'safetyCheck':\n    case 'other':\n      return {\n        reasonString: reason.reason,\n        configString: undefined,\n      }\n    case 'workingDir':\n      return {\n        reasonString: reason.reason,\n        configString: '/permissions to update rules',\n      }\n    default:\n      return null\n  }\n}\n\nexport function PermissionRuleExplanation({\n  permissionResult,\n  toolType,\n}: PermissionRuleExplanationProps): React.ReactNode {\n  const permissionMode = useAppState(s => s.toolPermissionContext.mode)\n  const strings = stringsForDecisionReason(\n    permissionResult?.decisionReason,\n    toolType,\n  )\n  if (!strings) {\n    return null\n  }\n\n  const themeColor =\n    strings.themeColor ??\n    (permissionResult?.decisionReason?.type === 'hook' &&\n    permissionMode === 'auto'\n      ? 'warning'\n      : undefined)\n\n  return (\n    <Box marginBottom={1} flexDirection=\"column\">\n      {themeColor ? (\n        <ThemedText color={themeColor}>{strings.reasonString}</ThemedText>\n      ) : (\n        <Text>\n          <Ansi>{strings.reasonString}</Ansi>\n        </Text>\n      )}\n      {strings.configString && <Text dimColor>{strings.configString}</Text>}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/permissions/PowerShellPermissionRequest/PowerShellPermissionRequest.tsx

@@ -0,0 +1,235 @@
+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 { getDestructiveCommandWarning } from '../../../tools/PowerShellTool/destructiveCommandWarning.js';
+import { PowerShellTool } from '../../../tools/PowerShellTool/PowerShellTool.js';
+import { isAllowlistedCommand } from '../../../tools/PowerShellTool/readOnlyValidation.js';
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js';
+import { getCompoundCommandPrefixesStatic } from '../../../utils/powershell/staticPrefix.js';
+import { Select } from '../../CustomSelect/select.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 { useShellPermissionFeedback } from '../useShellPermissionFeedback.js';
+import { logUnaryPermissionEvent } from '../utils.js';
+import { powershellToolUseOptions } from './powershellToolUseOptions.js';
+export function PowerShellPermissionRequest(props: PermissionRequestProps): React.ReactNode {
+  const {
+    toolUseConfirm,
+    toolUseContext,
+    onDone,
+    onReject,
+    workerBadge
+  } = props;
+  const {
+    command,
+    description
+  } = PowerShellTool.inputSchema.parse(toolUseConfirm.input);
+  const [theme] = useTheme();
+  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 destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE('tengu_destructive_command_warning', false) ? getDestructiveCommandWarning(command) : null;
+  const [showPermissionDebug, setShowPermissionDebug] = useState(false);
+
+  // Editable prefix — compute static prefix locally (no LLM call).
+  // Initialize synchronously to the raw command for single-line commands so
+  // the editable input renders immediately, then refine to the extracted prefix
+  // once the AST parser resolves. Multiline commands (`# comment\n...`,
+  // foreach loops) get undefined → powershellToolUseOptions:64 hides the
+  // "don't ask again" option — those literals are one-time-use (settings
+  // corpus shows 14 multiline rules, zero match twice). For compound commands,
+  // computes a prefix per subcommand, excluding subcommands that are already
+  // auto-allowed (read-only).
+  const [editablePrefix, setEditablePrefix] = useState<string | undefined>(command.includes('\n') ? undefined : command);
+  const hasUserEditedPrefix = useRef(false);
+  useEffect(() => {
+    let cancelled = false;
+    // Filter receives ParsedCommandElement — isAllowlistedCommand works from
+    // element.name/nameType/args directly. isReadOnlyCommand(text) would need
+    // to reparse (pwsh.exe spawn per subcommand) and returns false without the
+    // full parsed AST, making the filter a no-op.
+    getCompoundCommandPrefixesStatic(command, element => isAllowlistedCommand(element, element.text)).then(prefixes => {
+      if (cancelled || hasUserEditedPrefix.current) return;
+      if (prefixes.length > 0) {
+        setEditablePrefix(`${prefixes[0]}:*`);
+      }
+    }).catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [command]);
+  const onEditablePrefixChange = useCallback((value: string) => {
+    hasUserEditedPrefix.current = true;
+    setEditablePrefix(value);
+  }, []);
+  const unaryEvent = useMemo<UnaryEvent>(() => ({
+    completion_type: 'tool_use_single',
+    language_name: 'none'
+  }), []);
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent);
+  const options = useMemo(() => powershellToolUseOptions({
+    suggestions: toolUseConfirm.permissionResult.behavior === 'ask' ? toolUseConfirm.permissionResult.suggestions : undefined,
+    onRejectFeedbackChange: setRejectFeedback,
+    onAcceptFeedbackChange: setAcceptFeedback,
+    yesInputMode,
+    noInputMode,
+    editablePrefix,
+    onEditablePrefixChange
+  }), [toolUseConfirm, yesInputMode, noInputMode, editablePrefix, onEditablePrefixChange]);
+
+  // Toggle permission debug info with keybinding
+  const handleToggleDebug = useCallback(() => {
+    setShowPermissionDebug(prev => !prev);
+  }, []);
+  useKeybinding('permission:toggleDebug', handleToggleDebug, {
+    context: 'Confirmation'
+  });
+  function onSelect(value: string) {
+    // Map options to numeric values for analytics (strings not allowed in logEvent)
+    const optionIndex: Record<string, number> = {
+      yes: 1,
+      'yes-apply-suggestions': 2,
+      'yes-prefix-edited': 2,
+      no: 3
+    };
+    logEvent('tengu_permission_request_option_selected', {
+      option_index: optionIndex[value],
+      explainer_visible: explainerState.visible
+    });
+    const toolNameForAnalytics = sanitizeToolNameForAnalytics(toolUseConfirm.tool.name) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+    if (value === '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: PowerShellTool.name,
+            ruleContent: trimmedPrefix
+          }],
+          behavior: 'allow',
+          destination: 'localSettings'
+        }];
+        toolUseConfirm.onAllow(toolUseConfirm.input, prefixUpdates);
+      }
+      onDone();
+      return;
+    }
+    switch (value) {
+      case 'yes':
+        {
+          const trimmedFeedback = 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,
+            instructions_length: trimmedFeedback.length,
+            entered_feedback_mode: yesFeedbackModeEntered
+          });
+          toolUseConfirm.onAllow(toolUseConfirm.input, [], trimmedFeedback || 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 = 'suggestions' in toolUseConfirm.permissionResult ? toolUseConfirm.permissionResult.suggestions || [] : [];
+          toolUseConfirm.onAllow(toolUseConfirm.input, permissionUpdates);
+          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;
+        }
+    }
+  }
+  return <PermissionDialog workerBadge={workerBadge} title="PowerShell command">
+      <Box flexDirection="column" paddingX={2} paddingY={1}>
+        <Text dimColor={explainerState.visible}>
+          {PowerShellTool.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="PowerShell" />
+          {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 && <Box marginBottom={1}>
+                <Text color="warning">{destructiveWarning}</Text>
+              </Box>}
+            <Text>Do you want to proceed?</Text>
+            <Select options={options} 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":["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","getDestructiveCommandWarning","PowerShellTool","isAllowlistedCommand","PermissionUpdate","getCompoundCommandPrefixesStatic","Select","UnaryEvent","usePermissionRequestLogging","PermissionDecisionDebugInfo","PermissionDialog","PermissionExplainerContent","usePermissionExplainerUI","PermissionRequestProps","PermissionRuleExplanation","useShellPermissionFeedback","logUnaryPermissionEvent","powershellToolUseOptions","PowerShellPermissionRequest","props","ReactNode","toolUseConfirm","toolUseContext","onDone","onReject","workerBadge","command","description","inputSchema","parse","input","theme","explainerState","toolName","tool","name","toolInput","toolDescription","messages","yesInputMode","noInputMode","yesFeedbackModeEntered","noFeedbackModeEntered","acceptFeedback","rejectFeedback","setAcceptFeedback","setRejectFeedback","focusedOption","handleInputModeToggle","handleReject","handleFocus","explainerVisible","visible","destructiveWarning","showPermissionDebug","setShowPermissionDebug","editablePrefix","setEditablePrefix","includes","undefined","hasUserEditedPrefix","cancelled","element","text","then","prefixes","current","length","catch","onEditablePrefixChange","value","unaryEvent","completion_type","language_name","options","suggestions","permissionResult","behavior","onRejectFeedbackChange","onAcceptFeedbackChange","handleToggleDebug","prev","context","onSelect","optionIndex","Record","yes","no","option_index","explainer_visible","toolNameForAnalytics","trimmedPrefix","trim","onAllow","prefixUpdates","type","rules","ruleContent","destination","trimmedFeedback","isMcp","has_instructions","instructions_length","entered_feedback_mode","permissionUpdates","renderToolUseMessage","verbose","promise","debug","enabled"],"sources":["PowerShellPermissionRequest.tsx"],"sourcesContent":["import 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 { getDestructiveCommandWarning } from '../../../tools/PowerShellTool/destructiveCommandWarning.js'\nimport { PowerShellTool } from '../../../tools/PowerShellTool/PowerShellTool.js'\nimport { isAllowlistedCommand } from '../../../tools/PowerShellTool/readOnlyValidation.js'\nimport type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'\nimport { getCompoundCommandPrefixesStatic } from '../../../utils/powershell/staticPrefix.js'\nimport { Select } from '../../CustomSelect/select.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 { useShellPermissionFeedback } from '../useShellPermissionFeedback.js'\nimport { logUnaryPermissionEvent } from '../utils.js'\nimport { powershellToolUseOptions } from './powershellToolUseOptions.js'\n\nexport function PowerShellPermissionRequest(\n  props: PermissionRequestProps,\n): React.ReactNode {\n  const { toolUseConfirm, toolUseContext, onDone, onReject, workerBadge } =\n    props\n\n  const { command, description } = PowerShellTool.inputSchema.parse(\n    toolUseConfirm.input,\n  )\n\n  const [theme] = useTheme()\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 destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE(\n    'tengu_destructive_command_warning',\n    false,\n  )\n    ? getDestructiveCommandWarning(command)\n    : null\n\n  const [showPermissionDebug, setShowPermissionDebug] = useState(false)\n\n  // Editable prefix — compute static prefix locally (no LLM call).\n  // Initialize synchronously to the raw command for single-line commands so\n  // the editable input renders immediately, then refine to the extracted prefix\n  // once the AST parser resolves. Multiline commands (`# comment\\n...`,\n  // foreach loops) get undefined → powershellToolUseOptions:64 hides the\n  // \"don't ask again\" option — those literals are one-time-use (settings\n  // corpus shows 14 multiline rules, zero match twice). For compound commands,\n  // computes a prefix per subcommand, excluding subcommands that are already\n  // auto-allowed (read-only).\n  const [editablePrefix, setEditablePrefix] = useState<string | undefined>(\n    command.includes('\\n') ? undefined : command,\n  )\n  const hasUserEditedPrefix = useRef(false)\n  useEffect(() => {\n    let cancelled = false\n    // Filter receives ParsedCommandElement — isAllowlistedCommand works from\n    // element.name/nameType/args directly. isReadOnlyCommand(text) would need\n    // to reparse (pwsh.exe spawn per subcommand) and returns false without the\n    // full parsed AST, making the filter a no-op.\n    getCompoundCommandPrefixesStatic(command, element =>\n      isAllowlistedCommand(element, element.text),\n    )\n      .then(prefixes => {\n        if (cancelled || hasUserEditedPrefix.current) return\n        if (prefixes.length > 0) {\n          setEditablePrefix(`${prefixes[0]}:*`)\n        }\n      })\n      .catch(() => {})\n    return () => {\n      cancelled = true\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [command])\n\n  const onEditablePrefixChange = useCallback((value: string) => {\n    hasUserEditedPrefix.current = true\n    setEditablePrefix(value)\n  }, [])\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 options = useMemo(\n    () =>\n      powershellToolUseOptions({\n        suggestions:\n          toolUseConfirm.permissionResult.behavior === 'ask'\n            ? toolUseConfirm.permissionResult.suggestions\n            : undefined,\n        onRejectFeedbackChange: setRejectFeedback,\n        onAcceptFeedbackChange: setAcceptFeedback,\n        yesInputMode,\n        noInputMode,\n        editablePrefix,\n        onEditablePrefixChange,\n      }),\n    [\n      toolUseConfirm,\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  function onSelect(value: string) {\n    // Map options to numeric values for analytics (strings not allowed in logEvent)\n    const optionIndex: Record<string, number> = {\n      yes: 1,\n      'yes-apply-suggestions': 2,\n      'yes-prefix-edited': 2,\n      no: 3,\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: PowerShellTool.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    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  return (\n    <PermissionDialog workerBadge={workerBadge} title=\"PowerShell command\">\n      <Box flexDirection=\"column\" paddingX={2} paddingY={1}>\n        <Text dimColor={explainerState.visible}>\n          {PowerShellTool.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=\"PowerShell\"\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 color=\"warning\">{destructiveWarning}</Text>\n              </Box>\n            )}\n            <Text>Do you want to proceed?</Text>\n            <Select\n              options={options}\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":"AAAA,OAAOA,KAAK,IAAIC,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AAChF,SAASC,GAAG,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,iBAAiB;AACrD,SAASC,aAAa,QAAQ,uCAAuC;AACrE,SAASC,mCAAmC,QAAQ,2CAA2C;AAC/F,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,sCAAsC;AAC7C,SAASC,4BAA4B,QAAQ,yCAAyC;AACtF,SAASC,4BAA4B,QAAQ,4DAA4D;AACzG,SAASC,cAAc,QAAQ,iDAAiD;AAChF,SAASC,oBAAoB,QAAQ,qDAAqD;AAC1F,cAAcC,gBAAgB,QAAQ,sDAAsD;AAC5F,SAASC,gCAAgC,QAAQ,2CAA2C;AAC5F,SAASC,MAAM,QAAQ,8BAA8B;AACrD,SAAS,KAAKC,UAAU,EAAEC,2BAA2B,QAAQ,aAAa;AAC1E,SAASC,2BAA2B,QAAQ,mCAAmC;AAC/E,SAASC,gBAAgB,QAAQ,wBAAwB;AACzD,SACEC,0BAA0B,EAC1BC,wBAAwB,QACnB,6BAA6B;AACpC,cAAcC,sBAAsB,QAAQ,yBAAyB;AACrE,SAASC,yBAAyB,QAAQ,iCAAiC;AAC3E,SAASC,0BAA0B,QAAQ,kCAAkC;AAC7E,SAASC,uBAAuB,QAAQ,aAAa;AACrD,SAASC,wBAAwB,QAAQ,+BAA+B;AAExE,OAAO,SAASC,2BAA2BA,CACzCC,KAAK,EAAEN,sBAAsB,CAC9B,EAAE1B,KAAK,CAACiC,SAAS,CAAC;EACjB,MAAM;IAAEC,cAAc;IAAEC,cAAc;IAAEC,MAAM;IAAEC,QAAQ;IAAEC;EAAY,CAAC,GACrEN,KAAK;EAEP,MAAM;IAAEO,OAAO;IAAEC;EAAY,CAAC,GAAGzB,cAAc,CAAC0B,WAAW,CAACC,KAAK,CAC/DR,cAAc,CAACS,KACjB,CAAC;EAED,MAAM,CAACC,KAAK,CAAC,GAAGpC,QAAQ,CAAC,CAAC;EAC1B,MAAMqC,cAAc,GAAGpB,wBAAwB,CAAC;IAC9CqB,QAAQ,EAAEZ,cAAc,CAACa,IAAI,CAACC,IAAI;IAClCC,SAAS,EAAEf,cAAc,CAACS,KAAK;IAC/BO,eAAe,EAAEhB,cAAc,CAACM,WAAW;IAC3CW,QAAQ,EAAEhB,cAAc,CAACgB;EAC3B,CAAC,CAAC;EACF,MAAM;IACJC,YAAY;IACZC,WAAW;IACXC,sBAAsB;IACtBC,qBAAqB;IACrBC,cAAc;IACdC,cAAc;IACdC,iBAAiB;IACjBC,iBAAiB;IACjBC,aAAa;IACbC,qBAAqB;IACrBC,YAAY;IACZC;EACF,CAAC,GAAGnC,0BAA0B,CAAC;IAC7BM,cAAc;IACdE,MAAM;IACNC,QAAQ;IACR2B,gBAAgB,EAAEnB,cAAc,CAACoB;EACnC,CAAC,CAAC;EACF,MAAMC,kBAAkB,GAAGxD,mCAAmC,CAC5D,mCAAmC,EACnC,KACF,CAAC,GACGI,4BAA4B,CAACyB,OAAO,CAAC,GACrC,IAAI;EAER,MAAM,CAAC4B,mBAAmB,EAAEC,sBAAsB,CAAC,GAAG/D,QAAQ,CAAC,KAAK,CAAC;;EAErE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM,CAACgE,cAAc,EAAEC,iBAAiB,CAAC,GAAGjE,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC,CACtEkC,OAAO,CAACgC,QAAQ,CAAC,IAAI,CAAC,GAAGC,SAAS,GAAGjC,OACvC,CAAC;EACD,MAAMkC,mBAAmB,GAAGrE,MAAM,CAAC,KAAK,CAAC;EACzCF,SAAS,CAAC,MAAM;IACd,IAAIwE,SAAS,GAAG,KAAK;IACrB;IACA;IACA;IACA;IACAxD,gCAAgC,CAACqB,OAAO,EAAEoC,OAAO,IAC/C3D,oBAAoB,CAAC2D,OAAO,EAAEA,OAAO,CAACC,IAAI,CAC5C,CAAC,CACEC,IAAI,CAACC,QAAQ,IAAI;MAChB,IAAIJ,SAAS,IAAID,mBAAmB,CAACM,OAAO,EAAE;MAC9C,IAAID,QAAQ,CAACE,MAAM,GAAG,CAAC,EAAE;QACvBV,iBAAiB,CAAC,GAAGQ,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;MACvC;IACF,CAAC,CAAC,CACDG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IAClB,OAAO,MAAM;MACXP,SAAS,GAAG,IAAI;IAClB,CAAC;IACD;EACF,CAAC,EAAE,CAACnC,OAAO,CAAC,CAAC;EAEb,MAAM2C,sBAAsB,GAAGjF,WAAW,CAAC,CAACkF,KAAK,EAAE,MAAM,KAAK;IAC5DV,mBAAmB,CAACM,OAAO,GAAG,IAAI;IAClCT,iBAAiB,CAACa,KAAK,CAAC;EAC1B,CAAC,EAAE,EAAE,CAAC;EAEN,MAAMC,UAAU,GAAGjF,OAAO,CAACiB,UAAU,CAAC,CACpC,OAAO;IAAEiE,eAAe,EAAE,iBAAiB;IAAEC,aAAa,EAAE;EAAO,CAAC,CAAC,EACrE,EACF,CAAC;EAEDjE,2BAA2B,CAACa,cAAc,EAAEkD,UAAU,CAAC;EAEvD,MAAMG,OAAO,GAAGpF,OAAO,CACrB,MACE2B,wBAAwB,CAAC;IACvB0D,WAAW,EACTtD,cAAc,CAACuD,gBAAgB,CAACC,QAAQ,KAAK,KAAK,GAC9CxD,cAAc,CAACuD,gBAAgB,CAACD,WAAW,GAC3ChB,SAAS;IACfmB,sBAAsB,EAAEhC,iBAAiB;IACzCiC,sBAAsB,EAAElC,iBAAiB;IACzCN,YAAY;IACZC,WAAW;IACXgB,cAAc;IACda;EACF,CAAC,CAAC,EACJ,CACEhD,cAAc,EACdkB,YAAY,EACZC,WAAW,EACXgB,cAAc,EACda,sBAAsB,CAE1B,CAAC;;EAED;EACA,MAAMW,iBAAiB,GAAG5F,WAAW,CAAC,MAAM;IAC1CmE,sBAAsB,CAAC0B,IAAI,IAAI,CAACA,IAAI,CAAC;EACvC,CAAC,EAAE,EAAE,CAAC;EACNrF,aAAa,CAAC,wBAAwB,EAAEoF,iBAAiB,EAAE;IACzDE,OAAO,EAAE;EACX,CAAC,CAAC;EAEF,SAASC,QAAQA,CAACb,KAAK,EAAE,MAAM,EAAE;IAC/B;IACA,MAAMc,WAAW,EAAEC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;MAC1CC,GAAG,EAAE,CAAC;MACN,uBAAuB,EAAE,CAAC;MAC1B,mBAAmB,EAAE,CAAC;MACtBC,EAAE,EAAE;IACN,CAAC;IACDxF,QAAQ,CAAC,0CAA0C,EAAE;MACnDyF,YAAY,EAAEJ,WAAW,CAACd,KAAK,CAAC;MAChCmB,iBAAiB,EAAEzD,cAAc,CAACoB;IACpC,CAAC,CAAC;IAEF,MAAMsC,oBAAoB,GAAG1F,4BAA4B,CACvDqB,cAAc,CAACa,IAAI,CAACC,IACtB,CAAC,IAAIrC,0DAA0D;IAE/D,IAAIwE,KAAK,KAAK,mBAAmB,EAAE;MACjC,MAAMqB,aAAa,GAAG,CAACnC,cAAc,IAAI,EAAE,EAAEoC,IAAI,CAAC,CAAC;MACnD5E,uBAAuB,CAAC,iBAAiB,EAAEK,cAAc,EAAE,QAAQ,CAAC;MACpE,IAAI,CAACsE,aAAa,EAAE;QAClBtE,cAAc,CAACwE,OAAO,CAACxE,cAAc,CAACS,KAAK,EAAE,EAAE,CAAC;MAClD,CAAC,MAAM;QACL,MAAMgE,aAAa,EAAE1F,gBAAgB,EAAE,GAAG,CACxC;UACE2F,IAAI,EAAE,UAAU;UAChBC,KAAK,EAAE,CACL;YACE/D,QAAQ,EAAE/B,cAAc,CAACiC,IAAI;YAC7B8D,WAAW,EAAEN;UACf,CAAC,CACF;UACDd,QAAQ,EAAE,OAAO;UACjBqB,WAAW,EAAE;QACf,CAAC,CACF;QACD7E,cAAc,CAACwE,OAAO,CAACxE,cAAc,CAACS,KAAK,EAAEgE,aAAa,CAAC;MAC7D;MACAvE,MAAM,CAAC,CAAC;MACR;IACF;IAEA,QAAQ+C,KAAK;MACX,KAAK,KAAK;QAAE;UACV,MAAM6B,eAAe,GAAGxD,cAAc,CAACiD,IAAI,CAAC,CAAC;UAC7C5E,uBAAuB,CAAC,iBAAiB,EAAEK,cAAc,EAAE,QAAQ,CAAC;UACpE;UACAtB,QAAQ,CAAC,wBAAwB,EAAE;YACjCkC,QAAQ,EAAEyD,oBAAoB;YAC9BU,KAAK,EAAE/E,cAAc,CAACa,IAAI,CAACkE,KAAK,IAAI,KAAK;YACzCC,gBAAgB,EAAE,CAAC,CAACF,eAAe;YACnCG,mBAAmB,EAAEH,eAAe,CAAChC,MAAM;YAC3CoC,qBAAqB,EAAE9D;UACzB,CAAC,CAAC;UACFpB,cAAc,CAACwE,OAAO,CACpBxE,cAAc,CAACS,KAAK,EACpB,EAAE,EACFqE,eAAe,IAAIxC,SACrB,CAAC;UACDpC,MAAM,CAAC,CAAC;UACR;QACF;MACA,KAAK,uBAAuB;QAAE;UAC5BP,uBAAuB,CAAC,iBAAiB,EAAEK,cAAc,EAAE,QAAQ,CAAC;UACpE;UACA,MAAMmF,iBAAiB,GACrB,aAAa,IAAInF,cAAc,CAACuD,gBAAgB,GAC5CvD,cAAc,CAACuD,gBAAgB,CAACD,WAAW,IAAI,EAAE,GACjD,EAAE;UACRtD,cAAc,CAACwE,OAAO,CAACxE,cAAc,CAACS,KAAK,EAAE0E,iBAAiB,CAAC;UAC/DjF,MAAM,CAAC,CAAC;UACR;QACF;MACA,KAAK,IAAI;QAAE;UACT,MAAM4E,eAAe,GAAGvD,cAAc,CAACgD,IAAI,CAAC,CAAC;;UAE7C;UACA7F,QAAQ,CAAC,wBAAwB,EAAE;YACjCkC,QAAQ,EAAEyD,oBAAoB;YAC9BU,KAAK,EAAE/E,cAAc,CAACa,IAAI,CAACkE,KAAK,IAAI,KAAK;YACzCC,gBAAgB,EAAE,CAAC,CAACF,eAAe;YACnCG,mBAAmB,EAAEH,eAAe,CAAChC,MAAM;YAC3CoC,qBAAqB,EAAE7D;UACzB,CAAC,CAAC;;UAEF;UACAO,YAAY,CAACkD,eAAe,IAAIxC,SAAS,CAAC;UAC1C;QACF;IACF;EACF;EAEA,OACE,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAClC,WAAW,CAAC,CAAC,KAAK,CAAC,oBAAoB;AAC1E,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC3D,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAACO,cAAc,CAACoB,OAAO,CAAC;AAC/C,UAAU,CAAClD,cAAc,CAACuG,oBAAoB,CAClC;UAAE/E,OAAO;UAAEC;QAAY,CAAC,EACxB;UAAEI,KAAK;UAAE2E,OAAO,EAAE;QAAK,CAAC,CAAE;QAC5B,CAAC;AACX,QAAQ,EAAE,IAAI;AACd,QAAQ,CAAC,CAAC1E,cAAc,CAACoB,OAAO,IACtB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC/B,cAAc,CAACM,WAAW,CAAC,EAAE,IAAI,CAClD;AACT,QAAQ,CAAC,0BAA0B,CACzB,OAAO,CAAC,CAACK,cAAc,CAACoB,OAAO,CAAC,CAChC,OAAO,CAAC,CAACpB,cAAc,CAAC2E,OAAO,CAAC;AAE1C,MAAM,EAAE,GAAG;AACX,MAAM,CAACrD,mBAAmB,GAClB;AACR,UAAU,CAAC,2BAA2B,CAC1B,gBAAgB,CAAC,CAACjC,cAAc,CAACuD,gBAAgB,CAAC,CAClD,QAAQ,CAAC,YAAY;AAEjC,UAAU,CAACtD,cAAc,CAACoD,OAAO,CAACkC,KAAK,IAC3B,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACxD,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,yBAAyB,EAAE,IAAI;AAC5D,YAAY,EAAE,GAAG,CACN;AACX,QAAQ,GAAG,GAEH;AACR,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ;AACrC,YAAY,CAAC,yBAAyB,CACxB,gBAAgB,CAAC,CAACvF,cAAc,CAACuD,gBAAgB,CAAC,CAClD,QAAQ,CAAC,SAAS;AAEhC,YAAY,CAACvB,kBAAkB,IACjB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AACnC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAACA,kBAAkB,CAAC,EAAE,IAAI;AAChE,cAAc,EAAE,GAAG,CACN;AACb,YAAY,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI;AAC/C,YAAY,CAAC,MAAM,CACL,OAAO,CAAC,CAACqB,OAAO,CAAC,CACjB,kBAAkB,CAClB,QAAQ,CAAC,CAACS,QAAQ,CAAC,CACnB,QAAQ,CAAC,CAAC,MAAMlC,YAAY,CAAC,CAAC,CAAC,CAC/B,OAAO,CAAC,CAACC,WAAW,CAAC,CACrB,iBAAiB,CAAC,CAACF,qBAAqB,CAAC;AAEvD,UAAU,EAAE,GAAG;AACf,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC3D,YAAY,CAAC,IAAI,CAAC,QAAQ;AAC1B;AACA,cAAc,CAAC,CAAED,aAAa,KAAK,KAAK,IAAI,CAACR,YAAY,IACxCQ,aAAa,KAAK,IAAI,IAAI,CAACP,WAAY,KACxC,iBAAiB;AACjC,cAAc,CAACR,cAAc,CAAC6E,OAAO,IACrB,gBAAgB7E,cAAc,CAACoB,OAAO,GAAG,MAAM,GAAG,SAAS,EAAE;AAC7E,YAAY,EAAE,IAAI;AAClB,YAAY,CAAC9B,cAAc,CAACoD,OAAO,CAACkC,KAAK,IAC3B,CAAC,IAAI,CAAC,QAAQ,CAAC,yBAAyB,EAAE,IAAI,CAC/C;AACb,UAAU,EAAE,GAAG;AACf,QAAQ,GACD;AACP,IAAI,EAAE,gBAAgB,CAAC;AAEvB","ignoreList":[]}

package/src/components/permissions/PowerShellPermissionRequest/powershellToolUseOptions.tsx

@@ -0,0 +1,91 @@
+import { POWERSHELL_TOOL_NAME } from '../../../tools/PowerShellTool/toolName.js';
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js';
+import { shouldShowAlwaysAllowOptions } from '../../../utils/permissions/permissionsLoader.js';
+import type { OptionWithDescription } from '../../CustomSelect/select.js';
+import { generateShellSuggestionsLabel } from '../shellPermissionHelpers.js';
+export type PowerShellToolUseOption = 'yes' | 'yes-apply-suggestions' | 'yes-prefix-edited' | 'no';
+export function powershellToolUseOptions({
+  suggestions = [],
+  onRejectFeedbackChange,
+  onAcceptFeedbackChange,
+  yesInputMode = false,
+  noInputMode = false,
+  editablePrefix,
+  onEditablePrefixChange
+}: {
+  suggestions?: PermissionUpdate[];
+  onRejectFeedbackChange: (value: string) => void;
+  onAcceptFeedbackChange: (value: string) => void;
+  yesInputMode?: boolean;
+  noInputMode?: boolean;
+  editablePrefix?: string;
+  onEditablePrefixChange?: (value: string) => void;
+}): OptionWithDescription<PowerShellToolUseOption>[] {
+  const options: OptionWithDescription<PowerShellToolUseOption>[] = [];
+  if (yesInputMode) {
+    options.push({
+      type: 'input',
+      label: 'Yes',
+      value: 'yes',
+      placeholder: 'and tell Claude what to do next',
+      onChange: onAcceptFeedbackChange,
+      allowEmptySubmitToCancel: true
+    });
+  } else {
+    options.push({
+      label: 'Yes',
+      value: 'yes'
+    });
+  }
+
+  // Note: No sandbox toggle for PowerShell - sandbox is not supported on Windows
+  // Note: No classifier-reviewed option for PowerShell (ANT-ONLY feature for Bash)
+
+  // Only show "always allow" options when not restricted by allowManagedPermissionRulesOnly.
+  // Prefer the editable prefix input (static extractor + user edits) over the
+  // non-editable suggestions label. The editable input can't represent
+  // directory permissions or Read-tool rules, so fall back to the label when
+  // those are present.
+  if (shouldShowAlwaysAllowOptions() && suggestions.length > 0) {
+    const hasNonPowerShellSuggestions = suggestions.some(s => s.type === 'addDirectories' || s.type === 'addRules' && s.rules?.some(r => r.toolName !== POWERSHELL_TOOL_NAME));
+    if (editablePrefix !== undefined && onEditablePrefixChange && !hasNonPowerShellSuggestions) {
+      options.push({
+        type: 'input',
+        label: 'Yes, and don\u2019t ask again for',
+        value: 'yes-prefix-edited',
+        placeholder: 'command prefix (e.g., Get-Process:*)',
+        initialValue: editablePrefix,
+        onChange: onEditablePrefixChange,
+        allowEmptySubmitToCancel: true,
+        showLabelWithValue: true,
+        labelValueSeparator: ': ',
+        resetCursorOnUpdate: true
+      });
+    } else {
+      const label = generateShellSuggestionsLabel(suggestions, POWERSHELL_TOOL_NAME);
+      if (label) {
+        options.push({
+          label,
+          value: 'yes-apply-suggestions'
+        });
+      }
+    }
+  }
+  if (noInputMode) {
+    options.push({
+      type: 'input',
+      label: 'No',
+      value: 'no',
+      placeholder: 'and tell Claude what to do differently',
+      onChange: onRejectFeedbackChange,
+      allowEmptySubmitToCancel: true
+    });
+  } else {
+    options.push({
+      label: 'No',
+      value: 'no'
+    });
+  }
+  return options;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["POWERSHELL_TOOL_NAME","PermissionUpdate","shouldShowAlwaysAllowOptions","OptionWithDescription","generateShellSuggestionsLabel","PowerShellToolUseOption","powershellToolUseOptions","suggestions","onRejectFeedbackChange","onAcceptFeedbackChange","yesInputMode","noInputMode","editablePrefix","onEditablePrefixChange","value","options","push","type","label","placeholder","onChange","allowEmptySubmitToCancel","length","hasNonPowerShellSuggestions","some","s","rules","r","toolName","undefined","initialValue","showLabelWithValue","labelValueSeparator","resetCursorOnUpdate"],"sources":["powershellToolUseOptions.tsx"],"sourcesContent":["import { POWERSHELL_TOOL_NAME } from '../../../tools/PowerShellTool/toolName.js'\nimport type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'\nimport { shouldShowAlwaysAllowOptions } from '../../../utils/permissions/permissionsLoader.js'\nimport type { OptionWithDescription } from '../../CustomSelect/select.js'\nimport { generateShellSuggestionsLabel } from '../shellPermissionHelpers.js'\n\nexport type PowerShellToolUseOption =\n  | 'yes'\n  | 'yes-apply-suggestions'\n  | 'yes-prefix-edited'\n  | 'no'\n\nexport function powershellToolUseOptions({\n  suggestions = [],\n  onRejectFeedbackChange,\n  onAcceptFeedbackChange,\n  yesInputMode = false,\n  noInputMode = false,\n  editablePrefix,\n  onEditablePrefixChange,\n}: {\n  suggestions?: PermissionUpdate[]\n  onRejectFeedbackChange: (value: string) => void\n  onAcceptFeedbackChange: (value: string) => void\n  yesInputMode?: boolean\n  noInputMode?: boolean\n  editablePrefix?: string\n  onEditablePrefixChange?: (value: string) => void\n}): OptionWithDescription<PowerShellToolUseOption>[] {\n  const options: OptionWithDescription<PowerShellToolUseOption>[] = []\n\n  if (yesInputMode) {\n    options.push({\n      type: 'input',\n      label: 'Yes',\n      value: 'yes',\n      placeholder: 'and tell Claude what to do next',\n      onChange: onAcceptFeedbackChange,\n      allowEmptySubmitToCancel: true,\n    })\n  } else {\n    options.push({\n      label: 'Yes',\n      value: 'yes',\n    })\n  }\n\n  // Note: No sandbox toggle for PowerShell - sandbox is not supported on Windows\n  // Note: No classifier-reviewed option for PowerShell (ANT-ONLY feature for Bash)\n\n  // Only show \"always allow\" options when not restricted by allowManagedPermissionRulesOnly.\n  // Prefer the editable prefix input (static extractor + user edits) over the\n  // non-editable suggestions label. The editable input can't represent\n  // directory permissions or Read-tool rules, so fall back to the label when\n  // those are present.\n  if (shouldShowAlwaysAllowOptions() && suggestions.length > 0) {\n    const hasNonPowerShellSuggestions = suggestions.some(\n      s =>\n        s.type === 'addDirectories' ||\n        (s.type === 'addRules' &&\n          s.rules?.some(r => r.toolName !== POWERSHELL_TOOL_NAME)),\n    )\n    if (\n      editablePrefix !== undefined &&\n      onEditablePrefixChange &&\n      !hasNonPowerShellSuggestions\n    ) {\n      options.push({\n        type: 'input',\n        label: 'Yes, and don\\u2019t ask again for',\n        value: 'yes-prefix-edited',\n        placeholder: 'command prefix (e.g., Get-Process:*)',\n        initialValue: editablePrefix,\n        onChange: onEditablePrefixChange,\n        allowEmptySubmitToCancel: true,\n        showLabelWithValue: true,\n        labelValueSeparator: ': ',\n        resetCursorOnUpdate: true,\n      })\n    } else {\n      const label = generateShellSuggestionsLabel(\n        suggestions,\n        POWERSHELL_TOOL_NAME,\n      )\n      if (label) {\n        options.push({\n          label,\n          value: 'yes-apply-suggestions',\n        })\n      }\n    }\n  }\n\n  if (noInputMode) {\n    options.push({\n      type: 'input',\n      label: 'No',\n      value: 'no',\n      placeholder: 'and tell Claude what to do differently',\n      onChange: onRejectFeedbackChange,\n      allowEmptySubmitToCancel: true,\n    })\n  } else {\n    options.push({\n      label: 'No',\n      value: 'no',\n    })\n  }\n\n  return options\n}\n"],"mappings":"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","ignoreList":[]}