maistro 1.0.390

package/dist/config.js

@@ -0,0 +1,933 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execa } from 'execa';
+import { getClaudePath } from './claudePath.js';
+/**
+ * Default settings for new installations
+ */
+export const DEFAULT_SETTINGS = {
+    preventSleep: true,
+};
+const CONFIG_DIR = join(homedir(), '.maistro');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Load global configuration
+ */
+export function loadConfig() {
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            const content = readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, return empty
+    }
+    return {};
+}
+/**
+ * Save global configuration
+ */
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * Check if Claude Code CLI is installed
+ */
+export async function isClaudeCodeInstalled() {
+    try {
+        const claudePath = getClaudePath();
+        const result = await execa(claudePath, ['--version'], { reject: false });
+        if (result.exitCode === 0) {
+            const version = typeof result.stdout === 'string' ? result.stdout.trim() : '';
+            return { installed: true, version };
+        }
+        return { installed: false, error: 'Claude Code CLI returned non-zero exit code' };
+    }
+    catch (error) {
+        return {
+            installed: false,
+            error: error instanceof Error ? error.message : 'Claude Code CLI not found',
+        };
+    }
+}
+/**
+ * Check if Claude Code is authenticated (can make API calls)
+ * Uses cached validation to avoid expensive API calls on every startup
+ */
+export async function isClaudeCodeAuthenticated(forceCheck = false) {
+    // Check cache first (valid for 1 hour)
+    const config = loadConfig();
+    const cacheValidMs = 60 * 60 * 1000; // 1 hour
+    if (!forceCheck && config.claudeCodeValidated && config.lastValidated) {
+        const lastCheck = new Date(config.lastValidated).getTime();
+        const now = Date.now();
+        if (now - lastCheck < cacheValidMs) {
+            return { authenticated: true };
+        }
+    }
+    try {
+        const claudePath = getClaudePath();
+        // Try a simple command that requires auth
+        const result = await execa(claudePath, ['--print', '-p', 'Say "ok"'], {
+            reject: false,
+            timeout: 30000,
+            stdin: 'ignore',
+        });
+        if (result.exitCode === 0) {
+            // Cache successful validation
+            saveConfig({
+                ...config,
+                claudeCodeValidated: true,
+                lastValidated: new Date().toISOString(),
+            });
+            return { authenticated: true };
+        }
+        const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+        if (stderr.includes('auth') || stderr.includes('login') || stderr.includes('API')) {
+            // Clear cache on auth failure
+            saveConfig({
+                ...config,
+                claudeCodeValidated: false,
+                lastValidated: undefined,
+            });
+            return { authenticated: false, error: 'Claude Code is not authenticated. Run: claude login' };
+        }
+        return { authenticated: true }; // Assume authenticated if no auth error
+    }
+    catch (error) {
+        return {
+            authenticated: false,
+            error: error instanceof Error ? error.message : 'Failed to check authentication',
+        };
+    }
+}
+/**
+ * Test Claude Code interaction with tool use
+ * This catches API errors like rate limiting or concurrency issues
+ */
+export async function testClaudeInteraction() {
+    try {
+        const claudePath = getClaudePath();
+        // Run a simple task that uses tools - this tests full interaction
+        // Note: --output-format stream-json requires --verbose when used with --print
+        const result = await execa(claudePath, ['--print', '--verbose', '--output-format', 'stream-json', '-p', 'List one file in the current directory using the Bash tool, then say "test complete"'], {
+            reject: false,
+            timeout: 60000, // 60 second timeout
+            stdin: 'ignore',
+            cwd: process.cwd(),
+        });
+        const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+        const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+        const combined = stdout + stderr;
+        // Check for OAuth token expiration (401 + authentication_error)
+        if (combined.includes('OAuth token has expired') ||
+            combined.includes('authentication_error') ||
+            (combined.includes('API Error: 401') || combined.includes('API Error:401'))) {
+            return {
+                success: false,
+                error: 'OAuth token has expired. Please run /login to re-authenticate.',
+                output: stdout,
+                tokenExpired: true,
+            };
+        }
+        // Check for API errors in output
+        if (stdout.includes('API Error:') || stderr.includes('API Error:')) {
+            const apiErrorMatch = (stdout + stderr).match(/API Error:\s*(\d+)\s*([^\n]+)?/i);
+            if (apiErrorMatch) {
+                return {
+                    success: false,
+                    error: `API Error ${apiErrorMatch[1]}: ${apiErrorMatch[2] || 'Unknown error'}`,
+                    output: stdout,
+                };
+            }
+            return { success: false, error: 'API Error occurred', output: stdout };
+        }
+        // Check for rate limiting
+        if (stdout.includes('rate limit') || stderr.includes('rate limit') ||
+            stdout.includes('concurrency') || stderr.includes('concurrency')) {
+            return { success: false, error: 'Rate limited or concurrency issues', output: stdout };
+        }
+        if (result.exitCode === 0) {
+            return { success: true, output: stdout };
+        }
+        // Non-zero exit - check stderr for specific errors
+        if (stderr.includes('auth') || stderr.includes('login')) {
+            return { success: false, error: 'Authentication error', output: stdout };
+        }
+        return { success: false, error: stderr || `Exit code ${result.exitCode}`, output: stdout };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to test interaction',
+        };
+    }
+}
+/**
+ * Launch Claude Code /login command interactively to re-authenticate
+ * Returns true if login was successful
+ */
+export async function launchClaudeLogin() {
+    try {
+        const claudePath = getClaudePath();
+        // Spawn Claude Code interactively with /login - user can interact directly
+        const result = await execa(claudePath, ['/login'], {
+            stdio: 'inherit', // Connect to user's terminal for interactive login
+            reject: false,
+        });
+        return result.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if maistro is configured (Claude Code CLI is available and authenticated)
+ */
+export async function isConfigured() {
+    const installed = await isClaudeCodeInstalled();
+    if (!installed.installed)
+        return false;
+    const authenticated = await isClaudeCodeAuthenticated();
+    return authenticated.authenticated;
+}
+/**
+ * Get config file path (for display)
+ */
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+/**
+ * Get the preventSleep setting (defaults to true)
+ */
+export function getPreventSleep() {
+    const config = loadConfig();
+    return config.preventSleep ?? DEFAULT_SETTINGS.preventSleep;
+}
+/**
+ * Set the preventSleep setting
+ */
+export function setPreventSleep(value) {
+    const config = loadConfig();
+    saveConfig({
+        ...config,
+        preventSleep: value,
+    });
+}
+/**
+ * Detect the current terminal emulator
+ */
+export function detectTerminal() {
+    const termProgram = process.env.TERM_PROGRAM || '';
+    const termProgramVersion = process.env.TERM_PROGRAM_VERSION || '';
+    const term = process.env.TERM || '';
+    const lcTerminal = process.env.LC_TERMINAL || '';
+    const wtSession = process.env.WT_SESSION || '';
+    const alacrittySocket = process.env.ALACRITTY_SOCKET || '';
+    const kitty = process.env.KITTY_WINDOW_ID || '';
+    const wezterm = process.env.WEZTERM_EXECUTABLE || '';
+    const ghostty = process.env.GHOSTTY_RESOURCES_DIR || '';
+    // Ghostty - native support
+    if (ghostty || termProgram === 'ghostty') {
+        return {
+            name: 'Ghostty',
+            program: 'ghostty',
+            supportsShiftEnter: true,
+            configurable: false,
+        };
+    }
+    // WezTerm - native support
+    if (wezterm || termProgram === 'WezTerm') {
+        return {
+            name: 'WezTerm',
+            program: 'wezterm',
+            supportsShiftEnter: true,
+            configurable: false,
+        };
+    }
+    // Kitty - native support with CSI u protocol
+    if (kitty || term === 'xterm-kitty') {
+        return {
+            name: 'Kitty',
+            program: 'kitty',
+            supportsShiftEnter: true,
+            configurable: false,
+        };
+    }
+    // VS Code integrated terminal
+    if (termProgram === 'vscode') {
+        return {
+            name: 'VS Code Terminal',
+            program: 'vscode',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Open VS Code Settings (Cmd+, or Ctrl+,)',
+                'Search for "terminal.integrated.sendKeybindingsToShell"',
+                'Enable this setting',
+                '',
+                'Or add to keybindings.json (Cmd+K Cmd+S → Open Keyboard Shortcuts JSON):',
+                '{',
+                '  "key": "shift+enter",',
+                '  "command": "workbench.action.terminal.sendSequence",',
+                '  "args": { "text": "\\n" },',
+                '  "when": "terminalFocus"',
+                '}',
+            ],
+        };
+    }
+    // Windows Terminal
+    if (wtSession) {
+        return {
+            name: 'Windows Terminal',
+            program: 'windows-terminal',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Open Windows Terminal settings (Ctrl+,)',
+                'Go to Actions tab',
+                'Add a new action:',
+                '  - Keys: shift+enter',
+                '  - Action: Send Input',
+                '  - Input: \\x0a',
+            ],
+        };
+    }
+    // Alacritty
+    if (alacrittySocket || termProgram === 'Alacritty') {
+        return {
+            name: 'Alacritty',
+            program: 'alacritty',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Add to ~/.config/alacritty/alacritty.toml:',
+                '',
+                '[keyboard]',
+                'bindings = [',
+                '  { key = "Return", mods = "Shift", chars = "\\u000a" }',
+                ']',
+            ],
+        };
+    }
+    // iTerm2
+    if (termProgram === 'iTerm.app' || lcTerminal === 'iTerm2') {
+        return {
+            name: 'iTerm2',
+            program: 'iterm2',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Open iTerm2 → Preferences → Keys → Key Bindings',
+                'Click the + button to add a new binding:',
+                '  - Keyboard Shortcut: Shift + Enter',
+                '  - Action: Send Escape Sequence',
+                '  - Esc+: OM',
+                '',
+                'Or use: Action → Send Text with "vi Special Chars"',
+                '  - Enter: \\n',
+            ],
+        };
+    }
+    // Terminal.app (macOS)
+    if (termProgram === 'Apple_Terminal') {
+        return {
+            name: 'Terminal.app',
+            program: 'apple-terminal',
+            supportsShiftEnter: false,
+            configurable: false, // Terminal.app doesn't support custom key bindings easily
+            instructions: [
+                'Terminal.app has limited key binding customization.',
+                'Use Ctrl+J for newlines instead of Shift+Enter.',
+                '',
+                'Or consider switching to iTerm2, Kitty, WezTerm, or Ghostty',
+                'which have better keyboard customization support.',
+            ],
+        };
+    }
+    // Zed
+    if (termProgram === 'Zed') {
+        return {
+            name: 'Zed Terminal',
+            program: 'zed',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Add to ~/.config/zed/keymap.json:',
+                '',
+                '[',
+                '  {',
+                '    "context": "Terminal",',
+                '    "bindings": {',
+                '      "shift-enter": ["terminal::SendKeystroke", "\\n"]',
+                '    }',
+                '  }',
+                ']',
+            ],
+        };
+    }
+    // Warp
+    if (termProgram === 'WarpTerminal') {
+        return {
+            name: 'Warp',
+            program: 'warp',
+            supportsShiftEnter: false,
+            configurable: true,
+            instructions: [
+                'Open Warp → Settings → Keyboard Shortcuts',
+                'Add a custom shortcut:',
+                '  - Shortcut: Shift + Enter',
+                '  - Action: Send text',
+                '  - Text: \\n',
+            ],
+        };
+    }
+    // Unknown terminal
+    return {
+        name: termProgram || term || 'Unknown Terminal',
+        program: 'unknown',
+        supportsShiftEnter: false,
+        configurable: false,
+        instructions: [
+            'Your terminal may not support custom Shift+Enter bindings.',
+            'Use Ctrl+J for newlines (this works in all terminals).',
+        ],
+    };
+}
+/**
+ * Check if terminal setup has been shown
+ */
+export function isTerminalSetupShown() {
+    const config = loadConfig();
+    return config.terminalSetupShown === true;
+}
+/**
+ * Mark terminal setup as shown
+ */
+export function setTerminalSetupShown(value) {
+    const config = loadConfig();
+    saveConfig({
+        ...config,
+        terminalSetupShown: value,
+    });
+}
+/**
+ * Get the shiftEnterEnabled setting
+ */
+export function getShiftEnterEnabled() {
+    const config = loadConfig();
+    return config.shiftEnterEnabled === true;
+}
+/**
+ * Set the shiftEnterEnabled setting
+ */
+export function setShiftEnterEnabled(value) {
+    const config = loadConfig();
+    saveConfig({
+        ...config,
+        shiftEnterEnabled: value,
+    });
+}
+/**
+ * Get the cmdVPasteEnabled setting
+ */
+export function getCmdVPasteEnabled() {
+    const config = loadConfig();
+    return config.cmdVPasteEnabled === true;
+}
+/**
+ * Set the cmdVPasteEnabled setting
+ */
+export function setCmdVPasteEnabled(value) {
+    const config = loadConfig();
+    saveConfig({
+        ...config,
+        cmdVPasteEnabled: value,
+    });
+}
+/**
+ * VS Code keybinding for Shift+Enter
+ */
+// VS Code keybinding sends the Kitty keyboard protocol sequence for Shift+Enter
+// This is explicitly handled by maistro as a newline insertion
+const VSCODE_SHIFT_ENTER_KEYBINDING = {
+    key: 'shift+enter',
+    command: 'workbench.action.terminal.sendSequence',
+    args: { text: '\x1b[13;2u' },
+    when: 'terminalFocus',
+};
+/**
+ * VS Code keybinding for Cmd+V (clipboard paste)
+ */
+// VS Code keybinding sends the Kitty keyboard protocol sequence for Cmd+V
+// 118 = 'v', 9 = Super/Cmd modifier
+const VSCODE_CMD_V_KEYBINDING = {
+    key: 'cmd+v',
+    command: 'workbench.action.terminal.sendSequence',
+    args: { text: '\x1b[118;9u' },
+    when: 'terminalFocus',
+};
+/**
+ * Get VS Code keybindings.json path
+ */
+function getVSCodeKeybindingsPath() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'keybindings.json');
+    }
+    else if (platform === 'win32') {
+        return join(homedir(), 'AppData', 'Roaming', 'Code', 'User', 'keybindings.json');
+    }
+    else {
+        return join(homedir(), '.config', 'Code', 'User', 'keybindings.json');
+    }
+}
+/**
+ * Check if VS Code Shift+Enter keybinding is already configured
+ */
+export function isVSCodeShiftEnterConfigured() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    if (!existsSync(keybindingsPath)) {
+        return false;
+    }
+    try {
+        let content = readFileSync(keybindingsPath, 'utf-8');
+        // Remove comments (VS Code keybindings.json supports comments)
+        content = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const keybindings = JSON.parse(content);
+        if (!Array.isArray(keybindings)) {
+            return false;
+        }
+        // Check if a shift+enter binding for terminal exists
+        return keybindings.some((kb) => kb.key === 'shift+enter' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Configure VS Code Shift+Enter keybinding
+ * Returns { success, error?, backupPath? }
+ */
+export function configureVSCodeShiftEnter() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    const keybindingsDir = join(keybindingsPath, '..');
+    try {
+        // Ensure directory exists
+        if (!existsSync(keybindingsDir)) {
+            mkdirSync(keybindingsDir, { recursive: true });
+        }
+        let keybindings = [];
+        let backupPath;
+        // Read existing keybindings if file exists
+        if (existsSync(keybindingsPath)) {
+            const content = readFileSync(keybindingsPath, 'utf-8');
+            // Backup existing file
+            backupPath = keybindingsPath + '.maistro-backup';
+            writeFileSync(backupPath, content, 'utf-8');
+            // Parse (remove comments first)
+            const cleanContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            try {
+                keybindings = JSON.parse(cleanContent);
+                if (!Array.isArray(keybindings)) {
+                    keybindings = [];
+                }
+            }
+            catch {
+                // If parse fails, start fresh but keep backup
+                keybindings = [];
+            }
+        }
+        // Check if already configured
+        const existingIndex = keybindings.findIndex((kb) => kb.key === 'shift+enter' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus'));
+        if (existingIndex >= 0) {
+            // Already configured
+            return { success: true };
+        }
+        // Add the keybinding
+        keybindings.push(VSCODE_SHIFT_ENTER_KEYBINDING);
+        // Write back
+        writeFileSync(keybindingsPath, JSON.stringify(keybindings, null, 2), 'utf-8');
+        return { success: true, backupPath };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to configure VS Code',
+        };
+    }
+}
+/**
+ * Remove VS Code Shift+Enter keybinding
+ */
+export function removeVSCodeShiftEnter() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    if (!existsSync(keybindingsPath)) {
+        return { success: true }; // Nothing to remove
+    }
+    try {
+        const content = readFileSync(keybindingsPath, 'utf-8');
+        const cleanContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        let keybindings;
+        try {
+            keybindings = JSON.parse(cleanContent);
+            if (!Array.isArray(keybindings)) {
+                return { success: true };
+            }
+        }
+        catch {
+            return { success: true };
+        }
+        // Remove the keybinding
+        const filtered = keybindings.filter((kb) => !(kb.key === 'shift+enter' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus')));
+        if (filtered.length === keybindings.length) {
+            // Nothing was removed
+            return { success: true };
+        }
+        // Write back
+        writeFileSync(keybindingsPath, JSON.stringify(filtered, null, 2), 'utf-8');
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to remove VS Code keybinding',
+        };
+    }
+}
+/**
+ * Check if VS Code Cmd+V keybinding is already configured
+ */
+export function isVSCodeCmdVConfigured() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    if (!existsSync(keybindingsPath)) {
+        return false;
+    }
+    try {
+        let content = readFileSync(keybindingsPath, 'utf-8');
+        content = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const keybindings = JSON.parse(content);
+        if (!Array.isArray(keybindings)) {
+            return false;
+        }
+        return keybindings.some((kb) => kb.key === 'cmd+v' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Configure VS Code Cmd+V keybinding for clipboard paste
+ */
+export function configureVSCodeCmdV() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    const keybindingsDir = join(keybindingsPath, '..');
+    try {
+        if (!existsSync(keybindingsDir)) {
+            mkdirSync(keybindingsDir, { recursive: true });
+        }
+        let keybindings = [];
+        let backupPath;
+        if (existsSync(keybindingsPath)) {
+            const content = readFileSync(keybindingsPath, 'utf-8');
+            backupPath = keybindingsPath + '.maistro-backup';
+            writeFileSync(backupPath, content, 'utf-8');
+            const cleanContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            try {
+                keybindings = JSON.parse(cleanContent);
+                if (!Array.isArray(keybindings)) {
+                    keybindings = [];
+                }
+            }
+            catch {
+                keybindings = [];
+            }
+        }
+        const existingIndex = keybindings.findIndex((kb) => kb.key === 'cmd+v' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus'));
+        if (existingIndex >= 0) {
+            return { success: true };
+        }
+        keybindings.push(VSCODE_CMD_V_KEYBINDING);
+        writeFileSync(keybindingsPath, JSON.stringify(keybindings, null, 2), 'utf-8');
+        return { success: true, backupPath };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to configure VS Code',
+        };
+    }
+}
+/**
+ * Remove VS Code Cmd+V keybinding
+ */
+export function removeVSCodeCmdV() {
+    const keybindingsPath = getVSCodeKeybindingsPath();
+    if (!existsSync(keybindingsPath)) {
+        return { success: true };
+    }
+    try {
+        const content = readFileSync(keybindingsPath, 'utf-8');
+        const cleanContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        let keybindings;
+        try {
+            keybindings = JSON.parse(cleanContent);
+            if (!Array.isArray(keybindings)) {
+                return { success: true };
+            }
+        }
+        catch {
+            return { success: true };
+        }
+        const filtered = keybindings.filter((kb) => !(kb.key === 'cmd+v' &&
+            kb.command === 'workbench.action.terminal.sendSequence' &&
+            kb.when?.includes('terminalFocus')));
+        if (filtered.length === keybindings.length) {
+            return { success: true };
+        }
+        writeFileSync(keybindingsPath, JSON.stringify(filtered, null, 2), 'utf-8');
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to remove VS Code keybinding',
+        };
+    }
+}
+/**
+ * Configure terminal for Cmd+V paste support
+ * Warning: VS Code keybindings with "terminalFocus" affect ALL terminals,
+ * which may interfere with other terminal apps like Claude Code.
+ */
+export function configureTerminalCmdVPaste(terminalInfo) {
+    // VS Code: Can be configured but affects all terminals (may break Claude Code)
+    if (terminalInfo.program === 'vscode') {
+        const result = configureVSCodeCmdV();
+        if (result.success) {
+            return {
+                success: true,
+                message: 'VS Code Cmd+V keybinding configured',
+                backupPath: result.backupPath,
+                warning: 'This affects ALL VS Code terminals, including other apps like Claude Code.',
+            };
+        }
+        return result;
+    }
+    // Other terminals require manual configuration
+    return {
+        success: false,
+        error: `Automatic configuration not supported for ${terminalInfo.name}. See instructions for manual setup.`,
+    };
+}
+/**
+ * Remove terminal Cmd+V paste configuration
+ */
+export function removeTerminalCmdVPaste(terminalInfo) {
+    switch (terminalInfo.program) {
+        case 'vscode': {
+            const result = removeVSCodeCmdV();
+            if (result.success) {
+                return { success: true, message: 'VS Code Cmd+V keybinding removed' };
+            }
+            return result;
+        }
+        default:
+            return { success: true };
+    }
+}
+/**
+ * Configure terminal for Shift+Enter support
+ * Returns result with success status and any messages
+ */
+export function configureTerminalShiftEnter(terminalInfo) {
+    // Terminals with native support don't need configuration
+    if (terminalInfo.supportsShiftEnter) {
+        return { success: true, message: 'Terminal already supports Shift+Enter natively' };
+    }
+    // Handle each configurable terminal
+    switch (terminalInfo.program) {
+        case 'vscode': {
+            const result = configureVSCodeShiftEnter();
+            if (result.success) {
+                return {
+                    success: true,
+                    message: 'VS Code keybinding configured. Restart terminal for changes to take effect.',
+                    backupPath: result.backupPath,
+                };
+            }
+            return result;
+        }
+        // TODO: Add support for other terminals
+        // case 'iterm2':
+        // case 'alacritty':
+        // case 'zed':
+        default:
+            return {
+                success: false,
+                error: `Automatic configuration not supported for ${terminalInfo.name}. Use Ctrl+J instead.`,
+            };
+    }
+}
+/**
+ * Remove terminal Shift+Enter configuration
+ */
+export function removeTerminalShiftEnter(terminalInfo) {
+    if (terminalInfo.supportsShiftEnter) {
+        return { success: true, message: 'Terminal has native support, nothing to remove' };
+    }
+    switch (terminalInfo.program) {
+        case 'vscode': {
+            const result = removeVSCodeShiftEnter();
+            if (result.success) {
+                return { success: true, message: 'VS Code keybinding removed' };
+            }
+            return result;
+        }
+        default:
+            return { success: true };
+    }
+}
+/**
+ * Get the appropriate newline hint based on terminal configuration
+ * Returns "Ctrl+J newline" or "Ctrl+J | Shift+Enter newline"
+ */
+export function getNewlineHint() {
+    const terminalInfo = detectTerminal();
+    const shiftEnterEnabled = getShiftEnterEnabled();
+    // Show Shift+Enter hint if terminal has native support or is configured
+    if (terminalInfo.supportsShiftEnter || shiftEnterEnabled) {
+        return 'Ctrl+J | Shift+Enter newline';
+    }
+    return 'Ctrl+J newline';
+}
+/**
+ * Get terminal-specific instructions for configuring Cmd+V paste
+ * macOS terminals intercept Cmd+V for their own paste handling
+ * We need them to send an escape sequence we can detect
+ */
+export function getCmdVPasteInstructions() {
+    const terminalInfo = detectTerminal();
+    switch (terminalInfo.program) {
+        case 'iterm2':
+            return {
+                terminal: 'iTerm2',
+                instructions: [
+                    'Open iTerm2 → Preferences → Keys → Key Bindings',
+                    'Click the + button to add a new binding:',
+                    '  - Keyboard Shortcut: ⌘V (Cmd+V)',
+                    '  - Action: Send Escape Sequence',
+                    '  - Esc+: OV',
+                    '',
+                    'This makes Cmd+V send \\x1bOV which maistro detects for image paste.',
+                ],
+            };
+        case 'kitty':
+            return {
+                terminal: 'Kitty',
+                instructions: [
+                    'Kitty uses the CSI u keyboard protocol.',
+                    'Add to ~/.config/kitty/kitty.conf:',
+                    '',
+                    'map cmd+v send_text all \\x1b[118;9u',
+                    '',
+                    'Or Kitty may already send this sequence natively.',
+                ],
+            };
+        case 'wezterm':
+            return {
+                terminal: 'WezTerm',
+                instructions: [
+                    'Add to ~/.wezterm.lua:',
+                    '',
+                    'return {',
+                    '  keys = {',
+                    '    { key = "v", mods = "CMD", action = wezterm.action.SendString("\\x1b[118;9u") },',
+                    '  },',
+                    '}',
+                ],
+            };
+        case 'ghostty':
+            return {
+                terminal: 'Ghostty',
+                instructions: [
+                    'Add to ~/.config/ghostty/config:',
+                    '',
+                    'keybind = cmd+v=text:\\x1b[118;9u',
+                ],
+            };
+        case 'vscode':
+            return {
+                terminal: 'VS Code Terminal',
+                instructions: [
+                    '\x1b[33m⚠ WARNING:\x1b[0m VS Code keybindings with "terminalFocus" affect ALL terminals.',
+                    'This will change Cmd+V behavior in every terminal, including Claude Code.',
+                    '',
+                    '\x1b[1mOption 1: Enable Cmd+V override\x1b[0m (may affect other terminal apps)',
+                    '  Use the Settings menu to enable "Cmd+V for image paste"',
+                    '  To remove later: toggle OFF in Settings or delete the keybinding from:',
+                    '  ~/Library/Application Support/Code/User/keybindings.json',
+                    '',
+                    '\x1b[1mOption 2: Use Ctrl+V instead\x1b[0m (recommended, no conflicts)',
+                    '  Ctrl+V sends the standard paste sequence (\\x16) that maistro detects.',
+                    '  This works without any configuration and won\'t affect other apps.',
+                    '',
+                    '\x1b[1mOption 3: Use /paste command\x1b[0m',
+                    '  Type /paste in maistro to paste images from clipboard.',
+                ],
+            };
+        case 'alacritty':
+            return {
+                terminal: 'Alacritty',
+                instructions: [
+                    'Add to ~/.config/alacritty/alacritty.toml:',
+                    '',
+                    '[keyboard]',
+                    'bindings = [',
+                    '  { key = "V", mods = "Command", chars = "\\u001b[118;9u" }',
+                    ']',
+                ],
+            };
+        case 'apple-terminal':
+            return {
+                terminal: 'Terminal.app',
+                instructions: [
+                    'Terminal.app has limited key binding customization.',
+                    'Use /paste command to paste images from clipboard.',
+                    '',
+                    'Or consider switching to iTerm2, Kitty, WezTerm, or Ghostty',
+                    'which have better keyboard customization support.',
+                ],
+            };
+        default:
+            return {
+                terminal: terminalInfo.name,
+                instructions: [
+                    'Configure your terminal to send \\x1b[118;9u for Cmd+V.',
+                    'Or use the /paste command to paste images from clipboard.',
+                ],
+            };
+    }
+}
+//# sourceMappingURL=config.js.map