mirror of
https://github.com/claude-code-best/claude-code.git
synced 2026-06-17 22:05:50 +00:00
141ed7a76e
纯格式化：移除分号、React Compiler import、import 多行展开。 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
693 lines
22 KiB
TypeScript
693 lines
22 KiB
TypeScript
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 type { ThemeName } from 'src/utils/theme.js'
|
|
import { pathToFileURL } from 'url'
|
|
import { supportsHyperlinks } from '../../ink/supports-hyperlinks.js'
|
|
import { color } from '../../ink.js'
|
|
import { maybeMarkProjectOnboardingComplete } from '../../projectOnboardingState.js'
|
|
import type { ToolUseContext } from '../../Tool.js'
|
|
import type {
|
|
LocalJSXCommandContext,
|
|
LocalJSXCommandOnDone,
|
|
} from '../../types/command.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: Record<string, string> = {
|
|
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 Claude is running.
|
|
*/
|
|
function isVSCodeRemoteSSH(): boolean {
|
|
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(): string | null {
|
|
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: string): string {
|
|
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(): boolean {
|
|
// iTerm2, WezTerm, Ghostty, Kitty, and Warp natively support CSI u / Kitty
|
|
// keyboard protocol, which Claude Code 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: ThemeName): Promise<string> {
|
|
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 (process.env.USER_TYPE === 'ant') {
|
|
result += await setupShellCompletion(theme)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
export function isShiftEnterKeyBindingInstalled(): boolean {
|
|
return getGlobalConfig().shiftEnterKeyBindingInstalled === true
|
|
}
|
|
|
|
export function hasUsedBackslashReturn(): boolean {
|
|
return getGlobalConfig().hasUsedBackslashReturn === true
|
|
}
|
|
|
|
export function markBackslashReturnUsed(): void {
|
|
const config = getGlobalConfig()
|
|
if (!config.hasUsedBackslashReturn) {
|
|
saveGlobalConfig(current => ({
|
|
...current,
|
|
hasUsedBackslashReturn: true,
|
|
}))
|
|
}
|
|
}
|
|
|
|
export async function call(
|
|
onDone: LocalJSXCommandOnDone,
|
|
context: ToolUseContext & LocalJSXCommandContext,
|
|
_args: string,
|
|
): Promise<null> {
|
|
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
|
|
}
|
|
|
|
type VSCodeKeybinding = {
|
|
key: string
|
|
command: string
|
|
args: { text: string }
|
|
when: string
|
|
}
|
|
|
|
async function installBindingsForVSCodeTerminal(
|
|
editor: 'VSCode' | 'Cursor' | 'Windsurf' = 'VSCode',
|
|
theme: ThemeName,
|
|
): Promise<string> {
|
|
// 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: VSCodeKeybinding[] = []
|
|
let fileExists = false
|
|
try {
|
|
content = await readFile(keybindingsPath, { encoding: 'utf-8' })
|
|
fileExists = true
|
|
keybindings = (safeParseJSONC(content) as VSCodeKeybinding[]) ?? []
|
|
} catch (e: unknown) {
|
|
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: VSCodeKeybinding = {
|
|
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: string,
|
|
): Promise<boolean> {
|
|
// 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: string,
|
|
): Promise<boolean> {
|
|
// 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: ThemeName,
|
|
): Promise<string> {
|
|
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: ThemeName): Promise<string> {
|
|
const ALACRITTY_KEYBINDING = `[[keyboard.bindings]]
|
|
key = "Return"
|
|
mods = "Shift"
|
|
chars = "\\u001B\\r"`
|
|
|
|
// Get Alacritty config file paths in order of preference
|
|
const configPaths: string[] = []
|
|
|
|
// 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: string | null = 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: unknown) {
|
|
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: ThemeName): Promise<string> {
|
|
// 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: unknown) {
|
|
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: Array<{
|
|
context?: string
|
|
bindings: Record<string, string | string[]>
|
|
}>
|
|
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')
|
|
}
|
|
}
|