@kikkimo/claude-launcher 2.0.0 → 2.2.0

package/lib/ui/prompts.js

@@ -7,19 +7,23 @@ const colors = require('./colors');
 const { getAllProviders } = require('../presets/providers');
 const { validateBaseUrl, validateAuthToken, validateModel } = require('../validators');
 const i18n = require('../i18n');
+const stdinManager = require('../utils/stdin-manager');
 
 /**
- * Simple input using readline
+ * Simple input using readline via StdinManager
  */
 async function simpleInput(prompt) {
     return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
+        const scope = stdinManager.acquire('line', {
+            id: 'simpleInput',
+            allowNested: false
         });
 
+        const rl = scope.createReadline();
+
         rl.question(prompt, (answer) => {
             rl.close();
+            scope.release();
             resolve(answer.trim());
         });
     });
@@ -31,43 +35,45 @@ async function simpleInput(prompt) {
 async function getProviderChoice(prompt) {
     return new Promise((resolve) => {
         if (process.stdin.isTTY) {
-            // Use raw mode to capture ESC key - this is necessary for interactive input
             process.stdout.write(colors.green + prompt + colors.reset);
 
             let input = '';
+            const scope = stdinManager.acquire('raw', {
+                id: 'getProviderChoice',
+                allowNested: true
+            });
 
-            // Save original state
-            const originalRawMode = process.stdin.isRaw;
-            const originalPaused = process.stdin.isPaused();
-
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.setEncoding('utf8');
+            const handleKeyPress = (key) => {
+                const keyCode = key.charCodeAt(0);
 
-            const cleanup = () => {
-                try {
-                    process.stdin.setRawMode(false);
-                    if (originalPaused) {
-                        process.stdin.pause();
+                // Handle Ctrl+C first
+                if (key === '\u0003') {
+                    scope.release();
+                    // handleCtrlC() returns false on first Ctrl+C, or exits on second.
+                    // Resolve with null to indicate cancellation (same as ESC key).
+                    const exited = stdinManager.handleCtrlC();
+                    if (exited === false) {
+                        process.stdout.write('\n');
+                        resolve(null); // User cancelled with Ctrl+C
                     }
-                    process.stdin.removeAllListeners('data');
-                } catch (error) {
-                    // Ignore cleanup errors
+                    return;
                 }
-            };
 
-            const handleKeyPress = (key) => {
-                const keyCode = key.charCodeAt(0);
+                // If waiting for second Ctrl+C, any other key cancels it
+                if (stdinManager.isCtrlCPending()) {
+                    stdinManager.cancelCtrlC();
+                    // Continue to process this key normally
+                }
 
                 switch (keyCode) {
                     case 27: // ESC key
-                        cleanup();
+                        scope.release();
                         process.stdout.write('\n');
                         resolve(null);
                         return;
 
                     case 13: // Enter key
-                        cleanup();
+                        scope.release();
                         process.stdout.write('\n');
                         resolve(input);
                         return;
@@ -80,14 +86,8 @@ async function getProviderChoice(prompt) {
                         }
                         return;
 
-                    case 3: // Ctrl+C
-                        cleanup();
-                        process.stdout.write('\n');
-                        resolve(null);
-                        return;
-
                     default:
-                        // Only accept printable characters
+                        // Only accept printable ASCII characters
                         if (keyCode >= 32 && keyCode < 127) {
                             input += key;
                             process.stdout.write(key);
@@ -96,16 +96,16 @@ async function getProviderChoice(prompt) {
                 }
             };
 
-            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
+            const scope = stdinManager.acquire('line', {
+                id: 'getProviderChoice_nonTTY',
+                allowNested: true
             });
-
+            const rl = scope.createReadline();
             rl.question(colors.green + prompt + colors.reset, (answer) => {
                 rl.close();
+                scope.release();
                 resolve(answer.trim());
             });
         }
@@ -121,35 +121,51 @@ async function waitForKey(message = 'Press any key to continue...') {
 
     return new Promise((resolve) => {
         if (process.stdin.isTTY) {
-            // Force complete cleanup before setting up new listeners
-            try {
-                process.stdin.removeAllListeners('data');
-                process.stdin.removeAllListeners('keypress');
-            } catch (error) {
-                // Ignore cleanup errors
-            }
+            // Use StdinManager for proper state management
+            const scope = stdinManager.acquire('raw', {
+                id: 'waitForKey',
+                allowNested: true
+            });
+
+            const handler = (key) => {
+                // Handle Ctrl+C first
+                if (key === '\u0003') {
+                    scope.removeListener('data', handler);
+                    scope.release();
+                    // handleCtrlC() returns false on first Ctrl+C, or exits on second.
+                    // Resolve to allow caller to continue (waitForKey doesn't have cancellation).
+                    const exited = stdinManager.handleCtrlC();
+                    if (exited === false) {
+                        resolve(); // Continue after first Ctrl+C warning
+                    }
+                    return;
+                }
 
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.once('data', () => {
-                // Complete cleanup after key press
-                try {
-                    process.stdin.setRawMode(false);
-                    process.stdin.removeAllListeners('data');
-                    process.stdin.removeAllListeners('keypress');
-                    process.stdin.pause();
-                } catch (error) {
-                    // Ignore cleanup errors
+                // 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();
-            });
+            };
+
+            // Use on() instead of once() so Ctrl+C doesn't remove the listener
+            scope.on('data', handler);
         } else {
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout
+            // For non-TTY environments, use readline directly
+            const scope = stdinManager.acquire('line', {
+                id: 'waitForKey_nonTTY',
+                allowNested: true
             });
+
+            const rl = scope.createReadline();
             rl.question('', () => {
                 rl.close();
+                scope.release();
                 resolve();
             });
         }
@@ -252,7 +268,13 @@ async function promptForThirdPartyApi() {
                 if (selectedProvider.id === 'custom') {
                     console.log(colors.yellow + '  ' + i18n.tSync('ui.general.replace_url_model_note') + colors.reset);
                 } else {
-                    console.log(colors.yellow + `  Note: ${selectedProvider.note}` + colors.reset);
+                    // Try to get note from i18n, fallback to provider.note if not found
+                    const noteKey = `provider.notes.${selectedProvider.id}`;
+                    const noteText = i18n.tSync(noteKey);
+                    // If i18n returns the key itself, it means translation not found, use original note
+                    const displayNote = noteText === noteKey ? selectedProvider.note : noteText;
+                    const notePrefix = i18n.tSync('provider.note_prefix');
+                    console.log(colors.yellow + `  ${notePrefix}: ${displayNote}` + colors.reset);
                 }
             }
             console.log('');
@@ -291,7 +313,8 @@ async function promptForThirdPartyApi() {
 
             // For all known providers, show the recommended URL in the prompt
             let prompt;
-            if (selectedProvider.id === 'anthropic' || selectedProvider.id === 'deepseek' || selectedProvider.id === 'moonshot') {
+            if (selectedProvider.id === 'anthropic' || selectedProvider.id === 'deepseek' ||
+                selectedProvider.id === 'moonshot' || selectedProvider.id === 'kimi_for_coding' || selectedProvider.id === 'zhipu' || selectedProvider.id === 'zai') {
                 prompt = colors.green + i18n.tSync('ui.general.press_enter_default_url') + `${colors.yellow}${baseUrl}${colors.green}` + colors.reset;
                 console.log(colors.gray + '    ' + i18n.tSync('ui.general.edit_url_hint') + colors.reset);
             } else {
@@ -457,35 +480,43 @@ async function confirmAction(message) {
 
     return new Promise((resolve) => {
         if (process.stdin.isTTY) {
-            // Force complete cleanup before setting up new listeners
-            try {
-                process.stdin.removeAllListeners('data');
-                process.stdin.removeAllListeners('keypress');
-            } catch (error) {
-                // Ignore cleanup errors
-            }
+            const scope = stdinManager.acquire('raw', {
+                id: 'confirmAction',
+                allowNested: true
+            });
+            scope.once('data', (key) => {
+                // Handle Ctrl+C first
+                if (key === '\u0003') {
+                    scope.release();
+                    // handleCtrlC() returns false on first Ctrl+C (shows warning),
+                    // or calls process.exit(0) on second Ctrl+C (terminates process).
+                    // If it returns (first Ctrl+C), resolve with false to indicate cancellation.
+                    const exited = stdinManager.handleCtrlC();
+                    if (exited === false) {
+                        resolve(false); // User cancelled with Ctrl+C
+                    }
+                    // If handleCtrlC() didn't return, process.exit(0) was called
+                    return;
+                }
 
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.once('data', (key) => {
-                // Complete cleanup after key press
-                try {
-                    process.stdin.setRawMode(false);
-                    process.stdin.removeAllListeners('data');
-                    process.stdin.removeAllListeners('keypress');
-                    process.stdin.pause();
-                } catch (error) {
-                    // Ignore cleanup errors
+                // If waiting for second Ctrl+C, any other key cancels it
+                if (stdinManager.isCtrlCPending()) {
+                    stdinManager.cancelCtrlC();
                 }
-                resolve(key.toString().toLowerCase() === 'y');
+
+                const yes = key.toString().trim().toLowerCase() === 'y';
+                scope.release();
+                resolve(yes);
             });
         } else {
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout
+            const scope = stdinManager.acquire('line', {
+                id: 'confirmAction_nonTTY',
+                allowNested: true
             });
+            const rl = scope.createReadline();
             rl.question('', (answer) => {
                 rl.close();
+                scope.release();
                 resolve(answer.toLowerCase() === 'y');
             });
         }
@@ -537,4 +568,4 @@ module.exports = {
     showSuccess,
     showError,
     showInfo
-};
+};