@kikkimo/claude-launcher 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-07-20
+
+### Added
+- Initial release of Claude Launcher
+- Interactive menu with Claude-style orange/amber interface
+- Arrow key navigation with fallback to number selection
+- **AES-256-CBC Encryption**: Industry-standard encryption for API keys
+- **Machine-specific Encryption Keys**: Keys derived from machine-specific data
+- **Interactive API Key Setup**: Guided setup with copy/paste support and validation
+- **Retry Logic**: Allow users to re-enter invalid API keys without restarting
+- **Clean Process Handoff**: Claude runs in current terminal with clean environment
+- **Enhanced Error Handling**: Improved error messages and recovery mechanisms
+- **Security Explanations**: Clear explanations of encryption and local storage
+- Multiple Claude Code launch options:
+  - Standard launch
+  - Skip permissions mode
+  - Kimi K2 API integration
+  - Combined Kimi API with skip permissions
+- Smart configuration file detection across multiple locations
+- Cross-platform support (Windows, macOS, Linux)
+- Global npm installation support
+- Automatic config file creation with sensible defaults
+- Configuration template file (`claude-launcher-template.env`) for easy setup
+- Enhanced configuration workflow with template-based initialization
+- Multilingual documentation support (English and Chinese)
+- Standardized configuration file naming (`.claude-launcher.env`)
+- Beautiful Claude-style terminal interface
+- Encrypted credential storage
+- Multi-platform TTY/non-TTY environment support
+- Comprehensive error handling and user feedback
+
+### Changed
+- **Simplified Configuration**: Automatic config file creation on first run
+- **Improved Input Handling**: Fixed paste support and character duplication issues
+- **Updated Node.js Requirement**: Minimum Node.js version updated to 20.0.0
+- **Modernized Documentation**: Complete rewrite with Quick Start guide and better structure
+- **Enhanced User Experience**: Clearer prompts and instructions throughout the interface
+
+### Fixed
+- **Input System Overhaul**: Resolved memory leaks and EventEmitter issues
+- **API Key Validation**: Fixed hanging input and validation problems
+- **Process Management**: Resolved issues with Claude not starting in current terminal
+- **Cross-platform Compatibility**: Fixed Windows-specific launching issues
+- **Terminal State Management**: Proper cleanup of terminal settings before Claude launch
+
+### Security
+- **Encrypted Storage**: API keys encrypted with AES-256-CBC instead of legacy methods
+- **Local-only Decryption**: Encrypted keys cannot be decrypted on other machines
+- **Secure Input**: Plaintext input with proper validation and error handling
+- **Machine Binding**: Encryption keys tied to specific machine characteristics

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FangYi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,177 @@
+# Claude Launcher
+
+An elegant interactive launcher for Claude Code with a beautiful Claude-style interface. Launch Claude Code with various configurations through an intuitive command-line menu.
+
+## 📖 Documentation
+
+- [English](README.md) (Current)
+- [中文文档](docs/README-zh.md)
+
+## ✨ Features
+
+- 🎨 **Claude-style interface** with authentic orange/amber color scheme
+- ⌨️ **Arrow key navigation** with fallback to number selection
+- 🔐 **Encrypted API key storage** using AES-256-CBC encryption
+- 🚀 **Multiple launch options** including permission skipping and Kimi K2 API
+- 🌍 **Global installation** - use `claude-launcher` from anywhere
+- 🔧 **Smart configuration** - automatically finds/creates config files
+- 💻 **Cross-platform** - Windows, macOS, and Linux support
+
+## 🚀 Quick Start
+
+1. **Install globally:**
+   ```bash
+   npm install -g @kikkimo/claude-launcher
+   ```
+
+2. **Run the launcher:**
+   ```bash
+   claude-launcher
+   ```
+
+3. **For Kimi API users:** When prompted for the first time, enter your Kimi API key starting with `sk-`
+
+That's it! The launcher will guide you through the setup process.
+
+## 📦 Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @kikkimo/claude-launcher
+```
+
+After installation, you can run `claude-launcher` from any directory.
+
+### Local Installation
+
+```bash
+git clone https://github.com/kikkimo/claude-launcher.git
+cd claude-launcher
+npm install
+node claude-launcher
+```
+
+## 🎮 Usage
+
+### Available Launch Options
+
+1. **Launch Claude Code** - Standard Claude Code launch
+2. **Launch Claude Code (Skip Permissions)** - Launch with `--dangerously-skip-permissions`
+3. **Launch Claude Code with Kimi K2 API** - Use Kimi API with encrypted storage
+4. **Launch Claude Code with Kimi K2 API (Skip Permissions)** - Combine Kimi API with permission skipping
+5. **Exit** - Close the launcher
+
+### Interactive Navigation
+
+- **Arrow Keys**: Use ↑↓ to navigate, Enter to select (in TTY environments)
+- **Number Selection**: Type 1-5 and press Enter (in non-TTY environments)
+- **Quick Exit**: Press Esc or Q to quit anytime
+
+### Example Session
+
+```bash
+$ claude-launcher
+
+  ┌────────────────────────────────────────┐
+  │           Claude Code Launcher         │
+  └────────────────────────────────────────┘
+
+  Use ↑↓ arrow keys to navigate, Enter to select
+
+  → 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
+```
+
+## ⚙️ Configuration
+
+### Automatic Configuration
+
+On first run, if you select a Kimi API option and no configuration exists, the launcher will:
+
+1. Automatically create a configuration file at `~/.claude-launcher.env`
+2. Guide you through entering your Kimi API key
+3. Encrypt and store your API key securely using machine-specific encryption
+
+### Manual Configuration
+
+If you prefer to set up manually, the config file locations are searched in this order:
+
+1. `.claude-launcher.env` in current directory
+2. `.claude-launcher.env` in your home directory
+3. `.claude-launcher.env` in the installation directory
+
+### Configuration File Format
+
+```env
+KIMI_API_KEY=your_encrypted_api_key_here
+KIMI_BASE_URL=https://api.moonshot.cn/anthropic/
+```
+
+**Note**: The `KIMI_API_KEY` is automatically encrypted when entered through the launcher. Do not manually edit encrypted values.
+
+### Security Features
+
+- **AES-256-CBC Encryption**: API keys are encrypted using industry-standard encryption
+- **Machine-specific Keys**: Encryption keys are derived from machine-specific data
+- **Local Storage Only**: Encrypted keys cannot be decrypted on other machines
+- **Secure Input**: API key input supports copy/paste and validation
+
+## 📋 Requirements
+
+- **Node.js**: 20.0.0 or higher
+- **Claude Code**: Installed and accessible via `claude` command
+- **Terminal**: Any modern terminal with Node.js support
+
+## 🔧 Development
+
+### Building from Source
+
+```bash
+git clone https://github.com/kikkimo/claude-launcher.git
+cd claude-launcher
+npm install
+```
+
+### Testing Locally
+
+```bash
+npm start
+# or
+node claude-launcher
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please follow these steps:
+
+1. Fork the repository
+2. Create your feature branch: `git checkout -b feature/amazing-feature`
+3. Commit your changes: `git commit -m 'Add amazing feature'`
+4. Push to the branch: `git push origin feature/amazing-feature`
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Inspired by the beautiful design of Claude Code
+- Built with ❤️ for the Claude Code community
+- Thanks to all contributors and users
+
+## 🐛 Issues & Support
+
+If you encounter any issues or have questions:
+
+1. Check existing [Issues](https://github.com/kikkimo/claude-launcher/issues)
+2. Create a new issue with detailed information
+3. Include your operating system, Node.js version, and error messages
+
+---
+
+**Note**: This launcher is designed to work with Claude Code and Kimi K2 API. Make sure you have Claude Code installed before using this tool.

package/claude-launcher

@@ -0,0 +1,679 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+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;
+        }
+    }
+    
+    // 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');
+}
+
+// Encrypt API key using AES-256-CBC
+function encryptApiKey(plaintext) {
+    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
+        };
+    } catch (error) {
+        return {
+            success: false,
+            value: null,
+            error: error.message
+        };
+    }
+}
+
+// Decrypt API key using AES-256-CBC
+function decryptApiKey(encryptedData) {
+    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 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
+        };
+    }
+}
+
+// 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
+    };
+}
+
+// Load configuration from .env file
+function loadConfig() {
+    const config = {};
+    
+    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');
+            try {
+                if (fs.existsSync(templatePath)) {
+                    defaultConfig = fs.readFileSync(templatePath, 'utf8');
+                    console.log(colors.gray + `Using template from: ${templatePath}` + colors.reset);
+                }
+            } 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);
+            }
+            
+            config.KIMI_API_KEY = 'Your_Double_Base64_Encoded_Api_Key';
+            config.KIMI_BASE_URL = 'https://api.moonshot.cn/anthropic/';
+        }
+    } 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/';
+    }
+    
+    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();
+    
+    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);
+        });
+        
+    } 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();
+        });
+    }
+}
+
+// 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());
+        });
+    });
+}
+
+// Prompt user to input API key with simple readline
+async function promptForApiKey() {
+    try {
+        console.clear();
+        console.log('');
+        console.log(colors.bright + colors.orange + '[*] Kimi API Key Setup' + 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);
+        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('');
+        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('');
+        
+        // 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('');
+        
+        // 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
+            }
+            
+            // 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;
+        }
+        
+    } 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;
+    }
+}
+
+// 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
+            };
+        }
+        
+        // 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;
+    }
+}
+
+// Display Claude Code style header
+function displayHeader() {
+    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('');
+}
+
+// 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);
+        }
+    });
+    
+    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;
+    }
+}
+
+// Handle Kimi API launches with async configuration
+async function handleKimiLaunch(command) {
+    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
+        }
+    } 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
+        setTimeout(() => {
+            showMenu();
+        }, 2000);
+    }
+}
+
+// Execute selected menu item
+function executeSelection() {
+    switch (selectedIndex) {
+        case 0: // Launch Claude Code
+            launchClaude('claude');
+            break;
+            
+        case 1: // Launch Claude Code (Skip Permissions)
+            launchClaude('claude --dangerously-skip-permissions');
+            break;
+            
+        case 2: // Launch Claude Code with Kimi K2 API
+            handleKimiLaunch('claude');
+            break;
+            
+        case 3: // Launch Claude Code with Kimi K2 API (Skip Permissions)
+            handleKimiLaunch('claude --dangerously-skip-permissions');
+            break;
+            
+        case 4: // Exit
+            console.log('');
+            console.log(colors.green + 'Goodbye!' + colors.reset);
+            process.exit(0);
+            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);
+        });
+    } 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();
+                console.log('');
+                console.log(colors.green + 'Goodbye!' + colors.reset);
+                process.exit(0);
+            } else {
+                console.log(colors.red + '  Invalid selection. Please enter 1-5.' + colors.reset);
+            }
+        });
+    }
+}
+
+// Handle process termination
+process.on('SIGINT', () => {
+    console.log('');
+    console.log(colors.green + 'Goodbye!' + colors.reset);
+    process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+    console.log('');
+    console.log(colors.green + 'Goodbye!' + colors.reset);
+    process.exit(0);
+});
+
+// Start the application
+showMenu();

package/docs/README-zh.md

@@ -0,0 +1,177 @@
+# Claude Launcher
+
+一个优雅的 Claude Code 交互式启动器，具有美观的 Claude 风格界面。通过直观的命令行菜单使用各种配置启动 Claude Code。
+
+## 📖 文档
+
+- [English](../README.md)
+- [中文文档](README-zh.md) (当前)
+
+## ✨ 特性
+
+- 🎨 **Claude 风格界面** - 采用正宗的橙色/琥珀色配色方案
+- ⌨️ **方向键导航** - 支持方向键导航，非 TTY 环境下支持数字选择
+- 🔐 **加密 API 密钥存储** - 使用 AES-256-CBC 加密
+- 🚀 **多种启动选项** - 包括跳过权限检查和 Kimi K2 API
+- 🌍 **全局安装** - 在任何地方都可以使用 `claude-launcher`
+- 🔧 **智能配置** - 自动查找/创建配置文件
+- 💻 **跨平台支持** - Windows、macOS 和 Linux
+
+## 🚀 快速开始
+
+1. **全局安装:**
+   ```bash
+   npm install -g @kikkimo/claude-launcher
+   ```
+
+2. **运行启动器:**
+   ```bash
+   claude-launcher
+   ```
+
+3. **Kimi API 用户:** 首次使用时，输入以 `sk-` 开头的 Kimi API 密钥
+
+就这么简单！启动器会引导您完成设置过程。
+
+## 📦 安装
+
+### 全局安装（推荐）
+
+```bash
+npm install -g @kikkimo/claude-launcher
+```
+
+安装后，您可以在任何目录运行 `claude-launcher`。
+
+### 本地安装
+
+```bash
+git clone https://github.com/kikkimo/claude-launcher.git
+cd claude-launcher
+npm install
+node claude-launcher
+```
+
+## 🎮 使用方法
+
+### 可用的启动选项
+
+1. **启动 Claude Code** - 标准 Claude Code 启动
+2. **启动 Claude Code（跳过权限）** - 使用 `--dangerously-skip-permissions` 启动
+3. **使用 Kimi K2 API 启动 Claude Code** - 使用加密存储的 Kimi API
+4. **使用 Kimi K2 API 启动 Claude Code（跳过权限）** - 结合 Kimi API 和跳过权限
+5. **退出** - 关闭启动器
+
+### 交互式导航
+
+- **方向键**：使用 ↑↓ 导航，Enter 选择（在 TTY 环境中）
+- **数字选择**：输入 1-5 并按 Enter（在非 TTY 环境中）
+- **快速退出**：随时按 Esc 或 Q 退出
+
+### 示例会话
+
+```bash
+$ claude-launcher
+
+  ┌────────────────────────────────────────┐
+  │           Claude Code Launcher         │
+  └────────────────────────────────────────┘
+
+  Use ↑↓ arrow keys to navigate, Enter to select
+
+  → 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
+```
+
+## ⚙️ 配置
+
+### 自动配置
+
+首次运行时，如果您选择 Kimi API 选项且没有现有配置，启动器将：
+
+1. 自动在 `~/.claude-launcher.env` 创建配置文件
+2. 引导您输入 Kimi API 密钥
+3. 使用机器特定的加密安全存储您的 API 密钥
+
+### 手动配置
+
+如果您更喜欢手动设置，配置文件搜索顺序如下：
+
+1. 当前目录中的 `.claude-launcher.env`
+2. 用户主目录中的 `.claude-launcher.env`
+3. 安装目录中的 `.claude-launcher.env`
+
+### 配置文件格式
+
+```env
+KIMI_API_KEY=your_encrypted_api_key_here
+KIMI_BASE_URL=https://api.moonshot.cn/anthropic/
+```
+
+**注意**: `KIMI_API_KEY` 通过启动器输入时会自动加密。请勿手动编辑加密值。
+
+### 安全功能
+
+- **AES-256-CBC 加密**: 使用行业标准加密算法加密 API 密钥
+- **机器特定密钥**: 加密密钥从机器特定数据派生
+- **仅本地存储**: 加密密钥无法在其他机器上解密
+- **安全输入**: API 密钥输入支持复制/粘贴和验证
+
+## 📋 系统要求
+
+- **Node.js**: 20.0.0 或更高版本
+- **Claude Code**: 已安装并可通过 `claude` 命令访问
+- **终端**: 任何支持 Node.js 的现代终端
+
+## 🔧 开发
+
+### 从源码构建
+
+```bash
+git clone https://github.com/kikkimo/claude-launcher.git
+cd claude-launcher
+npm install
+```
+
+### 本地测试
+
+```bash
+npm start
+# 或者
+node claude-launcher
+```
+
+## 🤝 贡献
+
+我们欢迎贡献！请遵循以下步骤：
+
+1. Fork 这个仓库
+2. 创建您的功能分支：`git checkout -b feature/amazing-feature`
+3. 提交您的更改：`git commit -m 'Add amazing feature'`
+4. 推送到分支：`git push origin feature/amazing-feature`
+5. 打开一个 Pull Request
+
+## 📄 许可证
+
+此项目基于 MIT 许可证 - 查看 [LICENSE](../LICENSE) 文件了解详情。
+
+## 🙏 致谢
+
+- 灵感来源于 Claude Code 的精美设计
+- 用 ❤️ 为 Claude Code 社区构建
+- 感谢所有贡献者和用户
+
+## 🐛 问题与支持
+
+如果您遇到任何问题或有疑问：
+
+1. 查看现有的 [Issues](https://github.com/kikkimo/claude-launcher/issues)
+2. 创建新问题并提供详细信息
+3. 包含您的操作系统、Node.js 版本和错误消息
+
+---
+
+**注意**: 此启动器设计用于 Claude Code 和 Kimi K2 API。使用此工具前请确保已安装 Claude Code。

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@kikkimo/claude-launcher",
+  "version": "1.0.0",
+  "description": "Interactive launcher for Claude Code with beautiful Claude-style interface",
+  "main": "claude-launcher",
+  "bin": {
+    "claude-launcher": "./claude-launcher"
+  },
+  "scripts": {
+    "start": "node claude-launcher",
+    "test": "echo \"No tests specified\" && exit 0",
+    "prepublishOnly": "echo \"Publishing claude-launcher...\"",
+    "postinstall": "echo \"Claude Launcher installed successfully! Run 'claude-launcher' to start.\"",
+    "publish:public": "npm publish --access public"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "claude-launcher",
+    "claude-launcher-template.env",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "docs/"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "launcher",
+    "cli",
+    "interactive",
+    "menu",
+    "anthropic",
+    "kimi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kikkimo/claude-launcher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kikkimo/claude-launcher/issues"
+  },
+  "homepage": "https://github.com/kikkimo/claude-launcher#readme",
+  "author": "kikkimo <fywhu@qq.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "preferGlobal": true,
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}