@myrialabs/clopen 0.2.12 → 0.2.13

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/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/terminal/persistence.ts

@@ -33,49 +33,38 @@ export const persistenceHandler = createRouter()
 		return status;
 	})
 
-	// Get missed output
+	// Get missed output (serialized terminal state)
 	.http('terminal:missed-output', {
 		data: t.Object({
 			sessionId: t.String(),
-			streamId: t.Optional(t.String()),
-			fromIndex: t.Optional(t.Number())
+			streamId: t.Optional(t.String())
 		}),
 		response: t.Object({
 			sessionId: t.String(),
 			streamId: t.Union([t.String(), t.Null()]),
-			output: t.Array(t.String()),
-			outputCount: t.Number(),
+			output: t.String(),
 			status: t.String(),
-			fromIndex: t.Number(),
 			timestamp: t.String()
 		})
 	}, async ({ data }) => {
-		const { sessionId, streamId, fromIndex = 0 } = data;
+		const { sessionId, streamId } = data;
 
-		// Try to get output from stream manager (memory or cache)
-		let output: string[] = [];
+		// Get serialized terminal state from headless xterm
+		let output = '';
 
 		if (streamId) {
-			// If streamId is provided, get output from that specific stream
-			output = terminalStreamManager.getOutput(streamId, fromIndex);
+			output = terminalStreamManager.getSerializedOutput(streamId);
 		} else {
-			// Otherwise try to load cached output for the session
-			const cachedOutput = terminalStreamManager.loadCachedOutput(sessionId);
-			if (cachedOutput) {
-				output = cachedOutput.slice(fromIndex);
-			}
+			output = terminalStreamManager.getSerializedOutputBySession(sessionId);
 		}
 
-		// Get stream status if available
 		const streamStatus = streamId ? terminalStreamManager.getStreamStatus(streamId) : null;
 
 		return {
 			sessionId,
 			streamId: streamId || null,
 			output,
-			outputCount: output.length,
 			status: streamStatus?.status || 'unknown',
-			fromIndex,
 			timestamp: new Date().toISOString()
 		};
 	})
@@ -84,11 +73,10 @@ export const persistenceHandler = createRouter()
 	.on('terminal:reconnect', {
 		data: t.Object({
 			streamId: t.String(),
-			sessionId: t.String(),
-			fromIndex: t.Optional(t.Number())
+			sessionId: t.String()
 		})
 	}, async ({ data, conn }) => {
-		const { streamId, sessionId, fromIndex = 0 } = data;
+		const { streamId, sessionId } = data;
 		const projectId = ws.getProjectId(conn);
 
 		const stream = terminalStreamManager.getStream(streamId);
@@ -102,17 +90,15 @@ export const persistenceHandler = createRouter()
 		}
 
 		try {
-			// Broadcast missed output (frontend filters by sessionId for one-time replay)
-			const existingOutput = terminalStreamManager.getOutput(streamId, fromIndex);
-
-			if (existingOutput.length > 0) {
-				for (const output of existingOutput) {
-					ws.emit.project(projectId, 'terminal:output', {
-						sessionId,
-						content: output,
-						timestamp: new Date().toISOString()
-					});
-				}
+			// Send serialized terminal state (frontend writes it to xterm to restore)
+			const serializedOutput = terminalStreamManager.getSerializedOutput(streamId);
+
+			if (serializedOutput) {
+				ws.emit.project(projectId, 'terminal:output', {
+					sessionId,
+					content: serializedOutput,
+					timestamp: new Date().toISOString()
+				});
 			}
 
 			if (stream.status === 'active') {