@myrialabs/clopen 0.0.1

package/backend/ws/projects/status.ts

@@ -0,0 +1,116 @@
+/**
+ * Projects Status & Presence
+ *
+ * Real-time presence tracking:
+ * - projects:get-status  (HTTP) - Get project status
+ * - projects:join        (Event) - User joins a project
+ * - projects:leave       (Event) - User leaves a project
+ * - projects:presence-updated (Broadcast) - Full presence state
+ *
+ * Single broadcast event: `projects:presence-updated` contains full state.
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { getProjectStatusData, updateUserPresence } from '../../lib/project/status-manager';
+import { streamManager } from '../../lib/chat/stream-manager';
+import { ws } from '$backend/lib/utils/ws';
+import { debug } from '$shared/utils/logger';
+
+/**
+ * Broadcast full presence state of all projects to all connected clients
+ */
+export async function broadcastPresence() {
+	const statuses = await getProjectStatusData();
+	ws.emit.global('projects:presence-updated', {
+		type: 'presence-updated',
+		timestamp: Date.now(),
+		data: statuses
+	});
+}
+
+export const statusHandler = createRouter()
+	// Get project status (HTTP)
+	.http('projects:get-status', {
+		data: t.Object({}),
+		response: t.Any()
+	}, async ({ conn }) => {
+		const projectId = ws.getProjectId(conn);
+		return await getProjectStatusData(projectId);
+	})
+
+	// User joins a project
+	.on('projects:join', {
+		data: t.Object({
+			userName: t.Optional(t.String())
+		})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const userId = ws.getUserId(conn);
+
+		try {
+			// Send initial presence for ALL projects
+			const allStatuses = await getProjectStatusData();
+			ws.emit.user(userId, 'projects:presence-updated', {
+				type: 'presence-updated',
+				timestamp: Date.now(),
+				data: allStatuses
+			});
+
+			if (data.userName) {
+				updateUserPresence(projectId, userId, data.userName, 'join');
+
+				try {
+					streamManager.cleanupProjectStreams(projectId);
+				} catch (cleanupError) {
+					debug.error('project', 'Error cleaning up project streams:', cleanupError);
+				}
+
+				// Auto-cleanup on connection close (tab close, network drop)
+				ws.addCleanup(conn, () => {
+					updateUserPresence(projectId, userId, '', 'leave');
+					debug.log('project', `Auto-cleaned presence for ${userId} from project ${projectId}`);
+					broadcastPresence().catch(() => {});
+				});
+
+				await broadcastPresence();
+			}
+
+			debug.log('project', `User ${userId} joined project ${projectId}`);
+		} catch (error) {
+			debug.error('project', 'Error joining project:', error);
+			ws.emit.user(userId, 'projects:error', {
+				error: error instanceof Error ? error.message : 'Failed to join project'
+			});
+		}
+	})
+
+	// User leaves a project
+	.on('projects:leave', {
+		data: t.Object({
+			projectId: t.Optional(t.String())
+		})
+	}, async ({ data, conn }) => {
+		// Use explicit projectId from client (avoids race condition when switching projects)
+		const projectId = data.projectId || ws.getProjectId(conn);
+		const userId = ws.getUserId(conn);
+
+		try {
+			updateUserPresence(projectId, userId, '', 'leave');
+			await broadcastPresence();
+			debug.log('project', `User ${userId} left project ${projectId}`);
+		} catch (error) {
+			debug.error('project', 'Error leaving project:', error);
+		}
+	})
+
+	// Event declarations
+	.emit('projects:presence-updated', t.Object({
+		type: t.Literal('presence-updated'),
+		timestamp: t.Number(),
+		data: t.Any()
+	}))
+
+	.emit('projects:error', t.Object({
+		error: t.String()
+	}));

package/backend/ws/sessions/crud.ts

@@ -0,0 +1,327 @@
+/**
+ * Sessions CRUD Operations
+ *
+ * HTTP endpoints for session management:
+ * - List sessions (all or by project)
+ * - Create new session
+ * - Get session by ID (with messages)
+ * - Get or create shared session
+ * - Update session (title, reactivate, end)
+ * - Delete session
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import type { EngineType } from '$shared/types/engine';
+import { sessionQueries, messageQueries, projectQueries } from '../../lib/database/queries';
+import { ws } from '$backend/lib/utils/ws';
+import { debug } from '$shared/utils/logger';
+
+export const crudHandler = createRouter()
+	// List sessions (includes server-saved current session ID for refresh restore)
+	.http('sessions:list', {
+		data: t.Object({}),
+		response: t.Object({
+			sessions: t.Array(t.Object({
+				id: t.String(),
+				project_id: t.String(),
+				title: t.Optional(t.String()),
+				engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+				model: t.Optional(t.String()),
+				latest_sdk_session_id: t.Optional(t.String()),
+				current_head_message_id: t.Optional(t.String()),
+				started_at: t.String(),
+				ended_at: t.Optional(t.String())
+			})),
+			currentSessionId: t.Optional(t.String())
+		})
+	}, async ({ conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const userId = ws.getUserId(conn);
+		const sessions = sessionQueries.getByProjectId(projectId);
+
+		// Get the user's saved current session for this project
+		const currentSessionId = projectQueries.getCurrentSessionId(userId, projectId);
+
+		// Convert null to undefined for TypeScript optional fields
+		return {
+			sessions: sessions.map(session => ({
+				...session,
+				title: session.title ?? undefined,
+				engine: session.engine ?? 'claude-code',
+				model: session.model ?? undefined,
+				latest_sdk_session_id: session.latest_sdk_session_id ?? undefined,
+				current_head_message_id: session.current_head_message_id ?? undefined,
+				ended_at: session.ended_at ?? undefined
+			})),
+			currentSessionId: currentSessionId ?? undefined
+		};
+	})
+
+	// List active (non-ended) sessions for current project
+	.http('sessions:list-active', {
+		data: t.Object({}),
+		response: t.Array(t.Object({
+			id: t.String(),
+			project_id: t.String(),
+			title: t.Optional(t.String()),
+			engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+			model: t.Optional(t.String()),
+			latest_sdk_session_id: t.Optional(t.String()),
+			current_head_message_id: t.Optional(t.String()),
+			started_at: t.String(),
+			ended_at: t.Optional(t.String())
+		}))
+	}, async ({ conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const sessions = sessionQueries.getActiveSessionsForProject(projectId);
+
+		return sessions.map(session => ({
+			...session,
+			title: session.title ?? undefined,
+			engine: session.engine ?? 'claude-code',
+			model: session.model ?? undefined,
+			latest_sdk_session_id: session.latest_sdk_session_id ?? undefined,
+			current_head_message_id: session.current_head_message_id ?? undefined,
+			ended_at: session.ended_at ?? undefined
+		}));
+	})
+
+	// Create new session
+	.http('sessions:create', {
+		data: t.Object({
+			title: t.Optional(t.String()),
+			engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')]))
+		}),
+		response: t.Object({
+			id: t.String(),
+			project_id: t.String(),
+			title: t.Optional(t.String()),
+			engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+			model: t.Optional(t.String()),
+			latest_sdk_session_id: t.Optional(t.String()),
+			current_head_message_id: t.Optional(t.String()),
+			started_at: t.String(),
+			ended_at: t.Optional(t.String())
+		})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const now = new Date().toISOString();
+		const engine: EngineType = data.engine ?? 'claude-code';
+		const session = sessionQueries.create({
+			project_id: projectId,
+			title: data.title || 'New Chat Session',
+			engine,
+			started_at: now
+		});
+
+		// Convert null to undefined for TypeScript optional fields
+		return {
+			...session,
+			title: session.title ?? undefined,
+			engine: session.engine ?? 'claude-code',
+			model: session.model ?? undefined,
+			latest_sdk_session_id: session.latest_sdk_session_id ?? undefined,
+			current_head_message_id: session.current_head_message_id ?? undefined,
+			ended_at: session.ended_at ?? undefined
+		};
+	})
+
+	// Get session by ID (with messages)
+	.http('sessions:get', {
+		data: t.Object({
+			id: t.String({ minLength: 1 })
+		}),
+		response: t.Object({
+			session: t.Object({
+				id: t.String(),
+				project_id: t.String(),
+				title: t.Optional(t.String()),
+				engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+				model: t.Optional(t.String()),
+				latest_sdk_session_id: t.Optional(t.String()),
+				current_head_message_id: t.Optional(t.String()),
+				started_at: t.String(),
+				ended_at: t.Optional(t.String())
+			}),
+			messages: t.Array(t.Any())
+		})
+	}, async ({ data }) => {
+		const session = sessionQueries.getById(data.id);
+
+		if (!session) {
+			throw new Error('Session not found');
+		}
+
+		// Also get messages for this session
+		const messages = messageQueries.getBySessionId(data.id);
+
+		// Convert null to undefined for TypeScript optional fields
+		return {
+			session: {
+				...session,
+				title: session.title ?? undefined,
+				engine: session.engine ?? undefined,
+				model: session.model ?? undefined,
+				latest_sdk_session_id: session.latest_sdk_session_id ?? undefined,
+				current_head_message_id: session.current_head_message_id ?? undefined,
+				ended_at: session.ended_at ?? undefined
+			},
+			messages
+		};
+	})
+
+	// Get or create shared session
+	.http('sessions:get-shared', {
+		data: t.Object({
+			forceNew: t.Optional(t.Boolean())
+		}),
+		response: t.Object({
+			id: t.String(),
+			project_id: t.String(),
+			title: t.Optional(t.String()),
+			engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+			model: t.Optional(t.String()),
+			latest_sdk_session_id: t.Optional(t.String()),
+			current_head_message_id: t.Optional(t.String()),
+			started_at: t.String(),
+			ended_at: t.Optional(t.String())
+		})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+
+		// Get project details
+		const project = projectQueries.getById(projectId);
+		if (!project) {
+			throw new Error('Project not found');
+		}
+
+		// Check if an active session already exists BEFORE get-or-create
+		const existingActiveSession = (data.forceNew) ? null : sessionQueries.getActiveSessionForProject(projectId);
+
+		// Get or create shared session
+		const session = sessionQueries.getOrCreateSharedSession(
+			projectId,
+			project.name,
+			data.forceNew || false
+		);
+
+		const sessionResponse = {
+			...session,
+			title: session.title ?? undefined,
+			engine: session.engine ?? 'claude-code',
+			model: session.model ?? undefined,
+			latest_sdk_session_id: session.latest_sdk_session_id ?? undefined,
+			current_head_message_id: session.current_head_message_id ?? undefined,
+			ended_at: session.ended_at ?? undefined
+		};
+
+		// Broadcast when a NEW session was actually created.
+		// Covers both forceNew=true and the case where no active session existed.
+		// Other users do NOT auto-switch — they see the session in the session picker.
+		const isNewlyCreated = !existingActiveSession || existingActiveSession.id !== session.id;
+		if (isNewlyCreated) {
+			debug.log('session', `Broadcasting new session available to project: ${projectId}`);
+			ws.emit.project(projectId, 'sessions:session-available', {
+				session: sessionResponse
+			});
+		}
+
+		return sessionResponse;
+	})
+
+	// Update session
+	.http('sessions:update', {
+		data: t.Object({
+			id: t.String({ minLength: 1 }),
+			title: t.Optional(t.String()),
+			reactivate: t.Optional(t.Boolean()),
+			end_session: t.Optional(t.Boolean())
+		}),
+		response: t.Object({
+			id: t.String(),
+			project_id: t.String(),
+			title: t.Optional(t.String()),
+			engine: t.Optional(t.Union([t.Literal('claude-code'), t.Literal('opencode')])),
+			model: t.Optional(t.String()),
+			latest_sdk_session_id: t.Optional(t.String()),
+			current_head_message_id: t.Optional(t.String()),
+			started_at: t.String(),
+			ended_at: t.Optional(t.String())
+		})
+	}, async ({ data }) => {
+		const session = sessionQueries.getById(data.id);
+		if (!session) {
+			throw new Error('Session not found');
+		}
+
+		// Update session title if provided
+		if (data.title) {
+			sessionQueries.updateTitle(data.id, data.title);
+		}
+
+		// Reactivate session if requested (clear ended_at and end other sessions in same project)
+		if (data.reactivate) {
+			sessionQueries.reactivate(data.id);
+		}
+
+		// End session if requested
+		if (data.end_session) {
+			sessionQueries.end(data.id);
+		}
+
+		const updatedSession = sessionQueries.getById(data.id)!;
+
+		// Convert null to undefined for TypeScript optional fields
+		return {
+			...updatedSession,
+			title: updatedSession.title ?? undefined,
+			engine: updatedSession.engine ?? 'claude-code',
+			model: updatedSession.model ?? undefined,
+			latest_sdk_session_id: updatedSession.latest_sdk_session_id ?? undefined,
+			current_head_message_id: updatedSession.current_head_message_id ?? undefined,
+			ended_at: updatedSession.ended_at ?? undefined
+		};
+	})
+
+	// Delete session
+	.http('sessions:delete', {
+		data: t.Object({
+			id: t.String({ minLength: 1 })
+		}),
+		response: t.Object({
+			message: t.String()
+		})
+	}, async ({ data, conn }) => {
+		const session = sessionQueries.getById(data.id);
+
+		if (!session) {
+			throw new Error('Session not found');
+		}
+
+		const projectId = session.project_id;
+		sessionQueries.delete(data.id);
+
+		// Broadcast to all project members so other users see the deletion
+		debug.log('session', `Broadcasting session deleted: ${data.id} in project: ${projectId}`);
+		ws.emit.project(projectId, 'sessions:session-deleted', {
+			sessionId: data.id,
+			projectId
+		});
+
+		return {
+			message: 'Session deleted successfully'
+		};
+	})
+
+	// Persist user's current session choice (for refresh restore)
+	.on('sessions:set-current', {
+		data: t.Object({
+			sessionId: t.String()
+		})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const userId = ws.getUserId(conn);
+		projectQueries.setCurrentSessionId(userId, projectId, data.sessionId);
+		debug.log('session', `User ${userId} set current session to ${data.sessionId} in project ${projectId}`);
+	});

package/backend/ws/sessions/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Sessions Router
+ *
+ * Combines all session WebSocket handlers into a single router.
+ *
+ * Structure:
+ * - crud.ts: HTTP endpoints for CRUD operations (list, create, get, get-shared, update, delete)
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { crudHandler } from './crud';
+
+export const sessionsRouter = createRouter()
+	.merge(crudHandler)
+	// Collaborative broadcast events (Server → Client)
+	// Notification: a new session is available (no auto-switch)
+	.emit('sessions:session-available', t.Object({
+		session: t.Object({
+			id: t.String(),
+			project_id: t.String(),
+			title: t.Optional(t.String()),
+			latest_sdk_session_id: t.Optional(t.String()),
+			current_head_message_id: t.Optional(t.String()),
+			started_at: t.String(),
+			ended_at: t.Optional(t.String())
+		})
+	}))
+	// Notification: a session was deleted by another user
+	.emit('sessions:session-deleted', t.Object({
+		sessionId: t.String(),
+		projectId: t.String()
+	}));

package/backend/ws/settings/crud.ts

@@ -0,0 +1,112 @@
+/**
+ * Settings CRUD Operations
+ *
+ * HTTP endpoints for settings management:
+ * - Get single setting or all settings
+ * - Update single setting
+ * - Batch update multiple settings
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { settingsQueries } from '../../lib/database/queries';
+import { initializeEngine } from '../../lib/engine';
+import { CLAUDE_CODE_MODELS, registerModels } from '$shared/constants/engines';
+import type { EngineType } from '$shared/types/engine';
+
+export const crudHandler = createRouter()
+	// Get settings
+	.http('settings:get', {
+		data: t.Object({
+			key: t.Optional(t.String())
+		}),
+		response: t.Any()
+	}, async ({ data }) => {
+		if (data.key) {
+			const setting = settingsQueries.get(data.key);
+			if (!setting) {
+				throw new Error('Setting not found');
+			}
+			return setting;
+		} else {
+			const settings = settingsQueries.getAll();
+			return settings;
+		}
+	})
+
+	// Update single setting
+	.http('settings:update', {
+		data: t.Object({
+			key: t.String({ minLength: 1 }),
+			value: t.Any()
+		}),
+		response: t.Any()
+	}, async ({ data }) => {
+		const { key, value } = data;
+
+		if (!key || value === undefined) {
+			throw new Error('Key and value are required');
+		}
+
+		settingsQueries.set(key, value);
+		const setting = settingsQueries.get(key);
+
+		return setting;
+	})
+
+	// Batch update multiple settings
+	.http('settings:update-batch', {
+		data: t.Object({
+			settings: t.Array(
+				t.Object({
+					key: t.String({ minLength: 1 }),
+					value: t.Any()
+				})
+			)
+		}),
+		response: t.Any()
+	}, async ({ data }) => {
+		for (const { key, value } of data.settings) {
+			if (key && value !== undefined) {
+				settingsQueries.set(key, value);
+			}
+		}
+
+		const settings = settingsQueries.getAll();
+		return settings;
+	})
+
+	// List available models for an engine
+	.http('models:list', {
+		data: t.Object({
+			engine: t.Union([t.Literal('claude-code'), t.Literal('opencode')])
+		}),
+		response: t.Array(t.Object({
+			id: t.String(),
+			engine: t.Union([t.Literal('claude-code'), t.Literal('opencode')]),
+			modelId: t.String(),
+			name: t.String(),
+			provider: t.String(),
+			description: t.String(),
+			capabilities: t.Array(t.String()),
+			contextWindow: t.Number(),
+			category: t.Union([t.Literal('latest'), t.Literal('stable'), t.Literal('legacy')]),
+			recommended: t.Optional(t.Boolean())
+		}))
+	}, async ({ data }) => {
+		const engineType: EngineType = data.engine;
+
+		// Claude Code models are static
+		if (engineType === 'claude-code') {
+			return CLAUDE_CODE_MODELS;
+		}
+
+		// Dynamic engines: initialize and fetch models
+		const engine = await initializeEngine(engineType);
+		const models = await engine.getAvailableModels();
+
+		// Register fetched models in the shared registry
+		registerModels(engineType, models);
+
+		return models;
+	});

package/backend/ws/settings/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Settings Router
+ *
+ * Combines all settings WebSocket handlers into a single router.
+ *
+ * Structure:
+ * - crud.ts: HTTP endpoints for CRUD operations (get, update, update-batch)
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+import { crudHandler } from './crud';
+
+export const settingsRouter = createRouter()
+	.merge(crudHandler);

package/backend/ws/snapshot/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Snapshot Router
+ *
+ * Combines all snapshot WebSocket handlers into a single router.
+ *
+ * Structure:
+ * - restore.ts: Unified restore operation (replaces undo + redo)
+ * - timeline.ts: Timeline visualization data
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+import { restoreHandler } from './restore';
+import { timelineHandler } from './timeline';
+
+export const snapshotRouter = createRouter()
+	.merge(restoreHandler)
+	.merge(timelineHandler);