@myrialabs/clopen 0.1.9 → 0.2.0

package/backend/ws/snapshot/restore.ts

@@ -14,7 +14,9 @@ import { debug } from '$shared/utils/logger';
 import {
 	buildCheckpointTree,
 	getCheckpointPathToRoot,
-	findSessionEnd
+	findCheckpointForHead,
+	findSessionEnd,
+	INITIAL_NODE_ID
 } from '../../lib/snapshot/helpers';
 import { ws } from '$backend/lib/utils/ws';
 
@@ -53,7 +55,31 @@ export const restoreHandler = createRouter()
 			if (project) projectPath = project.path;
 		}
 
-		const result = await snapshotService.checkRestoreConflicts(sessionId, messageId, projectPath);
+		// Build checkpoint path for branch-aware conflict detection
+		let targetPath: string[] | undefined;
+		let resolvedMessageId: string | null = messageId === INITIAL_NODE_ID ? null : messageId;
+
+		if (messageId !== INITIAL_NODE_ID) {
+			const allMessages = messageQueries.getAllBySessionId(sessionId);
+			const { checkpoints, parentMap } = buildCheckpointTree(allMessages);
+			const checkpointIdSet = new Set(checkpoints.map(c => c.id));
+
+			const resolvedId = checkpointIdSet.has(messageId)
+				? messageId
+				: findCheckpointForHead(messageId, allMessages, checkpointIdSet);
+
+			if (resolvedId) {
+				resolvedMessageId = resolvedId;
+				targetPath = getCheckpointPathToRoot(resolvedId, parentMap);
+			}
+		}
+
+		const result = await snapshotService.checkRestoreConflicts(
+			sessionId,
+			resolvedMessageId,
+			projectPath,
+			targetPath
+		);
 
 		debug.log('snapshot', `Conflict check: ${result.conflicts.length} conflicts, ${result.checkpointsToUndo.length} checkpoints to undo`);
 
@@ -82,12 +108,67 @@ export const restoreHandler = createRouter()
 		})
 	}, async ({ data }) => {
 		const { messageId, sessionId, conflictResolutions } = data;
+		const isInitialRestore = messageId === INITIAL_NODE_ID;
 
-		debug.log('snapshot', 'RESTORE - Moving HEAD to checkpoint');
-		debug.log('snapshot', `Target checkpoint: ${messageId}`);
+		debug.log('snapshot', `RESTORE - ${isInitialRestore ? 'Restoring to initial state' : 'Moving HEAD to checkpoint'}`);
+		debug.log('snapshot', `Target: ${messageId}`);
 		debug.log('snapshot', `Session: ${sessionId}`);
 
-		// 1. Get the checkpoint message
+		// Handle restore to initial state (before any messages)
+		if (isInitialRestore) {
+			// Clear HEAD (no messages active)
+			sessionQueries.clearHead(sessionId);
+			debug.log('snapshot', 'HEAD cleared (initial state)');
+
+			// Clear latest_sdk_session_id so next chat starts fresh
+			const db = (await import('../../lib/database')).getDatabase();
+			db.prepare(`UPDATE chat_sessions SET latest_sdk_session_id = NULL WHERE id = ?`).run(sessionId);
+
+			// Clear checkpoint_tree_state
+			checkpointQueries.deleteForSession(sessionId);
+
+			// Restore file system: revert ALL session changes
+			let filesRestored = 0;
+			let filesSkipped = 0;
+
+			const session = sessionQueries.getById(sessionId);
+			if (session) {
+				const project = projectQueries.getById(session.project_id);
+				if (project) {
+					const result = await snapshotService.restoreSessionScoped(
+						project.path,
+						sessionId,
+						null, // null = restore to initial (before all snapshots)
+						conflictResolutions
+					);
+					filesRestored = result.restoredFiles;
+					filesSkipped = result.skippedFiles;
+				}
+			}
+
+			// Broadcast messages-changed
+			try {
+				ws.emit.chatSession(sessionId, 'chat:messages-changed', {
+					sessionId,
+					reason: 'restore',
+					timestamp: new Date().toISOString()
+				});
+			} catch (err) {
+				debug.error('snapshot', 'Failed to broadcast messages-changed:', err);
+			}
+
+			return {
+				restoredTo: {
+					messageId: INITIAL_NODE_ID,
+					timestamp: new Date().toISOString()
+				},
+				filesRestored,
+				filesSkipped
+			};
+		}
+
+		// Regular checkpoint restore
+		// 1. Get the target message
 		const checkpointMessage = messageQueries.getById(messageId);
 		if (!checkpointMessage) {
 			throw new Error('Checkpoint message not found');
@@ -99,9 +180,19 @@ export const restoreHandler = createRouter()
 
 		// 3. Get all messages and build checkpoint tree
 		const allMessages = messageQueries.getAllBySessionId(sessionId);
-		const { parentMap } = buildCheckpointTree(allMessages);
+		const { checkpoints, parentMap } = buildCheckpointTree(allMessages);
+
+		// 3b. Resolve the correct checkpoint for snapshot/tree operations
+		// The target message may be a non-checkpoint (e.g., assistant response)
+		// when called from edit mode. Walk back to find the nearest ancestor checkpoint.
+		const checkpointIdSet = new Set(checkpoints.map(c => c.id));
+		const resolvedCheckpointId = checkpointIdSet.has(messageId)
+			? messageId
+			: findCheckpointForHead(messageId, allMessages, checkpointIdSet);
 
-		// 4. Find session end (last message of checkpoint's session)
+		debug.log('snapshot', `Resolved checkpoint: ${resolvedCheckpointId} (target was ${messageId})`);
+
+		// 4. Find session end (last message of target's session)
 		const sessionEnd = findSessionEnd(checkpointMessage, allMessages);
 		debug.log('snapshot', `Session end: ${sessionEnd.id}`);
 
@@ -137,12 +228,19 @@ export const restoreHandler = createRouter()
 		}
 
 		// 6. Update checkpoint_tree_state for ancestors
-		const checkpointPath = getCheckpointPathToRoot(messageId, parentMap);
-		if (checkpointPath.length > 1) {
-			checkpointQueries.updateActiveChildrenAlongPath(sessionId, checkpointPath);
+		// Use resolved checkpoint ID (not raw messageId which may be a non-checkpoint)
+		// Also compute checkpointPath for branch-aware file restore
+		let checkpointPath: string[] = [];
+		if (resolvedCheckpointId) {
+			checkpointPath = getCheckpointPathToRoot(resolvedCheckpointId, parentMap);
+			if (checkpointPath.length > 1) {
+				checkpointQueries.updateActiveChildrenAlongPath(sessionId, checkpointPath);
+			}
 		}
 
 		// 7. Restore file system state using session-scoped restore
+		// Use resolved checkpoint ID so the snapshot lookup matches correctly
+		// (snapshots are keyed by checkpoint user message IDs, not assistant messages)
 		let filesRestored = 0;
 		let filesSkipped = 0;
 
@@ -153,8 +251,9 @@ export const restoreHandler = createRouter()
 				const result = await snapshotService.restoreSessionScoped(
 					project.path,
 					sessionId,
-					messageId,
-					conflictResolutions
+					resolvedCheckpointId,
+					conflictResolutions,
+					checkpointPath.length > 0 ? checkpointPath : undefined
 				);
 				filesRestored = result.restoredFiles;
 				filesSkipped = result.skippedFiles;

package/backend/ws/snapshot/timeline.ts

@@ -15,7 +15,8 @@ import {
 	getCheckpointPathToRoot,
 	findCheckpointForHead,
 	isDescendant,
-	getCheckpointFileStats
+	getCheckpointFileStats,
+	INITIAL_NODE_ID
 } from '../../lib/snapshot/helpers';
 import type { CheckpointNode, TimelineResponse } from '../../lib/snapshot/helpers';
 import type { SDKMessage } from '$shared/types/messaging';
@@ -36,11 +37,8 @@ export const timelineHandler = createRouter()
 
 		// 1. Get current HEAD
 		const currentHead = sessionQueries.getHead(sessionId);
-		debug.log('snapshot', `Current HEAD: ${currentHead || 'null'}`);
-
-		if (!currentHead) {
-			return { nodes: [], currentHeadId: null };
-		}
+		const isAtInitialState = !currentHead;
+		debug.log('snapshot', `Current HEAD: ${currentHead || 'null (initial state)'}`);
 
 		// 2. Get all messages
 		const allMessages = messageQueries.getAllBySessionId(sessionId);
@@ -61,8 +59,10 @@ export const timelineHandler = createRouter()
 		const checkpointIdSet = new Set(checkpoints.map(c => c.id));
 
 		// 4. Find which checkpoint HEAD belongs to
-		const activeCheckpointId = findCheckpointForHead(currentHead, allMessages, checkpointIdSet);
-		debug.log('snapshot', `Active checkpoint: ${activeCheckpointId}`);
+		const activeCheckpointId = isAtInitialState
+			? null
+			: findCheckpointForHead(currentHead, allMessages, checkpointIdSet);
+		debug.log('snapshot', `Active checkpoint: ${activeCheckpointId || '(initial)'}`);
 
 		// 5. Build active path (from root to active checkpoint)
 		const activePathIds = new Set<string>();
@@ -76,22 +76,47 @@ export const timelineHandler = createRouter()
 		// 6. Get active children map from database
 		const activeChildrenMap = checkpointQueries.getAllActiveChildren(sessionId);
 
-		// 7. Sort checkpoints by timestamp for file stats calculation
-		const sortedCheckpoints = [...checkpoints].sort(
-			(a, b) => a.timestamp.localeCompare(b.timestamp)
-		);
-
-		// Build next-checkpoint timestamp map for stats
-		const nextTimestampMap = new Map<string, string>();
-		for (let i = 0; i < sortedCheckpoints.length; i++) {
-			const next = sortedCheckpoints[i + 1];
-			if (next) {
-				nextTimestampMap.set(sortedCheckpoints[i].id, next.timestamp);
-			}
+		// 7. Build response nodes
+		const nodes: CheckpointNode[] = [];
+
+		// Find root checkpoints (those with no parent)
+		const rootCheckpointIds = checkpoints
+			.filter(cp => !parentMap.has(cp.id))
+			.map(cp => cp.id);
+
+		// Get session started_at for the initial node timestamp
+		const session = sessionQueries.getById(sessionId);
+		const sessionStartedAt = session?.started_at || new Date().toISOString();
+
+		// Add the "Initial State" node at the beginning
+		// Its activeChildId points to the first root checkpoint on the active path,
+		// or the first root checkpoint if we're at initial state
+		let initialActiveChildId: string | null = null;
+		if (isAtInitialState) {
+			// At initial state: the first root checkpoint (by timestamp) is the active child
+			initialActiveChildId = rootCheckpointIds[0] || null;
+		} else {
+			// Find root checkpoint on active path
+			initialActiveChildId = rootCheckpointIds.find(id => activePathIds.has(id)) || rootCheckpointIds[0] || null;
 		}
 
-		// 8. Build response nodes
-		const nodes: CheckpointNode[] = [];
+		nodes.push({
+			id: INITIAL_NODE_ID,
+			messageId: INITIAL_NODE_ID,
+			parentId: null,
+			activeChildId: initialActiveChildId,
+			timestamp: sessionStartedAt,
+			messageText: 'Session Start',
+			isOnActivePath: isAtInitialState || activePathIds.size > 0,
+			isOrphaned: false,
+			isCurrent: isAtInitialState,
+			hasSnapshot: false,
+			isInitial: true,
+			senderName: null,
+			filesChanged: 0,
+			insertions: 0,
+			deletions: 0
+		});
 
 		for (const cp of checkpoints) {
 			const sdk = JSON.parse(cp.sdk_message) as SDKMessage;
@@ -107,16 +132,16 @@ export const timelineHandler = createRouter()
 				isOrphaned = isDescendant(cp.id, activeCheckpointId, childrenMap);
 			}
 
-			// File stats
-			const nextTimestamp = nextTimestampMap.get(cp.id);
-			const stats = getCheckpointFileStats(cp, allMessages, nextTimestamp);
+			// File stats from checkpoint's own snapshot
+			const stats = getCheckpointFileStats(cp);
 
 			const snapshot = snapshotQueries.getByMessageId(cp.id);
 
 			nodes.push({
 				id: cp.id,
 				messageId: cp.id,
-				parentId: parentCpId,
+				// Root checkpoints have initial node as parent
+				parentId: parentCpId || INITIAL_NODE_ID,
 				activeChildId,
 				timestamp: cp.timestamp,
 				messageText,
@@ -131,11 +156,13 @@ export const timelineHandler = createRouter()
 			});
 		}
 
-		debug.log('snapshot', `Timeline nodes: ${nodes.length}`);
-		debug.log('snapshot', `Active path: ${activePathIds.size} nodes`);
+		const currentHeadId = isAtInitialState ? INITIAL_NODE_ID : activeCheckpointId;
+
+		debug.log('snapshot', `Timeline nodes: ${nodes.length} (including initial)`);
+		debug.log('snapshot', `Active path: ${activePathIds.size} nodes, current: ${currentHeadId}`);
 
 		return {
 			nodes,
-			currentHeadId: activeCheckpointId
+			currentHeadId
 		};
 	});

package/bin/clopen.ts

@@ -31,6 +31,7 @@ interface CLIOptions {
 	help?: boolean;
 	version?: boolean;
 	update?: boolean;
+	resetPat?: boolean;
 }
 
 // Get version from package.json
@@ -95,6 +96,7 @@ USAGE:
 
 COMMANDS:
   update                  Update clopen to the latest version
+  reset-pat               Regenerate admin Personal Access Token
 
 OPTIONS:
   -p, --port <number>     Port to run the server on (default: ${DEFAULT_PORT})
@@ -107,6 +109,7 @@ EXAMPLES:
   clopen --port 9150      # Start on port 9150
   clopen --host 0.0.0.0   # Bind to all network interfaces
   clopen update           # Update to the latest version
+  clopen reset-pat        # Regenerate admin login token
   clopen --version        # Show version
 
 For more information, visit: https://github.com/myrialabs/clopen
@@ -167,6 +170,10 @@ function parseArguments(): CLIOptions {
 				options.update = true;
 				break;
 
+			case 'reset-pat':
+				options.resetPat = true;
+				break;
+
 			default:
 				console.error(`❌ Error: Unknown option "${arg}"`);
 				console.log('Run "clopen --help" for usage information');
@@ -250,6 +257,31 @@ async function runUpdate() {
 	console.log('\n  Restart clopen to apply the update.');
 }
 
+async function recoverAdminToken() {
+	const version = getVersion();
+	console.log(`\x1b[36mClopen\x1b[0m v${version} — Admin Token Recovery\n`);
+
+	// Initialize database (import dynamically to avoid loading full backend)
+	const { initializeDatabase } = await import('../backend/lib/database/index');
+	const { listUsers, regeneratePAT } = await import('../backend/lib/auth/auth-service');
+
+	await initializeDatabase();
+
+	const users = listUsers();
+	const admin = users.find(u => u.role === 'admin');
+
+	if (!admin) {
+		console.error('❌ No admin user found. Start clopen first to complete setup.');
+		process.exit(1);
+	}
+
+	const newPAT = regeneratePAT(admin.id);
+
+	console.log(`  Admin  : ${admin.name}`);
+	console.log(`  New PAT: \x1b[32m${newPAT}\x1b[0m`);
+	console.log(`\n  Use this token to log in. Keep it safe — it won't be shown again.`);
+}
+
 async function setupEnvironment() {
 	// Check if .env exists, if not copy from .env.example
 	if (!existsSync(ENV_FILE)) {
@@ -368,7 +400,23 @@ async function main() {
 
 		// Show version if requested
 		if (options.version) {
-			console.log(getVersion());
+			const currentVersion = getVersion();
+			console.log(`v${currentVersion}`);
+
+			try {
+				const response = await fetch('https://registry.npmjs.org/@myrialabs/clopen/latest');
+				if (response.ok) {
+					const data = await response.json() as { version: string };
+					if (isNewerVersion(currentVersion, data.version)) {
+						console.log(`\x1b[33mUpdate available: v${data.version}\x1b[0m — run \x1b[36mclopen update\x1b[0m to update`);
+					} else {
+						console.log('\x1b[32m(latest)\x1b[0m');
+					}
+				}
+			} catch {
+				// Silent fail — network unavailable
+			}
+
 			process.exit(0);
 		}
 
@@ -384,6 +432,13 @@ async function main() {
 			process.exit(0);
 		}
 
+		// Recover admin token if requested
+		if (options.resetPat) {
+			await setupEnvironment();
+			await recoverAdminToken();
+			process.exit(0);
+		}
+
 		// 1. Setup environment variables
 		await setupEnvironment();