@kikkimo/claude-launcher 1.0.0 → 2.0.0

package/lib/launcher.js

@@ -0,0 +1,253 @@
+/**
+ * Launcher Module - Handles Claude Code launching with various configurations
+ */
+
+const { spawn } = require('child_process');
+const colors = require('./ui/colors');
+const i18n = require('./i18n');
+
+/**
+ * Launch Claude Code with specified environment variables
+ */
+function launchClaude(command, envVars = {}, disableAuthTokens = false) {
+    console.log('');
+    console.log(colors.yellow + '🚀 ' + i18n.tSync('launch.starting') + colors.reset);
+    console.log(colors.gray + i18n.tSync('launch.command', command) + colors.reset);
+
+    if (Object.keys(envVars).length > 0) {
+        console.log(colors.gray + i18n.tSync('launch.environment_variables') + colors.reset);
+        for (const [key, value] of Object.entries(envVars)) {
+            if (key.includes('TOKEN') || key.includes('KEY')) {
+                console.log(colors.gray + `  ${key}=***` + colors.reset);
+            } else {
+                console.log(colors.gray + `  ${key}=${value}` + colors.reset);
+            }
+        }
+    }
+
+    console.log('');
+    console.log(colors.green + '✓ ' + i18n.tSync('launch.run_in_terminal') + colors.reset);
+    console.log(colors.gray + '  ' + i18n.tSync('launch.launcher_exit') + colors.reset);
+    console.log('');
+
+    // Prepare clean environment
+    const env = { ...process.env, ...envVars };
+
+    // Disable conflicting auth tokens when using third-party API
+    if (disableAuthTokens) {
+        // Only delete CLAUDE_CODE_OAUTH_TOKEN - keep ANTHROPIC_AUTH_TOKEN that we just set
+        delete env.CLAUDE_CODE_OAUTH_TOKEN;
+        console.log(colors.gray + '  Disabled: 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',
+            env: env,
+            cwd: process.cwd(),
+            shell: true
+        });
+
+        // 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 + i18n.tSync('ui.general.press_key_return_menu') + colors.reset);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once('data', () => {
+            process.stdin.setRawMode(false);
+            // Note: Caller should handle menu display
+        });
+    }
+}
+
+/**
+ * Launch Claude with default settings
+ */
+function launchClaudeDefault() {
+    launchClaude('claude');
+}
+
+/**
+ * Launch Claude with skip permissions flag
+ */
+function launchClaudeSkipPermissions() {
+    launchClaude('claude --dangerously-skip-permissions');
+}
+
+/**
+ * Get environment variables based on provider type
+ */
+function getProviderEnvVars(api) {
+    // Decrypt the auth token (all tokens are stored encrypted)
+    const { decrypt } = require('./crypto');
+    const decrypted = decrypt(api.authToken);
+
+    if (!decrypted.success) {
+        console.error('Failed to decrypt auth token:', decrypted.error);
+        throw new Error('Failed to decrypt API auth token. Please check your configuration.');
+    }
+
+    const authToken = decrypted.value;
+
+    const baseEnvVars = {
+        ANTHROPIC_BASE_URL: api.baseUrl,
+        ANTHROPIC_AUTH_TOKEN: authToken,
+        ANTHROPIC_MODEL: api.model,
+        ANTHROPIC_SMALL_FAST_MODEL: api.smallFastModel || api.model
+    };
+
+    // Add provider-specific environment variables
+    switch (api.provider) {
+        case 'deepseek':
+            return {
+                ...baseEnvVars,
+                API_TIMEOUT_MS: '600000',
+                CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            };
+
+        case 'moonshot':
+        case 'anthropic':
+        case 'custom':
+        default:
+            return baseEnvVars;
+    }
+}
+
+/**
+ * Launch Claude with third-party API configuration
+ */
+function launchClaudeWithApi(api, skipPermissions = false) {
+    const command = skipPermissions
+        ? 'claude --dangerously-skip-permissions'
+        : 'claude';
+
+    const envVars = getProviderEnvVars(api);
+
+    console.log('');
+    console.log(colors.bright + colors.orange + '🔗 ' + i18n.tSync('launch.using_third_party_api') + colors.reset);
+    console.log(colors.gray + `  Provider: ${api.provider || 'Custom'}` + colors.reset);
+    console.log(colors.gray + `  API: ${api.name}` + colors.reset);
+    console.log(colors.gray + `  Base URL: ${api.baseUrl}` + colors.reset);
+    console.log(colors.gray + `  Model: ${api.model}` + colors.reset);
+
+    // Show provider-specific optimizations
+    if (api.provider === 'deepseek') {
+        console.log(colors.yellow + '  ⚡ ' + i18n.tSync('launch.deepseek_optimizations') + colors.reset);
+        console.log(colors.gray + '    • ' + i18n.tSync('launch.extended_timeout') + colors.reset);
+        console.log(colors.gray + '    • ' + i18n.tSync('launch.non_essential_disabled') + colors.reset);
+    }
+
+    console.log('');
+
+    launchClaude(command, envVars, true);
+}
+
+/**
+ * Test API connection
+ */
+async function testApiConnection(api) {
+    console.log(colors.yellow + '🔍 Testing API connection...' + colors.reset);
+
+    try {
+        // Handle both plaintext (during testing) and encrypted tokens (from stored APIs)
+        let authToken = api.authToken;
+
+        // Try to decrypt if it looks like an encrypted token
+        if (typeof authToken === 'string' && authToken.includes(':')) {
+            const { decrypt } = require('./crypto');
+            const decrypted = decrypt(authToken);
+
+            if (decrypted.success) {
+                authToken = decrypted.value;
+            }
+            // If decryption fails but token contains ':', it might be encrypted but corrupted
+            else if (authToken.split(':').length === 3) {
+                console.error('Failed to decrypt auth token for testing:', decrypted.error);
+                return { success: false, error: 'Failed to decrypt auth token' };
+            }
+            // Otherwise, treat as plaintext token
+        }
+
+        // Try to make a simple request to test the connection
+        const https = require('https');
+        const url = new URL(api.baseUrl);
+
+        return new Promise((resolve) => {
+            const options = {
+                hostname: url.hostname,
+                port: url.port || 443,
+                path: url.pathname,
+                method: 'GET',
+                timeout: 5000,
+                headers: {
+                    'Authorization': `Bearer ${authToken}`
+                }
+            };
+
+            const req = https.request(options, (res) => {
+                if (res.statusCode === 401) {
+                    console.log(colors.yellow + '⚠️  API returned 401 - Check your auth token' + colors.reset);
+                    resolve({ success: false, error: 'Authentication failed' });
+                } else if (res.statusCode >= 200 && res.statusCode < 500) {
+                    console.log(colors.green + '✓ API is reachable' + colors.reset);
+                    resolve({ success: true });
+                } else {
+                    console.log(colors.red + `❌ API returned status ${res.statusCode}` + colors.reset);
+                    resolve({ success: false, error: `HTTP ${res.statusCode}` });
+                }
+            });
+
+            req.on('error', (error) => {
+                console.log(colors.red + `❌ Connection failed: ${error.message}` + colors.reset);
+                resolve({ success: false, error: error.message });
+            });
+
+            req.on('timeout', () => {
+                console.log(colors.red + '❌ Connection timeout' + colors.reset);
+                req.destroy();
+                resolve({ success: false, error: 'Timeout' });
+            });
+
+            req.end();
+        });
+    } catch (error) {
+        console.log(colors.red + `❌ Test failed: ${error.message}` + colors.reset);
+        return { success: false, error: error.message };
+    }
+}
+
+module.exports = {
+    launchClaude,
+    launchClaudeDefault,
+    launchClaudeSkipPermissions,
+    launchClaudeWithApi,
+    getProviderEnvVars,
+    testApiConnection
+};

package/lib/presets/providers.js

@@ -0,0 +1,104 @@
+/**
+ * API Providers Presets - Claude Code compatible API providers
+ *
+ * Note: Only includes APIs that are compatible with Claude Code's Anthropic API format
+ */
+
+const providers = {
+    anthropic: {
+        name: 'Anthropic (Official)',
+        baseUrl: 'https://api.anthropic.com',
+        models: [
+            'claude-3-5-haiku-20241022',
+            'claude-3.7-sonnet',
+            'claude-sonnet-4',
+            'claude-opus-4',
+            'claude-opus-4.1'
+        ],
+        authTokenFormat: 'sk-ant-api03-...',
+        description: 'Official Anthropic API - Fully compatible',
+        requiresToken: true,
+        compatibility: 'native'
+    },
+    moonshot: {
+        name: 'Moonshot AI (Kimi-K2)',
+        baseUrl: 'https://api.moonshot.cn/anthropic',
+        models: [
+            'kimi-k2-0711-preview',
+            'kimi-k2-0905-preview',
+            'kimi-k2-turbo-preview'
+        ],
+        authTokenFormat: 'sk-...',
+        description: 'Moonshot AI - Provides Anthropic-compatible API',
+        requiresToken: true,
+        compatibility: 'anthropic-compatible'
+    },
+    deepseek: {
+        name: 'DeepSeek (DeepSeek V3/V3.1)',
+        baseUrl: 'https://api.deepseek.com/anthropic',
+        models: [
+            'deepseek-chat'
+        ],
+        authTokenFormat: 'sk-...',
+        description: 'DeepSeek AI - Anthropic-compatible endpoint',
+        requiresToken: true,
+        compatibility: 'anthropic-compatible'
+    },
+    custom: {
+        name: 'Custom Anthropic-Compatible API',
+        baseUrl: 'https://your-api-server.com/v1/anthropic',
+        models: [
+            'your-model-name'
+        ],
+        authTokenFormat: 'Bearer token or API key',
+        description: 'Custom server with Anthropic-compatible API',
+        requiresToken: true,
+        compatibility: 'anthropic-compatible',
+        note: 'Replace URL and model with your actual server details'
+    }
+};
+
+/**
+ * Get all available providers
+ */
+function getAllProviders() {
+    return Object.keys(providers).map(key => ({
+        id: key,
+        ...providers[key]
+    }));
+}
+
+/**
+ * Get a specific provider by ID
+ */
+function getProvider(providerId) {
+    return providers[providerId] || null;
+}
+
+/**
+ * Get suggested models for a provider
+ */
+function getSuggestedModels(providerId) {
+    const provider = providers[providerId];
+    return provider ? provider.models : [];
+}
+
+/**
+ * Validate if a URL matches a known provider
+ */
+function detectProvider(baseUrl) {
+    for (const [key, provider] of Object.entries(providers)) {
+        if (baseUrl.includes(provider.baseUrl.replace('https://', '').replace('http://', '').split('/')[0])) {
+            return key;
+        }
+    }
+    return 'custom';
+}
+
+module.exports = {
+    providers,
+    getAllProviders,
+    getProvider,
+    getSuggestedModels,
+    detectProvider
+};

package/lib/ui/colors.js

@@ -0,0 +1,32 @@
+/**
+ * Colors Module - ANSI color codes for Claude-style theming
+ */
+
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+
+    // Claude theme colors
+    orange: '\x1b[38;5;208m',      // Claude brand orange
+    amber: '\x1b[38;5;214m',       // Amber/yellow-orange
+
+    // Standard colors
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    black: '\x1b[30m',
+
+    // Background colors
+    bgOrange: '\x1b[48;5;208m',    // Background orange
+    bgAmber: '\x1b[48;5;214m',     // Background amber
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgBlue: '\x1b[44m'
+};
+
+module.exports = colors;

package/lib/ui/interactive-table.js

@@ -0,0 +1,260 @@
+/**
+ * Simple Interactive Table Test - Minimal version for testing clearing
+ */
+
+const colors = require('./colors');
+const { maskApiToken } = require('../validators');
+const { decrypt } = require('../crypto');
+const i18n = require('../i18n');
+const { padStringToWidth } = require('../utils/string-width');
+
+/**
+ * Display simple interactive table for API selection
+ */
+async function showApiSelectionTable(apis, title, actionType = 'select', activeIndex = -1, apiManager = null) {
+    if (apis.length === 0) {
+        console.clear();
+        console.log('');
+        console.log(colors.yellow + 'ℹ️  ' + i18n.tSync('messages.info.no_apis_info_title') + colors.reset);
+        console.log(colors.gray + '  ' + i18n.tSync('messages.info.apis_removed_or_none') + colors.reset);
+        console.log('');
+        console.log(colors.gray + i18n.tSync('messages.info.press_return_menu') + colors.reset);
+
+        await waitForKeyPress();
+        return null;
+    }
+
+    let selectedIndex = 0;
+    if (actionType === 'switch' && activeIndex >= 0 && activeIndex < apis.length) {
+        selectedIndex = activeIndex;
+    }
+
+    function displaySimpleTable() {
+        // Header info
+        console.log('');
+        console.log(colors.cyan + title + colors.reset);
+        console.log('');
+
+        // Show current active API for switch mode
+        if (actionType === 'switch' && activeIndex >= 0 && activeIndex < apis.length) {
+            const activeApi = apis[activeIndex];
+            console.log(colors.gray + i18n.tSync('ui.general.currently_active_api') + colors.reset);
+            console.log(colors.gray + `  Name: ${activeApi.name}` + colors.reset);
+            console.log(colors.gray + `  Provider: ${activeApi.provider}` + colors.reset);
+            console.log(colors.gray + `  Usage Count: ${activeApi.usageCount || 0}` + colors.reset);
+            console.log('');
+        }
+
+        // Table header with 3-column layout
+        console.log(colors.bright + colors.orange +
+            '┌────┬─────────────────────────┬────────────────────────────────────────────────────────────────────────┐' + colors.reset);
+        console.log(colors.bright + colors.orange +
+            '│ No.│ Name                    │ Detail                                                                 │' + colors.reset);
+        console.log(colors.bright + colors.orange +
+            '├────┼─────────────────────────┼────────────────────────────────────────────────────────────────────────┤' + colors.reset);
+
+        // Testing with multi-row display loop
+        apis.forEach((api, index) => {
+            const num = (index + 1).toString().padStart(2, ' ');
+
+            // Check if this is the currently active API
+            const isActiveApi = activeIndex === index;
+            const activeMarker = isActiveApi ? '●' : ' ';
+
+            // Format name with active marker
+            const nameWithMarker = `${activeMarker} ${api.name}`;
+            const displayName = nameWithMarker.padEnd(23, ' ');
+
+            // Test decrypt and maskApiToken functions
+            const decryptedToken = decrypt(api.authToken);
+            const displayToken = decryptedToken.success ? maskApiToken(decryptedToken.value) : '***ERROR***';
+
+            // Create 6 detail lines (full version)
+            const details = [
+                `Provider: ${api.provider}`,
+                `URL: ${api.baseUrl}`,
+                `Model: ${api.model}`,
+                `Token: ${displayToken}`,
+                `Usage: ${api.usageCount || 0} times`,
+                `Last Used: ${api.lastUsed ? new Date(api.lastUsed).toLocaleString() : 'Never'}`
+            ];
+
+            // Pad each detail line to exactly 70 characters
+            const paddedDetails = details.map(detail => padStringToWidth(detail, 70));
+
+            // Color selection based on active state and selection
+            const nameColor = isActiveApi ? colors.green : (index === selectedIndex ? colors.white : colors.gray);
+            const detailColor = isActiveApi ? colors.green : (index === selectedIndex ? colors.white : colors.gray);
+            const bgColor = index === selectedIndex ? colors.bgAmber : '';
+            const textBg = index === selectedIndex ? colors.black : '';
+
+            // Display 6 rows for each API, with No. and Name centered on row 3 (index 2)
+            for (let i = 0; i < paddedDetails.length; i++) {
+                if (i === 2) {
+                    // Middle row (3rd row) - show No. and Name for vertical centering
+                    console.log(colors.orange + '│' + textBg + bgColor + nameColor +
+                        ` ${num} ` + colors.reset + colors.orange + '│' + textBg + bgColor + nameColor +
+                        ` ${displayName} ` + colors.reset + colors.orange + '│' + textBg + bgColor + detailColor +
+                        ` ${paddedDetails[i]} ` + colors.reset + colors.orange + '│' + colors.reset);
+                } else {
+                    // Other rows - empty No. and Name columns
+                    console.log(colors.orange + '│' + textBg + bgColor + colors.gray +
+                        '    ' + colors.reset + colors.orange + '│' + textBg + bgColor + colors.gray +
+                        '                         ' + colors.reset + colors.orange + '│' + textBg + bgColor + detailColor +
+                        ' ' + paddedDetails[i] + ' ' + colors.reset + colors.orange + '│' + colors.reset);
+                }
+            }
+
+            // Add separator line after each API except the last one
+            if (index < apis.length - 1) {
+                console.log(colors.bright + colors.orange +
+                    '├────┼─────────────────────────┼────────────────────────────────────────────────────────────────────────┤' + colors.reset);
+            }
+        });
+
+        console.log(colors.bright + colors.orange +
+            '└────┴─────────────────────────┴────────────────────────────────────────────────────────────────────────┘' + colors.reset);
+        console.log('');
+
+        if (actionType === 'switch' && activeIndex >= 0) {
+            console.log(colors.green + '  ● = ' + i18n.tSync('ui.general.currently_active_api') + colors.reset);
+        }
+
+        // Different action prompts for different functionality
+        const actionText = actionType === 'remove' ? 'remove' : (actionType === 'switch' ? 'switch' : 'select');
+        console.log(colors.amber + '  ' + i18n.tSync('navigation.use_arrows_esc', actionText) + colors.reset);
+        console.log('');
+    }
+
+    function handleKeyPress(key) {
+        switch (key) {
+            case '\u001b[A': // Up arrow
+                selectedIndex = (selectedIndex - 1 + apis.length) % apis.length;
+                console.clear(); // Force clear screen
+                displaySimpleTable();
+                break;
+
+            case '\u001b[B': // Down arrow
+                selectedIndex = (selectedIndex + 1) % apis.length;
+                console.clear(); // Force clear screen
+                displaySimpleTable();
+                break;
+
+            case '\r': // Enter
+                return apis[selectedIndex];
+
+            case '\u001b': // Escape
+            case 'q':
+            case 'Q':
+                return null;
+        }
+        return undefined;
+    }
+
+    return new Promise((resolve) => {
+        // Initial display
+        console.clear();
+        displaySimpleTable();
+
+        if (process.stdin.isTTY) {
+            process.stdin.removeAllListeners('data');
+            process.stdin.removeAllListeners('keypress');
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+
+            const keyHandler = async (key) => {
+                const result = handleKeyPress(key);
+                if (result !== undefined) {
+                    // Force complete cleanup to prevent navigation issues
+                    if (process.stdin.isTTY) {
+                        process.stdin.setRawMode(false);
+                    }
+                    process.stdin.removeAllListeners('data');
+                    process.stdin.removeAllListeners('keypress');
+                    process.stdin.pause();
+
+                    // Handle switch mode - activate the selected API
+                    if (result && actionType === 'switch' && apiManager) {
+                        const selectedIndex = apis.findIndex(api => api.id === result.id);
+                        const switchedApi = apiManager.setActiveApi(selectedIndex);
+
+                        console.clear();
+                        console.log('');
+                        console.log(colors.bright + colors.green + `✓ ${i18n.tSync('messages.success.api_switched')}` + colors.reset);
+                        console.log(colors.gray + `  ${i18n.tSync('api.actions.switch_success', switchedApi.name)}` + colors.reset);
+                        console.log(colors.gray + `  ${i18n.tSync('api.details.provider')}: ${switchedApi.provider}` + colors.reset);
+                        console.log(colors.gray + `  ${i18n.tSync('api.details.url')}: ${switchedApi.baseUrl}` + colors.reset);
+                        console.log(colors.gray + `  ${i18n.tSync('api.details.model')}: ${switchedApi.model}` + colors.reset);
+                        console.log('');
+
+                        // Wait for user key press
+                        console.log(colors.gray + i18n.tSync('messages.prompts.press_any_key') + colors.reset);
+                        await waitForKeyPress();
+                    } else {
+                        console.clear();
+                        console.log('');
+                        console.log(colors.green + '✓ Selection completed: ' + (result ? result.name : 'Cancelled') + colors.reset);
+                        console.log('');
+                    }
+
+                    resolve(result);
+                }
+            };
+
+            process.stdin.on('data', keyHandler);
+        } else {
+            resolve(null);
+        }
+    });
+}
+
+function waitForKeyPress() {
+    return new Promise((resolve) => {
+        const keyHandler = () => {
+            process.stdin.removeListener('data', keyHandler);
+            resolve();
+        };
+        process.stdin.once('data', keyHandler);
+        process.stdin.resume();
+    });
+}
+
+async function confirmDeletion(api) {
+    console.clear();
+    console.log('');
+    console.log(colors.red + colors.bright + '[!] ' + i18n.tSync('messages.prompts.confirm_deletion') + colors.reset);
+    console.log('');
+    console.log(colors.yellow + i18n.tSync('ui.general.confirm_delete_api') + colors.reset);
+    console.log('');
+    console.log(colors.gray + `Name: ${api.name}` + colors.reset);
+    console.log(colors.gray + `Provider: ${api.provider}` + colors.reset);
+    console.log(colors.gray + `Base URL: ${api.baseUrl}` + colors.reset);
+    console.log(colors.gray + `Model: ${api.model}` + colors.reset);
+    const decryptedToken = decrypt(api.authToken);
+    const displayToken = decryptedToken.success ? maskApiToken(decryptedToken.value) : '***ERROR***';
+    console.log(colors.gray + `Token: ${displayToken}` + colors.reset);
+    console.log('');
+    console.log(colors.red + i18n.tSync('ui.general.action_cannot_undone') + colors.reset);
+    console.log('');
+
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        rl.question(colors.red + i18n.tSync('ui.general.confirm_deletion_prompt') + colors.reset, (answer) => {
+            rl.close();
+            const confirmed = answer.trim().toLowerCase() === 'y';
+            resolve(confirmed);
+        });
+    });
+}
+
+module.exports = {
+    showApiSelectionTable,
+    waitForKeyPress,
+    confirmDeletion
+};