@myrialabs/clopen 0.2.1 → 0.2.3

package/backend/{lib/project → project}/status-manager.ts

@@ -1,224 +1,224 @@
-/**
- * Project Status Data Service
- * Shared logic for getting project status data
- */
-
-import { streamManager, type StreamState } from '../chat/stream-manager.js';
-import { ws } from '../utils/ws.js';
-
-// Interactive tools that block the stream waiting for user input
-const INTERACTIVE_TOOLS = new Set(['AskUserQuestion']);
-
-/**
- * Check if an active stream is waiting for user input.
- * Scans stream messages for unanswered interactive tool_use blocks.
- * This is the backend single source of truth — works even when the
- * user is on a different project and not receiving chat events.
- */
-function detectStreamWaitingInput(stream: StreamState): boolean {
-  if (stream.status !== 'active') return false;
-
-  // SSEEventData.message is SDKMessage: { type, message: { content: [...] } }
-  // Content blocks live at msg.message.content, NOT msg.content
-  const answeredToolIds = new Set<string>();
-  for (const event of stream.messages) {
-    const msg = event.message;
-    if (!msg || (msg as any).type !== 'user') continue;
-    const content = Array.isArray((msg as any).message?.content) ? (msg as any).message.content : [];
-    for (const item of content) {
-      if (item.type === 'tool_result' && item.tool_use_id) {
-        answeredToolIds.add(item.tool_use_id);
-      }
-    }
-  }
-
-  for (const event of stream.messages) {
-    const msg = event.message;
-    if (!msg || (msg as any).type !== 'assistant') continue;
-    const content = Array.isArray((msg as any).message?.content) ? (msg as any).message.content : [];
-    if (content.some((item: any) =>
-      item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name) && item.id && !answeredToolIds.has(item.id)
-    )) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// Store active users per project (shared with main endpoint)
-const projectUsers = new Map<string, Set<{ userId: string; userName: string; lastSeen: number }>>();
-
-// Cleanup inactive users after 5 minutes
-const USER_TIMEOUT = 5 * 60 * 1000;
-
-function cleanupInactiveUsers() {
-  const now = Date.now();
-  projectUsers.forEach((users, projectId) => {
-    const activeUsers = new Set([...users].filter(user => now - user.lastSeen < USER_TIMEOUT));
-    if (activeUsers.size === 0) {
-      projectUsers.delete(projectId);
-    } else {
-      projectUsers.set(projectId, activeUsers);
-    }
-  });
-}
-
-// Get project status data
-export async function getProjectStatusData(projectId?: string) {
-  cleanupInactiveUsers();
-  
-  if (projectId) {
-    // Get status for specific project
-    const allProjectStreams = streamManager.getProjectStreams(projectId);
-    const users = projectUsers.get(projectId);
-
-    // Filter to only count active streams
-    const activeStreams = allProjectStreams.filter(s => s.status === 'active');
-
-    // Get per-chat-session user presence from WS rooms
-    const chatSessionUsers = ws.getProjectChatSessions(projectId);
-
-    return {
-      projectId,
-      hasActiveStreams: activeStreams.length > 0,
-      activeStreamCount: activeStreams.length,
-      activeUsers: users ? [...users].map(u => ({
-        userId: u.userId,
-        userName: u.userName
-      })) : [],
-      streams: allProjectStreams.map(s => ({
-        streamId: s.streamId,
-        chatSessionId: s.chatSessionId,
-        status: s.status,
-        startedAt: s.startedAt,
-        messagesCount: s.messages.length,
-        isWaitingInput: detectStreamWaitingInput(s)
-      })),
-      chatSessionUsers: Object.fromEntries(
-        Array.from(chatSessionUsers.entries()).map(([csId, csUsers]) => [
-          csId,
-          csUsers.map(u => {
-            // Resolve userName from projectUsers
-            const projectUser = users ? [...users].find(pu => pu.userId === u.userId) : undefined;
-            return { userId: u.userId, userName: projectUser?.userName || u.userId };
-          })
-        ])
-      )
-    };
-  } else {
-    // Get status for all projects
-    const allProjects = new Map<string, any>();
-    
-    // Get all active streams grouped by project
-    const allStreams = streamManager.getAllStreams();
-    allStreams.forEach(stream => {
-      if (stream.projectId) {
-        if (!allProjects.has(stream.projectId)) {
-          allProjects.set(stream.projectId, {
-            projectId: stream.projectId,
-            hasActiveStreams: false,
-            activeStreamCount: 0,
-            activeUsers: [],
-            streams: []
-          });
-        }
-        
-        const projectData = allProjects.get(stream.projectId);
-        if (stream.status === 'active') {
-          projectData.hasActiveStreams = true;
-          projectData.activeStreamCount++;
-        }
-        projectData.streams.push({
-          streamId: stream.streamId,
-          chatSessionId: stream.chatSessionId,
-          status: stream.status,
-          startedAt: stream.startedAt,
-          messagesCount: stream.messages.length,
-          isWaitingInput: detectStreamWaitingInput(stream)
-        });
-      }
-    });
-    
-    // Add active users to each project
-    projectUsers.forEach((users, projectId) => {
-      if (!allProjects.has(projectId)) {
-        allProjects.set(projectId, {
-          projectId,
-          hasActiveStreams: false,
-          activeStreamCount: 0,
-          activeUsers: [],
-          streams: [],
-          chatSessionUsers: {}
-        });
-      }
-
-      const projectData = allProjects.get(projectId);
-      projectData.activeUsers = [...users].map(u => ({
-        userId: u.userId,
-        userName: u.userName
-      }));
-    });
-
-    // Add per-chat-session user presence to each project
-    for (const [projectId, projectData] of allProjects) {
-      const chatSessionUsers = ws.getProjectChatSessions(projectId);
-      const users = projectUsers.get(projectId);
-      projectData.chatSessionUsers = Object.fromEntries(
-        Array.from(chatSessionUsers.entries()).map(([csId, csUsers]) => [
-          csId,
-          csUsers.map(u => {
-            const projectUser = users ? [...users].find(pu => pu.userId === u.userId) : undefined;
-            return { userId: u.userId, userName: projectUser?.userName || u.userId };
-          })
-        ])
-      );
-    }
-
-    return [...allProjects.values()];
-  }
-}
-
-// Update user presence
-export function updateUserPresence(projectId: string, userId: string, userName: string, action: string) {
-  cleanupInactiveUsers();
-  
-  if (action === 'leave') {
-    // Remove user from project
-    const users = projectUsers.get(projectId);
-    if (users) {
-      const updatedUsers = new Set([...users].filter(u => u.userId !== userId));
-      if (updatedUsers.size === 0) {
-        projectUsers.delete(projectId);
-      } else {
-        projectUsers.set(projectId, updatedUsers);
-      }
-    }
-  } else {
-    // Add or update user presence
-    if (!projectUsers.has(projectId)) {
-      projectUsers.set(projectId, new Set());
-    }
-    
-    const users = projectUsers.get(projectId)!;
-    // Remove old entry if exists
-    const updatedUsers = new Set([...users].filter(u => u.userId !== userId));
-    // Add new entry with updated timestamp
-    updatedUsers.add({
-      userId,
-      userName,
-      lastSeen: Date.now()
-    });
-    projectUsers.set(projectId, updatedUsers);
-  }
-  
-  // Return current users for the project
-  const currentUsers = projectUsers.get(projectId);
-  return {
-    projectId,
-    activeUsers: currentUsers ? [...currentUsers].map(u => ({ 
-      userId: u.userId, 
-      userName: u.userName 
-    })) : []
-  };
+/**
+ * Project Status Data Service
+ * Shared logic for getting project status data
+ */
+
+import { streamManager, type StreamState } from '../chat/stream-manager.js';
+import { ws } from '../utils/ws.js';
+
+// Interactive tools that block the stream waiting for user input
+const INTERACTIVE_TOOLS = new Set(['AskUserQuestion']);
+
+/**
+ * Check if an active stream is waiting for user input.
+ * Scans stream messages for unanswered interactive tool_use blocks.
+ * This is the backend single source of truth — works even when the
+ * user is on a different project and not receiving chat events.
+ */
+function detectStreamWaitingInput(stream: StreamState): boolean {
+  if (stream.status !== 'active') return false;
+
+  // SSEEventData.message is SDKMessage: { type, message: { content: [...] } }
+  // Content blocks live at msg.message.content, NOT msg.content
+  const answeredToolIds = new Set<string>();
+  for (const event of stream.messages) {
+    const msg = event.message;
+    if (!msg || (msg as any).type !== 'user') continue;
+    const content = Array.isArray((msg as any).message?.content) ? (msg as any).message.content : [];
+    for (const item of content) {
+      if (item.type === 'tool_result' && item.tool_use_id) {
+        answeredToolIds.add(item.tool_use_id);
+      }
+    }
+  }
+
+  for (const event of stream.messages) {
+    const msg = event.message;
+    if (!msg || (msg as any).type !== 'assistant') continue;
+    const content = Array.isArray((msg as any).message?.content) ? (msg as any).message.content : [];
+    if (content.some((item: any) =>
+      item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name) && item.id && !answeredToolIds.has(item.id)
+    )) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Store active users per project (shared with main endpoint)
+const projectUsers = new Map<string, Set<{ userId: string; userName: string; lastSeen: number }>>();
+
+// Cleanup inactive users after 5 minutes
+const USER_TIMEOUT = 5 * 60 * 1000;
+
+function cleanupInactiveUsers() {
+  const now = Date.now();
+  projectUsers.forEach((users, projectId) => {
+    const activeUsers = new Set([...users].filter(user => now - user.lastSeen < USER_TIMEOUT));
+    if (activeUsers.size === 0) {
+      projectUsers.delete(projectId);
+    } else {
+      projectUsers.set(projectId, activeUsers);
+    }
+  });
+}
+
+// Get project status data
+export async function getProjectStatusData(projectId?: string) {
+  cleanupInactiveUsers();
+  
+  if (projectId) {
+    // Get status for specific project
+    const allProjectStreams = streamManager.getProjectStreams(projectId);
+    const users = projectUsers.get(projectId);
+
+    // Filter to only count active streams
+    const activeStreams = allProjectStreams.filter(s => s.status === 'active');
+
+    // Get per-chat-session user presence from WS rooms
+    const chatSessionUsers = ws.getProjectChatSessions(projectId);
+
+    return {
+      projectId,
+      hasActiveStreams: activeStreams.length > 0,
+      activeStreamCount: activeStreams.length,
+      activeUsers: users ? [...users].map(u => ({
+        userId: u.userId,
+        userName: u.userName
+      })) : [],
+      streams: allProjectStreams.map(s => ({
+        streamId: s.streamId,
+        chatSessionId: s.chatSessionId,
+        status: s.status,
+        startedAt: s.startedAt,
+        messagesCount: s.messages.length,
+        isWaitingInput: detectStreamWaitingInput(s)
+      })),
+      chatSessionUsers: Object.fromEntries(
+        Array.from(chatSessionUsers.entries()).map(([csId, csUsers]) => [
+          csId,
+          csUsers.map(u => {
+            // Resolve userName from projectUsers
+            const projectUser = users ? [...users].find(pu => pu.userId === u.userId) : undefined;
+            return { userId: u.userId, userName: projectUser?.userName || u.userId };
+          })
+        ])
+      )
+    };
+  } else {
+    // Get status for all projects
+    const allProjects = new Map<string, any>();
+    
+    // Get all active streams grouped by project
+    const allStreams = streamManager.getAllStreams();
+    allStreams.forEach(stream => {
+      if (stream.projectId) {
+        if (!allProjects.has(stream.projectId)) {
+          allProjects.set(stream.projectId, {
+            projectId: stream.projectId,
+            hasActiveStreams: false,
+            activeStreamCount: 0,
+            activeUsers: [],
+            streams: []
+          });
+        }
+        
+        const projectData = allProjects.get(stream.projectId);
+        if (stream.status === 'active') {
+          projectData.hasActiveStreams = true;
+          projectData.activeStreamCount++;
+        }
+        projectData.streams.push({
+          streamId: stream.streamId,
+          chatSessionId: stream.chatSessionId,
+          status: stream.status,
+          startedAt: stream.startedAt,
+          messagesCount: stream.messages.length,
+          isWaitingInput: detectStreamWaitingInput(stream)
+        });
+      }
+    });
+    
+    // Add active users to each project
+    projectUsers.forEach((users, projectId) => {
+      if (!allProjects.has(projectId)) {
+        allProjects.set(projectId, {
+          projectId,
+          hasActiveStreams: false,
+          activeStreamCount: 0,
+          activeUsers: [],
+          streams: [],
+          chatSessionUsers: {}
+        });
+      }
+
+      const projectData = allProjects.get(projectId);
+      projectData.activeUsers = [...users].map(u => ({
+        userId: u.userId,
+        userName: u.userName
+      }));
+    });
+
+    // Add per-chat-session user presence to each project
+    for (const [projectId, projectData] of allProjects) {
+      const chatSessionUsers = ws.getProjectChatSessions(projectId);
+      const users = projectUsers.get(projectId);
+      projectData.chatSessionUsers = Object.fromEntries(
+        Array.from(chatSessionUsers.entries()).map(([csId, csUsers]) => [
+          csId,
+          csUsers.map(u => {
+            const projectUser = users ? [...users].find(pu => pu.userId === u.userId) : undefined;
+            return { userId: u.userId, userName: projectUser?.userName || u.userId };
+          })
+        ])
+      );
+    }
+
+    return [...allProjects.values()];
+  }
+}
+
+// Update user presence
+export function updateUserPresence(projectId: string, userId: string, userName: string, action: string) {
+  cleanupInactiveUsers();
+  
+  if (action === 'leave') {
+    // Remove user from project
+    const users = projectUsers.get(projectId);
+    if (users) {
+      const updatedUsers = new Set([...users].filter(u => u.userId !== userId));
+      if (updatedUsers.size === 0) {
+        projectUsers.delete(projectId);
+      } else {
+        projectUsers.set(projectId, updatedUsers);
+      }
+    }
+  } else {
+    // Add or update user presence
+    if (!projectUsers.has(projectId)) {
+      projectUsers.set(projectId, new Set());
+    }
+    
+    const users = projectUsers.get(projectId)!;
+    // Remove old entry if exists
+    const updatedUsers = new Set([...users].filter(u => u.userId !== userId));
+    // Add new entry with updated timestamp
+    updatedUsers.add({
+      userId,
+      userName,
+      lastSeen: Date.now()
+    });
+    projectUsers.set(projectId, updatedUsers);
+  }
+  
+  // Return current users for the project
+  const currentUsers = projectUsers.get(projectId);
+  return {
+    projectId,
+    activeUsers: currentUsers ? [...currentUsers].map(u => ({ 
+      userId: u.userId, 
+      userName: u.userName 
+    })) : []
+  };
 }

package/backend/{lib/snapshot → snapshot}/blob-store.ts

@@ -11,12 +11,12 @@
  */
 
 import { join } from 'path';
-import { homedir } from 'os';
 import fs from 'fs/promises';
 import { gzipSync, gunzipSync } from 'zlib';
 import { debug } from '$shared/utils/logger';
+import { getClopenDir } from '../utils/index.js';
 
-const SNAPSHOTS_DIR = join(homedir(), '.clopen', 'snapshots');
+const SNAPSHOTS_DIR = join(getClopenDir(), 'snapshots');
 const BLOBS_DIR = join(SNAPSHOTS_DIR, 'blobs');
 const TREES_DIR = join(SNAPSHOTS_DIR, 'trees');
 

package/backend/{lib/terminal → terminal}/shell-utils.ts

@@ -7,7 +7,7 @@ import { join } from 'path';
 import { spawn, type IPty } from 'bun-pty';
 
 import { debug } from '$shared/utils/logger';
-import { getCleanSpawnEnv } from '../shared/env';
+import { getCleanSpawnEnv } from '../utils/env';
 // Platform detection
 export const isWindows = process.platform === 'win32';
 export const isMacOS = process.platform === 'darwin';

package/backend/{lib/shared → utils}/env.ts

@@ -22,12 +22,12 @@ const isDev = process.env.NODE_ENV !== 'production';
 
 export const SERVER_ENV = {
 	NODE_ENV: (process.env.NODE_ENV || 'development') as string,
-	/** Backend port — dev: PORT_BACKEND (default 9151), prod: PORT (default 9141) */
+	/** Backend port — dev: PORT_BACKEND (default 9161), prod: PORT (default 9141) */
 	PORT: isDev
-		? (process.env.PORT_BACKEND ? parseInt(process.env.PORT_BACKEND) : 9151)
+		? (process.env.PORT_BACKEND ? parseInt(process.env.PORT_BACKEND) : 9161)
 		: (process.env.PORT ? parseInt(process.env.PORT) : 9141),
 	/** Frontend port — only used in dev for Vite proxy coordination */
-	PORT_FRONTEND: process.env.PORT_FRONTEND ? parseInt(process.env.PORT_FRONTEND) : 9141,
+	PORT_FRONTEND: process.env.PORT_FRONTEND ? parseInt(process.env.PORT_FRONTEND) : 9151,
 	HOST: (process.env.HOST || 'localhost') as string,
 	isDevelopment: isDev,
 } as const;
@@ -35,15 +35,13 @@ export const SERVER_ENV = {
 // ── .env parsing ────────────────────────────────────────────────────
 
 /**
- * Parse .env file into key-value map.
- * Knowing both key AND value lets us compare against process.env
- * to determine if Bun's auto-load is still in effect or if the
- * system/runtime changed the value after loading.
+ * Parse a .env file at the given path into a key-value record.
+ * Returns an empty object if the file doesn't exist or can't be read.
  */
-function parseDotEnv(): Map<string, string> {
-	const entries = new Map<string, string>();
+export function loadEnvFile(envPath: string): Record<string, string> {
+	const result: Record<string, string> = {};
 	try {
-		const content = readFileSync(join(process.cwd(), '.env'), 'utf-8');
+		const content = readFileSync(envPath, 'utf-8');
 		for (const line of content.split('\n')) {
 			let trimmed = line.trim();
 			if (!trimmed || trimmed.startsWith('#')) continue;
@@ -51,22 +49,22 @@ function parseDotEnv(): Map<string, string> {
 			const eqIdx = trimmed.indexOf('=');
 			if (eqIdx <= 0) continue;
 			const key = trimmed.substring(0, eqIdx).trim();
-			// Strip surrounding quotes from value
 			let value = trimmed.substring(eqIdx + 1).trim();
 			if ((value.startsWith('"') && value.endsWith('"')) ||
 				(value.startsWith("'") && value.endsWith("'"))) {
 				value = value.slice(1, -1);
 			}
-			entries.set(key, value);
+			result[key] = value;
 		}
 	} catch {
 		// .env doesn't exist or can't be read
 	}
-	return entries;
+	return result;
 }
 
-// Capture once at import time
-const dotEnv = parseDotEnv();
+// Capture once at import time — read from CWD which is set to the clopen
+// installation directory when spawned via bin/clopen.ts (cwd: __dirname).
+const dotEnv = new Map(Object.entries(loadEnvFile(join(process.cwd(), '.env'))));
 
 // ── Filter definitions ──────────────────────────────────────────────
 

package/backend/{lib/shared → utils}/index.ts

@@ -2,4 +2,7 @@
 export * from './process-manager.js';
 
 // Export environment sanitizer
-export * from './env.js';
+export * from './env.js';
+
+// Export path utilities
+export * from './paths.js';

package/backend/utils/paths.ts

@@ -0,0 +1,11 @@
+import { join } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Returns the Clopen data directory.
+ * - development: ~/.clopen-dev
+ * - everything else (production, undefined): ~/.clopen
+ */
+export function getClopenDir(): string {
+	return join(homedir(), process.env.NODE_ENV === 'development' ? '.clopen-dev' : '.clopen');
+}

package/backend/{lib/shared → utils}/port-utils.ts

@@ -1,14 +1,18 @@
 /**
  * Port utilities for checking ports before server start.
  * Bun-optimized: uses Bun.connect for fast cross-platform port check.
+ *
+ * Checks BOTH IPv4 (127.0.0.1) and IPv6 (::1) — on Windows, 'localhost'
+ * may resolve to either address. A zombie process listening on [::1] would
+ * go undetected by an IPv4-only check, causing the new server to bind to a
+ * port that can't actually serve traffic (connections hang indefinitely).
  */
 
-/** Check if a port is currently in use */
-export async function isPortInUse(port: number): Promise<boolean> {
+/** Try to connect to a specific host:port */
+async function tryConnect(hostname: string, port: number): Promise<boolean> {
 	try {
-		// Bun-native TCP connect — fast cross-platform check
 		const socket = await Bun.connect({
-			hostname: '127.0.0.1',
+			hostname,
 			port,
 			socket: {
 				data() {},
@@ -18,12 +22,21 @@ export async function isPortInUse(port: number): Promise<boolean> {
 			}
 		});
 		socket.end();
-		return true; // Connection succeeded = port in use
+		return true;
 	} catch {
-		return false; // Connection refused = port is free
+		return false;
 	}
 }
 
+/** Check if a port is currently in use on any localhost address (IPv4 + IPv6) */
+export async function isPortInUse(port: number): Promise<boolean> {
+	const [v4, v6] = await Promise.all([
+		tryConnect('127.0.0.1', port),
+		tryConnect('::1', port),
+	]);
+	return v4 || v6;
+}
+
 /** Find an available port starting from the given port, incrementing on collision */
 export async function findAvailablePort(startPort: number, maxAttempts = 8): Promise<number> {
 	let port = startPort;

package/backend/{lib/utils → utils}/ws.ts

@@ -16,7 +16,7 @@
  *
  * Usage:
  * ```ts
- * import { ws } from '$backend/lib/ws'
+ * import { ws } from '$backend/utils/ws'
  *
  * // Project-specific event
  * ws.emit.project(projectId, 'terminal:output', { content });
@@ -156,7 +156,7 @@ class WSServer {
 	/**
 	 * Ensure a connection is registered, hydrated, and return its wsId.
 	 * Handles the race condition where message handlers fire before the async
-	 * open handler completes its await import('$backend/lib/utils/ws').
+	 * open handler completes its await import('$backend/utils/ws').
 	 */
 	private ensureRegistered(conn: WSConnection): string {
 		const existingId = this.resolveId(conn);