@kikkimo/claude-launcher 1.0.0 → 2.1.0

package/claude-launcher

@@ -1,679 +1,1174 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+/**
+ * Claude Launcher - Refactored modular version
+ * A launcher for Claude Code with third-party API support
+ */
+
+/**
+ * Force complete stdin reset to prevent navigation issues
+ * Note: This function should only reset state, not remove listeners
+ * that might be used by other modules
+ */
+function forceStdinCleanup() {
+    try {
+        if (process.stdin.isTTY) {
+            // Only reset mode, don't remove listeners that might be in use
+            process.stdin.setRawMode(false);
+            // NOTE: Removed removeAllListeners to prevent conflicts
+            // Each module should manage its own listeners
+            // Only pause if not already paused (isPaused is a method, not a property)
+            if (!process.stdin.isPaused()) {
+                process.stdin.pause();
+            }
+        }
+    } catch (error) {
+        // Ignore cleanup errors but log for debugging
+        if (process.env.DEBUG_STDIN) {
+            console.error('[DEBUG] forceStdinCleanup error:', error.message);
+        }
+    }
+}
+
+
+const ApiManager = require('./lib/api-manager');
+const Menu = require('./lib/ui/menu');
+const colors = require('./lib/ui/colors');
+const { checkForUpdates, forceCheckForUpdates } = require('./lib/utils/version-checker');
+const {
+    waitForKey,
+    promptForThirdPartyApi,
+    confirmAction,
+    showSuccess,
+    showError,
+    showInfo
+} = require('./lib/ui/prompts');
+const {
+    launchClaudeDefault,
+    launchClaudeSkipPermissions,
+    launchClaudeWithApi
+} = require('./lib/launcher');
+const { getPasswordInput } = require('./lib/auth/password-input');
+const { verifyExportPassword, setupNewPassword, changePassword: changePasswordModule } = require('./lib/auth/password-validator');
+const { maskApiToken } = require('./lib/validators');
+const { showApiSelectionTable, confirmDeletion } = require('./lib/ui/interactive-table');
+const i18n = require('./lib/i18n');
 const fs = require('fs');
 const path = require('path');
-const readline = require('readline');
-const crypto = require('crypto');
-
-// Get config file location - check multiple locations for global installation
-function getConfigPath() {
-    const locations = [
-        // Current working directory (highest priority)
-        path.join(process.cwd(), '.claude-launcher.env'),
-        // User home directory
-        path.join(require('os').homedir(), '.claude-launcher.env'),
-        // Script directory (for local installation)
-        path.join(__dirname, '.claude-launcher.env')
-    ];
-    
-    // Return the first existing config file, or the home directory path as default
-    for (const location of locations) {
-        if (fs.existsSync(location)) {
-            return location;
-        }
+const os = require('os');
+const { exec } = require('child_process');
+
+// Initialize components
+const apiManager = new ApiManager();
+
+// Global menu objects to prevent screen flickering during navigation
+let globalMainMenu = null;
+let globalConfirmMenu = null;
+let globalApiManagementMenu = null;
+
+/**
+ * Initialize global menu objects to prevent recreation and screen flickering
+ */
+function initializeGlobalMenus() {
+    if (!globalMainMenu) {
+        globalMainMenu = new Menu();
+    }
+    if (!globalConfirmMenu) {
+        globalConfirmMenu = new Menu();
+    }
+    if (!globalApiManagementMenu) {
+        globalApiManagementMenu = new Menu();
     }
-    
-    // Default to home directory if no config exists
-    return path.join(require('os').homedir(), '.claude-launcher.env');
 }
 
-const CONFIG_FILE = getConfigPath();
-
-// ANSI color codes for Claude-style theming
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    orange: '\x1b[38;5;208m',      // Claude brand orange
-    amber: '\x1b[38;5;214m',       // Amber/yellow-orange
-    white: '\x1b[37m',
-    gray: '\x1b[90m',
-    green: '\x1b[32m',
-    red: '\x1b[31m',
-    yellow: '\x1b[33m',
-    black: '\x1b[30m',
-    bgOrange: '\x1b[48;5;208m',    // Background orange
-    bgAmber: '\x1b[48;5;214m'      // Background amber
-};
-
-// Generate encryption key from machine-specific data
-function getEncryptionKey() {
-    const os = require('os');
-    // Use a combination of hostname and user info to create a machine-specific key
-    const machineId = os.hostname() + os.userInfo().username + os.platform();
-    // Derive a 32-byte key using PBKDF2
-    return crypto.pbkdf2Sync(machineId, 'claude-launcher-salt', 10000, 32, 'sha256');
+/**
+ * Get export directory path and create if not exists
+ * @returns {string} - Export directory path
+ */
+function getExportDirectory() {
+    const userHome = os.homedir();
+    const exportDir = path.join(userHome, 'claude-launcher');
+
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(exportDir)) {
+        fs.mkdirSync(exportDir, { recursive: true });
+    }
+
+    return exportDir;
+}
+
+/**
+ * Generate timestamp-based filename for export
+ * @returns {string} - Filename with timestamp
+ */
+function generateExportFilename() {
+    const now = new Date();
+    const timestamp = now.getFullYear().toString() +
+                     (now.getMonth() + 1).toString().padStart(2, '0') +
+                     now.getDate().toString().padStart(2, '0') +
+                     now.getHours().toString().padStart(2, '0') +
+                     now.getMinutes().toString().padStart(2, '0') +
+                     now.getSeconds().toString().padStart(2, '0');
+
+    return `claude-launcher-export-${timestamp}.json`;
+}
+
+/**
+ * Open file with system default application
+ * @param {string} filePath - Path to the file to open
+ */
+function openFileWithDefault(filePath) {
+    const platform = process.platform;
+    let command;
+
+    if (platform === 'win32') {
+        command = `start "" "${filePath}"`;
+    } else if (platform === 'darwin') {
+        command = `open "${filePath}"`;
+    } else {
+        command = `xdg-open "${filePath}"`;
+    }
+
+    exec(command, (error) => {
+        if (error) {
+            console.log(colors.yellow + `Could not open file automatically: ${error.message}` + colors.reset);
+        }
+    });
 }
 
-// Encrypt API key using AES-256-CBC
-function encryptApiKey(plaintext) {
+/**
+ * Validate import file path and JSON format
+ * @param {string} filePath - Path to the JSON file
+ * @returns {Object} - Validation result with success status and data/error
+ */
+function validateImportFile(filePath) {
+    const result = {
+        valid: false,
+        data: null,
+        error: null
+    };
+
     try {
-        const key = getEncryptionKey();
-        const iv = crypto.randomBytes(16); // Generate random IV
-        const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
-        
-        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
-        encrypted += cipher.final('hex');
-        
-        // Combine IV and encrypted data
-        const result = iv.toString('hex') + ':' + encrypted;
-        
-        return {
-            success: true,
-            value: result,
-            error: null
-        };
+        // Check if file path is provided
+        if (!filePath || filePath.trim() === '') {
+            result.error = 'File path cannot be empty';
+            return result;
+        }
+
+        // Normalize and resolve path
+        const normalizedPath = path.resolve(filePath.trim());
+
+        // Check if file exists
+        if (!fs.existsSync(normalizedPath)) {
+            result.error = i18n.tSync('errors.file.file_not_found', normalizedPath);
+            return result;
+        }
+
+        // Check if it's a file (not directory)
+        const stats = fs.statSync(normalizedPath);
+        if (!stats.isFile()) {
+            result.error = `Path is not a file: ${normalizedPath}`;
+            return result;
+        }
+
+        // Check file extension
+        if (path.extname(normalizedPath).toLowerCase() !== '.json') {
+            result.error = `File must have .json extension: ${normalizedPath}`;
+            return result;
+        }
+
+        // Read and parse JSON file
+        const fileContent = fs.readFileSync(normalizedPath, 'utf8');
+
+        // Validate JSON format
+        let jsonData;
+        try {
+            jsonData = JSON.parse(fileContent);
+        } catch (parseError) {
+            result.error = `Invalid JSON format: ${parseError.message}`;
+            return result;
+        }
+
+        // Basic structure validation for claude-launcher config
+        if (!jsonData || typeof jsonData !== 'object') {
+            result.error = 'JSON file must contain a valid configuration object';
+            return result;
+        }
+
+        // Check for required fields (basic validation)
+        if (!jsonData.hasOwnProperty('apis') || !Array.isArray(jsonData.apis)) {
+            result.error = i18n.tSync('errors.file.invalid_format', 'JSON file must contain an "apis" array');
+            return result;
+        }
+
+        result.valid = true;
+        result.data = fileContent; // Return raw JSON string for compatibility
+        return result;
+
     } catch (error) {
-        return {
-            success: false,
-            value: null,
-            error: error.message
-        };
+        result.error = `File validation error: ${error.message}`;
+        return result;
     }
 }
 
-// Decrypt API key using AES-256-CBC
-function decryptApiKey(encryptedData) {
+// Main menu options - will be populated dynamically with i18n
+let menuOptions = [];
+
+/**
+ * Add new third-party API
+ */
+async function addNewThirdPartyApi() {
     try {
-        const key = getEncryptionKey();
-        
-        // Split IV and encrypted data
-        const parts = encryptedData.split(':');
-        if (parts.length !== 2) {
-            throw new Error('Invalid encrypted data format');
+        const apiData = await promptForThirdPartyApi();
+
+        // Check if this is the first API
+        const isFirstApi = apiManager.getApis().length === 0;
+        const hasExportPassword = apiManager.hasExportPassword();
+
+        const newApi = apiManager.addApi(
+            apiData.baseUrl,
+            apiData.authToken,
+            apiData.model,
+            apiData.name,
+            apiData.provider
+        );
+
+        showSuccess(await i18n.t('messages.success.api_added'), [
+            `Name: ${newApi.name}`,
+            `${await i18n.t('api.details.provider')}: ${newApi.provider}`,
+            `${await i18n.t('api.details.url')}: ${newApi.baseUrl}`,
+            `${await i18n.t('api.details.model')}: ${newApi.model}`
+        ]);
+
+        if (isFirstApi) {
+            showInfo(await i18n.t('messages.info.first_time_usage'));
         }
-        
-        const iv = Buffer.from(parts[0], 'hex');
-        const encrypted = parts[1];
-        
-        const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
-        
-        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
-        decrypted += decipher.final('utf8');
-        
-        return {
-            success: true,
-            value: decrypted,
-            error: null
-        };
+
     } catch (error) {
-        return {
-            success: false,
-            value: null,
-            error: error.message
-        };
+        // Force cleanup stdin state to prevent navigation issues
+        forceStdinCleanup();
+
+        // Check if user cancelled the operation
+        const cancelledMessage = await i18n.t('errors.general.cancelled_by_user');
+        if (error.message === cancelledMessage) {
+            // User cancelled - show neutral message instead of error
+            console.log(colors.yellow + await i18n.t('messages.info.operation_cancelled') + colors.reset);
+        } else {
+            // Actual error occurred
+            showError(await i18n.t('errors.api.failed_add', error.message));
+        }
     }
-}
 
-// Validate API key format
-function validateApiKey(apiKey) {
-    if (!apiKey || apiKey.trim() === '') {
-        return {
-            valid: false,
-            error: 'API key is empty or missing'
-        };
-    }
-    
-    if (!apiKey.startsWith('sk-')) {
-        return {
-            valid: false,
-            error: 'API key must start with "sk-"'
-        };
-    }
-    
-    if (apiKey.length < 20) {
-        return {
-            valid: false,
-            error: 'API key appears to be too short'
-        };
-    }
-    
-    return {
-        valid: true,
-        error: null,
-        value: apiKey
-    };
+    await waitForKey(await i18n.t('messages.prompts.press_any_key'));
 }
 
-// Load configuration from .env file
-function loadConfig() {
-    const config = {};
-    
+/**
+ * Remove third-party API
+ */
+async function removeThirdPartyApi() {
     try {
-        if (fs.existsSync(CONFIG_FILE)) {
-            const envContent = fs.readFileSync(CONFIG_FILE, 'utf8');
-            const lines = envContent.split('\n');
-            
-            lines.forEach(line => {
-                const match = line.match(/^([^=]+)=(.*)$/);
-                if (match) {
-                    const key = match[1];
-                    let value = match[2];
-                    
-                    // Store raw value for KIMI_API_KEY (validation will be done later)
-                    // Don't decrypt here to allow proper error handling
-                    
-                    config[key] = value;
-                }
-            });
-        } else {
-            console.log(colors.yellow + 'Warning: .claude-launcher.env file not found!' + colors.reset);
-            console.log(colors.gray + `Searched locations:` + colors.reset);
-            console.log(colors.gray + `  - ${path.join(process.cwd(), '.claude-launcher.env')} (current directory)` + colors.reset);
-            console.log(colors.gray + `  - ${path.join(require('os').homedir(), '.claude-launcher.env')} (home directory)` + colors.reset);
-            console.log(colors.gray + `Creating default config at: ${CONFIG_FILE}` + colors.reset);
-            
-            // Try to read template file, fallback to hardcoded defaults
-            let defaultConfig = `KIMI_API_KEY=Your_Double_Base64_Encoded_Api_Key
-KIMI_BASE_URL=https://api.moonshot.cn/anthropic/`;
-            
-            const templatePath = path.join(__dirname, 'claude-launcher-template.env');
+        // Get API list
+        const apis = apiManager.getApis();
+        const activeApi = apiManager.getActiveApi();
+        const activeIndex = activeApi ? apis.findIndex(api => api.id === activeApi.id) : -1;
+
+        // Show API selection table (handles no APIs case internally)
+        const selectedApi = await showApiSelectionTable(
+            apis,
+            i18n.tSync('ui.general.select_api_remove'),
+            'remove',
+            activeIndex
+        );
+
+        if (!selectedApi) {
+            return showMenu();
+        }
+
+        // Show confirmation dialog
+        const confirmed = await confirmDeletion(selectedApi);
+
+        if (confirmed) {
             try {
-                if (fs.existsSync(templatePath)) {
-                    defaultConfig = fs.readFileSync(templatePath, 'utf8');
-                    console.log(colors.gray + `Using template from: ${templatePath}` + colors.reset);
+                // Find the index of the selected API in the current list
+                const selectedIndex = apis.findIndex(api => api.id === selectedApi.id);
+                apiManager.removeApi(selectedIndex);
+
+                console.clear();
+                showSuccess(await i18n.t('messages.success.api_removed'), [
+                    `${await i18n.t('api.actions.removed_info', selectedApi.name)}`,
+                    `${await i18n.t('api.details.provider')}: ${selectedApi.provider}`
+                ]);
+
+                // Show success message and return to main menu
+                const remainingApis = apiManager.getApis();
+                if (remainingApis.length === 0) {
+                    showInfo(await i18n.t('messages.info.all_apis_removed'));
                 }
-            } catch (templateError) {
-                console.log(colors.yellow + 'Template file not found, using defaults' + colors.reset);
-            }
-            
-            try {
-                fs.writeFileSync(CONFIG_FILE, defaultConfig);
-                console.log(colors.green + 'Default configuration file created successfully!' + colors.reset);
-                console.log(colors.gray + 'Please edit the file to add your actual API credentials.' + colors.reset);
-            } catch (error) {
-                console.log(colors.red + 'Failed to create config file: ' + error.message + colors.reset);
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+                return showMenu();
+
+            } catch (removeError) {
+                showError(await i18n.t('errors.api.failed_remove', removeError.message));
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+                return showMenu();
             }
-            
-            config.KIMI_API_KEY = 'Your_Double_Base64_Encoded_Api_Key';
-            config.KIMI_BASE_URL = 'https://api.moonshot.cn/anthropic/';
+        } else {
+            showInfo(await i18n.t('messages.info.removal_cancelled'));
+            await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+            return showMenu();
         }
+
     } catch (error) {
-        console.log(colors.red + 'Error loading configuration: ' + error.message + colors.reset);
-        config.KIMI_API_KEY = 'Your_Double_Base64_Encoded_Api_Key';
-        config.KIMI_BASE_URL = 'https://api.moonshot.cn/anthropic/';
+        forceStdinCleanup();
+        showError('Failed to remove API', [error.message]);
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
     }
-    
-    return config;
 }
 
-// Launch Claude Code function with clean environment handoff
-function launchClaude(command, envVars = {}, disableAuthTokens = false) {
-    console.log('');
-    console.log(colors.yellow + 'Starting Claude Code...' + colors.reset);
-    console.log(colors.gray + `Command: ${command}` + colors.reset);
-    
-    if (Object.keys(envVars).length > 0) {
-        console.log(colors.gray + 'Environment variables:' + colors.reset);
-        for (const [key, value] of Object.entries(envVars)) {
-            if (key === 'ANTHROPIC_API_KEY') {
-                console.log(colors.gray + `  ${key}=***` + colors.reset);
-            } else {
-                console.log(colors.gray + `  ${key}=${value}` + colors.reset);
-            }
-        }
-    }
-    
-    console.log('');
-    console.log(colors.green + '[+] Claude will run in current terminal.' + colors.reset);
-    console.log(colors.gray + '    Launcher will exit to transfer control to Claude.' + colors.reset);
-    console.log('');
-    
-    // Prepare clean environment
-    const env = { ...process.env, ...envVars };
-    
-    // Disable conflicting auth tokens when using Kimi API
-    if (disableAuthTokens) {
-        delete env.ANTHROPIC_AUTH_TOKEN;
-        delete env.CLAUDE_CODE_OAUTH_TOKEN;
-        console.log(colors.gray + '  Disabled: ANTHROPIC_AUTH_TOKEN, CLAUDE_CODE_OAUTH_TOKEN' + colors.reset);
-    }
-    
-    // Parse command and arguments
-    const args = command.split(' ');
-    const cmd = args.shift();
-    
+/**
+ * Switch active third-party API
+ */
+async function switchThirdPartyApi() {
     try {
-        // Clean up terminal state before launching Claude
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
-        }
-        
-        // Remove all event listeners to avoid conflicts
-        process.stdin.removeAllListeners('data');
-        process.stdin.removeAllListeners('keypress');
-        process.removeAllListeners('SIGINT');
-        process.removeAllListeners('SIGTERM');
-        
-        // Launch Claude in current terminal, let it inherit everything
-        const child = spawn(cmd, args, {
-            stdio: 'inherit', // Claude takes over current terminal I/O
-            env: env,
-            cwd: process.cwd(),
-            shell: true // Use shell to find the command
-        });
-        
-        // Don't exit immediately, wait for Claude to exit then exit launcher
-        child.on('close', (code) => {
-            process.exit(code || 0);
-        });
-        
-        child.on('error', (error) => {
-            console.log(colors.red + 'Error running Claude: ' + error.message + colors.reset);
-            process.exit(1);
-        });
-        
+        const apis = apiManager.getApis();
+        const activeApi = apiManager.getActiveApi();
+        const activeIndex = activeApi ? apis.findIndex(api => api.id === activeApi.id) : -1;
+
+        // 现在表格函数内部处理整个切换流程
+        const selectedApi = await showApiSelectionTable(
+            apis,
+            i18n.tSync('api.actions.select_to_switch'),
+            'switch',
+            activeIndex,
+            apiManager  // 传递 apiManager 让表格函数处理切换逻辑
+        );
+
+        // 表格函数已经处理了所有显示和切换逻辑，直接返回主菜单
+        return showMenu();
+
     } catch (error) {
-        console.log(colors.red + 'Error launching Claude Code: ' + error.message + colors.reset);
-        console.log(colors.gray + 'Press any key to return to menu...' + colors.reset);
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.once('data', () => {
-            process.stdin.setRawMode(false);
-            showMenu();
-        });
+        forceStdinCleanup();
+        showError(await i18n.t('errors.api.failed_switch', error.message));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return showMenu();
     }
 }
 
-// Simple input using readline (supports paste naturally)
-function simpleInput(prompt) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        
-        rl.question(prompt, (answer) => {
-            rl.close();
-            resolve(answer.trim());
+/**
+ * View API statistics
+ */
+async function viewStatistics() {
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset);
+    console.log('');
+
+    const stats = apiManager.getStatistics();
+    const apis = apiManager.getApis();
+
+    console.log(colors.cyan + '  ' + i18n.tSync('ui.general.summary') + colors.reset);
+    console.log(colors.gray + `    ${await i18n.t('statistics.total_apis', stats.totalApis)}` + colors.reset);
+    console.log(colors.gray + `    ${await i18n.t('statistics.active_api', stats.activeApiName)}` + colors.reset);
+    console.log(colors.gray + `    ${await i18n.t('statistics.most_used', stats.mostUsedApi)}` + colors.reset);
+    console.log(colors.gray + `    ${await i18n.t('statistics.total_usage', stats.totalUsage)}` + colors.reset);
+    console.log('');
+
+    if (apis.length > 0) {
+        console.log(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + colors.reset);
+
+        // Pre-fetch translations to avoid await in forEach
+        const currentlyActiveText = await i18n.t('api.details.currently_active');
+        const providerText = await i18n.t('api.details.provider');
+        const usageText = await i18n.t('api.details.usage');
+        const timesSuffixText = await i18n.t('api.details.times_suffix');
+        const createdAtText = await i18n.t('api.details.created_at');
+
+        apis.forEach((api, index) => {
+            const isActive = apiManager.getActiveApi()?.id === api.id;
+            const activeText = isActive ? ` (${currentlyActiveText})` : '';
+            console.log(colors.gray + `    ${index + 1}. ${api.name}${activeText}` + colors.reset);
+            console.log(colors.dim + `       ${providerText}: ${api.provider}` + colors.reset);
+            console.log(colors.dim + `       ${usageText}: ${api.usageCount || 0} ${timesSuffixText}` + colors.reset);
+            console.log(colors.dim + `       ${createdAtText}: ${api.createdAt}` + colors.reset);
         });
-    });
+    }
+
+    console.log('');
+    await waitForKey(await i18n.t('messages.prompts.press_any_key'));
 }
 
-// Prompt user to input API key with simple readline
-async function promptForApiKey() {
-    try {
+
+/**
+ * Handle first time password setup
+ */
+async function handleFirstTimePasswordSetup() {
+    while (true) {
+        // Clear screen and show header
         console.clear();
         console.log('');
-        console.log(colors.bright + colors.orange + '[*] Kimi API Key Setup' + colors.reset);
+        console.log(colors.bright + colors.yellow + '🔐 ' + i18n.tSync('password.setup.first_time_title') + colors.reset);
         console.log('');
-        console.log(colors.yellow + '[!] This message appears because you have not set up a Kimi API key,' + colors.reset);
-        console.log(colors.yellow + '    or the API key decrypted from your local config file is invalid.' + colors.reset);
+
+        // Show information
+        console.log(colors.cyan + i18n.tSync('password.setup.why_needed') + colors.reset);
+        const whyNeededItems = i18n.tSync('password.setup.why_needed_items');
+        if (Array.isArray(whyNeededItems)) {
+            whyNeededItems.forEach(item => {
+                console.log(colors.gray + '• ' + item + colors.reset);
+            });
+        }
         console.log('');
-        console.log(colors.yellow + '[?] Why do you need to enter your API key?' + colors.reset);
-        console.log(colors.gray + '   • Kimi K2 API provides Claude-compatible interface' + colors.reset);
-        console.log(colors.gray + '   • Your API key enables access to Kimi\'s AI services' + colors.reset);
-        console.log(colors.bright + colors.green + '   • The key will be encrypted and stored locally' + colors.reset);
-        console.log(colors.bright + colors.green + '   • Only accessible on this machine' + colors.reset);
+        console.log(colors.cyan + '🔒 ' + i18n.tSync('password.setup.new_security_title') + colors.reset);
+        const securityItems = i18n.tSync('password.setup.security_items');
+        if (Array.isArray(securityItems)) {
+            securityItems.forEach(item => {
+                console.log(colors.gray + '• ' + item + colors.reset);
+            });
+        }
         console.log('');
-        console.log(colors.yellow + '[!] Security:' + colors.reset);
-        console.log(colors.gray + '   • API key is encrypted using AES-256-CBC' + colors.reset);
-        console.log(colors.gray + '   • Encryption key derived from machine-specific data' + colors.reset);
-        console.log(colors.gray + '   • Key cannot be decrypted on other machines' + colors.reset);
+        console.log(colors.yellow + i18n.tSync('password.setup.options_title') + colors.reset);
+        console.log(colors.gray + '• ' + i18n.tSync('password.setup.option_set') + colors.reset);
+        console.log(colors.gray + '• ' + i18n.tSync('password.setup.option_skip') + colors.reset);
         console.log('');
-        
-        // Show input box (fixed spacing)
-        console.log(colors.orange + '┌─────────────────────────────────────────────────────────┐' + colors.reset);
-        console.log(colors.orange + '│' + colors.reset + '  ' + colors.bright + 'Enter your Kimi API key' + '                                ' + colors.reset + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '├─────────────────────────────────────────────────────────┤' + colors.reset);
-        console.log(colors.orange + '│' + colors.reset + '  ' + colors.gray + 'Format: sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' + '     ' + colors.reset + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '│' + colors.reset + '  ' + colors.gray + 'You can copy and paste your API key here' + '               ' + colors.reset + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '│' + colors.reset + '  ' + colors.bright + colors.yellow + 'After entering, press ENTER to continue' + '                ' + colors.reset + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '│' + colors.reset + '  ' + colors.gray + 'Type "exit" or "quit" to return to menu' + '                ' + colors.reset + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '└─────────────────────────────────────────────────────────┘' + colors.reset);
+        console.log(colors.red + i18n.tSync('password.setup.warning_skip') + colors.reset);
         console.log('');
-        
-        // Clean up any existing listeners once before the input loop
-        process.stdin.removeAllListeners('data');
-        process.stdin.removeAllListeners('keypress');
-        
-        // Input loop - allow retry on invalid input
-        while (true) {
-            const apiKey = await simpleInput(colors.green + '[>] API Key (press ENTER after input): ' + colors.reset);
-            
-            // Check for exit commands
-            if (apiKey.toLowerCase() === 'exit' || apiKey.toLowerCase() === 'quit') {
-                console.log('');
-                console.log(colors.yellow + '[!] Setup cancelled by user.' + colors.reset);
-                throw new Error('User cancelled setup');
-            }
-            
-            // Validate the entered API key
-            const validation = validateApiKey(apiKey);
-            
-            if (!validation.valid) {
-                console.log(colors.red + '[X] Invalid API key: ' + validation.error + colors.reset);
-                console.log(colors.yellow + '[!] Please try again with a valid API key.' + colors.reset);
-                console.log('');
-                continue; // Ask again
-            }
-            
-            // Encrypt and save the API key
-            const encrypted = encryptApiKey(apiKey);
-            
-            if (!encrypted.success) {
-                console.log(colors.red + '[X] Failed to encrypt API key: ' + encrypted.error + colors.reset);
-                console.log(colors.yellow + '[!] Please try again.' + colors.reset);
-                console.log('');
-                continue; // Ask again
+
+        console.log(colors.gray + '按任意键继续...' + colors.reset);
+
+        // Wait for user to read the information
+        await new Promise((resolve) => {
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
+                process.stdin.once('data', () => {
+                    try {
+                        process.stdin.setRawMode(false);
+                        process.stdin.pause();
+                    } catch (error) {
+                        // Ignore cleanup errors
+                    }
+                    resolve();
+                });
+            } else {
+                resolve();
             }
-            
-            // Update configuration file
-            updateConfigFile('KIMI_API_KEY', encrypted.value);
-            
-            console.log('');
-            console.log(colors.green + '[+] API key encrypted and saved successfully!' + colors.reset);
-            console.log(colors.gray + '   Configuration saved to: ' + CONFIG_FILE + colors.reset);
-            console.log('');
-            
-            return apiKey;
+        });
+
+        // Now show the menu for selection
+        const menuOptions = [
+            i18n.tSync('password.setup.menu_set_password'),
+            i18n.tSync('password.setup.menu_skip_setup'),
+            i18n.tSync('menu.api_management.back')
+        ];
+
+        // Ensure global menus are initialized
+        initializeGlobalMenus();
+        globalConfirmMenu.setOptions(menuOptions);
+
+        const choice = await globalConfirmMenu.navigate();
+
+        switch (choice) {
+            case 0: // Set password
+                const passwordResult = await promptForPasswordSetup();
+                if (passwordResult) {
+                    return true; // Password set successfully
+                }
+                // If password setup failed, continue loop to show menu again
+                break;
+
+            case 1: // Skip setup
+                const skipResult = await confirmSkipPassword();
+                if (skipResult === true) {
+                    return true; // Skip confirmed
+                } else if (skipResult === 'reconsider') {
+                    continue; // Return to main setup menu
+                }
+                // If skip was canceled, continue loop
+                break;
+
+            case 2: // Back to main menu
+            case -1: // ESC pressed
+            default:
+                return false; // Exit setup
         }
-        
-    } catch (error) {
-        console.log(colors.red + '[X] Setup failed: ' + error.message + colors.reset);
-        process.exit(1);
     }
 }
 
-// Update configuration file with new value
-function updateConfigFile(key, value) {
-    try {
-        let configContent = '';
-        let keyExists = false;
-        
-        // Read existing config if it exists
-        if (fs.existsSync(CONFIG_FILE)) {
-            configContent = fs.readFileSync(CONFIG_FILE, 'utf8');
-            const lines = configContent.split('\n');
-            
-            // Update existing key or add new one
-            for (let i = 0; i < lines.length; i++) {
-                const match = lines[i].match(/^([^=]+)=(.*)$/);
-                if (match && match[1] === key) {
-                    lines[i] = `${key}=${value}`;
-                    keyExists = true;
-                    break;
-                }
-            }
-            
-            if (keyExists) {
-                configContent = lines.join('\n');
-            } else {
-                // Add new key at the end
-                configContent += `\n${key}=${value}`;
-            }
-        } else {
-            // Create new config file
-            configContent = `# Claude Launcher Configuration\n# Generated automatically\n\n${key}=${value}\nKIMI_BASE_URL=https://api.moonshot.cn/anthropic/\n`;
-        }
-        
-        fs.writeFileSync(CONFIG_FILE, configContent);
-    } catch (error) {
-        console.log(colors.red + 'Error updating config file: ' + error.message + colors.reset);
-        throw error;
+/**
+ * Prompt user to set password
+ */
+async function promptForPasswordSetup() {
+    const result = await setupNewPassword(apiManager, true);
+    if (result) {
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
     }
+    return result;
 }
 
-// Get Kimi configuration with validation and setup
-async function getKimiConfig() {
-    try {
-        const config = loadConfig();
-        const rawApiKey = config.KIMI_API_KEY;
-        const baseUrl = config.KIMI_BASE_URL || 'https://api.moonshot.cn/anthropic/';
-        
-        console.log('');
-        console.log(colors.bright + colors.orange + '[*] Validating Kimi API Configuration...' + colors.reset);
-        console.log('');
-        
-        // Check if API key is configured and valid
-        if (!rawApiKey || rawApiKey === 'Your_Double_Base64_Encoded_Api_Key' || rawApiKey === 'your_kimi_api_key_here') {
-            console.log(colors.yellow + '[!] No API key configured. Starting first-time setup...' + colors.reset);
-            console.log('');
-            
-            const apiKey = await promptForApiKey();
-            return {
-                ANTHROPIC_BASE_URL: baseUrl,
-                ANTHROPIC_API_KEY: apiKey
-            };
-        }
-        
-        // Try to decrypt existing API key
-        const decrypted = decryptApiKey(rawApiKey);
-        
-        if (!decrypted.success) {
-            console.log(colors.red + '[X] Failed to decrypt stored API key: ' + decrypted.error + colors.reset);
-            console.log(colors.yellow + '[!] This might happen if the key was encrypted on a different machine.' + colors.reset);
-            console.log(colors.yellow + '   Please re-enter your API key...' + colors.reset);
-            console.log('');
-            
-            const apiKey = await promptForApiKey();
-            return {
-                ANTHROPIC_BASE_URL: baseUrl,
-                ANTHROPIC_API_KEY: apiKey
-            };
-        }
-        
-        // Validate decrypted API key
-        const validation = validateApiKey(decrypted.value);
-        
-        if (!validation.valid) {
-            console.log(colors.red + '[X] Stored API key is invalid: ' + validation.error + colors.reset);
-            console.log('');
-            
-            const apiKey = await promptForApiKey();
-            return {
-                ANTHROPIC_BASE_URL: baseUrl,
-                ANTHROPIC_API_KEY: apiKey
-            };
+/**
+ * Confirm skip password setup
+ */
+async function confirmSkipPassword() {
+    console.log('');
+    console.log(colors.bright + colors.red + '⚠️  ' + i18n.tSync('errors.password.confirm_skip_title') + colors.reset);
+    console.log('');
+    console.log(colors.gray + i18n.tSync('ui.general.after_skipping_password_setup') + colors.reset);
+    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[0] + colors.reset);
+    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[1] + colors.reset);
+    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[2] + colors.reset);
+    console.log('');
+
+    // Ensure global menus are initialized
+    initializeGlobalMenus();
+
+    globalConfirmMenu.setOptions([
+        i18n.tSync('ui.general.confirm_skip_option'),
+        i18n.tSync('ui.general.reconsider_option')
+    ]);
+
+    const choice = await globalConfirmMenu.navigate();
+
+    if (choice === 0) {
+        try {
+            apiManager.skipPasswordSetup();
+            console.log(colors.yellow + i18n.tSync('errors.password.setup_skipped') + colors.reset);
+            await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
+            return true;
+        } catch (error) {
+            forceStdinCleanup();
+            console.log(colors.red + `Operation failed: ${error.message}` + colors.reset);
+            await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
+            return false;
         }
-        
-        // Success case
-        console.log(colors.green + '[+] API Key validation successful!' + colors.reset);
-        console.log(colors.gray + `   Decrypted key starts with: ${validation.value.substring(0, 8)}...` + colors.reset);
-        console.log(colors.gray + `   Base URL: ${baseUrl}` + colors.reset);
-        console.log('');
-        
-        return {
-            ANTHROPIC_BASE_URL: baseUrl,
-            ANTHROPIC_API_KEY: validation.value
-        };
-        
-    } catch (error) {
-        console.log(colors.red + '[X] Configuration error: ' + error.message + colors.reset);
-        throw error;
     }
+
+    return 'reconsider'; // Return to password setup main menu
 }
 
-// Display Claude Code style header
-function displayHeader() {
+/**
+ * Show API Management Menu
+ */
+async function showApiManagementMenu() {
+    // Force cleanup stdin state before showing API management menu
+    forceStdinCleanup();
+
     console.clear();
     console.log('');
-    
-    // Claude-style orange/amber border with Unicode box drawing characters
-    const border = colors.orange;
-    const title = colors.white + colors.bright;
-    
-    console.log(border + '  ┌────────────────────────────────────────┐' + colors.reset);
-    console.log(border + '  │' + title + '           Claude Code Launcher         ' + border + '│' + colors.reset);
-    console.log(border + '  └────────────────────────────────────────┘' + colors.reset);
-    console.log('');
-    console.log(colors.gray + '  Use ↑↓ arrow keys to navigate, Enter to select' + colors.reset);
+    console.log(colors.bright + colors.orange + '📋 ' + await i18n.t('menu.api_management.title') + colors.reset);
     console.log('');
-}
 
-// Menu options
-const menuOptions = [
-    'Launch Claude Code',
-    'Launch Claude Code (Skip Permissions)',
-    'Launch Claude Code with Kimi K2 API',
-    'Launch Claude Code with Kimi K2 API (Skip Permissions)',
-    'Exit'
-];
-
-let selectedIndex = 0;
-
-// Display menu with current selection
-function displayMenu() {
-    displayHeader();
-    
-    menuOptions.forEach((option, index) => {
-        if (index === selectedIndex) {
-            // Selected item with Claude-style highlighting
-            console.log(colors.orange + '  → ' + colors.black + colors.bgAmber + option + colors.reset);
-        } else {
-            // Normal item
-            console.log(colors.gray + '    ' + option + colors.reset);
+    // Check if this is first time usage and prompt for password setup
+    if (apiManager.isFirstTimeUsage()) {
+        const passwordChoice = await handleFirstTimePasswordSetup();
+        if (!passwordChoice) {
+            // User chose to skip or canceled, return to main menu
+            return showMenu();
         }
-    });
-    
-    console.log('');
-}
+    }
 
-// Handle key press
-function handleKeyPress(key) {
-    switch (key) {
-        case '\u001b[A': // Up arrow
-            selectedIndex = (selectedIndex - 1 + menuOptions.length) % menuOptions.length;
-            displayMenu();
-            break;
-            
-        case '\u001b[B': // Down arrow
-            selectedIndex = (selectedIndex + 1) % menuOptions.length;
-            displayMenu();
-            break;
-            
-        case '\r': // Enter
-            executeSelection();
-            break;
-            
-        case '\u001b': // Escape
-        case 'q':
-        case 'Q':
-            console.log('');
-            console.log(colors.green + 'Goodbye!' + colors.reset);
-            process.exit(0);
-            break;
+    // Build menu options based on password setup status
+    const menuOptions = [
+        await i18n.t('menu.api_management.add_new'),
+        await i18n.t('menu.api_management.remove'),
+        await i18n.t('menu.api_management.switch'),
+        await i18n.t('menu.api_management.statistics')
+    ];
+
+    // Add import/export options only if password is set
+    if (apiManager.canUseImportExport()) {
+        menuOptions.push(await i18n.t('menu.api_management.export'));
+        menuOptions.push(await i18n.t('menu.api_management.import'));
+        menuOptions.push(await i18n.t('menu.api_management.change_password'));
+    }
+
+    menuOptions.push(await i18n.t('menu.api_management.back'));
+
+    // Ensure global menus are initialized
+    initializeGlobalMenus();
+
+    globalApiManagementMenu.setOptions(menuOptions);
+
+    const choice = await globalApiManagementMenu.navigate();
+
+    // Handle menu choices based on current menu options
+    if (choice === 0) { // Add New API
+        await addNewThirdPartyApi();
+        return showMenu();
+    } else if (choice === 1) { // Remove API
+        await removeThirdPartyApi();
+        return showMenu();
+    } else if (choice === 2) { // Switch Active API
+        await switchThirdPartyApi();
+        return showMenu();
+    } else if (choice === 3) { // View API Statistics
+        await viewStatistics();
+        return showMenu();
+    } else if (apiManager.canUseImportExport()) {
+        // If import/export is available, handle those options
+        if (choice === 4) { // Export Configuration
+            await exportConfiguration();
+            return showMenu();
+        } else if (choice === 5) { // Import Configuration
+            await importConfiguration();
+            return showMenu();
+        } else if (choice === 6) { // Change Password
+            await changePassword();
+            return showMenu();
+        } else if (choice === 7) { // Back to Main Menu
+            return showMenu();
+        }
+    } else {
+        // If import/export is not available, only Back to Main Menu
+        if (choice === 4) { // Back to Main Menu
+            return showMenu();
+        }
     }
+
+    // Default fallback to main menu
+    return showMenu();
 }
 
-// Handle Kimi API launches with async configuration
-async function handleKimiLaunch(command) {
+/**
+ * Handle third-party API launch
+ */
+async function handleThirdPartyApiLaunch(skipPermissions = false) {
     try {
-        // Clean up existing listeners before API key input
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-            process.stdin.removeAllListeners('data');
-            process.stdin.pause();
-        }
-        
-        const kimiConfig = await getKimiConfig();
-        if (kimiConfig) {
-            launchClaude(command, kimiConfig, true); // true to disable auth tokens
+        const activeApi = apiManager.getActiveApi();
+
+        if (!activeApi) {
+            console.clear();
+            showInfo(i18n.tSync('launch.no_active_api'), [
+                i18n.tSync('launch.no_active_api_desc'),
+                i18n.tSync('launch.add_configure_first')
+            ]);
+
+            await waitForKey(i18n.tSync('launch.press_key_return'));
+            return showMenu();
         }
+
+        // Increment usage count for the active API since we're actually using it
+        apiManager.incrementActiveApiUsage();
+
+        launchClaudeWithApi(activeApi, skipPermissions);
+
     } catch (error) {
-        console.log('');
-        console.log(colors.red + '[X] Failed to configure Kimi API: ' + error.message + colors.reset);
-        console.log(colors.gray + 'Returning to menu...' + colors.reset);
-        console.log('');
-        
-        // Simple delay before returning to menu
+        showError('Failed to launch with third-party API', [error.message]);
+
         setTimeout(() => {
             showMenu();
         }, 2000);
     }
 }
 
-// Execute selected menu item
-function executeSelection() {
+/**
+ * Execute selected menu item
+ */
+async function executeSelection(selectedIndex) {
     switch (selectedIndex) {
         case 0: // Launch Claude Code
-            launchClaude('claude');
+            launchClaudeDefault();
             break;
-            
+
         case 1: // Launch Claude Code (Skip Permissions)
-            launchClaude('claude --dangerously-skip-permissions');
+            launchClaudeSkipPermissions();
             break;
-            
-        case 2: // Launch Claude Code with Kimi K2 API
-            handleKimiLaunch('claude');
+
+        case 2: // Launch Claude Code with 3rd-party API
+            await handleThirdPartyApiLaunch(false);
             break;
-            
-        case 3: // Launch Claude Code with Kimi K2 API (Skip Permissions)
-            handleKimiLaunch('claude --dangerously-skip-permissions');
+
+        case 3: // Launch Claude Code with 3rd-party API (Skip Permissions)
+            await handleThirdPartyApiLaunch(true);
             break;
-            
-        case 4: // Exit
+
+        case 4: // 3rd-party API Management
+            return await showApiManagementMenu();
+
+        case 5: // Language Settings
+            return await showLanguageSettings();
+
+        case 6: // Version Update Check
+            return await showVersionUpdateCheck();
+
+        case 7: // Exit
             console.log('');
-            console.log(colors.green + 'Goodbye!' + colors.reset);
+            console.log(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset);
             process.exit(0);
             break;
+
+        default:
+            showMenu();
+            break;
     }
 }
 
-// Initialize menu
-function showMenu() {
-    displayMenu();
-    
-    // Check if we're in a TTY environment
-    if (process.stdin.isTTY) {
-        // Set up raw mode for capturing arrow keys
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-        
-        process.stdin.on('data', (key) => {
-            handleKeyPress(key);
-        });
+/**
+ * Show main menu
+ */
+async function showMenu() {
+    // Force cleanup stdin state before showing main menu
+    forceStdinCleanup();
+
+    // Ensure global menus are initialized
+    initializeGlobalMenus();
+
+    // ========================================
+    // Version check configuration (hardcoded, modify as needed)
+    // ========================================
+    const ALWAYS_SHOW_VERSION = false;           // Version display toggle: true=always show, false=only show updates
+    const VERSION_CHECK_INTERVAL_HOURS = 12;    // Version check interval (hours): modify this to adjust check frequency
+
+    // Check for updates and prepare version info string
+    let versionInfo = null;
+    try {
+        const updateInfo = await checkForUpdates(false, VERSION_CHECK_INTERVAL_HOURS);
+
+        // Use hardcoded switch instead of config file settings
+        const shouldShowVersion = ALWAYS_SHOW_VERSION || updateInfo.available;
+
+        if (shouldShowVersion) {
+            if (updateInfo.available) {
+                // Display update notification (Claude Code style)
+                versionInfo = colors.yellow + '  ⚠️  ' + i18n.tSync('version.update_available', updateInfo.latestVersion, updateInfo.currentVersion) + colors.reset + '\n' +
+                             colors.yellow + '     ' + i18n.tSync('version.install_command') + colors.reset;
+            } else if (ALWAYS_SHOW_VERSION) {
+                // Display current version info (always show mode)
+                versionInfo = colors.cyan + '  ℹ️  ' + i18n.tSync('version.current_version_info', updateInfo.currentVersion, updateInfo.latestVersion) + colors.reset + '\n' +
+                             colors.yellow + '     ' + i18n.tSync('version.install_command') + colors.reset;
+            }
+        }
+    } catch (error) {
+        // Silently ignore update check errors
+    }
+
+    // Populate menu options dynamically with i18n translations
+    menuOptions = [
+        await i18n.t('menu.main.launch_default'),
+        await i18n.t('menu.main.launch_skip'),
+        await i18n.t('menu.main.launch_api'),
+        await i18n.t('menu.main.launch_api_skip'),
+        await i18n.t('menu.main.api_management'),
+        await i18n.t('menu.main.language_settings'),
+        await i18n.t('menu.main.version_check'),
+        await i18n.t('menu.main.exit')
+    ];
+
+    globalMainMenu.setOptions(menuOptions);
+    const selection = await globalMainMenu.navigate(false, versionInfo); // Pass version info to display between banner and nav
+
+    if (selection === -1) {
+        console.log('');
+        console.log(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset);
+        process.exit(0);
     } else {
-        // Fallback for non-TTY environments - use readline
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        
-        console.log(colors.yellow + '  Arrow keys not available. Enter selection number (1-5): ' + colors.reset);
-        
-        rl.on('line', (input) => {
-            const choice = parseInt(input.trim());
-            if (choice >= 1 && choice <= menuOptions.length) {
-                selectedIndex = choice - 1;
-                rl.close();
-                executeSelection();
-            } else if (input.toLowerCase() === 'q' || input.toLowerCase() === 'exit') {
-                rl.close();
+        await executeSelection(selection);
+    }
+}
+
+
+
+
+
+/**
+ * Export configuration with password encryption
+ */
+async function exportConfiguration() {
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '💾 ' + await i18n.t('import_export.export.title') + colors.reset);
+    console.log('');
+
+    // Add export function description
+    console.log(colors.cyan + '📄 ' + i18n.tSync('import_export.export.description_title') + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[1] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[2] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[3] + colors.reset);
+    console.log('');
+
+    // Verify password before export
+    const verified = await verifyExportPassword(apiManager, 'export');
+    if (!verified) {
+        console.log('');
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+        return;
+    }
+
+    try {
+        // Get export data
+        const exportData = apiManager.exportConfigAuthenticated();
+
+        // Prepare file path
+        const exportDir = getExportDirectory();
+        const filename = generateExportFilename();
+        const filePath = path.join(exportDir, filename);
+
+        // Write JSON file
+        fs.writeFileSync(filePath, exportData, 'utf8');
+
+        console.log(colors.green + '✓ ' + i18n.tSync('import_export.export.success_title') + colors.reset);
+        console.log('');
+        console.log(colors.cyan + '📁 ' + i18n.tSync('import_export.export.details_title') + colors.reset);
+        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_file_saved', filePath) + colors.reset);
+        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_export_dir', exportDir) + colors.reset);
+        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_filename', filename) + colors.reset);
+        console.log('');
+
+        // Open file with default application
+        console.log(colors.yellow + '🔍 ' + i18n.tSync('import_export.export.opening_file') + colors.reset);
+        openFileWithDefault(filePath);
+
+        console.log('');
+        console.log(colors.cyan + '💡 ' + i18n.tSync('import_export.export.tips_title') + colors.reset);
+        console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[0] + colors.reset);
+        console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[1] + colors.reset);
+
+    } catch (error) {
+        forceStdinCleanup();
+        console.log(colors.red + `❌ Export failed: ${error.message}` + colors.reset);
+    }
+
+    console.log('');
+    await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+}
+
+/**
+ * Import configuration from plaintext JSON
+ */
+async function importConfiguration() {
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '📥 ' + await i18n.t('import_export.import.title') + colors.reset);
+    console.log('');
+
+    // Add import function description
+    console.log(colors.cyan + '📄 ' + i18n.tSync('ui.general.import_function_description') + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[0] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[1] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[2] + colors.reset);
+    console.log('');
+
+    // Verify password identity
+    const passwordVerified = await verifyExportPassword(apiManager, 'import');
+    if (!passwordVerified) {
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+        return;
+    }
+
+    console.log('');
+    console.log(colors.cyan + '📁 ' + i18n.tSync('ui.general.file_input_required') + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[0] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[1] + colors.reset);
+    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[2] + colors.reset);
+    console.log('');
+
+    const { simpleInput } = require('./lib/ui/prompts');
+
+    let attempts = 0;
+    const maxAttempts = 3;
+
+    while (attempts < maxAttempts) {
+        attempts++;
+
+        // Get file path from user
+        const filePrompt = i18n.tSync('ui.general.enter_json_file_path_attempt', attempts, maxAttempts);
+        const filePath = await simpleInput(colors.green + filePrompt + colors.reset);
+
+        if (!filePath) {
+            console.log(colors.red + i18n.tSync('ui.general.file_path_empty') + colors.reset);
+            if (attempts < maxAttempts) {
                 console.log('');
-                console.log(colors.green + 'Goodbye!' + colors.reset);
-                process.exit(0);
+                continue;
             } else {
-                console.log(colors.red + '  Invalid selection. Please enter 1-5.' + colors.reset);
+                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset);
+                await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+                return;
             }
-        });
+        }
+
+        // Validate file
+        console.log('');
+        console.log(colors.yellow + i18n.tSync('ui.general.validating_file') + colors.reset);
+        const validation = validateImportFile(filePath);
+
+        if (!validation.valid) {
+            console.log(colors.red + '❌ ' + i18n.tSync('ui.general.file_validation_failed', validation.error) + colors.reset);
+            if (attempts < maxAttempts) {
+                console.log(colors.yellow + i18n.tSync('ui.general.check_file_path_json') + colors.reset);
+                console.log('');
+                continue;
+            } else {
+                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset);
+                await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+                return;
+            }
+        }
+
+        // File is valid, proceed with import
+        console.log(colors.green + i18n.tSync('ui.general.file_validation_successful') + colors.reset);
+        console.log('');
+
+        try {
+            // Import the validated configuration data
+            const result = apiManager.importConfigAuthenticated(validation.data);
+
+            console.log(colors.green + i18n.tSync('ui.general.import_successful') + colors.reset);
+            console.log('');
+            console.log(colors.cyan + i18n.tSync('ui.general.import_statistics') + colors.reset);
+            const importItems = i18n.tSync('ui.general.import_stats_items');
+            console.log(colors.gray + `  • ` + importItems[0].replace('{0}', result.imported) + colors.reset);
+            console.log(colors.gray + `  • ` + importItems[1].replace('{1}', result.skipped) + colors.reset);
+            console.log(colors.gray + `  • ` + importItems[2] + colors.reset);
+            console.log(colors.gray + `  • ` + importItems[3].replace('{0}', path.resolve(filePath)) + colors.reset);
+
+            break; // Success, exit the loop
+
+        } catch (error) {
+            forceStdinCleanup();
+            console.log(colors.red + `❌ Import failed: ${error.message}` + colors.reset);
+            if (attempts < maxAttempts) {
+                console.log(colors.yellow + i18n.tSync('ui.general.import_tips')[0] + colors.reset);
+                console.log('');
+                continue;
+            } else {
+                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_failed') + colors.reset);
+            }
+        }
     }
+
+    console.log('');
+    await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
 }
 
-// Handle process termination
-process.on('SIGINT', () => {
+/**
+ * Change password
+ */
+async function changePassword() {
+    console.clear();
     console.log('');
-    console.log(colors.green + 'Goodbye!' + colors.reset);
-    process.exit(0);
-});
+    console.log(colors.bright + colors.orange + '🔑 ' + i18n.tSync('errors.password.change_password_title') + colors.reset);
+    console.log('');
+
+    // Use unified password change module
+    const success = await changePasswordModule(apiManager);
+
+    if (success) {
+        console.log('');
+    }
+
+    await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+}
+
+/**
+ * Show language settings menu
+ */
+async function showLanguageSettings() {
+    try {
+        const supportedLanguages = i18n.getSupportedLanguages();
+        const currentLanguage = i18n.getCurrentLanguage();
+        const currentLanguageName = i18n.getCurrentLanguageName();
+
+        console.clear();
+        console.log('');
+        console.log(colors.bright + colors.orange + '🌍 ' + await i18n.t('menu.language.title') + colors.reset);
+        console.log('');
+
+        // Show current language
+        console.log(colors.cyan + await i18n.t('menu.language.current', currentLanguageName) + colors.reset);
+        console.log('');
+        console.log(colors.yellow + await i18n.t('menu.language.select_prompt') + colors.reset);
+        console.log('');
+
+        // Create menu options
+        const languageOptions = [];
+        const languageCodes = Object.keys(supportedLanguages);
+
+        languageCodes.forEach(langCode => {
+            const isActive = langCode === currentLanguage;
+            const displayName = supportedLanguages[langCode];
+            languageOptions.push(isActive ? `● ${displayName}` : `  ${displayName}`);
+        });
+
+        languageOptions.push(await i18n.t('menu.language.back'));
+
+        // Ensure global menus are initialized
+        initializeGlobalMenus();
+
+        globalApiManagementMenu.setOptions(languageOptions);
+        const choice = await globalApiManagementMenu.navigate();
+
+        if (choice === -1 || choice === languageOptions.length - 1) {
+            // Back to main menu
+            return showMenu();
+        }
+
+        // Check if user selected current language
+        const selectedLangCode = languageCodes[choice];
+        if (selectedLangCode === currentLanguage) {
+            // Already current language, return to main menu
+            return showMenu();
+        }
+
+        // Switch language
+        console.clear();
+            console.log('');
+            console.log(colors.yellow + await i18n.t('status.switching_language') + colors.reset);
+
+            try {
+                await i18n.setLanguage(selectedLangCode);
+
+                console.clear();
+                const newLanguageName = i18n.getCurrentLanguageName();
+                showSuccess(await i18n.t('messages.success.language_changed'), [
+                    await i18n.t('menu.language.changed_success', newLanguageName)
+                ]);
+
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+
+                // Return to main menu after successful language change
+                return showMenu();
+
+            } catch (error) {
+                showError(await i18n.t('errors.general.operation_failed', error.message));
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+                return showMenu();
+            }
+
+    } catch (error) {
+        showError('Failed to show language settings', [error.message]);
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+        return showMenu();
+    }
+}
+
+/**
+ * Show version update check screen
+ */
+async function showVersionUpdateCheck() {
+    try {
+        console.clear();
+        console.log('');
+        console.log(colors.bright + colors.orange + '🔄 ' + await i18n.t('version_check.title') + colors.reset);
+        console.log('');
 
+        console.log(colors.cyan + await i18n.t('version_check.checking') + colors.reset);
+        console.log(colors.gray + await i18n.t('version_check.please_wait') + colors.reset);
+        console.log('');
+
+        // Show progress indicator
+        const progressInterval = setInterval(() => {
+            process.stdout.write('.');
+        }, 500);
+
+        try {
+            // Force check with 15 second timeout
+            const result = await forceCheckForUpdates(15000);
+
+            // Stop progress indicator
+            clearInterval(progressInterval);
+            console.log('\n');
+
+            if (result.error) {
+                // Handle errors (timeout, network, etc.)
+                console.log(colors.red + '❌ ' + await i18n.t('version_check.error') + colors.reset);
+                console.log(colors.red + '   ' + result.error + colors.reset);
+                console.log('');
+                console.log(colors.gray + await i18n.t('version_check.error_tips') + colors.reset);
+            } else if (result.available) {
+                // Update available
+                console.log(colors.yellow + '🎉 ' + await i18n.t('version_check.update_available') + colors.reset);
+                console.log('');
+                console.log(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset);
+                console.log(colors.green + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset);
+                console.log('');
+                console.log(colors.yellow + '💡 ' + await i18n.t('version_check.update_command') + colors.reset);
+                console.log(colors.yellow + '   npm update -g @kikkimo/claude-launcher' + colors.reset);
+            } else {
+                // Already up to date
+                console.log(colors.green + '✅ ' + await i18n.t('version_check.up_to_date') + colors.reset);
+                console.log('');
+                console.log(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset);
+                console.log(colors.cyan + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset);
+            }
+
+        } catch (error) {
+            // Stop progress indicator
+            clearInterval(progressInterval);
+            console.log('\n');
+
+            console.log(colors.red + '❌ ' + await i18n.t('version_check.unexpected_error') + colors.reset);
+            console.log(colors.red + '   ' + error.message + colors.reset);
+        }
+
+        console.log('');
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return showMenu();
+
+    } catch (error) {
+        console.log(colors.red + '❌ Failed to check version: ' + error.message + colors.reset);
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+        return showMenu();
+    }
+}
+
+// End of API Management functions
+
+/**
+ * Graceful shutdown handlers
+ */
 process.on('SIGTERM', () => {
     console.log('');
-    console.log(colors.green + 'Goodbye!' + colors.reset);
+    console.log(colors.green + i18n.tSync('ui.general.goodbye') + colors.reset);
     process.exit(0);
 });
 
+// Global SIGINT handler (Ctrl+C) - fallback for non-raw mode Ctrl+C
+// In raw mode, Ctrl+C is handled by StdinManager directly
+// This handler catches Ctrl+C in line mode (e.g., during readline input)
+const stdinManager = require('./lib/utils/stdin-manager');
+
+// Flag to prevent re-entrance of SIGINT handler
+let exiting = false;
+
+process.on('SIGINT', () => {
+    // During Claude run, ignore in launcher so child handles it
+    // Check this BEFORE setting exiting flag to avoid breaking reentrancy protection
+    if (stdinManager.isSuspended && stdinManager.isSuspended()) {
+        return;
+    }
+
+    // Prevent re-entrance - ensure cleanup runs only once
+    if (exiting) {
+        return;
+    }
+    exiting = true;
+
+    // Try to reset stdin state before handling
+    try {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+    } catch (_) {
+        // Ignore errors during emergency cleanup
+    }
+
+    // Use unified Ctrl+C handler from StdinManager (synchronous)
+    try {
+        stdinManager.handleCtrlC();
+    } catch (_) {
+        // Ignore errors during Ctrl+C handling
+    }
+
+    // Exit with standard SIGINT exit code (128 + 2 = 130)
+    // Note: If handleCtrlC() calls process.exit(0) for second Ctrl+C,
+    // this line won't be reached, which is expected behavior
+    process.exit(130);
+});
+
+// Initialize global menus and start the application
+initializeGlobalMenus();
+
 // Start the application
-showMenu();
+showMenu();