@myrialabs/clopen 0.0.1

package/backend/ws/git/remote.ts

@@ -0,0 +1,214 @@
+/**
+ * Git Remote Handler
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { gitService } from '../../lib/git/git-service';
+import { projectQueries } from '../../lib/database/queries/project-queries';
+
+export const remoteHandler = createRouter()
+	.http('git:remotes', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Array(t.Object({
+			name: t.String(),
+			fetchUrl: t.String(),
+			pushUrl: t.String()
+		}))
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getRemotes(project.path);
+	})
+
+	.http('git:fetch', {
+		data: t.Object({
+			projectId: t.String(),
+			remote: t.Optional(t.String())
+		}),
+		response: t.Object({
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		const message = await gitService.fetch(project.path, data.remote);
+		return { message };
+	})
+
+	.http('git:pull', {
+		data: t.Object({
+			projectId: t.String(),
+			remote: t.Optional(t.String()),
+			branch: t.Optional(t.String())
+		}),
+		response: t.Object({
+			success: t.Boolean(),
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.pull(project.path, data.remote, data.branch);
+	})
+
+	.http('git:push', {
+		data: t.Object({
+			projectId: t.String(),
+			remote: t.Optional(t.String()),
+			branch: t.Optional(t.String()),
+			force: t.Optional(t.Boolean())
+		}),
+		response: t.Object({
+			success: t.Boolean(),
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.push(project.path, data.remote, data.branch, data.force);
+	})
+
+	.http('git:add-remote', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String(),
+			url: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.addRemote(project.path, data.name, data.url);
+		return { ok: true };
+	})
+
+	.http('git:remove-remote', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.removeRemote(project.path, data.name);
+		return { ok: true };
+	})
+
+	.http('git:stash-list', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Array(t.Object({
+			index: t.Number(),
+			message: t.String(),
+			date: t.String()
+		}))
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.stashList(project.path);
+	})
+
+	.http('git:stash-save', {
+		data: t.Object({
+			projectId: t.String(),
+			message: t.Optional(t.String())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.stashSave(project.path, data.message);
+		return { ok: true };
+	})
+
+	.http('git:stash-pop', {
+		data: t.Object({
+			projectId: t.String(),
+			index: t.Optional(t.Number())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.stashPop(project.path, data.index);
+		return { ok: true };
+	})
+
+	.http('git:stash-drop', {
+		data: t.Object({
+			projectId: t.String(),
+			index: t.Optional(t.Number())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.stashDrop(project.path, data.index);
+		return { ok: true };
+	})
+
+	.http('git:tags', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Array(t.Object({
+			name: t.String(),
+			hash: t.String(),
+			message: t.String(),
+			date: t.String(),
+			isAnnotated: t.Boolean()
+		}))
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getTags(project.path);
+	})
+
+	.http('git:create-tag', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String({ minLength: 1 }),
+			message: t.Optional(t.String()),
+			commitHash: t.Optional(t.String())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.createTag(project.path, data.name, data.message, data.commitHash);
+		return { ok: true };
+	})
+
+	.http('git:delete-tag', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.deleteTag(project.path, data.name);
+		return { ok: true };
+	})
+
+	.http('git:push-tag', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String(),
+			remote: t.Optional(t.String())
+		}),
+		response: t.Object({
+			success: t.Boolean(),
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.pushTag(project.path, data.name, data.remote);
+	});

package/backend/ws/git/staging.ts

@@ -0,0 +1,84 @@
+/**
+ * Git Staging Handler
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { gitService } from '../../lib/git/git-service';
+import { projectQueries } from '../../lib/database/queries/project-queries';
+
+export const stagingHandler = createRouter()
+	.http('git:stage', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.stageFile(project.path, data.filePath);
+		return { ok: true };
+	})
+
+	.http('git:stage-all', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.stageAll(project.path);
+		return { ok: true };
+	})
+
+	.http('git:unstage', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.unstageFile(project.path, data.filePath);
+		return { ok: true };
+	})
+
+	.http('git:unstage-all', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.unstageAll(project.path);
+		return { ok: true };
+	})
+
+	.http('git:discard', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.discardFile(project.path, data.filePath);
+		return { ok: true };
+	})
+
+	.http('git:discard-all', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.discardAll(project.path);
+		return { ok: true };
+	});

package/backend/ws/git/status.ts

@@ -0,0 +1,90 @@
+/**
+ * Git Status Handler
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { gitService } from '../../lib/git/git-service';
+import { projectQueries } from '../../lib/database/queries/project-queries';
+import { ws as wsServer } from '../../lib/utils/ws';
+
+export const statusHandler = createRouter()
+	.http('git:status', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({
+			isRepo: t.Boolean(),
+			staged: t.Array(t.Object({
+				path: t.String(),
+				indexStatus: t.String(),
+				workingStatus: t.String(),
+				oldPath: t.Optional(t.String())
+			})),
+			unstaged: t.Array(t.Object({
+				path: t.String(),
+				indexStatus: t.String(),
+				workingStatus: t.String(),
+				oldPath: t.Optional(t.String())
+			})),
+			untracked: t.Array(t.Object({
+				path: t.String(),
+				indexStatus: t.String(),
+				workingStatus: t.String(),
+				oldPath: t.Optional(t.String())
+			})),
+			conflicted: t.Array(t.Object({
+				path: t.String(),
+				indexStatus: t.String(),
+				workingStatus: t.String(),
+				oldPath: t.Optional(t.String())
+			}))
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+
+		const isRepo = await gitService.isRepo(project.path);
+		if (!isRepo) {
+			return {
+				isRepo: false,
+				staged: [],
+				unstaged: [],
+				untracked: [],
+				conflicted: []
+			};
+		}
+
+		const status = await gitService.getStatus(project.path);
+		return { isRepo: true, ...status };
+	})
+
+	.http('git:init', {
+		data: t.Object({
+			projectId: t.String(),
+			defaultBranch: t.Optional(t.String())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.init(project.path, data.defaultBranch);
+		return { ok: true };
+	})
+
+	.http('git:is-repo', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({
+			isRepo: t.Boolean(),
+			root: t.Optional(t.String())
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+
+		const isRepo = await gitService.isRepo(project.path);
+		const root = isRepo ? await gitService.getRoot(project.path) : undefined;
+		return { isRepo, root: root ?? undefined };
+	});

package/backend/ws/index.ts

@@ -0,0 +1,69 @@
+/**
+ * WebSocket Main Router
+ *
+ * This is the main entry point for all WebSocket routes.
+ * All module routers are imported from their respective folders and merged here.
+ *
+ * Structure follows backend/routes pattern:
+ * - Each feature group has its own folder (demo/, chat/, terminal/, etc.)
+ * - Each folder contains handlers and an index.ts that exports the router
+ * - This file imports and merges all routers into a single API type
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+
+// Import all module routers
+import { chatRouter } from './chat';
+import { terminalRouter } from './terminal';
+import { previewRouter } from './preview';
+import { snapshotRouter } from './snapshot';
+import { projectsRouter } from './projects';
+import { sessionsRouter } from './sessions';
+import { messagesRouter } from './messages';
+import { settingsRouter } from './settings';
+import { userRouter } from './user';
+import { filesRouter } from './files';
+import { systemRouter } from './system';
+import { tunnelRouter } from './tunnel';
+import { gitRouter } from './git';
+import { mcpRouter } from './mcp';
+import { engineRouter } from './engine';
+
+// ============================================
+// Main App Router - Merge All Module Routers
+// ============================================
+
+export const wsRouter = createRouter()
+	// Terminal System
+	.merge(terminalRouter)
+
+	// Preview
+	.merge(previewRouter)
+
+	// Chat System
+	.merge(chatRouter)
+
+	// Snapshot System
+	.merge(snapshotRouter)
+
+	// CRUD Operations
+	.merge(projectsRouter)
+	.merge(sessionsRouter)
+	.merge(messagesRouter)
+	.merge(settingsRouter)
+	.merge(userRouter)
+	.merge(filesRouter)
+	.merge(systemRouter)
+	.merge(tunnelRouter)
+
+	// Git Source Control
+	.merge(gitRouter)
+
+	// MCP (bridge for Open Code stdio server)
+	.merge(mcpRouter)
+
+	// AI Engine Management
+	.merge(engineRouter);
+
+// Export API type for frontend type-safe access
+export type WSAPI = typeof wsRouter['$api'];

package/backend/ws/mcp/index.ts

@@ -0,0 +1,61 @@
+/**
+ * MCP Bridge — WebSocket HTTP-like route for the stdio MCP server
+ *
+ * Provides a WS route that the MCP stdio server (spawned by Open Code)
+ * uses to execute tool handlers in-process.
+ *
+ * Handlers are loaded from the SAME serverMetadata registry —
+ * no duplication of tool names or handler imports.
+ *
+ * Route: mcp:execute (WS http-like request-response)
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+import { t } from 'elysia';
+import { debug } from '$shared/utils/logger';
+import { serverMetadata } from '../../lib/mcp/servers/index';
+import { mcpServers } from '../../lib/mcp/config';
+
+export const mcpRouter = createRouter()
+	.http('mcp:execute', {
+		data: t.Object({
+			server: t.String(),
+			tool: t.String(),
+			args: t.Record(t.String(), t.Unknown()),
+		}),
+		response: t.Any(),
+	}, async ({ data }) => {
+		const { server, tool, args } = data;
+
+		debug.log('mcp', `🌉 Bridge: ${server}/${tool}`);
+
+		// Validate server exists and is enabled
+		const serverConfig = mcpServers[server];
+		if (!serverConfig?.enabled) {
+			return {
+				content: [{ type: 'text', text: `Unknown or disabled MCP server: ${server}` }],
+				isError: true,
+			};
+		}
+
+		// Get handler from the single-source metadata registry
+		const meta = (serverMetadata as Record<string, { toolDefs: Record<string, { handler: (args: any) => Promise<any> }> }>)[server];
+		const toolDef = meta?.toolDefs[tool];
+		if (!toolDef) {
+			return {
+				content: [{ type: 'text', text: `Unknown tool: ${tool} in server ${server}` }],
+				isError: true,
+			};
+		}
+
+		try {
+			return await toolDef.handler(args);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+			debug.error('mcp', `🌉 Bridge error: ${server}/${tool}: ${errorMessage}`);
+			return {
+				content: [{ type: 'text', text: `Tool execution error: ${errorMessage}` }],
+				isError: true,
+			};
+		}
+	});

package/backend/ws/messages/crud.ts

@@ -0,0 +1,74 @@
+/**
+ * Messages CRUD Operations
+ *
+ * HTTP endpoints for message management:
+ * - List messages (with optional include_all for history view)
+ * - Get message by ID
+ * - Delete message
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { messageQueries } from '../../lib/database/queries';
+import { formatDatabaseMessage } from '$shared/utils/message-formatter';
+
+export const crudHandler = createRouter()
+	// List messages
+	.http('messages:list', {
+		data: t.Object({
+			session_id: t.String({ minLength: 1 }),
+			include_all: t.Optional(t.Boolean())
+		}),
+		response: t.Array(t.Any())
+	}, async ({ data }) => {
+		if (data.include_all) {
+			// Return all messages including those in other branches (for History view)
+			const allMessages = messageQueries.getAllBySessionId(data.session_id);
+			const messages = allMessages.map(msg => formatDatabaseMessage(msg));
+			return messages;
+		} else {
+			// Default: return only messages in current HEAD path (for Chat view)
+			const messages = messageQueries.getBySessionId(data.session_id);
+			return messages;
+		}
+	})
+
+	// Get message by ID
+	.http('messages:get', {
+		data: t.Object({
+			messageId: t.String({ minLength: 1 })
+		}),
+		response: t.Any()
+	}, async ({ data }) => {
+		const message = messageQueries.getById(data.messageId);
+
+		if (!message) {
+			throw new Error('Message not found');
+		}
+
+		// Parse SDK message and return with database metadata
+		return formatDatabaseMessage(message);
+	})
+
+	// Delete message
+	.http('messages:delete', {
+		data: t.Object({
+			messageId: t.String({ minLength: 1 })
+		}),
+		response: t.Object({
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		// Check if message exists first
+		const message = messageQueries.getById(data.messageId);
+		if (!message) {
+			throw new Error('Message not found');
+		}
+
+		// Delete the message
+		messageQueries.delete(data.messageId);
+
+		return {
+			message: 'Message deleted successfully'
+		};
+	});

package/backend/ws/messages/index.ts

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