@myrialabs/clopen 0.2.1 → 0.2.2

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/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/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);

package/backend/ws/README.md

@@ -466,7 +466,7 @@ try {
 
 **Backend:**
 ```typescript
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 .on('terminal:input', {
   data: t.Object({
@@ -589,7 +589,7 @@ ws.emit.global(event, payload)                  // → all connected clients
 Emit events from external sources (PTY, file watchers, etc.):
 
 ```typescript
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 // PTY output
 pty.onData((output) => {
@@ -632,7 +632,7 @@ browser.on('screencast-frame', (frame) => {
 
 **Backend - Connection Setup:**
 ```typescript
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 app.ws('/ws', {
   open(wsRaw) {
@@ -751,10 +751,10 @@ Merge another router.
 
 ### WebSocket Singleton API
 
-**File: `backend/lib/utils/ws.ts`**
+**File: `backend/utils/ws.ts`**
 
 ```typescript
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 // Emit events
 ws.emit.user(userId, 'event', payload)
@@ -781,7 +781,7 @@ ws.getConnectionCount(projectId?)
 
 ### Frontend Client API
 
-**File: `frontend/lib/utils/ws.ts`**
+**File: `frontend/shared/ws.ts`**
 
 ```typescript
 import ws from '$lib/utils/ws';
@@ -865,7 +865,7 @@ renderTree(tree);
 ```typescript
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 export const streamHandler = createRouter()
   .on('terminal:input', {
@@ -942,7 +942,7 @@ onDestroy(() => {
 ```typescript
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 export const interactHandler = createRouter()
   .on('browser:interact', {
@@ -1485,7 +1485,7 @@ cleanup();
 ### Event Emission
 
 ```typescript
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 // User-specific (all connections of a user)
 ws.emit.user(userId, 'event', payload);

package/backend/ws/auth/invites.ts

@@ -1,7 +1,7 @@
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { createInvite, listInvites, revokeInvite } from '$backend/lib/auth/auth-service';
-import { ws } from '$backend/lib/utils/ws';
+import { createInvite, listInvites, revokeInvite } from '$backend/auth/auth-service';
+import { ws } from '$backend/utils/ws';
 
 export const inviteHandler = createRouter()
 	// Create invite token (admin only — enforced by auth gate)

package/backend/ws/auth/login.ts

@@ -12,11 +12,11 @@ import {
 	updateUserName,
 	createOrGetNoAuthAdmin,
 	needsSetup
-} from '$backend/lib/auth/auth-service';
-import { settingsQueries } from '$backend/lib/database/queries';
-import { getTokenType } from '$backend/lib/auth/tokens';
-import { authRateLimiter } from '$backend/lib/auth/rate-limiter';
-import { ws } from '$backend/lib/utils/ws';
+} from '$backend/auth/auth-service';
+import { settingsQueries } from '$backend/database/queries';
+import { getTokenType } from '$backend/auth/tokens';
+import { authRateLimiter } from '$backend/auth/rate-limiter';
+import { ws } from '$backend/utils/ws';
 
 const authUserSchema = t.Object({
 	id: t.String(),
@@ -51,7 +51,7 @@ export const loginHandler = createRouter()
 		settingsQueries.set('system:settings', JSON.stringify(parsed));
 
 		// Set auth on connection
-		const tokenHash = (await import('$backend/lib/auth/tokens')).hashToken(result.sessionToken);
+		const tokenHash = (await import('$backend/auth/tokens')).hashToken(result.sessionToken);
 		ws.setAuth(conn, result.user.id, result.user.role, tokenHash);
 
 		return result;
@@ -82,7 +82,7 @@ export const loginHandler = createRouter()
 		const result = createOrGetNoAuthAdmin();
 
 		// Set auth on connection
-		const tokenHash = (await import('$backend/lib/auth/tokens')).hashToken(result.sessionToken);
+		const tokenHash = (await import('$backend/auth/tokens')).hashToken(result.sessionToken);
 		ws.setAuth(conn, result.user.id, result.user.role, tokenHash);
 
 		return result;
@@ -104,7 +104,7 @@ export const loginHandler = createRouter()
 		const result = createOrGetNoAuthAdmin();
 
 		// Set auth on connection
-		const tokenHash = (await import('$backend/lib/auth/tokens')).hashToken(result.sessionToken);
+		const tokenHash = (await import('$backend/auth/tokens')).hashToken(result.sessionToken);
 		ws.setAuth(conn, result.user.id, result.user.role, tokenHash);
 
 		return result;
@@ -187,7 +187,7 @@ export const loginHandler = createRouter()
 			authRateLimiter.recordSuccess(ip);
 
 			// Set auth on connection
-			const tokenHash = (await import('$backend/lib/auth/tokens')).hashToken(result.sessionToken);
+			const tokenHash = (await import('$backend/auth/tokens')).hashToken(result.sessionToken);
 			ws.setAuth(conn, result.user.id, result.user.role, tokenHash);
 
 			return result;

package/backend/ws/auth/status.ts

@@ -1,7 +1,7 @@
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { needsSetup, getUserById, getAuthMode, isOnboardingComplete } from '$backend/lib/auth/auth-service';
-import { ws } from '$backend/lib/utils/ws';
+import { needsSetup, getUserById, getAuthMode, isOnboardingComplete } from '$backend/auth/auth-service';
+import { ws } from '$backend/utils/ws';
 
 export const statusHandler = createRouter()
 	.http('auth:status', {

package/backend/ws/auth/users.ts

@@ -1,6 +1,6 @@
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { listUsers, removeUser } from '$backend/lib/auth/auth-service';
+import { listUsers, removeUser } from '$backend/auth/auth-service';
 
 export const usersHandler = createRouter()
 	// List all users (admin only — enforced by auth gate)

package/backend/ws/chat/background.ts

@@ -7,9 +7,9 @@
 
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { streamManager } from '../../lib/chat/stream-manager';
+import { streamManager } from '../../chat/stream-manager';
 import { debug } from '$shared/utils/logger';
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 
 export const backgroundHandler = createRouter()
 	// Start background stream (fire-and-forget)

package/backend/ws/chat/stream.ts

@@ -9,11 +9,11 @@
 
 import { t } from 'elysia';
 import { createRouter } from '$shared/utils/ws-server';
-import { streamManager, type StreamEvent } from '../../lib/chat/stream-manager';
+import { streamManager, type StreamEvent } from '../../chat/stream-manager';
 import { debug } from '$shared/utils/logger';
-import { ws } from '$backend/lib/utils/ws';
+import { ws } from '$backend/utils/ws';
 import { broadcastPresence } from '../projects/status';
-import { sessionQueries, messageQueries } from '../../lib/database/queries';
+import { sessionQueries, messageQueries } from '../../database/queries';
 
 // ============================================================================
 // Global stream lifecycle handler (module-level, not per-connection)