@myrialabs/clopen 0.2.12 → 0.2.14

package/backend/chat/stream-manager.ts

@@ -495,6 +495,9 @@ class StreamManager extends EventEmitter {
 				includePartialMessages: true,
 				abortController: streamState.abortController,
 				...(claudeAccountId !== undefined && { claudeAccountId }),
+				...(projectId && chatSessionId && {
+					mcpContext: { projectId, chatSessionId, streamId: streamState.streamId }
+				}),
 			});
 
 			await projectContextService.runWithContextAsync(

package/backend/engine/adapters/claude/stream.ts

@@ -90,7 +90,8 @@ export class ClaudeCodeEngine implements AIEngine {
 
     try {
       // Get custom MCP servers and allowed tools
-      const mcpServers = getEnabledMcpServers();
+      // Pass mcpContext so tool handlers are bound to the correct project
+      const mcpServers = getEnabledMcpServers(options.mcpContext);
       const allowedMcpTools = getAllowedMcpTools();
 
       debug.log('mcp', '📦 Loading custom MCP servers...');

package/backend/engine/types.ts

@@ -11,6 +11,13 @@ import type { EngineType, EngineModel } from '$shared/types/engine';
 
 export type { EngineType, EngineModel };
 
+/** Execution context for MCP tool handlers (project isolation) */
+export interface McpExecutionContext {
+	projectId?: string;
+	chatSessionId?: string;
+	streamId?: string;
+}
+
 /** Options passed to engine.streamQuery() */
 export interface EngineQueryOptions {
 	projectPath: string;
@@ -22,6 +29,8 @@ export interface EngineQueryOptions {
 	includePartialMessages?: boolean;
 	abortController?: AbortController;
 	claudeAccountId?: number;
+	/** Context bound to MCP tool handlers for project isolation */
+	mcpContext?: McpExecutionContext;
 }
 
 /** Options for one-shot structured generation (no tools, no streaming) */

package/backend/mcp/config.ts

@@ -5,10 +5,12 @@
  * to avoid duplication and make it easier to add new servers.
  */
 
-import type { McpSdkServerConfigWithInstance, McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import { createSdkMcpServer, tool, type McpSdkServerConfigWithInstance, type McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import type { McpRemoteConfig } from '@opencode-ai/sdk';
 import type { ServerConfig, ParsedMcpToolName, ServerName } from './types';
-import { serverRegistry, serverFactories } from './servers';
+import type { McpExecutionContext } from '../engine/types';
+import { serverRegistry, serverFactories, serverMetadata } from './servers';
+import { projectContextService } from './project-context';
 import { debug } from '$shared/utils/logger';
 import { SERVER_ENV } from '../utils/env';
 
@@ -87,15 +89,39 @@ export const mcpServers: Record<string, ServerConfig & { instance: McpSdkServerC
  *
  * Creates FRESH server instances each call so that concurrent streams
  * each get their own Protocol — avoids "Already connected to a transport" errors.
+ *
+ * When `context` is provided, tool handlers are wrapped to restore the
+ * AsyncLocalStorage execution context. This is required because the SDK
+ * invokes MCP tool handlers through IPC which breaks AsyncLocalStorage
+ * propagation — without this, background streams from Project A would
+ * resolve to Project B's preview browser when the user switches projects.
  */
-export function getEnabledMcpServers(): Record<string, McpServerConfig> {
+export function getEnabledMcpServers(context?: McpExecutionContext): Record<string, McpServerConfig> {
 	const enabledServers: Record<string, McpServerConfig> = {};
 
 	Object.entries(mcpServers).forEach(([serverName, serverConfig]) => {
 		if (serverConfig.enabled) {
-			const factory = serverFactories[serverName as ServerName];
-			enabledServers[serverName] = factory ? factory() : serverConfig.instance;
-			debug.log('mcp', `✓ Enabled MCP server: ${serverName}`);
+			if (context) {
+				// Create context-bound instance: wrap each tool handler so
+				// AsyncLocalStorage context is restored on invocation
+				const meta = serverMetadata[serverName as ServerName];
+				const sdkTools = (serverConfig.tools as readonly string[]).map(toolName => {
+					const def = meta.toolDefs[toolName];
+					const boundHandler = async (args: any) => {
+						return projectContextService.runWithContextAsync(context, () => def.handler(args));
+					};
+					return tool(toolName, def.description, def.schema, boundHandler as any);
+				});
+				enabledServers[serverName] = createSdkMcpServer({
+					name: meta.name,
+					version: '1.0.0',
+					tools: sdkTools
+				});
+			} else {
+				const factory = serverFactories[serverName as ServerName];
+				enabledServers[serverName] = factory ? factory() : serverConfig.instance;
+			}
+			debug.log('mcp', `✓ Enabled MCP server: ${serverName}${context ? ' (context-bound)' : ''}`);
 		} else {
 			debug.log('mcp', `✗ Disabled MCP server: ${serverName}`);
 		}

package/backend/snapshot/snapshot-service.ts

@@ -479,9 +479,6 @@ export class SnapshotService {
 			let restoredFiles = 0;
 			let skippedFiles = 0;
 
-			// Update in-memory baseline as we restore
-			const baseline = this.sessionBaselines.get(sessionId) || {};
-
 			for (const [filepath, expectedHash] of expectedState) {
 				// Check conflict resolution
 				if (conflictResolutions && conflictResolutions[filepath] === 'keep') {
@@ -509,7 +506,6 @@ export class SnapshotService {
 					// File should not exist at the target → delete it
 					try {
 						await fs.unlink(fullPath);
-						delete baseline[filepath];
 						debug.log('snapshot', `Deleted: ${filepath}`);
 						restoredFiles++;
 					} catch {
@@ -522,7 +518,6 @@ export class SnapshotService {
 						const dir = path.dirname(fullPath);
 						await fs.mkdir(dir, { recursive: true });
 						await fs.writeFile(fullPath, content);
-						baseline[filepath] = expectedHash;
 						debug.log('snapshot', `Restored: ${filepath}`);
 						restoredFiles++;
 					} catch (err) {
@@ -532,8 +527,15 @@ export class SnapshotService {
 				}
 			}
 
-			// Update in-memory baseline to reflect restored state
-			this.sessionBaselines.set(sessionId, baseline);
+			// Force re-initialize baseline from actual disk state.
+			// This is critical because:
+			// 1. Files already at expected state were skipped (baseline not updated for them)
+			// 2. After server restart, baseline starts empty — only restored files get entries
+			// 3. Files not mentioned in any snapshot are missing from the partial baseline
+			// Without this, subsequent captures would compute oldHash='' for files missing
+			// from the baseline, causing future restores to incorrectly delete those files.
+			this.sessionBaselines.delete(sessionId);
+			await this.initializeSessionBaseline(projectPath, sessionId);
 
 			debug.log('snapshot', `Restore complete: ${restoredFiles} restored, ${skippedFiles} skipped`);
 			return { restoredFiles, skippedFiles };

package/backend/terminal/stream-manager.ts

@@ -1,12 +1,12 @@
 /**
  * Terminal Stream Manager
  * Manages background terminal streams and their state
+ * Uses @xterm/headless to maintain accurate terminal state in-memory
  */
 
 import type { IPty } from 'bun-pty';
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'fs';
-import { join } from 'path';
-import { getClopenDir } from '../utils/paths';
+import { Terminal } from '@xterm/headless';
+import { SerializeAddon } from '@xterm/addon-serialize';
 
 interface TerminalStream {
   streamId: string;
@@ -18,23 +18,30 @@ interface TerminalStream {
   workingDirectory?: string;
   projectPath?: string;
   projectId?: string;
-  output: string[];
   processId?: number;
-  outputStartIndex?: number; // Track where new output starts (for background output)
+  headlessTerminal: Terminal;
+  serializeAddon: SerializeAddon;
 }
 
 class TerminalStreamManager {
   private streams: Map<string, TerminalStream> = new Map();
   private sessionToStream: Map<string, string> = new Map();
-  private tempDir: string = join(getClopenDir(), 'terminal-cache');
 
-  constructor() {
-    // Create temp directory for output caching
-    if (!existsSync(this.tempDir)) {
-      mkdirSync(this.tempDir, { recursive: true });
-    }
+  /**
+   * Create a headless terminal instance with serialize addon
+   */
+  private createHeadlessTerminal(cols: number, rows: number): { terminal: Terminal; serializeAddon: SerializeAddon } {
+    const terminal = new Terminal({
+      scrollback: 1000,
+      cols,
+      rows,
+      allowProposedApi: true
+    });
+    const serializeAddon = new SerializeAddon();
+    terminal.loadAddon(serializeAddon);
+    return { terminal, serializeAddon };
   }
-  
+
   /**
    * Create a new terminal stream
    */
@@ -46,26 +53,45 @@ class TerminalStreamManager {
     projectPath?: string,
     projectId?: string,
     predefinedStreamId?: string,
-    outputStartIndex?: number
+    terminalSize?: { cols: number; rows: number }
   ): string {
+    const cols = terminalSize?.cols || 80;
+    const rows = terminalSize?.rows || 24;
+
     // Check if there's already a stream for this session
     const existingStreamId = this.sessionToStream.get(sessionId);
-    let preservedOutput: string[] = [];
     if (existingStreamId) {
       const existingStream = this.streams.get(existingStreamId);
       if (existingStream) {
-        if (existingStream.pty && existingStream.pty !== pty) {
-          // Different PTY, kill the old one
+        if (existingStream.pty === pty) {
+          // Same PTY (reconnection) - reuse existing headless terminal as-is
+          // The headless terminal already has all accumulated output
+          const newStreamId = predefinedStreamId || existingStreamId;
+
+          // Resize headless terminal if dimensions changed
+          existingStream.headlessTerminal.resize(cols, rows);
+
+          // Update stream ID if changed
+          if (newStreamId !== existingStreamId) {
+            this.streams.delete(existingStreamId);
+            existingStream.streamId = newStreamId;
+            this.streams.set(newStreamId, existingStream);
+            this.sessionToStream.set(sessionId, newStreamId);
+          }
+
+          return newStreamId;
+        }
+
+        // Different PTY, kill the old one and dispose headless terminal
+        if (existingStream.pty) {
           try {
             existingStream.pty.kill();
-          } catch (error) {
+          } catch {
             // Ignore error if PTY already killed
           }
-        } else if (existingStream.pty === pty) {
-          // Same PTY (reconnection after browser refresh) - preserve output buffer
-          preservedOutput = [...existingStream.output];
         }
-        // Remove the old stream
+        existingStream.serializeAddon.dispose();
+        existingStream.headlessTerminal.dispose();
         this.streams.delete(existingStreamId);
       }
     }
@@ -73,6 +99,9 @@ class TerminalStreamManager {
     // Use provided streamId or generate a new one
     const streamId = predefinedStreamId || `terminal-stream-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
+    // Create headless terminal
+    const { terminal: headlessTerminal, serializeAddon } = this.createHeadlessTerminal(cols, rows);
+
     const stream: TerminalStream = {
       streamId,
       sessionId,
@@ -83,9 +112,9 @@ class TerminalStreamManager {
       workingDirectory,
       projectPath,
       projectId,
-      output: preservedOutput,
       processId: pty.pid,
-      outputStartIndex: outputStartIndex || 0
+      headlessTerminal,
+      serializeAddon
     };
 
     this.streams.set(streamId, stream);
@@ -93,14 +122,14 @@ class TerminalStreamManager {
 
     return streamId;
   }
-  
+
   /**
    * Get stream by ID
    */
   getStream(streamId: string): TerminalStream | undefined {
     return this.streams.get(streamId);
   }
-  
+
   /**
    * Get stream by session ID
    */
@@ -111,121 +140,65 @@ class TerminalStreamManager {
     }
     return undefined;
   }
-  
+
   /**
-   * Add output to stream
+   * Add output to stream (writes to headless terminal)
    */
   addOutput(streamId: string, output: string): void {
     const stream = this.streams.get(streamId);
     if (stream) {
-      stream.output.push(output);
-
-      // Keep only last 2000 entries to prevent memory overflow
-      if (stream.output.length > 2000) {
-        stream.output = stream.output.slice(-2000);
-      }
-
-      // Also persist output to disk for background persistence
-      this.persistOutputToDisk(stream);
+      stream.headlessTerminal.write(output);
     }
   }
 
-  /** Pending write flag to coalesce rapid writes */
-  private pendingWrites = new Set<string>();
-
   /**
-   * Persist output to disk for cross-project persistence (async, coalesced)
+   * Get serialized terminal output for a stream
    */
-  private persistOutputToDisk(stream: TerminalStream): void {
-    // Coalesce rapid writes - only schedule one write per session per microtask
-    if (this.pendingWrites.has(stream.sessionId)) return;
-    this.pendingWrites.add(stream.sessionId);
-
-    queueMicrotask(() => {
-      this.pendingWrites.delete(stream.sessionId);
-
-      try {
-        const cacheFile = join(this.tempDir, `${stream.sessionId}.json`);
-
-        // Only save new output (from outputStartIndex onwards)
-        const newOutput = stream.outputStartIndex !== undefined
-          ? stream.output.slice(stream.outputStartIndex)
-          : stream.output;
-
-        const cacheData = {
-          streamId: stream.streamId,
-          sessionId: stream.sessionId,
-          command: stream.command,
-          projectId: stream.projectId,
-          projectPath: stream.projectPath,
-          workingDirectory: stream.workingDirectory,
-          startedAt: stream.startedAt,
-          status: stream.status,
-          output: newOutput,
-          outputStartIndex: stream.outputStartIndex || 0,
-          lastUpdated: new Date().toISOString()
-        };
-
-        // Use Bun.write for non-blocking async disk write
-        Bun.write(cacheFile, JSON.stringify(cacheData)).catch(() => {
-          // Silently handle write errors
-        });
-      } catch {
-        // Silently handle errors
-      }
-    });
+  getSerializedOutput(streamId: string): string {
+    const stream = this.streams.get(streamId);
+    if (stream) {
+      return stream.serializeAddon.serialize();
+    }
+    return '';
   }
 
   /**
-   * Load cached output from disk (public method for API access)
+   * Get serialized terminal output by session ID
    */
-  loadCachedOutput(sessionId: string): string[] | null {
-    try {
-      const cacheFile = join(this.tempDir, `${sessionId}.json`);
-      if (existsSync(cacheFile)) {
-        const data = JSON.parse(readFileSync(cacheFile, 'utf-8'));
-        return data.output || [];
-      }
-    } catch (error) {
-      // Silently handle read errors
+  getSerializedOutputBySession(sessionId: string): string {
+    const streamId = this.sessionToStream.get(sessionId);
+    if (streamId) {
+      return this.getSerializedOutput(streamId);
     }
-    return null;
+    return '';
   }
-  
+
   /**
-   * Get output from index
+   * Clear headless terminal buffer (sync with frontend clear)
    */
-  getOutput(streamId: string, fromIndex: number = 0): string[] {
-    const stream = this.streams.get(streamId);
-    if (stream) {
-      return stream.output.slice(fromIndex);
-    }
-
-    // If stream not in memory, try to load from cache
-    // This handles cases where server restarts or stream is cleaned from memory
-    const sessionId = this.getSessionIdByStreamId(streamId);
-    if (sessionId) {
-      const cachedOutput = this.loadCachedOutput(sessionId);
-      if (cachedOutput) {
-        return cachedOutput.slice(fromIndex);
+  clearHeadlessTerminal(sessionId: string): void {
+    const streamId = this.sessionToStream.get(sessionId);
+    if (streamId) {
+      const stream = this.streams.get(streamId);
+      if (stream) {
+        stream.headlessTerminal.clear();
       }
     }
-
-    return [];
   }
 
   /**
-   * Get session ID from stream ID (helper method)
+   * Resize headless terminal to match PTY dimensions
    */
-  private getSessionIdByStreamId(streamId: string): string | null {
-    for (const [sessionId, sid] of this.sessionToStream.entries()) {
-      if (sid === streamId) {
-        return sessionId;
+  resizeHeadlessTerminal(sessionId: string, cols: number, rows: number): void {
+    const streamId = this.sessionToStream.get(sessionId);
+    if (streamId) {
+      const stream = this.streams.get(streamId);
+      if (stream) {
+        stream.headlessTerminal.resize(cols, rows);
       }
     }
-    return null;
   }
-  
+
   /**
    * Update stream status
    */
@@ -233,7 +206,7 @@ class TerminalStreamManager {
     const stream = this.streams.get(streamId);
     if (stream) {
       stream.status = status;
-      
+
       // Clean up completed/cancelled streams after a delay
       if (status === 'completed' || status === 'cancelled' || status === 'error') {
         // Keep stream for 5 minutes for reconnection attempts
@@ -243,9 +216,9 @@ class TerminalStreamManager {
       }
     }
   }
-  
+
   /**
-   * Remove stream
+   * Remove stream and dispose headless terminal
    */
   removeStream(streamId: string): void {
     const stream = this.streams.get(streamId);
@@ -254,33 +227,27 @@ class TerminalStreamManager {
       if (stream.status === 'active' && stream.pty) {
         try {
           stream.pty.kill();
-        } catch (error) {
+        } catch {
           // Silently handle error
         }
       }
 
-      // Clean up cache file
-      try {
-        const cacheFile = join(this.tempDir, `${stream.sessionId}.json`);
-        if (existsSync(cacheFile)) {
-          unlinkSync(cacheFile);
-        }
-      } catch (error) {
-        // Silently handle error
-      }
+      // Dispose headless terminal
+      stream.serializeAddon.dispose();
+      stream.headlessTerminal.dispose();
 
       // Remove from maps
       this.streams.delete(streamId);
       this.sessionToStream.delete(stream.sessionId);
     }
   }
-  
+
   /**
    * Get stream status info
    */
   getStreamStatus(streamId: string): {
     status: string;
-    messagesCount: number;
+    bufferLength: number;
     startedAt: Date;
     processId?: number;
   } | null {
@@ -288,51 +255,35 @@ class TerminalStreamManager {
     if (!stream) {
       return null;
     }
-    
+
     return {
       status: stream.status,
-      messagesCount: stream.output.length,
+      bufferLength: stream.headlessTerminal.buffer.active.length,
       startedAt: stream.startedAt,
       processId: stream.processId
     };
   }
-  
+
   /**
-   * Clean up terminal cache files for a specific project
+   * Clean up terminal streams for a specific project
    */
-  cleanupProjectCache(projectId: string): number {
-    let deleted = 0;
-    try {
-      const files = readdirSync(this.tempDir);
-      for (const file of files) {
-        if (!file.endsWith('.json')) continue;
-        try {
-          const filePath = join(this.tempDir, file);
-          const data = JSON.parse(readFileSync(filePath, 'utf-8'));
-          if (data.projectId === projectId) {
-            unlinkSync(filePath);
-            deleted++;
-          }
-        } catch {
-          // Skip unreadable files
-        }
-      }
-    } catch {
-      // Directory may not exist
-    }
+  cleanupProjectStreams(projectId: string): number {
+    let cleaned = 0;
 
-    // Also remove in-memory streams for this project
     for (const [streamId, stream] of this.streams) {
       if (stream.projectId === projectId) {
         if (stream.status === 'active' && stream.pty) {
           try { stream.pty.kill(); } catch {}
         }
+        stream.serializeAddon.dispose();
+        stream.headlessTerminal.dispose();
         this.streams.delete(streamId);
         this.sessionToStream.delete(stream.sessionId);
+        cleaned++;
       }
     }
 
-    return deleted;
+    return cleaned;
   }
 
   /**
@@ -346,4 +297,4 @@ class TerminalStreamManager {
 }
 
 // Export singleton instance
-export const terminalStreamManager = new TerminalStreamManager();
+export const terminalStreamManager = new TerminalStreamManager();

package/backend/ws/projects/crud.ts

@@ -106,9 +106,9 @@ export const crudHandler = createRouter()
 
 		const mode = data.mode ?? 'remove';
 
-		// Clean up terminal cache for this project
-		const cachedTerminals = terminalStreamManager.cleanupProjectCache(data.id);
-		debug.log('project', `Cleaned up ${cachedTerminals} terminal cache files for project ${data.id}`);
+		// Clean up terminal streams for this project
+		const cleanedStreams = terminalStreamManager.cleanupProjectStreams(data.id);
+		debug.log('project', `Cleaned up ${cleanedStreams} terminal streams for project ${data.id}`);
 
 		if (mode === 'full') {
 			// Full delete: remove sessions with blob cleanup, then the project itself

package/backend/ws/snapshot/timeline.ts

@@ -126,9 +126,13 @@ export const timelineHandler = createRouter()
 			const isOnActivePath = activePathIds.has(cp.id);
 			const isCurrent = cp.id === activeCheckpointId;
 
-			// Orphaned = descendant of active checkpoint in the checkpoint tree
+			// Orphaned = in the "future" relative to the current checkpoint.
+			// At initial state: ALL checkpoints are orphaned (we've gone back before any messages).
+			// Otherwise: only descendants of the active checkpoint that are not on the active path.
 			let isOrphaned = false;
-			if (activeCheckpointId && !isOnActivePath) {
+			if (isAtInitialState) {
+				isOrphaned = true;
+			} else if (activeCheckpointId && !isOnActivePath) {
 				isOrphaned = isDescendant(cp.id, activeCheckpointId, childrenMap);
 			}