@myrialabs/clopen 0.0.1

package/backend/lib/terminal/pty-session-manager.ts

@@ -0,0 +1,387 @@
+/**
+ * Persistent PTY Session Manager
+ * Manages long-running interactive PTY sessions (one per terminal tab)
+ * Supports true TTY interaction with stdin/stdout streaming
+ */
+
+import type { IPty } from 'bun-pty';
+import { spawn } from 'bun-pty';
+import { debug } from '$shared/utils/logger';
+
+export interface PtySession {
+	sessionId: string;
+	pty: IPty;
+	cwd: string;
+	projectId?: string;
+	createdAt: Date;
+	lastActivityAt: Date;
+	// Stream listeners
+	dataListeners: Set<(data: string) => void>;
+	exitListeners: Set<(event: { exitCode: number; signal?: number | string }) => void>;
+	// Output batching (performance optimization)
+	pendingOutput: string;
+	flushScheduled: boolean;
+	// Monotonically increasing sequence number for deduplication
+	outputSeq: number;
+}
+
+class PtySessionManager {
+	private sessions = new Map<string, PtySession>();
+	private cleanupInterval: Timer | null = null;
+
+	constructor() {
+		// Start cleanup interval (remove sessions inactive for >1 hour)
+		this.startCleanupInterval();
+	}
+
+	/**
+	 * Create or get existing PTY session
+	 */
+	async createSession(
+		sessionId: string,
+		cwd: string,
+		projectId?: string,
+		terminalSize?: { cols: number; rows: number }
+	): Promise<PtySession> {
+		// Return existing session if already created
+		const existing = this.sessions.get(sessionId);
+		if (existing && existing.pty) {
+			debug.log('terminal', `♻️  Reusing existing PTY session: ${sessionId}`);
+			existing.lastActivityAt = new Date();
+			return existing;
+		}
+
+		debug.log('terminal', `🚀 Creating new interactive PTY session: ${sessionId}`);
+
+		// Determine shell based on platform
+		const isWindows = process.platform === 'win32';
+		let shell: string;
+		let shellArgs: string[] = [];
+
+		if (isWindows) {
+			// Windows: Use PowerShell in interactive mode
+			shell = 'powershell';
+			shellArgs = ['-NoLogo']; // Interactive mode, no -Command
+		} else {
+			// Unix: Use user's default shell or bash
+			shell = process.env.SHELL || '/bin/bash';
+			shellArgs = []; // Interactive mode, no -c
+		}
+
+		// Prepare environment
+		const ptyEnv: Record<string, string> = {};
+		for (const [key, value] of Object.entries(process.env)) {
+			if (value !== undefined) {
+				ptyEnv[key] = value;
+			}
+		}
+
+		// Terminal size
+		const cols = terminalSize?.cols || 80;
+		const rows = terminalSize?.rows || 24;
+
+		// Add terminal-specific environment variables
+		Object.assign(ptyEnv, {
+			FORCE_COLOR: '1',
+			COLORTERM: 'truecolor',
+			TERM: 'xterm-256color',
+			COLUMNS: cols.toString(),
+			LINES: rows.toString(),
+			TERM_PROGRAM: 'xterm.js',
+			CLICOLOR: '1',
+			LC_ALL: 'en_US.UTF-8',
+			LANG: 'en_US.UTF-8'
+		});
+
+		// Spawn interactive PTY
+		const pty = spawn(shell, shellArgs, {
+			name: 'xterm-256color',
+			cols,
+			rows,
+			cwd,
+			env: ptyEnv
+		});
+
+		debug.log('terminal', `✅ PTY spawned with PID: ${pty.pid}`);
+
+		// CRITICAL: Send initial newline to trigger shell prompt display
+		// Without this, shell won't show prompt on first connection
+		setTimeout(() => {
+			try {
+				pty.write('\r');
+				debug.log('terminal', '📝 Sent initial newline to trigger prompt');
+			} catch (error) {
+				debug.error('terminal', 'Failed to send initial newline:', error);
+			}
+		}, 100);
+
+		// Create session
+		const session: PtySession = {
+			sessionId,
+			pty,
+			cwd,
+			projectId,
+			createdAt: new Date(),
+			lastActivityAt: new Date(),
+			dataListeners: new Set(),
+			exitListeners: new Set(),
+			// Initialize batching state
+			pendingOutput: '',
+			flushScheduled: false,
+			outputSeq: 0
+		};
+
+		// Setup PTY event handlers with micro-task batching
+		pty.onData((data: string) => {
+			session.lastActivityAt = new Date();
+
+			// IMPORTANT: Always persist output to stream manager FIRST
+			// This ensures output is saved even if there are no active listeners
+			try {
+				const { terminalStreamManager } = require('./stream-manager');
+				const stream = terminalStreamManager.getStreamBySession(sessionId);
+				if (stream) {
+					terminalStreamManager.addOutput(stream.streamId, data);
+				}
+			} catch (error) {
+				// Stream manager not available yet, skip buffering
+			}
+
+			// Batch output for high-frequency data (micro-task batching)
+			session.pendingOutput += data;
+
+			if (!session.flushScheduled) {
+				session.flushScheduled = true;
+
+				// Use queueMicrotask for minimal latency batching
+				queueMicrotask(() => {
+					const output = session.pendingOutput;
+					session.pendingOutput = '';
+					session.flushScheduled = false;
+
+					// Increment sequence number for deduplication
+					session.outputSeq++;
+
+					// Broadcast batched output to all listeners
+					session.dataListeners.forEach(listener => {
+						try {
+							listener(output);
+						} catch (error) {
+							debug.error('terminal', 'Error in data listener:', error);
+						}
+					});
+				});
+			}
+		});
+
+		pty.onExit((event: { exitCode: number; signal?: number | string }) => {
+			debug.log('terminal', `🏁 PTY session ${sessionId} exited with code: ${event.exitCode}`);
+			// Broadcast to all listeners
+			session.exitListeners.forEach(listener => {
+				try {
+					listener(event);
+				} catch (error) {
+					debug.error('terminal', 'Error in exit listener:', error);
+				}
+			});
+			// Remove session
+			this.sessions.delete(sessionId);
+		});
+
+		// Store session
+		this.sessions.set(sessionId, session);
+
+		return session;
+	}
+
+	/**
+	 * Get existing session
+	 */
+	getSession(sessionId: string): PtySession | undefined {
+		return this.sessions.get(sessionId);
+	}
+
+	/**
+	 * Write data to PTY (stdin)
+	 */
+	write(sessionId: string, data: string): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session || !session.pty) {
+			debug.error('terminal', `❌ Cannot write to session ${sessionId}: session not found`);
+			return false;
+		}
+
+		try {
+			session.pty.write(data);
+			session.lastActivityAt = new Date();
+			return true;
+		} catch (error) {
+			debug.error('terminal', `❌ Error writing to PTY ${sessionId}:`, error);
+			return false;
+		}
+	}
+
+	/**
+	 * Resize PTY
+	 */
+	resize(sessionId: string, cols: number, rows: number): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session || !session.pty) {
+			return false;
+		}
+
+		try {
+			session.pty.resize(cols, rows);
+			debug.log('terminal', `🔧 PTY ${sessionId} resized to ${cols}x${rows}`);
+			return true;
+		} catch (error) {
+			debug.error('terminal', `❌ Error resizing PTY ${sessionId}:`, error);
+			return false;
+		}
+	}
+
+	/**
+	 * Kill PTY session
+	 */
+	killSession(sessionId: string, signal?: string): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session || !session.pty) {
+			return false;
+		}
+
+		try {
+			debug.log('terminal', `💀 Killing PTY session ${sessionId}`);
+
+			if (signal === 'SIGKILL' || signal === '9') {
+				session.pty.kill('SIGKILL');
+			} else if (signal === 'SIGTERM' || signal === '15') {
+				session.pty.kill('SIGTERM');
+			} else {
+				// Send Ctrl+C first for graceful termination
+				session.pty.write('\x03');
+
+				// Follow up with SIGKILL after delay
+				setTimeout(() => {
+					if (this.sessions.has(sessionId)) {
+						try {
+							session.pty.kill('SIGKILL');
+						} catch {
+							// Already dead, ignore
+						}
+					}
+				}, 1000);
+			}
+
+			this.sessions.delete(sessionId);
+			return true;
+		} catch (error) {
+			debug.error('terminal', `❌ Error killing PTY ${sessionId}:`, error);
+			this.sessions.delete(sessionId); // Remove anyway
+			return false;
+		}
+	}
+
+	/**
+	 * Add data listener
+	 */
+	addDataListener(sessionId: string, listener: (data: string) => void): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return false;
+		}
+		session.dataListeners.add(listener);
+		return true;
+	}
+
+	/**
+	 * Remove data listener
+	 */
+	removeDataListener(sessionId: string, listener: (data: string) => void): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return false;
+		}
+		return session.dataListeners.delete(listener);
+	}
+
+	/**
+	 * Add exit listener
+	 */
+	addExitListener(
+		sessionId: string,
+		listener: (event: { exitCode: number; signal?: number | string }) => void
+	): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return false;
+		}
+		session.exitListeners.add(listener);
+		return true;
+	}
+
+	/**
+	 * Remove exit listener
+	 */
+	removeExitListener(
+		sessionId: string,
+		listener: (event: { exitCode: number; signal?: number | string }) => void
+	): boolean {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return false;
+		}
+		return session.exitListeners.delete(listener);
+	}
+
+	/**
+	 * Get all active sessions
+	 */
+	getAllSessions(): PtySession[] {
+		return Array.from(this.sessions.values());
+	}
+
+	/**
+	 * Start cleanup interval
+	 */
+	private startCleanupInterval() {
+		// Run every 15 minutes
+		this.cleanupInterval = setInterval(() => {
+			this.cleanupInactiveSessions();
+		}, 15 * 60 * 1000);
+	}
+
+	/**
+	 * Cleanup inactive sessions (>1 hour no activity)
+	 */
+	private cleanupInactiveSessions() {
+		const now = new Date();
+		const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
+
+		for (const [sessionId, session] of this.sessions.entries()) {
+			if (session.lastActivityAt < oneHourAgo) {
+				debug.log('terminal', `🧹 Cleaning up inactive session: ${sessionId}`);
+				this.killSession(sessionId);
+			}
+		}
+	}
+
+	/**
+	 * Cleanup all sessions (on shutdown)
+	 */
+	dispose() {
+		debug.log('terminal', '🧹 Disposing all PTY sessions');
+
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+		}
+
+		for (const sessionId of this.sessions.keys()) {
+			this.killSession(sessionId, 'SIGKILL');
+		}
+
+		this.sessions.clear();
+	}
+}
+
+// Export singleton instance
+export const ptySessionManager = new PtySessionManager();

package/backend/lib/terminal/shell-utils.ts

@@ -0,0 +1,313 @@
+/**
+ * Shell utilities optimized for bun-pty
+ * Provides cross-platform shell detection and PTY creation
+ */
+
+import { join } from 'path';
+import { spawn, type IPty } from 'bun-pty';
+
+import { debug } from '$shared/utils/logger';
+// Platform detection
+export const isWindows = process.platform === 'win32';
+export const isMacOS = process.platform === 'darwin';
+export const isLinux = process.platform === 'linux';
+
+/**
+ * Find Git Bash executable on Windows
+ */
+export async function findGitBash(): Promise<string | null> {
+	if (!isWindows) return null;
+	
+	const possiblePaths = [
+		'C:\\Program Files\\Git\\bin\\bash.exe',
+		'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+		process.env.PROGRAMFILES ? join(process.env.PROGRAMFILES, 'Git', 'bin', 'bash.exe') : null,
+		process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, 'Programs', 'Git', 'bin', 'bash.exe') : null,
+	].filter(Boolean) as string[];
+	
+	for (const bashPath of possiblePaths) {
+		try {
+			if (await Bun.file(bashPath).exists()) {
+				debug.log('terminal', '✅ Found Git Bash at:', bashPath);
+				return bashPath;
+			}
+		} catch {
+			// Continue to next path
+		}
+	}
+	
+	return null;
+}
+
+/**
+ * Find PowerShell executable on Windows
+ */
+export async function findPowerShell(): Promise<string | null> {
+	if (!isWindows) return null;
+	
+	const possiblePaths = [
+		'C:\\Program Files\\PowerShell\\7\\pwsh.exe',
+		'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe',
+		process.env.SYSTEMROOT ? join(process.env.SYSTEMROOT, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe') : null,
+	].filter(Boolean) as string[];
+	
+	for (const pwshPath of possiblePaths) {
+		try {
+			if (await Bun.file(pwshPath).exists()) {
+				debug.log('terminal', '✅ Found PowerShell at:', pwshPath);
+				return pwshPath;
+			}
+		} catch {
+			// Continue to next path
+		}
+	}
+	
+	return null;
+}
+
+/**
+ * Check if Git Bash is available
+ */
+export async function isGitBashAvailable(): Promise<boolean> {
+	if (!isWindows) return false;
+	return (await findGitBash()) !== null;
+}
+
+/**
+ * Get Git Bash required message
+ */
+export function getGitBashRequiredMessage(command: string): string {
+	return `⚠️  Git Bash is required for Unix commands!
+
+The command '${command}' requires Git Bash.
+
+Please install Git for Windows:
+• Download from: https://git-scm.com/download/win
+• Or install via: winget install Git.Git
+
+After installation, restart the application.`;
+}
+
+/**
+ * Get the appropriate shell configuration for the current platform
+ */
+export async function getShellConfig(preferGitBash = false): Promise<{
+	shell: string;
+	args: (command: string) => string[];
+	name: string;
+	isUnixLike: boolean;
+}> {
+	if (isWindows) {
+		// For Windows, always use PowerShell as the primary shell
+		// PowerShell is available on all modern Windows systems
+		return {
+			shell: 'powershell',
+			args: (command: string) => ['-NoProfile', '-Command', command],
+			name: 'PowerShell',
+			isUnixLike: false
+		};
+	}
+	
+	// macOS
+	if (isMacOS) {
+		if (await Bun.file('/bin/zsh').exists()) {
+			return {
+				shell: '/bin/zsh',
+				args: (command: string) => ['-c', command],
+				name: 'Zsh',
+				isUnixLike: true
+			};
+		}
+		return {
+			shell: '/bin/bash',
+			args: (command: string) => ['-c', command],
+			name: 'Bash',
+			isUnixLike: true
+		};
+	}
+	
+	// Linux
+	if (isLinux) {
+		const userShell = process.env.SHELL || '/bin/bash';
+		const shellName = userShell.split('/').pop() || 'Shell';
+		return {
+			shell: userShell,
+			args: (command: string) => ['-c', command],
+			name: shellName.charAt(0).toUpperCase() + shellName.slice(1),
+			isUnixLike: true
+		};
+	}
+	
+	// Fallback
+	return {
+		shell: '/bin/sh',
+		args: (command: string) => ['-c', command],
+		name: 'Shell',
+		isUnixLike: true
+	};
+}
+
+/**
+ * Create a PTY instance using bun-pty with xterm.js optimizations
+ */
+export function createPty(shell: string, args: string[], cwd: string, terminalSize?: { cols: number; rows: number }): IPty {
+	// Prepare environment
+	const ptyEnv: Record<string, string> = {};
+	
+	// Copy defined environment variables
+	for (const [key, value] of Object.entries(process.env)) {
+		if (value !== undefined) {
+			ptyEnv[key] = value;
+		}
+	}
+	
+	// Get terminal dimensions from frontend or use defaults
+	const cols = terminalSize?.cols || 80;
+	const rows = terminalSize?.rows || 24;
+	
+	// Add terminal-specific environment variables optimized for xterm.js
+	Object.assign(ptyEnv, {
+		FORCE_COLOR: '1',
+		COLORTERM: 'truecolor',
+		TERM: 'xterm-256color',
+		COLUMNS: cols.toString(),
+		LINES: rows.toString(),
+		// Enable proper ANSI support
+		TERM_PROGRAM: 'xterm.js',
+		// Optimize for interactive terminal
+		CLICOLOR: '1',
+		// Enable Unicode support
+		LC_ALL: 'en_US.UTF-8',
+		LANG: 'en_US.UTF-8'
+	});
+	
+	// Extract the actual command from args
+	const actualCommand: string = '';
+	
+	if (isWindows) {
+		// Windows: Always use PowerShell
+		if (shell === 'powershell') {
+			// Extract the actual command from args
+			let actualCommand = args.join(' ');
+			if (args.length >= 2 && (args[0] === '-Command' || args[0] === '-NoProfile')) {
+				// Find the actual command in the args
+				const commandIndex = args.findIndex(arg => arg === '-Command');
+				if (commandIndex !== -1 && commandIndex + 1 < args.length) {
+					actualCommand = args[commandIndex + 1];
+				} else if (args[args.length - 1] !== '-Command' && args[args.length - 1] !== '-NoProfile') {
+					actualCommand = args[args.length - 1];
+				}
+			}
+			return spawn('powershell', ['-NoProfile', '-NoLogo', '-Command', actualCommand], {
+				name: 'xterm-256color',
+				cols,
+				rows,
+				cwd: cwd,
+				env: ptyEnv
+			});
+		}
+		
+		// Default to PowerShell if shell is not recognized
+		return spawn('powershell', ['-NoProfile', '-NoLogo', '-Command', args.join(' ') || 'Write-Host "Terminal ready"'], {
+			name: 'xterm-256color',
+			cols,
+			rows,
+			cwd: cwd,
+			env: ptyEnv
+		});
+	}
+	
+	// Unix-like systems
+	return spawn(shell, args, {
+		name: 'xterm-256color',
+		cols,
+		rows,
+		cwd: cwd,
+		env: ptyEnv
+	});
+}
+
+/**
+ * Create a PTY wrapper for process-manager compatibility with xterm.js support
+ */
+export function createPtyWrapper(pty: IPty, sessionId?: string): any {
+	let isKilled = false;
+	
+	return {
+		pid: pty.pid,
+		pty: pty, // Expose the original PTY instance
+		
+		// Expose PTY event handlers
+		onData: (callback: (data: string) => void) => {
+			return pty.onData(callback);
+		},
+		
+		onExit: (callback: (event: { exitCode: number; signal?: number | string }) => void) => {
+			return pty.onExit((event) => {
+				isKilled = true;
+				debug.log('terminal', `🏁 PTY ${pty.pid} exited with code:`, event.exitCode);
+				callback({ exitCode: event.exitCode, signal: event.signal });
+			});
+		},
+		
+		resize: (cols: number, rows: number) => {
+			try {
+				debug.log('terminal', `🔧 Resizing PTY ${pty.pid} to ${cols}x${rows}`);
+				pty.resize(cols, rows);
+				debug.log('terminal', `✅ PTY ${pty.pid} resized successfully`);
+			} catch (error) {
+				debug.error('terminal', `❌ Failed to resize PTY ${pty.pid}:`, error);
+				throw error;
+			}
+		},
+		
+		write: (data: string) => {
+			return pty.write(data);
+		},
+		
+		kill: (signal?: number | string) => {
+			if (isKilled) {
+				debug.log('terminal', '⚠️ PTY already killed, ignoring kill signal');
+				return;
+			}
+			
+			try {
+				isKilled = true;
+				debug.log('terminal', `💀 Killing PTY ${pty.pid} with signal:`, signal);
+				
+				if (signal === 'SIGKILL' || signal === 9) {
+					pty.kill('SIGKILL');
+				} else if (signal === 'SIGTERM' || signal === 15) {
+					pty.kill('SIGTERM');
+				} else {
+					// Send Ctrl+C for graceful termination, then SIGKILL as fallback
+					debug.log('terminal', '⌨️  Sending Ctrl+C to PTY...');
+					pty.write('\x03');
+					
+					// Give the process time to handle Ctrl+C gracefully
+					setTimeout(() => {
+						try {
+							if (pty.pid && !isKilled) {
+								debug.log('terminal', '⏰ Graceful termination timeout, sending SIGKILL...');
+								pty.kill('SIGKILL');
+							}
+						} catch (killError) {
+							// Process might already be dead, this is expected
+							debug.log('terminal', '💀 PTY process already terminated');
+						}
+					}, 1000);
+				}
+			} catch (e) {
+				debug.log('terminal', '⚠️ Error killing PTY (this may be normal during shutdown):', e instanceof Error ? e.message : e);
+			}
+		},
+		
+		exited: new Promise<number>((resolve) => {
+			pty.onExit((event) => {
+				isKilled = true;
+				debug.log('terminal', `🏁 PTY ${pty.pid} exited with code:`, event.exitCode);
+				resolve(event.exitCode);
+			});
+		})
+	};
+}