@myrialabs/clopen 0.2.11 → 0.2.13

package/frontend/services/chat/chat.service.ts

@@ -43,16 +43,14 @@ class ChatService {
 
   static loadingTexts: string[] = [
     'thinking', 'processing', 'analyzing', 'calculating', 'computing',
-    'strategizing', 'learningpatterns', 'updatingweights', 'finetuning',
-    'adaptingmodels', 'trainingnetworks', 'evaluatingoptions', 'planningactions',
-    'executingplans', 'simulatingscenarios', 'predictingoutcomes', 'scanningenvironment',
-    'monitoringsignals', 'processinginputs', 'adjustingparameters', 'optimizing',
-    'generatingresponses', 'refininglogic', 'recognizingpatterns', 'synthesizinginformation',
-    'runninginference', 'validatingoutputs', 'modulatingresponse', 'updatingmemory',
-    'switchingcontext', 'resolvingconflicts', 'allocatingresources', 'prioritizingtasks',
-    'developingawareness', 'buildingstrategies', 'assessingscenarios', 'integratingdata',
-    'bootingreasoning', 'activatingmodules', 'triggeringaction', 'deployinglogic',
-    'maintainingstate', 'clearingcache', 'updating', 'reflecting', 'syncinglogic',
+    'strategizing', 'learningpatterns', 'adaptingmodels', 'evaluatingoptions',
+    'executingplans', 'simulatingscenarios', 'predictingoutcomes', 'planningactions',
+    'processinginputs', 'optimizing', 'generatingresponses', 'refininglogic', 
+    'validatingoutputs', 'modulatingresponse', 'updatingmemory', 'recognizingpatterns',
+    'switchingcontext', 'allocatingresources', 'prioritizingtasks',
+    'developingawareness', 'buildingstrategies', 'assessingscenarios',
+    'bootingreasoning', 'triggeringaction', 'deployinglogic', 'synthesizinginformation',
+    'maintainingstate', 'updating', 'reflecting', 'syncinglogic',
     'connectingdots', 'compilingideas', 'brainstorming', 'schedulingtasks'
   ].map(text => text + '...');
 
@@ -482,11 +480,11 @@ class ChatService {
     // and global flags — cancel sets isCancelling=true to prevent presence re-enabling
     this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: true }, chatSessionId);
 
-    // Clean up stale stream_events from the cancelled stream.
-    // Without this, stale stream_events remain in the messages array and cause
-    // wrong insertion positions when a new stream starts (e.g., reasoning inserted
-    // before a stale non-reasoning stream_event instead of at the end).
-    this.cleanupStreamEvents();
+    // Convert stream_events to finalized assistant messages on cancel.
+    // This preserves partial reasoning/text that was visible to the user.
+    // Empty stream_events are removed. The backend saves partial text to DB
+    // independently, so on refresh the DB version takes over.
+    this.finalizeStreamEvents();
 
     // Safety timeout: if backend events (chat:cancelled + presence update) don't
     // arrive within 10 seconds, force-clear isCancelling to prevent infinite loader.
@@ -581,15 +579,32 @@ class ChatService {
         }
         // If no reasoning stream_event found, fall through to push at end
       } else {
-        // Remove ALL regular (non-reasoning) stream_events, not just the last one
-        // This prevents stale stream_events from remaining when message order varies
+        // Replace text stream_event IN PLACE to preserve message position
+        // (same approach as reasoning — prevents visual displacement)
         for (let i = sessionState.messages.length - 1; i >= 0; i--) {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && !msg.metadata?.reasoning) {
-            sessionState.messages.splice(i, 1);
-            break; // Only remove the most recent one
+            const messageFormatter = {
+              ...sdkMessage,
+              metadata: buildMetadataFromTransport(data)
+            };
+            sessionState.messages[i] = messageFormatter;
+
+            // Detect interactive tool_use blocks in the replaced message
+            if (sdkMessage.type === 'assistant' && sdkMessage.message?.content) {
+              const content = Array.isArray(sdkMessage.message.content) ? sdkMessage.message.content : [];
+              const hasInteractiveTool = content.some(
+                (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name)
+              );
+              if (hasInteractiveTool) {
+                this.setProcessState({ isWaitingInput: true });
+              }
+            }
+
+            return; // Replaced in-place, skip push below
           }
         }
+        // No stream_event found, fall through to push at end
       }
     }
 
@@ -723,7 +738,7 @@ class ChatService {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && msg.metadata?.reasoning) {
             msg.partialText = partialText || '';
-            break;
+            return;
           }
         }
       } else {
@@ -733,17 +748,42 @@ class ChatService {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && !msg.metadata?.reasoning) {
             msg.partialText = partialText || '';
-            break;
+            return;
           }
         }
       }
+
+      // Fallback: no matching stream_event found (start event was missed).
+      // Create one now so text doesn't get lost.
+      const fallbackMessage = {
+        type: 'stream_event' as const,
+        processId: data.processId,
+        partialText: partialText || '',
+        metadata: buildMetadataFromTransport({
+          timestamp: data.timestamp,
+          ...(isReasoning && { reasoning: true }),
+        })
+      };
+
+      if (isReasoning) {
+        const textStreamIdx = (sessionState.messages as any[]).findIndex(
+          (m: any) => m.type === 'stream_event' && !m.metadata?.reasoning
+        );
+        if (textStreamIdx >= 0) {
+          (sessionState.messages as any[]).splice(textStreamIdx, 0, fallbackMessage);
+        } else {
+          (sessionState.messages as any[]).push(fallbackMessage);
+        }
+      } else {
+        (sessionState.messages as any[]).push(fallbackMessage);
+      }
     }
     // Note: 'end' event is not needed - streaming message will be replaced by final message in handleMessageEvent
   }
 
   /**
    * Remove all stream_event messages from the messages array.
-   * Called on cancel and new message send to prevent stale streaming
+   * Called on new message send to prevent stale streaming
    * placeholders from causing wrong insertion positions.
    */
   private cleanupStreamEvents(): void {
@@ -754,6 +794,36 @@ class ChatService {
     }
   }
 
+  /**
+   * Convert stream_event messages with text to finalized assistant messages.
+   * Called on cancel to preserve partial reasoning/text that was visible.
+   * Empty stream_events (no text) are removed.
+   * The backend saves these to DB independently, so on refresh the DB version takes over.
+   */
+  private finalizeStreamEvents(): void {
+    for (let i = sessionState.messages.length - 1; i >= 0; i--) {
+      const msg = sessionState.messages[i] as any;
+      if (msg.type !== 'stream_event') continue;
+
+      if (msg.partialText) {
+        const isReasoning = msg.metadata?.reasoning === true;
+        sessionState.messages[i] = {
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [{ type: 'text', text: msg.partialText }]
+          },
+          metadata: {
+            ...msg.metadata,
+            ...(isReasoning && { reasoning: true }),
+          }
+        } as any;
+      } else {
+        sessionState.messages.splice(i, 1);
+      }
+    }
+  }
+
   /**
    * Detect whether any interactive tool (e.g. AskUserQuestion) is pending in the current messages.
    * Used after browser refresh / catchup to restore the isWaitingInput state.
@@ -774,10 +844,11 @@ class ChatService {
       }
     }
 
-    // Check if any interactive tool is unanswered
+    // Check if any interactive tool is unanswered (skip interrupted/cancelled messages)
     for (const msg of sessionState.messages) {
       const msgAny = msg as any;
       if (msgAny.type !== 'assistant' || !msgAny.message?.content) continue;
+      if (msgAny.metadata?.interrupted) continue;
       const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
       const hasPendingInteractive = content.some(
         (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name) && item.id && !answeredToolIds.has(item.id)

package/frontend/services/notification/global-stream-monitor.ts

@@ -35,13 +35,16 @@ class GlobalStreamMonitor {
 
     // Stream finished — notify on completion
     ws.on('chat:stream-finished', async (data) => {
-      const { projectId, status, chatSessionId } = data;
+      const { projectId, status, chatSessionId, reason } = data;
 
-      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status });
+      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status, reason });
 
       // Clean up notified IDs for this session (stream is done)
       this.clearSessionNotifications(chatSessionId);
 
+      // Skip notifications when stream was cancelled due to session deletion
+      if (reason === 'session-deleted') return;
+
       // Play sound notification
       try {
         await soundNotification.play();

package/frontend/services/terminal/project.service.ts

@@ -262,66 +262,10 @@ class TerminalProjectManager {
 					}
 				}
 
-				// Restore saved output for this session
-				let baseOutput: any[] = [];
-				let backgroundOutput: any[] = [];
-
-				// First, restore base output from context (input/output sebelumnya)
-				if (context.sessionOutputs.has(sessionId)) {
-					const savedOutput = context.sessionOutputs.get(sessionId);
-					if (savedOutput) {
-						baseOutput = savedOutput.map(output => ({
-							content: output.content,
-							type: output.type as any,
-							timestamp: output.timestamp
-						}));
-						// Restored base output lines for session
-					}
-				}
-
-				// Second, get NEW output from server that was generated while we were away
-				// We need to track when we saved the output to know what's new
-				if (hasActiveStream && activeStreamInfo) {
-					try {
-						// Get the saved output count from context metadata
-						// This tells us how much output we had when we switched away
-						let savedOutputCount = 0;
-						const savedMetadata = context.sessionOutputs.get(`${sessionId}-metadata`);
-						if (savedMetadata && typeof savedMetadata === 'object' && 'outputCount' in savedMetadata) {
-							savedOutputCount = (savedMetadata as any).outputCount || 0;
-						} else {
-							// Fallback: count actual output lines in baseOutput
-							for (const line of baseOutput) {
-								if (line.type === 'output' || line.type === 'error') {
-									savedOutputCount++;
-								}
-							}
-						}
-
-						// Get only NEW output from server (skip what we already have)
-						const data = await terminalService.getMissedOutput(
-							sessionId,
-							activeStreamInfo.streamId,
-							savedOutputCount
-						);
-						if (data.success && data.output && data.output.length > 0) {
-							// Convert server output to terminal lines
-							backgroundOutput = data.output.map((content: string) => ({
-								content: content,
-								type: 'output',
-								timestamp: new Date()
-							}));
-							debug.log('terminal', `Restored ${backgroundOutput.length} new output lines for session ${sessionId}`);
-						}
-					} catch (error) {
-						debug.error('terminal', 'Failed to fetch missed output:', error);
-					}
-				}
-
-				// Combine base output with background output from server
-				// Base output contains previous input/output saved in context
-				// Background output contains new output from server (if any)
-				terminalSession.lines = [...baseOutput, ...backgroundOutput];
+				// Always start with empty lines.
+				// The create-session replay from headless xterm will provide the
+				// accurate current terminal state (respects clear, scrollback, etc.)
+				terminalSession.lines = [];
 
 				// Restore command history from context (persisted) rather than manager (temporary)
 				const savedCommandHistory = context.sessionCommandHistories.get(sessionId);

package/frontend/services/terminal/terminal.service.ts

@@ -62,20 +62,6 @@ export class TerminalService {
 		// Create unique stream ID for this connection
 		const streamId = `${sessionId}-${Date.now()}`;
 
-		// Get current output count to mark where new output starts
-		let outputStartIndex = 0;
-		if (typeof window !== 'undefined') {
-			try {
-				const terminalStoreModule = await import('$frontend/stores/features/terminal.svelte');
-				const termSession = terminalStoreModule.terminalStore.getSession(sessionId);
-				if (termSession && termSession.lines) {
-					outputStartIndex = termSession.lines.length;
-				}
-			} catch {
-				// Ignore error, use default 0
-			}
-		}
-
 		// Setup WebSocket listeners for this session
 		const listeners: Array<() => void> = [];
 
@@ -173,8 +159,7 @@ export class TerminalService {
 				workingDirectory: session.workingDirectory,
 				projectPath,
 				cols: terminalSize?.cols || 80,
-				rows: terminalSize?.rows || 24,
-				outputStartIndex
+				rows: terminalSize?.rows || 24
 			});
 
 			debug.log('terminal', `✅ Terminal session created:`, response);
@@ -230,6 +215,17 @@ export class TerminalService {
 		}
 	}
 
+	/**
+	 * Clear headless terminal on backend (sync with frontend clear)
+	 */
+	async clearHeadlessTerminal(sessionId: string): Promise<void> {
+		try {
+			await ws.http('terminal:clear', { sessionId });
+		} catch {
+			// Silently handle - non-critical
+		}
+	}
+
 	/**
 	 * Resize terminal for a specific session
 	 */
@@ -301,39 +297,34 @@ export class TerminalService {
 	}
 
 	/**
-	 * Get missed output for a session
+	 * Get missed output for a session (serialized terminal state)
 	 */
 	async getMissedOutput(
 		sessionId: string,
-		streamId?: string,
-		fromIndex: number = 0
+		streamId?: string
 	): Promise<{
 		success: boolean;
-		output: string[];
-		outputCount: number;
+		output: string;
 		status: string;
 	}> {
 		try {
-			const data = await ws.http('terminal:missed-output', { sessionId, streamId, fromIndex }, 5000);
+			const data = await ws.http('terminal:missed-output', { sessionId, streamId }, 5000);
 			if (data.sessionId === sessionId) {
 				return {
 					success: true,
 					output: data.output,
-					outputCount: data.outputCount,
 					status: data.status
 				};
 			}
 			return {
 				success: false,
-				output: [],
-				outputCount: 0,
+				output: '',
 				status: 'invalid_session'
 			};
 		} catch {
 			return {
 				success: false,
-				output: [],
-				outputCount: 0,
+				output: '',
 				status: 'timeout'
 			};
 		}

package/frontend/stores/core/app.svelte.ts

@@ -129,10 +129,18 @@ export function syncGlobalStateFromSession(sessionId: string): void {
 }
 
 /**
- * Remove a session's process state entry (e.g. when deleting a session).
+ * Remove all app-level state for a deleted session
+ * (process state, unread status, etc.)
  */
-export function clearSessionProcessState(sessionId: string): void {
+export function clearSessionState(sessionId: string): void {
 	delete appState.sessionStates[sessionId];
+
+	if (appState.unreadSessions.has(sessionId)) {
+		const next = new Map(appState.unreadSessions);
+		next.delete(sessionId);
+		appState.unreadSessions = next;
+		persistUnreadSessions();
+	}
 }
 
 // ========================================

package/frontend/stores/core/sessions.svelte.ts

@@ -13,7 +13,7 @@ import { buildMetadataFromTransport } from '$shared/utils/message-formatter';
 import ws, { onWsReconnect } from '$frontend/utils/ws';
 import { projectState } from './projects.svelte';
 import { setupEditModeListener, restoreEditMode } from '$frontend/stores/ui/edit-mode.svelte';
-import { markSessionUnread, markSessionRead, appState } from '$frontend/stores/core/app.svelte';
+import { markSessionUnread, markSessionRead, clearSessionState, appState } from '$frontend/stores/core/app.svelte';
 import { debug } from '$shared/utils/logger';
 
 interface SessionState {
@@ -164,6 +164,9 @@ export function removeSession(sessionId: string) {
 		sessionState.sessions.splice(index, 1);
 	}
 
+	// Clear all app-level state for this session (unread, process state)
+	clearSessionState(sessionId);
+
 	// Clear current session if it's the one being removed
 	if (sessionState.currentSession?.id === sessionId) {
 		sessionState.currentSession = null;
@@ -433,6 +436,12 @@ export async function initializeSessions() {
 	setupCollaborativeListeners();
 	setupEditModeListener();
 
+	// Skip loading if no project is active — both calls require WS project context
+	if (!projectState.currentProject) {
+		debug.log('session', 'No active project, skipping session load');
+		return;
+	}
+
 	// Load sessions and restore edit mode in parallel
 	// Both only need WS project context (already set by initializeProjects)
 	await Promise.all([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myrialabs/clopen",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "All-in-one web workspace for Claude Code & OpenCode — chat, terminal, git, browser preview, checkpoints, and real-time collaboration",
   "author": "Myria Labs",
   "license": "MIT",
@@ -77,17 +77,19 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.63",
     "@anthropic-ai/sdk": "0.78.0",
-    "@opencode-ai/sdk": "1.2.15",
     "@elysiajs/cors": "^1.4.0",
     "@iconify-json/lucide": "^1.2.57",
     "@iconify-json/material-icon-theme": "^1.2.16",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@monaco-editor/loader": "^1.5.0",
+    "@opencode-ai/sdk": "1.2.15",
     "@xterm/addon-clipboard": "^0.2.0",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-ligatures": "^0.10.0",
+    "@xterm/addon-serialize": "^0.14.0",
     "@xterm/addon-unicode11": "^0.9.0",
     "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/headless": "^6.0.0",
     "@xterm/xterm": "^6.0.0",
     "bun-pty": "^0.4.2",
     "cloudflared": "^0.7.1",