pi-crew 0.5.2 → 0.5.5

package/src/runtime/foreground-control.ts

@@ -4,6 +4,8 @@ import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
 import { readCrewAgents } from "./crew-agent-records.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { sleepSync } from "../utils/sleep.ts";
 
 export type ForegroundControlRequestType = "interrupt" | "status";
 
@@ -59,24 +61,92 @@ export function readForegroundControlStatus(manifest: TeamRunManifest, tasks: Te
 
 export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reason = "User requested foreground interrupt."): ForegroundControlRequest {
 	const controlPath = foregroundControlPath(manifest);
+	const lockDir = `${controlPath}.lock`;
+	const pidFile = path.join(lockDir, "pid");
 	let requests: ForegroundControlRequest[] = [];
-	if (fs.existsSync(controlPath)) {
-		try {
-			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
-			requests = Array.isArray(parsed.requests) ? parsed.requests : [];
-		} catch {
-			requests = [];
+
+	// FIX: Use file locking to prevent race condition in read-modify-write
+	// Added stale lock detection similar to event-log.ts
+	const acquireLock = (): void => {
+		const timeout = 5000;
+		const staleMs = 10000;
+		const start = Date.now();
+		while (true) {
+			try {
+				fs.mkdirSync(lockDir, { recursive: true });
+				try { fs.writeFileSync(pidFile, String(process.pid), "utf-8"); } catch { /* best-effort */ }
+				break;
+			} catch {
+				if (Date.now() - start > timeout) {
+					// Check if lock is stale before giving up
+					try {
+						const raw = fs.readFileSync(pidFile, "utf-8").trim();
+						const ownerPid = Number.parseInt(raw, 10);
+						if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
+							let alive = false;
+							try { process.kill(ownerPid, 0); alive = true; } catch { /* dead */ }
+							if (!alive) {
+								// Lock is stale — clear it and retry
+								fs.rmSync(lockDir, { recursive: true, force: true });
+								continue;
+							}
+							// Lock held by live process — throw
+							const err = new Error(`Foreground control lock timeout for ${controlPath}`);
+							logInternalError("foreground-control.lock-timeout", err, `controlPath=${controlPath}`);
+							throw err;
+						}
+					} catch { /* no pid file — continue to throw */ }
+					const err = new Error(`Foreground control lock timeout for ${controlPath}`);
+					logInternalError("foreground-control.lock-timeout", err, `controlPath=${controlPath}`);
+					throw err;
+				}
+				// Stale detection: if the owning process is dead, remove the stale lock
+				try {
+					const raw = fs.readFileSync(pidFile, "utf-8").trim();
+					const ownerPid = Number.parseInt(raw, 10);
+					if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
+						let alive = false;
+						try { process.kill(ownerPid, 0); alive = true; } catch { /* dead */ }
+						if (!alive) {
+							const stat = fs.statSync(lockDir);
+							if (Date.now() - stat.mtimeMs > staleMs) {
+								fs.rmSync(lockDir, { recursive: true, force: true });
+								continue;
+							}
+						}
+					}
+				} catch { /* no pid file — fall through to sleep */ }
+				// Brief sleep to avoid CPU spinning
+				sleepSync(10);
+			}
 		}
-	}
-	const request: ForegroundControlRequest = {
-		id: `fg_${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 10)}`,
-		type: "interrupt",
-		createdAt: new Date().toISOString(),
-		reason,
-		acknowledged: false,
 	};
-	fs.mkdirSync(path.dirname(controlPath), { recursive: true });
-	fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
-	appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
-	return request;
+	const releaseLock = (): void => {
+		try { fs.rmSync(lockDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+	};
+
+	acquireLock();
+	try {
+		if (fs.existsSync(controlPath)) {
+			try {
+				const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+				requests = Array.isArray(parsed.requests) ? parsed.requests : [];
+			} catch {
+				requests = [];
+			}
+		}
+		const request: ForegroundControlRequest = {
+			id: `fg_${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 10)}`,
+			type: "interrupt",
+			createdAt: new Date().toISOString(),
+			reason,
+			acknowledged: false,
+		};
+		fs.mkdirSync(path.dirname(controlPath), { recursive: true });
+		fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
+		appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
+		return request;
+	} finally {
+		releaseLock();
+	}
 }

package/src/runtime/pi-args.ts

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { AgentConfig } from "../agents/agent-config.ts";
+import { getAgentSessionOptions } from "../agents/agent-config.ts";
 
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const PROMPT_RUNTIME_EXTENSION_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "prompt", "prompt-runtime.ts");
@@ -17,6 +18,8 @@ export interface BuildPiWorkerArgsInput {
 	maxDepth?: number;
 	skillPaths?: string[];
 	env?: NodeJS.ProcessEnv;
+	/** Role for tool restrictions (uses role-tools.ts config) */
+	role?: string;
 }
 
 export interface BuildPiWorkerArgsResult {
@@ -99,7 +102,14 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		args.push("--thinking", input.agent.thinking);
 	}
 
-	if (input.agent.tools?.length) args.push("--tools", input.agent.tools.join(","));
+	// Apply role-based tool restrictions (from role-tools.ts)
+	// Role-specific config takes precedence over agent-defined tools
+	const toolConfig = input.role ? getAgentSessionOptions(input.role) : {};
+	const explicitTools = toolConfig.tools ?? input.agent.tools;
+	const excludeTools = toolConfig.excludeTools;
+
+	if (explicitTools?.length) args.push("--tools", explicitTools.join(","));
+	if (excludeTools?.length) args.push("--exclude-tools", excludeTools.join(","));
 	// Always add --no-extensions before --extension to prevent user extensions from being auto-loaded.
 	// User extensions in ~/.pi/agent/extensions/ may fail due to missing dependencies.
 	args.push("--no-extensions");

package/src/runtime/pi-json-output.ts

@@ -12,6 +12,8 @@ export interface ParsedPiJsonOutput {
 	textEvents: string[];
 	finalText?: string;
 	usage?: ParsedPiUsage;
+	/** Unified patches extracted from tool_result events (edit tool patch field) */
+	patches?: string[];
 }
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -87,6 +89,7 @@ function extractText(value: unknown): string[] {
 export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
 	let jsonEvents = 0;
 	const textEvents: string[] = [];
+	const patches: string[] = [];
 	let usage: ParsedPiUsage | undefined;
 	for (const line of stdout.split("\n")) {
 		const trimmed = line.trim();
@@ -99,6 +102,8 @@ export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
 		}
 		jsonEvents++;
 		textEvents.push(...extractText(event));
+		// Extract unified patches from tool_result events
+		extractPatch(event, patches);
 		const eventUsage = extractUsage(event);
 		if (eventUsage) usage = mergeUsage(usage ?? {}, eventUsage);
 	}
@@ -107,5 +112,31 @@ export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
 		textEvents,
 		finalText: textEvents.length > 0 ? textEvents[textEvents.length - 1] : undefined,
 		usage,
+		patches: patches.length > 0 ? patches : undefined,
 	};
 }
+
+/**
+ * Extract unified patches from a tool_result event.
+ * pi's edit tool now includes a `patch` field (standard unified diff format).
+ * We detect it by looking for lines starting with "---" or "+++" which indicate
+ * unified diff format.
+ */
+function extractPatch(event: unknown, patches: string[]): void {
+	const obj = asRecord(event);
+	if (!obj || obj.type !== "tool_result") return;
+
+	const content = obj.content;
+	if (!Array.isArray(content)) return;
+
+	for (const item of content) {
+		const part = asRecord(item);
+		if (!part || part.type !== "text") continue;
+		const text = typeof part.text === "string" ? part.text : "";
+
+		// Check if this looks like a unified patch (starts with "---" or "+++")
+		if (text.includes("--- a/") || text.includes("diff ---")) {
+			patches.push(text);
+		}
+	}
+}

package/src/runtime/progress-tracker.ts

@@ -0,0 +1,124 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import { crewEventBus } from "../observability/event-bus.ts";
+
+export interface AgentProgress {
+  toolCalls: number;
+  currentTool: string | null;
+  toolStartTime: number | null;
+  errors: string[];
+  turns: number;
+  tokens: { input: number; output: number };
+  status: "idle" | "running" | "completed" | "error";
+}
+
+export class ProgressTracker {
+  private sessions = new Map<string, {
+    unsubscribe: () => void;
+    progress: AgentProgress;
+  }>();
+
+  track(
+    session: { subscribe: (listener: (event: AgentSessionEvent) => void) => () => void },
+    agentId: string,
+    runId: string
+  ): AgentProgress {
+    if (this.sessions.has(agentId)) {
+      return this.sessions.get(agentId)!.progress;
+    }
+
+    const progress: AgentProgress = {
+      toolCalls: 0,
+      currentTool: null,
+      toolStartTime: null,
+      errors: [],
+      turns: 0,
+      tokens: { input: 0, output: 0 },
+      status: "running",
+    };
+
+    const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+      this.handleEvent(event, progress, agentId, runId);
+    });
+
+    this.sessions.set(agentId, { unsubscribe, progress });
+    return progress;
+  }
+
+  private handleEvent(
+    event: AgentSessionEvent,
+    progress: AgentProgress,
+    agentId: string,
+    runId: string
+  ): void {
+    switch (event.type) {
+      case "tool_execution_start":
+        progress.toolCalls++;
+        progress.currentTool = event.toolName;
+        progress.toolStartTime = Date.now();
+        crewEventBus.emit({
+          type: "agent:progress",
+          runId,
+          agentId,
+          payload: { ...progress },
+          timestamp: Date.now(),
+        });
+        break;
+
+      case "tool_execution_end":
+        progress.currentTool = null;
+        progress.toolStartTime = null;
+        if (event.isError) {
+          progress.errors.push(String(event.result ?? "Unknown error"));
+          crewEventBus.emit({
+            type: "agent:error",
+            runId,
+            agentId,
+            payload: String(event.result ?? "Unknown error"),
+            timestamp: Date.now(),
+          });
+        }
+        crewEventBus.emit({
+          type: "agent:progress",
+          runId,
+          agentId,
+          payload: { ...progress },
+          timestamp: Date.now(),
+        });
+        break;
+
+      case "turn_start":
+        progress.turns++;
+        break;
+
+      case "agent_end":
+        progress.status = "completed";
+        crewEventBus.emit({
+          type: "agent:complete",
+          runId,
+          agentId,
+          payload: { ...progress },
+          timestamp: Date.now(),
+        });
+        break;
+
+      case "agent_start":
+        progress.status = "running";
+        break;
+    }
+  }
+
+  untrack(agentId: string): void {
+    const tracked = this.sessions.get(agentId);
+    if (tracked) {
+      tracked.unsubscribe();
+      this.sessions.delete(agentId);
+    }
+  }
+
+  getProgress(agentId: string): AgentProgress | undefined {
+    return this.sessions.get(agentId)?.progress;
+  }
+}
+
+// Export singleton instance
+export const globalProgressTracker = new ProgressTracker();