@jonnyhoo/ccs 1.0.0

package/dist/ccs.js

@@ -0,0 +1,642 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const claude_detector_1 = require("./utils/claude-detector");
+const config_manager_1 = require("./utils/config-manager");
+const api_key_validator_1 = require("./utils/api-key-validator");
+const error_manager_1 = require("./utils/error-manager");
+const cliproxy_1 = require("./cliproxy");
+const websearch_manager_1 = require("./utils/websearch-manager");
+const unified_config_loader_1 = require("./config/unified-config-loader");
+const image_analyzer_profile_hook_injector_1 = require("./utils/hooks/image-analyzer-profile-hook-injector");
+const ui_1 = require("./utils/ui");
+// Import centralized error handling
+const errors_1 = require("./errors");
+// Import extracted command handlers
+const version_command_1 = require("./commands/version-command");
+const help_command_1 = require("./commands/help-command");
+const install_command_1 = require("./commands/install-command");
+const doctor_command_1 = require("./commands/doctor-command");
+const sync_command_1 = require("./commands/sync-command");
+const shell_completion_command_1 = require("./commands/shell-completion-command");
+const update_command_1 = require("./commands/update-command");
+// Import extracted utility functions
+const shell_executor_1 = require("./utils/shell-executor");
+// Version and Update check utilities
+const version_1 = require("./utils/version");
+const update_checker_1 = require("./utils/update-checker");
+/**
+ * Smart profile detection
+ */
+function detectProfile(args) {
+    if (args.length === 0 || args[0].startsWith('-')) {
+        // No args or first arg is a flag → use default profile
+        return { profile: 'default', remainingArgs: args };
+    }
+    else {
+        // First arg doesn't start with '-' → treat as profile name
+        return { profile: args[0], remainingArgs: args.slice(1) };
+    }
+}
+// ========== GLMT Proxy Execution ==========
+/**
+ * Execute Claude CLI with embedded proxy (for GLMT profile)
+ */
+async function execClaudeWithProxy(claudeCli, profileName, args) {
+    // 1. Read settings to get API key
+    const settingsPath = (0, config_manager_1.getSettingsPath)(profileName);
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const envData = settings.env;
+    const apiKey = envData['ANTHROPIC_AUTH_TOKEN'];
+    if (!apiKey || apiKey === 'YOUR_GLM_API_KEY_HERE') {
+        console.error((0, ui_1.fail)('GLMT profile requires Z.AI API key'));
+        console.error('    Edit ~/.ccs/glmt.settings.json and set ANTHROPIC_AUTH_TOKEN');
+        process.exit(1);
+    }
+    // Detect verbose flag
+    const verbose = args.includes('--verbose') || args.includes('-v');
+    // 2. Spawn embedded proxy with verbose flag
+    const proxyPath = path.join(__dirname, 'glmt', 'glmt-proxy.js');
+    const proxyArgs = verbose ? ['--verbose'] : [];
+    // Use process.execPath for Windows compatibility (CVE-2024-27980)
+    // Pass environment variables to proxy subprocess (required for auth)
+    const proxy = (0, child_process_1.spawn)(process.execPath, [proxyPath, ...proxyArgs], {
+        stdio: ['ignore', 'pipe', verbose ? 'pipe' : 'inherit'],
+        env: {
+            ...process.env,
+            ANTHROPIC_AUTH_TOKEN: apiKey,
+            ANTHROPIC_BASE_URL: envData['ANTHROPIC_BASE_URL'],
+        },
+    });
+    // 3. Wait for proxy ready signal (with timeout)
+    const { ProgressIndicator } = await Promise.resolve().then(() => __importStar(require('./utils/progress-indicator')));
+    const spinner = new ProgressIndicator('Starting GLMT proxy');
+    spinner.start();
+    let port;
+    try {
+        port = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Proxy startup timeout (5s)'));
+            }, 5000);
+            proxy.stdout?.on('data', (data) => {
+                const match = data.toString().match(/PROXY_READY:(\d+)/);
+                if (match) {
+                    clearTimeout(timeout);
+                    resolve(parseInt(match[1]));
+                }
+            });
+            proxy.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            proxy.on('exit', (code) => {
+                if (code !== 0 && code !== null) {
+                    clearTimeout(timeout);
+                    reject(new Error(`Proxy exited with code ${code}`));
+                }
+            });
+        });
+        spinner.succeed(`GLMT proxy ready on port ${port}`);
+    }
+    catch (error) {
+        const err = error;
+        spinner.fail('Failed to start GLMT proxy');
+        console.error((0, ui_1.fail)(`Error: ${err.message}`));
+        console.error('');
+        console.error('Possible causes:');
+        console.error('  1. Port conflict (unlikely with random port)');
+        console.error('  2. Node.js permission issue');
+        console.error('  3. Firewall blocking localhost');
+        console.error('');
+        console.error('Workarounds:');
+        console.error('  - Use non-thinking mode: ccs glm "prompt"');
+        console.error('  - Enable verbose logging: ccs glmt --verbose "prompt"');
+        console.error('  - Check proxy logs in ~/.ccs/logs/ (if debug enabled)');
+        console.error('');
+        proxy.kill();
+        process.exit(1);
+    }
+    // 4. Spawn Claude CLI with proxy URL
+    // Use model from user's settings (not hardcoded) - fixes issue #358
+    const configuredModel = envData['ANTHROPIC_MODEL'] || 'glm-4.7';
+    const envVars = {
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}`,
+        ANTHROPIC_AUTH_TOKEN: apiKey,
+        ANTHROPIC_MODEL: configuredModel,
+    };
+    const isWindows = process.platform === 'win32';
+    const needsShell = isWindows && /\.(cmd|bat|ps1)$/i.test(claudeCli);
+    const webSearchEnv = (0, websearch_manager_1.getWebSearchHookEnv)();
+    const env = {
+        ...process.env,
+        ...envVars,
+        ...webSearchEnv,
+        CCS_PROFILE_TYPE: 'settings', // Signal to WebSearch hook this is a third-party provider
+    };
+    let claude;
+    if (needsShell) {
+        const cmdString = [claudeCli, ...args].map(shell_executor_1.escapeShellArg).join(' ');
+        claude = (0, child_process_1.spawn)(cmdString, {
+            stdio: 'inherit',
+            windowsHide: true,
+            shell: true,
+            env,
+        });
+    }
+    else {
+        claude = (0, child_process_1.spawn)(claudeCli, args, {
+            stdio: 'inherit',
+            windowsHide: true,
+            env,
+        });
+    }
+    // 5. Cleanup: kill proxy when Claude exits
+    claude.on('exit', (code, signal) => {
+        proxy.kill('SIGTERM');
+        if (signal)
+            process.kill(process.pid, signal);
+        else
+            process.exit(code || 0);
+    });
+    claude.on('error', (error) => {
+        console.error((0, ui_1.fail)(`Claude CLI error: ${error}`));
+        proxy.kill('SIGTERM');
+        process.exit(1);
+    });
+    // Also handle parent process termination
+    process.once('SIGTERM', () => {
+        proxy.kill('SIGTERM');
+        claude.kill('SIGTERM');
+    });
+    process.once('SIGINT', () => {
+        proxy.kill('SIGTERM');
+        claude.kill('SIGTERM');
+    });
+}
+/**
+ * Perform background update check (refreshes cache, no notification)
+ */
+async function refreshUpdateCache() {
+    try {
+        const currentVersion = (0, version_1.getVersion)();
+        // npm is now the only supported installation method
+        await (0, update_checker_1.checkForUpdates)(currentVersion, true, 'npm');
+    }
+    catch (_e) {
+        // Silently fail - update check shouldn't crash main CLI
+    }
+}
+/**
+ * Show update notification if cached result indicates update available
+ * Returns true if notification was shown
+ */
+async function showCachedUpdateNotification() {
+    try {
+        const currentVersion = (0, version_1.getVersion)();
+        const updateInfo = (0, update_checker_1.checkCachedUpdate)(currentVersion);
+        if (updateInfo) {
+            await (0, update_checker_1.showUpdateNotification)(updateInfo);
+            return true;
+        }
+    }
+    catch (_e) {
+        // Silently fail
+    }
+    return false;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const firstArg = args[0];
+    // Initialize UI colors early to ensure consistent colored output
+    // Must happen before any status messages (ok, info, fail, etc.)
+    if (process.stdout.isTTY && !process.env['CI']) {
+        const { initUI } = await Promise.resolve().then(() => __importStar(require('./utils/ui')));
+        await initUI();
+    }
+    // Trigger update check early for ALL commands except version/help/update
+    // Only if TTY and not CI to avoid noise in automated environments
+    const skipUpdateCheck = [
+        'version',
+        '--version',
+        '-v',
+        'help',
+        '--help',
+        '-h',
+        'update',
+        '--update',
+    ];
+    if (process.stdout.isTTY && !process.env['CI'] && !skipUpdateCheck.includes(firstArg)) {
+        // 1. Show cached update notification (async for proper UI)
+        await showCachedUpdateNotification();
+        // 2. Refresh cache in background if stale (non-blocking)
+        if ((0, update_checker_1.isCacheStale)()) {
+            refreshUpdateCache();
+        }
+    }
+    // Auto-migrate to unified config format (silent if already migrated)
+    // Skip if user is explicitly running migrate command
+    if (firstArg !== 'migrate') {
+        const { autoMigrate } = await Promise.resolve().then(() => __importStar(require('./config/migration-manager')));
+        await autoMigrate();
+    }
+    // Auto-recovery for missing configuration (BEFORE any early-exit commands)
+    // This ensures ALL commands benefit from auto-recovery, not just profile-switching flow
+    // Recovery is safe to run early - it only creates missing files with safe defaults
+    // Wrapped in try-catch to prevent blocking --version/--help on permission errors
+    try {
+        const RecoveryManagerModule = await Promise.resolve().then(() => __importStar(require('./management/recovery-manager')));
+        const RecoveryManager = RecoveryManagerModule.default;
+        const recovery = new RecoveryManager();
+        const recovered = recovery.recoverAll();
+        if (recovered) {
+            recovery.showRecoveryHints();
+        }
+    }
+    catch (err) {
+        // Recovery is best-effort - don't block basic CLI functionality
+        console.warn('[!] Recovery failed:', err.message);
+    }
+    // Special case: version command (check BEFORE profile detection)
+    if (firstArg === 'version' || firstArg === '--version' || firstArg === '-v') {
+        (0, version_command_1.handleVersionCommand)();
+    }
+    // Special case: help command
+    if (firstArg === '--help' || firstArg === '-h' || firstArg === 'help') {
+        await (0, help_command_1.handleHelpCommand)();
+        return;
+    }
+    // Special case: install command
+    if (firstArg === '--install') {
+        (0, install_command_1.handleInstallCommand)();
+        return;
+    }
+    // Special case: uninstall command
+    if (firstArg === '--uninstall') {
+        (0, install_command_1.handleUninstallCommand)();
+        return;
+    }
+    // Special case: shell completion installer
+    if (firstArg === '--shell-completion' || firstArg === '-sc') {
+        await (0, shell_completion_command_1.handleShellCompletionCommand)(args.slice(1));
+        return;
+    }
+    // Special case: doctor command
+    if (firstArg === 'doctor' || firstArg === '--doctor') {
+        const restArgs = args.slice(args.indexOf(firstArg) + 1);
+        await (0, doctor_command_1.handleDoctorCommand)(restArgs);
+        return;
+    }
+    // Special case: sync command
+    if (firstArg === 'sync' || firstArg === '--sync') {
+        await (0, sync_command_1.handleSyncCommand)();
+        return;
+    }
+    // Special case: cleanup command
+    if (firstArg === 'cleanup' || firstArg === '--cleanup') {
+        const { handleCleanupCommand } = await Promise.resolve().then(() => __importStar(require('./commands/cleanup-command')));
+        await handleCleanupCommand(args.slice(1));
+        return;
+    }
+    // Special case: migrate command
+    if (firstArg === 'migrate' || firstArg === '--migrate') {
+        const { handleMigrateCommand, printMigrateHelp } = await Promise.resolve().then(() => __importStar(require('./commands/migrate-command')));
+        const migrateArgs = args.slice(1);
+        if (migrateArgs.includes('--help') || migrateArgs.includes('-h')) {
+            printMigrateHelp();
+            return;
+        }
+        await handleMigrateCommand(migrateArgs);
+        return;
+    }
+    // Special case: update command
+    if (firstArg === 'update' || firstArg === '--update') {
+        const updateArgs = args.slice(1);
+        // Handle --help for update command
+        if (updateArgs.includes('--help') || updateArgs.includes('-h')) {
+            console.log('');
+            console.log('Usage: ccs update [options]');
+            console.log('');
+            console.log('Options:');
+            console.log('  --force       Force reinstall current version');
+            console.log('  --beta, --dev Install from dev channel (unstable)');
+            console.log('  --help, -h    Show this help message');
+            console.log('');
+            console.log('Examples:');
+            console.log('  ccs update           Update to latest stable');
+            console.log('  ccs update --force   Force reinstall');
+            console.log('  ccs update --beta    Install dev channel');
+            console.log('');
+            return;
+        }
+        const forceFlag = updateArgs.includes('--force');
+        const betaFlag = updateArgs.includes('--beta') || updateArgs.includes('--dev');
+        await (0, update_command_1.handleUpdateCommand)({ force: forceFlag, beta: betaFlag });
+        return;
+    }
+    // Special case: auth command
+    if (firstArg === 'auth') {
+        const AuthCommandsModule = await Promise.resolve().then(() => __importStar(require('./auth/auth-commands')));
+        const AuthCommands = AuthCommandsModule.default;
+        const authCommands = new AuthCommands();
+        await authCommands.route(args.slice(1));
+        return;
+    }
+    // Special case: api command (manages API profiles)
+    if (firstArg === 'api') {
+        const { handleApiCommand } = await Promise.resolve().then(() => __importStar(require('./commands/api-command')));
+        await handleApiCommand(args.slice(1));
+        return;
+    }
+    // Special case: cliproxy command (manages CLIProxyAPI binary)
+    if (firstArg === 'cliproxy') {
+        const { handleCliproxyCommand } = await Promise.resolve().then(() => __importStar(require('./commands/cliproxy-command')));
+        await handleCliproxyCommand(args.slice(1));
+        return;
+    }
+    // Special case: config command (web dashboard)
+    if (firstArg === 'config') {
+        const { handleConfigCommand } = await Promise.resolve().then(() => __importStar(require('./commands/config-command')));
+        await handleConfigCommand(args.slice(1));
+        return;
+    }
+    // Special case: tokens command (auth token management)
+    if (firstArg === 'tokens') {
+        const { handleTokensCommand } = await Promise.resolve().then(() => __importStar(require('./commands/tokens-command')));
+        const exitCode = await handleTokensCommand(args.slice(1));
+        process.exit(exitCode);
+    }
+    // Special case: persist command (write profile env to ~/.claude/settings.json)
+    if (firstArg === 'persist') {
+        const { handlePersistCommand } = await Promise.resolve().then(() => __importStar(require('./commands/persist-command')));
+        await handlePersistCommand(args.slice(1));
+        return;
+    }
+    // Special case: setup command (first-time wizard)
+    if (firstArg === 'setup' || firstArg === '--setup') {
+        const { handleSetupCommand } = await Promise.resolve().then(() => __importStar(require('./commands/setup-command')));
+        await handleSetupCommand(args.slice(1));
+        return;
+    }
+    // Special case: copilot command (GitHub Copilot integration)
+    // Only route to command handler for known subcommands, otherwise treat as profile
+    const COPILOT_SUBCOMMANDS = [
+        'auth',
+        'status',
+        'models',
+        'start',
+        'stop',
+        'enable',
+        'disable',
+        'help',
+        '--help',
+        '-h',
+    ];
+    if (firstArg === 'copilot' && args.length > 1 && COPILOT_SUBCOMMANDS.includes(args[1])) {
+        // `ccs copilot <subcommand>` - route to copilot command handler
+        const { handleCopilotCommand } = await Promise.resolve().then(() => __importStar(require('./commands/copilot-command')));
+        const exitCode = await handleCopilotCommand(args.slice(1));
+        process.exit(exitCode);
+    }
+    // Special case: headless delegation (-p flag)
+    if (args.includes('-p') || args.includes('--prompt')) {
+        const { DelegationHandler } = await Promise.resolve().then(() => __importStar(require('./delegation/delegation-handler')));
+        const handler = new DelegationHandler();
+        await handler.route(args);
+        return;
+    }
+    // First-time install: offer setup wizard for interactive users
+    // Check independently of recovery status (user may have empty config.yaml)
+    // Skip if headless, CI, or non-TTY environment
+    const { isFirstTimeInstall } = await Promise.resolve().then(() => __importStar(require('./commands/setup-command')));
+    if (process.stdout.isTTY && !process.env['CI'] && isFirstTimeInstall()) {
+        console.log('');
+        console.log((0, ui_1.info)('First-time install detected. Run `ccs setup` for guided configuration.'));
+        console.log('    Or use `ccs config` for the web dashboard.');
+        console.log('');
+    }
+    // Detect profile
+    const { profile, remainingArgs } = detectProfile(args);
+    // Detect Claude CLI first (needed for all paths)
+    const claudeCli = (0, claude_detector_1.detectClaudeCli)();
+    if (!claudeCli) {
+        await error_manager_1.ErrorManager.showClaudeNotFound();
+        process.exit(1);
+    }
+    // Use ProfileDetector to determine profile type
+    const ProfileDetectorModule = await Promise.resolve().then(() => __importStar(require('./auth/profile-detector')));
+    const ProfileDetector = ProfileDetectorModule.default;
+    const InstanceManagerModule = await Promise.resolve().then(() => __importStar(require('./management/instance-manager')));
+    const InstanceManager = InstanceManagerModule.default;
+    const ProfileRegistryModule = await Promise.resolve().then(() => __importStar(require('./auth/profile-registry')));
+    const ProfileRegistry = ProfileRegistryModule.default;
+    const detector = new ProfileDetector();
+    try {
+        const profileInfo = detector.detectProfileType(profile);
+        if (profileInfo.type === 'cliproxy') {
+            // CLIPROXY FLOW: OAuth-based profiles (gemini, codex, agy, qwen) or user-defined variants
+            // Inject WebSearch hook into profile settings before launch
+            (0, websearch_manager_1.ensureProfileHooks)(profileInfo.name);
+            // Inject Image Analyzer hook into profile settings before launch
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)(profileInfo.name);
+            const provider = profileInfo.provider || profileInfo.name;
+            const customSettingsPath = profileInfo.settingsPath; // undefined for hardcoded profiles
+            const variantPort = profileInfo.port; // variant-specific port for isolation
+            await (0, cliproxy_1.execClaudeWithCLIProxy)(claudeCli, provider, remainingArgs, {
+                customSettingsPath,
+                port: variantPort,
+            });
+        }
+        else if (profileInfo.type === 'copilot') {
+            // COPILOT FLOW: GitHub Copilot subscription via copilot-api proxy
+            // Inject WebSearch hook into profile settings before launch
+            (0, websearch_manager_1.ensureProfileHooks)(profileInfo.name);
+            // Inject Image Analyzer hook into profile settings before launch
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)(profileInfo.name);
+            const { executeCopilotProfile } = await Promise.resolve().then(() => __importStar(require('./copilot')));
+            const copilotConfig = profileInfo.copilotConfig;
+            if (!copilotConfig) {
+                console.error((0, ui_1.fail)('Copilot configuration not found'));
+                process.exit(1);
+            }
+            const exitCode = await executeCopilotProfile(copilotConfig, remainingArgs);
+            process.exit(exitCode);
+        }
+        else if (profileInfo.type === 'settings') {
+            // Settings-based profiles (glm, glmt, kimi) are third-party providers
+            // WebSearch is server-side tool - third-party providers have no access
+            // Inject WebSearch hook into profile settings before launch
+            (0, websearch_manager_1.ensureProfileHooks)(profileInfo.name);
+            // Inject Image Analyzer hook into profile settings before launch
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)(profileInfo.name);
+            (0, websearch_manager_1.ensureMcpWebSearch)();
+            // Display WebSearch status (single line, equilibrium UX)
+            (0, websearch_manager_1.displayWebSearchStatus)();
+            // Pre-flight validation for GLM/GLMT/MiniMax profiles
+            if (profileInfo.name === 'glm' || profileInfo.name === 'glmt') {
+                const preflightSettingsPath = (0, config_manager_1.getSettingsPath)(profileInfo.name);
+                const preflightSettings = (0, config_manager_1.loadSettings)(preflightSettingsPath);
+                const apiKey = preflightSettings.env?.['ANTHROPIC_AUTH_TOKEN'];
+                if (apiKey) {
+                    const validation = await (0, api_key_validator_1.validateGlmKey)(apiKey, preflightSettings.env?.['ANTHROPIC_BASE_URL']);
+                    if (!validation.valid) {
+                        console.error('');
+                        console.error((0, ui_1.fail)(validation.error || 'API key validation failed'));
+                        if (validation.suggestion) {
+                            console.error('');
+                            console.error(validation.suggestion);
+                        }
+                        console.error('');
+                        console.error((0, ui_1.info)('To skip validation: CCS_SKIP_PREFLIGHT=1 ccs glm "prompt"'));
+                        process.exit(1);
+                    }
+                }
+            }
+            if (profileInfo.name === 'mm') {
+                const preflightSettingsPath = (0, config_manager_1.getSettingsPath)(profileInfo.name);
+                const preflightSettings = (0, config_manager_1.loadSettings)(preflightSettingsPath);
+                const apiKey = preflightSettings.env?.['ANTHROPIC_AUTH_TOKEN'];
+                if (apiKey) {
+                    const validation = await (0, api_key_validator_1.validateMiniMaxKey)(apiKey, preflightSettings.env?.['ANTHROPIC_BASE_URL']);
+                    if (!validation.valid) {
+                        console.error('');
+                        console.error((0, ui_1.fail)(validation.error || 'API key validation failed'));
+                        if (validation.suggestion) {
+                            console.error('');
+                            console.error(validation.suggestion);
+                        }
+                        console.error('');
+                        console.error((0, ui_1.info)('To skip validation: CCS_SKIP_PREFLIGHT=1 ccs mm "prompt"'));
+                        process.exit(1);
+                    }
+                }
+            }
+            // Check if this is GLMT profile (requires proxy)
+            if (profileInfo.name === 'glmt') {
+                // GLMT FLOW: Settings-based with embedded proxy for thinking support
+                await execClaudeWithProxy(claudeCli, profileInfo.name, remainingArgs);
+            }
+            else {
+                // EXISTING FLOW: Settings-based profile (glm, kimi)
+                // Use --settings flag (backward compatible)
+                const expandedSettingsPath = (0, config_manager_1.getSettingsPath)(profileInfo.name);
+                const webSearchEnv = (0, websearch_manager_1.getWebSearchHookEnv)();
+                // Get global env vars (DISABLE_TELEMETRY, etc.) for third-party profiles
+                const globalEnvConfig = (0, unified_config_loader_1.getGlobalEnvConfig)();
+                const globalEnv = globalEnvConfig.enabled ? globalEnvConfig.env : {};
+                // Log global env injection for visibility (debug mode only)
+                if (globalEnvConfig.enabled && Object.keys(globalEnv).length > 0 && process.env.CCS_DEBUG) {
+                    const envNames = Object.keys(globalEnv).join(', ');
+                    console.error((0, ui_1.info)(`Global env: ${envNames}`));
+                }
+                // CRITICAL: Load settings and explicitly set ANTHROPIC_* env vars
+                // to prevent inheriting stale values from previous CLIProxy sessions.
+                // Environment variables take precedence over --settings file values,
+                // so we must explicitly set them here to ensure correct routing.
+                const settings = (0, config_manager_1.loadSettings)(expandedSettingsPath);
+                const settingsEnv = settings.env || {};
+                const envVars = {
+                    ...globalEnv,
+                    ...settingsEnv, // Explicitly inject all settings env vars
+                    ...webSearchEnv,
+                    CCS_PROFILE_TYPE: 'settings', // Signal to WebSearch hook this is a third-party provider
+                };
+                (0, shell_executor_1.execClaude)(claudeCli, ['--settings', expandedSettingsPath, ...remainingArgs], envVars);
+            }
+        }
+        else if (profileInfo.type === 'account') {
+            // NEW FLOW: Account-based profile (work, personal)
+            // All platforms: Use instance isolation with CLAUDE_CONFIG_DIR
+            const registry = new ProfileRegistry();
+            const instanceMgr = new InstanceManager();
+            // Ensure instance exists (lazy init if needed)
+            const instancePath = instanceMgr.ensureInstance(profileInfo.name);
+            // Update last_used timestamp (check unified config first, fallback to legacy)
+            if (registry.hasAccountUnified(profileInfo.name)) {
+                registry.touchAccountUnified(profileInfo.name);
+            }
+            else {
+                registry.touchProfile(profileInfo.name);
+            }
+            // Execute Claude with instance isolation
+            // Skip WebSearch hook - account profiles use native server-side WebSearch
+            // Skip Image Analyzer hook - account profiles have native vision support
+            const envVars = {
+                CLAUDE_CONFIG_DIR: instancePath,
+                CCS_PROFILE_TYPE: 'account',
+                CCS_WEBSEARCH_SKIP: '1',
+                CCS_IMAGE_ANALYSIS_SKIP: '1',
+            };
+            (0, shell_executor_1.execClaude)(claudeCli, remainingArgs, envVars);
+        }
+        else {
+            // DEFAULT: No profile configured, use Claude's own defaults
+            // Skip WebSearch hook - native Claude has server-side WebSearch
+            // Skip Image Analyzer hook - native Claude has native vision support
+            const envVars = {
+                CCS_PROFILE_TYPE: 'default',
+                CCS_WEBSEARCH_SKIP: '1',
+                CCS_IMAGE_ANALYSIS_SKIP: '1',
+            };
+            (0, shell_executor_1.execClaude)(claudeCli, remainingArgs, envVars);
+        }
+    }
+    catch (error) {
+        const err = error;
+        // Check if this is a profile not found error with suggestions
+        if (err.profileName && err.availableProfiles !== undefined) {
+            const allProfiles = err.availableProfiles.split('\n');
+            await error_manager_1.ErrorManager.showProfileNotFound(err.profileName, allProfiles, err.suggestions);
+        }
+        else {
+            console.error((0, ui_1.fail)(err.message));
+        }
+        process.exit(1);
+    }
+}
+// ========== Global Error Handlers ==========
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+    (0, errors_1.handleError)(error);
+});
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason) => {
+    (0, errors_1.handleError)(reason);
+});
+// Handle process termination signals for cleanup
+process.on('SIGTERM', () => {
+    (0, errors_1.runCleanup)();
+    process.exit(0);
+});
+process.on('SIGINT', () => {
+    (0, errors_1.runCleanup)();
+    process.exit(130); // 128 + SIGINT(2)
+});
+// Run main
+main().catch(errors_1.handleError);
+//# sourceMappingURL=ccs.js.map