thaddeus 1.0.26 → 1.0.28

package/src/commands/terminalSetup/terminalSetup.js

@@ -0,0 +1,491 @@
+import chalk from 'chalk';
+import { randomBytes } from 'crypto';
+import { copyFile, mkdir, readFile, writeFile } from 'fs/promises';
+import { homedir, platform } from 'os';
+import { dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+import { supportsHyperlinks } from '../../ink/supports-hyperlinks.js';
+import { color } from '../../ink.js';
+import { maybeMarkProjectOnboardingComplete } from '../../projectOnboardingState.js';
+import { backupTerminalPreferences, checkAndRestoreTerminalBackup, getTerminalPlistPath, markTerminalSetupComplete } from '../../utils/appleTerminalBackup.js';
+import { setupShellCompletion } from '../../utils/completionCache.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { env } from '../../utils/env.js';
+import { isFsInaccessible } from '../../utils/errors.js';
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js';
+import { addItemToJSONCArray, safeParseJSONC } from '../../utils/json.js';
+import { logError } from '../../utils/log.js';
+import { getPlatform } from '../../utils/platform.js';
+import { jsonParse, jsonStringify } from '../../utils/slowOperations.js';
+const EOL = '\n';
+// Terminals that natively support CSI u / Kitty keyboard protocol
+const NATIVE_CSIU_TERMINALS = {
+    ghostty: 'Ghostty',
+    kitty: 'Kitty',
+    'iTerm.app': 'iTerm2',
+    WezTerm: 'WezTerm',
+    WarpTerminal: 'Warp'
+};
+/**
+ * Detect if we're running in a VSCode Remote SSH session.
+ * In this case, keybindings need to be installed on the LOCAL machine,
+ * not the remote server where Thaddeus is running.
+ */
+function isVSCodeRemoteSSH() {
+    const askpassMain = process.env.VSCODE_GIT_ASKPASS_MAIN ?? '';
+    const path = process.env.PATH ?? '';
+    // Check both env vars - VSCODE_GIT_ASKPASS_MAIN is more reliable when git extension
+    // is active, and PATH is a fallback. Omit path separator for Windows compatibility.
+    return askpassMain.includes('.vscode-server') || askpassMain.includes('.cursor-server') || askpassMain.includes('.windsurf-server') || path.includes('.vscode-server') || path.includes('.cursor-server') || path.includes('.windsurf-server');
+}
+export function getNativeCSIuTerminalDisplayName() {
+    if (!env.terminal || !(env.terminal in NATIVE_CSIU_TERMINALS)) {
+        return null;
+    }
+    return NATIVE_CSIU_TERMINALS[env.terminal] ?? null;
+}
+/**
+ * Format a file path as a clickable hyperlink.
+ *
+ * Paths containing spaces (e.g., "Application Support") are not clickable
+ * in most terminals - they get split at the space. OSC 8 hyperlinks solve
+ * this by embedding a file:// URL that the terminal can open on click,
+ * while displaying the clean path to the user.
+ *
+ * Unlike createHyperlink(), this doesn't apply any color styling so the
+ * path inherits the parent's styling (e.g., chalk.dim).
+ */
+function formatPathLink(filePath) {
+    if (!supportsHyperlinks()) {
+        return filePath;
+    }
+    const fileUrl = pathToFileURL(filePath).href;
+    // OSC 8 hyperlink: \e]8;;URL\a TEXT \e]8;;\a
+    return `\x1b]8;;${fileUrl}\x07${filePath}\x1b]8;;\x07`;
+}
+export function shouldOfferTerminalSetup() {
+    // iTerm2, WezTerm, Ghostty, Kitty, and Warp natively support CSI u / Kitty
+    // keyboard protocol, which Thaddeus already parses. No setup needed for
+    // these terminals.
+    return platform() === 'darwin' && env.terminal === 'Apple_Terminal' || env.terminal === 'vscode' || env.terminal === 'cursor' || env.terminal === 'windsurf' || env.terminal === 'alacritty' || env.terminal === 'zed';
+}
+export async function setupTerminal(theme) {
+    let result = '';
+    switch (env.terminal) {
+        case 'Apple_Terminal':
+            result = await enableOptionAsMetaForTerminal(theme);
+            break;
+        case 'vscode':
+            result = await installBindingsForVSCodeTerminal('VSCode', theme);
+            break;
+        case 'cursor':
+            result = await installBindingsForVSCodeTerminal('Cursor', theme);
+            break;
+        case 'windsurf':
+            result = await installBindingsForVSCodeTerminal('Windsurf', theme);
+            break;
+        case 'alacritty':
+            result = await installBindingsForAlacritty(theme);
+            break;
+        case 'zed':
+            result = await installBindingsForZed(theme);
+            break;
+        case null:
+            break;
+    }
+    saveGlobalConfig(current => {
+        if (['vscode', 'cursor', 'windsurf', 'alacritty', 'zed'].includes(env.terminal ?? '')) {
+            if (current.shiftEnterKeyBindingInstalled === true)
+                return current;
+            return {
+                ...current,
+                shiftEnterKeyBindingInstalled: true
+            };
+        }
+        else if (env.terminal === 'Apple_Terminal') {
+            if (current.optionAsMetaKeyInstalled === true)
+                return current;
+            return {
+                ...current,
+                optionAsMetaKeyInstalled: true
+            };
+        }
+        return current;
+    });
+    maybeMarkProjectOnboardingComplete();
+    // Install shell completions (ant-only, since the completion command is ant-only)
+    if ("external" === 'ant') {
+        result += await setupShellCompletion(theme);
+    }
+    return result;
+}
+export function isShiftEnterKeyBindingInstalled() {
+    return getGlobalConfig().shiftEnterKeyBindingInstalled === true;
+}
+export function hasUsedBackslashReturn() {
+    return getGlobalConfig().hasUsedBackslashReturn === true;
+}
+export function markBackslashReturnUsed() {
+    const config = getGlobalConfig();
+    if (!config.hasUsedBackslashReturn) {
+        saveGlobalConfig(current => ({
+            ...current,
+            hasUsedBackslashReturn: true
+        }));
+    }
+}
+export async function call(onDone, context, _args) {
+    if (env.terminal && env.terminal in NATIVE_CSIU_TERMINALS) {
+        const message = `Shift+Enter is natively supported in ${NATIVE_CSIU_TERMINALS[env.terminal]}.
+
+No configuration needed. Just use Shift+Enter to add newlines.`;
+        onDone(message);
+        return null;
+    }
+    // Check if terminal is supported
+    if (!shouldOfferTerminalSetup()) {
+        const terminalName = env.terminal || 'your current terminal';
+        const currentPlatform = getPlatform();
+        // Build platform-specific terminal suggestions
+        let platformTerminals = '';
+        if (currentPlatform === 'macos') {
+            platformTerminals = '   • macOS: Apple Terminal\n';
+        }
+        else if (currentPlatform === 'windows') {
+            platformTerminals = '   • Windows: Windows Terminal\n';
+        }
+        // For Linux and other platforms, we don't show native terminal options
+        // since they're not currently supported
+        const message = `Terminal setup cannot be run from ${terminalName}.
+
+This command configures a convenient Shift+Enter shortcut for multi-line prompts.
+${chalk.dim('Note: You can already use backslash (\\\\) + return to add newlines.')}
+
+To set up the shortcut (optional):
+1. Exit tmux/screen temporarily
+2. Run /terminal-setup directly in one of these terminals:
+${platformTerminals}   • IDE: VSCode, Cursor, Windsurf, Zed
+   • Other: Alacritty
+3. Return to tmux/screen - settings will persist
+
+${chalk.dim('Note: iTerm2, WezTerm, Ghostty, Kitty, and Warp support Shift+Enter natively.')}`;
+        onDone(message);
+        return null;
+    }
+    const result = await setupTerminal(context.options.theme);
+    onDone(result);
+    return null;
+}
+async function installBindingsForVSCodeTerminal(editor = 'VSCode', theme) {
+    // Check if we're running in a VSCode Remote SSH session
+    // In this case, keybindings need to be installed on the LOCAL machine
+    if (isVSCodeRemoteSSH()) {
+        return `${color('warning', theme)(`Cannot install keybindings from a remote ${editor} session.`)}${EOL}${EOL}${editor} keybindings must be installed on your local machine, not the remote server.${EOL}${EOL}To install the Shift+Enter keybinding:${EOL}1. Open ${editor} on your local machine (not connected to remote)${EOL}2. Open the Command Palette (Cmd/Ctrl+Shift+P) → "Preferences: Open Keyboard Shortcuts (JSON)"${EOL}3. Add this keybinding (the file must be a JSON array):${EOL}${EOL}${chalk.dim(`[
+  {
+    "key": "shift+enter",
+    "command": "workbench.action.terminal.sendSequence",
+    "args": { "text": "\\u001b\\r" },
+    "when": "terminalFocus"
+  }
+]`)}${EOL}`;
+    }
+    const editorDir = editor === 'VSCode' ? 'Code' : editor;
+    const userDirPath = join(homedir(), platform() === 'win32' ? join('AppData', 'Roaming', editorDir, 'User') : platform() === 'darwin' ? join('Library', 'Application Support', editorDir, 'User') : join('.config', editorDir, 'User'));
+    const keybindingsPath = join(userDirPath, 'keybindings.json');
+    try {
+        // Ensure user directory exists (idempotent with recursive)
+        await mkdir(userDirPath, {
+            recursive: true
+        });
+        // Read existing keybindings file, or default to empty array if it doesn't exist
+        let content = '[]';
+        let keybindings = [];
+        let fileExists = false;
+        try {
+            content = await readFile(keybindingsPath, {
+                encoding: 'utf-8'
+            });
+            fileExists = true;
+            keybindings = safeParseJSONC(content) ?? [];
+        }
+        catch (e) {
+            if (!isFsInaccessible(e))
+                throw e;
+        }
+        // Backup the existing file before modifying it
+        if (fileExists) {
+            const randomSha = randomBytes(4).toString('hex');
+            const backupPath = `${keybindingsPath}.${randomSha}.bak`;
+            try {
+                await copyFile(keybindingsPath, backupPath);
+            }
+            catch {
+                return `${color('warning', theme)(`Error backing up existing ${editor} terminal keybindings. Bailing out.`)}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`;
+            }
+        }
+        // Check if keybinding already exists
+        const existingBinding = keybindings.find(binding => binding.key === 'shift+enter' && binding.command === 'workbench.action.terminal.sendSequence' && binding.when === 'terminalFocus');
+        if (existingBinding) {
+            return `${color('warning', theme)(`Found existing ${editor} terminal Shift+Enter key binding. Remove it to continue.`)}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}`;
+        }
+        // Create the new keybinding
+        const newKeybinding = {
+            key: 'shift+enter',
+            command: 'workbench.action.terminal.sendSequence',
+            args: {
+                text: '\u001b\r'
+            },
+            when: 'terminalFocus'
+        };
+        // Modify the content by adding the new keybinding while preserving comments and formatting
+        const updatedContent = addItemToJSONCArray(content, newKeybinding);
+        // Write the updated content back to the file
+        await writeFile(keybindingsPath, updatedContent, {
+            encoding: 'utf-8'
+        });
+        return `${color('success', theme)(`Installed ${editor} terminal Shift+Enter key binding`)}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}`;
+    }
+    catch (error) {
+        logError(error);
+        throw new Error(`Failed to install ${editor} terminal Shift+Enter key binding`);
+    }
+}
+async function enableOptionAsMetaForProfile(profileName) {
+    // First try to add the property (in case it doesn't exist)
+    // Quote the profile name to handle names with spaces (e.g., "Man Page", "Red Sands")
+    const { code: addCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', ['-c', `Add :'Window Settings':'${profileName}':useOptionAsMetaKey bool true`, getTerminalPlistPath()]);
+    // If adding fails (likely because it already exists), try setting it instead
+    if (addCode !== 0) {
+        const { code: setCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', ['-c', `Set :'Window Settings':'${profileName}':useOptionAsMetaKey true`, getTerminalPlistPath()]);
+        if (setCode !== 0) {
+            logError(new Error(`Failed to enable Option as Meta key for Terminal.app profile: ${profileName}`));
+            return false;
+        }
+    }
+    return true;
+}
+async function disableAudioBellForProfile(profileName) {
+    // First try to add the property (in case it doesn't exist)
+    // Quote the profile name to handle names with spaces (e.g., "Man Page", "Red Sands")
+    const { code: addCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', ['-c', `Add :'Window Settings':'${profileName}':Bell bool false`, getTerminalPlistPath()]);
+    // If adding fails (likely because it already exists), try setting it instead
+    if (addCode !== 0) {
+        const { code: setCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', ['-c', `Set :'Window Settings':'${profileName}':Bell false`, getTerminalPlistPath()]);
+        if (setCode !== 0) {
+            logError(new Error(`Failed to disable audio bell for Terminal.app profile: ${profileName}`));
+            return false;
+        }
+    }
+    return true;
+}
+// Enable Option as Meta key for Terminal.app
+async function enableOptionAsMetaForTerminal(theme) {
+    try {
+        // Create a backup of the current plist file
+        const backupPath = await backupTerminalPreferences();
+        if (!backupPath) {
+            throw new Error('Failed to create backup of Terminal.app preferences, bailing out');
+        }
+        // Read the current default profile from the plist
+        const { stdout: defaultProfile, code: readCode } = await execFileNoThrow('defaults', ['read', 'com.apple.Terminal', 'Default Window Settings']);
+        if (readCode !== 0 || !defaultProfile.trim()) {
+            throw new Error('Failed to read default Terminal.app profile');
+        }
+        const { stdout: startupProfile, code: startupCode } = await execFileNoThrow('defaults', ['read', 'com.apple.Terminal', 'Startup Window Settings']);
+        if (startupCode !== 0 || !startupProfile.trim()) {
+            throw new Error('Failed to read startup Terminal.app profile');
+        }
+        let wasAnyProfileUpdated = false;
+        const defaultProfileName = defaultProfile.trim();
+        const optionAsMetaEnabled = await enableOptionAsMetaForProfile(defaultProfileName);
+        const audioBellDisabled = await disableAudioBellForProfile(defaultProfileName);
+        if (optionAsMetaEnabled || audioBellDisabled) {
+            wasAnyProfileUpdated = true;
+        }
+        const startupProfileName = startupProfile.trim();
+        // Only proceed if the startup profile is different from the default profile
+        if (startupProfileName !== defaultProfileName) {
+            const startupOptionAsMetaEnabled = await enableOptionAsMetaForProfile(startupProfileName);
+            const startupAudioBellDisabled = await disableAudioBellForProfile(startupProfileName);
+            if (startupOptionAsMetaEnabled || startupAudioBellDisabled) {
+                wasAnyProfileUpdated = true;
+            }
+        }
+        if (!wasAnyProfileUpdated) {
+            throw new Error('Failed to enable Option as Meta key or disable audio bell for any Terminal.app profile');
+        }
+        // Flush the preferences cache
+        await execFileNoThrow('killall', ['cfprefsd']);
+        markTerminalSetupComplete();
+        return `${color('success', theme)(`Configured Terminal.app settings:`)}${EOL}${color('success', theme)('- Enabled "Use Option as Meta key"')}${EOL}${color('success', theme)('- Switched to visual bell')}${EOL}${chalk.dim('Option+Enter will now enter a newline.')}${EOL}${chalk.dim('You must restart Terminal.app for changes to take effect.', theme)}${EOL}`;
+    }
+    catch (error) {
+        logError(error);
+        // Attempt to restore from backup
+        const restoreResult = await checkAndRestoreTerminalBackup();
+        const errorMessage = 'Failed to enable Option as Meta key for Terminal.app.';
+        if (restoreResult.status === 'restored') {
+            throw new Error(`${errorMessage} Your settings have been restored from backup.`);
+        }
+        else if (restoreResult.status === 'failed') {
+            throw new Error(`${errorMessage} Restoring from backup failed, try manually with: defaults import com.apple.Terminal ${restoreResult.backupPath}`);
+        }
+        else {
+            throw new Error(`${errorMessage} No backup was available to restore from.`);
+        }
+    }
+}
+async function installBindingsForAlacritty(theme) {
+    const ALACRITTY_KEYBINDING = `[[keyboard.bindings]]
+key = "Return"
+mods = "Shift"
+chars = "\\u001B\\r"`;
+    // Get Alacritty config file paths in order of preference
+    const configPaths = [];
+    // XDG config path (Linux and macOS)
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        configPaths.push(join(xdgConfigHome, 'alacritty', 'alacritty.toml'));
+    }
+    else {
+        configPaths.push(join(homedir(), '.config', 'alacritty', 'alacritty.toml'));
+    }
+    // Windows-specific path
+    if (platform() === 'win32') {
+        const appData = process.env.APPDATA;
+        if (appData) {
+            configPaths.push(join(appData, 'alacritty', 'alacritty.toml'));
+        }
+    }
+    // Find existing config file by attempting to read it, or use first preferred path
+    let configPath = null;
+    let configContent = '';
+    let configExists = false;
+    for (const path of configPaths) {
+        try {
+            configContent = await readFile(path, {
+                encoding: 'utf-8'
+            });
+            configPath = path;
+            configExists = true;
+            break;
+        }
+        catch (e) {
+            if (!isFsInaccessible(e))
+                throw e;
+            // File missing or inaccessible — try next config path
+        }
+    }
+    // If no config exists, use the first path (XDG/default location)
+    if (!configPath) {
+        configPath = configPaths[0] ?? null;
+    }
+    if (!configPath) {
+        throw new Error('No valid config path found for Alacritty');
+    }
+    try {
+        if (configExists) {
+            // Check if keybinding already exists (look for Shift+Return binding)
+            if (configContent.includes('mods = "Shift"') && configContent.includes('key = "Return"')) {
+                return `${color('warning', theme)('Found existing Alacritty Shift+Enter key binding. Remove it to continue.')}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}`;
+            }
+            // Create backup
+            const randomSha = randomBytes(4).toString('hex');
+            const backupPath = `${configPath}.${randomSha}.bak`;
+            try {
+                await copyFile(configPath, backupPath);
+            }
+            catch {
+                return `${color('warning', theme)('Error backing up existing Alacritty config. Bailing out.')}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`;
+            }
+        }
+        else {
+            // Ensure config directory exists (idempotent with recursive)
+            await mkdir(dirname(configPath), {
+                recursive: true
+            });
+        }
+        // Add the keybinding to the config
+        let updatedContent = configContent;
+        if (configContent && !configContent.endsWith('\n')) {
+            updatedContent += '\n';
+        }
+        updatedContent += '\n' + ALACRITTY_KEYBINDING + '\n';
+        // Write the updated config
+        await writeFile(configPath, updatedContent, {
+            encoding: 'utf-8'
+        });
+        return `${color('success', theme)('Installed Alacritty Shift+Enter key binding')}${EOL}${color('success', theme)('You may need to restart Alacritty for changes to take effect')}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}`;
+    }
+    catch (error) {
+        logError(error);
+        throw new Error('Failed to install Alacritty Shift+Enter key binding');
+    }
+}
+async function installBindingsForZed(theme) {
+    // Zed uses JSON keybindings similar to VSCode
+    const zedDir = join(homedir(), '.config', 'zed');
+    const keymapPath = join(zedDir, 'keymap.json');
+    try {
+        // Ensure zed directory exists (idempotent with recursive)
+        await mkdir(zedDir, {
+            recursive: true
+        });
+        // Read existing keymap file, or default to empty array if it doesn't exist
+        let keymapContent = '[]';
+        let fileExists = false;
+        try {
+            keymapContent = await readFile(keymapPath, {
+                encoding: 'utf-8'
+            });
+            fileExists = true;
+        }
+        catch (e) {
+            if (!isFsInaccessible(e))
+                throw e;
+        }
+        if (fileExists) {
+            // Check if keybinding already exists
+            if (keymapContent.includes('shift-enter')) {
+                return `${color('warning', theme)('Found existing Zed Shift+Enter key binding. Remove it to continue.')}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}`;
+            }
+            // Create backup
+            const randomSha = randomBytes(4).toString('hex');
+            const backupPath = `${keymapPath}.${randomSha}.bak`;
+            try {
+                await copyFile(keymapPath, backupPath);
+            }
+            catch {
+                return `${color('warning', theme)('Error backing up existing Zed keymap. Bailing out.')}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`;
+            }
+        }
+        // Parse and modify the keymap
+        let keymap;
+        try {
+            keymap = jsonParse(keymapContent);
+            if (!Array.isArray(keymap)) {
+                keymap = [];
+            }
+        }
+        catch {
+            keymap = [];
+        }
+        // Add the new keybinding for terminal context
+        keymap.push({
+            context: 'Terminal',
+            bindings: {
+                'shift-enter': ['terminal::SendText', '\u001b\r']
+            }
+        });
+        // Write the updated keymap
+        await writeFile(keymapPath, jsonStringify(keymap, null, 2) + '\n', {
+            encoding: 'utf-8'
+        });
+        return `${color('success', theme)('Installed Zed Shift+Enter key binding')}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}`;
+    }
+    catch (error) {
+        logError(error);
+        throw new Error('Failed to install Zed Shift+Enter key binding');
+    }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","randomBytes","copyFile","mkdir","readFile","writeFile","homedir","platform","dirname","join","ThemeName","pathToFileURL","supportsHyperlinks","color","maybeMarkProjectOnboardingComplete","ToolUseContext","LocalJSXCommandContext","LocalJSXCommandOnDone","backupTerminalPreferences","checkAndRestoreTerminalBackup","getTerminalPlistPath","markTerminalSetupComplete","setupShellCompletion","getGlobalConfig","saveGlobalConfig","env","isFsInaccessible","execFileNoThrow","addItemToJSONCArray","safeParseJSONC","logError","getPlatform","jsonParse","jsonStringify","EOL","NATIVE_CSIU_TERMINALS","Record","ghostty","kitty","WezTerm","WarpTerminal","isVSCodeRemoteSSH","askpassMain","process","VSCODE_GIT_ASKPASS_MAIN","path","PATH","includes","getNativeCSIuTerminalDisplayName","terminal","formatPathLink","filePath","fileUrl","href","shouldOfferTerminalSetup","setupTerminal","theme","Promise","result","enableOptionAsMetaForTerminal","installBindingsForVSCodeTerminal","installBindingsForAlacritty","installBindingsForZed","current","shiftEnterKeyBindingInstalled","optionAsMetaKeyInstalled","isShiftEnterKeyBindingInstalled","hasUsedBackslashReturn","markBackslashReturnUsed","config","call","onDone","context","_args","message","terminalName","currentPlatform","platformTerminals","dim","options","VSCodeKeybinding","key","command","args","text","when","editor","editorDir","userDirPath","keybindingsPath","recursive","content","keybindings","fileExists","encoding","e","randomSha","toString","backupPath","existingBinding","find","binding","newKeybinding","updatedContent","error","Error","enableOptionAsMetaForProfile","profileName","code","addCode","setCode","disableAudioBellForProfile","stdout","defaultProfile","readCode","trim","startupProfile","startupCode","wasAnyProfileUpdated","defaultProfileName","optionAsMetaEnabled","audioBellDisabled","startupProfileName","startupOptionAsMetaEnabled","startupAudioBellDisabled","restoreResult","errorMessage","status","ALACRITTY_KEYBINDING","configPaths","xdgConfigHome","XDG_CONFIG_HOME","push","appData","APPDATA","configPath","configContent","configExists","endsWith","zedDir","keymapPath","keymapContent","keymap","Array","bindings","isArray"],"sources":["terminalSetup.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport { randomBytes } from 'crypto'\nimport { copyFile, mkdir, readFile, writeFile } from 'fs/promises'\nimport { homedir, platform } from 'os'\nimport { dirname, join } from 'path'\nimport type { ThemeName } from 'src/utils/theme.js'\nimport { pathToFileURL } from 'url'\nimport { supportsHyperlinks } from '../../ink/supports-hyperlinks.js'\nimport { color } from '../../ink.js'\nimport { maybeMarkProjectOnboardingComplete } from '../../projectOnboardingState.js'\nimport type { ToolUseContext } from '../../Tool.js'\nimport type {\n  LocalJSXCommandContext,\n  LocalJSXCommandOnDone,\n} from '../../types/command.js'\nimport {\n  backupTerminalPreferences,\n  checkAndRestoreTerminalBackup,\n  getTerminalPlistPath,\n  markTerminalSetupComplete,\n} from '../../utils/appleTerminalBackup.js'\nimport { setupShellCompletion } from '../../utils/completionCache.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { env } from '../../utils/env.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { execFileNoThrow } from '../../utils/execFileNoThrow.js'\nimport { addItemToJSONCArray, safeParseJSONC } from '../../utils/json.js'\nimport { logError } from '../../utils/log.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { jsonParse, jsonStringify } from '../../utils/slowOperations.js'\n\nconst EOL = '\\n'\n\n// Terminals that natively support CSI u / Kitty keyboard protocol\nconst NATIVE_CSIU_TERMINALS: Record<string, string> = {\n  ghostty: 'Ghostty',\n  kitty: 'Kitty',\n  'iTerm.app': 'iTerm2',\n  WezTerm: 'WezTerm',\n  WarpTerminal: 'Warp',\n}\n\n/**\n * Detect if we're running in a VSCode Remote SSH session.\n * In this case, keybindings need to be installed on the LOCAL machine,\n * not the remote server where Claude is running.\n */\nfunction isVSCodeRemoteSSH(): boolean {\n  const askpassMain = process.env.VSCODE_GIT_ASKPASS_MAIN ?? ''\n  const path = process.env.PATH ?? ''\n\n  // Check both env vars - VSCODE_GIT_ASKPASS_MAIN is more reliable when git extension\n  // is active, and PATH is a fallback. Omit path separator for Windows compatibility.\n  return (\n    askpassMain.includes('.vscode-server') ||\n    askpassMain.includes('.cursor-server') ||\n    askpassMain.includes('.windsurf-server') ||\n    path.includes('.vscode-server') ||\n    path.includes('.cursor-server') ||\n    path.includes('.windsurf-server')\n  )\n}\n\nexport function getNativeCSIuTerminalDisplayName(): string | null {\n  if (!env.terminal || !(env.terminal in NATIVE_CSIU_TERMINALS)) {\n    return null\n  }\n  return NATIVE_CSIU_TERMINALS[env.terminal] ?? null\n}\n\n/**\n * Format a file path as a clickable hyperlink.\n *\n * Paths containing spaces (e.g., \"Application Support\") are not clickable\n * in most terminals - they get split at the space. OSC 8 hyperlinks solve\n * this by embedding a file:// URL that the terminal can open on click,\n * while displaying the clean path to the user.\n *\n * Unlike createHyperlink(), this doesn't apply any color styling so the\n * path inherits the parent's styling (e.g., chalk.dim).\n */\nfunction formatPathLink(filePath: string): string {\n  if (!supportsHyperlinks()) {\n    return filePath\n  }\n  const fileUrl = pathToFileURL(filePath).href\n  // OSC 8 hyperlink: \\e]8;;URL\\a TEXT \\e]8;;\\a\n  return `\\x1b]8;;${fileUrl}\\x07${filePath}\\x1b]8;;\\x07`\n}\n\nexport function shouldOfferTerminalSetup(): boolean {\n  // iTerm2, WezTerm, Ghostty, Kitty, and Warp natively support CSI u / Kitty\n  // keyboard protocol, which Claude Code already parses. No setup needed for\n  // these terminals.\n  return (\n    (platform() === 'darwin' && env.terminal === 'Apple_Terminal') ||\n    env.terminal === 'vscode' ||\n    env.terminal === 'cursor' ||\n    env.terminal === 'windsurf' ||\n    env.terminal === 'alacritty' ||\n    env.terminal === 'zed'\n  )\n}\n\nexport async function setupTerminal(theme: ThemeName): Promise<string> {\n  let result = ''\n\n  switch (env.terminal) {\n    case 'Apple_Terminal':\n      result = await enableOptionAsMetaForTerminal(theme)\n      break\n    case 'vscode':\n      result = await installBindingsForVSCodeTerminal('VSCode', theme)\n      break\n    case 'cursor':\n      result = await installBindingsForVSCodeTerminal('Cursor', theme)\n      break\n    case 'windsurf':\n      result = await installBindingsForVSCodeTerminal('Windsurf', theme)\n      break\n    case 'alacritty':\n      result = await installBindingsForAlacritty(theme)\n      break\n    case 'zed':\n      result = await installBindingsForZed(theme)\n      break\n    case null:\n      break\n  }\n\n  saveGlobalConfig(current => {\n    if (\n      ['vscode', 'cursor', 'windsurf', 'alacritty', 'zed'].includes(\n        env.terminal ?? '',\n      )\n    ) {\n      if (current.shiftEnterKeyBindingInstalled === true) return current\n      return { ...current, shiftEnterKeyBindingInstalled: true }\n    } else if (env.terminal === 'Apple_Terminal') {\n      if (current.optionAsMetaKeyInstalled === true) return current\n      return { ...current, optionAsMetaKeyInstalled: true }\n    }\n    return current\n  })\n\n  maybeMarkProjectOnboardingComplete()\n\n  // Install shell completions (ant-only, since the completion command is ant-only)\n  if (\"external\" === 'ant') {\n    result += await setupShellCompletion(theme)\n  }\n\n  return result\n}\n\nexport function isShiftEnterKeyBindingInstalled(): boolean {\n  return getGlobalConfig().shiftEnterKeyBindingInstalled === true\n}\n\nexport function hasUsedBackslashReturn(): boolean {\n  return getGlobalConfig().hasUsedBackslashReturn === true\n}\n\nexport function markBackslashReturnUsed(): void {\n  const config = getGlobalConfig()\n  if (!config.hasUsedBackslashReturn) {\n    saveGlobalConfig(current => ({\n      ...current,\n      hasUsedBackslashReturn: true,\n    }))\n  }\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: ToolUseContext & LocalJSXCommandContext,\n  _args: string,\n): Promise<null> {\n  if (env.terminal && env.terminal in NATIVE_CSIU_TERMINALS) {\n    const message = `Shift+Enter is natively supported in ${NATIVE_CSIU_TERMINALS[env.terminal]}.\n\nNo configuration needed. Just use Shift+Enter to add newlines.`\n    onDone(message)\n    return null\n  }\n\n  // Check if terminal is supported\n  if (!shouldOfferTerminalSetup()) {\n    const terminalName = env.terminal || 'your current terminal'\n    const currentPlatform = getPlatform()\n\n    // Build platform-specific terminal suggestions\n    let platformTerminals = ''\n    if (currentPlatform === 'macos') {\n      platformTerminals = '   • macOS: Apple Terminal\\n'\n    } else if (currentPlatform === 'windows') {\n      platformTerminals = '   • Windows: Windows Terminal\\n'\n    }\n    // For Linux and other platforms, we don't show native terminal options\n    // since they're not currently supported\n\n    const message = `Terminal setup cannot be run from ${terminalName}.\n\nThis command configures a convenient Shift+Enter shortcut for multi-line prompts.\n${chalk.dim('Note: You can already use backslash (\\\\\\\\) + return to add newlines.')}\n\nTo set up the shortcut (optional):\n1. Exit tmux/screen temporarily\n2. Run /terminal-setup directly in one of these terminals:\n${platformTerminals}   • IDE: VSCode, Cursor, Windsurf, Zed\n   • Other: Alacritty\n3. Return to tmux/screen - settings will persist\n\n${chalk.dim('Note: iTerm2, WezTerm, Ghostty, Kitty, and Warp support Shift+Enter natively.')}`\n    onDone(message)\n    return null\n  }\n\n  const result = await setupTerminal(context.options.theme)\n  onDone(result)\n  return null\n}\n\ntype VSCodeKeybinding = {\n  key: string\n  command: string\n  args: { text: string }\n  when: string\n}\n\nasync function installBindingsForVSCodeTerminal(\n  editor: 'VSCode' | 'Cursor' | 'Windsurf' = 'VSCode',\n  theme: ThemeName,\n): Promise<string> {\n  // Check if we're running in a VSCode Remote SSH session\n  // In this case, keybindings need to be installed on the LOCAL machine\n  if (isVSCodeRemoteSSH()) {\n    return `${color(\n      'warning',\n      theme,\n    )(\n      `Cannot install keybindings from a remote ${editor} session.`,\n    )}${EOL}${EOL}${editor} keybindings must be installed on your local machine, not the remote server.${EOL}${EOL}To install the Shift+Enter keybinding:${EOL}1. Open ${editor} on your local machine (not connected to remote)${EOL}2. Open the Command Palette (Cmd/Ctrl+Shift+P) → \"Preferences: Open Keyboard Shortcuts (JSON)\"${EOL}3. Add this keybinding (the file must be a JSON array):${EOL}${EOL}${chalk.dim(`[\n  {\n    \"key\": \"shift+enter\",\n    \"command\": \"workbench.action.terminal.sendSequence\",\n    \"args\": { \"text\": \"\\\\u001b\\\\r\" },\n    \"when\": \"terminalFocus\"\n  }\n]`)}${EOL}`\n  }\n\n  const editorDir = editor === 'VSCode' ? 'Code' : editor\n  const userDirPath = join(\n    homedir(),\n    platform() === 'win32'\n      ? join('AppData', 'Roaming', editorDir, 'User')\n      : platform() === 'darwin'\n        ? join('Library', 'Application Support', editorDir, 'User')\n        : join('.config', editorDir, 'User'),\n  )\n  const keybindingsPath = join(userDirPath, 'keybindings.json')\n\n  try {\n    // Ensure user directory exists (idempotent with recursive)\n    await mkdir(userDirPath, { recursive: true })\n\n    // Read existing keybindings file, or default to empty array if it doesn't exist\n    let content = '[]'\n    let keybindings: VSCodeKeybinding[] = []\n    let fileExists = false\n    try {\n      content = await readFile(keybindingsPath, { encoding: 'utf-8' })\n      fileExists = true\n      keybindings = (safeParseJSONC(content) as VSCodeKeybinding[]) ?? []\n    } catch (e: unknown) {\n      if (!isFsInaccessible(e)) throw e\n    }\n\n    // Backup the existing file before modifying it\n    if (fileExists) {\n      const randomSha = randomBytes(4).toString('hex')\n      const backupPath = `${keybindingsPath}.${randomSha}.bak`\n      try {\n        await copyFile(keybindingsPath, backupPath)\n      } catch {\n        return `${color(\n          'warning',\n          theme,\n        )(\n          `Error backing up existing ${editor} terminal keybindings. Bailing out.`,\n        )}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`\n      }\n    }\n\n    // Check if keybinding already exists\n    const existingBinding = keybindings.find(\n      binding =>\n        binding.key === 'shift+enter' &&\n        binding.command === 'workbench.action.terminal.sendSequence' &&\n        binding.when === 'terminalFocus',\n    )\n    if (existingBinding) {\n      return `${color(\n        'warning',\n        theme,\n      )(\n        `Found existing ${editor} terminal Shift+Enter key binding. Remove it to continue.`,\n      )}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}`\n    }\n\n    // Create the new keybinding\n    const newKeybinding: VSCodeKeybinding = {\n      key: 'shift+enter',\n      command: 'workbench.action.terminal.sendSequence',\n      args: { text: '\\u001b\\r' },\n      when: 'terminalFocus',\n    }\n\n    // Modify the content by adding the new keybinding while preserving comments and formatting\n    const updatedContent = addItemToJSONCArray(content, newKeybinding)\n\n    // Write the updated content back to the file\n    await writeFile(keybindingsPath, updatedContent, { encoding: 'utf-8' })\n\n    return `${color(\n      'success',\n      theme,\n    )(\n      `Installed ${editor} terminal Shift+Enter key binding`,\n    )}${EOL}${chalk.dim(`See ${formatPathLink(keybindingsPath)}`)}${EOL}`\n  } catch (error) {\n    logError(error)\n    throw new Error(\n      `Failed to install ${editor} terminal Shift+Enter key binding`,\n    )\n  }\n}\n\nasync function enableOptionAsMetaForProfile(\n  profileName: string,\n): Promise<boolean> {\n  // First try to add the property (in case it doesn't exist)\n  // Quote the profile name to handle names with spaces (e.g., \"Man Page\", \"Red Sands\")\n  const { code: addCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', [\n    '-c',\n    `Add :'Window Settings':'${profileName}':useOptionAsMetaKey bool true`,\n    getTerminalPlistPath(),\n  ])\n\n  // If adding fails (likely because it already exists), try setting it instead\n  if (addCode !== 0) {\n    const { code: setCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', [\n      '-c',\n      `Set :'Window Settings':'${profileName}':useOptionAsMetaKey true`,\n      getTerminalPlistPath(),\n    ])\n\n    if (setCode !== 0) {\n      logError(\n        new Error(\n          `Failed to enable Option as Meta key for Terminal.app profile: ${profileName}`,\n        ),\n      )\n      return false\n    }\n  }\n\n  return true\n}\n\nasync function disableAudioBellForProfile(\n  profileName: string,\n): Promise<boolean> {\n  // First try to add the property (in case it doesn't exist)\n  // Quote the profile name to handle names with spaces (e.g., \"Man Page\", \"Red Sands\")\n  const { code: addCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', [\n    '-c',\n    `Add :'Window Settings':'${profileName}':Bell bool false`,\n    getTerminalPlistPath(),\n  ])\n\n  // If adding fails (likely because it already exists), try setting it instead\n  if (addCode !== 0) {\n    const { code: setCode } = await execFileNoThrow('/usr/libexec/PlistBuddy', [\n      '-c',\n      `Set :'Window Settings':'${profileName}':Bell false`,\n      getTerminalPlistPath(),\n    ])\n\n    if (setCode !== 0) {\n      logError(\n        new Error(\n          `Failed to disable audio bell for Terminal.app profile: ${profileName}`,\n        ),\n      )\n      return false\n    }\n  }\n\n  return true\n}\n\n// Enable Option as Meta key for Terminal.app\nasync function enableOptionAsMetaForTerminal(\n  theme: ThemeName,\n): Promise<string> {\n  try {\n    // Create a backup of the current plist file\n    const backupPath = await backupTerminalPreferences()\n    if (!backupPath) {\n      throw new Error(\n        'Failed to create backup of Terminal.app preferences, bailing out',\n      )\n    }\n\n    // Read the current default profile from the plist\n    const { stdout: defaultProfile, code: readCode } = await execFileNoThrow(\n      'defaults',\n      ['read', 'com.apple.Terminal', 'Default Window Settings'],\n    )\n\n    if (readCode !== 0 || !defaultProfile.trim()) {\n      throw new Error('Failed to read default Terminal.app profile')\n    }\n\n    const { stdout: startupProfile, code: startupCode } = await execFileNoThrow(\n      'defaults',\n      ['read', 'com.apple.Terminal', 'Startup Window Settings'],\n    )\n    if (startupCode !== 0 || !startupProfile.trim()) {\n      throw new Error('Failed to read startup Terminal.app profile')\n    }\n\n    let wasAnyProfileUpdated = false\n\n    const defaultProfileName = defaultProfile.trim()\n    const optionAsMetaEnabled =\n      await enableOptionAsMetaForProfile(defaultProfileName)\n    const audioBellDisabled =\n      await disableAudioBellForProfile(defaultProfileName)\n\n    if (optionAsMetaEnabled || audioBellDisabled) {\n      wasAnyProfileUpdated = true\n    }\n\n    const startupProfileName = startupProfile.trim()\n\n    // Only proceed if the startup profile is different from the default profile\n    if (startupProfileName !== defaultProfileName) {\n      const startupOptionAsMetaEnabled =\n        await enableOptionAsMetaForProfile(startupProfileName)\n      const startupAudioBellDisabled =\n        await disableAudioBellForProfile(startupProfileName)\n\n      if (startupOptionAsMetaEnabled || startupAudioBellDisabled) {\n        wasAnyProfileUpdated = true\n      }\n    }\n\n    if (!wasAnyProfileUpdated) {\n      throw new Error(\n        'Failed to enable Option as Meta key or disable audio bell for any Terminal.app profile',\n      )\n    }\n\n    // Flush the preferences cache\n    await execFileNoThrow('killall', ['cfprefsd'])\n\n    markTerminalSetupComplete()\n\n    return `${color(\n      'success',\n      theme,\n    )(\n      `Configured Terminal.app settings:`,\n    )}${EOL}${color('success', theme)('- Enabled \"Use Option as Meta key\"')}${EOL}${color('success', theme)('- Switched to visual bell')}${EOL}${chalk.dim('Option+Enter will now enter a newline.')}${EOL}${chalk.dim('You must restart Terminal.app for changes to take effect.', theme)}${EOL}`\n  } catch (error) {\n    logError(error)\n\n    // Attempt to restore from backup\n    const restoreResult = await checkAndRestoreTerminalBackup()\n\n    const errorMessage = 'Failed to enable Option as Meta key for Terminal.app.'\n    if (restoreResult.status === 'restored') {\n      throw new Error(\n        `${errorMessage} Your settings have been restored from backup.`,\n      )\n    } else if (restoreResult.status === 'failed') {\n      throw new Error(\n        `${errorMessage} Restoring from backup failed, try manually with: defaults import com.apple.Terminal ${restoreResult.backupPath}`,\n      )\n    } else {\n      throw new Error(\n        `${errorMessage} No backup was available to restore from.`,\n      )\n    }\n  }\n}\n\nasync function installBindingsForAlacritty(theme: ThemeName): Promise<string> {\n  const ALACRITTY_KEYBINDING = `[[keyboard.bindings]]\nkey = \"Return\"\nmods = \"Shift\"\nchars = \"\\\\u001B\\\\r\"`\n\n  // Get Alacritty config file paths in order of preference\n  const configPaths: string[] = []\n\n  // XDG config path (Linux and macOS)\n  const xdgConfigHome = process.env.XDG_CONFIG_HOME\n  if (xdgConfigHome) {\n    configPaths.push(join(xdgConfigHome, 'alacritty', 'alacritty.toml'))\n  } else {\n    configPaths.push(join(homedir(), '.config', 'alacritty', 'alacritty.toml'))\n  }\n\n  // Windows-specific path\n  if (platform() === 'win32') {\n    const appData = process.env.APPDATA\n    if (appData) {\n      configPaths.push(join(appData, 'alacritty', 'alacritty.toml'))\n    }\n  }\n\n  // Find existing config file by attempting to read it, or use first preferred path\n  let configPath: string | null = null\n  let configContent = ''\n  let configExists = false\n\n  for (const path of configPaths) {\n    try {\n      configContent = await readFile(path, { encoding: 'utf-8' })\n      configPath = path\n      configExists = true\n      break\n    } catch (e: unknown) {\n      if (!isFsInaccessible(e)) throw e\n      // File missing or inaccessible — try next config path\n    }\n  }\n\n  // If no config exists, use the first path (XDG/default location)\n  if (!configPath) {\n    configPath = configPaths[0] ?? null\n  }\n\n  if (!configPath) {\n    throw new Error('No valid config path found for Alacritty')\n  }\n\n  try {\n    if (configExists) {\n      // Check if keybinding already exists (look for Shift+Return binding)\n      if (\n        configContent.includes('mods = \"Shift\"') &&\n        configContent.includes('key = \"Return\"')\n      ) {\n        return `${color(\n          'warning',\n          theme,\n        )(\n          'Found existing Alacritty Shift+Enter key binding. Remove it to continue.',\n        )}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}`\n      }\n\n      // Create backup\n      const randomSha = randomBytes(4).toString('hex')\n      const backupPath = `${configPath}.${randomSha}.bak`\n      try {\n        await copyFile(configPath, backupPath)\n      } catch {\n        return `${color(\n          'warning',\n          theme,\n        )(\n          'Error backing up existing Alacritty config. Bailing out.',\n        )}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`\n      }\n    } else {\n      // Ensure config directory exists (idempotent with recursive)\n      await mkdir(dirname(configPath), { recursive: true })\n    }\n\n    // Add the keybinding to the config\n    let updatedContent = configContent\n    if (configContent && !configContent.endsWith('\\n')) {\n      updatedContent += '\\n'\n    }\n    updatedContent += '\\n' + ALACRITTY_KEYBINDING + '\\n'\n\n    // Write the updated config\n    await writeFile(configPath, updatedContent, { encoding: 'utf-8' })\n\n    return `${color(\n      'success',\n      theme,\n    )('Installed Alacritty Shift+Enter key binding')}${EOL}${color(\n      'success',\n      theme,\n    )(\n      'You may need to restart Alacritty for changes to take effect',\n    )}${EOL}${chalk.dim(`See ${formatPathLink(configPath)}`)}${EOL}`\n  } catch (error) {\n    logError(error)\n    throw new Error('Failed to install Alacritty Shift+Enter key binding')\n  }\n}\n\nasync function installBindingsForZed(theme: ThemeName): Promise<string> {\n  // Zed uses JSON keybindings similar to VSCode\n  const zedDir = join(homedir(), '.config', 'zed')\n  const keymapPath = join(zedDir, 'keymap.json')\n\n  try {\n    // Ensure zed directory exists (idempotent with recursive)\n    await mkdir(zedDir, { recursive: true })\n\n    // Read existing keymap file, or default to empty array if it doesn't exist\n    let keymapContent = '[]'\n    let fileExists = false\n    try {\n      keymapContent = await readFile(keymapPath, { encoding: 'utf-8' })\n      fileExists = true\n    } catch (e: unknown) {\n      if (!isFsInaccessible(e)) throw e\n    }\n\n    if (fileExists) {\n      // Check if keybinding already exists\n      if (keymapContent.includes('shift-enter')) {\n        return `${color(\n          'warning',\n          theme,\n        )(\n          'Found existing Zed Shift+Enter key binding. Remove it to continue.',\n        )}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}`\n      }\n\n      // Create backup\n      const randomSha = randomBytes(4).toString('hex')\n      const backupPath = `${keymapPath}.${randomSha}.bak`\n      try {\n        await copyFile(keymapPath, backupPath)\n      } catch {\n        return `${color(\n          'warning',\n          theme,\n        )(\n          'Error backing up existing Zed keymap. Bailing out.',\n        )}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}${chalk.dim(`Backup path: ${formatPathLink(backupPath)}`)}${EOL}`\n      }\n    }\n\n    // Parse and modify the keymap\n    let keymap: Array<{\n      context?: string\n      bindings: Record<string, string | string[]>\n    }>\n    try {\n      keymap = jsonParse(keymapContent)\n      if (!Array.isArray(keymap)) {\n        keymap = []\n      }\n    } catch {\n      keymap = []\n    }\n\n    // Add the new keybinding for terminal context\n    keymap.push({\n      context: 'Terminal',\n      bindings: {\n        'shift-enter': ['terminal::SendText', '\\u001b\\r'],\n      },\n    })\n\n    // Write the updated keymap\n    await writeFile(keymapPath, jsonStringify(keymap, null, 2) + '\\n', {\n      encoding: 'utf-8',\n    })\n\n    return `${color(\n      'success',\n      theme,\n    )(\n      'Installed Zed Shift+Enter key binding',\n    )}${EOL}${chalk.dim(`See ${formatPathLink(keymapPath)}`)}${EOL}`\n  } catch (error) {\n    logError(error)\n    throw new Error('Failed to install Zed Shift+Enter key binding')\n  }\n}\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,WAAW,QAAQ,QAAQ;AACpC,SAASC,QAAQ,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,SAAS,QAAQ,aAAa;AAClE,SAASC,OAAO,EAAEC,QAAQ,QAAQ,IAAI;AACtC,SAASC,OAAO,EAAEC,IAAI,QAAQ,MAAM;AACpC,cAAcC,SAAS,QAAQ,oBAAoB;AACnD,SAASC,aAAa,QAAQ,KAAK;AACnC,SAASC,kBAAkB,QAAQ,kCAAkC;AACrE,SAASC,KAAK,QAAQ,cAAc;AACpC,SAASC,kCAAkC,QAAQ,iCAAiC;AACpF,cAAcC,cAAc,QAAQ,eAAe;AACnD,cACEC,sBAAsB,EACtBC,qBAAqB,QAChB,wBAAwB;AAC/B,SACEC,yBAAyB,EACzBC,6BAA6B,EAC7BC,oBAAoB,EACpBC,yBAAyB,QACpB,oCAAoC;AAC3C,SAASC,oBAAoB,QAAQ,gCAAgC;AACrE,SAASC,eAAe,EAAEC,gBAAgB,QAAQ,uBAAuB;AACzE,SAASC,GAAG,QAAQ,oBAAoB;AACxC,SAASC,gBAAgB,QAAQ,uBAAuB;AACxD,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,mBAAmB,EAAEC,cAAc,QAAQ,qBAAqB;AACzE,SAASC,QAAQ,QAAQ,oBAAoB;AAC7C,SAASC,WAAW,QAAQ,yBAAyB;AACrD,SAASC,SAAS,EAAEC,aAAa,QAAQ,+BAA+B;AAExE,MAAMC,GAAG,GAAG,IAAI;;AAEhB;AACA,MAAMC,qBAAqB,EAAEC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;EACpDC,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACd,WAAW,EAAE,QAAQ;EACrBC,OAAO,EAAE,SAAS;EAClBC,YAAY,EAAE;AAChB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,SAASC,iBAAiBA,CAAA,CAAE,EAAE,OAAO,CAAC;EACpC,MAAMC,WAAW,GAAGC,OAAO,CAAClB,GAAG,CAACmB,uBAAuB,IAAI,EAAE;EAC7D,MAAMC,IAAI,GAAGF,OAAO,CAAClB,GAAG,CAACqB,IAAI,IAAI,EAAE;;EAEnC;EACA;EACA,OACEJ,WAAW,CAACK,QAAQ,CAAC,gBAAgB,CAAC,IACtCL,WAAW,CAACK,QAAQ,CAAC,gBAAgB,CAAC,IACtCL,WAAW,CAACK,QAAQ,CAAC,kBAAkB,CAAC,IACxCF,IAAI,CAACE,QAAQ,CAAC,gBAAgB,CAAC,IAC/BF,IAAI,CAACE,QAAQ,CAAC,gBAAgB,CAAC,IAC/BF,IAAI,CAACE,QAAQ,CAAC,kBAAkB,CAAC;AAErC;AAEA,OAAO,SAASC,gCAAgCA,CAAA,CAAE,EAAE,MAAM,GAAG,IAAI,CAAC;EAChE,IAAI,CAACvB,GAAG,CAACwB,QAAQ,IAAI,EAAExB,GAAG,CAACwB,QAAQ,IAAId,qBAAqB,CAAC,EAAE;IAC7D,OAAO,IAAI;EACb;EACA,OAAOA,qBAAqB,CAACV,GAAG,CAACwB,QAAQ,CAAC,IAAI,IAAI;AACpD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,cAAcA,CAACC,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;EAChD,IAAI,CAACvC,kBAAkB,CAAC,CAAC,EAAE;IACzB,OAAOuC,QAAQ;EACjB;EACA,MAAMC,OAAO,GAAGzC,aAAa,CAACwC,QAAQ,CAAC,CAACE,IAAI;EAC5C;EACA,OAAO,WAAWD,OAAO,OAAOD,QAAQ,cAAc;AACxD;AAEA,OAAO,SAASG,wBAAwBA,CAAA,CAAE,EAAE,OAAO,CAAC;EAClD;EACA;EACA;EACA,OACG/C,QAAQ,CAAC,CAAC,KAAK,QAAQ,IAAIkB,GAAG,CAACwB,QAAQ,KAAK,gBAAgB,IAC7DxB,GAAG,CAACwB,QAAQ,KAAK,QAAQ,IACzBxB,GAAG,CAACwB,QAAQ,KAAK,QAAQ,IACzBxB,GAAG,CAACwB,QAAQ,KAAK,UAAU,IAC3BxB,GAAG,CAACwB,QAAQ,KAAK,WAAW,IAC5BxB,GAAG,CAACwB,QAAQ,KAAK,KAAK;AAE1B;AAEA,OAAO,eAAeM,aAAaA,CAACC,KAAK,EAAE9C,SAAS,CAAC,EAAE+C,OAAO,CAAC,MAAM,CAAC,CAAC;EACrE,IAAIC,MAAM,GAAG,EAAE;EAEf,QAAQjC,GAAG,CAACwB,QAAQ;IAClB,KAAK,gBAAgB;MACnBS,MAAM,GAAG,MAAMC,6BAA6B,CAACH,KAAK,CAAC;MACnD;IACF,KAAK,QAAQ;MACXE,MAAM,GAAG,MAAME,gCAAgC,CAAC,QAAQ,EAAEJ,KAAK,CAAC;MAChE;IACF,KAAK,QAAQ;MACXE,MAAM,GAAG,MAAME,gCAAgC,CAAC,QAAQ,EAAEJ,KAAK,CAAC;MAChE;IACF,KAAK,UAAU;MACbE,MAAM,GAAG,MAAME,gCAAgC,CAAC,UAAU,EAAEJ,KAAK,CAAC;MAClE;IACF,KAAK,WAAW;MACdE,MAAM,GAAG,MAAMG,2BAA2B,CAACL,KAAK,CAAC;MACjD;IACF,KAAK,KAAK;MACRE,MAAM,GAAG,MAAMI,qBAAqB,CAACN,KAAK,CAAC;MAC3C;IACF,KAAK,IAAI;MACP;EACJ;EAEAhC,gBAAgB,CAACuC,OAAO,IAAI;IAC1B,IACE,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAChB,QAAQ,CAC3DtB,GAAG,CAACwB,QAAQ,IAAI,EAClB,CAAC,EACD;MACA,IAAIc,OAAO,CAACC,6BAA6B,KAAK,IAAI,EAAE,OAAOD,OAAO;MAClE,OAAO;QAAE,GAAGA,OAAO;QAAEC,6BAA6B,EAAE;MAAK,CAAC;IAC5D,CAAC,MAAM,IAAIvC,GAAG,CAACwB,QAAQ,KAAK,gBAAgB,EAAE;MAC5C,IAAIc,OAAO,CAACE,wBAAwB,KAAK,IAAI,EAAE,OAAOF,OAAO;MAC7D,OAAO;QAAE,GAAGA,OAAO;QAAEE,wBAAwB,EAAE;MAAK,CAAC;IACvD;IACA,OAAOF,OAAO;EAChB,CAAC,CAAC;EAEFjD,kCAAkC,CAAC,CAAC;;EAEpC;EACA,IAAI,UAAU,KAAK,KAAK,EAAE;IACxB4C,MAAM,IAAI,MAAMpC,oBAAoB,CAACkC,KAAK,CAAC;EAC7C;EAEA,OAAOE,MAAM;AACf;AAEA,OAAO,SAASQ,+BAA+BA,CAAA,CAAE,EAAE,OAAO,CAAC;EACzD,OAAO3C,eAAe,CAAC,CAAC,CAACyC,6BAA6B,KAAK,IAAI;AACjE;AAEA,OAAO,SAASG,sBAAsBA,CAAA,CAAE,EAAE,OAAO,CAAC;EAChD,OAAO5C,eAAe,CAAC,CAAC,CAAC4C,sBAAsB,KAAK,IAAI;AAC1D;AAEA,OAAO,SAASC,uBAAuBA,CAAA,CAAE,EAAE,IAAI,CAAC;EAC9C,MAAMC,MAAM,GAAG9C,eAAe,CAAC,CAAC;EAChC,IAAI,CAAC8C,MAAM,CAACF,sBAAsB,EAAE;IAClC3C,gBAAgB,CAACuC,OAAO,KAAK;MAC3B,GAAGA,OAAO;MACVI,sBAAsB,EAAE;IAC1B,CAAC,CAAC,CAAC;EACL;AACF;AAEA,OAAO,eAAeG,IAAIA,CACxBC,MAAM,EAAEtD,qBAAqB,EAC7BuD,OAAO,EAAEzD,cAAc,GAAGC,sBAAsB,EAChDyD,KAAK,EAAE,MAAM,CACd,EAAEhB,OAAO,CAAC,IAAI,CAAC,CAAC;EACf,IAAIhC,GAAG,CAACwB,QAAQ,IAAIxB,GAAG,CAACwB,QAAQ,IAAId,qBAAqB,EAAE;IACzD,MAAMuC,OAAO,GAAG,wCAAwCvC,qBAAqB,CAACV,GAAG,CAACwB,QAAQ,CAAC;AAC/F;AACA,+DAA+D;IAC3DsB,MAAM,CAACG,OAAO,CAAC;IACf,OAAO,IAAI;EACb;;EAEA;EACA,IAAI,CAACpB,wBAAwB,CAAC,CAAC,EAAE;IAC/B,MAAMqB,YAAY,GAAGlD,GAAG,CAACwB,QAAQ,IAAI,uBAAuB;IAC5D,MAAM2B,eAAe,GAAG7C,WAAW,CAAC,CAAC;;IAErC;IACA,IAAI8C,iBAAiB,GAAG,EAAE;IAC1B,IAAID,eAAe,KAAK,OAAO,EAAE;MAC/BC,iBAAiB,GAAG,8BAA8B;IACpD,CAAC,MAAM,IAAID,eAAe,KAAK,SAAS,EAAE;MACxCC,iBAAiB,GAAG,kCAAkC;IACxD;IACA;IACA;;IAEA,MAAMH,OAAO,GAAG,qCAAqCC,YAAY;AACrE;AACA;AACA,EAAE3E,KAAK,CAAC8E,GAAG,CAAC,sEAAsE,CAAC;AACnF;AACA;AACA;AACA;AACA,EAAED,iBAAiB;AACnB;AACA;AACA;AACA,EAAE7E,KAAK,CAAC8E,GAAG,CAAC,+EAA+E,CAAC,EAAE;IAC1FP,MAAM,CAACG,OAAO,CAAC;IACf,OAAO,IAAI;EACb;EAEA,MAAMhB,MAAM,GAAG,MAAMH,aAAa,CAACiB,OAAO,CAACO,OAAO,CAACvB,KAAK,CAAC;EACzDe,MAAM,CAACb,MAAM,CAAC;EACd,OAAO,IAAI;AACb;AAEA,KAAKsB,gBAAgB,GAAG;EACtBC,GAAG,EAAE,MAAM;EACXC,OAAO,EAAE,MAAM;EACfC,IAAI,EAAE;IAAEC,IAAI,EAAE,MAAM;EAAC,CAAC;EACtBC,IAAI,EAAE,MAAM;AACd,CAAC;AAED,eAAezB,gCAAgCA,CAC7C0B,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,EACnD9B,KAAK,EAAE9C,SAAS,CACjB,EAAE+C,OAAO,CAAC,MAAM,CAAC,CAAC;EACjB;EACA;EACA,IAAIhB,iBAAiB,CAAC,CAAC,EAAE;IACvB,OAAO,GAAG5B,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,4CAA4C8B,MAAM,WACpD,CAAC,GAAGpD,GAAG,GAAGA,GAAG,GAAGoD,MAAM,+EAA+EpD,GAAG,GAAGA,GAAG,yCAAyCA,GAAG,WAAWoD,MAAM,mDAAmDpD,GAAG,iGAAiGA,GAAG,0DAA0DA,GAAG,GAAGA,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC;AACzZ;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,CAAC,GAAG5C,GAAG,EAAE;EACT;EAEA,MAAMqD,SAAS,GAAGD,MAAM,KAAK,QAAQ,GAAG,MAAM,GAAGA,MAAM;EACvD,MAAME,WAAW,GAAG/E,IAAI,CACtBH,OAAO,CAAC,CAAC,EACTC,QAAQ,CAAC,CAAC,KAAK,OAAO,GAClBE,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE8E,SAAS,EAAE,MAAM,CAAC,GAC7ChF,QAAQ,CAAC,CAAC,KAAK,QAAQ,GACrBE,IAAI,CAAC,SAAS,EAAE,qBAAqB,EAAE8E,SAAS,EAAE,MAAM,CAAC,GACzD9E,IAAI,CAAC,SAAS,EAAE8E,SAAS,EAAE,MAAM,CACzC,CAAC;EACD,MAAME,eAAe,GAAGhF,IAAI,CAAC+E,WAAW,EAAE,kBAAkB,CAAC;EAE7D,IAAI;IACF;IACA,MAAMrF,KAAK,CAACqF,WAAW,EAAE;MAAEE,SAAS,EAAE;IAAK,CAAC,CAAC;;IAE7C;IACA,IAAIC,OAAO,GAAG,IAAI;IAClB,IAAIC,WAAW,EAAEZ,gBAAgB,EAAE,GAAG,EAAE;IACxC,IAAIa,UAAU,GAAG,KAAK;IACtB,IAAI;MACFF,OAAO,GAAG,MAAMvF,QAAQ,CAACqF,eAAe,EAAE;QAAEK,QAAQ,EAAE;MAAQ,CAAC,CAAC;MAChED,UAAU,GAAG,IAAI;MACjBD,WAAW,GAAI/D,cAAc,CAAC8D,OAAO,CAAC,IAAIX,gBAAgB,EAAE,IAAK,EAAE;IACrE,CAAC,CAAC,OAAOe,CAAC,EAAE,OAAO,EAAE;MACnB,IAAI,CAACrE,gBAAgB,CAACqE,CAAC,CAAC,EAAE,MAAMA,CAAC;IACnC;;IAEA;IACA,IAAIF,UAAU,EAAE;MACd,MAAMG,SAAS,GAAG/F,WAAW,CAAC,CAAC,CAAC,CAACgG,QAAQ,CAAC,KAAK,CAAC;MAChD,MAAMC,UAAU,GAAG,GAAGT,eAAe,IAAIO,SAAS,MAAM;MACxD,IAAI;QACF,MAAM9F,QAAQ,CAACuF,eAAe,EAAES,UAAU,CAAC;MAC7C,CAAC,CAAC,MAAM;QACN,OAAO,GAAGrF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,6BAA6B8B,MAAM,qCACrC,CAAC,GAAGpD,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACuC,eAAe,CAAC,EAAE,CAAC,GAAGvD,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,gBAAgB5B,cAAc,CAACgD,UAAU,CAAC,EAAE,CAAC,GAAGhE,GAAG,EAAE;MACvI;IACF;;IAEA;IACA,MAAMiE,eAAe,GAAGP,WAAW,CAACQ,IAAI,CACtCC,OAAO,IACLA,OAAO,CAACpB,GAAG,KAAK,aAAa,IAC7BoB,OAAO,CAACnB,OAAO,KAAK,wCAAwC,IAC5DmB,OAAO,CAAChB,IAAI,KAAK,eACrB,CAAC;IACD,IAAIc,eAAe,EAAE;MACnB,OAAO,GAAGtF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,kBAAkB8B,MAAM,2DAC1B,CAAC,GAAGpD,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACuC,eAAe,CAAC,EAAE,CAAC,GAAGvD,GAAG,EAAE;IACvE;;IAEA;IACA,MAAMoE,aAAa,EAAEtB,gBAAgB,GAAG;MACtCC,GAAG,EAAE,aAAa;MAClBC,OAAO,EAAE,wCAAwC;MACjDC,IAAI,EAAE;QAAEC,IAAI,EAAE;MAAW,CAAC;MAC1BC,IAAI,EAAE;IACR,CAAC;;IAED;IACA,MAAMkB,cAAc,GAAG3E,mBAAmB,CAAC+D,OAAO,EAAEW,aAAa,CAAC;;IAElE;IACA,MAAMjG,SAAS,CAACoF,eAAe,EAAEc,cAAc,EAAE;MAAET,QAAQ,EAAE;IAAQ,CAAC,CAAC;IAEvE,OAAO,GAAGjF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,aAAa8B,MAAM,mCACrB,CAAC,GAAGpD,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACuC,eAAe,CAAC,EAAE,CAAC,GAAGvD,GAAG,EAAE;EACvE,CAAC,CAAC,OAAOsE,KAAK,EAAE;IACd1E,QAAQ,CAAC0E,KAAK,CAAC;IACf,MAAM,IAAIC,KAAK,CACb,qBAAqBnB,MAAM,mCAC7B,CAAC;EACH;AACF;AAEA,eAAeoB,4BAA4BA,CACzCC,WAAW,EAAE,MAAM,CACpB,EAAElD,OAAO,CAAC,OAAO,CAAC,CAAC;EAClB;EACA;EACA,MAAM;IAAEmD,IAAI,EAAEC;EAAQ,CAAC,GAAG,MAAMlF,eAAe,CAAC,yBAAyB,EAAE,CACzE,IAAI,EACJ,2BAA2BgF,WAAW,gCAAgC,EACtEvF,oBAAoB,CAAC,CAAC,CACvB,CAAC;;EAEF;EACA,IAAIyF,OAAO,KAAK,CAAC,EAAE;IACjB,MAAM;MAAED,IAAI,EAAEE;IAAQ,CAAC,GAAG,MAAMnF,eAAe,CAAC,yBAAyB,EAAE,CACzE,IAAI,EACJ,2BAA2BgF,WAAW,2BAA2B,EACjEvF,oBAAoB,CAAC,CAAC,CACvB,CAAC;IAEF,IAAI0F,OAAO,KAAK,CAAC,EAAE;MACjBhF,QAAQ,CACN,IAAI2E,KAAK,CACP,iEAAiEE,WAAW,EAC9E,CACF,CAAC;MACD,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb;AAEA,eAAeI,0BAA0BA,CACvCJ,WAAW,EAAE,MAAM,CACpB,EAAElD,OAAO,CAAC,OAAO,CAAC,CAAC;EAClB;EACA;EACA,MAAM;IAAEmD,IAAI,EAAEC;EAAQ,CAAC,GAAG,MAAMlF,eAAe,CAAC,yBAAyB,EAAE,CACzE,IAAI,EACJ,2BAA2BgF,WAAW,mBAAmB,EACzDvF,oBAAoB,CAAC,CAAC,CACvB,CAAC;;EAEF;EACA,IAAIyF,OAAO,KAAK,CAAC,EAAE;IACjB,MAAM;MAAED,IAAI,EAAEE;IAAQ,CAAC,GAAG,MAAMnF,eAAe,CAAC,yBAAyB,EAAE,CACzE,IAAI,EACJ,2BAA2BgF,WAAW,cAAc,EACpDvF,oBAAoB,CAAC,CAAC,CACvB,CAAC;IAEF,IAAI0F,OAAO,KAAK,CAAC,EAAE;MACjBhF,QAAQ,CACN,IAAI2E,KAAK,CACP,0DAA0DE,WAAW,EACvE,CACF,CAAC;MACD,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb;;AAEA;AACA,eAAehD,6BAA6BA,CAC1CH,KAAK,EAAE9C,SAAS,CACjB,EAAE+C,OAAO,CAAC,MAAM,CAAC,CAAC;EACjB,IAAI;IACF;IACA,MAAMyC,UAAU,GAAG,MAAMhF,yBAAyB,CAAC,CAAC;IACpD,IAAI,CAACgF,UAAU,EAAE;MACf,MAAM,IAAIO,KAAK,CACb,kEACF,CAAC;IACH;;IAEA;IACA,MAAM;MAAEO,MAAM,EAAEC,cAAc;MAAEL,IAAI,EAAEM;IAAS,CAAC,GAAG,MAAMvF,eAAe,CACtE,UAAU,EACV,CAAC,MAAM,EAAE,oBAAoB,EAAE,yBAAyB,CAC1D,CAAC;IAED,IAAIuF,QAAQ,KAAK,CAAC,IAAI,CAACD,cAAc,CAACE,IAAI,CAAC,CAAC,EAAE;MAC5C,MAAM,IAAIV,KAAK,CAAC,6CAA6C,CAAC;IAChE;IAEA,MAAM;MAAEO,MAAM,EAAEI,cAAc;MAAER,IAAI,EAAES;IAAY,CAAC,GAAG,MAAM1F,eAAe,CACzE,UAAU,EACV,CAAC,MAAM,EAAE,oBAAoB,EAAE,yBAAyB,CAC1D,CAAC;IACD,IAAI0F,WAAW,KAAK,CAAC,IAAI,CAACD,cAAc,CAACD,IAAI,CAAC,CAAC,EAAE;MAC/C,MAAM,IAAIV,KAAK,CAAC,6CAA6C,CAAC;IAChE;IAEA,IAAIa,oBAAoB,GAAG,KAAK;IAEhC,MAAMC,kBAAkB,GAAGN,cAAc,CAACE,IAAI,CAAC,CAAC;IAChD,MAAMK,mBAAmB,GACvB,MAAMd,4BAA4B,CAACa,kBAAkB,CAAC;IACxD,MAAME,iBAAiB,GACrB,MAAMV,0BAA0B,CAACQ,kBAAkB,CAAC;IAEtD,IAAIC,mBAAmB,IAAIC,iBAAiB,EAAE;MAC5CH,oBAAoB,GAAG,IAAI;IAC7B;IAEA,MAAMI,kBAAkB,GAAGN,cAAc,CAACD,IAAI,CAAC,CAAC;;IAEhD;IACA,IAAIO,kBAAkB,KAAKH,kBAAkB,EAAE;MAC7C,MAAMI,0BAA0B,GAC9B,MAAMjB,4BAA4B,CAACgB,kBAAkB,CAAC;MACxD,MAAME,wBAAwB,GAC5B,MAAMb,0BAA0B,CAACW,kBAAkB,CAAC;MAEtD,IAAIC,0BAA0B,IAAIC,wBAAwB,EAAE;QAC1DN,oBAAoB,GAAG,IAAI;MAC7B;IACF;IAEA,IAAI,CAACA,oBAAoB,EAAE;MACzB,MAAM,IAAIb,KAAK,CACb,wFACF,CAAC;IACH;;IAEA;IACA,MAAM9E,eAAe,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,CAAC;IAE9CN,yBAAyB,CAAC,CAAC;IAE3B,OAAO,GAAGR,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,mCACF,CAAC,GAAGtB,GAAG,GAAGrB,KAAK,CAAC,SAAS,EAAE2C,KAAK,CAAC,CAAC,oCAAoC,CAAC,GAAGtB,GAAG,GAAGrB,KAAK,CAAC,SAAS,EAAE2C,KAAK,CAAC,CAAC,2BAA2B,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,wCAAwC,CAAC,GAAG5C,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,2DAA2D,EAAEtB,KAAK,CAAC,GAAGtB,GAAG,EAAE;EAChS,CAAC,CAAC,OAAOsE,KAAK,EAAE;IACd1E,QAAQ,CAAC0E,KAAK,CAAC;;IAEf;IACA,MAAMqB,aAAa,GAAG,MAAM1G,6BAA6B,CAAC,CAAC;IAE3D,MAAM2G,YAAY,GAAG,uDAAuD;IAC5E,IAAID,aAAa,CAACE,MAAM,KAAK,UAAU,EAAE;MACvC,MAAM,IAAItB,KAAK,CACb,GAAGqB,YAAY,gDACjB,CAAC;IACH,CAAC,MAAM,IAAID,aAAa,CAACE,MAAM,KAAK,QAAQ,EAAE;MAC5C,MAAM,IAAItB,KAAK,CACb,GAAGqB,YAAY,wFAAwFD,aAAa,CAAC3B,UAAU,EACjI,CAAC;IACH,CAAC,MAAM;MACL,MAAM,IAAIO,KAAK,CACb,GAAGqB,YAAY,2CACjB,CAAC;IACH;EACF;AACF;AAEA,eAAejE,2BAA2BA,CAACL,KAAK,EAAE9C,SAAS,CAAC,EAAE+C,OAAO,CAAC,MAAM,CAAC,CAAC;EAC5E,MAAMuE,oBAAoB,GAAG;AAC/B;AACA;AACA,qBAAqB;;EAEnB;EACA,MAAMC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE;;EAEhC;EACA,MAAMC,aAAa,GAAGvF,OAAO,CAAClB,GAAG,CAAC0G,eAAe;EACjD,IAAID,aAAa,EAAE;IACjBD,WAAW,CAACG,IAAI,CAAC3H,IAAI,CAACyH,aAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;EACtE,CAAC,MAAM;IACLD,WAAW,CAACG,IAAI,CAAC3H,IAAI,CAACH,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;EAC7E;;EAEA;EACA,IAAIC,QAAQ,CAAC,CAAC,KAAK,OAAO,EAAE;IAC1B,MAAM8H,OAAO,GAAG1F,OAAO,CAAClB,GAAG,CAAC6G,OAAO;IACnC,IAAID,OAAO,EAAE;MACXJ,WAAW,CAACG,IAAI,CAAC3H,IAAI,CAAC4H,OAAO,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;IAChE;EACF;;EAEA;EACA,IAAIE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;EACpC,IAAIC,aAAa,GAAG,EAAE;EACtB,IAAIC,YAAY,GAAG,KAAK;EAExB,KAAK,MAAM5F,IAAI,IAAIoF,WAAW,EAAE;IAC9B,IAAI;MACFO,aAAa,GAAG,MAAMpI,QAAQ,CAACyC,IAAI,EAAE;QAAEiD,QAAQ,EAAE;MAAQ,CAAC,CAAC;MAC3DyC,UAAU,GAAG1F,IAAI;MACjB4F,YAAY,GAAG,IAAI;MACnB;IACF,CAAC,CAAC,OAAO1C,CAAC,EAAE,OAAO,EAAE;MACnB,IAAI,CAACrE,gBAAgB,CAACqE,CAAC,CAAC,EAAE,MAAMA,CAAC;MACjC;IACF;EACF;;EAEA;EACA,IAAI,CAACwC,UAAU,EAAE;IACfA,UAAU,GAAGN,WAAW,CAAC,CAAC,CAAC,IAAI,IAAI;EACrC;EAEA,IAAI,CAACM,UAAU,EAAE;IACf,MAAM,IAAI9B,KAAK,CAAC,0CAA0C,CAAC;EAC7D;EAEA,IAAI;IACF,IAAIgC,YAAY,EAAE;MAChB;MACA,IACED,aAAa,CAACzF,QAAQ,CAAC,gBAAgB,CAAC,IACxCyF,aAAa,CAACzF,QAAQ,CAAC,gBAAgB,CAAC,EACxC;QACA,OAAO,GAAGlC,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,0EACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACqF,UAAU,CAAC,EAAE,CAAC,GAAGrG,GAAG,EAAE;MAClE;;MAEA;MACA,MAAM8D,SAAS,GAAG/F,WAAW,CAAC,CAAC,CAAC,CAACgG,QAAQ,CAAC,KAAK,CAAC;MAChD,MAAMC,UAAU,GAAG,GAAGqC,UAAU,IAAIvC,SAAS,MAAM;MACnD,IAAI;QACF,MAAM9F,QAAQ,CAACqI,UAAU,EAAErC,UAAU,CAAC;MACxC,CAAC,CAAC,MAAM;QACN,OAAO,GAAGrF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,0DACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACqF,UAAU,CAAC,EAAE,CAAC,GAAGrG,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,gBAAgB5B,cAAc,CAACgD,UAAU,CAAC,EAAE,CAAC,GAAGhE,GAAG,EAAE;MAClI;IACF,CAAC,MAAM;MACL;MACA,MAAM/B,KAAK,CAACK,OAAO,CAAC+H,UAAU,CAAC,EAAE;QAAE7C,SAAS,EAAE;MAAK,CAAC,CAAC;IACvD;;IAEA;IACA,IAAIa,cAAc,GAAGiC,aAAa;IAClC,IAAIA,aAAa,IAAI,CAACA,aAAa,CAACE,QAAQ,CAAC,IAAI,CAAC,EAAE;MAClDnC,cAAc,IAAI,IAAI;IACxB;IACAA,cAAc,IAAI,IAAI,GAAGyB,oBAAoB,GAAG,IAAI;;IAEpD;IACA,MAAM3H,SAAS,CAACkI,UAAU,EAAEhC,cAAc,EAAE;MAAET,QAAQ,EAAE;IAAQ,CAAC,CAAC;IAElE,OAAO,GAAGjF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CAAC,6CAA6C,CAAC,GAAGtB,GAAG,GAAGrB,KAAK,CAC5D,SAAS,EACT2C,KACF,CAAC,CACC,8DACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAACqF,UAAU,CAAC,EAAE,CAAC,GAAGrG,GAAG,EAAE;EAClE,CAAC,CAAC,OAAOsE,KAAK,EAAE;IACd1E,QAAQ,CAAC0E,KAAK,CAAC;IACf,MAAM,IAAIC,KAAK,CAAC,qDAAqD,CAAC;EACxE;AACF;AAEA,eAAe3C,qBAAqBA,CAACN,KAAK,EAAE9C,SAAS,CAAC,EAAE+C,OAAO,CAAC,MAAM,CAAC,CAAC;EACtE;EACA,MAAMkF,MAAM,GAAGlI,IAAI,CAACH,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC;EAChD,MAAMsI,UAAU,GAAGnI,IAAI,CAACkI,MAAM,EAAE,aAAa,CAAC;EAE9C,IAAI;IACF;IACA,MAAMxI,KAAK,CAACwI,MAAM,EAAE;MAAEjD,SAAS,EAAE;IAAK,CAAC,CAAC;;IAExC;IACA,IAAImD,aAAa,GAAG,IAAI;IACxB,IAAIhD,UAAU,GAAG,KAAK;IACtB,IAAI;MACFgD,aAAa,GAAG,MAAMzI,QAAQ,CAACwI,UAAU,EAAE;QAAE9C,QAAQ,EAAE;MAAQ,CAAC,CAAC;MACjED,UAAU,GAAG,IAAI;IACnB,CAAC,CAAC,OAAOE,CAAC,EAAE,OAAO,EAAE;MACnB,IAAI,CAACrE,gBAAgB,CAACqE,CAAC,CAAC,EAAE,MAAMA,CAAC;IACnC;IAEA,IAAIF,UAAU,EAAE;MACd;MACA,IAAIgD,aAAa,CAAC9F,QAAQ,CAAC,aAAa,CAAC,EAAE;QACzC,OAAO,GAAGlC,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,oEACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAAC0F,UAAU,CAAC,EAAE,CAAC,GAAG1G,GAAG,EAAE;MAClE;;MAEA;MACA,MAAM8D,SAAS,GAAG/F,WAAW,CAAC,CAAC,CAAC,CAACgG,QAAQ,CAAC,KAAK,CAAC;MAChD,MAAMC,UAAU,GAAG,GAAG0C,UAAU,IAAI5C,SAAS,MAAM;MACnD,IAAI;QACF,MAAM9F,QAAQ,CAAC0I,UAAU,EAAE1C,UAAU,CAAC;MACxC,CAAC,CAAC,MAAM;QACN,OAAO,GAAGrF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,oDACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAAC0F,UAAU,CAAC,EAAE,CAAC,GAAG1G,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,gBAAgB5B,cAAc,CAACgD,UAAU,CAAC,EAAE,CAAC,GAAGhE,GAAG,EAAE;MAClI;IACF;;IAEA;IACA,IAAI4G,MAAM,EAAEC,KAAK,CAAC;MAChBvE,OAAO,CAAC,EAAE,MAAM;MAChBwE,QAAQ,EAAE5G,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7C,CAAC,CAAC;IACF,IAAI;MACF0G,MAAM,GAAG9G,SAAS,CAAC6G,aAAa,CAAC;MACjC,IAAI,CAACE,KAAK,CAACE,OAAO,CAACH,MAAM,CAAC,EAAE;QAC1BA,MAAM,GAAG,EAAE;MACb;IACF,CAAC,CAAC,MAAM;MACNA,MAAM,GAAG,EAAE;IACb;;IAEA;IACAA,MAAM,CAACV,IAAI,CAAC;MACV5D,OAAO,EAAE,UAAU;MACnBwE,QAAQ,EAAE;QACR,aAAa,EAAE,CAAC,oBAAoB,EAAE,UAAU;MAClD;IACF,CAAC,CAAC;;IAEF;IACA,MAAM3I,SAAS,CAACuI,UAAU,EAAE3G,aAAa,CAAC6G,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE;MACjEhD,QAAQ,EAAE;IACZ,CAAC,CAAC;IAEF,OAAO,GAAGjF,KAAK,CACb,SAAS,EACT2C,KACF,CAAC,CACC,uCACF,CAAC,GAAGtB,GAAG,GAAGlC,KAAK,CAAC8E,GAAG,CAAC,OAAO5B,cAAc,CAAC0F,UAAU,CAAC,EAAE,CAAC,GAAG1G,GAAG,EAAE;EAClE,CAAC,CAAC,OAAOsE,KAAK,EAAE;IACd1E,QAAQ,CAAC0E,KAAK,CAAC;IACf,MAAM,IAAIC,KAAK,CAAC,+CAA+C,CAAC;EAClE;AACF","ignoreList":[]}

package/src/commands/thaddeus-usage/index.js

@@ -0,0 +1,17 @@
+const call = async () => {
+    const { getUsageStats } = await import('../../services/thaddeusAuth.js');
+    const { formatUsageStats } = await import('../../services/thaddeusLoginFlow.js');
+    const stats = await getUsageStats();
+    if (stats) {
+        return { type: 'text', value: formatUsageStats(stats.usage, stats.caps) };
+    }
+    return { type: 'text', value: 'Unable to fetch usage stats. Check your connection.' };
+};
+const thaddeusUsageCommand = {
+    type: 'local',
+    name: 'thaddeus-usage',
+    description: 'Show your current monthly Thaddeus usage and limits',
+    supportsNonInteractive: true,
+    load: () => Promise.resolve({ call }),
+};
+export default thaddeusUsageCommand;

package/src/commands/theme/index.js

@@ -0,0 +1,7 @@
+const theme = {
+    type: 'local-jsx',
+    name: 'theme',
+    description: 'Change the theme',
+    load: () => import('./theme.js'),
+};
+export default theme;