@myrialabs/clopen 0.2.1 → 0.2.3

package/frontend/{lib/services → services}/notification/global-stream-monitor.ts

@@ -1,117 +1,117 @@
-/**
- * Global Stream Monitor Service
- *
- * Single source of truth for chat stream notifications (sound + push).
- *
- * Listens for backend events and triggers notifications for ALL projects —
- * both active and non-active:
- * - chat:stream-finished  → stream completed/errored/cancelled
- * - chat:waiting-input    → AskUserQuestion requires user input
- *
- * The backend uses ws.emit.projectMembers() so notifications reach users
- * even when they are on a different project or session.
- */
-
-import { soundNotification, pushNotification } from '$frontend/lib/services/notification';
-import { projectState } from '$frontend/lib/stores/core/projects.svelte';
-import { debug } from '$shared/utils/logger';
-import ws from '$frontend/lib/utils/ws';
-
-class GlobalStreamMonitor {
-  private initialized = false;
-
-  /** Track notified AskUserQuestion tool_use IDs to ensure once-only notification */
-  private notifiedToolUseIds = new Set<string>();
-
-  /**
-   * Initialize the monitor - subscribes to WS events.
-   * Safe to call multiple times (idempotent).
-   */
-  initialize(): void {
-    if (this.initialized) return;
-    this.initialized = true;
-
-    debug.log('notification', 'GlobalStreamMonitor: Initializing WS listeners');
-
-    // Stream finished — notify on completion
-    ws.on('chat:stream-finished', async (data) => {
-      const { projectId, status, chatSessionId } = data;
-
-      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status });
-
-      // Clean up notified IDs for this session (stream is done)
-      this.clearSessionNotifications(chatSessionId);
-
-      // Play sound notification
-      try {
-        await soundNotification.play();
-      } catch (error) {
-        debug.error('notification', 'Error playing sound notification:', error);
-      }
-
-      // Send push notification with project context
-      try {
-        const projectName = projectState.projects.find(p => p.id === projectId)?.name || 'Unknown';
-
-        if (status === 'completed') {
-          await pushNotification.sendChatComplete(`Chat response ready in "${projectName}"`);
-        } else if (status === 'error') {
-          await pushNotification.sendChatError(`Chat error in "${projectName}"`);
-        } else if (status === 'cancelled') {
-          await pushNotification.sendChatComplete(`Chat interrupted in "${projectName}"`);
-        }
-      } catch (error) {
-        debug.error('notification', 'Error sending push notification:', error);
-      }
-    });
-
-    // Waiting for input — notify once per AskUserQuestion
-    ws.on('chat:waiting-input', async (data) => {
-      const { projectId, chatSessionId, toolUseId } = data;
-
-      // Deduplicate: only notify once per tool_use ID
-      if (this.notifiedToolUseIds.has(toolUseId)) return;
-      this.notifiedToolUseIds.add(toolUseId);
-
-      debug.log('notification', 'GlobalStreamMonitor: Waiting for input', { projectId, chatSessionId, toolUseId });
-
-      // Play sound notification
-      try {
-        await soundNotification.play();
-      } catch (error) {
-        debug.error('notification', 'Error playing sound notification:', error);
-      }
-
-      // Send push notification
-      try {
-        const projectName = projectState.projects.find(p => p.id === projectId)?.name || 'Unknown';
-        await pushNotification.sendChatComplete(`Waiting for your input in "${projectName}"`);
-      } catch (error) {
-        debug.error('notification', 'Error sending push notification:', error);
-      }
-    });
-  }
-
-  /**
-   * Remove tracked tool_use IDs for a finished session
-   */
-  private clearSessionNotifications(chatSessionId: string): void {
-    // Tool IDs are globally unique, so a simple clear-on-stream-finish
-    // is enough — they won't collide across sessions.
-    // For long-running apps, periodically trim to avoid unbounded growth.
-    if (this.notifiedToolUseIds.size > 500) {
-      this.notifiedToolUseIds.clear();
-    }
-  }
-
-  /**
-   * Clear state (for cleanup/testing)
-   */
-  clear(): void {
-    this.notifiedToolUseIds.clear();
-    debug.log('notification', 'GlobalStreamMonitor: Clearing state');
-  }
-}
-
-// Export singleton instance
-export const globalStreamMonitor = new GlobalStreamMonitor();
+/**
+ * Global Stream Monitor Service
+ *
+ * Single source of truth for chat stream notifications (sound + push).
+ *
+ * Listens for backend events and triggers notifications for ALL projects —
+ * both active and non-active:
+ * - chat:stream-finished  → stream completed/errored/cancelled
+ * - chat:waiting-input    → AskUserQuestion requires user input
+ *
+ * The backend uses ws.emit.projectMembers() so notifications reach users
+ * even when they are on a different project or session.
+ */
+
+import { soundNotification, pushNotification } from '$frontend/services/notification';
+import { projectState } from '$frontend/stores/core/projects.svelte';
+import { debug } from '$shared/utils/logger';
+import ws from '$frontend/utils/ws';
+
+class GlobalStreamMonitor {
+  private initialized = false;
+
+  /** Track notified AskUserQuestion tool_use IDs to ensure once-only notification */
+  private notifiedToolUseIds = new Set<string>();
+
+  /**
+   * Initialize the monitor - subscribes to WS events.
+   * Safe to call multiple times (idempotent).
+   */
+  initialize(): void {
+    if (this.initialized) return;
+    this.initialized = true;
+
+    debug.log('notification', 'GlobalStreamMonitor: Initializing WS listeners');
+
+    // Stream finished — notify on completion
+    ws.on('chat:stream-finished', async (data) => {
+      const { projectId, status, chatSessionId } = data;
+
+      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status });
+
+      // Clean up notified IDs for this session (stream is done)
+      this.clearSessionNotifications(chatSessionId);
+
+      // Play sound notification
+      try {
+        await soundNotification.play();
+      } catch (error) {
+        debug.error('notification', 'Error playing sound notification:', error);
+      }
+
+      // Send push notification with project context
+      try {
+        const projectName = projectState.projects.find(p => p.id === projectId)?.name || 'Unknown';
+
+        if (status === 'completed') {
+          await pushNotification.sendChatComplete(`Chat response ready in "${projectName}"`);
+        } else if (status === 'error') {
+          await pushNotification.sendChatError(`Chat error in "${projectName}"`);
+        } else if (status === 'cancelled') {
+          await pushNotification.sendChatComplete(`Chat interrupted in "${projectName}"`);
+        }
+      } catch (error) {
+        debug.error('notification', 'Error sending push notification:', error);
+      }
+    });
+
+    // Waiting for input — notify once per AskUserQuestion
+    ws.on('chat:waiting-input', async (data) => {
+      const { projectId, chatSessionId, toolUseId } = data;
+
+      // Deduplicate: only notify once per tool_use ID
+      if (this.notifiedToolUseIds.has(toolUseId)) return;
+      this.notifiedToolUseIds.add(toolUseId);
+
+      debug.log('notification', 'GlobalStreamMonitor: Waiting for input', { projectId, chatSessionId, toolUseId });
+
+      // Play sound notification
+      try {
+        await soundNotification.play();
+      } catch (error) {
+        debug.error('notification', 'Error playing sound notification:', error);
+      }
+
+      // Send push notification
+      try {
+        const projectName = projectState.projects.find(p => p.id === projectId)?.name || 'Unknown';
+        await pushNotification.sendChatComplete(`Waiting for your input in "${projectName}"`);
+      } catch (error) {
+        debug.error('notification', 'Error sending push notification:', error);
+      }
+    });
+  }
+
+  /**
+   * Remove tracked tool_use IDs for a finished session
+   */
+  private clearSessionNotifications(chatSessionId: string): void {
+    // Tool IDs are globally unique, so a simple clear-on-stream-finish
+    // is enough — they won't collide across sessions.
+    // For long-running apps, periodically trim to avoid unbounded growth.
+    if (this.notifiedToolUseIds.size > 500) {
+      this.notifiedToolUseIds.clear();
+    }
+  }
+
+  /**
+   * Clear state (for cleanup/testing)
+   */
+  clear(): void {
+    this.notifiedToolUseIds.clear();
+    debug.log('notification', 'GlobalStreamMonitor: Clearing state');
+  }
+}
+
+// Export singleton instance
+export const globalStreamMonitor = new GlobalStreamMonitor();

package/frontend/{lib/services → services}/notification/push.service.ts

@@ -4,7 +4,7 @@
  * Handles native browser push notifications for chat responses
  */
 
-import { settings } from '$frontend/lib/stores/features/settings.svelte';
+import { settings } from '$frontend/stores/features/settings.svelte';
 
 import { debug } from '$shared/utils/logger';
 // Check if browser supports notifications

package/frontend/{lib/services → services}/notification/sound.service.ts

@@ -4,7 +4,7 @@
  * Handles single audio notification for chat responses using local notification.ogg file
  */
 
-import { settings } from '$frontend/lib/stores/features/settings.svelte';
+import { settings } from '$frontend/stores/features/settings.svelte';
 
 import { debug } from '$shared/utils/logger';
 // Cache for audio element

package/frontend/{lib/services → services}/preview/browser/browser-console.service.ts

@@ -1,5 +1,5 @@
 import { debug } from '$shared/utils/logger';
-import ws from '$frontend/lib/utils/ws';
+import ws from '$frontend/utils/ws';
 
 export interface ConsoleMessage {
 	id: string;

package/frontend/{lib/services → services}/preview/browser/browser-webcodecs.service.ts

@@ -14,7 +14,7 @@
  * 7. Render video to canvas, play audio
  */
 
-import ws from '$frontend/lib/utils/ws';
+import ws from '$frontend/utils/ws';
 import { debug } from '$shared/utils/logger';
 
 export interface BrowserWebCodecsStreamStats {

package/frontend/{lib/services → services}/preview/browser/mcp-integration.svelte.ts

@@ -5,8 +5,8 @@
  * opens the preview panel to display the session visually.
  */
 
-import ws from '$frontend/lib/utils/ws';
-import { showPanel } from '$frontend/lib/stores/ui/workspace.svelte';
+import ws from '$frontend/utils/ws';
+import { showPanel } from '$frontend/stores/ui/workspace.svelte';
 import { debug } from '$shared/utils/logger';
 
 export interface MCPLaunchRequest {

package/frontend/{lib/services → services}/project/status.service.ts

@@ -1,160 +1,160 @@
-/**
- * Project Status Service
- * Tracks active streams and user presence for projects via WebSocket
- * Fully realtime - no cache, no polling
- *
- * Single event: `projects:presence-updated` contains full state
- */
-
-import { getOrCreateAnonymousUser, type AnonymousUser } from '$shared/utils/anonymous-user';
-import ws from '$frontend/lib/utils/ws';
-import { debug } from '$shared/utils/logger';
-
-export interface ProjectStatus {
-  projectId: string;
-  hasActiveStreams: boolean;
-  activeStreamCount: number;
-  activeUsers: { userId: string; userName: string }[];
-  streams: {
-    streamId: string;
-    chatSessionId: string;
-    status: string;
-    startedAt: string;
-    messagesCount: number;
-    isWaitingInput?: boolean;
-  }[];
-  /** Per-chat-session user presence: { chatSessionId → users[] } */
-  chatSessionUsers?: Record<string, { userId: string; userName: string }[]>;
-}
-
-class ProjectStatusService {
-  private currentUser: AnonymousUser | null = null;
-  private currentProjectId: string | null = null;
-  private initialized = false;
-  private statusUpdateCallbacks: Set<(statuses: ProjectStatus[]) => void> = new Set();
-  private unsubscribe: (() => void) | null = null;
-
-  /**
-   * Initialize the service - sets up WS listener
-   * Called automatically on first use
-   */
-  async initialize(): Promise<void> {
-    if (typeof window === 'undefined' || this.initialized) return;
-
-    this.currentUser = await getOrCreateAnonymousUser();
-    debug.log('project', 'Initialized with user:', this.currentUser?.name);
-
-    this.unsubscribe = ws.on('projects:presence-updated', (data) => {
-      try {
-        if (data.type === 'presence-updated' && data.data) {
-          const statuses = Array.isArray(data.data) ? data.data : [data.data];
-          this.statusUpdateCallbacks.forEach(callback => {
-            try {
-              callback(statuses);
-            } catch (error) {
-              debug.error('project', 'Error in status callback:', error);
-            }
-          });
-        }
-      } catch (error) {
-        debug.error('project', 'Error handling presence update:', error);
-      }
-    });
-
-    this.initialized = true;
-  }
-
-  private async ensureInitialized(): Promise<void> {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-  }
-
-  /**
-   * Subscribe to real-time presence updates
-   * Auto-initializes WS listener if not done yet
-   */
-  onStatusUpdate(callback: (statuses: ProjectStatus[]) => void): () => void {
-    this.statusUpdateCallbacks.add(callback);
-    this.ensureInitialized();
-
-    return () => {
-      this.statusUpdateCallbacks.delete(callback);
-    };
-  }
-
-  /**
-   * Join a project - start presence tracking
-   */
-  async startTracking(projectId: string): Promise<void> {
-    if (typeof window === 'undefined') return;
-
-    await this.ensureInitialized();
-
-    if (this.currentProjectId && this.currentProjectId !== projectId) {
-      await this.stopTracking();
-    }
-
-    this.currentProjectId = projectId;
-
-    if (this.currentUser) {
-      ws.emit('projects:join', {
-        userName: this.currentUser.name
-      });
-    }
-
-    document.addEventListener('visibilitychange', this.handleVisibilityChange);
-    window.addEventListener('beforeunload', this.handleBeforeUnload);
-  }
-
-  /**
-   * Leave a project - stop presence tracking
-   */
-  async stopTracking(): Promise<void> {
-    if (this.currentProjectId && this.currentUser) {
-      // Send projectId explicitly because ws.setProject() may have already changed context
-      ws.emit('projects:leave', {
-        projectId: this.currentProjectId
-      });
-    }
-
-    if (typeof window !== 'undefined') {
-      document.removeEventListener('visibilitychange', this.handleVisibilityChange);
-      window.removeEventListener('beforeunload', this.handleBeforeUnload);
-    }
-
-    this.currentProjectId = null;
-  }
-
-  cleanup(): void {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    this.statusUpdateCallbacks.clear();
-    this.initialized = false;
-  }
-
-  private handleVisibilityChange = () => {
-    if (!document.hidden && this.currentProjectId && this.currentUser) {
-      ws.http('projects:update-presence', {
-        userName: this.currentUser.name,
-        action: 'update'
-      }).catch(() => {});
-    }
-  };
-
-  private handleBeforeUnload = () => {
-    if (this.currentProjectId && this.currentUser) {
-      ws.emit('projects:leave', {
-        projectId: this.currentProjectId
-      });
-    }
-  };
-
-  getCurrentUser(): AnonymousUser | null {
-    return this.currentUser;
-  }
-}
-
-export const projectStatusService = new ProjectStatusService();
+/**
+ * Project Status Service
+ * Tracks active streams and user presence for projects via WebSocket
+ * Fully realtime - no cache, no polling
+ *
+ * Single event: `projects:presence-updated` contains full state
+ */
+
+import { getOrCreateAnonymousUser, type AnonymousUser } from '$shared/utils/anonymous-user';
+import ws from '$frontend/utils/ws';
+import { debug } from '$shared/utils/logger';
+
+export interface ProjectStatus {
+  projectId: string;
+  hasActiveStreams: boolean;
+  activeStreamCount: number;
+  activeUsers: { userId: string; userName: string }[];
+  streams: {
+    streamId: string;
+    chatSessionId: string;
+    status: string;
+    startedAt: string;
+    messagesCount: number;
+    isWaitingInput?: boolean;
+  }[];
+  /** Per-chat-session user presence: { chatSessionId → users[] } */
+  chatSessionUsers?: Record<string, { userId: string; userName: string }[]>;
+}
+
+class ProjectStatusService {
+  private currentUser: AnonymousUser | null = null;
+  private currentProjectId: string | null = null;
+  private initialized = false;
+  private statusUpdateCallbacks: Set<(statuses: ProjectStatus[]) => void> = new Set();
+  private unsubscribe: (() => void) | null = null;
+
+  /**
+   * Initialize the service - sets up WS listener
+   * Called automatically on first use
+   */
+  async initialize(): Promise<void> {
+    if (typeof window === 'undefined' || this.initialized) return;
+
+    this.currentUser = await getOrCreateAnonymousUser();
+    debug.log('project', 'Initialized with user:', this.currentUser?.name);
+
+    this.unsubscribe = ws.on('projects:presence-updated', (data) => {
+      try {
+        if (data.type === 'presence-updated' && data.data) {
+          const statuses = Array.isArray(data.data) ? data.data : [data.data];
+          this.statusUpdateCallbacks.forEach(callback => {
+            try {
+              callback(statuses);
+            } catch (error) {
+              debug.error('project', 'Error in status callback:', error);
+            }
+          });
+        }
+      } catch (error) {
+        debug.error('project', 'Error handling presence update:', error);
+      }
+    });
+
+    this.initialized = true;
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * Subscribe to real-time presence updates
+   * Auto-initializes WS listener if not done yet
+   */
+  onStatusUpdate(callback: (statuses: ProjectStatus[]) => void): () => void {
+    this.statusUpdateCallbacks.add(callback);
+    this.ensureInitialized();
+
+    return () => {
+      this.statusUpdateCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * Join a project - start presence tracking
+   */
+  async startTracking(projectId: string): Promise<void> {
+    if (typeof window === 'undefined') return;
+
+    await this.ensureInitialized();
+
+    if (this.currentProjectId && this.currentProjectId !== projectId) {
+      await this.stopTracking();
+    }
+
+    this.currentProjectId = projectId;
+
+    if (this.currentUser) {
+      ws.emit('projects:join', {
+        userName: this.currentUser.name
+      });
+    }
+
+    document.addEventListener('visibilitychange', this.handleVisibilityChange);
+    window.addEventListener('beforeunload', this.handleBeforeUnload);
+  }
+
+  /**
+   * Leave a project - stop presence tracking
+   */
+  async stopTracking(): Promise<void> {
+    if (this.currentProjectId && this.currentUser) {
+      // Send projectId explicitly because ws.setProject() may have already changed context
+      ws.emit('projects:leave', {
+        projectId: this.currentProjectId
+      });
+    }
+
+    if (typeof window !== 'undefined') {
+      document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+      window.removeEventListener('beforeunload', this.handleBeforeUnload);
+    }
+
+    this.currentProjectId = null;
+  }
+
+  cleanup(): void {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    this.statusUpdateCallbacks.clear();
+    this.initialized = false;
+  }
+
+  private handleVisibilityChange = () => {
+    if (!document.hidden && this.currentProjectId && this.currentUser) {
+      ws.http('projects:update-presence', {
+        userName: this.currentUser.name,
+        action: 'update'
+      }).catch(() => {});
+    }
+  };
+
+  private handleBeforeUnload = () => {
+    if (this.currentProjectId && this.currentUser) {
+      ws.emit('projects:leave', {
+        projectId: this.currentProjectId
+      });
+    }
+  };
+
+  getCurrentUser(): AnonymousUser | null {
+    return this.currentUser;
+  }
+}
+
+export const projectStatusService = new ProjectStatusService();

package/frontend/{lib/services → services}/snapshot/snapshot.service.ts

@@ -5,8 +5,8 @@
  * v2 adds conflict detection and session-scoped restore.
  */
 
-import ws from '$frontend/lib/utils/ws';
-import type { TimelineResponse } from '$frontend/lib/components/checkpoint/timeline/types';
+import ws from '$frontend/utils/ws';
+import type { TimelineResponse } from '$frontend/components/checkpoint/timeline/types';
 
 /**
  * Conflict information for a single file

package/frontend/{lib/services → services}/terminal/background/index.ts

@@ -5,7 +5,7 @@
 
 import { terminalSessionManager } from '../session.service';
 import { terminalPersistenceManager } from '../persistence.service';
-import { terminalStore } from '$frontend/lib/stores/features/terminal.svelte';
+import { terminalStore } from '$frontend/stores/features/terminal.svelte';
 
 // Import modular services
 import { streamManager } from './stream-manager';

package/frontend/{lib/services → services}/terminal/background/session-restore.ts

@@ -5,7 +5,7 @@
 
 import { terminalSessionManager } from '../session.service';
 import { terminalPersistenceManager } from '../persistence.service';
-import { terminalStore } from '$frontend/lib/stores/features/terminal.svelte';
+import { terminalStore } from '$frontend/stores/features/terminal.svelte';
 
 interface SessionToReconnect {
 	sessionId: string;

package/frontend/{lib/services → services}/terminal/background/stream-manager.ts

@@ -5,7 +5,7 @@
 
 import { terminalSessionManager } from '../session.service';
 import { terminalPersistenceManager } from '../persistence.service';
-import { terminalStore } from '$frontend/lib/stores/features/terminal.svelte';
+import { terminalStore } from '$frontend/stores/features/terminal.svelte';
 import type { TerminalLine } from '$shared/types/terminal';
 
 export interface StreamInfo {