@myrialabs/clopen 0.0.1

package/frontend/lib/services/terminal/background/session-restore.ts

@@ -0,0 +1,274 @@
+/**
+ * Terminal Session Restoration Service
+ * Handles restoration of terminal sessions after browser refresh
+ */
+
+import { terminalSessionManager } from '../session.service';
+import { terminalPersistenceManager } from '../persistence.service';
+import { terminalStore } from '$frontend/lib/stores/features/terminal.svelte';
+
+interface SessionToReconnect {
+	sessionId: string;
+	streamId: string;
+	command: string;
+}
+
+class SessionRestoreService {
+	private isRestorationComplete = false;
+	private sessionsToReconnect: SessionToReconnect[] = [];
+
+	/**
+	 * Check if restoration is done
+	 */
+	isRestorationDone(): boolean {
+		return this.isRestorationComplete;
+	}
+
+	/**
+	 * Check if there are restored sessions
+	 */
+	hasRestoredSessions(): boolean {
+		const persistedData = terminalPersistenceManager.loadTerminalSessions();
+		return persistedData !== null && persistedData.sessions.length > 0;
+	}
+
+	/**
+	 * Get sessions that need reconnection
+	 */
+	getSessionsToReconnect(): SessionToReconnect[] {
+		return this.sessionsToReconnect;
+	}
+
+	/**
+	 * Clear sessions to reconnect list
+	 */
+	clearSessionsToReconnect(): void {
+		this.sessionsToReconnect = [];
+	}
+
+	/**
+	 * Restore terminal sessions from persistence
+	 */
+	async restoreTerminalSessions(): Promise<void> {
+		const persistedData = terminalPersistenceManager.loadTerminalSessions();
+		if (!persistedData || persistedData.sessions.length === 0) {
+			// If no sessions, then clean up any orphaned stream info
+			this.cleanupStaleStreamInfo();
+			this.isRestorationComplete = true; // Mark as done even if no sessions
+			return;
+		}
+
+		// Check if terminal store already has sessions (might be initialized elsewhere)
+		const existingSessions = terminalStore.sessions;
+		const existingSessionIds = new Set(existingSessions.map(s => s.id));
+
+		// Update nextSessionId based on restored sessions to avoid conflicts
+		let maxSessionId = 0;
+		for (const persistedSession of persistedData.sessions) {
+			const match = persistedSession.sessionId.match(/terminal-(\d+)/);
+			if (match) {
+				const id = parseInt(match[1], 10);
+				if (id > maxSessionId) {
+					maxSessionId = id;
+				}
+			}
+		}
+
+		// Update terminal store's nextSessionId if needed
+		if (maxSessionId > 0) {
+			terminalStore.updateNextSessionId(maxSessionId + 1);
+		}
+
+		// Track sessions that need stream reconnection
+		const sessionsNeedingReconnect: SessionToReconnect[] = [];
+
+		for (const persistedSession of persistedData.sessions) {
+			// Skip if session already exists
+			if (existingSessionIds.has(persistedSession.sessionId)) {
+				continue;
+			}
+
+			// Restore session in session manager
+			terminalSessionManager.restoreSession(
+				persistedSession.sessionId,
+				persistedSession.projectId,
+				persistedSession.projectPath,
+				persistedSession.workingDirectory,
+				[], // outputHistory will be restored from lines
+				persistedSession.commandHistory,
+				persistedSession.createdAt,
+				persistedSession.lastUsedAt
+			);
+
+			// Restore session in terminal store
+			// Extract terminal number from sessionId (format: projectId-terminal-N or terminal-N)
+			const sessionParts = persistedSession.sessionId.split('-');
+			const terminalNumber = sessionParts[sessionParts.length - 1] || '1';
+
+			const restoredSession = {
+				id: persistedSession.sessionId,
+				name: `Terminal ${terminalNumber}`,
+				directory: persistedSession.workingDirectory,
+				lines: persistedSession.lines || [],
+				commandHistory: persistedSession.commandHistory || [],
+				isActive: persistedSession.isActive,
+				createdAt: persistedSession.createdAt,
+				lastUsedAt: persistedSession.lastUsedAt,
+				shellType: persistedSession.shellType || 'Unknown',
+				terminalBuffer: undefined,
+				projectId: persistedSession.projectId,
+				projectPath: persistedSession.projectPath
+			};
+
+			// Add to terminal store only if it doesn't exist
+			terminalStore.addSession(restoredSession);
+
+			// Check if this session was executing and needs reconnection
+			if (persistedSession.isExecuting && persistedSession.lastCommand) {
+				// Mark this session as restored
+				if (typeof window !== 'undefined') {
+					sessionStorage.setItem('terminal-restored-' + persistedSession.sessionId, 'true');
+				}
+
+				// Add to reconnection list
+				// Use streamId if available, otherwise generate one based on sessionId
+				const streamId = persistedSession.streamId || `stream-${persistedSession.sessionId}-${Date.now()}`;
+				sessionsNeedingReconnect.push({
+					sessionId: persistedSession.sessionId,
+					streamId: streamId,
+					command: persistedSession.lastCommand
+				});
+			}
+
+			// Note: We don't need to add output history to session manager separately
+			// because the lines are already included in restoredSession.lines
+			// Adding them again would cause duplication
+		}
+
+		// Set active session only if it exists in the restored sessions
+		if (persistedData.activeSessionId) {
+			const activeSessionExists = terminalStore.sessions.find(s => s.id === persistedData.activeSessionId);
+			if (activeSessionExists) {
+				terminalStore.setActiveSession(persistedData.activeSessionId);
+				terminalSessionManager.setActiveSession(persistedData.activeSessionId);
+			} else if (terminalStore.sessions.length > 0) {
+				// Set first session as active if specified active session doesn't exist
+				const firstSession = terminalStore.sessions[0];
+				terminalStore.setActiveSession(firstSession.id);
+				terminalSessionManager.setActiveSession(firstSession.id);
+			}
+		}
+
+		// Mark restoration as complete
+		this.isRestorationComplete = true;
+
+		// Store sessions needing reconnect for later processing
+		this.sessionsToReconnect = sessionsNeedingReconnect;
+
+		// After restoration complete, clean up truly orphaned stream info
+		// This will only remove stream info for sessions that don't exist
+		this.cleanupStaleStreamInfo();
+	}
+
+	/**
+	 * Clean up stale stream info (in-memory)
+	 * Only removes stream info that doesn't have corresponding sessions
+	 */
+	cleanupStaleStreamInfo(): void {
+		const validSessionIds = new Set(terminalStore.sessions.map(s => s.id));
+		const allStreams = terminalPersistenceManager.getAllActiveStreams();
+
+		for (const stream of allStreams) {
+			if (!validSessionIds.has(stream.sessionId)) {
+				terminalPersistenceManager.clearStreamInfo(stream.sessionId, stream.streamId);
+			}
+		}
+	}
+
+	/**
+	 * Get active streams for reconnection
+	 */
+	getActiveStreamsForReconnection(): SessionToReconnect[] {
+		// Only try to reconnect if we have restored sessions
+		const restoredSessions = terminalStore.sessions;
+		if (restoredSessions.length === 0) {
+			return [];
+		}
+
+		const activeStreams: SessionToReconnect[] = [];
+		const processedStreamIds = new Set<string>();
+
+		// First, add sessions that were marked as executing during restoration
+		if (this.sessionsToReconnect.length > 0) {
+			for (const session of this.sessionsToReconnect) {
+				activeStreams.push(session);
+				processedStreamIds.add(session.streamId);
+			}
+		}
+
+		// Check persistence manager for all stream info (session-based and streamId-based)
+		const allActiveStreams = terminalPersistenceManager.getAllActiveStreams();
+		for (const streamInfo of allActiveStreams) {
+			// Skip if already processed
+			if (processedStreamIds.has(streamInfo.streamId)) {
+				continue;
+			}
+
+			// IMPORTANT: Only reconnect to streams that belong to current project sessions
+			// Don't try to reconnect to streams from other projects during restoration
+			let shouldReconnect = false;
+			let matchingSessionId: string | null = null;
+
+			for (const session of restoredSessions) {
+				// Only match by exact sessionId (not by projectId during initial restoration)
+				// This prevents trying to reconnect to other project's streams
+				if (streamInfo.sessionId === session.id) {
+					shouldReconnect = true;
+					matchingSessionId = session.id;
+					break;
+				}
+			}
+
+			if (shouldReconnect && matchingSessionId) {
+				activeStreams.push({
+					sessionId: matchingSessionId,
+					streamId: streamInfo.streamId,
+					command: streamInfo.command
+				});
+				processedStreamIds.add(streamInfo.streamId);
+			}
+		}
+
+		return activeStreams;
+	}
+
+	/**
+	 * Save current terminal state
+	 */
+	saveCurrentState(): void {
+		const sessions = terminalStore.sessions;
+		const activeSessionId = terminalStore.activeSessionId;
+
+		// Check for duplicates before saving
+		const uniqueSessions = new Map<string, any>();
+		for (const session of sessions) {
+			if (!uniqueSessions.has(session.id)) {
+				// Enhance session with execution state from terminalSessionManager
+				const sessionState = terminalSessionManager.getSession(session.id);
+				const enhancedSession = {
+					...session,
+					isExecuting: sessionState?.isExecuting || false,
+					lastCommand: sessionState?.lastCommand || undefined,
+					streamId: sessionState?.streamId || undefined
+				};
+				uniqueSessions.set(session.id, enhancedSession);
+			}
+		}
+
+		const cleanSessions = Array.from(uniqueSessions.values());
+		terminalPersistenceManager.saveTerminalSessions(cleanSessions, activeSessionId);
+	}
+}
+
+// Export singleton instance
+export const sessionRestoreService = new SessionRestoreService();

package/frontend/lib/services/terminal/background/stream-manager.ts

@@ -0,0 +1,286 @@
+/**
+ * Terminal Stream Manager
+ * Manages active terminal streams and their lifecycle
+ */
+
+import { terminalSessionManager } from '../session.service';
+import { terminalPersistenceManager } from '../persistence.service';
+import { terminalStore } from '$frontend/lib/stores/features/terminal.svelte';
+import type { TerminalLine } from '$shared/types/terminal';
+
+export interface StreamInfo {
+	streamId: string;
+	sessionId: string;
+	command: string;
+	status: 'active' | 'reconnecting' | 'completed' | 'error';
+	reconnectAttempts: number;
+	maxReconnectAttempts: number;
+	outputIndex: number;
+}
+
+class StreamManager {
+	private streams = new Map<string, StreamInfo>();
+	private reconnectTimers = new Map<string, NodeJS.Timeout>();
+	private readonly MAX_RECONNECT_ATTEMPTS = 5;
+	private readonly RECONNECT_DELAY = 2000; // Start with 2 seconds
+
+	/**
+	 * Get stream info for a session
+	 */
+	getStreamInfo(sessionId: string): StreamInfo | undefined {
+		return this.streams.get(sessionId);
+	}
+
+	/**
+	 * Check if a session has an active stream (PTY process running)
+	 */
+	hasActiveStream(sessionId: string): boolean {
+		const streamInfo = this.streams.get(sessionId);
+		return streamInfo?.status === 'active' || streamInfo?.status === 'reconnecting';
+	}
+
+	/**
+	 * Check if any session has active streams
+	 */
+	hasAnyActiveStreams(): boolean {
+		for (const [_, streamInfo] of this.streams) {
+			if (streamInfo.status === 'active' || streamInfo.status === 'reconnecting') {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Get active streams count
+	 */
+	getActiveStreamsCount(): number {
+		return this.streams.size;
+	}
+
+	/**
+	 * Start a new terminal stream
+	 */
+	startStream(sessionId: string, streamId: string, command: string, projectId?: string): void {
+		// Save stream info for persistence with projectId
+		terminalPersistenceManager.saveActiveStream(sessionId, streamId, command, projectId);
+
+		// Track stream
+		const streamInfo: StreamInfo = {
+			streamId,
+			sessionId,
+			command,
+			status: 'active',
+			reconnectAttempts: 0,
+			maxReconnectAttempts: this.MAX_RECONNECT_ATTEMPTS,
+			outputIndex: 0
+		};
+
+		this.streams.set(sessionId, streamInfo);
+	}
+
+	/**
+	 * Update stream status
+	 */
+	updateStreamStatus(sessionId: string, status: StreamInfo['status']): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (streamInfo) {
+			streamInfo.status = status;
+		}
+	}
+
+	/**
+	 * Update output index
+	 */
+	updateOutputIndex(sessionId: string, index: number): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (streamInfo) {
+			streamInfo.outputIndex = index;
+		}
+	}
+
+	/**
+	 * Increment output index
+	 */
+	incrementOutputIndex(sessionId: string): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (streamInfo) {
+			streamInfo.outputIndex++;
+		}
+	}
+
+	/**
+	 * Update reconnect attempts
+	 */
+	updateReconnectAttempts(sessionId: string, attempts: number): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (streamInfo) {
+			streamInfo.reconnectAttempts = attempts;
+		}
+	}
+
+	/**
+	 * Set reconnect timer
+	 */
+	setReconnectTimer(sessionId: string, timer: NodeJS.Timeout): void {
+		// Clear existing timer if any
+		this.clearReconnectTimer(sessionId);
+		this.reconnectTimers.set(sessionId, timer);
+	}
+
+	/**
+	 * Clear reconnect timer
+	 */
+	clearReconnectTimer(sessionId: string): void {
+		const timer = this.reconnectTimers.get(sessionId);
+		if (timer) {
+			clearTimeout(timer);
+			this.reconnectTimers.delete(sessionId);
+		}
+	}
+
+	/**
+	 * End a terminal stream
+	 */
+	endStream(sessionId: string, forceClear: boolean = false): void {
+		const streamInfo = this.streams.get(sessionId);
+
+		// If forceClear is true (e.g., from cancelCommand), clear localStorage immediately
+		if (forceClear && streamInfo) {
+			terminalPersistenceManager.clearStreamInfo(sessionId, streamInfo.streamId);
+		}
+		// Otherwise DON'T clear stream info from localStorage here
+		// It will be cleared by terminal-service when command actually completes
+		// This allows reconnection after browser refresh
+
+		// Remove from active streams in memory
+		this.streams.delete(sessionId);
+
+		// Clear any reconnect timers
+		this.clearReconnectTimer(sessionId);
+	}
+
+	/**
+	 * Handle stream completion
+	 */
+	handleStreamCompletion(sessionId: string): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (!streamInfo) return;
+
+		// Clear reconnect timer
+		this.clearReconnectTimer(sessionId);
+
+		// Remove stream
+		this.streams.delete(sessionId);
+
+		// Clear persistence with streamId
+		terminalPersistenceManager.clearStreamInfo(sessionId, streamInfo.streamId);
+
+		// Mark session as not executing
+		terminalSessionManager.endExecution(sessionId);
+		terminalStore.setExecutingState(sessionId, false);
+
+		// Trigger prompt display
+		terminalStore.triggerPromptDisplay(sessionId);
+	}
+
+	/**
+	 * Handle stream data
+	 */
+	handleStreamData(sessionId: string, data: any): void {
+		const streamInfo = this.streams.get(sessionId);
+		if (!streamInfo) return;
+
+		// Update output index
+		streamInfo.outputIndex++;
+
+		// Handle different data types
+		switch (data.type) {
+			case 'output':
+			case 'error':
+				// Add to terminal display
+				const outputLine: TerminalLine = {
+					content: data.content || '',
+					type: data.type,
+					timestamp: new Date()
+				};
+				terminalStore.addOutput(sessionId, outputLine);
+
+				// Add to session history
+				terminalSessionManager.addOutputToHistory(sessionId, data.content || '');
+
+				// Clear the restoration flag on first successful output
+				// This ensures we don't show "restored session" message on interrupt
+				if (typeof window !== 'undefined' && sessionStorage.getItem('terminal-restored-' + sessionId) === 'true') {
+					sessionStorage.removeItem('terminal-restored-' + sessionId);
+				}
+				break;
+
+			case 'directory':
+				// Update working directory
+				if (data.newDirectory) {
+					terminalSessionManager.updateWorkingDirectory(sessionId, data.newDirectory);
+					terminalStore.updateWorkingDirectory(sessionId, data.newDirectory);
+				}
+				break;
+
+			case 'exit':
+			case 'complete':
+				// Command completed
+				this.handleStreamCompletion(sessionId);
+				break;
+		}
+	}
+
+	/**
+	 * Clean up all streams
+	 */
+	cleanup(): void {
+		// Clear all timers
+		for (const timer of this.reconnectTimers.values()) {
+			clearTimeout(timer);
+		}
+
+		// Clear maps
+		this.streams.clear();
+		this.reconnectTimers.clear();
+	}
+
+	/**
+	 * Get all streams
+	 */
+	getAllStreams(): Map<string, StreamInfo> {
+		return this.streams;
+	}
+
+	/**
+	 * Create stream info
+	 */
+	createStreamInfo(
+		streamId: string,
+		sessionId: string,
+		command: string,
+		status: StreamInfo['status'] = 'reconnecting',
+		attemptNumber: number = 1
+	): StreamInfo {
+		return {
+			streamId,
+			sessionId,
+			command,
+			status,
+			reconnectAttempts: attemptNumber,
+			maxReconnectAttempts: this.MAX_RECONNECT_ATTEMPTS,
+			outputIndex: 0
+		};
+	}
+
+	/**
+	 * Add or update stream
+	 */
+	setStream(sessionId: string, streamInfo: StreamInfo): void {
+		this.streams.set(sessionId, streamInfo);
+	}
+}
+
+// Export singleton instance
+export const streamManager = new StreamManager();

package/frontend/lib/services/terminal/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Terminal Services Module
+ *
+ * Centralized exports for all terminal-related services
+ */
+
+export { terminalService } from './terminal.service';
+export { terminalPersistenceManager } from './persistence.service';
+export { terminalProjectManager } from './project.service';
+export { terminalSessionManager } from './session.service';
+
+// Export types if needed
+export type { TerminalSessionState } from './session.service';
+export type { StreamingResponse, TerminalConnectOptions } from './terminal.service';