@myrialabs/clopen 0.2.5 → 0.2.6

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 FIRST — 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,7 +180,19 @@ 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 aborting.
+    // This lets the SDK process the denial responses while the subprocess
+    // is still alive, preventing "Operation aborted" write errors.
+    for (const [, pending] of this.pendingUserAnswers) {
+      pending.resolve({ behavior: 'deny', message: 'Cancelled' });
+    }
+    this.pendingUserAnswers.clear();
+
+    // Only interrupt if the controller hasn't been aborted yet.
+    // Interrupting after abort causes the SDK to write to a dead subprocess,
+    // resulting in "Operation aborted" unhandled rejections that crash Bun.
+    if (this.activeQuery && typeof this.activeQuery.interrupt === 'function'
+        && this.activeController && !this.activeController.signal.aborted) {
       try {
         await this.activeQuery.interrupt();
       } catch {
@@ -188,13 +200,19 @@ export class ClaudeCodeEngine implements AIEngine {
       }
     }
 
+    // Brief delay between interrupt and abort to let the SDK flush pending
+    // write operations (e.g., handleControlRequest responses). Without this,
+    // aborting immediately after interrupt kills the subprocess while the SDK
+    // still has in-flight writes, causing "Operation aborted" rejections.
+    if (this.activeController && !this.activeController.signal.aborted) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
     if (this.activeController) {
       this.activeController.abort();
       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/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;
 	}