@myrialabs/clopen 0.2.5 → 0.2.7

package/backend/chat/stream-manager.ts

@@ -41,6 +41,7 @@ export interface StreamState {
 	abortController?: AbortController;
 	streamPromise?: Promise<void>;
 	sdkSessionId?: string;
+	preStreamSdkSessionId?: string | null; // latest_sdk_session_id before this stream started
 	hasCompactBoundary?: boolean;
 	eventSeq: number; // Sequence number for deduplication
 }
@@ -132,7 +133,17 @@ class StreamManager extends EventEmitter {
 			const existingStream = this.activeStreams.get(existingStreamId);
 			if (existingStream && existingStream.status === 'active') {
 				if (existingStream.projectId === request.projectId) {
-					return existingStreamId;
+					if ((request.engine || 'claude-code') === 'claude-code') {
+						// Claude Code: cancel existing stream to prevent message loss from race condition.
+						// Claude Code SDK only returns session_id inside yielded messages, so a cancelled
+						// stream may never have established a valid session — safe to cancel and restart.
+						debug.log('chat', `Cancelling existing active stream ${existingStreamId} before starting new one`);
+						await this.cancelStream(existingStreamId);
+					} else {
+						// Other engines (OpenCode): return existing stream ID (original behavior).
+						// OpenCode creates sessions synchronously, so the existing stream is valid.
+						return existingStreamId;
+					}
 				}
 			}
 		}
@@ -302,6 +313,9 @@ class StreamManager extends EventEmitter {
 				}
 			}
 
+			// Store pre-stream session ID so cancelStream() can restore it
+			streamState.preStreamSdkSessionId = resumeSessionId ?? null;
+
 			// Prepare user message
 			const userMessage = {
 				...(prompt as SDKMessage),
@@ -378,10 +392,102 @@ class StreamManager extends EventEmitter {
 				return;
 			}
 
+			// Detect orphaned user messages and prepend context (claude-code only).
+			// When a stream is cancelled before the SDK returns a session_id,
+			// the user's message is saved to DB but unknown to the SDK session.
+			// We prepend those orphaned messages as context so the AI has full history.
+			let enginePrompt = prompt;
+			if (engineType === 'claude-code' && chatSessionId) {
+				try {
+					const head = sessionQueries.getHead(chatSessionId);
+					if (head) {
+						const chain = messageQueries.getPathToRoot(head);
+						// Remove the current user message (last in chain, just saved)
+						const previousChain = chain.slice(0, -1);
+
+						if (previousChain.length > 0) {
+							// Find boundary: last message with session_id matching resumeSessionId
+							let boundaryIndex = -1;
+
+							if (resumeSessionId) {
+								for (let i = previousChain.length - 1; i >= 0; i--) {
+									try {
+										const sdk = JSON.parse(previousChain[i].sdk_message);
+										if (sdk.session_id === resumeSessionId) {
+											boundaryIndex = i;
+											break;
+										}
+									} catch { /* skip unparseable */ }
+								}
+							}
+
+							// Collect orphaned user messages after boundary
+							const orphanedUserTexts: string[] = [];
+							for (let i = boundaryIndex + 1; i < previousChain.length; i++) {
+								try {
+									const sdk = JSON.parse(previousChain[i].sdk_message);
+									if (sdk.type === 'user') {
+										const content = sdk.message?.content;
+										let text = '';
+										if (typeof content === 'string') {
+											text = content;
+										} else if (Array.isArray(content)) {
+											text = content
+												.filter((block: any) => block.type === 'text')
+												.map((block: any) => block.text)
+												.join('\n');
+										}
+										if (text.trim()) {
+											orphanedUserTexts.push(text.trim());
+										}
+									}
+								} catch { /* skip unparseable */ }
+							}
+
+							// Prepend context if there are orphaned messages
+							if (orphanedUserTexts.length > 0) {
+								debug.log('chat', `Prepending ${orphanedUserTexts.length} orphaned user message(s) as context`);
+
+								const contextPrefix = [
+									'[Previous unprocessed messages from the user:]',
+									...orphanedUserTexts.map((text, i) => `${i + 1}. "${text}"`),
+									'',
+									'[Current message:]'
+								].join('\n');
+
+								const originalContent = prompt.message.content;
+								let modifiedContent: typeof originalContent;
+
+								if (typeof originalContent === 'string') {
+									modifiedContent = contextPrefix + '\n' + originalContent;
+								} else if (Array.isArray(originalContent)) {
+									modifiedContent = [
+										{ type: 'text' as const, text: contextPrefix },
+										...originalContent
+									];
+								} else {
+									modifiedContent = originalContent;
+								}
+
+								enginePrompt = {
+									...prompt,
+									message: {
+										...prompt.message,
+										content: modifiedContent
+									}
+								} as SDKUserMessage;
+							}
+						}
+					}
+				} catch (error) {
+					debug.error('chat', 'Failed to detect orphaned messages:', error);
+				}
+			}
+
 			// Stream messages through the engine adapter
 			for await (const message of engine.streamQuery({
 				projectPath: actualProjectPath,
-				prompt: prompt,
+				prompt: enginePrompt,
 				resume: resumeSessionId,
 				model: model || 'sonnet',
 				includePartialMessages: true,
@@ -1009,15 +1115,28 @@ class StreamManager extends EventEmitter {
 			}
 		}
 
-		// Abort the stream-manager's controller FIRST.
-		// This ensures processStream() sees the abort signal at its next check point
-		// and avoids starting a new engine query with an already-aborted controller.
-		streamState.abortController?.abort();
+		// Claude Code only: restore latest_sdk_session_id to pre-stream value.
+		// Claude Code SDK only returns session_id inside yielded messages, so a cancelled
+		// stream's fork session_id is not a valid resume target. OpenCode creates sessions
+		// synchronously, so its session_id is always valid — no restoration needed.
+		if (streamState.engine === 'claude-code' && streamState.chatSessionId && streamState.preStreamSdkSessionId !== undefined) {
+			try {
+				if (streamState.preStreamSdkSessionId) {
+					sessionQueries.updateLatestSdkSessionId(streamState.chatSessionId, streamState.preStreamSdkSessionId);
+				} else {
+					sessionQueries.clearLatestSdkSessionId(streamState.chatSessionId);
+				}
+				debug.log('chat', `Restored latest_sdk_session_id to: ${streamState.preStreamSdkSessionId || 'null'}`);
+			} catch (error) {
+				debug.error('chat', 'Failed to restore latest_sdk_session_id:', error);
+			}
+		}
 
-		// Cancel the per-project engine — this is safe because each project
-		// has its own engine instance (via getProjectEngine), so cancel()
-		// only affects this project's active query/session, not other projects.
-		// Wrapped in try/catch to prevent SDK errors from crashing the server.
+		// Cancel the per-project engine — this sends an interrupt to the
+		// still-alive SDK subprocess, then aborts the controller. If we abort
+		// the controller first, the subprocess dies and the SDK's subsequent
+		// interrupt write fails with "Operation aborted" (unhandled rejection
+		// that crashes Bun).
 		const projectId = streamState.projectId || 'default';
 		try {
 			const engine = getProjectEngine(projectId, streamState.engine);
@@ -1028,6 +1147,13 @@ class StreamManager extends EventEmitter {
 			debug.error('chat', 'Error cancelling engine (non-fatal):', error);
 		}
 
+		// Abort the stream-manager's controller as a fallback.
+		// engine.cancel() already aborts the same controller, so this is
+		// typically a no-op but ensures cleanup if the engine wasn't active.
+		if (!streamState.abortController?.signal.aborted) {
+			streamState.abortController?.abort();
+		}
+
 		this.emitStreamEvent(streamState, 'cancelled', {
 			processId: streamState.processId,
 			timestamp: streamState.completedAt.toISOString()

package/backend/database/queries/session-queries.ts

@@ -66,6 +66,15 @@ export const sessionQueries = {
 		`).run(sdkSessionId, id);
 	},
 
+	clearLatestSdkSessionId(id: string): void {
+		const db = getDatabase();
+		db.prepare(`
+			UPDATE chat_sessions
+			SET latest_sdk_session_id = NULL
+			WHERE id = ?
+		`).run(id);
+	},
+
 	updateEngineModel(id: string, engine: string, model: string): void {
 		const db = getDatabase();
 		db.prepare(`

package/backend/engine/adapters/claude/error-handler.ts

@@ -3,8 +3,13 @@ export function handleStreamError(error: unknown): void {
     throw error;
   }
 
-  // Abort errors are expected during cancellation - don't re-throw
-  if (error.name === 'AbortError' || error.message.includes('aborted') || error.message.includes('abort')) {
+  // Abort errors are expected during cancellation - don't re-throw.
+  // "Operation aborted" comes from the SDK's internal write() when the
+  // subprocess is killed during handleControlRequest.
+  if (error.name === 'AbortError'
+    || error.message.includes('aborted')
+    || error.message.includes('abort')
+    || error.message === 'Operation aborted') {
     return;
   }
 

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

@@ -180,21 +180,30 @@ export class ClaudeCodeEngine implements AIEngine {
    * Cancel active query
    */
   async cancel(): Promise<void> {
-    if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+    // Resolve all pending AskUserQuestion promises before terminating.
+    for (const [, pending] of this.pendingUserAnswers) {
+      pending.resolve({ behavior: 'deny', message: 'Cancelled' });
+    }
+    this.pendingUserAnswers.clear();
+
+    // Use close() to forcefully terminate the query process and clean up
+    // all resources (docs: "Forcefully ends the query and cleans up all
+    // resources"). Unlike interrupt() which can hang indefinitely when the
+    // subprocess is unresponsive, close() is synchronous and guaranteed to
+    // complete — making cancel deterministic.
+    if (this.activeQuery && typeof this.activeQuery.close === 'function') {
       try {
-        await this.activeQuery.interrupt();
+        this.activeQuery.close();
       } catch {
-        // Ignore interrupt errors
+        // Ignore close errors — process may already be dead
       }
     }
 
-    if (this.activeController) {
+    if (this.activeController && !this.activeController.signal.aborted) {
       this.activeController.abort();
-      this.activeController = null;
     }
+    this.activeController = null;
     this.activeQuery = null;
-    // Reject all pending user answer promises (abort signal handles this, but clean up the map)
-    this.pendingUserAnswers.clear();
   }
 
   /**

package/backend/index.ts

@@ -180,10 +180,32 @@ process.on('SIGTERM', gracefulShutdown);
 // Safety net: prevent server crash from unhandled errors.
 // These can occur when AI engine SDKs emit asynchronous errors that bypass
 // the normal try/catch flow (e.g., subprocess killed during initialization).
-process.on('unhandledRejection', (reason) => {
-	debug.error('server', 'Unhandled promise rejection (server still running):', reason);
+//
+// IMPORTANT: Use the Web API (globalThis.addEventListener) instead of Node's
+// process.on('unhandledRejection') because Bun only respects event.preventDefault()
+// from the Web API to suppress the default crash behavior.
+globalThis.addEventListener('unhandledrejection', (event: PromiseRejectionEvent) => {
+	// preventDefault() is the ONLY way to prevent Bun from exiting on unhandled rejections.
+	// process.on('unhandledRejection') alone does NOT prevent the crash in Bun 1.3.x.
+	event.preventDefault();
+
+	try {
+		const reason = event.reason;
+		const message = reason instanceof Error ? reason.message : String(reason);
+		if (message.includes('Operation aborted') || message.includes('aborted')) {
+			debug.warn('server', 'Suppressed expected SDK abort rejection:', message);
+			return;
+		}
+		debug.error('server', 'Unhandled promise rejection (server still running):', reason);
+	} catch {
+		console.error('Unhandled promise rejection (server still running)');
+	}
 });
 
 process.on('uncaughtException', (error) => {
-	debug.error('server', 'Uncaught exception (server still running):', error);
+	try {
+		debug.error('server', 'Uncaught exception (server still running):', error);
+	} catch {
+		console.error('Uncaught exception (server still running)');
+	}
 });

package/backend/mcp/servers/browser-automation/browser.ts

@@ -89,10 +89,26 @@ interface CloseTabResponse {
  * Internal helper: Get active tab
  * Throws error if no active tab found
  * Automatically acquires MCP control for the active tab to ensure UI sync
+ *
+ * If MCP is already controlling a specific tab, that tab is returned regardless
+ * of which tab the user has currently active in the frontend. This prevents MCP
+ * from "following" the user when they switch tabs mid-session.
  */
 export async function getActiveTabSession(projectId?: string) {
-	// Get active tab directly from backend tab manager
 	const previewService = getPreviewService(projectId);
+
+	// If MCP is already controlling a specific tab, stick to that tab.
+	// This prevents user tab-switching from hijacking the MCP session.
+	const controlState = browserMcpControl.getControlState();
+	if (controlState.isControlling && controlState.browserTabId) {
+		const controlledTab = previewService.getTab(controlState.browserTabId);
+		if (controlledTab) {
+			debug.log('mcp', `🎮 Using MCP-controlled tab: ${controlledTab.id} (ignoring active tab)`);
+			return { tab: controlledTab, session: controlledTab };
+		}
+	}
+
+	// No controlled tab — use the active tab and acquire control
 	const tab = previewService.getActiveTab();
 
 	if (!tab) {
@@ -101,8 +117,9 @@ export async function getActiveTabSession(projectId?: string) {
 
 	// Acquire control for active tab (ensures UI sync after idle timeout)
 	// This is idempotent - if already controlling this tab, just updates timestamp
-	if (!browserMcpControl.isTabControlled(tab.id)) {
-		const acquired = browserMcpControl.acquireControl(tab.id);
+	const resolvedProjectId = previewService.getProjectId();
+	if (!browserMcpControl.isTabControlled(tab.id, resolvedProjectId)) {
+		const acquired = browserMcpControl.acquireControl(tab.id, undefined, resolvedProjectId);
 		if (acquired) {
 			debug.log('mcp', `🔄 Auto-acquired control for tab ${tab.id} (resumed after idle)`);
 		}
@@ -189,7 +206,7 @@ export async function switchTabHandler(args: { tabId: string; projectId?: string
 		// Update MCP control to the new tab
 		if (tab) {
 			browserMcpControl.releaseControl();
-			browserMcpControl.acquireControl(tab.id);
+			browserMcpControl.acquireControl(tab.id, undefined, previewService.getProjectId());
 		}
 
 		// Update last action to keep control alive
@@ -244,7 +261,7 @@ export async function openNewTabHandler(args: { url?: string; deviceSize?: 'desk
 
 		// Auto-acquire control of the new tab
 		browserMcpControl.releaseControl();
-		browserMcpControl.acquireControl(tab.id);
+		browserMcpControl.acquireControl(tab.id, undefined, previewService.getProjectId());
 
 		// Update last action to keep control alive
 		browserMcpControl.updateLastAction();
@@ -296,7 +313,7 @@ export async function closeTabHandler(args: { tabId: string; projectId?: string
 		if (result.newActiveTabId) {
 			const newActiveTab = previewService.getTab(result.newActiveTabId);
 			if (newActiveTab) {
-				browserMcpControl.acquireControl(newActiveTab.id);
+				browserMcpControl.acquireControl(newActiveTab.id, undefined, previewService.getProjectId());
 			}
 		}
 

package/backend/preview/browser/browser-mcp-control.ts

@@ -28,6 +28,7 @@ export interface McpControlState {
 	isControlling: boolean;
 	mcpSessionId: string | null;
 	browserTabId: string | null;
+	projectId: string | null;
 	startedAt: number | null;
 	lastActionAt: number | null;
 }
@@ -60,6 +61,7 @@ export class BrowserMcpControl extends EventEmitter {
 		isControlling: false,
 		mcpSessionId: null,
 		browserTabId: null,
+		projectId: null,
 		startedAt: null,
 		lastActionAt: null
 	};
@@ -96,13 +98,16 @@ export class BrowserMcpControl extends EventEmitter {
 
 	/**
 	 * Handle tab destroyed event
-	 * Auto-release control if the destroyed tab was being controlled
+	 * Auto-release control if the destroyed tab was being controlled.
+	 * Uses the service's projectId to avoid cross-project false-positives.
 	 */
 	private handleTabDestroyed(tabId: string): void {
-		if (this.controlState.isControlling && this.controlState.browserTabId === tabId) {
-			debug.warn('mcp', `⚠️ Controlled tab ${tabId} was destroyed - auto-releasing control`);
-			this.releaseControl();
-		}
+		if (!this.controlState.isControlling || this.controlState.browserTabId !== tabId) return;
+		// Validate project to prevent cross-project collisions (tab IDs are not globally unique)
+		const serviceProjectId = this.previewService?.getProjectId();
+		if (serviceProjectId && this.controlState.projectId && this.controlState.projectId !== serviceProjectId) return;
+		debug.warn('mcp', `⚠️ Controlled tab ${tabId} was destroyed - auto-releasing control`);
+		this.releaseControl();
 	}
 
 	/**
@@ -167,18 +172,25 @@ export class BrowserMcpControl extends EventEmitter {
 	}
 
 	/**
-	 * Check if a specific browser tab is being controlled
+	 * Check if a specific browser tab is being controlled.
+	 * When projectId is provided, also validates the project to prevent cross-project
+	 * false-positives (tab IDs are only unique per project, not globally).
 	 */
-	isTabControlled(browserTabId: string): boolean {
-		return this.controlState.isControlling &&
-			   this.controlState.browserTabId === browserTabId;
+	isTabControlled(browserTabId: string, projectId?: string): boolean {
+		if (!this.controlState.isControlling || this.controlState.browserTabId !== browserTabId) {
+			return false;
+		}
+		if (projectId && this.controlState.projectId && this.controlState.projectId !== projectId) {
+			return false;
+		}
+		return true;
 	}
 
 	/**
 	 * Acquire control of a browser tab
 	 * Returns true if control was acquired, false if already controlled by another MCP
 	 */
-	acquireControl(browserTabId: string, mcpSessionId?: string): boolean {
+	acquireControl(browserTabId: string, mcpSessionId?: string, projectId?: string): boolean {
 		// Validate tab exists before acquiring control
 		if (this.previewService && !this.previewService.getTab(browserTabId)) {
 			debug.warn('mcp', `❌ Cannot acquire control: tab ${browserTabId} does not exist`);
@@ -204,6 +216,7 @@ export class BrowserMcpControl extends EventEmitter {
 			isControlling: true,
 			mcpSessionId: mcpSessionId || null,
 			browserTabId,
+			projectId: projectId || null,
 			startedAt: now,
 			lastActionAt: now
 		};
@@ -238,6 +251,7 @@ export class BrowserMcpControl extends EventEmitter {
 			isControlling: false,
 			mcpSessionId: null,
 			browserTabId: null,
+			projectId: null,
 			startedAt: null,
 			lastActionAt: null
 		};
@@ -380,13 +394,14 @@ export class BrowserMcpControl extends EventEmitter {
 	}
 
 	/**
-	 * Auto-release control for a specific browser tab (called when tab closes)
+	 * Auto-release control for a specific browser tab (called when tab closes).
+	 * projectId is used to prevent accidental release across projects with same tab IDs.
 	 */
-	autoReleaseForTab(browserTabId: string): void {
-		if (this.controlState.isControlling && this.controlState.browserTabId === browserTabId) {
-			debug.log('mcp', `🗑️ Auto-releasing MCP control for closed tab: ${browserTabId}`);
-			this.releaseControl(browserTabId);
-		}
+	autoReleaseForTab(browserTabId: string, projectId?: string): void {
+		if (!this.controlState.isControlling || this.controlState.browserTabId !== browserTabId) return;
+		if (projectId && this.controlState.projectId && this.controlState.projectId !== projectId) return;
+		debug.log('mcp', `🗑️ Auto-releasing MCP control for closed tab: ${browserTabId}`);
+		this.releaseControl(browserTabId);
 	}
 
 	/**
@@ -403,6 +418,7 @@ export class BrowserMcpControl extends EventEmitter {
 			isControlling: false,
 			mcpSessionId: null,
 			browserTabId: null,
+			projectId: null,
 			startedAt: null,
 			lastActionAt: null
 		};

package/backend/preview/browser/browser-pool.ts

@@ -49,7 +49,9 @@ const DEFAULT_CONFIG: PoolConfig = {
 const CHROMIUM_ARGS = [
 	'--no-sandbox',
 	'--disable-blink-features=AutomationControlled',
-	'--window-size=1366,768'
+	'--window-size=1366,768',
+	'--autoplay-policy=no-user-gesture-required',
+	'--disable-features=AudioServiceOutOfProcess'
 ];
 
 class BrowserPool {

package/backend/preview/browser/browser-preview-service.ts

@@ -103,17 +103,15 @@ export class BrowserPreviewService extends EventEmitter {
 			if (this.videoCapture.isStreaming(sessionId)) {
 				const tab = this.getTab(sessionId);
 				if (tab) {
-					// Small delay to ensure page is fully loaded
-					setTimeout(async () => {
-						try {
-							const success = await this.videoCapture.handleNavigation(sessionId, tab);
-							if (success) {
-								this.emit('preview:browser-navigation-streaming-ready', { sessionId });
-							}
-						} catch (error) {
-							// Silently fail - frontend will request refresh if needed
+					// Restart streaming immediately — page is already navigated
+					try {
+						const success = await this.videoCapture.handleNavigation(sessionId, tab);
+						if (success) {
+							this.emit('preview:browser-navigation-streaming-ready', { sessionId });
 						}
-					}, 100);
+					} catch (error) {
+						// Silently fail - frontend will request refresh if needed
+					}
 				}
 			}
 		});
@@ -214,14 +212,15 @@ export class BrowserPreviewService extends EventEmitter {
 			preNavigationSetup
 		});
 
-		// Setup console and navigation tracking
-		await this.consoleManager.setupConsoleLogging(tab.id, tab.page, tab);
-		await this.navigationTracker.setupNavigationTracking(tab.id, tab.page, tab);
+		// Setup console, navigation tracking, and pre-inject streaming scripts in parallel
+		await Promise.all([
+			this.consoleManager.setupConsoleLogging(tab.id, tab.page, tab),
+			this.navigationTracker.setupNavigationTracking(tab.id, tab.page, tab),
+		]);
 
-		// Setup dialog bindings and handling
-		// Temporarily disable dialog injection to test CloudFlare evasion
-		// await this.dialogHandler.setupDialogBindings(tab.id, tab.page);
-		// await this.dialogHandler.setupDialogHandling(tab.id, tab.page, tab);
+		// Pre-inject WebCodecs scripts so startStreaming() is fast (~50-80ms vs ~200-350ms)
+		// Fire-and-forget: failure here is non-fatal, startStreaming() will retry injection
+		this.videoCapture.preInjectScripts(tab.id, tab).catch(() => {});
 
 		return tab;
 	}

package/backend/preview/browser/browser-tab-manager.ts

@@ -273,7 +273,7 @@ export class BrowserTabManager extends EventEmitter {
 		const wasActive = tab.isActive;
 
 		// Auto-release MCP control if this tab is being controlled
-		browserMcpControl.autoReleaseForTab(tabId);
+		browserMcpControl.autoReleaseForTab(tabId, this.projectId);
 
 		// IMMEDIATELY set destroyed flag and stop streaming
 		tab.isDestroyed = true;