@myrialabs/clopen 0.0.1

package/backend/ws/snapshot/restore.ts

@@ -0,0 +1,173 @@
+/**
+ * Snapshot Restore Handler (Unified - replaces undo.ts and redo.ts)
+ *
+ * Single restore operation that moves HEAD to any checkpoint.
+ * Works identically regardless of whether the target is on the
+ * current path, a branch, or an orphaned node.
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { messageQueries, sessionQueries, projectQueries, snapshotQueries, checkpointQueries } from '../../lib/database/queries';
+import { snapshotService } from '../../lib/snapshot/snapshot-service';
+import { debug } from '$shared/utils/logger';
+import {
+	buildCheckpointTree,
+	getCheckpointPathToRoot,
+	findSessionEnd
+} from '../../lib/snapshot/helpers';
+import { ws } from '$backend/lib/utils/ws';
+
+export const restoreHandler = createRouter()
+	.http('snapshot:restore', {
+		data: t.Object({
+			messageId: t.String(),
+			sessionId: t.String()
+		}),
+		response: t.Object({
+			restoredTo: t.Object({
+				messageId: t.String(),
+				timestamp: t.String()
+			}),
+			filesRestored: t.Optional(t.Number())
+		})
+	}, async ({ data, conn }) => {
+		const { messageId, sessionId } = data;
+
+		debug.log('snapshot', 'RESTORE - Moving HEAD to checkpoint');
+		debug.log('snapshot', `Target checkpoint: ${messageId}`);
+		debug.log('snapshot', `Session: ${sessionId}`);
+
+		// 1. Get the checkpoint message
+		const checkpointMessage = messageQueries.getById(messageId);
+		if (!checkpointMessage) {
+			throw new Error('Checkpoint message not found');
+		}
+
+		// 2. Get current HEAD
+		const currentHead = sessionQueries.getHead(sessionId);
+		debug.log('snapshot', `Current HEAD: ${currentHead}`);
+
+		// 3. Get all messages and build checkpoint tree
+		const allMessages = messageQueries.getAllBySessionId(sessionId);
+		const { parentMap } = buildCheckpointTree(allMessages);
+
+		// 4. Find session end (last message of checkpoint's session)
+		const sessionEnd = findSessionEnd(checkpointMessage, allMessages);
+		const isSameAsCheckpoint = sessionEnd.id === messageId;
+		debug.log('snapshot', `Session end: ${sessionEnd.id} (checkpoint: ${messageId}, sameAsCheckpoint: ${isSameAsCheckpoint})`);
+
+		if (isSameAsCheckpoint) {
+			debug.warn('snapshot', '⚠️ Session end is the SAME as checkpoint message! This means no assistant children were found.');
+			debug.warn('snapshot', `Checkpoint parent_message_id: ${checkpointMessage.parent_message_id}`);
+			// List all direct children of this checkpoint to debug
+			const directChildren = allMessages.filter(m => m.parent_message_id === messageId);
+			debug.warn('snapshot', `Direct children of checkpoint: ${directChildren.length}`);
+			for (const child of directChildren) {
+				try {
+					const sdk = JSON.parse(child.sdk_message);
+					debug.warn('snapshot', `  child=${child.id.slice(0, 8)} type=${sdk.type} ts=${child.timestamp}`);
+				} catch {
+					debug.warn('snapshot', `  child=${child.id.slice(0, 8)} (parse error)`);
+				}
+			}
+		}
+
+		// If session end is already HEAD, nothing to do (but still restore files)
+		if (sessionEnd.id === currentHead) {
+			debug.log('snapshot', 'Already at this checkpoint HEAD');
+		}
+
+		// 5. Update HEAD to session end
+		sessionQueries.updateHead(sessionId, sessionEnd.id);
+		debug.log('snapshot', `HEAD updated to: ${sessionEnd.id}`);
+
+		// 5b. Update latest_sdk_session_id so resume works correctly
+		// Walk backward from sessionEnd to find the last assistant message with session_id
+		{
+			let walkId: string | null = sessionEnd.id;
+			let foundSdkSessionId: string | null = null;
+			const msgLookup = new Map(allMessages.map(m => [m.id, m]));
+
+			while (walkId) {
+				const walkMsg = msgLookup.get(walkId);
+				if (!walkMsg) break;
+
+				try {
+					const sdk = JSON.parse(walkMsg.sdk_message);
+					if (sdk.session_id) {
+						foundSdkSessionId = sdk.session_id;
+						break;
+					}
+				} catch { /* skip */ }
+
+				walkId = walkMsg.parent_message_id || null;
+			}
+
+			if (foundSdkSessionId) {
+				sessionQueries.updateLatestSdkSessionId(sessionId, foundSdkSessionId);
+				debug.log('snapshot', `latest_sdk_session_id updated to: ${foundSdkSessionId}`);
+			} else {
+				debug.warn('snapshot', 'Could not find SDK session_id for resume - resume may not work correctly');
+			}
+		}
+
+		// 6. Update checkpoint_tree_state for ancestors
+		const checkpointPath = getCheckpointPathToRoot(messageId, parentMap);
+		if (checkpointPath.length > 1) {
+			checkpointQueries.updateActiveChildrenAlongPath(sessionId, checkpointPath);
+		}
+
+		// 7. Restore file system state from snapshot
+		// Walk backward from session end to checkpoint to find the best (most recent) snapshot
+		let filesRestored = 0;
+		const msgMap = new Map(allMessages.map(m => [m.id, m]));
+
+		let snapshot = null;
+		let walkId: string | null = sessionEnd.id;
+		while (walkId) {
+			const s = snapshotQueries.getByMessageId(walkId);
+			if (s) {
+				snapshot = s;
+				break;
+			}
+			// Don't walk past the checkpoint message
+			if (walkId === messageId) break;
+			const walkMsg = msgMap.get(walkId);
+			if (!walkMsg) break;
+			walkId = walkMsg.parent_message_id || null;
+		}
+
+		debug.log('snapshot', `Snapshot found: ${snapshot ? `${snapshot.id} (for message ${snapshot.message_id})` : 'none'}`);
+
+		if (snapshot) {
+			const session = sessionQueries.getById(sessionId);
+			if (session) {
+				const project = projectQueries.getById(session.project_id);
+				if (project) {
+					await snapshotService.restoreSnapshot(project.path, snapshot);
+					debug.log('snapshot', 'Files restored from snapshot');
+					filesRestored = 1;
+				}
+			}
+		}
+
+		// 8. Broadcast messages-changed to users in the chat session
+		try {
+			ws.emit.chatSession(sessionId, 'chat:messages-changed', {
+				sessionId,
+				reason: 'restore',
+				timestamp: new Date().toISOString()
+			});
+		} catch (err) {
+			debug.error('snapshot', 'Failed to broadcast messages-changed:', err);
+		}
+
+		return {
+			restoredTo: {
+				messageId: sessionEnd.id,
+				timestamp: sessionEnd.timestamp
+			},
+			filesRestored
+		};
+	});

package/backend/ws/snapshot/timeline.ts

@@ -0,0 +1,141 @@
+/**
+ * Snapshot Timeline WebSocket Handler (Rewritten)
+ *
+ * Builds timeline from parent_message_id tree structure.
+ * No longer depends on branch_id markers.
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { messageQueries, sessionQueries, checkpointQueries, snapshotQueries } from '../../lib/database/queries';
+import { debug } from '$shared/utils/logger';
+import {
+	extractMessageText,
+	buildCheckpointTree,
+	getCheckpointPathToRoot,
+	findCheckpointForHead,
+	isDescendant,
+	getCheckpointFileStats
+} from '../../lib/snapshot/helpers';
+import type { CheckpointNode, TimelineResponse } from '../../lib/snapshot/helpers';
+import type { SDKMessage } from '$shared/types/messaging';
+
+export const timelineHandler = createRouter()
+	.http('snapshot:get-timeline', {
+		data: t.Object({
+			sessionId: t.String()
+		}),
+		response: t.Object({
+			nodes: t.Array(t.Any()),
+			currentHeadId: t.Union([t.String(), t.Null()])
+		})
+	}, async ({ data }) => {
+		const { sessionId } = data;
+
+		debug.log('snapshot', 'TIMELINE - Building tree view');
+
+		// 1. Get current HEAD
+		const currentHead = sessionQueries.getHead(sessionId);
+		debug.log('snapshot', `Current HEAD: ${currentHead || 'null'}`);
+
+		if (!currentHead) {
+			return { nodes: [], currentHeadId: null };
+		}
+
+		// 2. Get all messages
+		const allMessages = messageQueries.getAllBySessionId(sessionId);
+		debug.log('snapshot', `Total messages: ${allMessages.length}`);
+
+		if (allMessages.length === 0) {
+			return { nodes: [], currentHeadId: null };
+		}
+
+		// 3. Build checkpoint tree
+		const { checkpoints, parentMap, childrenMap } = buildCheckpointTree(allMessages);
+		debug.log('snapshot', `Checkpoints found: ${checkpoints.length}`);
+
+		if (checkpoints.length === 0) {
+			return { nodes: [], currentHeadId: null };
+		}
+
+		const checkpointIdSet = new Set(checkpoints.map(c => c.id));
+
+		// 4. Find which checkpoint HEAD belongs to
+		const activeCheckpointId = findCheckpointForHead(currentHead, allMessages, checkpointIdSet);
+		debug.log('snapshot', `Active checkpoint: ${activeCheckpointId}`);
+
+		// 5. Build active path (from root to active checkpoint)
+		const activePathIds = new Set<string>();
+		if (activeCheckpointId) {
+			const activePath = getCheckpointPathToRoot(activeCheckpointId, parentMap);
+			for (const id of activePath) {
+				activePathIds.add(id);
+			}
+		}
+
+		// 6. Get active children map from database
+		const activeChildrenMap = checkpointQueries.getAllActiveChildren(sessionId);
+
+		// 7. Sort checkpoints by timestamp for file stats calculation
+		const sortedCheckpoints = [...checkpoints].sort(
+			(a, b) => a.timestamp.localeCompare(b.timestamp)
+		);
+
+		// Build next-checkpoint timestamp map for stats
+		const nextTimestampMap = new Map<string, string>();
+		for (let i = 0; i < sortedCheckpoints.length; i++) {
+			const next = sortedCheckpoints[i + 1];
+			if (next) {
+				nextTimestampMap.set(sortedCheckpoints[i].id, next.timestamp);
+			}
+		}
+
+		// 8. Build response nodes
+		const nodes: CheckpointNode[] = [];
+
+		for (const cp of checkpoints) {
+			const sdk = JSON.parse(cp.sdk_message) as SDKMessage;
+			const messageText = extractMessageText(sdk).trim().slice(0, 100);
+			const parentCpId = parentMap.get(cp.id) || null;
+			const activeChildId = activeChildrenMap.get(cp.id) || null;
+			const isOnActivePath = activePathIds.has(cp.id);
+			const isCurrent = cp.id === activeCheckpointId;
+
+			// Orphaned = descendant of active checkpoint in the checkpoint tree
+			let isOrphaned = false;
+			if (activeCheckpointId && !isOnActivePath) {
+				isOrphaned = isDescendant(cp.id, activeCheckpointId, childrenMap);
+			}
+
+			// File stats
+			const nextTimestamp = nextTimestampMap.get(cp.id);
+			const stats = getCheckpointFileStats(cp, allMessages, nextTimestamp);
+
+			const snapshot = snapshotQueries.getByMessageId(cp.id);
+
+			nodes.push({
+				id: cp.id,
+				messageId: cp.id,
+				parentId: parentCpId,
+				activeChildId,
+				timestamp: cp.timestamp,
+				messageText,
+				isOnActivePath,
+				isOrphaned,
+				isCurrent,
+				hasSnapshot: !!snapshot,
+				senderName: cp.sender_name,
+				filesChanged: stats.filesChanged,
+				insertions: stats.insertions,
+				deletions: stats.deletions
+			});
+		}
+
+		debug.log('snapshot', `Timeline nodes: ${nodes.length}`);
+		debug.log('snapshot', `Active path: ${activePathIds.size} nodes`);
+
+		return {
+			nodes,
+			currentHeadId: activeCheckpointId
+		};
+	});

package/backend/ws/system/index.ts

@@ -0,0 +1,14 @@
+/**
+ * System Router
+ *
+ * Combines all system WebSocket handlers into a single router.
+ *
+ * Structure:
+ * - operations.ts: HTTP endpoints for system operations (clear-data)
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+import { operationsHandler } from './operations';
+
+export const systemRouter = createRouter()
+	.merge(operationsHandler);

package/backend/ws/system/operations.ts

@@ -0,0 +1,49 @@
+/**
+ * System Operations
+ *
+ * HTTP endpoints for system-level operations:
+ * - Clear all database data
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { initializeDatabase, getDatabase } from '../../lib/database';
+import { debug } from '$shared/utils/logger';
+
+export const operationsHandler = createRouter()
+	// Clear all database data
+	.http('system:clear-data', {
+		data: t.Object({}),
+		response: t.Object({
+			cleared: t.Boolean(),
+			tablesCount: t.Number()
+		})
+	}, async () => {
+		debug.log('server', 'Clearing all database data...');
+
+		// Initialize database first to ensure it exists
+		await initializeDatabase();
+
+		// Get database connection
+		const db = getDatabase();
+
+		// Get all table names
+		const tables = db.prepare(`
+			SELECT name FROM sqlite_master
+			WHERE type='table'
+			AND name NOT LIKE 'sqlite_%'
+		`).all() as { name: string }[];
+
+		// Delete all data from each table
+		for (const table of tables) {
+			db.prepare(`DELETE FROM ${table.name}`).run();
+			debug.log('server', `Cleared table: ${table.name}`);
+		}
+
+		debug.log('server', 'Database cleared successfully');
+
+		return {
+			cleared: true,
+			tablesCount: tables.length
+		};
+	});

package/backend/ws/terminal/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Terminal Router
+ *
+ * Combines all terminal WebSocket handlers into a single router.
+ * Replaces SSE-based terminal streaming with WebSocket bi-directional communication.
+ *
+ * Structure:
+ * - session.ts: HTTP endpoints for session management (create, resize, kill, cancel, check-shell, pty-status)
+ * - stream.ts: Real-time events for terminal I/O (input, output, exit, directory, ready)
+ * - persistence.ts: Stream persistence and reconnection (stream-status, missed-output, reconnect)
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { sessionHandler } from './session';
+import { streamHandler } from './stream';
+import { persistenceHandler } from './persistence';
+
+export const terminalRouter = createRouter()
+	// Session Management (HTTP)
+	.merge(sessionHandler)
+
+	// Stream Events (Real-time I/O)
+	.merge(streamHandler)
+
+	// Stream Persistence (HTTP + Events)
+	.merge(persistenceHandler)
+
+	// Collaborative broadcast events (Server → Client)
+	.emit('terminal:tab-created', t.Object({
+		sessionId: t.String(),
+		streamId: t.String(),
+		pid: t.Number(),
+		currentDirectory: t.String(),
+		cols: t.Number(),
+		rows: t.Number()
+	}))
+	.emit('terminal:tab-closed', t.Object({
+		sessionId: t.String()
+	}));

package/backend/ws/terminal/persistence.ts

@@ -0,0 +1,153 @@
+/**
+ * Terminal Stream Persistence
+ *
+ * Handles terminal stream persistence and reconnection:
+ * - Get stream status
+ * - Retrieve missed output
+ * - Reconnect to existing streams
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { terminalStreamManager } from '../../lib/terminal/stream-manager';
+import { debug } from '$shared/utils/logger';
+import { ws } from '$backend/lib/utils/ws';
+import { ptySessionManager } from '../../lib/terminal/pty-session-manager';
+
+export const persistenceHandler = createRouter()
+	// Get stream status
+	.http('terminal:stream-status', {
+		data: t.Object({
+			streamId: t.String()
+		}),
+		response: t.Any()
+	}, async ({ data }) => {
+		const { streamId } = data;
+
+		const status = terminalStreamManager.getStreamStatus(streamId);
+
+		if (!status) {
+			throw new Error('Stream not found');
+		}
+
+		return status;
+	})
+
+	// Get missed output
+	.http('terminal:missed-output', {
+		data: t.Object({
+			sessionId: t.String(),
+			streamId: t.Optional(t.String()),
+			fromIndex: t.Optional(t.Number())
+		}),
+		response: t.Object({
+			sessionId: t.String(),
+			streamId: t.Union([t.String(), t.Null()]),
+			output: t.Array(t.String()),
+			outputCount: t.Number(),
+			status: t.String(),
+			fromIndex: t.Number(),
+			timestamp: t.String()
+		})
+	}, async ({ data }) => {
+		const { sessionId, streamId, fromIndex = 0 } = data;
+
+		// Try to get output from stream manager (memory or cache)
+		let output: string[] = [];
+
+		if (streamId) {
+			// If streamId is provided, get output from that specific stream
+			output = terminalStreamManager.getOutput(streamId, fromIndex);
+		} else {
+			// Otherwise try to load cached output for the session
+			const cachedOutput = terminalStreamManager.loadCachedOutput(sessionId);
+			if (cachedOutput) {
+				output = cachedOutput.slice(fromIndex);
+			}
+		}
+
+		// Get stream status if available
+		const streamStatus = streamId ? terminalStreamManager.getStreamStatus(streamId) : null;
+
+		return {
+			sessionId,
+			streamId: streamId || null,
+			output,
+			outputCount: output.length,
+			status: streamStatus?.status || 'unknown',
+			fromIndex,
+			timestamp: new Date().toISOString()
+		};
+	})
+
+	// Reconnect to stream
+	.on('terminal:reconnect', {
+		data: t.Object({
+			streamId: t.String(),
+			sessionId: t.String(),
+			fromIndex: t.Optional(t.Number())
+		})
+	}, async ({ data, conn }) => {
+		const { streamId, sessionId, fromIndex = 0 } = data;
+		const projectId = ws.getProjectId(conn);
+
+		const stream = terminalStreamManager.getStream(streamId);
+
+		if (!stream) {
+			ws.emit.project(projectId, 'terminal:error', {
+				sessionId,
+				error: 'Stream not found'
+			});
+			return;
+		}
+
+		try {
+			// Broadcast missed output (frontend filters by sessionId for one-time replay)
+			const existingOutput = terminalStreamManager.getOutput(streamId, fromIndex);
+
+			if (existingOutput.length > 0) {
+				for (const output of existingOutput) {
+					ws.emit.project(projectId, 'terminal:output', {
+						sessionId,
+						content: output,
+						timestamp: new Date().toISOString()
+					});
+				}
+			}
+
+			if (stream.status === 'active') {
+				// If no dataListeners exist yet (create-session hasn't been called),
+				// set up a project-broadcast listener so ongoing output reaches all clients.
+				// This listener will be replaced when terminal:create-session is called later.
+				const ptySession = ptySessionManager.getSession(sessionId);
+				if (ptySession && ptySession.dataListeners.size === 0) {
+					debug.log('terminal', `📡 Reconnect: No dataListeners, setting up broadcast listener for session: ${sessionId}`);
+
+					const broadcastListener = (output: string) => {
+						const currentSeq = ptySessionManager.getSession(sessionId)?.outputSeq || 0;
+						ws.emit.project(projectId, 'terminal:output', {
+							sessionId,
+							content: output,
+							seq: currentSeq,
+							projectId,
+							timestamp: new Date().toISOString()
+						});
+					};
+					ptySession.dataListeners.add(broadcastListener);
+				}
+				// No polling needed - dataListener handles ongoing output via ws.emit.project()
+			} else {
+				// Stream is not active, broadcast exit event (frontend filters by sessionId)
+				ws.emit.project(projectId, 'terminal:exit', {
+					sessionId,
+					exitCode: 0
+				});
+			}
+		} catch (error) {
+			debug.error('terminal', 'Error in stream reconnect:', error);
+			ws.emit.project(projectId, 'terminal:error', {
+				sessionId,
+				error: error instanceof Error ? error.message : 'Unknown error'
+			});
+		}
+	})