@myrialabs/clopen 0.2.1 → 0.2.3

package/.dockerignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+logs
+.env
+.git

package/.env.example

@@ -1,6 +1,3 @@
-# Node Environment (development | production)
-NODE_ENV=production
-
 # Server configuration
 HOST=localhost
 
@@ -8,5 +5,5 @@ HOST=localhost
 PORT=9141
 
 # Development ports (two ports — Vite proxies to Elysia)
-PORT_BACKEND=9151
-PORT_FRONTEND=9141
+PORT_FRONTEND=9151
+PORT_BACKEND=9161

package/CONTRIBUTING.md

@@ -22,6 +22,10 @@ bun install
 bun run check
 ```
 
+### Data Directory
+
+When running `bun run dev`, Clopen stores data in `~/.clopen-dev` instead of `~/.clopen`. This keeps development data separate from any production instance — especially important since Clopen can be used to develop itself.
+
 ### Keep Updated
 
 ```bash

package/README.md

@@ -9,7 +9,7 @@
 
 ## Features
 
-- **Multi-Account Claude Code** - Manage multiple accounts (personal, work, team) and switch instantly per session, isolated under `~/.clopen/claude/user/` without touching system-level Claude config
+- **Multi-Account Claude Code** - Manage multiple accounts (personal, work, team) and switch instantly per session, isolated under `~/.clopen/claude/user/` (or `~/.clopen-dev/` in development) without touching system-level Claude config
 - **Multi-Engine Support** - Switch between Claude Code and OpenCode
 - **AI Chat Interface** - Streaming responses with tool use visualization
 - **Background Processing** - Chat, terminal, and other processes continue running even when you close the browser — come back later and pick up where you left off
@@ -92,6 +92,8 @@ bun run dev     # Start development server
 bun run check   # Type checking
 ```
 
+When running in development mode, Clopen uses `~/.clopen-dev` instead of `~/.clopen`, keeping dev data separate from any production instance.
+
 ---
 
 ## Architecture
@@ -123,7 +125,7 @@ Clopen uses an engine-agnostic adapter pattern — both engines normalize output
 ### Port 9141 Already in Use
 
 ```bash
-clopen --port 9150
+clopen --port 9145
 ```
 
 Or kill the existing process:

package/backend/{lib/auth → auth}/auth-service.ts

@@ -4,9 +4,9 @@
  * Core authentication logic: user creation, session management, invite handling.
  */
 
-import { authQueries, settingsQueries } from '$backend/lib/database/queries';
+import { authQueries, settingsQueries } from '$backend/database/queries';
 import { generateSessionToken, generatePAT, generateInviteToken, hashToken, getTokenType } from './tokens';
-import { generateColorFromString, getInitials } from '$backend/lib/user/helpers';
+import { generateColorFromString, getInitials } from '$backend/utils/user-helpers';
 import { debug } from '$shared/utils/logger';
 
 /** Default session lifetime in days */

package/backend/{lib/chat → chat}/stream-manager.ts

@@ -1097,7 +1097,7 @@ class StreamManager extends EventEmitter {
 			// Update checkpoint_tree_state when saving a new checkpoint (real user message)
 			if (message.type === 'user') {
 				try {
-					const { isCheckpointMessage, buildCheckpointTree, getCheckpointPathToRoot } = await import('../../lib/snapshot/helpers');
+					const { isCheckpointMessage, buildCheckpointTree, getCheckpointPathToRoot } = await import('../snapshot/helpers');
 					const { checkpointQueries } = await import('../database/queries');
 
 					// Check if this new message is a checkpoint

package/backend/{lib/database → database}/queries/message-queries.ts

@@ -42,6 +42,48 @@ export const messageQueries = {
 		});
 	},
 
+	/**
+	 * Get minimal preview data for a session: first user msg, last assistant msg, and counts.
+	 * Used by the Sessions/History modal to avoid loading all messages.
+	 */
+	getSessionPreview(sessionId: string): {
+		firstUserMessage: DatabaseMessage | null;
+		lastAssistantMessage: DatabaseMessage | null;
+		userCount: number;
+		assistantCount: number;
+	} {
+		const db = getDatabase();
+
+		const firstUserMessage = db.prepare(`
+			SELECT * FROM messages
+			WHERE session_id = ? AND json_extract(sdk_message, '$.type') = 'user'
+			ORDER BY timestamp ASC
+			LIMIT 1
+		`).get(sessionId) as DatabaseMessage | null;
+
+		const lastAssistantMessage = db.prepare(`
+			SELECT * FROM messages
+			WHERE session_id = ? AND json_extract(sdk_message, '$.type') = 'assistant'
+			ORDER BY timestamp DESC
+			LIMIT 1
+		`).get(sessionId) as DatabaseMessage | null;
+
+		const counts = db.prepare(`
+			SELECT
+				SUM(CASE WHEN json_extract(sdk_message, '$.type') = 'user' THEN 1 ELSE 0 END) AS user_count,
+				SUM(CASE WHEN json_extract(sdk_message, '$.type') = 'assistant' THEN 1 ELSE 0 END) AS assistant_count
+			FROM messages
+			WHERE session_id = ?
+		`).get(sessionId) as { user_count: number; assistant_count: number } | null;
+
+		return {
+			firstUserMessage,
+			lastAssistantMessage,
+			userCount: counts?.user_count ?? 0,
+			assistantCount: counts?.assistant_count ?? 0
+		};
+	},
+
 	/**
 	 * Get all messages for a session including deleted ones (for timeline view)
 	 */

package/backend/{lib/database → database}/utils/connection.ts

@@ -1,17 +1,17 @@
 import { join } from 'path';
-import { homedir } from 'os';
 import { Database } from 'bun:sqlite';
 import type { DatabaseConnection } from '$shared/types/database/connection';
 
 import { debug } from '$shared/utils/logger';
+import { getClopenDir } from '../../utils/index.js';
+
 export class DatabaseManager {
 	private static instance: DatabaseManager | null = null;
 	private db: DatabaseConnection | null = null;
 	private readonly dbPath: string;
 
 	private constructor() {
-		const clopenDir = join(homedir(), '.clopen');
-		this.dbPath = join(clopenDir, 'app.db');
+		this.dbPath = join(getClopenDir(), 'app.db');
 	}
 
 	static getInstance(): DatabaseManager {
@@ -29,8 +29,8 @@ export class DatabaseManager {
 		debug.log('database', '🔗 Connecting to database...');
 
 		try {
-			// Create ~/.clopen directory if it doesn't exist
-			const clopenDir = join(homedir(), '.clopen');
+			// Create clopen directory if it doesn't exist
+			const clopenDir = getClopenDir();
 			const dirFile = Bun.file(clopenDir);
 
 			// Check if directory exists, if not create it

package/backend/{lib/engine → engine}/adapters/claude/environment.ts

@@ -7,22 +7,21 @@
  * stream concurrently.
  */
 
-import { homedir } from 'os';
 import { join } from 'path';
 import { isWindows, findGitBash } from '../../../terminal/shell-utils.js';
 import { engineQueries } from '../../../database/queries';
 import { debug } from '$shared/utils/logger';
-import { getCleanSpawnEnv } from '../../../shared/env';
+import { getCleanSpawnEnv, getClopenDir } from '../../../utils/index.js';
 
 let _ready = false;
 let _initPromise: Promise<void> | null = null;
 let _envOverrides: Record<string, string> = {};
 
 /**
- * Returns the isolated Claude config directory under ~/.clopen/claude/user/
+ * Returns the isolated Claude config directory under {clopenDir}/claude/user/
  */
 export function getClaudeUserConfigDir(): string {
-  return join(homedir(), '.clopen', 'claude', 'user');
+  return join(getClopenDir(), 'claude', 'user');
 }
 
 /**

package/backend/{lib/engine → engine}/adapters/opencode/message-converter.ts

@@ -141,7 +141,7 @@ const TOOL_NAME_MAP: Record<string, string> = {
 
 /** Map Open Code tool name to Claude Code tool name for UI rendering */
 export function mapToolName(openCodeToolName: string): string {
-	// Check if this is a custom MCP tool (resolves via single source in backend/lib/mcp)
+	// Check if this is a custom MCP tool (resolves via single source in backend/mcp)
 	const mcpName = resolveOpenCodeToolName(openCodeToolName);
 	if (mcpName) return mcpName;
 

package/backend/{lib/engine → engine}/adapters/opencode/server.ts

@@ -11,6 +11,7 @@
 import type { OpencodeClient } from '@opencode-ai/sdk';
 import { getOpenCodeMcpConfig } from '../../../mcp';
 import { debug } from '$shared/utils/logger';
+import { findAvailablePort } from '../../../utils/port-utils';
 
 const OPENCODE_PORT = 4096;
 const OPENCODE_HOST = '127.0.0.1';
@@ -58,9 +59,14 @@ async function init(): Promise<void> {
 		}
 	}
 
+	const actualPort = await findAvailablePort(OPENCODE_PORT);
+	if (actualPort !== OPENCODE_PORT) {
+		debug.log('engine', `Open Code port ${OPENCODE_PORT} in use, using ${actualPort} instead`);
+	}
+
 	const result = await createOpencode({
 		hostname: OPENCODE_HOST,
-		port: OPENCODE_PORT,
+		port: actualPort,
 		...(Object.keys(mcpConfig).length > 0 && {
 			config: { mcp: mcpConfig },
 		}),

package/backend/{lib/files → files}/file-watcher.ts

@@ -12,7 +12,7 @@
 import { watch, type FSWatcher, existsSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { join, relative, normalize, sep } from 'node:path';
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 import { debug } from '$shared/utils/logger';
 import type { FileChange } from '$shared/types/filesystem';
 

package/backend/{lib/git → git}/git-executor.ts

@@ -4,7 +4,7 @@
  */
 
 import { debug } from '$shared/utils/logger';
-import { getCleanSpawnEnv } from '../shared/env';
+import { getCleanSpawnEnv } from '../utils/env';
 
 export interface GitExecResult {
 	stdout: string;
@@ -22,7 +22,8 @@ export async function execGit(
 ): Promise<GitExecResult> {
 	debug.log('git', `Executing: git ${args.join(' ')} in ${cwd}`);
 
-	const proc = Bun.spawn(['git', ...args], {
+	const safeCwd = cwd.replace(/\\/g, '/');
+	const proc = Bun.spawn(['git', '-c', `safe.directory=${safeCwd}`, ...args], {
 		cwd,
 		stdout: 'pipe',
 		stderr: 'pipe',

package/backend/index.ts

@@ -9,7 +9,7 @@ if (typeof globalThis.Bun === 'undefined') {
 }
 
 // MUST be first import — cleans process.env before any other module reads it
-import { SERVER_ENV } from './lib/shared/env';
+import { SERVER_ENV } from './utils/env';
 
 import { Elysia } from 'elysia';
 import { corsMiddleware } from './middleware/cors';
@@ -17,10 +17,9 @@ import { errorHandlerMiddleware } from './middleware/error-handler';
 import { loggerMiddleware } from './middleware/logger';
 
 // Database initialization
-import { initializeDatabase, closeDatabase } from './lib/database';
-import { disposeAllEngines } from './lib/engine';
+import { initializeDatabase, closeDatabase } from './database';
+import { disposeAllEngines } from './engine';
 import { debug } from '$shared/utils/logger';
-import { findAvailablePort } from './lib/shared/port-utils';
 import { networkInterfaces } from 'os';
 import { resolve } from 'node:path';
 import { statSync } from 'node:fs';
@@ -29,11 +28,11 @@ import { statSync } from 'node:fs';
 import { wsRouter } from './ws';
 
 // MCP remote server for Open Code custom tools
-import { handleMcpRequest, closeMcpServer } from './lib/mcp/remote-server';
+import { handleMcpRequest, closeMcpServer } from './mcp/remote-server';
 
 // Auth middleware
-import { checkRouteAccess } from './lib/auth/permissions';
-import { ws as wsServer } from './lib/utils/ws';
+import { checkRouteAccess } from './auth/permissions';
+import { ws as wsServer } from './utils/ws';
 
 // Register auth gate on WebSocket router — blocks unauthenticated/unauthorized access
 wsRouter.setAuthMiddleware(async (conn, action) => {
@@ -45,7 +44,7 @@ wsRouter.setAuthMiddleware(async (conn, action) => {
 /**
  * Clopen - Elysia Backend Server
  *
- * Development: Elysia runs on port 9151, Vite dev server proxies /api and /ws from port 9141
+ * Development: Elysia runs on port 9161, Vite dev server proxies /api and /ws from port 9151
  * Production: Elysia runs on port 9141, serves static files from dist/ + API + WebSocket
  */
 
@@ -117,11 +116,12 @@ if (!isDevelopment) {
 
 // Start server with proper initialization sequence
 async function startServer() {
-	// Find available port — auto-increment if desired port is in use
-	const actualPort = await findAvailablePort(PORT);
-	if (actualPort !== PORT) {
-		debug.log('server', `⚠️ Port ${PORT} in use, using ${actualPort} instead`);
-	}
+	// Port resolution is handled by the caller:
+	// - Development: scripts/dev.ts resolves ports and passes via PORT_BACKEND env
+	// - Production:  scripts/start.ts resolves port and passes via PORT env
+	// - CLI:         bin/clopen.ts resolves port and passes via PORT env
+	// This avoids double port-check race conditions (e.g. zombie processes on
+	// Windows causing silent desync between Vite proxy and backend).
 
 	// Initialize database first before accepting connections
 	try {
@@ -133,18 +133,18 @@ async function startServer() {
 
 	// Start listening after database is ready
 	app.listen({
-		port: actualPort,
+		port: PORT,
 		hostname: HOST
 	}, () => {
 		if (isDevelopment) {
 			console.log('🚀 Backend ready — waiting for frontend...');
 		} else {
-			console.log(`🚀 Clopen running at http://localhost:${actualPort}`);
+			console.log(`🚀 Clopen running at http://localhost:${PORT}`);
 		}
 		if (HOST === '0.0.0.0') {
 			const ips = getLocalIps();
 			for (const ip of ips) {
-				console.log(`🌐 Network access: http://${ip}:${actualPort}`);
+				console.log(`🌐 Network access: http://${ip}:${PORT}`);
 			}
 		}
 	});