@kikkimo/claude-launcher 2.0.0 → 2.2.0

package/lib/ui/interactive-table.js

@@ -7,6 +7,7 @@ const { maskApiToken } = require('../validators');
 const { decrypt } = require('../crypto');
 const i18n = require('../i18n');
 const { padStringToWidth } = require('../utils/string-width');
+const stdinManager = require('../utils/stdin-manager');
 
 /**
  * Display simple interactive table for API selection
@@ -127,6 +128,18 @@ async function showApiSelectionTable(apis, title, actionType = 'select', activeI
     }
 
     function handleKeyPress(key) {
+        // Handle Ctrl+C first
+        if (key === '\u0003') {
+            stdinManager.handleCtrlC();
+            return undefined;
+        }
+
+        // If waiting for second Ctrl+C, any other key cancels it
+        if (stdinManager.isCtrlCPending()) {
+            stdinManager.cancelCtrlC();
+            // Continue to process this key normally
+        }
+
         switch (key) {
             case '\u001b[A': // Up arrow
                 selectedIndex = (selectedIndex - 1 + apis.length) % apis.length;
@@ -157,22 +170,17 @@ async function showApiSelectionTable(apis, title, actionType = 'select', activeI
         displaySimpleTable();
 
         if (process.stdin.isTTY) {
-            process.stdin.removeAllListeners('data');
-            process.stdin.removeAllListeners('keypress');
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.setEncoding('utf8');
+            // Use StdinManager for proper state management
+            const scope = stdinManager.acquire('raw', {
+                id: 'showApiSelectionTable',
+                allowNested: true
+            });
 
             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();
+                    // Release the scope, which automatically restores previous state
+                    scope.release();
 
                     // Handle switch mode - activate the selected API
                     if (result && actionType === 'switch' && apiManager) {
@@ -202,7 +210,7 @@ async function showApiSelectionTable(apis, title, actionType = 'select', activeI
                 }
             };
 
-            process.stdin.on('data', keyHandler);
+            scope.on('data', keyHandler);
         } else {
             resolve(null);
         }
@@ -211,12 +219,33 @@ async function showApiSelectionTable(apis, title, actionType = 'select', activeI
 
 function waitForKeyPress() {
     return new Promise((resolve) => {
-        const keyHandler = () => {
-            process.stdin.removeListener('data', keyHandler);
+        // Use StdinManager for proper state management
+        const scope = stdinManager.acquire('raw', {
+            id: 'waitForKeyPress',
+            allowNested: true
+        });
+
+        const handler = (key) => {
+            // Handle Ctrl+C first
+            if (key === '\u0003') {
+                stdinManager.handleCtrlC();
+                return; // Keep listener active for subsequent keys
+            }
+
+            // If waiting for second Ctrl+C, any other key cancels it
+            if (stdinManager.isCtrlCPending()) {
+                stdinManager.cancelCtrlC();
+            }
+
+            // Manually remove listener before resolving
+            scope.removeListener('data', handler);
+            // Release the scope, which automatically restores previous state
+            scope.release();
             resolve();
         };
-        process.stdin.once('data', keyHandler);
-        process.stdin.resume();
+
+        // Use on() instead of once() so Ctrl+C doesn't remove the listener
+        scope.on('data', handler);
     });
 }
 
@@ -238,17 +267,66 @@ async function confirmDeletion(api) {
     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
+    // Use StdinManager for proper state management
+    const scope = stdinManager.acquire('line', {
+        id: 'confirmDeletion',
+        allowNested: false
     });
 
+    let rl;
+    try {
+        rl = scope.createReadline();
+    } catch (error) {
+        console.error('[ERROR] Failed to create readline interface:', error.message);
+        scope.release();
+        return false; // Default to not deleting if we can't get user confirmation
+    }
+
     return new Promise((resolve) => {
+        let released = false;
+        let timeoutId = null;
+
+        // Centralized cleanup helper to prevent double-release
+        const cleanup = (result) => {
+            if (released) return; // Guard against multiple calls
+            released = true;
+
+            // Clear timeout if it exists
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+
+            // Remove all readline listeners to prevent subsequent handlers
+            if (rl) {
+                rl.removeAllListeners('error');
+                rl.removeAllListeners('line');
+                // Don't remove 'close' listeners - readline needs them for cleanup
+                rl.close();
+            }
+
+            // Release the scope
+            scope.release();
+
+            // Resolve the promise
+            resolve(result);
+        };
+
+        // Set a timeout to prevent infinite waiting
+        timeoutId = setTimeout(() => {
+            console.log('\n' + colors.yellow + '[!] Confirmation timeout - operation cancelled' + colors.reset);
+            cleanup(false); // Timeout means no deletion
+        }, 60000); // 60 second timeout
+
         rl.question(colors.red + i18n.tSync('ui.general.confirm_deletion_prompt') + colors.reset, (answer) => {
-            rl.close();
             const confirmed = answer.trim().toLowerCase() === 'y';
-            resolve(confirmed);
+            cleanup(confirmed);
+        });
+
+        // Handle readline errors
+        rl.on('error', (error) => {
+            console.error('[ERROR] Readline error:', error.message);
+            cleanup(false); // Error means no deletion
         });
     });
 }
@@ -257,4 +335,4 @@ module.exports = {
     showApiSelectionTable,
     waitForKeyPress,
     confirmDeletion
-};
+};

package/lib/ui/menu.js

@@ -1,4 +1,4 @@
-/**
+/**
  * Menu Module - Handles menu display and navigation
  */
 
@@ -6,6 +6,7 @@ const readline = require('readline');
 const colors = require('./colors');
 const i18n = require('../i18n');
 const { padStringToWidth } = require('../utils/string-width');
+const stdinManager = require('../utils/stdin-manager');
 
 /**
  * Force cleanup stdin state before displaying any menu
@@ -14,13 +15,20 @@ const { padStringToWidth } = require('../utils/string-width');
 function forceCleanupBeforeMenu() {
     try {
         if (process.stdin.isTTY) {
+            // Only reset mode, don't remove listeners that might be in use
             process.stdin.setRawMode(false);
-            process.stdin.removeAllListeners('data');
-            process.stdin.removeAllListeners('keypress');
-            process.stdin.pause();
+            // NOTE: Removed removeAllListeners to prevent conflicts with other modules
+            // The menu will manage its own listeners
+            // Only pause if not already paused
+            if (typeof process.stdin.isPaused !== 'function' || !process.stdin.isPaused()) {
+                process.stdin.pause();
+            }
         }
     } catch (error) {
-        // Ignore cleanup errors - we just want to ensure clean state
+        // Ignore cleanup errors but log for debugging
+        if (process.env.DEBUG_STDIN) {
+            console.error('[DEBUG] forceCleanupBeforeMenu error:', error.message);
+        }
     }
 }
 
@@ -40,9 +48,9 @@ class Menu {
         // Use console.clear and console.log for proper screen clearing
         console.clear();
         console.log('');
-        console.log(colors.orange + '  ┌───────────────────────────────────────────────────────────────────────────┐' + colors.reset);
-        console.log(colors.orange + '  │' + colors.white + colors.bright + '                            Claude Code Launcher                           ' + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '  └───────────────────────────────────────────────────────────────────────────┘' + colors.reset);
+        console.log(colors.orange + '  ┌──────────────────────────────────────────────────────┐' + colors.reset);
+        console.log(colors.orange + '  │' + colors.white + colors.bright + '                 Claude Code Launcher                 ' + colors.orange + '│' + colors.reset);
+        console.log(colors.orange + '  └──────────────────────────────────────────────────────┘' + colors.reset);
         console.log('');
         console.log(colors.gray + '  ' + i18n.tSync('navigation.use_arrows') + colors.reset);
         console.log('');
@@ -59,9 +67,9 @@ class Menu {
             console.clear();
         }
         console.log('');
-        console.log(colors.orange + '  ┌───────────────────────────────────────────────────────────────────────────┐' + colors.reset);
-        console.log(colors.orange + '  │' + colors.white + colors.bright + '                            Claude Code Launcher                           ' + colors.orange + '│' + colors.reset);
-        console.log(colors.orange + '  └───────────────────────────────────────────────────────────────────────────┘' + colors.reset);
+        console.log(colors.orange + '  ┌──────────────────────────────────────────────────────┐' + colors.reset);
+        console.log(colors.orange + '  │' + colors.white + colors.bright + '                 Claude Code Launcher                 ' + colors.orange + '│' + colors.reset);
+        console.log(colors.orange + '  └──────────────────────────────────────────────────────┘' + colors.reset);
         console.log('');
 
         // Display version info if provided (between banner and navigation tips, like Claude Code)
@@ -101,90 +109,115 @@ class Menu {
      * @param {string} versionInfo - Optional version info to display
      */
     async navigate(clearScreen = true, versionInfo = null) {
-        let ctrlCCount = 0;
+        // Guard against empty menu to prevent NaN from modulo operations
+        if (!this.menuOptions || this.menuOptions.length === 0) {
+            console.log(colors.yellow + '  Warning: No menu options available' + colors.reset);
+            return -1; // Return cancel/exit code
+        }
+
         this.versionInfo = versionInfo; // Store for redrawing
 
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.displayMenu(clearScreen, versionInfo);
 
             if (process.stdin.isTTY) {
-                process.stdin.setRawMode(true);
-                process.stdin.resume();
-                process.stdin.setEncoding('utf8');
+                const scope = stdinManager.acquire('raw', {
+                    id: 'menu_navigate',
+                    allowNested: true
+                });
 
-                const handleKeyPress = (key) => {
-                    switch (key) {
-                        case '\u0003': // Ctrl+C - 2-step exit
-                            ctrlCCount++;
-                            if (ctrlCCount === 1) {
-                                console.log('');
-                                console.log(colors.yellow + '⚠️  ' + i18n.tSync('messages.prompts.ctrl_c_again') + colors.reset);
-                                setTimeout(() => {
-                                    ctrlCCount = 0; // Reset after 3 seconds
-                                }, 3000);
-                            } else if (ctrlCCount >= 2) {
-                                process.stdin.removeListener('data', handleKeyPress);
-                                if (process.stdin.isTTY) {
-                                    process.stdin.setRawMode(false);
-                                }
-                                console.log('');
-                                console.log(colors.green + '👋 Goodbye!' + colors.reset);
-                                process.exit(0);
-                            }
-                            break;
-
-                        case '\u001b[A': // Up arrow
-                            ctrlCCount = 0; // Reset Ctrl+C count on other keys
-                            this.selectedIndex = (this.selectedIndex - 1 + this.menuOptions.length) % this.menuOptions.length;
-                            this.displayMenu(true, this.versionInfo);
-                            break;
-
-                        case '\u001b[B': // Down arrow
-                            ctrlCCount = 0; // Reset Ctrl+C count on other keys
-                            this.selectedIndex = (this.selectedIndex + 1) % this.menuOptions.length;
-                            this.displayMenu(true, this.versionInfo);
-                            break;
-
-                        case '\r': // Enter
-                            process.stdin.removeListener('data', handleKeyPress);
-                            if (process.stdin.isTTY) {
-                                process.stdin.setRawMode(false);
-                            }
-                            process.stdin.pause();
-                            resolve(this.selectedIndex);
-                            break;
-
-                        case '\u001b': // Escape
-                        case 'q':
-                        case 'Q':
-                            process.stdin.removeListener('data', handleKeyPress);
-                            if (process.stdin.isTTY) {
-                                process.stdin.setRawMode(false);
-                            }
-                            process.stdin.pause();
-                            resolve(-1);
-                            break;
+                let resolved = false;
+                let cleanedUp = false;
+
+                const cleanup = () => {
+                    if (cleanedUp) return;
+                    cleanedUp = true;
+                    try {
+                        scope.removeListener('data', handleKeyPress);
+                        scope.release();
+                    } catch (error) {
+                        // Ignore cleanup errors to prevent masking original error
+                    }
+                };
+
+                const safeResolve = (value) => {
+                    if (resolved) return;
+                    resolved = true;
+                    cleanup();
+                    resolve(value);
+                };
 
+                const safeReject = (error) => {
+                    if (resolved) return;
+                    resolved = true;
+                    cleanup();
+                    reject(error);
+                };
+
+                const handleKeyPress = (key) => {
+                    try {
+                        // Handle Ctrl+C first
+                        if (key === '\u0003') {
+                            stdinManager.handleCtrlC();
+                            return; // Don't process further
+                        }
+
+                        // If waiting for second Ctrl+C, any other key cancels it
+                        if (stdinManager.isCtrlCPending()) {
+                            stdinManager.cancelCtrlC();
+                            // Continue to process this key normally
+                        }
+
+                        switch (key) {
+                            case '\u001b[A': // Up arrow
+                                this.selectedIndex = (this.selectedIndex - 1 + this.menuOptions.length) % this.menuOptions.length;
+                                this.displayMenu(true, this.versionInfo);
+                                break;
+
+                            case '\u001b[B': // Down arrow
+                                this.selectedIndex = (this.selectedIndex + 1) % this.menuOptions.length;
+                                this.displayMenu(true, this.versionInfo);
+                                break;
+
+                            case '\r': // Enter
+                                safeResolve(this.selectedIndex);
+                                break;
+
+                            case '\u001b': // Escape
+                            case 'q':
+                            case 'Q':
+                                safeResolve(-1);
+                                break;
+
+                            default:
+                                break;
+                        }
+                    } catch (error) {
+                        safeReject(error);
                     }
                 };
 
-                process.stdin.on('data', handleKeyPress);
+                scope.on('data', handleKeyPress);
             } else {
-                // Fallback for non-TTY environments
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout
+                // Non-TTY fallback: use StdinManager for line-based input
+                const lineScope = stdinManager.acquire('line', {
+                    id: 'menu_navigate_nonTTY',
+                    allowNested: false
                 });
 
+                const rl = lineScope.createReadline();
+
                 console.log(colors.yellow + '  ' + i18n.tSync('navigation.arrow_keys_not_available', this.menuOptions.length) + colors.reset);
 
                 rl.on('line', (input) => {
                     const choice = parseInt(input.trim());
                     if (choice >= 1 && choice <= this.menuOptions.length) {
                         rl.close();
+                        lineScope.release();
                         resolve(choice - 1);
                     } else if (input.toLowerCase() === 'q' || input.toLowerCase() === 'exit') {
                         rl.close();
+                        lineScope.release();
                         resolve(-1);
                     } else {
                         console.log(colors.red + '  Invalid selection. Please enter 1-' + this.menuOptions.length + '.' + colors.reset);
@@ -194,17 +227,18 @@ class Menu {
         });
     }
 
-    /**
-     * Display a list for selection
-     */
     async selectFromList(title, items, activeIndex = -1) {
-        // Force cleanup stdin state before any list selection
+        // Guard against empty items list to prevent NaN from modulo operations
+        if (!items || items.length === 0) {
+            console.log(colors.yellow + '  Warning: No items available to select' + colors.reset);
+            return null; // Return null to indicate no selection
+        }
+
         forceCleanupBeforeMenu();
 
         let selectedIndex = activeIndex >= 0 ? activeIndex : 0;
-        let ctrlCCount = 0;
 
-        function displayList() {
+        const displayList = () => {
             console.clear();
             console.log('');
             console.log(colors.bright + colors.orange + `[*] ${title}` + colors.reset);
@@ -218,7 +252,6 @@ class Menu {
                 const activeIndicator = isActive ? ' (ACTIVE)' : '';
 
                 if (index === selectedIndex) {
-                    // Pad the selected item to ensure complete background coverage
                     const itemText = `${item.name}${activeIndicator}`;
                     const paddedItem = padStringToWidth(itemText, Math.max(40, itemText.length + 2));
                     console.log(colors.orange + prefix + colors.black + colors.bgAmber + paddedItem + colors.reset);
@@ -233,82 +266,118 @@ class Menu {
             });
 
             console.log('');
-        }
+        };
 
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             displayList();
 
             if (process.stdin.isTTY) {
-                process.stdin.setRawMode(true);
-                process.stdin.resume();
-                process.stdin.setEncoding('utf8');
+                const scope = stdinManager.acquire('raw', {
+                    id: 'menu_selectFromList',
+                    allowNested: true
+                });
+
+                let resolved = false;
+                let cleanedUp = false;
+
+                const cleanup = () => {
+                    if (cleanedUp) return;
+                    cleanedUp = true;
+                    try {
+                        scope.removeListener('data', handleKeyPress);
+                        scope.release();
+                    } catch (error) {
+                        // Ignore cleanup errors to prevent masking original error
+                    }
+                };
+
+                const safeResolve = (value) => {
+                    if (resolved) return;
+                    resolved = true;
+                    cleanup();
+                    resolve(value);
+                };
+
+                const safeReject = (error) => {
+                    if (resolved) return;
+                    resolved = true;
+                    cleanup();
+                    reject(error);
+                };
 
                 const handleKeyPress = (key) => {
-                    switch (key) {
-                        case '\u0003': // Ctrl+C - 2-step exit
-                            ctrlCCount++;
-                            if (ctrlCCount === 1) {
-                                console.log('');
-                                console.log(colors.yellow + '⚠️  ' + i18n.tSync('messages.prompts.ctrl_c_again') + colors.reset);
-                                setTimeout(() => {
-                                    ctrlCCount = 0; // Reset after 3 seconds
-                                }, 3000);
-                            } else if (ctrlCCount >= 2) {
-                                process.stdin.removeListener('data', handleKeyPress);
-                                if (process.stdin.isTTY) {
-                                    process.stdin.setRawMode(false);
-                                }
-                                console.log('');
-                                console.log(colors.green + '👋 Goodbye!' + colors.reset);
-                                process.exit(0);
-                            }
-                            break;
-
-                        case '\u001b[A': // Up arrow
-                            ctrlCCount = 0; // Reset Ctrl+C count on other keys
-                            selectedIndex = (selectedIndex - 1 + items.length) % items.length;
-                            displayList();
-                            break;
-
-                        case '\u001b[B': // Down arrow
-                            ctrlCCount = 0; // Reset Ctrl+C count on other keys
-                            selectedIndex = (selectedIndex + 1) % items.length;
-                            displayList();
-                            break;
-
-                        case '\r': // Enter
-                            process.stdin.removeListener('data', handleKeyPress);
-                            if (process.stdin.isTTY) {
-                                process.stdin.setRawMode(false);
-                            }
-                            process.stdin.pause();
-                            resolve(selectedIndex);
-                            break;
-
-                        case '\u001b': // Escape
-                        case 'q':
-                        case 'Q':
-                            process.stdin.removeListener('data', handleKeyPress);
-                            if (process.stdin.isTTY) {
-                                process.stdin.setRawMode(false);
-                            }
-                            process.stdin.pause();
-                            resolve(null);
-                            break;
-
-                        default:
-                            // Any other key resets Ctrl+C count
-                            ctrlCCount = 0;
-                            break;
+                    try {
+                        // Handle Ctrl+C first
+                        if (key === '\u0003') {
+                            stdinManager.handleCtrlC();
+                            return; // Don't process further
+                        }
+
+                        // If waiting for second Ctrl+C, any other key cancels it
+                        if (stdinManager.isCtrlCPending()) {
+                            stdinManager.cancelCtrlC();
+                            // Continue to process this key normally
+                        }
+
+                        switch (key) {
+                            case '\u001b[A': // Up arrow
+                                selectedIndex = (selectedIndex - 1 + items.length) % items.length;
+                                displayList();
+                                break;
+
+                            case '\u001b[B': // Down arrow
+                                selectedIndex = (selectedIndex + 1) % items.length;
+                                displayList();
+                                break;
+
+                            case '\r': // Enter
+                                safeResolve(selectedIndex);
+                                break;
+
+                            case '\u001b': // Escape
+                            case 'q':
+                            case 'Q':
+                                safeResolve(null);
+                                break;
+
+                            default:
+                                break;
+                        }
+                    } catch (error) {
+                        safeReject(error);
                     }
                 };
 
-                process.stdin.on('data', handleKeyPress);
+                scope.on('data', handleKeyPress);
             } else {
-                resolve(null);
+                // Non-TTY fallback: use line-based input
+                const lineScope = stdinManager.acquire('line', {
+                    id: 'menu_selectFromList_nonTTY',
+                    allowNested: false
+                });
+
+                const rl = lineScope.createReadline();
+
+                console.log(colors.yellow + '  Arrow keys not available. Enter item number (1-' + items.length + ') or q to cancel:' + colors.reset);
+
+                rl.on('line', (input) => {
+                    const choice = parseInt(input.trim());
+                    if (choice >= 1 && choice <= items.length) {
+                        rl.close();
+                        lineScope.release();
+                        resolve(choice - 1);
+                    } else if (input.toLowerCase() === 'q') {
+                        rl.close();
+                        lineScope.release();
+                        resolve(null);
+                    } else {
+                        console.log(colors.red + '  Invalid selection. Please enter 1-' + items.length + '.' + colors.reset);
+                    }
+                });
             }
         });
     }
+
 }
 
-module.exports = Menu;
+module.exports = Menu;