@myrialabs/clopen 0.0.1

package/backend/lib/shared/process-manager.ts

@@ -0,0 +1,281 @@
+/**
+ * TARGETED Process Management for Terminal Command Cancellation
+ * Tracks specific session processes without affecting external terminals
+ */
+
+import type { Subprocess } from 'bun';
+
+import { debug } from '$shared/utils/logger';
+// Store active child processes globally
+const activeProcesses = new Map<string, Subprocess>();
+// Store child process trees for comprehensive cleanup
+const processTreeMap = new Map<string, number[]>();
+// Track manually terminated sessions
+const manuallyTerminatedSessions = new Set<string>();
+// Platform detection
+const isWindows = process.platform === 'win32';
+
+export function setActiveProcess(sessionId: string, process: Subprocess) {
+	debug.log('server', '🔧 Setting active process for session:', sessionId, 'PID:', process.pid);
+	
+	// Clean up any existing process for this session first
+	const existingProcess = activeProcesses.get(sessionId);
+	if (existingProcess && existingProcess.pid) {
+		debug.log('server', '🧹 Cleaning up existing process for session:', sessionId);
+		try {
+			// Use nuclear cleanup for existing process
+			nuclearProcessCleanup(sessionId);
+		} catch (error) {
+			debug.log('server', '⚠️ Failed to clean existing process:', error);
+		}
+	}
+	
+	activeProcesses.set(sessionId, process);
+	processTreeMap.set(sessionId, []);
+	
+	// Add cleanup handlers - ONLY cleanup tracking, not nuclear
+	process.exited.then((code) => {
+		debug.log('server', `🏁 Process for session ${sessionId} exited with code ${code}`);
+		// Just cleanup tracking - don't force kill other processes
+		activeProcesses.delete(sessionId);
+		processTreeMap.delete(sessionId);
+		// Clean up manual termination tracking after some time
+		setTimeout(() => {
+			manuallyTerminatedSessions.delete(sessionId);
+		}, 5000);
+	}).catch((error) => {
+		debug.log('server', `❌ Process error for session ${sessionId}:`, error);
+		// Just cleanup tracking - don't force kill other processes
+		activeProcesses.delete(sessionId);
+		processTreeMap.delete(sessionId);
+		// Clean up manual termination tracking
+		setTimeout(() => {
+			manuallyTerminatedSessions.delete(sessionId);
+		}, 5000);
+	});
+	
+	// Start monitoring child processes for this session
+	if (process.pid) {
+		startChildProcessMonitoring(sessionId, process.pid);
+	}
+}
+
+// Track child processes without aggressive monitoring
+function startChildProcessMonitoring(sessionId: string, parentPid: number) {
+	const monitorInterval = setInterval(async () => {
+		try {
+			// Only monitor if session still exists and process is alive
+			if (!activeProcesses.has(sessionId)) {
+				clearInterval(monitorInterval);
+				return;
+			}
+			
+			const childPids = await discoverChildProcesses(parentPid);
+			const currentChildren = processTreeMap.get(sessionId) || [];
+			
+			// Add new children to tracking (passive monitoring only)
+			for (const childPid of childPids) {
+				if (!currentChildren.includes(childPid)) {
+					debug.log('server', `🔍 Discovered new child process: ${childPid} for session: ${sessionId}`);
+					currentChildren.push(childPid);
+				}
+			}
+			
+			processTreeMap.set(sessionId, currentChildren);
+			
+		} catch (error) {
+			debug.log('server', '⚠️ Child process monitoring error:', error);
+			// Don't kill anything on monitoring errors
+		}
+	}, 5000); // Check every 5 seconds (less aggressive)
+	
+	// Clean up monitoring after reasonable time
+	setTimeout(() => {
+		clearInterval(monitorInterval);
+	}, 300000); // Stop after 5 minutes max
+}
+
+// NUCLEAR: Discover all child processes of a parent
+async function discoverChildProcesses(parentPid: number): Promise<number[]> {
+	const childPids: number[] = [];
+	
+	try {
+		if (isWindows) {
+			// Windows: Use WMIC to find all children recursively
+			const proc = Bun.spawn(['wmic', 'process', 'where', `ParentProcessId=${parentPid}`, 'get', 'ProcessId', '/format:csv'], {
+				stdout: 'pipe',
+				stderr: 'ignore'
+			});
+			const output = await new Response(proc.stdout).text();
+			
+			const lines = output.split('\n');
+			for (const line of lines) {
+				const match = line.match(/,(\d+)$/);
+				if (match) {
+					const childPid = parseInt(match[1]);
+					childPids.push(childPid);
+					
+					// Recursively find grandchildren
+					const grandChildren = await discoverChildProcesses(childPid);
+					childPids.push(...grandChildren);
+				}
+			}
+		} else {
+			// Unix: Use pgrep to find children
+			try {
+				const proc = Bun.spawn(['pgrep', '-P', parentPid.toString()], {
+					stdout: 'pipe',
+					stderr: 'ignore'
+				});
+				const output = await new Response(proc.stdout).text();
+				
+				const lines = output.trim().split('\n');
+				for (const line of lines) {
+					if (line.trim()) {
+						const childPid = parseInt(line.trim());
+						if (!isNaN(childPid)) {
+							childPids.push(childPid);
+							
+							// Recursively find grandchildren
+							const grandChildren = await discoverChildProcesses(childPid);
+							childPids.push(...grandChildren);
+						}
+					}
+				}
+			} catch (error) {
+				// No children found, which is fine
+			}
+		}
+	} catch (error) {
+		debug.log('server', '⚠️ Error discovering child processes:', error);
+	}
+	
+	return [...new Set(childPids)]; // Remove duplicates
+}
+
+// TARGETED: Complete process tree cleanup for specific session only
+export async function nuclearProcessCleanup(sessionId: string) {
+	debug.log('server', '🎯 TARGETED CLEANUP for session:', sessionId);
+	
+	// Mark this session as manually terminated
+	manuallyTerminatedSessions.add(sessionId);
+	
+	const process = activeProcesses.get(sessionId);
+	const childPids = processTreeMap.get(sessionId) || [];
+	
+	// Kill all child processes first (bottom-up)
+	for (const childPid of childPids) {
+		try {
+			debug.log('server', `💥 Killing child process: ${childPid}`);
+			if (isWindows) {
+				const proc = Bun.spawn(['taskkill', '/F', '/PID', childPid.toString()], {
+					stdout: 'ignore',
+					stderr: 'ignore'
+				});
+				await proc.exited;
+			} else {
+				const proc = Bun.spawn(['kill', '-9', childPid.toString()], {
+					stdout: 'ignore',
+					stderr: 'ignore'
+				});
+				await proc.exited;
+			}
+			debug.log('server', `✅ Killed child process: ${childPid}`);
+		} catch (error) {
+			debug.log('server', `⚠️ Failed to kill child ${childPid}:`, error);
+		}
+	}
+	
+	// Kill parent process
+	if (process && process.pid) {
+		try {
+			debug.log('server', `💥 Killing parent process: ${process.pid}`);
+			process.kill();
+			debug.log('server', `✅ Killed parent process: ${process.pid}`);
+		} catch (error) {
+			debug.log('server', '⚠️ Failed to kill parent process:', error);
+		}
+	}
+	
+	// TARGETED: Only kill processes that belong to this specific session
+	// No more nuclear killing of all npm/node processes
+	debug.log('server', '🎯 Targeted cleanup completed - only session-specific processes terminated')
+	
+	// Clean up tracking
+	activeProcesses.delete(sessionId);
+	processTreeMap.delete(sessionId);
+	
+	debug.log('server', '🎯 TARGETED CLEANUP completed for session:', sessionId);
+}
+
+export function removeActiveProcess(sessionId: string) {
+	debug.log('server', '🗑️ Removing active process for session:', sessionId);
+	
+	// Simple cleanup - just remove from tracking
+	activeProcesses.delete(sessionId);
+	processTreeMap.delete(sessionId);
+}
+
+export function getActiveProcess(sessionId: string): Subprocess | undefined {
+	const process = activeProcesses.get(sessionId);
+	if (process && !process.pid) {
+		// Process is dead, remove it from the map
+		debug.log('server', '🪦 Process for session', sessionId, 'is dead, removing from active list');
+		activeProcesses.delete(sessionId);
+		processTreeMap.delete(sessionId);
+		return undefined;
+	}
+	return process;
+}
+
+export function getAllActiveProcesses(): Map<string, Subprocess> {
+	return activeProcesses;
+}
+
+export function getActiveProcessCount(): number {
+	return activeProcesses.size;
+}
+
+// Enhanced cleanup function with targeted options
+export async function cleanupAllProcesses() {
+	debug.log('server', '🎯 TARGETED CLEANUP of all tracked processes...');
+	
+	// Targeted cleanup for each session
+	for (const sessionId of activeProcesses.keys()) {
+		await nuclearProcessCleanup(sessionId);
+	}
+	
+	// REMOVED: Global process killing - only clean up tracked processes
+	debug.log('server', '🎯 All tracked processes cleaned up - no global process termination')
+	
+	activeProcesses.clear();
+	processTreeMap.clear();
+}
+
+// Get comprehensive process status for debugging
+export function getProcessStatus(sessionId: string) {
+	const process = activeProcesses.get(sessionId);
+	const childPids = processTreeMap.get(sessionId) || [];
+	
+	if (!process) {
+		return { exists: false, childProcesses: [] };
+	}
+	
+	return {
+		exists: true,
+		pid: process.pid,
+		killed: process.killed,
+		exitCode: process.exitCode,
+		signalCode: process.signalCode,
+		childProcesses: childPids
+	};
+}
+
+// Get all tracked child processes for a session
+export function getChildProcesses(sessionId: string): number[] {
+	return processTreeMap.get(sessionId) || [];
+}
+
+export function wasManuallyTerminated(sessionId: string): boolean {
+	return manuallyTerminatedSessions.has(sessionId);
+}

package/backend/lib/snapshot/blob-store.ts

@@ -0,0 +1,227 @@
+/**
+ * Content-Addressable Blob Store
+ * Git-like storage for snapshot file contents
+ *
+ * Structure:
+ *   ~/.clopen/snapshots/blobs/{hash[0:2]}/{hash}.gz  - compressed file blobs
+ *   ~/.clopen/snapshots/trees/{snapshotId}.json       - tree maps (filepath -> hash)
+ *
+ * Deduplication: Same file content across any snapshot is stored only once.
+ * Compression: All blobs are gzip compressed to minimize disk usage.
+ */
+
+import { join } from 'path';
+import { homedir } from 'os';
+import fs from 'fs/promises';
+import { gzipSync, gunzipSync } from 'zlib';
+import { debug } from '$shared/utils/logger';
+
+const SNAPSHOTS_DIR = join(homedir(), '.clopen', 'snapshots');
+const BLOBS_DIR = join(SNAPSHOTS_DIR, 'blobs');
+const TREES_DIR = join(SNAPSHOTS_DIR, 'trees');
+
+export interface TreeMap {
+	[filepath: string]: string; // filepath -> blob hash
+}
+
+interface FileHashCacheEntry {
+	mtimeMs: number;
+	size: number;
+	hash: string;
+}
+
+class BlobStore {
+	private initialized = false;
+
+	/**
+	 * Cache: filepath -> { mtimeMs, size, hash }
+	 * Avoids re-reading files that haven't changed (based on mtime + size).
+	 */
+	private fileHashCache = new Map<string, FileHashCacheEntry>();
+
+	/**
+	 * Ensure storage directories exist
+	 */
+	async init(): Promise<void> {
+		if (this.initialized) return;
+		await fs.mkdir(BLOBS_DIR, { recursive: true });
+		await fs.mkdir(TREES_DIR, { recursive: true });
+		this.initialized = true;
+	}
+
+	/**
+	 * Compute SHA-256 hash of content (Buffer for binary safety)
+	 */
+	hashContent(content: Buffer): string {
+		const hasher = new Bun.CryptoHasher('sha256');
+		hasher.update(content);
+		return hasher.digest('hex');
+	}
+
+	/**
+	 * Get blob file path from hash (using 2-char prefix subdirectory like git)
+	 */
+	private getBlobPath(hash: string): string {
+		const prefix = hash.substring(0, 2);
+		return join(BLOBS_DIR, prefix, hash + '.gz');
+	}
+
+	/**
+	 * Check if a blob exists
+	 */
+	async hasBlob(hash: string): Promise<boolean> {
+		try {
+			await fs.access(this.getBlobPath(hash));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Store content as a blob. Returns the hash.
+	 * If blob already exists (same hash), it's a no-op (deduplication).
+	 * Accepts Buffer to safely handle both text and binary files.
+	 */
+	async storeBlob(content: Buffer): Promise<string> {
+		await this.init();
+		const hash = this.hashContent(content);
+
+		// Check if already exists (deduplication)
+		if (await this.hasBlob(hash)) {
+			return hash;
+		}
+
+		// Create prefix directory
+		const prefixDir = join(BLOBS_DIR, hash.substring(0, 2));
+		await fs.mkdir(prefixDir, { recursive: true });
+
+		// Compress and write (Buffer directly, no encoding conversion)
+		const compressed = gzipSync(content);
+		await fs.writeFile(this.getBlobPath(hash), compressed);
+
+		return hash;
+	}
+
+	/**
+	 * Read blob content by hash. Returns Buffer to safely handle binary files.
+	 */
+	async readBlob(hash: string): Promise<Buffer> {
+		const blobPath = this.getBlobPath(hash);
+		const compressed = await fs.readFile(blobPath);
+		return gunzipSync(compressed);
+	}
+
+	/**
+	 * Store a tree (snapshot state) as a JSON file.
+	 * Returns the tree hash for reference.
+	 */
+	async storeTree(snapshotId: string, tree: TreeMap): Promise<string> {
+		await this.init();
+		const treePath = join(TREES_DIR, `${snapshotId}.json`);
+		const content = JSON.stringify(tree);
+		const treeHash = this.hashContent(Buffer.from(content, 'utf-8'));
+		await fs.writeFile(treePath, content, 'utf-8');
+		return treeHash;
+	}
+
+	/**
+	 * Read a tree by snapshot ID
+	 */
+	async readTree(snapshotId: string): Promise<TreeMap> {
+		const treePath = join(TREES_DIR, `${snapshotId}.json`);
+		const content = await fs.readFile(treePath, 'utf-8');
+		return JSON.parse(content) as TreeMap;
+	}
+
+	/**
+	 * Check if a tree exists
+	 */
+	async hasTree(snapshotId: string): Promise<boolean> {
+		try {
+			await fs.access(join(TREES_DIR, `${snapshotId}.json`));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Resolve a tree to full file contents (as Buffers).
+	 * Reads all blobs in parallel for performance.
+	 * Returns { filepath: Buffer } map for binary-safe handling.
+	 */
+	async resolveTree(tree: TreeMap): Promise<Record<string, Buffer>> {
+		const result: Record<string, Buffer> = {};
+
+		const entries = Object.entries(tree);
+		const blobPromises = entries.map(async ([filepath, hash]) => {
+			try {
+				const content = await this.readBlob(hash);
+				return { filepath, content };
+			} catch (err) {
+				debug.warn('snapshot', `Could not read blob ${hash} for ${filepath}:`, err);
+				return null;
+			}
+		});
+
+		const results = await Promise.all(blobPromises);
+		for (const r of results) {
+			if (r) {
+				result[r.filepath] = r.content;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Hash a file using mtime cache. Returns { hash, content? }.
+	 * If the file hasn't changed (same mtime+size), returns cached hash without reading content.
+	 * If the file has changed, reads content, hashes it, stores blob, and caches.
+	 * Reads as Buffer to safely handle binary files (images, PDFs, etc.).
+	 *
+	 * @returns hash and content Buffer (content is null if cache hit and blob already exists)
+	 */
+	async hashFile(filepath: string, fullPath: string): Promise<{ hash: string; content: Buffer | null; cached: boolean }> {
+		await this.init();
+
+		const stat = await fs.stat(fullPath);
+
+		// Check mtime cache
+		const cached = this.fileHashCache.get(filepath);
+		if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+			return { hash: cached.hash, content: null, cached: true };
+		}
+
+		// File changed - read as Buffer (binary-safe, no encoding conversion)
+		const content = await fs.readFile(fullPath);
+		const hash = this.hashContent(content);
+
+		// Store blob (deduplication handled internally)
+		await this.storeBlob(content);
+
+		// Update cache
+		this.fileHashCache.set(filepath, {
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			hash
+		});
+
+		return { hash, content, cached: false };
+	}
+
+	/**
+	 * Delete a tree file (cleanup)
+	 */
+	async deleteTree(snapshotId: string): Promise<void> {
+		try {
+			await fs.unlink(join(TREES_DIR, `${snapshotId}.json`));
+		} catch {
+			// Ignore - might not exist
+		}
+	}
+}
+
+// Export singleton
+export const blobStore = new BlobStore();