@myrialabs/clopen 0.1.8 → 0.1.10

package/backend/index.ts

@@ -118,7 +118,11 @@ async function startServer() {
 		port: actualPort,
 		hostname: HOST
 	}, () => {
-		console.log(`🚀 Clopen running at http://localhost:${actualPort}`);
+		if (isDevelopment) {
+			console.log('🚀 Backend ready — waiting for frontend...');
+		} else {
+			console.log(`🚀 Clopen running at http://localhost:${actualPort}`);
+		}
 		if (HOST === '0.0.0.0') {
 			const ips = getLocalIps();
 			for (const ip of ips) {

package/backend/lib/chat/stream-manager.ts

@@ -891,7 +891,10 @@ class StreamManager extends EventEmitter {
 			const { projectPath, projectId, chatSessionId } = requestData;
 			if (projectPath && projectId && chatSessionId && userMessageId) {
 				snapshotService.captureSnapshot(projectPath, projectId, chatSessionId, userMessageId)
-					.then(() => debug.log('chat', `Stream-end snapshot captured for message: ${userMessageId}`))
+					.then(() => {
+						debug.log('chat', `Stream-end snapshot captured for message: ${userMessageId}`);
+						this.emit('snapshot:captured', { projectId, chatSessionId });
+					})
 					.catch(err => debug.error('chat', 'Failed to capture stream-end snapshot:', err));
 			}
 		}

package/backend/lib/database/migrations/023_create_user_unread_sessions_table.ts

@@ -0,0 +1,32 @@
+import type { DatabaseConnection } from '$shared/types/database/connection';
+import { debug } from '$shared/utils/logger';
+
+export const description = 'Create user_unread_sessions table for persisting per-user unread session state';
+
+export const up = (db: DatabaseConnection): void => {
+	debug.log('migration', 'Creating user_unread_sessions table...');
+
+	db.exec(`
+		CREATE TABLE IF NOT EXISTS user_unread_sessions (
+			user_id TEXT NOT NULL,
+			session_id TEXT NOT NULL,
+			project_id TEXT NOT NULL,
+			marked_at TEXT NOT NULL,
+			PRIMARY KEY (user_id, session_id),
+			FOREIGN KEY (session_id) REFERENCES chat_sessions(id) ON DELETE CASCADE
+		)
+	`);
+
+	db.exec(`
+		CREATE INDEX IF NOT EXISTS idx_user_unread_sessions_user_project
+		ON user_unread_sessions(user_id, project_id)
+	`);
+
+	debug.log('migration', 'user_unread_sessions table created');
+};
+
+export const down = (db: DatabaseConnection): void => {
+	debug.log('migration', 'Dropping user_unread_sessions table...');
+	db.exec('DROP TABLE IF EXISTS user_unread_sessions');
+	debug.log('migration', 'user_unread_sessions table dropped');
+};

package/backend/lib/database/migrations/index.ts

@@ -21,6 +21,7 @@ import * as migration019 from './019_add_claude_account_to_sessions';
 import * as migration020 from './020_add_snapshot_tree_hash';
 import * as migration021 from './021_drop_prompt_templates_table';
 import * as migration022 from './022_add_snapshot_changes_column';
+import * as migration023 from './023_create_user_unread_sessions_table';
 
 // Export all migrations in order
 export const migrations = [
@@ -155,6 +156,12 @@ export const migrations = [
 		description: migration022.description,
 		up: migration022.up,
 		down: migration022.down
+	},
+	{
+		id: '023',
+		description: migration023.description,
+		up: migration023.up,
+		down: migration023.down
 	}
 ];
 

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

@@ -188,6 +188,19 @@ export const sessionQueries = {
 		`).run(messageId, sessionId);
 	},
 
+	/**
+	 * Clear the HEAD pointer (set to NULL).
+	 * Used when restoring to the initial state (before any messages).
+	 */
+	clearHead(sessionId: string): void {
+		const db = getDatabase();
+		db.prepare(`
+			UPDATE chat_sessions
+			SET current_head_message_id = NULL
+			WHERE id = ?
+		`).run(sessionId);
+	},
+
 	/**
 	 * Get current HEAD message ID for a session
 	 */
@@ -267,5 +280,42 @@ export const sessionQueries = {
 			SET head_message_id = ?
 			WHERE session_id = ? AND branch_name = ?
 		`).run(newHeadMessageId, sessionId, branchName);
+	},
+
+	// ==================== PER-USER UNREAD SESSION TRACKING ====================
+
+	/**
+	 * Mark a session as unread for a specific user
+	 */
+	markUnread(userId: string, sessionId: string, projectId: string): void {
+		const db = getDatabase();
+		const now = new Date().toISOString();
+		db.prepare(`
+			INSERT OR IGNORE INTO user_unread_sessions (user_id, session_id, project_id, marked_at)
+			VALUES (?, ?, ?, ?)
+		`).run(userId, sessionId, projectId, now);
+	},
+
+	/**
+	 * Mark a session as read for a specific user
+	 */
+	markRead(userId: string, sessionId: string): void {
+		const db = getDatabase();
+		db.prepare(`
+			DELETE FROM user_unread_sessions
+			WHERE user_id = ? AND session_id = ?
+		`).run(userId, sessionId);
+	},
+
+	/**
+	 * Get all unread session IDs for a user within a project
+	 * Returns array of { sessionId, projectId }
+	 */
+	getUnreadSessions(userId: string, projectId: string): { session_id: string; project_id: string }[] {
+		const db = getDatabase();
+		return db.prepare(`
+			SELECT session_id, project_id FROM user_unread_sessions
+			WHERE user_id = ? AND project_id = ?
+		`).all(userId, projectId) as { session_id: string; project_id: string }[];
 	}
 };

package/backend/lib/database/queries/snapshot-queries.ts

@@ -114,7 +114,7 @@ export const snapshotQueries = {
 		const db = getDatabase();
 		const snapshots = db.prepare(`
 			SELECT * FROM message_snapshots
-			WHERE session_id = ?
+			WHERE session_id = ? AND (is_deleted IS NULL OR is_deleted = 0)
 			ORDER BY created_at ASC
 		`).all(sessionId) as MessageSnapshot[];
 

package/backend/lib/engine/adapters/opencode/server.ts

@@ -81,6 +81,14 @@ export function getClient(): OpencodeClient | null {
 	return ready ? client : null;
 }
 
+/**
+ * Get the OpenCode server base URL (e.g. "http://127.0.0.1:4096").
+ * Used for direct HTTP calls to v2 endpoints not available on the v1 client.
+ */
+export function getServerUrl(): string | null {
+	return serverHandle?.url ?? null;
+}
+
 /**
  * Dispose the OpenCode client and stop the server.
  * Called during full server shutdown (disposeAllEngines).

package/backend/lib/engine/adapters/opencode/stream.ts

@@ -40,7 +40,7 @@ import {
 	convertSubtaskToolUseOnly,
 	getToolInput,
 } from './message-converter';
-import { ensureClient, getClient } from './server';
+import { ensureClient, getClient, getServerUrl } from './server';
 import { debug } from '$shared/utils/logger';
 
 /** Map SDK Model.status to our category */
@@ -75,6 +75,8 @@ export class OpenCodeEngine implements AIEngine {
 	private activeAbortController: AbortController | null = null;
 	private activeSessionId: string | null = null;
 	private activeProjectPath: string | null = null;
+	/** Pending question requests keyed by tool callID → { requestId, questions } */
+	private pendingQuestions = new Map<string, { requestId: string; questions: Array<{ question: string }> }>();
 
 	get isInitialized(): boolean {
 		return this._isInitialized;
@@ -102,6 +104,7 @@ export class OpenCodeEngine implements AIEngine {
 	 */
 	async dispose(): Promise<void> {
 		await this.cancel();
+		this.pendingQuestions.clear();
 		this._isInitialized = false;
 		debug.log('engine', 'Open Code engine instance disposed');
 	}
@@ -664,6 +667,39 @@ export class OpenCodeEngine implements AIEngine {
 							break;
 						}
 
+						// v2 question event — emitted when the question tool needs user input
+						case 'question.asked': {
+							const props = evt.properties as {
+								id: string;
+								sessionID: string;
+								questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string }> }>;
+								tool?: { messageID: string; callID: string };
+							};
+							if (props.sessionID !== sessionId) break;
+							if (props.tool?.callID) {
+								this.pendingQuestions.set(props.tool.callID, {
+									requestId: props.id,
+									questions: props.questions,
+								});
+								debug.log('engine', `[OC] question.asked: stored question ${props.id} for callID ${props.tool.callID}`);
+							}
+							break;
+						}
+
+						// v2 permission event — auto-approve to avoid blocking the session
+						// (tool permissions like file_write, bash, etc. are bypassed)
+						case 'permission.asked':
+						case 'permission.updated': {
+							const props = evt.properties as {
+								id: string;
+								sessionID: string;
+								callID?: string;
+							};
+							if (props.sessionID !== sessionId) break;
+							this.autoApprovePermission(props.id, props.sessionID);
+							break;
+						}
+
 						case 'session.error': {
 							const errorProps = (event as EventSessionError).properties;
 							// Only handle errors for our session (sessionID is optional on errors)
@@ -729,6 +765,7 @@ export class OpenCodeEngine implements AIEngine {
 			this.activeAbortController = null;
 			this.activeSessionId = null;
 			this.activeProjectPath = null;
+			this.pendingQuestions.clear();
 		}
 	}
 
@@ -754,6 +791,7 @@ export class OpenCodeEngine implements AIEngine {
 		this._isActive = false;
 		this.activeSessionId = null;
 		this.activeProjectPath = null;
+		this.pendingQuestions.clear();
 	}
 
 	/**
@@ -779,6 +817,142 @@ export class OpenCodeEngine implements AIEngine {
 		await this.cancel();
 	}
 
+	/**
+	 * Resolve a pending AskUserQuestion by replying via the OpenCode question API.
+	 *
+	 * Flow:
+	 * 1. If a `question.asked` event was received → use stored requestId to reply
+	 * 2. Fallback → fetch pending questions from GET /question and match by callID
+	 *
+	 * The reply is sent to POST /question/{requestID}/reply with answers
+	 * ordered by the original questions array.
+	 */
+	resolveUserAnswer(toolUseId: string, answers: Record<string, string>): boolean {
+		const pending = this.pendingQuestions.get(toolUseId);
+
+		if (pending) {
+			// Convert Record<questionText, answerLabel> → Array<Array<string>> ordered by questions
+			const orderedAnswers = pending.questions.map(q => {
+				const answer = answers[q.question];
+				return answer ? [answer] : [];
+			});
+			this.replyToQuestion(pending.requestId, orderedAnswers);
+			this.pendingQuestions.delete(toolUseId);
+			return true;
+		}
+
+		// Fallback: fetch pending questions from the API and find matching one
+		debug.log('engine', `resolveUserAnswer: No stored question for toolUseId ${toolUseId}, fetching from API...`);
+		this.fetchAndReplyToQuestion(toolUseId, answers);
+		return true;
+	}
+
+	/**
+	 * POST /question/{requestID}/reply to send user answers back to the OpenCode server.
+	 */
+	private replyToQuestion(requestId: string, orderedAnswers: string[][]): void {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) {
+			debug.warn('engine', 'replyToQuestion: Server URL not available');
+			return;
+		}
+
+		const dirParam = this.activeProjectPath ? `?directory=${encodeURIComponent(this.activeProjectPath)}` : '';
+		const url = `${serverUrl}/question/${requestId}/reply${dirParam}`;
+		debug.log('engine', `Replying to question ${requestId}:`, orderedAnswers);
+
+		fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ answers: orderedAnswers }),
+		}).then(async res => {
+			if (res.ok) {
+				debug.log('engine', `Question reply accepted: ${requestId} (${res.status})`);
+			} else {
+				const body = await res.text().catch(() => '');
+				debug.error('engine', `Question reply failed: ${res.status} ${res.statusText}`, body);
+			}
+		}).catch(error => {
+			debug.error('engine', 'Failed to reply to question:', error);
+		});
+	}
+
+	/**
+	 * Fallback: GET /question to list pending questions, find the matching one, and reply.
+	 */
+	private async fetchAndReplyToQuestion(toolUseId: string, answers: Record<string, string>): Promise<void> {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) {
+			debug.warn('engine', 'fetchAndReplyToQuestion: Server URL not available');
+			return;
+		}
+
+		try {
+			const dirParam = this.activeProjectPath ? `?directory=${encodeURIComponent(this.activeProjectPath)}` : '';
+			const res = await fetch(`${serverUrl}/question${dirParam}`);
+			if (!res.ok) {
+				debug.error('engine', `Failed to list pending questions: ${res.status}`);
+				return;
+			}
+
+			const questions = await res.json() as Array<{
+				id: string;
+				questions: Array<{ question: string }>;
+				tool?: { callID: string };
+			}>;
+
+			const matching = questions.find(q => q.tool?.callID === toolUseId);
+			if (!matching) {
+				debug.warn('engine', 'fetchAndReplyToQuestion: No matching question for toolUseId:', toolUseId);
+				return;
+			}
+
+			const orderedAnswers = matching.questions.map(q => {
+				const answer = answers[q.question];
+				return answer ? [answer] : [];
+			});
+			this.replyToQuestion(matching.id, orderedAnswers);
+		} catch (error) {
+			debug.error('engine', 'Failed to fetch and reply to question:', error);
+		}
+	}
+
+	/**
+	 * Auto-approve a permission request to avoid blocking the session.
+	 * Uses direct HTTP since the v1 client may not have the v2 permission.reply method.
+	 */
+	private autoApprovePermission(permissionId: string, sessionId: string): void {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) return;
+
+		// Try v2 endpoint first (/permission/{requestID}/reply), fall back to v1
+		fetch(`${serverUrl}/permission/${permissionId}/reply`, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ reply: 'once' }),
+		}).then(res => {
+			if (res.ok) {
+				debug.log('engine', `[OC] auto-approved permission ${permissionId} (v2)`);
+				return;
+			}
+			// v2 endpoint not available — try v1
+			const client = getClient();
+			if (client) {
+				client.postSessionIdPermissionsPermissionId({
+					path: { id: sessionId, permissionID: permissionId },
+					body: { response: 'once' },
+					...(this.activeProjectPath && { query: { directory: this.activeProjectPath } }),
+				}).then(() => {
+					debug.log('engine', `[OC] auto-approved permission ${permissionId} (v1)`);
+				}).catch(err => {
+					debug.error('engine', 'Failed to auto-approve permission (v1):', err);
+				});
+			}
+		}).catch(error => {
+			debug.error('engine', 'Failed to auto-approve permission:', error);
+		});
+	}
+
 	/**
 	 * Extract prompt parts (text + file attachments) from SDKUserMessage.
 	 * Converts Claude-format image/document blocks to OpenCode FilePartInput format.

package/backend/lib/snapshot/helpers.ts

@@ -7,6 +7,9 @@ import type { DatabaseMessage } from '$shared/types/database/schema';
  * Snapshot domain helper functions
  */
 
+/** Sentinel ID for the "initial state" node (before any chat messages) */
+export const INITIAL_NODE_ID = '__initial__';
+
 export interface CheckpointNode {
 	id: string;
 	messageId: string;
@@ -18,6 +21,7 @@ export interface CheckpointNode {
 	isOrphaned: boolean; // descendant of current active checkpoint
 	isCurrent: boolean; // this is the current active checkpoint
 	hasSnapshot: boolean;
+	isInitial?: boolean; // true for the "initial state" node
 	senderName?: string | null;
 	// File change statistics (git-like)
 	filesChanged?: number;
@@ -335,62 +339,31 @@ export function isDescendant(
 }
 
 /**
- * Get file change stats for a checkpoint by looking at snapshots
- * between this checkpoint and the next.
+ * Get file change stats for a checkpoint.
+ * The snapshot associated with the checkpoint message itself contains the stats
+ * (file changes the assistant made in response to this user message).
  */
 export function getCheckpointFileStats(
-	checkpointMsg: DatabaseMessage,
-	allMessages: DatabaseMessage[],
-	nextCheckpointTimestamp?: string
+	checkpointMsg: DatabaseMessage
 ): { filesChanged: number; insertions: number; deletions: number } {
-	let filesChanged = 0;
-	let insertions = 0;
-	let deletions = 0;
-
-	const checkpointTimestamp = checkpointMsg.timestamp;
-
-	const laterMessages = allMessages
-		.filter(m => {
-			if (m.timestamp <= checkpointTimestamp) return false;
-			if (nextCheckpointTimestamp && m.timestamp >= nextCheckpointTimestamp) return false;
-			return true;
-		})
-		.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+	const snapshot = snapshotQueries.getByMessageId(checkpointMsg.id);
+	if (!snapshot) {
+		return { filesChanged: 0, insertions: 0, deletions: 0 };
+	}
 
-	const allChangedFiles = new Set<string>();
-	const statsInRange: Array<{ files: number; ins: number; del: number }> = [];
+	let filesChanged = snapshot.files_changed || 0;
+	const insertions = snapshot.insertions || 0;
+	const deletions = snapshot.deletions || 0;
 
-	for (const msg of laterMessages) {
+	// Try to get a more accurate file count from session_changes
+	if (snapshot.session_changes) {
 		try {
-			const sdkMsg = JSON.parse(msg.sdk_message) as SDKMessage;
-			if (sdkMsg.type !== 'user') continue;
-
-			const userSnapshot = snapshotQueries.getByMessageId(msg.id);
-			if (!userSnapshot) continue;
-
-			const fc = userSnapshot.files_changed || 0;
-			const ins = userSnapshot.insertions || 0;
-			const del = userSnapshot.deletions || 0;
-
-			if (fc > 0 || ins > 0 || del > 0) {
-				statsInRange.push({ files: fc, ins, del });
-			}
-
-			if (userSnapshot.delta_changes) {
-				try {
-					const delta = JSON.parse(userSnapshot.delta_changes);
-					if (delta.added) Object.keys(delta.added).forEach(f => allChangedFiles.add(f));
-					if (delta.modified) Object.keys(delta.modified).forEach(f => allChangedFiles.add(f));
-					if (delta.deleted && Array.isArray(delta.deleted)) delta.deleted.forEach((f: string) => allChangedFiles.add(f));
-				} catch { /* skip */ }
+			const changes = JSON.parse(snapshot.session_changes as string);
+			const changeCount = Object.keys(changes).length;
+			if (changeCount > 0) {
+				filesChanged = changeCount;
 			}
-		} catch { /* skip */ }
-	}
-
-	if (statsInRange.length > 0) {
-		filesChanged = allChangedFiles.size > 0 ? allChangedFiles.size : Math.max(...statsInRange.map(s => s.files));
-		insertions = statsInRange.reduce((sum, s) => sum + s.ins, 0);
-		deletions = statsInRange.reduce((sum, s) => sum + s.del, 0);
+		} catch { /* use files_changed from DB */ }
 	}
 
 	return { filesChanged, insertions, deletions };