pi-harness-runtime 0.10.7 → 0.10.11

package/packages/runtime/workspace-manager.ts

@@ -1,591 +0,0 @@
-/**
- * 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
-	});
-}

package/packages/scheduler/README.md

@@ -1,3 +0,0 @@
-# packages/scheduler
-
-Local scheduler and resume timers will live here.

package/packages/scheduler/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "@pi-harness/scheduler",
-  "version": "0.10.7",
-  "description": "pi-harness-runtime — scheduler",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "bun test"
-  },
-  "dependencies": {}
-}

package/packages/scheduler/src/scheduler.ts

@@ -1,50 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-export interface ScheduledJob {
-  jobId: string;
-  status: "scheduled" | "cancelled";
-  reason: string;
-  resumeAt: string;
-}
-
-export class JsonRuntimeScheduler {
-  constructor(private readonly rootDir: string) {}
-
-  private schedulePath(): string {
-    return join(this.rootDir, "schedule.json");
-  }
-
-  async readAll(): Promise<ScheduledJob[]> {
-    try {
-      const text = await readFile(this.schedulePath(), "utf-8");
-      return JSON.parse(text) as ScheduledJob[];
-    } catch {
-      return [];
-    }
-  }
-
-  async writeAll(jobs: ScheduledJob[]): Promise<void> {
-    await mkdir(this.rootDir, { recursive: true });
-    await writeFile(this.schedulePath(), JSON.stringify(jobs, null, 2) + "\n", "utf-8");
-  }
-
-  async scheduleResume(jobId: string, resumeAt: string, reason: string): Promise<void> {
-    const jobs = (await this.readAll()).filter((j) => j.jobId !== jobId);
-    jobs.push({ jobId, status: "scheduled", resumeAt, reason });
-    await this.writeAll(jobs);
-  }
-
-  async dueJobs(now: Date = new Date()): Promise<string[]> {
-    const nowMs = now.getTime();
-    return (await this.readAll())
-      .filter((j) => j.status === "scheduled")
-      .filter((j) => Date.parse(j.resumeAt) <= nowMs)
-      .map((j) => j.jobId);
-  }
-
-  async cancel(jobId: string): Promise<void> {
-    const jobs = await this.readAll();
-    await this.writeAll(jobs.map((j) => j.jobId === jobId ? { ...j, status: "cancelled" } : j));
-  }
-}