pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/packages/runtime/workspace-manager.ts

@@ -0,0 +1,591 @@
+/**
+ * Workspace Manager — RFC-0026
+ *
+ * Manages workspace directories, worktrees, and cleanup for the harness runtime.
+ *
+ * Features:
+ * - Workspace lifecycle management
+ * - Worktree creation and cleanup
+ * - Disk usage tracking
+ * - Automatic cleanup policies
+ * - Workspace snapshots
+ */
+
+import {
+	existsSync,
+	mkdirSync,
+	rmSync,
+	readdirSync,
+	statSync,
+	writeFileSync,
+	readFileSync,
+	cpSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { EventEmitter } from "node:events";
+
+export interface Workspace {
+	id: string;
+	path: string;
+	createdAt: string;
+	lastAccessedAt: string;
+	owner: string; // jobId
+	purpose: string;
+	sizeBytes: number;
+	worktree?: string; // Git worktree path
+	isActive: boolean;
+	metadata: Record<string, unknown>;
+}
+
+export interface WorkspaceConfig {
+	/** Root directory for workspaces (default: ~/.pi/workspaces) */
+	rootDir?: string;
+	/** Maximum workspace age in days (default: 7) */
+	maxAgeDays?: number;
+	/** Maximum disk usage in bytes (default: 10GB) */
+	maxDiskUsage?: number;
+	/** Enable automatic cleanup (default: true) */
+	autoCleanup?: boolean;
+	/** Cleanup interval in ms (default: 1 hour) */
+	cleanupIntervalMs?: number;
+	/** Workspace prefix (default: ws-) */
+	prefix?: string;
+}
+
+export interface WorkspaceEvent {
+	workspaceId: string;
+	timestamp: string;
+	type: "created" | "accessed" | "cleaned" | "deleted" | "error";
+	details?: string;
+}
+
+const DEFAULT_CONFIG: Required<Omit<WorkspaceConfig, "rootDir">> = {
+	maxAgeDays: 7,
+	maxDiskUsage: 10 * 1024 * 1024 * 1024, // 10GB
+	autoCleanup: true,
+	cleanupIntervalMs: 3600000, // 1 hour
+	prefix: "ws-",
+};
+
+export class WorkspaceManager extends EventEmitter {
+	private readonly config: WorkspaceConfig;
+	private readonly rootDir: string;
+	private workspaces: Map<string, Workspace> = new Map();
+	private cleanupTimer: NodeJS.Timeout | null = null;
+	private manifestPath: string;
+
+	constructor(config: WorkspaceConfig = {}) {
+		super();
+		this.config = { ...DEFAULT_CONFIG, ...config };
+		this.rootDir = this.config.rootDir ?? join(homedir(), ".pi", "workspaces");
+		this.manifestPath = join(this.rootDir, "workspaces.json");
+
+		this.ensureRootDir();
+		this.loadManifest();
+	}
+
+	/**
+	 * Create a new workspace
+	 */
+	create(options: {
+		owner: string;
+		purpose: string;
+		fromTemplate?: string;
+		metadata?: Record<string, unknown>;
+	}): Workspace {
+		const id = this.generateId();
+		const path = join(this.rootDir, id);
+
+		// Create directory
+		mkdirSync(path, { recursive: true });
+
+		// Copy template if specified
+		if (options.fromTemplate && existsSync(options.fromTemplate)) {
+			this.copyDirectory(options.fromTemplate, path);
+		}
+
+		const workspace: Workspace = {
+			id,
+			path,
+			createdAt: new Date().toISOString(),
+			lastAccessedAt: new Date().toISOString(),
+			owner: options.owner,
+			purpose: options.purpose,
+			sizeBytes: this.calculateDirSize(path),
+			isActive: true,
+			metadata: options.metadata ?? {},
+		};
+
+		this.workspaces.set(id, workspace);
+		this.saveManifest();
+
+		this.emit("workspace", {
+			workspaceId: id,
+			timestamp: new Date().toISOString(),
+			type: "created",
+			details: `Created workspace for ${options.owner}: ${options.purpose}`,
+		});
+
+		return workspace;
+	}
+
+	/**
+	 * Get a workspace by ID
+	 */
+	get(id: string): Workspace | null {
+		const workspace = this.workspaces.get(id);
+		if (workspace) {
+			// Update last accessed
+			workspace.lastAccessedAt = new Date().toISOString();
+			this.saveManifest();
+		}
+		return workspace ?? null;
+	}
+
+	/**
+	 * Get workspace by path
+	 */
+	getByPath(path: string): Workspace | null {
+		for (const workspace of Array.from(this.workspaces.values())) {
+			if (workspace.path === path || workspace.path.startsWith(path + "/")) {
+				return workspace;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * List all workspaces
+	 */
+	list(filter?: {
+		owner?: string;
+		isActive?: boolean;
+		olderThan?: Date;
+	}): Workspace[] {
+		let result = Array.from(this.workspaces.values());
+
+		if (filter?.owner) {
+			result = result.filter((ws) => ws.owner === filter.owner);
+		}
+
+		if (filter?.isActive !== undefined) {
+			result = result.filter((ws) => ws.isActive === filter.isActive);
+		}
+
+		if (filter?.olderThan) {
+			result = result.filter(
+				(ws) => new Date(ws.lastAccessedAt) < filter.olderThan!,
+			);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Update workspace metadata
+	 */
+	update(id: string, updates: Partial<Workspace>): boolean {
+		const workspace = this.workspaces.get(id);
+		if (!workspace) {
+			return false;
+		}
+
+		Object.assign(workspace, updates, {
+			lastAccessedAt: new Date().toISOString(),
+		});
+
+		this.saveManifest();
+		return true;
+	}
+
+	/**
+	 * Mark workspace as complete (no longer active)
+	 */
+	complete(id: string): boolean {
+		return this.update(id, { isActive: false });
+	}
+
+	/**
+	 * Delete a workspace
+	 */
+	delete(id: string, force: boolean = false): boolean {
+		const workspace = this.workspaces.get(id);
+		if (!workspace) {
+			return false;
+		}
+
+		// Check if active and not forced
+		if (workspace.isActive && !force) {
+			return false;
+		}
+
+		// Delete directory
+		try {
+			rmSync(workspace.path, { recursive: true, force: true });
+		} catch (error) {
+			this.emit("workspace", {
+				workspaceId: id,
+				timestamp: new Date().toISOString(),
+				type: "error",
+				details: `Failed to delete: ${error}`,
+			});
+			return false;
+		}
+
+		this.workspaces.delete(id);
+		this.saveManifest();
+
+		this.emit("workspace", {
+			workspaceId: id,
+			timestamp: new Date().toISOString(),
+			type: "deleted",
+			details: `Deleted workspace ${id}`,
+		});
+
+		return true;
+	}
+
+	/**
+	 * Delete all workspaces for an owner
+	 */
+	deleteByOwner(owner: string, force: boolean = false): number {
+		const toDelete = this.list({ owner, isActive: false });
+		let deleted = 0;
+
+		for (const workspace of toDelete) {
+			if (this.delete(workspace.id, force)) {
+				deleted++;
+			}
+		}
+
+		return deleted;
+	}
+
+	/**
+	 * Get workspace disk usage
+	 */
+	getDiskUsage(): { total: number; byOwner: Record<string, number> } {
+		const byOwner: Record<string, number> = {};
+		let total = 0;
+
+		for (const workspace of Array.from(this.workspaces.values())) {
+			const size = workspace.sizeBytes;
+			total += size;
+			byOwner[workspace.owner] = (byOwner[workspace.owner] ?? 0) + size;
+		}
+
+		return { total, byOwner };
+	}
+
+	/**
+	 * Check if cleanup is needed
+	 */
+	isCleanupNeeded(): boolean {
+		const usage = this.getDiskUsage();
+
+		// Check disk usage
+		const maxDisk = this.config.maxDiskUsage ?? DEFAULT_CONFIG.maxDiskUsage;
+		if (usage.total > maxDisk) {
+			return true;
+		}
+
+		// Check for old workspaces
+		const cutoff = new Date();
+		const maxAge = this.config.maxAgeDays ?? DEFAULT_CONFIG.maxAgeDays;
+		if (maxAge) {
+			cutoff.setDate(cutoff.getDate() - maxAge);
+		}
+
+		for (const workspace of Array.from(this.workspaces.values())) {
+			if (new Date(workspace.lastAccessedAt) < cutoff) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Run cleanup
+	 */
+	cleanup(options?: {
+		olderThanDays?: number;
+		owner?: string;
+		dryRun?: boolean;
+	}): { deleted: number; freedBytes: number; workspaces: string[] } {
+		const olderThan = new Date();
+		const daysToSubtract = options?.olderThanDays ?? this.config.maxAgeDays;
+		if (daysToSubtract) {
+			olderThan.setDate(olderThan.getDate() - daysToSubtract);
+		}
+
+		const toDelete = this.list({
+			owner: options?.owner,
+			isActive: false,
+			olderThan,
+		});
+
+		let deleted = 0;
+		let freedBytes = 0;
+		const deletedIds: string[] = [];
+
+		for (const workspace of Array.from(toDelete)) {
+			if (options?.dryRun) {
+				deletedIds.push(workspace.id);
+				freedBytes += workspace.sizeBytes;
+				deleted++;
+			} else {
+				if (this.delete(workspace.id, true)) {
+					deletedIds.push(workspace.id);
+					freedBytes += workspace.sizeBytes;
+					deleted++;
+
+					this.emit("workspace", {
+						workspaceId: workspace.id,
+						timestamp: new Date().toISOString(),
+						type: "cleaned",
+						details: `Cleaned up workspace (${freedBytes} bytes freed)`,
+					});
+				}
+			}
+		}
+
+		return { deleted, freedBytes, workspaces: deletedIds };
+	}
+
+	/**
+	 * Create a worktree from a workspace
+	 */
+	createWorktree(workspaceId: string, branchName: string): string | null {
+		const workspace = this.workspaces.get(workspaceId);
+		if (!workspace) {
+			return null;
+		}
+
+		const worktreePath = join(this.rootDir, `${workspaceId}-${branchName}`);
+
+		// This would typically use git worktree add
+		// For now, create a symlink-style directory
+		try {
+			cpSync(workspace.path, worktreePath, { recursive: true });
+			workspace.worktree = worktreePath;
+			this.saveManifest();
+
+			return worktreePath;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Start automatic cleanup timer
+	 */
+	startAutoCleanup(): void {
+		if (this.cleanupTimer) {
+			return;
+		}
+
+		this.cleanupTimer = setInterval(() => {
+			if (this.isCleanupNeeded()) {
+				this.cleanup();
+			}
+		}, this.config.cleanupIntervalMs);
+	}
+
+	/**
+	 * Stop automatic cleanup timer
+	 */
+	stopAutoCleanup(): void {
+		if (this.cleanupTimer) {
+			clearInterval(this.cleanupTimer);
+			this.cleanupTimer = null;
+		}
+	}
+
+	/**
+	 * Snapshot a workspace
+	 */
+	snapshot(workspaceId: string, name: string): string | null {
+		const workspace = this.workspaces.get(workspaceId);
+		if (!workspace) {
+			return null;
+		}
+
+		const snapshotDir = join(this.rootDir, ".snapshots", workspaceId);
+		const snapshotPath = join(snapshotDir, `${name}-${Date.now()}.tar.gz`);
+
+		try {
+			mkdirSync(snapshotDir, { recursive: true });
+			// In a real implementation, we'd use tar or a proper archive library
+			// For now, just copy the directory
+			cpSync(workspace.path, snapshotPath, { recursive: true });
+			return snapshotPath;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Get workspace statistics
+	 */
+	getStats(): {
+		total: number;
+		active: number;
+		totalSize: number;
+		oldest: string | null;
+		newest: string | null;
+	} {
+		let total = 0;
+		let active = 0;
+		let totalSize = 0;
+		let oldest: string | null = null;
+		let newest: string | null = null;
+		let oldestDate = new Date(0);
+		let newestDate = new Date(0);
+
+		for (const workspace of Array.from(this.workspaces.values())) {
+			total++;
+			totalSize += workspace.sizeBytes;
+
+			if (workspace.isActive) active++;
+
+			const created = new Date(workspace.createdAt);
+			if (created > newestDate) {
+				newestDate = created;
+				newest = workspace.id;
+			}
+			if (created < oldestDate) {
+				oldestDate = created;
+				oldest = workspace.id;
+			}
+		}
+
+		return { total, active, totalSize, oldest, newest };
+	}
+
+	/**
+	 * Verify workspace integrity
+	 */
+	verify(id: string): { exists: boolean; size: number; isAccessible: boolean } {
+		const workspace = this.workspaces.get(id);
+		if (!workspace) {
+			return { exists: false, size: 0, isAccessible: false };
+		}
+
+		const exists = existsSync(workspace.path);
+		let size = 0;
+		let isAccessible = false;
+
+		if (exists) {
+			try {
+				size = this.calculateDirSize(workspace.path);
+				isAccessible = true;
+
+				// Update stored size
+				this.update(id, { sizeBytes: size });
+			} catch {
+				isAccessible = false;
+			}
+		}
+
+		return { exists, size, isAccessible };
+	}
+
+	// ─── Private Methods ────────────────────────────────────────────────
+
+	private ensureRootDir(): void {
+		if (!existsSync(this.rootDir)) {
+			mkdirSync(this.rootDir, { recursive: true });
+		}
+	}
+
+	private generateId(): string {
+		const timestamp = Date.now().toString(36);
+		const random = Math.random().toString(36).substring(2, 8);
+		return `${this.config.prefix}${timestamp}-${random}`;
+	}
+
+	private calculateDirSize(dirPath: string): number {
+		if (!existsSync(dirPath)) {
+			return 0;
+		}
+
+		let size = 0;
+
+		try {
+			const entries = readdirSync(dirPath, { withFileTypes: true });
+
+			for (const entry of entries) {
+				const fullPath = join(dirPath, entry.name);
+
+				if (entry.isDirectory()) {
+					size += this.calculateDirSize(fullPath);
+				} else if (entry.isFile()) {
+					try {
+						size += statSync(fullPath).size;
+					} catch {
+						// Skip inaccessible files
+					}
+				}
+			}
+		} catch {
+			// Skip inaccessible directories
+		}
+
+		return size;
+	}
+
+	private copyDirectory(src: string, dest: string): void {
+		if (!existsSync(src)) {
+			return;
+		}
+
+		mkdirSync(dest, { recursive: true });
+		cpSync(src, dest, { recursive: true });
+	}
+
+	private loadManifest(): void {
+		if (!existsSync(this.manifestPath)) {
+			return;
+		}
+
+		try {
+			const data = readFileSync(this.manifestPath, "utf-8");
+			const workspaces = JSON.parse(data) as Workspace[];
+
+			for (const workspace of workspaces) {
+				this.workspaces.set(workspace.id, workspace);
+			}
+		} catch {
+			// Ignore corrupt manifest
+		}
+	}
+
+	private saveManifest(): void {
+		const workspaces = Array.from(this.workspaces.values());
+
+		try {
+			writeFileSync(
+				this.manifestPath,
+				JSON.stringify(workspaces, null, 2),
+				"utf-8",
+			);
+		} catch {
+			// Ignore save errors
+		}
+	}
+}
+
+/**
+ * Create a WorkspaceManager with default config for harness runtime
+ */
+export function createHarnessWorkspaceManager(): WorkspaceManager {
+	return new WorkspaceManager({
+		rootDir: join(homedir(), ".pi", "harness", "workspaces"),
+		maxAgeDays: 7,
+		maxDiskUsage: 10 * 1024 * 1024 * 1024, // 10GB
+		autoCleanup: true,
+		cleanupIntervalMs: 3600000, // 1 hour
+	});
+}