@myrialabs/clopen 0.0.1

package/backend/ws/user/crud.ts

@@ -0,0 +1,156 @@
+/**
+ * User CRUD Operations
+ *
+ * HTTP endpoints for user management:
+ * - Generate anonymous user
+ * - Update user name
+ * - Restore user state (server-side state management)
+ * - Save user state
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { generateAnonymousUser, generateColorFromString, getInitials } from '../../lib/user/helpers';
+import type { AnonymousUser } from '../../lib/user/helpers';
+import { ws } from '$backend/lib/utils/ws';
+import { settingsQueries } from '$backend/lib/database/queries';
+import { debug } from '$shared/utils/logger';
+
+/**
+ * User state keys stored in the settings table.
+ * Format: `user:{userId}:{key}`
+ */
+function userKey(userId: string, key: string): string {
+	return `user:${userId}:${key}`;
+}
+
+/**
+ * Read a user state value from the settings table.
+ * Returns parsed JSON or null if not found.
+ */
+function getUserState(userId: string, key: string): any {
+	const setting = settingsQueries.get(userKey(userId, key));
+	if (!setting) return null;
+	try {
+		return JSON.parse(setting.value);
+	} catch {
+		return setting.value;
+	}
+}
+
+/**
+ * Write a user state value to the settings table.
+ * Values are JSON-stringified before storage.
+ */
+function setUserState(userId: string, key: string, value: any): void {
+	const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+	settingsQueries.set(userKey(userId, key), serialized);
+}
+
+export const crudHandler = createRouter()
+	// Generate anonymous user
+	.http('user:anonymous', {
+		data: t.Object({}),
+		response: t.Object({
+			id: t.String(),
+			name: t.String(),
+			color: t.String(),
+			avatar: t.String(),
+			createdAt: t.String()
+		})
+	}, async () => {
+		const newUser = generateAnonymousUser();
+
+		debug.log('user', '✅ Generated new anonymous user:', newUser.name);
+
+		return newUser;
+	})
+
+	// Update user name
+	.http('user:update', {
+		data: t.Object({
+			newName: t.String({ minLength: 1 })
+		}),
+		response: t.Object({
+			id: t.String(),
+			name: t.String(),
+			color: t.String(),
+			avatar: t.String(),
+			createdAt: t.String()
+		})
+	}, async ({ data, conn }) => {
+		const userId = ws.getUserId(conn);
+		const { newName } = data;
+
+		const trimmedName = newName.trim();
+
+		if (trimmedName.length === 0) {
+			throw new Error('Name cannot be empty');
+		}
+
+		// Create updated user object
+		const updatedUser: AnonymousUser = {
+			id: userId,
+			name: trimmedName,
+			avatar: getInitials(trimmedName),
+			color: generateColorFromString(trimmedName),
+			createdAt: new Date().toISOString()
+		};
+
+		debug.log('user', '✅ Updated user name:', { userId, newName: trimmedName });
+
+		return updatedUser;
+	})
+
+	// Restore user state - returns all server-side user state at once
+	.http('user:restore-state', {
+		data: t.Object({}),
+		response: t.Object({
+			currentProjectId: t.Union([t.String(), t.Null()]),
+			lastView: t.Union([t.String(), t.Null()]),
+			settings: t.Union([t.Any(), t.Null()])
+		})
+	}, async ({ conn }) => {
+		const userId = ws.getUserId(conn);
+
+		const currentProjectId = getUserState(userId, 'currentProjectId') as string | null;
+		const lastView = getUserState(userId, 'lastView') as string | null;
+		const userSettings = getUserState(userId, 'settings');
+
+		debug.log('user', `Restored state for ${userId}:`, {
+			currentProjectId,
+			lastView,
+			hasSettings: !!userSettings
+		});
+
+		return {
+			currentProjectId: currentProjectId ?? null,
+			lastView: lastView ?? null,
+			settings: userSettings ?? null
+		};
+	})
+
+	// Save user state - saves a single key-value pair
+	.http('user:save-state', {
+		data: t.Object({
+			key: t.String({ minLength: 1 }),
+			value: t.Any()
+		}),
+		response: t.Object({
+			success: t.Boolean()
+		})
+	}, async ({ data, conn }) => {
+		const userId = ws.getUserId(conn);
+
+		// Validate allowed keys to prevent arbitrary data storage
+		const allowedKeys = ['currentProjectId', 'lastView', 'settings'];
+		if (!allowedKeys.includes(data.key)) {
+			throw new Error(`Invalid state key: ${data.key}. Allowed: ${allowedKeys.join(', ')}`);
+		}
+
+		setUserState(userId, data.key, data.value);
+
+		debug.log('user', `Saved state for ${userId}: ${data.key}`);
+
+		return { success: true };
+	});

package/backend/ws/user/index.ts

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

package/bin/clopen.ts

@@ -0,0 +1,307 @@
+#!/usr/bin/env bun
+
+/**
+ * Clopen CLI Entry Point
+ *
+ * Handles:
+ * - CLI argument parsing
+ * - Environment setup (.env from .env.example)
+ * - Dependency installation (always runs to ensure up-to-date)
+ * - Build verification
+ * - Server startup
+ */
+
+import { existsSync, copyFileSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// CLI Options interface
+interface CLIOptions {
+	port?: number;
+	host?: string;
+	help?: boolean;
+	version?: boolean;
+}
+
+// Get version from package.json
+function getVersion(): string {
+	try {
+		const packagePath = join(__dirname, 'package.json');
+		const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+		return packageJson.version || '0.0.0';
+	} catch {
+		return '0.0.0';
+	}
+}
+
+// Simple loading indicator
+let loadingInterval: Timer | null = null;
+let currentMessage = '';
+
+async function delay(ms: number = 500) {
+	await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function updateLoading(message: string) {
+	currentMessage = message;
+	if (!loadingInterval) {
+		const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+		let i = 0;
+		loadingInterval = setInterval(() => {
+			// Clear line and write new message to avoid text overlap
+			process.stdout.write(`\r\x1b[K${frames[i]} ${currentMessage}`);
+			i = (i + 1) % frames.length;
+		}, 80);
+	}
+}
+
+function stopLoading() {
+	if (loadingInterval) {
+		clearInterval(loadingInterval);
+		loadingInterval = null;
+		process.stdout.write('\r\x1b[K'); // Clear line
+	}
+}
+
+const __dirname = join(import.meta.dir, '..');
+const ENV_EXAMPLE = join(__dirname, '.env.example');
+const ENV_FILE = join(__dirname, '.env');
+const DIST_DIR = join(__dirname, 'dist');
+const BUILD_VERSION_FILE = join(DIST_DIR, '.build-version');
+
+// Default values
+const DEFAULT_PORT = 9141;
+const DEFAULT_HOST = 'localhost';
+const MIN_PORT = 1024;
+const MAX_PORT = 65535;
+
+function showHelp() {
+	console.log(`
+Clopen - Modern web UI for Claude Code
+
+USAGE:
+  clopen [OPTIONS]
+
+OPTIONS:
+  -p, --port <number>     Port to run the server on (default: ${DEFAULT_PORT})
+  --host <address>        Host address to bind to (default: ${DEFAULT_HOST})
+  -v, --version           Show version number
+  -h, --help              Show this help message
+
+EXAMPLES:
+  clopen                  # Start with default settings (port ${DEFAULT_PORT})
+  clopen --port 9150      # Start on port 9150
+  clopen --host 0.0.0.0   # Bind to all network interfaces
+  clopen --version        # Show version
+
+For more information, visit: https://github.com/myrialabs/clopen
+`);
+}
+
+function parseArguments(): CLIOptions {
+	const args = process.argv.slice(2);
+	const options: CLIOptions = {};
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+
+		switch (arg) {
+			case '-h':
+			case '--help':
+				options.help = true;
+				break;
+
+			case '-v':
+			case '--version':
+				options.version = true;
+				break;
+
+			case '-p':
+			case '--port': {
+				const portValue = args[++i];
+				if (!portValue) {
+					console.error('❌ Error: --port requires a value');
+					console.log('Run "clopen --help" for usage information');
+					process.exit(1);
+				}
+				const port = parseInt(portValue);
+				if (isNaN(port)) {
+					console.error(`❌ Error: Invalid port "${portValue}". Port must be a number.`);
+					process.exit(1);
+				}
+				if (port < MIN_PORT || port > MAX_PORT) {
+					console.error(`❌ Error: Port must be between ${MIN_PORT} and ${MAX_PORT}.`);
+					process.exit(1);
+				}
+				options.port = port;
+				break;
+			}
+
+			case '--host': {
+				const hostValue = args[++i];
+				if (!hostValue) {
+					console.error('❌ Error: --host requires a value');
+					console.log('Run "clopen --help" for usage information');
+					process.exit(1);
+				}
+				options.host = hostValue;
+				break;
+			}
+
+			default:
+				console.error(`❌ Error: Unknown option "${arg}"`);
+				console.log('Run "clopen --help" for usage information');
+				process.exit(1);
+		}
+	}
+
+	return options;
+}
+
+async function setupEnvironment() {
+	// Check if .env exists, if not copy from .env.example
+	if (!existsSync(ENV_FILE)) {
+		if (existsSync(ENV_EXAMPLE)) {
+			copyFileSync(ENV_EXAMPLE, ENV_FILE);
+		}
+	}
+}
+
+async function installDependencies() {
+	// Always run bun install to ensure dependencies are up to date
+	// Bun is fast and will skip if nothing changed
+	updateLoading('Checking dependencies...');
+	await delay();
+
+	const installProc = Bun.spawn(['bun', 'install', '--silent'], {
+		cwd: __dirname,
+		stdout: 'pipe',
+		stderr: 'pipe'
+	});
+
+	// If install takes longer than 3 seconds, it's actually installing
+	const updateMessageTimeout = setTimeout(() => {
+		updateLoading('Installing dependencies...');
+	}, 3000);
+
+	const exitCode = await installProc.exited;
+	clearTimeout(updateMessageTimeout);
+
+	if (exitCode !== 0) {
+		stopLoading();
+		// Show error output only if failed
+		const errorText = await new Response(installProc.stderr).text();
+		console.error('❌ Dependency installation failed:');
+		console.error(errorText);
+		process.exit(exitCode);
+	}
+}
+
+function needsBuild(): boolean {
+	// No dist directory — must build
+	if (!existsSync(DIST_DIR)) return true;
+
+	// No build version file — must build
+	if (!existsSync(BUILD_VERSION_FILE)) return true;
+
+	// Compare built version with current version
+	try {
+		const builtVersion = readFileSync(BUILD_VERSION_FILE, 'utf-8').trim();
+		return builtVersion !== getVersion();
+	} catch {
+		return true;
+	}
+}
+
+async function verifyBuild() {
+	if (needsBuild()) {
+		updateLoading('Building...');
+		await delay();
+
+		const buildProc = Bun.spawn(['bun', 'run', 'build'], {
+			cwd: __dirname,
+			stdout: 'pipe',
+			stderr: 'pipe'
+		});
+
+		const exitCode = await buildProc.exited;
+
+		if (exitCode !== 0) {
+			stopLoading();
+			const errorText = await new Response(buildProc.stderr).text();
+			console.error('❌ Build failed:');
+			console.error(errorText);
+			process.exit(exitCode);
+		}
+
+		// Write current version to build version file
+		writeFileSync(BUILD_VERSION_FILE, getVersion());
+	}
+}
+
+async function startServer(options: CLIOptions) {
+	updateLoading('Starting server...');
+	await delay();
+
+	// Run server as subprocess to ensure it uses local node_modules
+	const serverPath = join(__dirname, 'backend/index.ts');
+
+	stopLoading();
+
+	// Prepare environment variables
+	const env = { ...process.env };
+	if (options.port) {
+		env.PORT = options.port.toString();
+	}
+	if (options.host) {
+		env.HOST = options.host;
+	}
+
+	const serverProc = Bun.spawn(['bun', serverPath], {
+		cwd: __dirname,
+		stdout: 'inherit',
+		stderr: 'inherit',
+		stdin: 'inherit',
+		env
+	});
+
+	// Wait for server process
+	await serverProc.exited;
+}
+
+async function main() {
+	try {
+		// Parse CLI arguments
+		const options = parseArguments();
+
+		// Show version if requested
+		if (options.version) {
+			console.log(getVersion());
+			process.exit(0);
+		}
+
+		// Show help if requested
+		if (options.help) {
+			showHelp();
+			process.exit(0);
+		}
+
+		// 1. Setup environment variables
+		await setupEnvironment();
+
+		// 2. Install dependencies if needed
+		await installDependencies();
+
+		// 3. Verify/build frontend
+		await verifyBuild();
+
+		// 4. Start server
+		await startServer(options);
+
+	} catch (error) {
+		console.error('❌ Failed to start Clopen:', error);
+		process.exit(1);
+	}
+}
+
+// Run CLI
+main();