mirror of
https://github.com/AutoMaker-Org/automaker.git
synced 2026-02-02 08:33:36 +00:00
feat: add external terminal support with cross-platform detection
Add support for opening worktree directories in external terminals (iTerm2, Warp, Ghostty, System Terminal, etc.) while retaining the integrated terminal as the default option. Changes: - Add terminal detection for macOS, Windows, and Linux - Add "Open in Terminal" split-button in worktree dropdown - Add external terminal selection in Settings > Terminal - Add default open mode setting (new tab vs split) - Display branch name in terminal panel header - Support 20+ terminals across platforms Part of #558, Closes #550
This commit is contained in:
Stefan de Vogelaere
@@ -177,3 +177,12 @@ export {
|
||||
openInFileManager,
|
||||
openInTerminal,
|
||||
} from './editor.js';
|
||||
|
||||
// External terminal detection and launching
|
||||
export {
|
||||
clearTerminalCache,
|
||||
detectAllTerminals,
|
||||
detectDefaultTerminal,
|
||||
findTerminalById,
|
||||
openInExternalTerminal,
|
||||
} from './terminal.js';
|
||||
|
||||
602
libs/platform/src/terminal.ts
Normal file
602
libs/platform/src/terminal.ts
Normal file
@@ -0,0 +1,602 @@
|
||||
/**
|
||||
* Cross-platform terminal detection and launching utilities
|
||||
*
|
||||
* Handles:
|
||||
* - Detecting available external terminals on the system
|
||||
* - Cross-platform terminal launching
|
||||
* - Caching of detected terminals for performance
|
||||
*/
|
||||
|
||||
import { execFile, spawn, type ChildProcess } from 'child_process';
|
||||
import { promisify } from 'util';
|
||||
import { homedir } from 'os';
|
||||
import { join } from 'path';
|
||||
import { access } from 'fs/promises';
|
||||
import type { TerminalInfo } from '@automaker/types';
|
||||
|
||||
const execFileAsync = promisify(execFile);
|
||||
|
||||
// Platform detection
|
||||
const isWindows = process.platform === 'win32';
|
||||
const isMac = process.platform === 'darwin';
|
||||
const isLinux = process.platform === 'linux';
|
||||
|
||||
// Cache with TTL for terminal detection
|
||||
let cachedTerminals: TerminalInfo[] | null = null;
|
||||
let cacheTimestamp: number = 0;
|
||||
const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
|
||||
|
||||
/**
|
||||
* Check if the terminal cache is still valid
|
||||
*/
|
||||
function isCacheValid(): boolean {
|
||||
return cachedTerminals !== null && Date.now() - cacheTimestamp < CACHE_TTL_MS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the terminal detection cache
|
||||
* Useful when terminals may have been installed/uninstalled
|
||||
*/
|
||||
export function clearTerminalCache(): void {
|
||||
cachedTerminals = null;
|
||||
cacheTimestamp = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a CLI command exists in PATH
|
||||
* Uses platform-specific command lookup (where on Windows, which on Unix)
|
||||
*/
|
||||
async function commandExists(cmd: string): Promise<boolean> {
|
||||
try {
|
||||
const whichCmd = isWindows ? 'where' : 'which';
|
||||
await execFileAsync(whichCmd, [cmd]);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a macOS app bundle exists and return the path if found
|
||||
* Checks /Applications, /System/Applications (for built-in apps), and ~/Applications
|
||||
*/
|
||||
async function findMacApp(appName: string): Promise<string | null> {
|
||||
if (!isMac) return null;
|
||||
|
||||
// Check /Applications first (third-party apps)
|
||||
const appPath = join('/Applications', `${appName}.app`);
|
||||
try {
|
||||
await access(appPath);
|
||||
return appPath;
|
||||
} catch {
|
||||
// Not in /Applications
|
||||
}
|
||||
|
||||
// Check /System/Applications (built-in macOS apps like Terminal on Catalina+)
|
||||
const systemAppPath = join('/System/Applications', `${appName}.app`);
|
||||
try {
|
||||
await access(systemAppPath);
|
||||
return systemAppPath;
|
||||
} catch {
|
||||
// Not in /System/Applications
|
||||
}
|
||||
|
||||
// Check ~/Applications (used by some installers)
|
||||
const userAppPath = join(homedir(), 'Applications', `${appName}.app`);
|
||||
try {
|
||||
await access(userAppPath);
|
||||
return userAppPath;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a Windows path exists
|
||||
*/
|
||||
async function windowsPathExists(path: string): Promise<boolean> {
|
||||
if (!isWindows) return false;
|
||||
|
||||
try {
|
||||
await access(path);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Terminal definition with CLI command and platform-specific identifiers
|
||||
*/
|
||||
interface TerminalDefinition {
|
||||
id: string;
|
||||
name: string;
|
||||
/** CLI command (cross-platform, checked via which/where) */
|
||||
cliCommand?: string;
|
||||
/** Alternative CLI commands to check */
|
||||
cliAliases?: readonly string[];
|
||||
/** macOS app bundle name */
|
||||
macAppName?: string;
|
||||
/** Windows executable paths to check */
|
||||
windowsPaths?: readonly string[];
|
||||
/** Linux binary paths to check */
|
||||
linuxPaths?: readonly string[];
|
||||
/** Platform restriction */
|
||||
platform?: 'darwin' | 'win32' | 'linux';
|
||||
}
|
||||
|
||||
/**
|
||||
* List of supported terminals in priority order
|
||||
*/
|
||||
const SUPPORTED_TERMINALS: TerminalDefinition[] = [
|
||||
// macOS terminals
|
||||
{
|
||||
id: 'iterm2',
|
||||
name: 'iTerm2',
|
||||
cliCommand: 'iterm2',
|
||||
macAppName: 'iTerm',
|
||||
platform: 'darwin',
|
||||
},
|
||||
{
|
||||
id: 'warp',
|
||||
name: 'Warp',
|
||||
cliCommand: 'warp',
|
||||
macAppName: 'Warp',
|
||||
platform: 'darwin',
|
||||
},
|
||||
{
|
||||
id: 'ghostty',
|
||||
name: 'Ghostty',
|
||||
cliCommand: 'ghostty',
|
||||
macAppName: 'Ghostty',
|
||||
},
|
||||
{
|
||||
id: 'rio',
|
||||
name: 'Rio',
|
||||
cliCommand: 'rio',
|
||||
macAppName: 'Rio',
|
||||
},
|
||||
{
|
||||
id: 'alacritty',
|
||||
name: 'Alacritty',
|
||||
cliCommand: 'alacritty',
|
||||
macAppName: 'Alacritty',
|
||||
},
|
||||
{
|
||||
id: 'wezterm',
|
||||
name: 'WezTerm',
|
||||
cliCommand: 'wezterm',
|
||||
macAppName: 'WezTerm',
|
||||
},
|
||||
{
|
||||
id: 'kitty',
|
||||
name: 'Kitty',
|
||||
cliCommand: 'kitty',
|
||||
macAppName: 'kitty',
|
||||
},
|
||||
{
|
||||
id: 'hyper',
|
||||
name: 'Hyper',
|
||||
cliCommand: 'hyper',
|
||||
macAppName: 'Hyper',
|
||||
},
|
||||
{
|
||||
id: 'tabby',
|
||||
name: 'Tabby',
|
||||
cliCommand: 'tabby',
|
||||
macAppName: 'Tabby',
|
||||
},
|
||||
{
|
||||
id: 'terminal-macos',
|
||||
name: 'System Terminal',
|
||||
macAppName: 'Utilities/Terminal',
|
||||
platform: 'darwin',
|
||||
},
|
||||
|
||||
// Windows terminals
|
||||
{
|
||||
id: 'windows-terminal',
|
||||
name: 'Windows Terminal',
|
||||
cliCommand: 'wt',
|
||||
windowsPaths: [join(process.env.LOCALAPPDATA || '', 'Microsoft', 'WindowsApps', 'wt.exe')],
|
||||
platform: 'win32',
|
||||
},
|
||||
{
|
||||
id: 'powershell',
|
||||
name: 'PowerShell',
|
||||
cliCommand: 'pwsh',
|
||||
cliAliases: ['powershell'],
|
||||
windowsPaths: [
|
||||
join(
|
||||
process.env.SYSTEMROOT || 'C:\\Windows',
|
||||
'System32',
|
||||
'WindowsPowerShell',
|
||||
'v1.0',
|
||||
'powershell.exe'
|
||||
),
|
||||
],
|
||||
platform: 'win32',
|
||||
},
|
||||
{
|
||||
id: 'cmd',
|
||||
name: 'Command Prompt',
|
||||
cliCommand: 'cmd',
|
||||
windowsPaths: [join(process.env.SYSTEMROOT || 'C:\\Windows', 'System32', 'cmd.exe')],
|
||||
platform: 'win32',
|
||||
},
|
||||
{
|
||||
id: 'git-bash',
|
||||
name: 'Git Bash',
|
||||
windowsPaths: [
|
||||
join(process.env.PROGRAMFILES || 'C:\\Program Files', 'Git', 'git-bash.exe'),
|
||||
join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'Git', 'git-bash.exe'),
|
||||
],
|
||||
platform: 'win32',
|
||||
},
|
||||
|
||||
// Linux terminals
|
||||
{
|
||||
id: 'gnome-terminal',
|
||||
name: 'GNOME Terminal',
|
||||
cliCommand: 'gnome-terminal',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'konsole',
|
||||
name: 'Konsole',
|
||||
cliCommand: 'konsole',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'xfce4-terminal',
|
||||
name: 'XFCE4 Terminal',
|
||||
cliCommand: 'xfce4-terminal',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'tilix',
|
||||
name: 'Tilix',
|
||||
cliCommand: 'tilix',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'terminator',
|
||||
name: 'Terminator',
|
||||
cliCommand: 'terminator',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'foot',
|
||||
name: 'Foot',
|
||||
cliCommand: 'foot',
|
||||
platform: 'linux',
|
||||
},
|
||||
{
|
||||
id: 'xterm',
|
||||
name: 'XTerm',
|
||||
cliCommand: 'xterm',
|
||||
platform: 'linux',
|
||||
},
|
||||
];
|
||||
|
||||
/**
|
||||
* Try to find a terminal - checks CLI, macOS app bundle, or Windows paths
|
||||
* Returns TerminalInfo if found, null otherwise
|
||||
*/
|
||||
async function findTerminal(definition: TerminalDefinition): Promise<TerminalInfo | null> {
|
||||
// Skip if terminal is for a different platform
|
||||
if (definition.platform) {
|
||||
if (definition.platform === 'darwin' && !isMac) return null;
|
||||
if (definition.platform === 'win32' && !isWindows) return null;
|
||||
if (definition.platform === 'linux' && !isLinux) return null;
|
||||
}
|
||||
|
||||
// Try CLI command first (works on all platforms)
|
||||
const cliCandidates = [definition.cliCommand, ...(definition.cliAliases ?? [])].filter(
|
||||
Boolean
|
||||
) as string[];
|
||||
for (const cliCommand of cliCandidates) {
|
||||
if (await commandExists(cliCommand)) {
|
||||
return {
|
||||
id: definition.id,
|
||||
name: definition.name,
|
||||
command: cliCommand,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Try macOS app bundle
|
||||
if (isMac && definition.macAppName) {
|
||||
const appPath = await findMacApp(definition.macAppName);
|
||||
if (appPath) {
|
||||
return {
|
||||
id: definition.id,
|
||||
name: definition.name,
|
||||
command: `open -a "${appPath}"`,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Try Windows paths
|
||||
if (isWindows && definition.windowsPaths) {
|
||||
for (const windowsPath of definition.windowsPaths) {
|
||||
if (await windowsPathExists(windowsPath)) {
|
||||
return {
|
||||
id: definition.id,
|
||||
name: definition.name,
|
||||
command: windowsPath,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect all available external terminals on the system
|
||||
* Results are cached for 5 minutes for performance
|
||||
*/
|
||||
export async function detectAllTerminals(): Promise<TerminalInfo[]> {
|
||||
// Return cached result if still valid
|
||||
if (isCacheValid() && cachedTerminals) {
|
||||
return cachedTerminals;
|
||||
}
|
||||
|
||||
// Check all terminals in parallel for better performance
|
||||
const terminalChecks = SUPPORTED_TERMINALS.map((def) => findTerminal(def));
|
||||
const results = await Promise.all(terminalChecks);
|
||||
|
||||
// Filter out null results (terminals not found)
|
||||
const terminals = results.filter((t): t is TerminalInfo => t !== null);
|
||||
|
||||
// Update cache
|
||||
cachedTerminals = terminals;
|
||||
cacheTimestamp = Date.now();
|
||||
|
||||
return terminals;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect the default (first available) external terminal on the system
|
||||
* Returns the highest priority terminal that is installed, or null if none found
|
||||
*/
|
||||
export async function detectDefaultTerminal(): Promise<TerminalInfo | null> {
|
||||
const terminals = await detectAllTerminals();
|
||||
return terminals[0] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find a specific terminal by ID
|
||||
* Returns the terminal info if available, null otherwise
|
||||
*/
|
||||
export async function findTerminalById(id: string): Promise<TerminalInfo | null> {
|
||||
const terminals = await detectAllTerminals();
|
||||
return terminals.find((t) => t.id === id) ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a directory in the specified external terminal
|
||||
*
|
||||
* Handles cross-platform differences:
|
||||
* - On macOS, uses 'open -a' for app bundles or direct command with --directory flag
|
||||
* - On Windows, uses spawn with shell:true
|
||||
* - On Linux, uses direct execution with working directory
|
||||
*
|
||||
* @param targetPath - The directory path to open
|
||||
* @param terminalId - The terminal ID to use (optional, uses default if not specified)
|
||||
* @returns Promise that resolves with terminal info when launched, rejects on error
|
||||
*/
|
||||
export async function openInExternalTerminal(
|
||||
targetPath: string,
|
||||
terminalId?: string
|
||||
): Promise<{ terminalName: string }> {
|
||||
// Determine which terminal to use
|
||||
let terminal: TerminalInfo | null;
|
||||
|
||||
if (terminalId) {
|
||||
terminal = await findTerminalById(terminalId);
|
||||
if (!terminal) {
|
||||
// Fall back to default if specified terminal not found
|
||||
terminal = await detectDefaultTerminal();
|
||||
}
|
||||
} else {
|
||||
terminal = await detectDefaultTerminal();
|
||||
}
|
||||
|
||||
if (!terminal) {
|
||||
throw new Error('No external terminal available');
|
||||
}
|
||||
|
||||
// Execute the terminal
|
||||
await executeTerminalCommand(terminal, targetPath);
|
||||
|
||||
return { terminalName: terminal.name };
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a terminal command to open at a specific path
|
||||
* Handles platform-specific differences in command execution
|
||||
*/
|
||||
async function executeTerminalCommand(terminal: TerminalInfo, targetPath: string): Promise<void> {
|
||||
const { id, command } = terminal;
|
||||
|
||||
// Handle 'open -a "AppPath"' style commands (macOS app bundles)
|
||||
if (command.startsWith('open -a ')) {
|
||||
const appPath = command.replace('open -a ', '').replace(/"/g, '');
|
||||
|
||||
// Different terminals have different ways to open at a directory
|
||||
if (id === 'iterm2') {
|
||||
// iTerm2: Use AppleScript to open a new window at the path
|
||||
await execFileAsync('osascript', [
|
||||
'-e',
|
||||
`tell application "iTerm"
|
||||
create window with default profile
|
||||
tell current session of current window
|
||||
write text "cd ${escapeShellArg(targetPath)}"
|
||||
end tell
|
||||
end tell`,
|
||||
]);
|
||||
} else if (id === 'terminal-macos') {
|
||||
// macOS Terminal: Use AppleScript
|
||||
await execFileAsync('osascript', [
|
||||
'-e',
|
||||
`tell application "Terminal"
|
||||
do script "cd ${escapeShellArg(targetPath)}"
|
||||
activate
|
||||
end tell`,
|
||||
]);
|
||||
} else if (id === 'warp') {
|
||||
// Warp: Open app and use AppleScript to cd
|
||||
await execFileAsync('open', ['-a', appPath, targetPath]);
|
||||
} else {
|
||||
// Generic: Just open the app with the directory as argument
|
||||
await execFileAsync('open', ['-a', appPath, targetPath]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle different terminals based on their ID
|
||||
switch (id) {
|
||||
case 'iterm2':
|
||||
// iTerm2 CLI mode
|
||||
await execFileAsync('osascript', [
|
||||
'-e',
|
||||
`tell application "iTerm"
|
||||
create window with default profile
|
||||
tell current session of current window
|
||||
write text "cd ${escapeShellArg(targetPath)}"
|
||||
end tell
|
||||
end tell`,
|
||||
]);
|
||||
break;
|
||||
|
||||
case 'ghostty':
|
||||
// Ghostty: uses --working-directory=PATH format (single arg)
|
||||
await spawnDetached(command, [`--working-directory=${targetPath}`]);
|
||||
break;
|
||||
|
||||
case 'alacritty':
|
||||
// Alacritty: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'wezterm':
|
||||
// WezTerm: uses start --cwd flag
|
||||
await spawnDetached(command, ['start', '--cwd', targetPath]);
|
||||
break;
|
||||
|
||||
case 'kitty':
|
||||
// Kitty: uses --directory flag
|
||||
await spawnDetached(command, ['--directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'hyper':
|
||||
// Hyper: open at directory by setting cwd
|
||||
await spawnDetached(command, [targetPath]);
|
||||
break;
|
||||
|
||||
case 'tabby':
|
||||
// Tabby: open at directory
|
||||
await spawnDetached(command, ['open', targetPath]);
|
||||
break;
|
||||
|
||||
case 'rio':
|
||||
// Rio: uses --working-dir flag
|
||||
await spawnDetached(command, ['--working-dir', targetPath]);
|
||||
break;
|
||||
|
||||
case 'windows-terminal':
|
||||
// Windows Terminal: uses -d flag for directory
|
||||
await spawnDetached(command, ['-d', targetPath], { shell: true });
|
||||
break;
|
||||
|
||||
case 'powershell':
|
||||
case 'cmd':
|
||||
// PowerShell/CMD: Start in directory with /K to keep open
|
||||
await spawnDetached('start', [command, '/K', `cd /d "${targetPath}"`], {
|
||||
shell: true,
|
||||
});
|
||||
break;
|
||||
|
||||
case 'git-bash':
|
||||
// Git Bash: uses --cd flag
|
||||
await spawnDetached(command, ['--cd', targetPath], { shell: true });
|
||||
break;
|
||||
|
||||
case 'gnome-terminal':
|
||||
// GNOME Terminal: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'konsole':
|
||||
// Konsole: uses --workdir flag
|
||||
await spawnDetached(command, ['--workdir', targetPath]);
|
||||
break;
|
||||
|
||||
case 'xfce4-terminal':
|
||||
// XFCE4 Terminal: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'tilix':
|
||||
// Tilix: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'terminator':
|
||||
// Terminator: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'foot':
|
||||
// Foot: uses --working-directory flag
|
||||
await spawnDetached(command, ['--working-directory', targetPath]);
|
||||
break;
|
||||
|
||||
case 'xterm':
|
||||
// XTerm: uses -e to run a shell in the directory
|
||||
await spawnDetached(command, ['-e', `cd "${targetPath}" && $SHELL`]);
|
||||
break;
|
||||
|
||||
default:
|
||||
// Generic fallback: try to run the command with the directory as argument
|
||||
await spawnDetached(command, [targetPath]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawn a detached process that won't block the parent
|
||||
*/
|
||||
function spawnDetached(
|
||||
command: string,
|
||||
args: string[],
|
||||
options: { shell?: boolean } = {}
|
||||
): Promise<void> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const child: ChildProcess = spawn(command, args, {
|
||||
shell: options.shell ?? false,
|
||||
stdio: 'ignore',
|
||||
detached: true,
|
||||
});
|
||||
|
||||
// Unref to allow the parent process to exit independently
|
||||
child.unref();
|
||||
|
||||
child.on('error', (err) => {
|
||||
reject(err);
|
||||
});
|
||||
|
||||
// Resolve after a small delay to catch immediate spawn errors
|
||||
// Terminals run in background, so we don't wait for them to exit
|
||||
setTimeout(() => resolve(), 100);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape a string for safe use in shell commands
|
||||
*/
|
||||
function escapeShellArg(arg: string): string {
|
||||
// Escape single quotes by ending the quoted string, adding escaped quote, and starting new quoted string
|
||||
return `'${arg.replace(/'/g, "'\\''")}'`;
|
||||
}
|
||||
Reference in New Issue
Block a user