@xortex/xcode 3.0.0 → 3.0.2

package/components/permissions/FilePermissionDialog/FilePermissionDialog.tsx

@@ -0,0 +1,204 @@
+import { relative } from 'path';
+import React, { useMemo } from 'react';
+import { useDiffInIDE } from '../../../hooks/useDiffInIDE.js';
+import { Box, Text } from '../../../ink.js';
+import type { ToolUseContext } from '../../../Tool.js';
+import { getLanguageName } from '../../../utils/cliHighlight.js';
+import { getCwd } from '../../../utils/cwd.js';
+import { getFsImplementation, safeResolvePath } from '../../../utils/fsOperations.js';
+import { expandPath } from '../../../utils/path.js';
+import type { CompletionType } from '../../../utils/unaryLogging.js';
+import { Select } from '../../CustomSelect/index.js';
+import { ShowInIDEPrompt } from '../../ShowInIDEPrompt.js';
+import { usePermissionRequestLogging } from '../hooks.js';
+import { PermissionDialog } from '../PermissionDialog.js';
+import type { ToolUseConfirm } from '../PermissionRequest.js';
+import type { WorkerBadgeProps } from '../WorkerBadge.js';
+import type { IDEDiffSupport } from './ideDiffConfig.js';
+import type { FileOperationType, PermissionOption } from './permissionOptions.js';
+import { type ToolInput, useFilePermissionDialog } from './useFilePermissionDialog.js';
+export type FilePermissionDialogProps<T extends ToolInput = ToolInput> = {
+  // Required props from PermissionRequestProps
+  toolUseConfirm: ToolUseConfirm;
+  toolUseContext: ToolUseContext;
+  onDone: () => void;
+  onReject: () => void;
+
+  // Dialog customization
+  title: string;
+  subtitle?: React.ReactNode;
+  question?: string | React.ReactNode;
+  content?: React.ReactNode; // Can be general content or diff component
+
+  // Logging
+  completionType?: CompletionType;
+  languageName?: string; // override — derived from path when omitted
+
+  // File/directory operations
+  path: string | null;
+  parseInput: (input: unknown) => T;
+  operationType?: FileOperationType;
+
+  // IDE diff support
+  ideDiffSupport?: IDEDiffSupport<T>;
+
+  // Worker badge for teammate permission requests
+  workerBadge: WorkerBadgeProps | undefined;
+};
+export function FilePermissionDialog<T extends ToolInput = ToolInput>({
+  toolUseConfirm,
+  toolUseContext,
+  onDone,
+  onReject,
+  title,
+  subtitle,
+  question = 'Do you want to proceed?',
+  content,
+  completionType = 'tool_use_single',
+  path,
+  parseInput,
+  operationType = 'write',
+  ideDiffSupport,
+  workerBadge,
+  languageName: languageNameOverride
+}: FilePermissionDialogProps<T>): React.ReactNode {
+  // Derive from path unless caller provided an explicit override (NotebookEdit
+  // passes 'python'/'markdown' from cell_type). getLanguageName is async;
+  // downstream UnaryEvent.language_name and logPermissionEvent already accept
+  // Promise<string>. useMemo keeps the promise stable across renders.
+  const languageName = useMemo(() => languageNameOverride ?? (path ? getLanguageName(path) : 'none'), [languageNameOverride, path]);
+  const unaryEvent = useMemo(() => ({
+    completion_type: completionType,
+    language_name: languageName
+  }), [completionType, languageName]);
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent);
+  const symlinkTarget = useMemo(() => {
+    if (!path || operationType === 'read') {
+      return null;
+    }
+    const expandedPath = expandPath(path);
+    const fs = getFsImplementation();
+    const {
+      resolvedPath,
+      isSymlink
+    } = safeResolvePath(fs, expandedPath);
+    if (isSymlink) {
+      return resolvedPath;
+    }
+    return null;
+  }, [path, operationType]);
+  const fileDialogResult = useFilePermissionDialog({
+    filePath: path || '',
+    completionType,
+    languageName,
+    toolUseConfirm,
+    onDone,
+    onReject,
+    parseInput,
+    operationType
+  });
+
+  // Use file dialog results for options
+  const {
+    options,
+    acceptFeedback,
+    rejectFeedback,
+    setFocusedOption,
+    handleInputModeToggle,
+    focusedOption,
+    yesInputMode,
+    noInputMode
+  } = fileDialogResult;
+
+  // Parse input using the provided parser
+  const parsedInput = parseInput(toolUseConfirm.input);
+
+  // Set up IDE diff support if enabled. Memoized: getConfig may do disk I/O
+  // (FileWrite's getConfig calls readFileSync for the old-content diff).
+  // Keyed on the raw input — parseInput is a pure Zod parse whose result
+  // depends only on toolUseConfirm.input.
+  const ideDiffConfig = useMemo(() => ideDiffSupport ? ideDiffSupport.getConfig(parseInput(toolUseConfirm.input)) : null, [ideDiffSupport, toolUseConfirm.input]);
+
+  // Create diff params based on whether IDE diff is available
+  const diffParams = ideDiffConfig ? {
+    onChange: (option: PermissionOption, input: {
+      file_path: string;
+      edits: Array<{
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean;
+      }>;
+    }) => {
+      const transformedInput = ideDiffSupport!.applyChanges(parsedInput, input.edits);
+      fileDialogResult.onChange(option, transformedInput);
+    },
+    toolUseContext,
+    filePath: ideDiffConfig.filePath,
+    edits: (ideDiffConfig.edits || []).map(e => ({
+      old_string: e.old_string,
+      new_string: e.new_string,
+      replace_all: e.replace_all || false
+    })),
+    editMode: ideDiffConfig.editMode || 'single'
+  } : {
+    onChange: () => {},
+    toolUseContext,
+    filePath: '',
+    edits: [],
+    editMode: 'single' as const
+  };
+  const {
+    closeTabInIDE,
+    showingDiffInIDE,
+    ideName
+  } = useDiffInIDE(diffParams);
+  const onChange = (option_0: PermissionOption, feedback?: string) => {
+    closeTabInIDE?.();
+    fileDialogResult.onChange(option_0, parsedInput, feedback?.trim());
+  };
+  if (showingDiffInIDE && ideDiffConfig && path) {
+    return <ShowInIDEPrompt onChange={(option_1: PermissionOption, _input, feedback_0?: string) => onChange(option_1, feedback_0)} options={options} filePath={path} input={parsedInput} ideName={ideName} symlinkTarget={symlinkTarget} rejectFeedback={rejectFeedback} acceptFeedback={acceptFeedback} setFocusedOption={setFocusedOption} onInputModeToggle={handleInputModeToggle} focusedOption={focusedOption} yesInputMode={yesInputMode} noInputMode={noInputMode} />;
+  }
+  const isSymlinkOutsideCwd = symlinkTarget != null && relative(getCwd(), symlinkTarget).startsWith('..');
+  const symlinkWarning = symlinkTarget ? <Box paddingX={1} marginBottom={1}>
+      <Text color="warning">
+        {isSymlinkOutsideCwd ? `This will modify ${symlinkTarget} (outside working directory) via a symlink` : `Symlink target: ${symlinkTarget}`}
+      </Text>
+    </Box> : null;
+  return <>
+      <PermissionDialog title={title} subtitle={subtitle} innerPaddingX={0} workerBadge={workerBadge}>
+        {symlinkWarning}
+        {content}
+        <Box flexDirection="column" paddingX={1}>
+          {typeof question === 'string' ? <Text>{question}</Text> : question}
+          <Select options={options} inlineDescriptions onChange={value => {
+          const selected = options.find(opt => opt.value === value);
+          if (selected) {
+            // For reject option
+            if (selected.option.type === 'reject') {
+              const trimmedFeedback = rejectFeedback.trim();
+              onChange(selected.option, trimmedFeedback || undefined);
+              return;
+            }
+            // For accept-once option, pass accept feedback if present
+            if (selected.option.type === 'accept-once') {
+              const trimmedFeedback_0 = acceptFeedback.trim();
+              onChange(selected.option, trimmedFeedback_0 || undefined);
+              return;
+            }
+            onChange(selected.option);
+          }
+        }} onCancel={() => onChange({
+          type: 'reject'
+        })} onFocus={value_0 => setFocusedOption(value_0)} onInputModeToggle={handleInputModeToggle} />
+        </Box>
+      </PermissionDialog>
+      <Box paddingX={1} marginTop={1}>
+        <Text dimColor>
+          Esc to cancel
+          {(focusedOption === 'yes' && !yesInputMode || focusedOption === 'no' && !noInputMode) && ' · Tab to amend'}
+        </Text>
+      </Box>
+    </>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["relative","React","useMemo","useDiffInIDE","Box","Text","ToolUseContext","getLanguageName","getCwd","getFsImplementation","safeResolvePath","expandPath","CompletionType","Select","ShowInIDEPrompt","usePermissionRequestLogging","PermissionDialog","ToolUseConfirm","WorkerBadgeProps","IDEDiffSupport","FileOperationType","PermissionOption","ToolInput","useFilePermissionDialog","FilePermissionDialogProps","toolUseConfirm","toolUseContext","onDone","onReject","title","subtitle","ReactNode","question","content","completionType","languageName","path","parseInput","input","T","operationType","ideDiffSupport","workerBadge","FilePermissionDialog","languageNameOverride","unaryEvent","completion_type","language_name","symlinkTarget","expandedPath","fs","resolvedPath","isSymlink","fileDialogResult","filePath","options","acceptFeedback","rejectFeedback","setFocusedOption","handleInputModeToggle","focusedOption","yesInputMode","noInputMode","parsedInput","ideDiffConfig","getConfig","diffParams","onChange","option","file_path","edits","Array","old_string","new_string","replace_all","transformedInput","applyChanges","map","e","editMode","const","closeTabInIDE","showingDiffInIDE","ideName","feedback","trim","_input","isSymlinkOutsideCwd","startsWith","symlinkWarning","value","selected","find","opt","type","trimmedFeedback","undefined"],"sources":["FilePermissionDialog.tsx"],"sourcesContent":["import { relative } from 'path'\nimport React, { useMemo } from 'react'\nimport { useDiffInIDE } from '../../../hooks/useDiffInIDE.js'\nimport { Box, Text } from '../../../ink.js'\nimport type { ToolUseContext } from '../../../Tool.js'\nimport { getLanguageName } from '../../../utils/cliHighlight.js'\nimport { getCwd } from '../../../utils/cwd.js'\nimport {\n  getFsImplementation,\n  safeResolvePath,\n} from '../../../utils/fsOperations.js'\nimport { expandPath } from '../../../utils/path.js'\nimport type { CompletionType } from '../../../utils/unaryLogging.js'\nimport { Select } from '../../CustomSelect/index.js'\nimport { ShowInIDEPrompt } from '../../ShowInIDEPrompt.js'\nimport { usePermissionRequestLogging } from '../hooks.js'\nimport { PermissionDialog } from '../PermissionDialog.js'\nimport type { ToolUseConfirm } from '../PermissionRequest.js'\nimport type { WorkerBadgeProps } from '../WorkerBadge.js'\nimport type { IDEDiffSupport } from './ideDiffConfig.js'\nimport type {\n  FileOperationType,\n  PermissionOption,\n} from './permissionOptions.js'\nimport {\n  type ToolInput,\n  useFilePermissionDialog,\n} from './useFilePermissionDialog.js'\n\nexport type FilePermissionDialogProps<T extends ToolInput = ToolInput> = {\n  // Required props from PermissionRequestProps\n  toolUseConfirm: ToolUseConfirm\n  toolUseContext: ToolUseContext\n  onDone: () => void\n  onReject: () => void\n\n  // Dialog customization\n  title: string\n  subtitle?: React.ReactNode\n  question?: string | React.ReactNode\n  content?: React.ReactNode // Can be general content or diff component\n\n  // Logging\n  completionType?: CompletionType\n  languageName?: string // override — derived from path when omitted\n\n  // File/directory operations\n  path: string | null\n  parseInput: (input: unknown) => T\n  operationType?: FileOperationType\n\n  // IDE diff support\n  ideDiffSupport?: IDEDiffSupport<T>\n\n  // Worker badge for teammate permission requests\n  workerBadge: WorkerBadgeProps | undefined\n}\n\nexport function FilePermissionDialog<T extends ToolInput = ToolInput>({\n  toolUseConfirm,\n  toolUseContext,\n  onDone,\n  onReject,\n  title,\n  subtitle,\n  question = 'Do you want to proceed?',\n  content,\n  completionType = 'tool_use_single',\n  path,\n  parseInput,\n  operationType = 'write',\n  ideDiffSupport,\n  workerBadge,\n  languageName: languageNameOverride,\n}: FilePermissionDialogProps<T>): React.ReactNode {\n  // Derive from path unless caller provided an explicit override (NotebookEdit\n  // passes 'python'/'markdown' from cell_type). getLanguageName is async;\n  // downstream UnaryEvent.language_name and logPermissionEvent already accept\n  // Promise<string>. useMemo keeps the promise stable across renders.\n  const languageName = useMemo(\n    () => languageNameOverride ?? (path ? getLanguageName(path) : 'none'),\n    [languageNameOverride, path],\n  )\n  const unaryEvent = useMemo(\n    () => ({\n      completion_type: completionType,\n      language_name: languageName,\n    }),\n    [completionType, languageName],\n  )\n  usePermissionRequestLogging(toolUseConfirm, unaryEvent)\n\n  const symlinkTarget = useMemo(() => {\n    if (!path || operationType === 'read') {\n      return null\n    }\n    const expandedPath = expandPath(path)\n    const fs = getFsImplementation()\n    const { resolvedPath, isSymlink } = safeResolvePath(fs, expandedPath)\n    if (isSymlink) {\n      return resolvedPath\n    }\n    return null\n  }, [path, operationType])\n\n  const fileDialogResult = useFilePermissionDialog({\n    filePath: path || '',\n    completionType,\n    languageName,\n    toolUseConfirm,\n    onDone,\n    onReject,\n    parseInput,\n    operationType,\n  })\n\n  // Use file dialog results for options\n  const {\n    options,\n    acceptFeedback,\n    rejectFeedback,\n    setFocusedOption,\n    handleInputModeToggle,\n    focusedOption,\n    yesInputMode,\n    noInputMode,\n  } = fileDialogResult\n\n  // Parse input using the provided parser\n  const parsedInput = parseInput(toolUseConfirm.input)\n\n  // Set up IDE diff support if enabled. Memoized: getConfig may do disk I/O\n  // (FileWrite's getConfig calls readFileSync for the old-content diff).\n  // Keyed on the raw input — parseInput is a pure Zod parse whose result\n  // depends only on toolUseConfirm.input.\n  const ideDiffConfig = useMemo(\n    () =>\n      ideDiffSupport\n        ? ideDiffSupport.getConfig(parseInput(toolUseConfirm.input))\n        : null,\n    [ideDiffSupport, toolUseConfirm.input],\n  )\n\n  // Create diff params based on whether IDE diff is available\n  const diffParams = ideDiffConfig\n    ? {\n        onChange: (\n          option: PermissionOption,\n          input: {\n            file_path: string\n            edits: Array<{\n              old_string: string\n              new_string: string\n              replace_all?: boolean\n            }>\n          },\n        ) => {\n          const transformedInput = ideDiffSupport!.applyChanges(\n            parsedInput,\n            input.edits,\n          )\n          fileDialogResult.onChange(option, transformedInput)\n        },\n        toolUseContext,\n        filePath: ideDiffConfig.filePath,\n        edits: (ideDiffConfig.edits || []).map(e => ({\n          old_string: e.old_string,\n          new_string: e.new_string,\n          replace_all: e.replace_all || false,\n        })),\n        editMode: ideDiffConfig.editMode || 'single',\n      }\n    : {\n        onChange: () => {},\n        toolUseContext,\n        filePath: '',\n        edits: [],\n        editMode: 'single' as const,\n      }\n\n  const { closeTabInIDE, showingDiffInIDE, ideName } = useDiffInIDE(diffParams)\n\n  const onChange = (option: PermissionOption, feedback?: string) => {\n    closeTabInIDE?.()\n    fileDialogResult.onChange(option, parsedInput, feedback?.trim())\n  }\n\n  if (showingDiffInIDE && ideDiffConfig && path) {\n    return (\n      <ShowInIDEPrompt\n        onChange={(option: PermissionOption, _input, feedback?: string) =>\n          onChange(option, feedback)\n        }\n        options={options}\n        filePath={path}\n        input={parsedInput}\n        ideName={ideName}\n        symlinkTarget={symlinkTarget}\n        rejectFeedback={rejectFeedback}\n        acceptFeedback={acceptFeedback}\n        setFocusedOption={setFocusedOption}\n        onInputModeToggle={handleInputModeToggle}\n        focusedOption={focusedOption}\n        yesInputMode={yesInputMode}\n        noInputMode={noInputMode}\n      />\n    )\n  }\n\n  const isSymlinkOutsideCwd =\n    symlinkTarget != null && relative(getCwd(), symlinkTarget).startsWith('..')\n\n  const symlinkWarning = symlinkTarget ? (\n    <Box paddingX={1} marginBottom={1}>\n      <Text color=\"warning\">\n        {isSymlinkOutsideCwd\n          ? `This will modify ${symlinkTarget} (outside working directory) via a symlink`\n          : `Symlink target: ${symlinkTarget}`}\n      </Text>\n    </Box>\n  ) : null\n\n  return (\n    <>\n      <PermissionDialog\n        title={title}\n        subtitle={subtitle}\n        innerPaddingX={0}\n        workerBadge={workerBadge}\n      >\n        {symlinkWarning}\n        {content}\n        <Box flexDirection=\"column\" paddingX={1}>\n          {typeof question === 'string' ? <Text>{question}</Text> : question}\n          <Select\n            options={options}\n            inlineDescriptions\n            onChange={value => {\n              const selected = options.find(opt => opt.value === value)\n              if (selected) {\n                // For reject option\n                if (selected.option.type === 'reject') {\n                  const trimmedFeedback = rejectFeedback.trim()\n                  onChange(selected.option, trimmedFeedback || undefined)\n                  return\n                }\n                // For accept-once option, pass accept feedback if present\n                if (selected.option.type === 'accept-once') {\n                  const trimmedFeedback = acceptFeedback.trim()\n                  onChange(selected.option, trimmedFeedback || undefined)\n                  return\n                }\n                onChange(selected.option)\n              }\n            }}\n            onCancel={() => onChange({ type: 'reject' })}\n            onFocus={value => setFocusedOption(value)}\n            onInputModeToggle={handleInputModeToggle}\n          />\n        </Box>\n      </PermissionDialog>\n      <Box paddingX={1} marginTop={1}>\n        <Text dimColor>\n          Esc to cancel\n          {((focusedOption === 'yes' && !yesInputMode) ||\n            (focusedOption === 'no' && !noInputMode)) &&\n            ' · Tab to amend'}\n        </Text>\n      </Box>\n    </>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/permissions/FilePermissionDialog/ideDiffConfig.ts

@@ -0,0 +1,42 @@
+import type { ToolInput } from './useFilePermissionDialog.js'
+
+export interface FileEdit {
+  old_string: string
+  new_string: string
+  replace_all?: boolean
+}
+
+export interface IDEDiffConfig {
+  filePath: string
+  edits?: FileEdit[]
+  editMode?: 'single' | 'multiple'
+}
+
+export interface IDEDiffChangeInput {
+  file_path: string
+  edits: FileEdit[]
+}
+
+export interface IDEDiffSupport<TInput extends ToolInput> {
+  getConfig(input: TInput): IDEDiffConfig
+  applyChanges(input: TInput, modifiedEdits: FileEdit[]): TInput
+}
+
+export function createSingleEditDiffConfig(
+  filePath: string,
+  oldString: string,
+  newString: string,
+  replaceAll?: boolean,
+): IDEDiffConfig {
+  return {
+    filePath,
+    edits: [
+      {
+        old_string: oldString,
+        new_string: newString,
+        replace_all: replaceAll,
+      },
+    ],
+    editMode: 'single',
+  }
+}

package/components/permissions/FilePermissionDialog/permissionOptions.tsx

@@ -0,0 +1,177 @@
+import { homedir } from 'os';
+import { basename, join, sep } from 'path';
+import React, { type ReactNode } from 'react';
+import { getOriginalCwd } from '../../../bootstrap/state.js';
+import { Text } from '../../../ink.js';
+import { getShortcutDisplay } from '../../../keybindings/shortcutFormat.js';
+import type { ToolPermissionContext } from '../../../Tool.js';
+import { expandPath, getDirectoryForPath } from '../../../utils/path.js';
+import { normalizeCaseForComparison, pathInAllowedWorkingPath } from '../../../utils/permissions/filesystem.js';
+import type { OptionWithDescription } from '../../CustomSelect/select.js';
+/**
+ * Check if a path is within the project's .claude/ folder.
+ * This is used to determine whether to show the special ".claude folder" permission option.
+ */
+export function isInClaudeFolder(filePath: string): boolean {
+  const absolutePath = expandPath(filePath);
+  const claudeFolderPath = expandPath(`${getOriginalCwd()}/.claude`);
+
+  // Check if the path is within the project's .claude folder
+  const normalizedAbsolutePath = normalizeCaseForComparison(absolutePath);
+  const normalizedClaudeFolderPath = normalizeCaseForComparison(claudeFolderPath);
+
+  // Path must start with the .claude folder path (and be inside it, not just the folder itself)
+  return normalizedAbsolutePath.startsWith(normalizedClaudeFolderPath + sep.toLowerCase()) ||
+  // Also match case where sep is / on posix systems
+  normalizedAbsolutePath.startsWith(normalizedClaudeFolderPath + '/');
+}
+
+/**
+ * Check if a path is within the global ~/.claude/ folder.
+ * This is used to determine whether to show the special ".claude folder" permission option
+ * for files in the user's home directory.
+ */
+export function isInGlobalClaudeFolder(filePath: string): boolean {
+  const absolutePath = expandPath(filePath);
+  const globalClaudeFolderPath = join(homedir(), '.claude');
+  const normalizedAbsolutePath = normalizeCaseForComparison(absolutePath);
+  const normalizedGlobalClaudeFolderPath = normalizeCaseForComparison(globalClaudeFolderPath);
+  return normalizedAbsolutePath.startsWith(normalizedGlobalClaudeFolderPath + sep.toLowerCase()) || normalizedAbsolutePath.startsWith(normalizedGlobalClaudeFolderPath + '/');
+}
+export type PermissionOption = {
+  type: 'accept-once';
+} | {
+  type: 'accept-session';
+  scope?: 'claude-folder' | 'global-claude-folder';
+} | {
+  type: 'reject';
+};
+export type PermissionOptionWithLabel = OptionWithDescription<string> & {
+  option: PermissionOption;
+};
+export type FileOperationType = 'read' | 'write' | 'create';
+export function getFilePermissionOptions({
+  filePath,
+  toolPermissionContext,
+  operationType = 'write',
+  onRejectFeedbackChange,
+  onAcceptFeedbackChange,
+  yesInputMode = false,
+  noInputMode = false
+}: {
+  filePath: string;
+  toolPermissionContext: ToolPermissionContext;
+  operationType?: FileOperationType;
+  onRejectFeedbackChange?: (value: string) => void;
+  onAcceptFeedbackChange?: (value: string) => void;
+  yesInputMode?: boolean;
+  noInputMode?: boolean;
+}): PermissionOptionWithLabel[] {
+  const options: PermissionOptionWithLabel[] = [];
+  const modeCycleShortcut = getShortcutDisplay('chat:cycleMode', 'Chat', 'shift+tab');
+
+  // When in input mode, show input field
+  if (yesInputMode && onAcceptFeedbackChange) {
+    options.push({
+      type: 'input',
+      label: 'Yes',
+      value: 'yes',
+      placeholder: 'and tell Claude what to do next',
+      onChange: onAcceptFeedbackChange,
+      allowEmptySubmitToCancel: true,
+      option: {
+        type: 'accept-once'
+      }
+    });
+  } else {
+    options.push({
+      label: 'Yes',
+      value: 'yes',
+      option: {
+        type: 'accept-once'
+      }
+    });
+  }
+  const inAllowedPath = pathInAllowedWorkingPath(filePath, toolPermissionContext);
+
+  // Check if this is a .claude/ folder path (project or global)
+  const inClaudeFolder = isInClaudeFolder(filePath);
+  const inGlobalClaudeFolder = isInGlobalClaudeFolder(filePath);
+
+  // Option 2: For .claude/ folder, show special option instead of generic session option
+  // Note: Session-level options are always shown since they only affect in-memory state,
+  // not persisted settings. The allowManagedPermissionRulesOnly setting only restricts
+  // persisted permission rules.
+  if ((inClaudeFolder || inGlobalClaudeFolder) && operationType !== 'read') {
+    options.push({
+      label: 'Yes, and allow Claude to edit its own settings for this session',
+      value: 'yes-claude-folder',
+      option: {
+        type: 'accept-session',
+        scope: inGlobalClaudeFolder ? 'global-claude-folder' : 'claude-folder'
+      }
+    });
+  } else {
+    // Option 2: Allow all changes/reads during session
+    let sessionLabel: ReactNode;
+    if (inAllowedPath) {
+      // Inside working directory
+      if (operationType === 'read') {
+        sessionLabel = 'Yes, during this session';
+      } else {
+        sessionLabel = <Text>
+            Yes, allow all edits during this session{' '}
+            <Text bold>({modeCycleShortcut})</Text>
+          </Text>;
+      }
+    } else {
+      // Outside working directory - include directory name
+      const dirPath = getDirectoryForPath(filePath);
+      const dirName = basename(dirPath) || 'this directory';
+      if (operationType === 'read') {
+        sessionLabel = <Text>
+            Yes, allow reading from <Text bold>{dirName}/</Text> during this
+            session
+          </Text>;
+      } else {
+        sessionLabel = <Text>
+            Yes, allow all edits in <Text bold>{dirName}/</Text> during this
+            session <Text bold>({modeCycleShortcut})</Text>
+          </Text>;
+      }
+    }
+    options.push({
+      label: sessionLabel,
+      value: 'yes-session',
+      option: {
+        type: 'accept-session'
+      }
+    });
+  }
+
+  // When in input mode, show input field for reject
+  if (noInputMode && onRejectFeedbackChange) {
+    options.push({
+      type: 'input',
+      label: 'No',
+      value: 'no',
+      placeholder: 'and tell Claude what to do differently',
+      onChange: onRejectFeedbackChange,
+      allowEmptySubmitToCancel: true,
+      option: {
+        type: 'reject'
+      }
+    });
+  } else {
+    // Not in input mode - simple option
+    options.push({
+      label: 'No',
+      value: 'no',
+      option: {
+        type: 'reject'
+      }
+    });
+  }
+  return options;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["homedir","basename","join","sep","React","ReactNode","getOriginalCwd","Text","getShortcutDisplay","ToolPermissionContext","expandPath","getDirectoryForPath","normalizeCaseForComparison","pathInAllowedWorkingPath","OptionWithDescription","isInClaudeFolder","filePath","absolutePath","claudeFolderPath","normalizedAbsolutePath","normalizedClaudeFolderPath","startsWith","toLowerCase","isInGlobalClaudeFolder","globalClaudeFolderPath","normalizedGlobalClaudeFolderPath","PermissionOption","type","scope","PermissionOptionWithLabel","option","FileOperationType","getFilePermissionOptions","toolPermissionContext","operationType","onRejectFeedbackChange","onAcceptFeedbackChange","yesInputMode","noInputMode","value","options","modeCycleShortcut","push","label","placeholder","onChange","allowEmptySubmitToCancel","inAllowedPath","inClaudeFolder","inGlobalClaudeFolder","sessionLabel","dirPath","dirName"],"sources":["permissionOptions.tsx"],"sourcesContent":["import { homedir } from 'os'\nimport { basename, join, sep } from 'path'\nimport React, { type ReactNode } from 'react'\nimport { getOriginalCwd } from '../../../bootstrap/state.js'\nimport { Text } from '../../../ink.js'\nimport { getShortcutDisplay } from '../../../keybindings/shortcutFormat.js'\nimport type { ToolPermissionContext } from '../../../Tool.js'\nimport { expandPath, getDirectoryForPath } from '../../../utils/path.js'\nimport {\n  normalizeCaseForComparison,\n  pathInAllowedWorkingPath,\n} from '../../../utils/permissions/filesystem.js'\nimport type { OptionWithDescription } from '../../CustomSelect/select.js'\n/**\n * Check if a path is within the project's .claude/ folder.\n * This is used to determine whether to show the special \".claude folder\" permission option.\n */\nexport function isInClaudeFolder(filePath: string): boolean {\n  const absolutePath = expandPath(filePath)\n  const claudeFolderPath = expandPath(`${getOriginalCwd()}/.claude`)\n\n  // Check if the path is within the project's .claude folder\n  const normalizedAbsolutePath = normalizeCaseForComparison(absolutePath)\n  const normalizedClaudeFolderPath =\n    normalizeCaseForComparison(claudeFolderPath)\n\n  // Path must start with the .claude folder path (and be inside it, not just the folder itself)\n  return (\n    normalizedAbsolutePath.startsWith(\n      normalizedClaudeFolderPath + sep.toLowerCase(),\n    ) ||\n    // Also match case where sep is / on posix systems\n    normalizedAbsolutePath.startsWith(normalizedClaudeFolderPath + '/')\n  )\n}\n\n/**\n * Check if a path is within the global ~/.claude/ folder.\n * This is used to determine whether to show the special \".claude folder\" permission option\n * for files in the user's home directory.\n */\nexport function isInGlobalClaudeFolder(filePath: string): boolean {\n  const absolutePath = expandPath(filePath)\n  const globalClaudeFolderPath = join(homedir(), '.claude')\n\n  const normalizedAbsolutePath = normalizeCaseForComparison(absolutePath)\n  const normalizedGlobalClaudeFolderPath = normalizeCaseForComparison(\n    globalClaudeFolderPath,\n  )\n\n  return (\n    normalizedAbsolutePath.startsWith(\n      normalizedGlobalClaudeFolderPath + sep.toLowerCase(),\n    ) ||\n    normalizedAbsolutePath.startsWith(normalizedGlobalClaudeFolderPath + '/')\n  )\n}\n\nexport type PermissionOption =\n  | { type: 'accept-once' }\n  | { type: 'accept-session'; scope?: 'claude-folder' | 'global-claude-folder' }\n  | { type: 'reject' }\n\nexport type PermissionOptionWithLabel = OptionWithDescription<string> & {\n  option: PermissionOption\n}\n\nexport type FileOperationType = 'read' | 'write' | 'create'\n\nexport function getFilePermissionOptions({\n  filePath,\n  toolPermissionContext,\n  operationType = 'write',\n  onRejectFeedbackChange,\n  onAcceptFeedbackChange,\n  yesInputMode = false,\n  noInputMode = false,\n}: {\n  filePath: string\n  toolPermissionContext: ToolPermissionContext\n  operationType?: FileOperationType\n  onRejectFeedbackChange?: (value: string) => void\n  onAcceptFeedbackChange?: (value: string) => void\n  yesInputMode?: boolean\n  noInputMode?: boolean\n}): PermissionOptionWithLabel[] {\n  const options: PermissionOptionWithLabel[] = []\n  const modeCycleShortcut = getShortcutDisplay(\n    'chat:cycleMode',\n    'Chat',\n    'shift+tab',\n  )\n\n  // When in input mode, show input field\n  if (yesInputMode && onAcceptFeedbackChange) {\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      option: { type: 'accept-once' },\n    })\n  } else {\n    options.push({\n      label: 'Yes',\n      value: 'yes',\n      option: { type: 'accept-once' },\n    })\n  }\n\n  const inAllowedPath = pathInAllowedWorkingPath(\n    filePath,\n    toolPermissionContext,\n  )\n\n  // Check if this is a .claude/ folder path (project or global)\n  const inClaudeFolder = isInClaudeFolder(filePath)\n  const inGlobalClaudeFolder = isInGlobalClaudeFolder(filePath)\n\n  // Option 2: For .claude/ folder, show special option instead of generic session option\n  // Note: Session-level options are always shown since they only affect in-memory state,\n  // not persisted settings. The allowManagedPermissionRulesOnly setting only restricts\n  // persisted permission rules.\n  if ((inClaudeFolder || inGlobalClaudeFolder) && operationType !== 'read') {\n    options.push({\n      label: 'Yes, and allow Claude to edit its own settings for this session',\n      value: 'yes-claude-folder',\n      option: {\n        type: 'accept-session',\n        scope: inGlobalClaudeFolder ? 'global-claude-folder' : 'claude-folder',\n      },\n    })\n  } else {\n    // Option 2: Allow all changes/reads during session\n    let sessionLabel: ReactNode\n\n    if (inAllowedPath) {\n      // Inside working directory\n      if (operationType === 'read') {\n        sessionLabel = 'Yes, during this session'\n      } else {\n        sessionLabel = (\n          <Text>\n            Yes, allow all edits during this session{' '}\n            <Text bold>({modeCycleShortcut})</Text>\n          </Text>\n        )\n      }\n    } else {\n      // Outside working directory - include directory name\n      const dirPath = getDirectoryForPath(filePath)\n      const dirName = basename(dirPath) || 'this directory'\n\n      if (operationType === 'read') {\n        sessionLabel = (\n          <Text>\n            Yes, allow reading from <Text bold>{dirName}/</Text> during this\n            session\n          </Text>\n        )\n      } else {\n        sessionLabel = (\n          <Text>\n            Yes, allow all edits in <Text bold>{dirName}/</Text> during this\n            session <Text bold>({modeCycleShortcut})</Text>\n          </Text>\n        )\n      }\n    }\n\n    options.push({\n      label: sessionLabel,\n      value: 'yes-session',\n      option: { type: 'accept-session' },\n    })\n  }\n\n  // When in input mode, show input field for reject\n  if (noInputMode && onRejectFeedbackChange) {\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      option: { type: 'reject' },\n    })\n  } else {\n    // Not in input mode - simple option\n    options.push({\n      label: 'No',\n      value: 'no',\n      option: { type: 'reject' },\n    })\n  }\n\n  return options\n}\n"],"mappings":"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","ignoreList":[]}