claude-code/commands/sandbox-toggle/sandbox-toggle.tsx

import { relative } from 'path';
import React from 'react';
import { getCwdState } from '../../bootstrap/state.js';
import { SandboxSettings } from '../../components/sandbox/SandboxSettings.js';
import { color } from '../../ink.js';
import { getPlatform } from '../../utils/platform.js';
import { addToExcludedCommands, SandboxManager } from '../../utils/sandbox/sandbox-adapter.js';
import { getSettings_DEPRECATED, getSettingsFilePathForSource } from '../../utils/settings/settings.js';
import type { ThemeName } from '../../utils/theme.js';
export async function call(onDone: (result?: string) => void, _context: unknown, args?: string): Promise<React.ReactNode | null> {
  const settings = getSettings_DEPRECATED();
  const themeName: ThemeName = settings.theme as ThemeName || 'light';
  const platform = getPlatform();
  if (!SandboxManager.isSupportedPlatform()) {
    // WSL1 users will see this since isSupportedPlatform returns false for WSL1
    const errorMessage = platform === 'wsl' ? 'Error: Sandboxing requires WSL2. WSL1 is not supported.' : 'Error: Sandboxing is currently only supported on macOS, Linux, and WSL2.';
    const message = color('error', themeName)(errorMessage);
    onDone(message);
    return null;
  }

  // Check dependencies - get structured result with errors/warnings
  const depCheck = SandboxManager.checkDependencies();

  // Check if platform is in enabledPlatforms list (undocumented enterprise setting)
  if (!SandboxManager.isPlatformInEnabledList()) {
    const message = color('error', themeName)(`Error: Sandboxing is disabled for this platform (${platform}) via the enabledPlatforms setting.`);
    onDone(message);
    return null;
  }

  // Check if sandbox settings are locked by higher-priority settings
  if (SandboxManager.areSandboxSettingsLockedByPolicy()) {
    const message = color('error', themeName)('Error: Sandbox settings are overridden by a higher-priority configuration and cannot be changed locally.');
    onDone(message);
    return null;
  }

  // Parse the arguments
  const trimmedArgs = args?.trim() || '';

  // If no args, show the interactive menu
  if (!trimmedArgs) {
    return <SandboxSettings onComplete={onDone} depCheck={depCheck} />;
  }

  // Handle subcommands
  if (trimmedArgs) {
    const parts = trimmedArgs.split(' ');
    const subcommand = parts[0];
    if (subcommand === 'exclude') {
      // Handle exclude subcommand
      const commandPattern = trimmedArgs.slice('exclude '.length).trim();
      if (!commandPattern) {
        const message = color('error', themeName)('Error: Please provide a command pattern to exclude (e.g., /sandbox exclude "npm run test:*")');
        onDone(message);
        return null;
      }

      // Remove quotes if present
      const cleanPattern = commandPattern.replace(/^["']|["']$/g, '');

      // Add to excludedCommands
      addToExcludedCommands(cleanPattern);

      // Get the local settings path and make it relative to cwd
      const localSettingsPath = getSettingsFilePathForSource('localSettings');
      const relativePath = localSettingsPath ? relative(getCwdState(), localSettingsPath) : '.claude/settings.local.json';
      const message = color('success', themeName)(`Added "${cleanPattern}" to excluded commands in ${relativePath}`);
      onDone(message);
      return null;
    } else {
      // Unknown subcommand
      const message = color('error', themeName)(`Error: Unknown subcommand "${subcommand}". Available subcommand: exclude`);
      onDone(message);
      return null;
    }
  }

  // Should never reach here since we handle all cases above
  return null;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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