@xortex/xcode 3.0.0 → 3.0.2

package/components/permissions/shellPermissionHelpers.tsx

@@ -0,0 +1,164 @@
+import { basename, sep } from 'path';
+import React, { type ReactNode } from 'react';
+import { getOriginalCwd } from '../../bootstrap/state.js';
+import { Text } from '../../ink.js';
+import type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js';
+import { permissionRuleExtractPrefix } from '../../utils/permissions/shellRuleMatching.js';
+function commandListDisplay(commands: string[]): ReactNode {
+  switch (commands.length) {
+    case 0:
+      return '';
+    case 1:
+      return <Text bold>{commands[0]}</Text>;
+    case 2:
+      return <Text>
+          <Text bold>{commands[0]}</Text> and <Text bold>{commands[1]}</Text>
+        </Text>;
+    default:
+      return <Text>
+          <Text bold>{commands.slice(0, -1).join(', ')}</Text>, and{' '}
+          <Text bold>{commands.slice(-1)[0]}</Text>
+        </Text>;
+  }
+}
+function commandListDisplayTruncated(commands: string[]): ReactNode {
+  // Check if the plain text representation would be too long
+  const plainText = commands.join(', ');
+  if (plainText.length > 50) {
+    return 'similar';
+  }
+  return commandListDisplay(commands);
+}
+function formatPathList(paths: string[]): ReactNode {
+  if (paths.length === 0) return '';
+
+  // Extract directory names from paths
+  const names = paths.map(p => basename(p) || p);
+  if (names.length === 1) {
+    return <Text>
+        <Text bold>{names[0]}</Text>
+        {sep}
+      </Text>;
+  }
+  if (names.length === 2) {
+    return <Text>
+        <Text bold>{names[0]}</Text>
+        {sep} and <Text bold>{names[1]}</Text>
+        {sep}
+      </Text>;
+  }
+
+  // For 3+, show first two with "and N more"
+  return <Text>
+      <Text bold>{names[0]}</Text>
+      {sep}, <Text bold>{names[1]}</Text>
+      {sep} and {paths.length - 2} more
+    </Text>;
+}
+
+/**
+ * Generate the label for the "Yes, and apply suggestions" option in shell
+ * permission dialogs (Bash, PowerShell). Parametrized by the shell tool name
+ * and an optional command transform (e.g., Bash strips output redirections so
+ * filenames don't show as commands).
+ */
+export function generateShellSuggestionsLabel(suggestions: PermissionUpdate[], shellToolName: string, commandTransform?: (command: string) => string): ReactNode | null {
+  // Collect all rules for display
+  const allRules = suggestions.filter(s => s.type === 'addRules').flatMap(s => s.rules || []);
+
+  // Separate Read rules from shell rules
+  const readRules = allRules.filter(r => r.toolName === 'Read');
+  const shellRules = allRules.filter(r => r.toolName === shellToolName);
+
+  // Get directory info
+  const directories = suggestions.filter(s => s.type === 'addDirectories').flatMap(s => s.directories || []);
+
+  // Extract paths from Read rules (keep separate from directories)
+  const readPaths = readRules.map(r => r.ruleContent?.replace('/**', '') || '').filter(p => p);
+
+  // Extract shell command prefixes, optionally transforming for display
+  const shellCommands = [...new Set(shellRules.flatMap(rule => {
+    if (!rule.ruleContent) return [];
+    const command = permissionRuleExtractPrefix(rule.ruleContent) ?? rule.ruleContent;
+    return commandTransform ? commandTransform(command) : command;
+  }))];
+
+  // Check what we have
+  const hasDirectories = directories.length > 0;
+  const hasReadPaths = readPaths.length > 0;
+  const hasCommands = shellCommands.length > 0;
+
+  // Handle single type cases
+  if (hasReadPaths && !hasDirectories && !hasCommands) {
+    // Only Read rules - use "reading from" language
+    if (readPaths.length === 1) {
+      const firstPath = readPaths[0]!;
+      const dirName = basename(firstPath) || firstPath;
+      return <Text>
+          Yes, allow reading from <Text bold>{dirName}</Text>
+          {sep} from this project
+        </Text>;
+    }
+
+    // Multiple read paths
+    return <Text>
+        Yes, allow reading from {formatPathList(readPaths)} from this project
+      </Text>;
+  }
+  if (hasDirectories && !hasReadPaths && !hasCommands) {
+    // Only directory permissions - use "access to" language
+    if (directories.length === 1) {
+      const firstDir = directories[0]!;
+      const dirName = basename(firstDir) || firstDir;
+      return <Text>
+          Yes, and always allow access to <Text bold>{dirName}</Text>
+          {sep} from this project
+        </Text>;
+    }
+
+    // Multiple directories
+    return <Text>
+        Yes, and always allow access to {formatPathList(directories)} from this
+        project
+      </Text>;
+  }
+  if (hasCommands && !hasDirectories && !hasReadPaths) {
+    // Only shell command permissions
+    return <Text>
+        {"Yes, and don't ask again for "}
+        {commandListDisplayTruncated(shellCommands)} commands in{' '}
+        <Text bold>{getOriginalCwd()}</Text>
+      </Text>;
+  }
+
+  // Handle mixed cases
+  if ((hasDirectories || hasReadPaths) && !hasCommands) {
+    // Combine directories and read paths since they're both path access
+    const allPaths = [...directories, ...readPaths];
+    if (hasDirectories && hasReadPaths) {
+      // Mixed - use generic "access to"
+      return <Text>
+          Yes, and always allow access to {formatPathList(allPaths)} from this
+          project
+        </Text>;
+    }
+  }
+  if ((hasDirectories || hasReadPaths) && hasCommands) {
+    // Build descriptive message for both types
+    const allPaths = [...directories, ...readPaths];
+
+    // Keep it concise but informative
+    if (allPaths.length === 1 && shellCommands.length === 1) {
+      return <Text>
+          Yes, and allow access to {formatPathList(allPaths)} and{' '}
+          {commandListDisplayTruncated(shellCommands)} commands
+        </Text>;
+    }
+    return <Text>
+        Yes, and allow {formatPathList(allPaths)} access and{' '}
+        {commandListDisplayTruncated(shellCommands)} commands
+      </Text>;
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["basename","sep","React","ReactNode","getOriginalCwd","Text","PermissionUpdate","permissionRuleExtractPrefix","commandListDisplay","commands","length","slice","join","commandListDisplayTruncated","plainText","formatPathList","paths","names","map","p","generateShellSuggestionsLabel","suggestions","shellToolName","commandTransform","command","allRules","filter","s","type","flatMap","rules","readRules","r","toolName","shellRules","directories","readPaths","ruleContent","replace","shellCommands","Set","rule","hasDirectories","hasReadPaths","hasCommands","firstPath","dirName","firstDir","allPaths"],"sources":["shellPermissionHelpers.tsx"],"sourcesContent":["import { basename, sep } from 'path'\nimport React, { type ReactNode } from 'react'\nimport { getOriginalCwd } from '../../bootstrap/state.js'\nimport { Text } from '../../ink.js'\nimport type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js'\nimport { permissionRuleExtractPrefix } from '../../utils/permissions/shellRuleMatching.js'\n\nfunction commandListDisplay(commands: string[]): ReactNode {\n  switch (commands.length) {\n    case 0:\n      return ''\n    case 1:\n      return <Text bold>{commands[0]}</Text>\n    case 2:\n      return (\n        <Text>\n          <Text bold>{commands[0]}</Text> and <Text bold>{commands[1]}</Text>\n        </Text>\n      )\n    default:\n      return (\n        <Text>\n          <Text bold>{commands.slice(0, -1).join(', ')}</Text>, and{' '}\n          <Text bold>{commands.slice(-1)[0]}</Text>\n        </Text>\n      )\n  }\n}\n\nfunction commandListDisplayTruncated(commands: string[]): ReactNode {\n  // Check if the plain text representation would be too long\n  const plainText = commands.join(', ')\n  if (plainText.length > 50) {\n    return 'similar'\n  }\n  return commandListDisplay(commands)\n}\n\nfunction formatPathList(paths: string[]): ReactNode {\n  if (paths.length === 0) return ''\n\n  // Extract directory names from paths\n  const names = paths.map(p => basename(p) || p)\n\n  if (names.length === 1) {\n    return (\n      <Text>\n        <Text bold>{names[0]}</Text>\n        {sep}\n      </Text>\n    )\n  }\n  if (names.length === 2) {\n    return (\n      <Text>\n        <Text bold>{names[0]}</Text>\n        {sep} and <Text bold>{names[1]}</Text>\n        {sep}\n      </Text>\n    )\n  }\n\n  // For 3+, show first two with \"and N more\"\n  return (\n    <Text>\n      <Text bold>{names[0]}</Text>\n      {sep}, <Text bold>{names[1]}</Text>\n      {sep} and {paths.length - 2} more\n    </Text>\n  )\n}\n\n/**\n * Generate the label for the \"Yes, and apply suggestions\" option in shell\n * permission dialogs (Bash, PowerShell). Parametrized by the shell tool name\n * and an optional command transform (e.g., Bash strips output redirections so\n * filenames don't show as commands).\n */\nexport function generateShellSuggestionsLabel(\n  suggestions: PermissionUpdate[],\n  shellToolName: string,\n  commandTransform?: (command: string) => string,\n): ReactNode | null {\n  // Collect all rules for display\n  const allRules = suggestions\n    .filter(s => s.type === 'addRules')\n    .flatMap(s => s.rules || [])\n\n  // Separate Read rules from shell rules\n  const readRules = allRules.filter(r => r.toolName === 'Read')\n  const shellRules = allRules.filter(r => r.toolName === shellToolName)\n\n  // Get directory info\n  const directories = suggestions\n    .filter(s => s.type === 'addDirectories')\n    .flatMap(s => s.directories || [])\n\n  // Extract paths from Read rules (keep separate from directories)\n  const readPaths = readRules\n    .map(r => r.ruleContent?.replace('/**', '') || '')\n    .filter(p => p)\n\n  // Extract shell command prefixes, optionally transforming for display\n  const shellCommands = [\n    ...new Set(\n      shellRules.flatMap(rule => {\n        if (!rule.ruleContent) return []\n        const command =\n          permissionRuleExtractPrefix(rule.ruleContent) ?? rule.ruleContent\n        return commandTransform ? commandTransform(command) : command\n      }),\n    ),\n  ]\n\n  // Check what we have\n  const hasDirectories = directories.length > 0\n  const hasReadPaths = readPaths.length > 0\n  const hasCommands = shellCommands.length > 0\n\n  // Handle single type cases\n  if (hasReadPaths && !hasDirectories && !hasCommands) {\n    // Only Read rules - use \"reading from\" language\n    if (readPaths.length === 1) {\n      const firstPath = readPaths[0]!\n      const dirName = basename(firstPath) || firstPath\n      return (\n        <Text>\n          Yes, allow reading from <Text bold>{dirName}</Text>\n          {sep} from this project\n        </Text>\n      )\n    }\n\n    // Multiple read paths\n    return (\n      <Text>\n        Yes, allow reading from {formatPathList(readPaths)} from this project\n      </Text>\n    )\n  }\n\n  if (hasDirectories && !hasReadPaths && !hasCommands) {\n    // Only directory permissions - use \"access to\" language\n    if (directories.length === 1) {\n      const firstDir = directories[0]!\n      const dirName = basename(firstDir) || firstDir\n      return (\n        <Text>\n          Yes, and always allow access to <Text bold>{dirName}</Text>\n          {sep} from this project\n        </Text>\n      )\n    }\n\n    // Multiple directories\n    return (\n      <Text>\n        Yes, and always allow access to {formatPathList(directories)} from this\n        project\n      </Text>\n    )\n  }\n\n  if (hasCommands && !hasDirectories && !hasReadPaths) {\n    // Only shell command permissions\n    return (\n      <Text>\n        {\"Yes, and don't ask again for \"}\n        {commandListDisplayTruncated(shellCommands)} commands in{' '}\n        <Text bold>{getOriginalCwd()}</Text>\n      </Text>\n    )\n  }\n\n  // Handle mixed cases\n  if ((hasDirectories || hasReadPaths) && !hasCommands) {\n    // Combine directories and read paths since they're both path access\n    const allPaths = [...directories, ...readPaths]\n    if (hasDirectories && hasReadPaths) {\n      // Mixed - use generic \"access to\"\n      return (\n        <Text>\n          Yes, and always allow access to {formatPathList(allPaths)} from this\n          project\n        </Text>\n      )\n    }\n  }\n\n  if ((hasDirectories || hasReadPaths) && hasCommands) {\n    // Build descriptive message for both types\n    const allPaths = [...directories, ...readPaths]\n\n    // Keep it concise but informative\n    if (allPaths.length === 1 && shellCommands.length === 1) {\n      return (\n        <Text>\n          Yes, and allow access to {formatPathList(allPaths)} and{' '}\n          {commandListDisplayTruncated(shellCommands)} commands\n        </Text>\n      )\n    }\n\n    return (\n      <Text>\n        Yes, and allow {formatPathList(allPaths)} access and{' '}\n        {commandListDisplayTruncated(shellCommands)} commands\n      </Text>\n    )\n  }\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

package/components/permissions/useShellPermissionFeedback.ts

@@ -0,0 +1,148 @@
+import { useState } from 'react'
+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 { useSetAppState } from '../../state/AppState.js'
+import type { ToolUseConfirm } from './PermissionRequest.js'
+import { logUnaryPermissionEvent } from './utils.js'
+
+/**
+ * Shared feedback-mode state + handlers for shell permission dialogs (Bash,
+ * PowerShell). Encapsulates the yes/no input-mode toggle, feedback text state,
+ * focus tracking, and reject handling.
+ */
+export function useShellPermissionFeedback({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  explainerVisible,
+}: {
+  toolUseConfirm: ToolUseConfirm
+  onDone: () => void
+  onReject: () => void
+  explainerVisible: boolean
+}): {
+  yesInputMode: boolean
+  noInputMode: boolean
+  yesFeedbackModeEntered: boolean
+  noFeedbackModeEntered: boolean
+  acceptFeedback: string
+  rejectFeedback: string
+  setAcceptFeedback: (v: string) => void
+  setRejectFeedback: (v: string) => void
+  focusedOption: string
+  handleInputModeToggle: (option: string) => void
+  handleReject: (feedback?: string) => void
+  handleFocus: (value: string) => void
+} {
+  const setAppState = useSetAppState()
+  const [rejectFeedback, setRejectFeedback] = useState('')
+  const [acceptFeedback, setAcceptFeedback] = useState('')
+  const [yesInputMode, setYesInputMode] = useState(false)
+  const [noInputMode, setNoInputMode] = useState(false)
+  const [focusedOption, setFocusedOption] = useState('yes')
+  // Track whether user ever entered feedback mode (persists after collapse)
+  const [yesFeedbackModeEntered, setYesFeedbackModeEntered] = useState(false)
+  const [noFeedbackModeEntered, setNoFeedbackModeEntered] = useState(false)
+
+  // Handle Tab key toggling input mode for Yes/No options
+  function handleInputModeToggle(option: string) {
+    // Notify that user is interacting with the dialog
+    toolUseConfirm.onUserInteraction()
+    const analyticsProps = {
+      toolName: sanitizeToolNameForAnalytics(
+        toolUseConfirm.tool.name,
+      ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      isMcp: toolUseConfirm.tool.isMcp ?? false,
+    }
+
+    if (option === 'yes') {
+      if (yesInputMode) {
+        setYesInputMode(false)
+        logEvent('tengu_accept_feedback_mode_collapsed', analyticsProps)
+      } else {
+        setYesInputMode(true)
+        setYesFeedbackModeEntered(true)
+        logEvent('tengu_accept_feedback_mode_entered', analyticsProps)
+      }
+    } else if (option === 'no') {
+      if (noInputMode) {
+        setNoInputMode(false)
+        logEvent('tengu_reject_feedback_mode_collapsed', analyticsProps)
+      } else {
+        setNoInputMode(true)
+        setNoFeedbackModeEntered(true)
+        logEvent('tengu_reject_feedback_mode_entered', analyticsProps)
+      }
+    }
+  }
+
+  function handleReject(feedback?: string) {
+    const trimmedFeedback = feedback?.trim()
+    const hasFeedback = !!trimmedFeedback
+
+    // Log escape if no feedback was provided (user pressed ESC)
+    if (!hasFeedback) {
+      logEvent('tengu_permission_request_escape', {
+        explainer_visible: explainerVisible,
+      })
+      // Increment escape count for attribution tracking
+      setAppState(prev => ({
+        ...prev,
+        attribution: {
+          ...prev.attribution,
+          escapeCount: prev.attribution.escapeCount + 1,
+        },
+      }))
+    }
+
+    logUnaryPermissionEvent(
+      'tool_use_single',
+      toolUseConfirm,
+      'reject',
+      hasFeedback,
+    )
+
+    if (trimmedFeedback) {
+      toolUseConfirm.onReject(trimmedFeedback)
+    } else {
+      toolUseConfirm.onReject()
+    }
+
+    onReject()
+    onDone()
+  }
+
+  function handleFocus(value: string) {
+    // Notify that user is interacting with the dialog (only if focus changed)
+    // This prevents triggering on the initial mount/render
+    if (value !== focusedOption) {
+      toolUseConfirm.onUserInteraction()
+    }
+    // Reset input mode when navigating away, but only if no text typed
+    if (value !== 'yes' && yesInputMode && !acceptFeedback.trim()) {
+      setYesInputMode(false)
+    }
+    if (value !== 'no' && noInputMode && !rejectFeedback.trim()) {
+      setNoInputMode(false)
+    }
+    setFocusedOption(value)
+  }
+
+  return {
+    yesInputMode,
+    noInputMode,
+    yesFeedbackModeEntered,
+    noFeedbackModeEntered,
+    acceptFeedback,
+    rejectFeedback,
+    setAcceptFeedback,
+    setRejectFeedback,
+    focusedOption,
+    handleInputModeToggle,
+    handleReject,
+    handleFocus,
+  }
+}

package/components/permissions/utils.ts

@@ -0,0 +1,25 @@
+import { getHostPlatformForAnalytics } from '../../utils/env.js'
+import { type CompletionType, logUnaryEvent } from '../../utils/unaryLogging.js'
+import type { ToolUseConfirm } from './PermissionRequest.js'
+
+export function logUnaryPermissionEvent(
+  completion_type: CompletionType,
+  {
+    assistantMessage: {
+      message: { id: message_id },
+    },
+  }: ToolUseConfirm,
+  event: 'accept' | 'reject',
+  hasFeedback?: boolean,
+): void {
+  void logUnaryEvent({
+    completion_type,
+    event,
+    metadata: {
+      language_name: 'none',
+      message_id,
+      platform: getHostPlatformForAnalytics(),
+      hasFeedback: hasFeedback ?? false,
+    },
+  })
+}

package/components/sandbox/SandboxConfigTab.tsx

@@ -0,0 +1,45 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import { SandboxManager, shouldAllowManagedSandboxDomainsOnly } from '../../utils/sandbox/sandbox-adapter.js';
+export function SandboxConfigTab() {
+  const $ = _c(3);
+  const isEnabled = SandboxManager.isSandboxingEnabled();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const depCheck = SandboxManager.checkDependencies();
+    t0 = depCheck.warnings.length > 0 ? <Box marginTop={1} flexDirection="column">{depCheck.warnings.map(_temp)}</Box> : null;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const warningsNote = t0;
+  if (!isEnabled) {
+    let t1;
+    if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <Box flexDirection="column" paddingY={1}><Text color="subtle">Sandbox is not enabled</Text>{warningsNote}</Box>;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    const fsReadConfig = SandboxManager.getFsReadConfig();
+    const fsWriteConfig = SandboxManager.getFsWriteConfig();
+    const networkConfig = SandboxManager.getNetworkRestrictionConfig();
+    const allowUnixSockets = SandboxManager.getAllowUnixSockets();
+    const excludedCommands = SandboxManager.getExcludedCommands();
+    const globPatternWarnings = SandboxManager.getLinuxGlobPatternWarnings();
+    t1 = <Box flexDirection="column" paddingY={1}><Box flexDirection="column"><Text bold={true} color="permission">Excluded Commands:</Text><Text dimColor={true}>{excludedCommands.length > 0 ? excludedCommands.join(", ") : "None"}</Text></Box>{fsReadConfig.denyOnly.length > 0 && <Box marginTop={1} flexDirection="column"><Text bold={true} color="permission">Filesystem Read Restrictions:</Text><Text dimColor={true}>Denied: {fsReadConfig.denyOnly.join(", ")}</Text>{fsReadConfig.allowWithinDeny && fsReadConfig.allowWithinDeny.length > 0 && <Text dimColor={true}>Allowed within denied: {fsReadConfig.allowWithinDeny.join(", ")}</Text>}</Box>}{fsWriteConfig.allowOnly.length > 0 && <Box marginTop={1} flexDirection="column"><Text bold={true} color="permission">Filesystem Write Restrictions:</Text><Text dimColor={true}>Allowed: {fsWriteConfig.allowOnly.join(", ")}</Text>{fsWriteConfig.denyWithinAllow.length > 0 && <Text dimColor={true}>Denied within allowed: {fsWriteConfig.denyWithinAllow.join(", ")}</Text>}</Box>}{(networkConfig.allowedHosts && networkConfig.allowedHosts.length > 0 || networkConfig.deniedHosts && networkConfig.deniedHosts.length > 0) && <Box marginTop={1} flexDirection="column"><Text bold={true} color="permission">Network Restrictions{shouldAllowManagedSandboxDomainsOnly() ? " (Managed)" : ""}:</Text>{networkConfig.allowedHosts && networkConfig.allowedHosts.length > 0 && <Text dimColor={true}>Allowed: {networkConfig.allowedHosts.join(", ")}</Text>}{networkConfig.deniedHosts && networkConfig.deniedHosts.length > 0 && <Text dimColor={true}>Denied: {networkConfig.deniedHosts.join(", ")}</Text>}</Box>}{allowUnixSockets && allowUnixSockets.length > 0 && <Box marginTop={1} flexDirection="column"><Text bold={true} color="permission">Allowed Unix Sockets:</Text><Text dimColor={true}>{allowUnixSockets.join(", ")}</Text></Box>}{globPatternWarnings.length > 0 && <Box marginTop={1} flexDirection="column"><Text bold={true} color="warning">⚠ Warning: Glob patterns not fully supported on Linux</Text><Text dimColor={true}>The following patterns will be ignored:{" "}{globPatternWarnings.slice(0, 3).join(", ")}{globPatternWarnings.length > 3 && ` (${globPatternWarnings.length - 3} more)`}</Text></Box>}{warningsNote}</Box>;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+function _temp(w, i) {
+  return <Text key={i} dimColor={true}>{w}</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Box","Text","SandboxManager","shouldAllowManagedSandboxDomainsOnly","SandboxConfigTab","$","_c","isEnabled","isSandboxingEnabled","t0","Symbol","for","depCheck","checkDependencies","warnings","length","map","_temp","warningsNote","t1","fsReadConfig","getFsReadConfig","fsWriteConfig","getFsWriteConfig","networkConfig","getNetworkRestrictionConfig","allowUnixSockets","getAllowUnixSockets","excludedCommands","getExcludedCommands","globPatternWarnings","getLinuxGlobPatternWarnings","join","denyOnly","allowWithinDeny","allowOnly","denyWithinAllow","allowedHosts","deniedHosts","slice","w","i"],"sources":["SandboxConfigTab.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Box, Text } from '../../ink.js'\nimport {\n  SandboxManager,\n  shouldAllowManagedSandboxDomainsOnly,\n} from '../../utils/sandbox/sandbox-adapter.js'\n\nexport function SandboxConfigTab(): React.ReactNode {\n  const isEnabled = SandboxManager.isSandboxingEnabled()\n\n  // Show warnings (e.g., seccomp not available on Linux)\n  const depCheck = SandboxManager.checkDependencies()\n  const warningsNote =\n    depCheck.warnings.length > 0 ? (\n      <Box marginTop={1} flexDirection=\"column\">\n        {depCheck.warnings.map((w, i) => (\n          <Text key={i} dimColor>\n            {w}\n          </Text>\n        ))}\n      </Box>\n    ) : null\n\n  if (!isEnabled) {\n    return (\n      <Box flexDirection=\"column\" paddingY={1}>\n        <Text color=\"subtle\">Sandbox is not enabled</Text>\n        {warningsNote}\n      </Box>\n    )\n  }\n\n  const fsReadConfig = SandboxManager.getFsReadConfig()\n  const fsWriteConfig = SandboxManager.getFsWriteConfig()\n  const networkConfig = SandboxManager.getNetworkRestrictionConfig()\n  const allowUnixSockets = SandboxManager.getAllowUnixSockets()\n  const excludedCommands = SandboxManager.getExcludedCommands()\n  const globPatternWarnings = SandboxManager.getLinuxGlobPatternWarnings()\n\n  return (\n    <Box flexDirection=\"column\" paddingY={1}>\n      {/* Excluded Commands */}\n      <Box flexDirection=\"column\">\n        <Text bold color=\"permission\">\n          Excluded Commands:\n        </Text>\n        <Text dimColor>\n          {excludedCommands.length > 0 ? excludedCommands.join(', ') : 'None'}\n        </Text>\n      </Box>\n\n      {/* Filesystem Read Restrictions */}\n      {fsReadConfig.denyOnly.length > 0 && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text bold color=\"permission\">\n            Filesystem Read Restrictions:\n          </Text>\n          <Text dimColor>Denied: {fsReadConfig.denyOnly.join(', ')}</Text>\n          {fsReadConfig.allowWithinDeny &&\n            fsReadConfig.allowWithinDeny.length > 0 && (\n              <Text dimColor>\n                Allowed within denied: {fsReadConfig.allowWithinDeny.join(', ')}\n              </Text>\n            )}\n        </Box>\n      )}\n\n      {/* Filesystem Write Restrictions */}\n      {fsWriteConfig.allowOnly.length > 0 && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text bold color=\"permission\">\n            Filesystem Write Restrictions:\n          </Text>\n          <Text dimColor>Allowed: {fsWriteConfig.allowOnly.join(', ')}</Text>\n          {fsWriteConfig.denyWithinAllow.length > 0 && (\n            <Text dimColor>\n              Denied within allowed: {fsWriteConfig.denyWithinAllow.join(', ')}\n            </Text>\n          )}\n        </Box>\n      )}\n\n      {/* Network Restrictions */}\n      {((networkConfig.allowedHosts && networkConfig.allowedHosts.length > 0) ||\n        (networkConfig.deniedHosts &&\n          networkConfig.deniedHosts.length > 0)) && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text bold color=\"permission\">\n            Network Restrictions\n            {shouldAllowManagedSandboxDomainsOnly() ? ' (Managed)' : ''}:\n          </Text>\n          {networkConfig.allowedHosts &&\n            networkConfig.allowedHosts.length > 0 && (\n              <Text dimColor>\n                Allowed: {networkConfig.allowedHosts.join(', ')}\n              </Text>\n            )}\n          {networkConfig.deniedHosts &&\n            networkConfig.deniedHosts.length > 0 && (\n              <Text dimColor>\n                Denied: {networkConfig.deniedHosts.join(', ')}\n              </Text>\n            )}\n        </Box>\n      )}\n\n      {/* Unix Sockets */}\n      {allowUnixSockets && allowUnixSockets.length > 0 && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text bold color=\"permission\">\n            Allowed Unix Sockets:\n          </Text>\n          <Text dimColor>{allowUnixSockets.join(', ')}</Text>\n        </Box>\n      )}\n\n      {/* Linux Glob Pattern Warning */}\n      {globPatternWarnings.length > 0 && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text bold color=\"warning\">\n            ⚠ Warning: Glob patterns not fully supported on Linux\n          </Text>\n          <Text dimColor>\n            The following patterns will be ignored:{' '}\n            {globPatternWarnings.slice(0, 3).join(', ')}\n            {globPatternWarnings.length > 3 &&\n              ` (${globPatternWarnings.length - 3} more)`}\n          </Text>\n        </Box>\n      )}\n\n      {warningsNote}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/sandbox/SandboxDependenciesTab.tsx

@@ -0,0 +1,120 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, Text } from '../../ink.js';
+import { getPlatform } from '../../utils/platform.js';
+import type { SandboxDependencyCheck } from '../../utils/sandbox/sandbox-adapter.js';
+type Props = {
+  depCheck: SandboxDependencyCheck;
+};
+export function SandboxDependenciesTab(t0) {
+  const $ = _c(24);
+  const {
+    depCheck
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = getPlatform();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const platform = t1;
+  const isMac = platform === "macos";
+  let t2;
+  if ($[1] !== depCheck.errors) {
+    t2 = depCheck.errors.some(_temp);
+    $[1] = depCheck.errors;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const rgMissing = t2;
+  let t3;
+  if ($[3] !== depCheck.errors) {
+    t3 = depCheck.errors.some(_temp2);
+    $[3] = depCheck.errors;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  const bwrapMissing = t3;
+  let t4;
+  if ($[5] !== depCheck.errors) {
+    t4 = depCheck.errors.some(_temp3);
+    $[5] = depCheck.errors;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  const socatMissing = t4;
+  const seccompMissing = depCheck.warnings.length > 0;
+  let t5;
+  if ($[7] !== bwrapMissing || $[8] !== depCheck.errors || $[9] !== rgMissing || $[10] !== seccompMissing || $[11] !== socatMissing) {
+    const otherErrors = depCheck.errors.filter(_temp4);
+    const rgInstallHint = isMac ? "brew install ripgrep" : "apt install ripgrep";
+    let t6;
+    if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+      t6 = isMac && <Box flexDirection="column"><Text>seatbelt: <Text color="success">built-in (macOS)</Text></Text></Box>;
+      $[13] = t6;
+    } else {
+      t6 = $[13];
+    }
+    let t7;
+    let t8;
+    if ($[14] !== rgMissing) {
+      t7 = <Text>ripgrep (rg):{" "}{rgMissing ? <Text color="error">not found</Text> : <Text color="success">found</Text>}</Text>;
+      t8 = rgMissing && <Text dimColor={true}>{"  "}· {rgInstallHint}</Text>;
+      $[14] = rgMissing;
+      $[15] = t7;
+      $[16] = t8;
+    } else {
+      t7 = $[15];
+      t8 = $[16];
+    }
+    let t9;
+    if ($[17] !== t7 || $[18] !== t8) {
+      t9 = <Box flexDirection="column">{t7}{t8}</Box>;
+      $[17] = t7;
+      $[18] = t8;
+      $[19] = t9;
+    } else {
+      t9 = $[19];
+    }
+    let t10;
+    if ($[20] !== bwrapMissing || $[21] !== seccompMissing || $[22] !== socatMissing) {
+      t10 = !isMac && <><Box flexDirection="column"><Text>bubblewrap (bwrap):{" "}{bwrapMissing ? <Text color="error">not installed</Text> : <Text color="success">installed</Text>}</Text>{bwrapMissing && <Text dimColor={true}>{"  "}· apt install bubblewrap</Text>}</Box><Box flexDirection="column"><Text>socat:{" "}{socatMissing ? <Text color="error">not installed</Text> : <Text color="success">installed</Text>}</Text>{socatMissing && <Text dimColor={true}>{"  "}· apt install socat</Text>}</Box><Box flexDirection="column"><Text>seccomp filter:{" "}{seccompMissing ? <Text color="warning">not installed</Text> : <Text color="success">installed</Text>}{seccompMissing && <Text dimColor={true}> (required to block unix domain sockets)</Text>}</Text>{seccompMissing && <Box flexDirection="column"><Text dimColor={true}>{"  "}· npm install -g @anthropic-ai/sandbox-runtime</Text><Text dimColor={true}>{"  "}· or copy vendor/seccomp/* from sandbox-runtime and set</Text><Text dimColor={true}>{"    "}sandbox.seccomp.bpfPath and applyPath in settings.json</Text></Box>}</Box></>;
+      $[20] = bwrapMissing;
+      $[21] = seccompMissing;
+      $[22] = socatMissing;
+      $[23] = t10;
+    } else {
+      t10 = $[23];
+    }
+    t5 = <Box flexDirection="column" paddingY={1} gap={1}>{t6}{t9}{t10}{otherErrors.map(_temp5)}</Box>;
+    $[7] = bwrapMissing;
+    $[8] = depCheck.errors;
+    $[9] = rgMissing;
+    $[10] = seccompMissing;
+    $[11] = socatMissing;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  return t5;
+}
+function _temp5(err) {
+  return <Text key={err} color="error">{err}</Text>;
+}
+function _temp4(e_2) {
+  return !e_2.includes("ripgrep") && !e_2.includes("bwrap") && !e_2.includes("socat");
+}
+function _temp3(e_1) {
+  return e_1.includes("socat");
+}
+function _temp2(e_0) {
+  return e_0.includes("bwrap");
+}
+function _temp(e) {
+  return e.includes("ripgrep");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Box","Text","getPlatform","SandboxDependencyCheck","Props","depCheck","SandboxDependenciesTab","t0","$","_c","t1","Symbol","for","platform","isMac","t2","errors","some","_temp","rgMissing","t3","_temp2","bwrapMissing","t4","_temp3","socatMissing","seccompMissing","warnings","length","t5","otherErrors","filter","_temp4","rgInstallHint","t6","t7","t8","t9","t10","map","_temp5","err","e_2","e","includes","e_1","e_0"],"sources":["SandboxDependenciesTab.tsx"],"sourcesContent":["import React from 'react'\nimport { Box, Text } from '../../ink.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport type { SandboxDependencyCheck } from '../../utils/sandbox/sandbox-adapter.js'\n\ntype Props = {\n  depCheck: SandboxDependencyCheck\n}\n\nexport function SandboxDependenciesTab({ depCheck }: Props): React.ReactNode {\n  const platform = getPlatform()\n  const isMac = platform === 'macos'\n\n  // ripgrep is required on all platforms (used to scan for dangerous dirs).\n  // On macOS, seatbelt is built into the OS — ripgrep is the only runtime dep.\n  // On Linux/WSL, bwrap + socat are required, seccomp is optional.\n  //\n  // #31804: previously this tab unconditionally rendered Linux deps (bwrap,\n  // socat, seccomp). When ripgrep was missing on macOS, users saw confusing\n  // Linux install instructions and no mention of the actual problem.\n  const rgMissing = depCheck.errors.some(e => e.includes('ripgrep'))\n  const bwrapMissing = depCheck.errors.some(e => e.includes('bwrap'))\n  const socatMissing = depCheck.errors.some(e => e.includes('socat'))\n  const seccompMissing = depCheck.warnings.length > 0\n\n  // Any errors we don't have a dedicated row for — render verbatim so they\n  // aren't silently swallowed (e.g. \"Unsupported platform\" or future deps).\n  const otherErrors = depCheck.errors.filter(\n    e => !e.includes('ripgrep') && !e.includes('bwrap') && !e.includes('socat'),\n  )\n\n  const rgInstallHint = isMac ? 'brew install ripgrep' : 'apt install ripgrep'\n\n  return (\n    <Box flexDirection=\"column\" paddingY={1} gap={1}>\n      {isMac && (\n        <Box flexDirection=\"column\">\n          <Text>\n            seatbelt: <Text color=\"success\">built-in (macOS)</Text>\n          </Text>\n        </Box>\n      )}\n\n      <Box flexDirection=\"column\">\n        <Text>\n          ripgrep (rg):{' '}\n          {rgMissing ? (\n            <Text color=\"error\">not found</Text>\n          ) : (\n            <Text color=\"success\">found</Text>\n          )}\n        </Text>\n        {rgMissing && (\n          <Text dimColor>\n            {'  '}· {rgInstallHint}\n          </Text>\n        )}\n      </Box>\n\n      {!isMac && (\n        <>\n          <Box flexDirection=\"column\">\n            <Text>\n              bubblewrap (bwrap):{' '}\n              {bwrapMissing ? (\n                <Text color=\"error\">not installed</Text>\n              ) : (\n                <Text color=\"success\">installed</Text>\n              )}\n            </Text>\n            {bwrapMissing && (\n              <Text dimColor>{'  '}· apt install bubblewrap</Text>\n            )}\n          </Box>\n\n          <Box flexDirection=\"column\">\n            <Text>\n              socat:{' '}\n              {socatMissing ? (\n                <Text color=\"error\">not installed</Text>\n              ) : (\n                <Text color=\"success\">installed</Text>\n              )}\n            </Text>\n            {socatMissing && <Text dimColor>{'  '}· apt install socat</Text>}\n          </Box>\n\n          <Box flexDirection=\"column\">\n            <Text>\n              seccomp filter:{' '}\n              {seccompMissing ? (\n                <Text color=\"warning\">not installed</Text>\n              ) : (\n                <Text color=\"success\">installed</Text>\n              )}\n              {seccompMissing && (\n                <Text dimColor> (required to block unix domain sockets)</Text>\n              )}\n            </Text>\n            {seccompMissing && (\n              <Box flexDirection=\"column\">\n                <Text dimColor>\n                  {'  '}· npm install -g @anthropic-ai/sandbox-runtime\n                </Text>\n                <Text dimColor>\n                  {'  '}· or copy vendor/seccomp/* from sandbox-runtime and set\n                </Text>\n                <Text dimColor>\n                  {'    '}sandbox.seccomp.bpfPath and applyPath in settings.json\n                </Text>\n              </Box>\n            )}\n          </Box>\n        </>\n      )}\n\n      {otherErrors.map(err => (\n        <Text key={err} color=\"error\">\n          {err}\n        </Text>\n      ))}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/sandbox/SandboxDoctorSection.tsx

@@ -0,0 +1,46 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, Text } from '../../ink.js';
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js';
+export function SandboxDoctorSection() {
+  const $ = _c(2);
+  if (!SandboxManager.isSupportedPlatform()) {
+    return null;
+  }
+  if (!SandboxManager.isSandboxEnabledInSettings()) {
+    return null;
+  }
+  let t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const depCheck = SandboxManager.checkDependencies();
+      const hasErrors = depCheck.errors.length > 0;
+      const hasWarnings = depCheck.warnings.length > 0;
+      if (!hasErrors && !hasWarnings) {
+        t1 = null;
+        break bb0;
+      }
+      const statusColor = hasErrors ? "error" as const : "warning" as const;
+      const statusText = hasErrors ? "Missing dependencies" : "Available (with warnings)";
+      t0 = <Box flexDirection="column"><Text bold={true}>Sandbox</Text><Text>└ Status: <Text color={statusColor}>{statusText}</Text></Text>{depCheck.errors.map(_temp)}{depCheck.warnings.map(_temp2)}{hasErrors && <Text dimColor={true}>└ Run /sandbox for install instructions</Text>}</Box>;
+    }
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t0 = $[0];
+    t1 = $[1];
+  }
+  if (t1 !== Symbol.for("react.early_return_sentinel")) {
+    return t1;
+  }
+  return t0;
+}
+function _temp2(w, i_0) {
+  return <Text key={i_0} color="warning">└ {w}</Text>;
+}
+function _temp(e, i) {
+  return <Text key={i} color="error">└ {e}</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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