@myrialabs/clopen 0.0.1

package/backend/ws/files/watch.ts

@@ -0,0 +1,124 @@
+/**
+ * File Watch Handlers
+ *
+ * Real-time file system watching:
+ * - Watch project directory for changes
+ * - Unwatch project directory
+ * - File change events
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { fileWatcher } from '$backend/lib/files/file-watcher';
+import { debug } from '$shared/utils/logger';
+import { ws } from '$backend/lib/utils/ws';
+
+export const watchHandler = createRouter()
+	// Start watching a project directory
+	.on('files:watch', {
+		data: t.Object({
+			projectPath: t.String({ minLength: 1 })
+		})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+		const { projectPath } = data;
+
+		try {
+			// Check if already watching
+			if (fileWatcher.isWatching(projectId)) {
+				// Already watching, broadcast confirmation (frontend filters by projectId)
+				ws.emit.project(projectId, 'files:watching', {
+					projectId,
+					watching: true,
+					timestamp: Date.now()
+				});
+				return;
+			}
+
+			// Start watching
+			const success = await fileWatcher.startWatching(projectId, projectPath);
+
+			if (success) {
+				// Broadcast confirmation (frontend filters by projectId)
+				ws.emit.project(projectId, 'files:watching', {
+					projectId,
+					watching: true,
+					timestamp: Date.now()
+				});
+
+				debug.log('file', `Started watching project ${projectId}`);
+			} else {
+				// Broadcast error (frontend filters by projectId)
+				ws.emit.project(projectId, 'files:watch-error', {
+					projectId,
+					error: 'Failed to start file watcher'
+				});
+			}
+		} catch (error) {
+			debug.error('file', 'Error starting file watch:', error);
+			ws.emit.project(projectId, 'files:watch-error', {
+				projectId,
+				error: error instanceof Error ? error.message : 'Unknown error'
+			});
+		}
+	})
+
+	// Stop watching a project directory
+	.on('files:unwatch', {
+		data: t.Object({})
+	}, async ({ data, conn }) => {
+		const projectId = ws.getProjectId(conn);
+
+		try {
+			const success = fileWatcher.stopWatching(projectId);
+
+			// Broadcast confirmation (frontend filters by projectId)
+			ws.emit.project(projectId, 'files:watching', {
+				projectId,
+				watching: false,
+				timestamp: Date.now()
+			});
+
+			if (success) {
+				debug.log('file', `Stopped watching project ${projectId}`);
+			}
+		} catch (error) {
+			debug.error('file', 'Error stopping file watch:', error);
+		}
+	})
+
+	// Event declarations for type safety
+
+	// Emitted when file watcher status changes
+	.emit('files:watching', t.Object({
+		projectId: t.String(),
+		watching: t.Boolean(),
+		timestamp: t.Number()
+	}))
+
+	// Emitted when files change
+	.emit('files:changed', t.Object({
+		projectId: t.String(),
+		changes: t.Array(t.Object({
+			path: t.String(),
+			type: t.Union([
+				t.Literal('created'),
+				t.Literal('modified'),
+				t.Literal('deleted')
+			]),
+			timestamp: t.String()
+		})),
+		timestamp: t.Number()
+	}))
+
+	// Emitted on watcher errors
+	.emit('files:watch-error', t.Object({
+		projectId: t.String(),
+		error: t.String()
+	}))
+
+	// Emitted when git state changes (external git operations)
+	.emit('git:changed', t.Object({
+		projectId: t.String(),
+		timestamp: t.Number()
+	}));

package/backend/ws/files/write.ts

@@ -0,0 +1,143 @@
+/**
+ * Files Write Operations
+ *
+ * HTTP endpoints for modifying files and directories:
+ * - Write file
+ * - Create file
+ * - Create directory
+ * - Rename file/directory
+ * - Duplicate file/directory
+ * - Upload file
+ * - Delete file/directory
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { debug } from '$shared/utils/logger';
+import {
+	writeFileOperation,
+	createFileOperation,
+	createDirectoryOperation,
+	renameOperation,
+	duplicateOperation,
+	uploadFileOperation,
+	deleteOperation
+} from '../../lib/files/file-operations';
+
+export const writeHandler = createRouter()
+	// Write file operation
+	.http('files:write-file', {
+		data: t.Object({
+			filePath: t.String(),
+			content: t.String()
+		}),
+		response: t.Object({
+			message: t.String(),
+			size: t.Number(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		debug.log('file', 'Write file operation:', {
+			filePath: data.filePath,
+			contentLength: data.content.length
+		});
+		return await writeFileOperation(data.filePath, data.content);
+	})
+
+	// Create file operation
+	.http('files:create-file', {
+		data: t.Object({
+			filePath: t.String(),
+			content: t.Optional(t.String())
+		}),
+		response: t.Object({
+			message: t.String(),
+			path: t.String(),
+			size: t.Number(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		return await createFileOperation(data.filePath, data.content);
+	})
+
+	// Create directory operation
+	.http('files:create-directory', {
+		data: t.Object({
+			dirPath: t.String()
+		}),
+		response: t.Object({
+			message: t.String(),
+			path: t.String(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		return await createDirectoryOperation(data.dirPath);
+	})
+
+	// Rename operation
+	.http('files:rename', {
+		data: t.Object({
+			oldPath: t.String(),
+			newPath: t.String()
+		}),
+		response: t.Object({
+			message: t.String(),
+			oldPath: t.String(),
+			newPath: t.String(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		return await renameOperation(data.oldPath, data.newPath);
+	})
+
+	// Duplicate operation
+	.http('files:duplicate', {
+		data: t.Object({
+			sourcePath: t.String(),
+			targetPath: t.String()
+		}),
+		response: t.Object({
+			message: t.String(),
+			sourcePath: t.String(),
+			targetPath: t.String(),
+			size: t.Number(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		return await duplicateOperation(data.sourcePath, data.targetPath);
+	})
+
+	// Upload file operation
+	.http('files:upload-file', {
+		data: t.Object({
+			targetPath: t.String(),
+			file: t.Object({
+				name: t.String(),
+				type: t.String(),
+				size: t.Number(),
+				data: t.Uint8Array()
+			})
+		}),
+		response: t.Object({
+			message: t.String(),
+			path: t.String(),
+			size: t.Number(),
+			modified: t.String()
+		})
+	}, async ({ data }) => {
+		return await uploadFileOperation(data.file, data.targetPath);
+	})
+
+	// Delete operation
+	.http('files:delete', {
+		data: t.Object({
+			filePath: t.String(),
+			force: t.Optional(t.Boolean())
+		}),
+		response: t.Object({
+			message: t.String(),
+			path: t.String()
+		})
+	}, async ({ data }) => {
+		return await deleteOperation(data.filePath, data.force);
+	});

package/backend/ws/git/branch.ts

@@ -0,0 +1,106 @@
+/**
+ * Git Branch 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';
+
+const BranchSchema = t.Object({
+	name: t.String(),
+	isCurrent: t.Boolean(),
+	isRemote: t.Boolean(),
+	upstream: t.Optional(t.String()),
+	ahead: t.Number(),
+	behind: t.Number(),
+	lastCommit: t.Optional(t.String())
+});
+
+export const branchHandler = createRouter()
+	.http('git:branches', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Object({
+			current: t.String(),
+			local: t.Array(BranchSchema),
+			remote: t.Array(BranchSchema),
+			ahead: t.Number(),
+			behind: t.Number()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getBranches(project.path);
+	})
+
+	.http('git:create-branch', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String({ minLength: 1 }),
+			startPoint: 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.createBranch(project.path, data.name, data.startPoint);
+		return { ok: true };
+	})
+
+	.http('git:switch-branch', {
+		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.switchBranch(project.path, data.name);
+		return { ok: true };
+	})
+
+	.http('git:delete-branch', {
+		data: t.Object({
+			projectId: t.String(),
+			name: t.String(),
+			force: t.Optional(t.Boolean())
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.deleteBranch(project.path, data.name, data.force);
+		return { ok: true };
+	})
+
+	.http('git:rename-branch', {
+		data: t.Object({
+			projectId: t.String(),
+			oldName: t.String(),
+			newName: t.String({ minLength: 1 })
+		}),
+		response: t.Object({ ok: t.Boolean() })
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		await gitService.renameBranch(project.path, data.oldName, data.newName);
+		return { ok: true };
+	})
+
+	.http('git:merge-branch', {
+		data: t.Object({
+			projectId: t.String(),
+			branchName: 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.mergeBranch(project.path, data.branchName);
+	});

package/backend/ws/git/commit.ts

@@ -0,0 +1,39 @@
+/**
+ * Git Commit 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 commitHandler = createRouter()
+	.http('git:commit', {
+		data: t.Object({
+			projectId: t.String(),
+			message: t.String({ minLength: 1 })
+		}),
+		response: t.Object({
+			hash: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		const hash = await gitService.commit(project.path, data.message);
+		return { hash };
+	})
+
+	.http('git:amend', {
+		data: t.Object({
+			projectId: t.String(),
+			message: t.Optional(t.String())
+		}),
+		response: t.Object({
+			hash: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		const hash = await gitService.amendCommit(project.path, data.message);
+		return { hash };
+	});

package/backend/ws/git/conflict.ts

@@ -0,0 +1,68 @@
+/**
+ * Git Conflict Resolution 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';
+
+const ConflictMarkerSchema = t.Object({
+	ourStart: t.Number(),
+	ourEnd: t.Number(),
+	theirStart: t.Number(),
+	theirEnd: t.Number(),
+	baseStart: t.Optional(t.Number()),
+	baseEnd: t.Optional(t.Number()),
+	ourContent: t.String(),
+	theirContent: t.String(),
+	baseContent: t.Optional(t.String())
+});
+
+export const conflictHandler = createRouter()
+	.http('git:conflict-files', {
+		data: t.Object({
+			projectId: t.String()
+		}),
+		response: t.Array(t.Object({
+			path: t.String(),
+			content: t.String(),
+			markers: t.Array(ConflictMarkerSchema)
+		}))
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getConflictFiles(project.path);
+	})
+
+	.http('git:resolve-conflict', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.String(),
+			resolution: t.Union([t.Literal('ours'), t.Literal('theirs'), t.Literal('custom')]),
+			customContent: 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.resolveConflict(
+			project.path,
+			data.filePath,
+			data.resolution,
+			data.customContent
+		);
+		return { ok: true };
+	})
+
+	.http('git:abort-merge', {
+		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.abortMerge(project.path);
+		return { ok: true };
+	});

package/backend/ws/git/diff.ts

@@ -0,0 +1,69 @@
+/**
+ * Git Diff 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';
+
+const DiffHunkLineSchema = t.Object({
+	type: t.Union([t.Literal('add'), t.Literal('delete'), t.Literal('context'), t.Literal('header')]),
+	content: t.String(),
+	oldLineNumber: t.Optional(t.Number()),
+	newLineNumber: t.Optional(t.Number())
+});
+
+const DiffHunkSchema = t.Object({
+	oldStart: t.Number(),
+	oldLines: t.Number(),
+	newStart: t.Number(),
+	newLines: t.Number(),
+	header: t.String(),
+	lines: t.Array(DiffHunkLineSchema)
+});
+
+const FileDiffSchema = t.Object({
+	oldPath: t.String(),
+	newPath: t.String(),
+	status: t.String(),
+	hunks: t.Array(DiffHunkSchema),
+	isBinary: t.Boolean()
+});
+
+export const diffHandler = createRouter()
+	.http('git:diff-unstaged', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.Optional(t.String())
+		}),
+		response: t.Array(FileDiffSchema)
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getDiffUnstaged(project.path, data.filePath);
+	})
+
+	.http('git:diff-staged', {
+		data: t.Object({
+			projectId: t.String(),
+			filePath: t.Optional(t.String())
+		}),
+		response: t.Array(FileDiffSchema)
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getDiffStaged(project.path, data.filePath);
+	})
+
+	.http('git:diff-commit', {
+		data: t.Object({
+			projectId: t.String(),
+			commitHash: t.String()
+		}),
+		response: t.Array(FileDiffSchema)
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getDiffCommit(project.path, data.commitHash);
+	});

package/backend/ws/git/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Git Router
+ * Combines all git WebSocket handlers into a single router.
+ */
+
+import { createRouter } from '$shared/utils/ws-server';
+import { statusHandler } from './status';
+import { stagingHandler } from './staging';
+import { commitHandler } from './commit';
+import { diffHandler } from './diff';
+import { branchHandler } from './branch';
+import { logHandler } from './log';
+import { remoteHandler } from './remote';
+import { conflictHandler } from './conflict';
+
+export const gitRouter = createRouter()
+	.merge(statusHandler)
+	.merge(stagingHandler)
+	.merge(commitHandler)
+	.merge(diffHandler)
+	.merge(branchHandler)
+	.merge(logHandler)
+	.merge(remoteHandler)
+	.merge(conflictHandler);

package/backend/ws/git/log.ts

@@ -0,0 +1,41 @@
+/**
+ * Git Log 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 logHandler = createRouter()
+	.http('git:log', {
+		data: t.Object({
+			projectId: t.String(),
+			limit: t.Optional(t.Number()),
+			skip: t.Optional(t.Number()),
+			branch: t.Optional(t.String())
+		}),
+		response: t.Object({
+			commits: t.Array(t.Object({
+				hash: t.String(),
+				hashShort: t.String(),
+				author: t.String(),
+				authorEmail: t.String(),
+				date: t.String(),
+				message: t.String(),
+				parents: t.Array(t.String()),
+				refs: t.Optional(t.Array(t.String()))
+			})),
+			total: t.Number(),
+			hasMore: t.Boolean()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+		return await gitService.getLog(
+			project.path,
+			data.limit ?? 50,
+			data.skip ?? 0,
+			data.branch
+		);
+	});