pi-harness-runtime 1.1.429 → 1.1.431

package/packages/runtime/command-executor.ts

@@ -1,523 +0,0 @@
-/**
- * Command Executor — RFC-0025
- *
- * Safe shell command execution with timeout, output capture, and security policies.
- *
- * Features:
- * - Timeout enforcement
- * - Output capture (stdout/stderr)
- * - Working directory control
- * - Environment variable injection
- * - Security policy enforcement
- * - Process management (kill, signal)
- */
-
-import {
-	spawn,
-	type ChildProcess,
-	type SpawnOptions,
-} from "node:child_process";
-import { EventEmitter } from "node:events";
-import { join } from "node:path";
-
-export interface CommandResult {
-	success: boolean;
-	exitCode: number | null;
-	stdout: string;
-	stderr: string;
-	timedOut: boolean;
-	duration: number;
-	command: string;
-}
-
-export interface CommandOptions {
-	/** Working directory (default: process.cwd()) */
-	cwd?: string;
-	/** Environment variables to inject */
-	env?: Record<string, string>;
-	/** Timeout in milliseconds (default: no timeout) */
-	timeout?: number;
-	/** Shell to use (default: /bin/sh on Unix, cmd.exe on Windows) */
-	shell?: string;
-	/** User ID to run as (if available) */
-	uid?: number;
-	/** Group ID to run as (if available) */
-	gid?: number;
-	/** Capture stdout (default: true) */
-	captureStdout?: boolean;
-	/** Capture stderr (default: true) */
-	captureStderr?: boolean;
-	/** Treat non-zero exit as success (default: false) */
-	ignoreExitCode?: boolean;
-	/** Policy to check before execution */
-	policyCheck?: boolean;
-}
-
-export interface CommandPolicy {
-	/** Allowed commands (exact match or pattern) */
-	allowedCommands?: RegExp[];
-	/** Denied commands (takes precedence) */
-	deniedCommands?: RegExp[];
-	/** Maximum timeout in ms */
-	maxTimeout?: number;
-	/** Allowed working directories */
-	allowedDirs?: string[];
-	/** Denied working directories */
-	deniedDirs?: string[];
-	/** Allow shell built-ins */
-	allowShellBuiltins?: boolean;
-	/** Allow environment variable injection */
-	allowEnvInjection?: boolean;
-	/** Commands that require explicit policy bypass */
-	requireApproval?: RegExp[];
-}
-
-export interface CommandEvent {
-	command: string;
-	timestamp: string;
-	pid?: number;
-}
-
-export interface CommandExecutorEvents {
-	onStart: (event: CommandEvent) => void;
-	onExit: (
-		event: CommandEvent & { exitCode: number; duration: number },
-	) => void;
-	onTimeout: (event: CommandEvent) => void;
-	onError: (error: Error, command: string) => void;
-	onPolicyViolation: (reason: string, command: string) => void;
-}
-
-const DEFAULT_POLICY: CommandPolicy = {
-	allowShellBuiltins: true,
-	allowEnvInjection: true,
-	maxTimeout: 300000, // 5 minutes default
-};
-
-export class CommandExecutor extends EventEmitter {
-	private readonly policy: CommandPolicy;
-	private runningProcesses: Map<number, ChildProcess> = new Map();
-	private defaultOptions: CommandOptions;
-
-	constructor(policy: CommandPolicy = {}) {
-		super();
-		this.policy = { ...DEFAULT_POLICY, ...policy };
-		this.defaultOptions = {
-			captureStdout: true,
-			captureStderr: true,
-			ignoreExitCode: false,
-			policyCheck: true,
-		};
-	}
-
-	/**
-	 * Execute a command synchronously
-	 */
-	exec(command: string, options: CommandOptions = {}): CommandResult {
-		const opts = { ...this.defaultOptions, ...options };
-		const startTime = Date.now();
-
-		// Policy check
-		if (opts.policyCheck !== false) {
-			const policyResult = this.checkPolicy(command, opts);
-			if (!policyResult.allowed) {
-				this.emit(
-					"policyViolation",
-					policyResult.reason ?? "Policy violation",
-					command,
-				);
-				return {
-					success: false,
-					exitCode: null,
-					stdout: "",
-					stderr: policyResult.reason ?? "Policy violation",
-					timedOut: false,
-					duration: Date.now() - startTime,
-					command,
-				};
-			}
-		}
-
-		// Spawn process
-		const spawnOpts: SpawnOptions = {
-			cwd: opts.cwd ?? process.cwd(),
-			env: { ...process.env, ...opts.env },
-			shell:
-				opts.shell ?? (process.platform === "win32" ? "cmd.exe" : "/bin/sh"),
-			uid: opts.uid,
-			gid: opts.gid,
-			windowsHide: true,
-		};
-
-		let proc: ChildProcess;
-		try {
-			proc = spawn(command, [], spawnOpts);
-		} catch (error) {
-			this.emit("error", error as Error, command);
-			return {
-				success: false,
-				exitCode: null,
-				stdout: "",
-				stderr: String(error),
-				timedOut: false,
-				duration: Date.now() - startTime,
-				command,
-			};
-		}
-
-		this.runningProcesses.set(proc.pid!, proc);
-
-		const event: CommandEvent = {
-			command,
-			timestamp: new Date().toISOString(),
-			pid: proc.pid,
-		};
-		this.emit("start", event);
-
-		// Collect output
-		let stdout = "";
-		let stderr = "";
-
-		if (opts.captureStdout && proc.stdout) {
-			proc.stdout.on("data", (data) => {
-				stdout += data.toString();
-			});
-		}
-
-		if (opts.captureStderr && proc.stderr) {
-			proc.stderr.on("data", (data) => {
-				stderr += data.toString();
-			});
-		}
-
-		// Handle timeout
-		let timedOutFlag = false;
-		let timeoutId: NodeJS.Timeout | undefined;
-
-		if (opts.timeout && opts.timeout > 0) {
-			const maxTimeout = this.policy.maxTimeout ?? Infinity;
-			const effectiveTimeout = Math.min(opts.timeout, maxTimeout);
-
-			timeoutId = setTimeout(() => {
-				timedOutFlag = true;
-				this.kill(proc.pid!);
-				this.emit("timeout", event);
-			}, effectiveTimeout);
-		}
-
-		// Wait for completion
-		const exitCode = this.waitForExit(proc);
-
-		// Cleanup
-		if (timeoutId) clearTimeout(timeoutId);
-		this.runningProcesses.delete(proc.pid!);
-
-		const duration = Date.now() - startTime;
-		this.emit("exit", { ...event, exitCode: exitCode ?? -1, duration });
-
-		const success: boolean =
-			(exitCode === 0 || opts.ignoreExitCode) && !timedOutFlag ? true : false;
-
-		return {
-			success,
-			exitCode,
-			stdout,
-			stderr,
-			timedOut: timedOutFlag,
-			duration,
-			command,
-		};
-	}
-
-	/**
-	 * Execute a command asynchronously (non-blocking)
-	 */
-	async execAsync(
-		command: string,
-		options: CommandOptions = {},
-	): Promise<CommandResult> {
-		const opts = { ...this.defaultOptions, ...options };
-		const startTime = Date.now();
-
-		// Policy check
-		if (opts.policyCheck !== false) {
-			const policyResult = this.checkPolicy(command, opts);
-			if (!policyResult.allowed) {
-				this.emit(
-					"policyViolation",
-					policyResult.reason ?? "Policy violation",
-					command,
-				);
-				return {
-					success: false,
-					exitCode: null,
-					stdout: "",
-					stderr: policyResult.reason ?? "Policy violation",
-					timedOut: false,
-					duration: Date.now() - startTime,
-					command,
-				};
-			}
-		}
-
-		// Spawn process
-		const spawnOpts: SpawnOptions = {
-			cwd: opts.cwd ?? process.cwd(),
-			env: { ...process.env, ...opts.env },
-			shell:
-				opts.shell ?? (process.platform === "win32" ? "cmd.exe" : "/bin/sh"),
-			uid: opts.uid,
-			gid: opts.gid,
-			windowsHide: true,
-		};
-
-		return new Promise((resolve) => {
-			const proc = spawn(command, [], spawnOpts);
-			this.runningProcesses.set(proc.pid!, proc);
-
-			const event: CommandEvent = {
-				command,
-				timestamp: new Date().toISOString(),
-				pid: proc.pid,
-			};
-			this.emit("start", event);
-
-			// Collect output
-			let stdout = "";
-			let stderr = "";
-
-			if (opts.captureStdout && proc.stdout) {
-				proc.stdout.on("data", (data) => {
-					stdout += data.toString();
-				});
-			}
-
-			if (opts.captureStderr && proc.stderr) {
-				proc.stderr.on("data", (data) => {
-					stderr += data.toString();
-				});
-			}
-
-			// Handle timeout
-			let timedOut = false;
-			const timeoutId = setTimeout(
-				() => {
-					timedOut = true;
-					this.kill(proc.pid!);
-					this.emit("timeout", event);
-				},
-				opts.timeout ?? this.policy.maxTimeout ?? 300000,
-			);
-
-			proc.on("close", (code) => {
-				clearTimeout(timeoutId);
-				this.runningProcesses.delete(proc.pid!);
-
-				const duration = Date.now() - startTime;
-				const exitCode = code !== null ? code : -1;
-				this.emit("exit", { ...event, exitCode, duration });
-
-				const execSuccess: boolean =
-					(code === 0 || opts.ignoreExitCode) && !timedOut ? true : false;
-
-				resolve({
-					success: execSuccess,
-					exitCode: code,
-					stdout,
-					stderr,
-					timedOut: timedOut,
-					duration,
-					command,
-				});
-			});
-
-			proc.on("error", (error) => {
-				clearTimeout(timeoutId);
-				this.runningProcesses.delete(proc.pid!);
-				this.emit("error", error, command);
-
-				resolve({
-					success: false,
-					exitCode: null,
-					stdout,
-					stderr: stderr + "\n" + String(error),
-					timedOut: false,
-					duration: Date.now() - startTime,
-					command,
-				});
-			});
-		});
-	}
-
-	/**
-	 * Kill a running process
-	 */
-	kill(pid: number, signal: NodeJS.Signals = "SIGTERM"): boolean {
-		const proc = this.runningProcesses.get(pid);
-		if (!proc) {
-			return false;
-		}
-
-		try {
-			proc.kill(signal);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	/**
-	 * Kill all running processes
-	 */
-	killAll(signal: NodeJS.Signals = "SIGTERM"): number {
-		let killed = 0;
-		for (const entry of Array.from(this.runningProcesses.entries())) {
-			const [_pid, proc] = entry;
-			try {
-				proc.kill(signal);
-				killed++;
-			} catch {
-				// Process already exited
-			}
-		}
-		this.runningProcesses.clear();
-		return killed;
-	}
-
-	/**
-	 * Get count of running processes
-	 */
-	getRunningCount(): number {
-		return this.runningProcesses.size;
-	}
-
-	/**
-	 * Get list of running process PIDs
-	 */
-	getRunningPids(): number[] {
-		return Array.from(this.runningProcesses.keys());
-	}
-
-	/**
-	 * Check policy for a command
-	 */
-	checkPolicy(
-		command: string,
-		_options?: CommandOptions,
-	): { allowed: boolean; reason?: string } {
-		// Check denied commands
-		if (this.policy.deniedCommands) {
-			for (const pattern of this.policy.deniedCommands) {
-				if (pattern.test(command)) {
-					return {
-						allowed: false,
-						reason: `Command matches denied pattern: ${pattern}`,
-					};
-				}
-			}
-		}
-
-		// Check allowed commands (if specified, must match)
-		if (this.policy.allowedCommands && this.policy.allowedCommands.length > 0) {
-			let allowed = false;
-			for (const pattern of this.policy.allowedCommands) {
-				if (pattern.test(command)) {
-					allowed = true;
-					break;
-				}
-			}
-			if (!allowed) {
-				return {
-					allowed: false,
-					reason: "Command not in allowed list",
-				};
-			}
-		}
-
-		// Check denied directories
-		if (_options?.cwd) {
-			if (this.policy.deniedDirs) {
-				for (const dir of this.policy.deniedDirs) {
-					if (_options.cwd.startsWith(dir)) {
-						return {
-							allowed: false,
-							reason: `Working directory matches denied path: ${dir}`,
-						};
-					}
-				}
-			}
-		}
-
-		// Check for dangerous shell operators
-		const dangerousPatterns = [
-			{ pattern: /;\s*rm\s+-rf/i, reason: "Attempted rm -rf" },
-			{
-				pattern: />\s*\/dev\/null/i,
-				reason: "Output redirection to /dev/null",
-			},
-			{ pattern: /\|\s*sh\s*$/i, reason: "Pipe to shell" },
-			{ pattern: /&\s*$/, reason: "Background execution" },
-		];
-
-		for (const { pattern, reason } of dangerousPatterns) {
-			if (pattern.test(command)) {
-				// Only block if explicitly denied
-				if (this.policy.deniedCommands) {
-					return { allowed: false, reason };
-				}
-			}
-		}
-
-		return { allowed: true };
-	}
-
-	/**
-	 * Update policy at runtime
-	 */
-	updatePolicy(updates: Partial<CommandPolicy>): void {
-		Object.assign(this.policy, updates);
-	}
-
-	/**
-	 * Get current policy
-	 */
-	getPolicy(): CommandPolicy {
-		return { ...this.policy };
-	}
-
-	// ─── Private Methods ────────────────────────────────────────────────
-
-	private waitForExit(_proc: ChildProcess): number | null {
-		// Note: This method is for synchronous execution.
-		// For async execution, use execAsync() which properly handles events.
-		// This returns null for sync - actual exit code is captured via events.
-		return null;
-	}
-}
-
-/**
- * Create a CommandExecutor with safe defaults for harness runtime
- */
-export function createHarnessExecutor(): CommandExecutor {
-	return new CommandExecutor({
-		// Allow common development commands
-		allowedCommands: [
-			/^(git|npm|npx|yarn|pnpm|bun|node|python3?|make|cargo|go)\s/,
-			/^(tsc|esbuild|rollup|vite|webpack)\s/,
-			/^(jest|vitest|mocha|pytest|cargo test|npm test)\s/,
-			/^(eslint|ruff|black|prettier)\s/,
-			/^(mkdir|rm|cp|mv|cat|echo|ls|cd)\s/,
-		],
-		// Deny dangerous patterns
-		deniedCommands: [
-			/rm\s+-rf\s+\/(?!node_modules)/, // rm -rf / except rm -rf node_modules
-			/curl\s+.*\|.*sh$/i, // curl | sh
-			/wget\s+.*\|.*sh$/i, // wget | sh
-			/base64\s+-d\s+.*\|.*sh/i, // base64 decode | sh
-			/:\(\)\{.*\}\s*:/, // Fork bomb
-		],
-		maxTimeout: 300000, // 5 minutes
-		// Default to user's home directory
-		allowedDirs: [join(process.env.HOME ?? "", "")],
-	});
-}

package/packages/runtime/index.ts

@@ -1,50 +0,0 @@
-/**
- * Runtime Package — RFC-0024, RFC-0025, RFC-0026, RFC-0027, RFC-0028
- *
- * Core runtime components for the pi-harness-runtime.
- */
-
-// RFC-0024: Local Runtime Agent
-export { LocalRuntimeAgent, createHarnessRuntimeAgent } from "./local-runtime-agent.js";
-export type { LocalRuntimeAgentConfig, LocalRuntimeAgentEvents, QuotaSummary, AuthSession } from "./local-runtime-agent.js";
-
-// RFC-0025: Command Executor
-export { CommandExecutor, createHarnessExecutor } from "./command-executor.js";
-export type {
-	CommandResult,
-	CommandOptions,
-	CommandPolicy,
-	CommandEvent,
-	CommandExecutorEvents,
-} from "./command-executor.js";
-
-// RFC-0026: Workspace Manager
-export { WorkspaceManager, createHarnessWorkspaceManager } from "./workspace-manager.js";
-export type {
-	Workspace,
-	WorkspaceConfig,
-	WorkspaceEvent,
-} from "./workspace-manager.js";
-
-// RFC-0027: Runtime API
-export { RuntimeApi, createHarnessRuntimeApi } from "./runtime-api.js";
-export type {
-	RuntimeApiConfig,
-	ApiResponse,
-	JobSummary,
-	TaskSummary,
-	RuntimeStatus,
-} from "./runtime-api.js";
-
-// RFC-0028: Policy Engine
-export { PolicyEngine, createHarnessPolicyEngine } from "./policy-engine.js";
-export type {
-	PolicyResult,
-	PolicyContext,
-	Policy,
-	PolicyCondition,
-	PolicyEffect,
-	PolicyRule,
-	RateLimit,
-	AuditEntry,
-} from "./policy-engine.js";