@kikkimo/claude-launcher 2.3.0 → 2.5.0

package/claude-launcher

@@ -46,6 +46,7 @@ const {
 const {
     launchClaudeDefault,
     launchClaudeSkipPermissions,
+    launchClaudeAutoMode,
     launchClaudeWithApi
 } = require('./lib/launcher');
 const { getPasswordInput } = require('./lib/auth/password-input');
@@ -263,9 +264,52 @@ async function addNewThirdPartyApi() {
 }
 
 /**
- * Remove third-party API
+ * Remove third-party API menu with submenu
  */
 async function removeThirdPartyApi() {
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '🗑️  ' + await i18n.t('menu.remove_api.title') + colors.reset);
+    console.log('');
+
+    const apis = apiManager.getApis();
+
+    // Show current API count
+    if (apis.length > 0) {
+        console.log(colors.cyan + '  ' + await i18n.t('messages.info.current_api_count', apis.length) + colors.reset);
+        console.log('');
+    }
+
+    const menuOptions = [
+        await i18n.t('menu.remove_api.delete_single'),
+        await i18n.t('menu.remove_api.clear_all'),
+        await i18n.t('menu.remove_api.back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // Delete Single API
+            await deleteSingleApi();
+            return;
+
+        case 1: // Clear All APIs
+            await clearAllApis();
+            return;
+
+        case 2: // Back
+        case -1:
+        default:
+            return;
+    }
+}
+
+/**
+ * Delete a single API
+ */
+async function deleteSingleApi() {
     try {
         // Get API list
         const apis = apiManager.getApis();
@@ -281,7 +325,7 @@ async function removeThirdPartyApi() {
         );
 
         if (!selectedApi) {
-            return showMenu();
+            return;
         }
 
         // Show confirmation dialog
@@ -299,23 +343,20 @@ async function removeThirdPartyApi() {
                     `${await i18n.t('api.details.provider')}: ${selectedApi.provider}`
                 ]);
 
-                // Show success message and return to main menu
+                // Show success message
                 const remainingApis = apiManager.getApis();
                 if (remainingApis.length === 0) {
                     showInfo(await i18n.t('messages.info.all_apis_removed'));
                 }
                 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();
             }
         } else {
             showInfo(await i18n.t('messages.info.removal_cancelled'));
             await waitForKey(await i18n.t('messages.prompts.press_any_key'));
-            return showMenu();
         }
 
     } catch (error) {
@@ -325,6 +366,42 @@ async function removeThirdPartyApi() {
     }
 }
 
+/**
+ * Clear all APIs with confirmation
+ */
+async function clearAllApis() {
+    const { simpleInput } = require('./lib/ui/prompts');
+
+    const apis = apiManager.getApis();
+    const count = apis.length;
+
+    if (count === 0) {
+        console.clear();
+        showInfo(await i18n.t('messages.info.no_apis'));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return;
+    }
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.red + '⚠️  ' + await i18n.t('menu.remove_api.clear_all') + colors.reset);
+    console.log('');
+    console.log(colors.yellow + '  ' + await i18n.t('messages.prompts.confirm_clear_all', count) + colors.reset);
+    console.log('');
+
+    const input = await simpleInput(colors.cyan + '  ' + await i18n.t('messages.prompts.confirm_clear_all_input') + colors.reset);
+
+    if (input === 'CLEAR') {
+        const clearedCount = apiManager.clearAllApis();
+        console.clear();
+        showSuccess(await i18n.t('messages.info.all_apis_cleared', clearedCount));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+    } else {
+        showInfo(await i18n.t('messages.info.clear_cancelled'));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+    }
+}
+
 /**
  * Switch active third-party API
  */
@@ -357,40 +434,110 @@ async function switchThirdPartyApi() {
 /**
  * View API statistics
  */
+/**
+ * Format timestamp to relative time
+ * @param {string|null} timestamp - ISO timestamp or null
+ * @returns {string} Relative time string
+ */
+function formatRelativeTime(timestamp) {
+    if (!timestamp) return i18n.tSync('statistics.time_never');
+
+    const now = Date.now();
+    const diff = now - new Date(timestamp).getTime();
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+
+    if (minutes < 1) return i18n.tSync('statistics.time_just_now');
+    if (minutes < 60) return i18n.tSync('statistics.time_minutes_ago', minutes);
+    if (hours < 24) return i18n.tSync('statistics.time_hours_ago', hours);
+    return i18n.tSync('statistics.time_days_ago', days);
+}
+
 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();
+    const menuOptions = [
+        await i18n.t('statistics.menu_view'),
+        await i18n.t('statistics.menu_reset'),
+        await i18n.t('statistics.menu_back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // View Statistics Details
+            await showStatisticsDetails();
+            return viewStatistics();
+
+        case 1: // Reset Statistics
+            const { simpleInput } = require('./lib/ui/prompts');
+            const confirm = await simpleInput(colors.yellow + '  ' + await i18n.t('statistics.reset_confirm') + ' ' + colors.reset);
+            if (confirm.toLowerCase() === 'y') {
+                apiManager.resetStatistics();
+                console.log(colors.green + '  ✓ ' + await i18n.t('statistics.reset_success') + colors.reset);
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+            }
+            return viewStatistics();
+
+        case 2: // Back
+        case -1:
+        default:
+            return;
+    }
+}
+
+/**
+ * Show detailed statistics
+ */
+async function showStatisticsDetails() {
+    const { padStringToWidth } = require('./lib/utils/string-width');
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset);
+    console.log('');
+
+    const stats = apiManager.getEnhancedStatistics();
 
-    console.log(colors.cyan + '  ' + i18n.tSync('ui.general.summary') + colors.reset);
+    // Summary section
+    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(colors.gray + `    ${await i18n.t('statistics.success_rate', stats.successRate)}` + 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);
-        });
+    if (stats.apiStats.length > 0) {
+        console.log(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + ':' + colors.reset);
+        console.log('');
+
+        // Table header
+        console.log(colors.dim + '    ' +
+            padStringToWidth(await i18n.t('statistics.header_name'), 20) +
+            padStringToWidth(await i18n.t('statistics.header_usage'), 10) +
+            padStringToWidth(await i18n.t('statistics.header_success'), 10) +
+            await i18n.t('statistics.header_last_used') +
+            colors.reset);
+        console.log(colors.dim + '    ' + '─'.repeat(60) + colors.reset);
+
+        for (const api of stats.apiStats) {
+            const lastUsedText = formatRelativeTime(api.lastUsed);
+            console.log(colors.gray + '    ' +
+                padStringToWidth(api.name, 20) +
+                padStringToWidth(String(api.usageCount), 10) +
+                padStringToWidth(api.successRate, 10) +
+                lastUsedText +
+                colors.reset);
+        }
+    } else {
+        console.log(colors.gray + '  ' + await i18n.t('statistics.no_usage') + colors.reset);
     }
 
     console.log('');
@@ -568,20 +715,23 @@ async function showApiManagementMenu() {
 
     // 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')
+        await i18n.t('menu.api_management.add_new'),      // 0
+        await i18n.t('menu.api_management.remove'),       // 1
+        await i18n.t('menu.api_management.switch'),       // 2
+        await i18n.t('menu.api_management.statistics')    // 3
     ];
 
     // 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.export'));          // 4
+        menuOptions.push(await i18n.t('menu.api_management.import'));          // 5
+        menuOptions.push(await i18n.t('menu.api_management.change_password')); // 6
     }
 
-    menuOptions.push(await i18n.t('menu.api_management.back'));
+    // Add model upgrade settings (always available)
+    menuOptions.push(await i18n.t('model_upgrade.settings_title'));  // 4 or 7 (depending on import/export)
+
+    menuOptions.push(await i18n.t('menu.api_management.back'));      // 5 or 8
 
     // Ensure global menus are initialized
     initializeGlobalMenus();
@@ -604,7 +754,7 @@ async function showApiManagementMenu() {
         await viewStatistics();
         return showMenu();
     } else if (apiManager.canUseImportExport()) {
-        // If import/export is available, handle those options
+        // With import/export enabled: indices 4-8
         if (choice === 4) { // Export Configuration
             await exportConfiguration();
             return showMenu();
@@ -614,12 +764,16 @@ async function showApiManagementMenu() {
         } else if (choice === 6) { // Change Password
             await changePassword();
             return showMenu();
-        } else if (choice === 7) { // Back to Main Menu
+        } else if (choice === 7) { // Model Upgrade Settings (NEW)
+            return await showModelUpgradeSettings();
+        } else if (choice === 8) { // 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
+        // Without import/export: indices 4-5
+        if (choice === 4) { // Model Upgrade Settings (NEW)
+            return await showModelUpgradeSettings();
+        } else if (choice === 5) { // Back to Main Menu
             return showMenu();
         }
     }
@@ -628,6 +782,144 @@ async function showApiManagementMenu() {
     return showMenu();
 }
 
+/**
+ * Show model upgrade settings menu
+ */
+async function showModelUpgradeSettings() {
+    const versionChecker = require('./lib/utils/version-checker');
+    const upgradeChecker = require('./lib/utils/model-upgrade-checker');
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '⚙️  ' + await i18n.t('model_upgrade.settings_title') + colors.reset);
+    console.log('');
+
+    const config = await versionChecker.loadConfig();
+    const isAutoOn = config.autoModelUpgrade === true;
+
+    console.log(colors.cyan + '  ' + await i18n.t('model_upgrade.current_config') + ':' + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.auto_upgrade_label') + ': ' +
+        (isAutoOn
+            ? colors.green + await i18n.t('model_upgrade.auto_upgrade_on')
+            : colors.dim + await i18n.t('model_upgrade.auto_upgrade_off')
+        ) + colors.reset);
+    console.log('');
+
+    const menuOptions = [
+        isAutoOn
+            ? await i18n.t('model_upgrade.menu_toggle_auto_on')
+            : await i18n.t('model_upgrade.menu_toggle_auto_off'),
+        await i18n.t('model_upgrade.menu_manual_upgrade'),
+        await i18n.t('model_upgrade.menu_back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // Toggle auto upgrade
+            await versionChecker.setAutoModelUpgrade(!isAutoOn);
+            console.log('');
+            console.log(colors.green + '✓ ' + await i18n.t('model_upgrade.auto_upgrade_label') + ': ' +
+                (!isAutoOn
+                    ? await i18n.t('model_upgrade.auto_upgrade_on')
+                    : await i18n.t('model_upgrade.auto_upgrade_off')
+                ) + colors.reset);
+            await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+            return showModelUpgradeSettings();
+
+        case 1: // Manual upgrade
+            await performManualUpgrade();
+            return showModelUpgradeSettings();
+
+        case 2: // Back
+        case -1:
+        default:
+            return showApiManagementMenu();
+    }
+}
+
+/**
+ * Perform manual upgrade for all APIs with interactive confirmation
+ */
+async function performManualUpgrade() {
+    const { getLatestModel, getProvider } = require('./lib/presets/providers');
+    const { simpleInput } = require('./lib/ui/prompts');
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '🔄 ' + await i18n.t('model_upgrade.manual_title') + colors.reset);
+    console.log('');
+
+    const apis = apiManager.getApis();
+
+    if (apis.length === 0) {
+        console.log(colors.yellow + '  ' + await i18n.t('messages.info.no_apis') + colors.reset);
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return;
+    }
+
+    console.log(colors.gray + '  ' + await i18n.t('model_upgrade.manual_checking', apis.length) + colors.reset);
+    console.log('');
+
+    let upgradedCount = 0;
+    let skippedUpToDate = 0;
+    let skippedNoInfo = 0;
+    let skippedByUser = 0;
+
+    for (let i = 0; i < apis.length; i++) {
+        const api = apis[i];
+        const latestModel = getLatestModel(api.model, api.provider);
+
+        console.log(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset);
+        console.log(colors.bright + `  ${i + 1}/${apis.length}  ${api.name}` + colors.reset);
+        console.log(colors.gray + '       ' + await i18n.t('model_upgrade.manual_api_current', api.model) + colors.reset);
+
+        if (latestModel) {
+            console.log(colors.green + '       ' + await i18n.t('model_upgrade.manual_api_latest', latestModel) + colors.reset);
+            console.log('');
+
+            // Ask for confirmation
+            const answer = await simpleInput(colors.yellow + '       ' + await i18n.t('model_upgrade.manual_confirm') + ' ' + colors.reset);
+
+            if (answer.toLowerCase() === 'y') {
+                apiManager.updateApiModel(api.id, latestModel);
+                console.log(colors.green + '       ✓ ' + await i18n.t('model_upgrade.manual_upgraded', api.model, latestModel) + colors.reset);
+                upgradedCount++;
+            } else {
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_skipped') + colors.reset);
+                skippedByUser++;
+            }
+        } else {
+            // No upgrade info available - check if model exists in provider
+            const provider = getProvider(api.provider);
+            if (provider && provider.models && provider.models.includes(api.model)) {
+                // Model exists in provider, likely already latest or no alias defined
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_uptodate') + colors.reset);
+                skippedUpToDate++;
+            } else {
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_no_info') + colors.reset);
+                skippedNoInfo++;
+            }
+        }
+
+        console.log('');
+    }
+
+    console.log(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset);
+    console.log('');
+    console.log(colors.green + '  ' + await i18n.t('model_upgrade.manual_complete') + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_upgraded', upgradedCount) + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_skipped',
+        skippedUpToDate + skippedNoInfo + skippedByUser,
+        skippedUpToDate,
+        skippedNoInfo) + colors.reset);
+    console.log('');
+
+    await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+}
+
 /**
  * Handle third-party API launch
  */
@@ -646,12 +938,15 @@ async function handleThirdPartyApiLaunch(skipPermissions = false) {
             return showMenu();
         }
 
-        // Increment usage count for the active API since we're actually using it
-        apiManager.incrementActiveApiUsage();
+        // Record successful launch BEFORE launching (since process exits after)
+        apiManager.recordSuccessfulLaunch();
 
         launchClaudeWithApi(activeApi, skipPermissions);
 
     } catch (error) {
+        // Record failed launch
+        apiManager.recordFailedLaunch(error.message);
+
         showError('Failed to launch with third-party API', [error.message]);
 
         setTimeout(() => {
@@ -673,24 +968,28 @@ async function executeSelection(selectedIndex) {
             launchClaudeSkipPermissions();
             break;
 
-        case 2: // Launch Claude Code with 3rd-party API
+        case 2: // Launch Claude Code (Enable Auto Mode)
+            launchClaudeAutoMode();
+            break;
+
+        case 3: // Launch Claude Code with 3rd-party API
             await handleThirdPartyApiLaunch(false);
             break;
 
-        case 3: // Launch Claude Code with 3rd-party API (Skip Permissions)
+        case 4: // Launch Claude Code with 3rd-party API (Skip Permissions)
             await handleThirdPartyApiLaunch(true);
             break;
 
-        case 4: // 3rd-party API Management
+        case 5: // 3rd-party API Management
             return await showApiManagementMenu();
 
-        case 5: // Language Settings
+        case 6: // Language Settings
             return await showLanguageSettings();
 
-        case 6: // Version Update Check
+        case 7: // Version Update Check
             return await showVersionUpdateCheck();
 
-        case 7: // Exit
+        case 8: // Exit
             console.log('');
             console.log(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset);
             process.exit(0);
@@ -741,10 +1040,65 @@ async function showMenu() {
         // Silently ignore update check errors
     }
 
+    // ========================================
+    // Model upgrade check (new feature)
+    // ========================================
+    let modelUpgradeInfo = null;
+    try {
+        const upgradeChecker = require('./lib/utils/model-upgrade-checker');
+        const autoUpgrade = await upgradeChecker.isAutoUpgradeEnabled();
+
+        if (autoUpgrade) {
+            // Auto upgrade enabled: always check and upgrade (bypass cache)
+            const upgrades = upgradeChecker.checkAllApiUpgrades(apiManager);
+            if (upgrades.length > 0) {
+                const upgraded = upgradeChecker.performAutoUpgrade(apiManager, upgrades);
+                if (upgraded.length > 0) {
+                    modelUpgradeInfo = colors.green + '  ✓ ' +
+                        i18n.tSync('model_upgrade.auto_upgraded', upgraded[0].from, upgraded[0].to) + colors.reset;
+                    if (upgraded.length > 1) {
+                        modelUpgradeInfo += '\n' + colors.green + '    ' +
+                            `(+${upgraded.length - 1} more)` + colors.reset;
+                    }
+                }
+            }
+        } else {
+            // Auto upgrade disabled: use cache for notification
+            const result = await upgradeChecker.checkForModelUpgrades(apiManager);
+            if (result.needsCheck && result.upgrades.length > 0) {
+                const first = result.upgrades[0];
+                modelUpgradeInfo = colors.yellow + '  ⚠️  ' +
+                    i18n.tSync('model_upgrade.notification', first.currentModel, first.latestModel) +
+                    colors.reset + '\n' +
+                    colors.yellow + '      ' +
+                    i18n.tSync('model_upgrade.notification_api', first.apiName) +
+                    colors.reset + '\n' +
+                    colors.gray + '      ' +
+                    i18n.tSync('model_upgrade.notification_hint') +
+                    colors.reset;
+            }
+        }
+    } catch (error) {
+        // Silently ignore model upgrade check errors
+    }
+
+    // Combine version info and model upgrade info
+    let displayInfo = '';
+    if (versionInfo) {
+        displayInfo += versionInfo;
+    }
+    if (modelUpgradeInfo) {
+        if (displayInfo) {
+            displayInfo += '\n';
+        }
+        displayInfo += modelUpgradeInfo;
+    }
+
     // 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_auto_mode'),
         await i18n.t('menu.main.launch_api'),
         await i18n.t('menu.main.launch_api_skip'),
         await i18n.t('menu.main.api_management'),
@@ -753,8 +1107,31 @@ async function showMenu() {
         await i18n.t('menu.main.exit')
     ];
 
+    // Pre-compute hint texts synchronously for menu callback
+    const hintAutoMode = i18n.tSync('hints.auto_mode_info');
+    const activeApi = apiManager.getActiveApi();
+    let hintApiInfo = null;
+    if (activeApi) {
+        const { getProvider } = require('./lib/presets/providers');
+        const providerConfig = getProvider(activeApi.provider);
+        const providerName = providerConfig ? providerConfig.name : (activeApi.provider || 'Custom');
+        hintApiInfo = i18n.tSync('hints.active_api_info', providerName, activeApi.model);
+    } else {
+        hintApiInfo = i18n.tSync('hints.no_active_api');
+    }
+
+    // Synchronous hint callback — must not use await
+    const hintCallback = (selectedIndex) => {
+        switch (selectedIndex) {
+            case 2: return hintAutoMode;
+            case 3: return hintApiInfo;
+            case 4: return hintApiInfo;
+            default: return null;
+        }
+    };
+
     globalMainMenu.setOptions(menuOptions);
-    const selection = await globalMainMenu.navigate(false, versionInfo); // Pass version info to display between banner and nav
+    const selection = await globalMainMenu.navigate(false, displayInfo || null, hintCallback);
 
     if (selection === -1) {
         console.log('');