pi-crew 0.9.53 → 0.9.55

package/src/state/worker-atomic-writer.ts

@@ -0,0 +1,198 @@
+/**
+ * Phase 1.5 worker-thread atomic writer (RFC: 15-PHASE1.5-WORKER-WRITER-RFC.md).
+ *
+ * Background: multi-step goal-wrapped workflows crash silently and
+ * non-deterministically during batch transitions. The crash point moves to
+ * every `await` yield in the write path (mkdir, open, stat, rename,
+ * appendEvent). Sync replacements regress. Hypothesis: V8/libuv-level race
+ * during event-loop yields. Mitigation: route writes through a dedicated
+ * worker thread that performs SYNC fs operations with no internal yields.
+ *
+ * Opt-in via `PI_CREW_WORKER_ATOMIC_WRITER=1`. When disabled, callers fall
+ * back to the regular async path. Safe to ship behind a flag.
+ *
+ * Protocol (main → worker):
+ *   { kind: "write", id, filePath, content }
+ *   { kind: "mkdir", id, dirPath }
+ *   { kind: "append", id, filePath, content }
+ *
+ * Protocol (worker → main):
+ *   { kind: "done", id }
+ *   { kind: "error", id, message }
+ */
+
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { Worker } from "node:worker_threads";
+
+const require = createRequire(import.meta.url);
+
+let worker: Worker | undefined;
+let nextRequestId = 1;
+const pending = new Map<number, { resolve: () => void; reject: (e: Error) => void }>();
+
+/** Worker script source — runs SYNC fs ops with no internal yields. */
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require("node:worker_threads");
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+
+function isSymlinkSafePath(filePath) {
+  try {
+    // Safe roots: the system temp dir (resolved through any symlinks, e.g.
+    // macOS /var → /private/var) and the current project cwd.
+    var tmpReal;
+    try { tmpReal = fs.realpathSync(require("node:os").tmpdir()); } catch (e2) { tmpReal = require("node:os").tmpdir(); }
+    var cwd = process.cwd();
+    // Accept a symlink ancestor as safe if the resolved target (a) IS a safe
+    // root, (b) is UNDER a safe root (target is a descendant), or (c) is an
+    // ANCESTOR of a safe root (target is a parent dir of a safe root).
+    // Case (c) is essential on macOS: /var → /private/var is an ancestor of
+    // the tmpdir /private/var/folders/…, so it must be allowed.
+    var isSafeAncestor = function (real) {
+      var roots = [tmpReal, cwd];
+      return roots.some(function (root) {
+        return real === root
+          || real.indexOf(root + path.sep) === 0
+          || root.indexOf(real + path.sep) === 0;
+      });
+    };
+    var currentPath = filePath;
+    while (currentPath !== path.dirname(currentPath)) {
+      var dir = path.dirname(currentPath);
+      try {
+        var stat = fs.lstatSync(dir);
+        if (stat.isSymbolicLink()) {
+          var real = fs.realpathSync(dir);
+          if (!isSafeAncestor(real)) return false;
+        }
+      } catch (e3) { /* not found — fine */ }
+      currentPath = dir;
+    }
+    return true;
+  } catch (e) { return true; }
+}
+
+function syncAtomicWriteFile(filePath, content) {
+  if (!isSymlinkSafePath(filePath)) throw new Error("Refusing to write: unsafe path: " + filePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = filePath + "." + crypto.randomUUID() + ".tmp";
+  try {
+    const fd = fs.openSync(tempPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+    try {
+      fs.writeFileSync(fd, content, "utf-8");
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    try { fs.rmSync(tempPath, { force: true }); } catch (cleanupError) {
+      logInternalError("worker-atomic-writer.cleanup-temp", cleanupError, "tempPath=" + tempPath, "debug");
+    }
+    // If rename raced with another writer that produced identical content, swallow.
+    if (error && error.code === "EEXIST") {
+      try {
+        const existing = fs.readFileSync(filePath, "utf-8");
+        if (existing === content) return;
+      } catch (compareError) {
+        logInternalError("worker-atomic-writer.compare-existing", compareError, "filePath=" + filePath, "debug");
+      }
+    }
+    throw error;
+  }
+}
+
+function syncAppend(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, content, "utf-8");
+}
+
+parentPort.on("message", (msg) => {
+  try {
+    if (msg.kind === "write") syncAtomicWriteFile(msg.filePath, msg.content);
+    else if (msg.kind === "mkdir") fs.mkdirSync(msg.dirPath, { recursive: true });
+    else if (msg.kind === "append") syncAppend(msg.filePath, msg.content);
+    else throw new Error("worker-atomic-writer: unknown message kind: " + msg.kind);
+    parentPort.postMessage({ kind: "done", id: msg.id });
+  } catch (error) {
+    parentPort.postMessage({ kind: "error", id: msg.id, message: error && error.message ? error.message : String(error) });
+  }
+});
+`;
+
+function getWorker(): Worker {
+	if (worker) return worker;
+	// Write worker source to a temp file (so Worker can load it as CJS via
+	// require() inside the worker, which always has CommonJS available).
+	const os = require("node:os");
+	const tmpPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-waw-")), "worker.cjs");
+	fs.writeFileSync(tmpPath, WORKER_SOURCE, "utf-8");
+	worker = new Worker(tmpPath);
+	worker.on("message", (msg: { kind: string; id: number; message?: string }) => {
+		const entry = pending.get(msg.id);
+		if (!entry) return;
+		pending.delete(msg.id);
+		if (msg.kind === "done") entry.resolve();
+		else entry.reject(new Error(msg.message ?? "worker-atomic-writer: unknown error"));
+	});
+	worker.on("error", (error: Error) => {
+		// Reject ALL pending requests — worker died.
+		for (const [, entry] of pending) entry.reject(error);
+		pending.clear();
+		worker = undefined;
+	});
+	worker.unref(); // don't keep event loop alive (unless tests request it)
+	if (keepRefForTests) worker.ref();
+	return worker;
+}
+
+function dispatch(kind: "write" | "mkdir" | "append", payload: Record<string, unknown>): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const id = nextRequestId++;
+		pending.set(id, { resolve, reject });
+		try {
+			getWorker().postMessage({ kind, id, ...payload });
+		} catch (error) {
+			pending.delete(id);
+			reject(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+}
+
+/** Whether the worker writer is enabled (env var opt-in). */
+export function isWorkerAtomicWriterEnabled(): boolean {
+	return process.env.PI_CREW_WORKER_ATOMIC_WRITER === "1" || process.env.PI_TEAMS_WORKER_ATOMIC_WRITER === "1";
+}
+
+/** Atomic-write a file via the worker thread. Sync fs ops inside worker. */
+export function atomicWriteFileViaWorker(filePath: string, content: string): Promise<void> {
+	return dispatch("write", { filePath, content });
+}
+
+/** Append to a file via the worker thread (used by event-log). */
+export function appendFileViaWorker(filePath: string, content: string): Promise<void> {
+	return dispatch("append", { filePath, content });
+}
+
+/** Terminate the worker (for tests / cleanup). */
+export function terminateWorkerAtomicWriter(): void {
+	if (worker) {
+		const w = worker;
+		worker = undefined;
+		w.terminate().catch(() => {
+			/* ignore */
+		});
+	}
+	for (const [, entry] of pending) entry.reject(new Error("worker terminated"));
+	pending.clear();
+}
+
+/** Tests-only knob: keep the worker ref'd so the test runner doesn't exit
+ *  before promises resolve. Production code leaves this false (worker is
+ *  unref'd to avoid blocking process exit). */
+let keepRefForTests = false;
+export function __setKeepWorkerRefForTests(value: boolean): void {
+	keepRefForTests = value;
+}

package/src/subagents/async-entry.ts

@@ -0,0 +1 @@
+export * from "../runtime/async-runner.ts";

package/src/subagents/index.ts

@@ -0,0 +1,3 @@
+export * from "./async-entry.ts";
+export * from "./manager.ts";
+export * from "./spawn.ts";

package/src/subagents/live/control.ts

@@ -0,0 +1 @@
+export * from "../../runtime/live-agent-control.ts";

package/src/subagents/live/manager.ts

@@ -0,0 +1 @@
+export * from "../../runtime/live-agent-manager.ts";

package/src/subagents/live/realtime.ts

@@ -0,0 +1 @@
+export * from "../../runtime/live-control-realtime.ts";

package/src/subagents/live/session-runtime.ts

@@ -0,0 +1 @@
+export * from "../../runtime/live-session-runtime.ts";

package/src/subagents/manager.ts

@@ -0,0 +1 @@
+export * from "../runtime/subagent-manager.ts";

package/src/subagents/spawn.ts

@@ -0,0 +1 @@
+export * from "../runtime/child-pi.ts";

package/src/teams/discover-teams.ts

@@ -0,0 +1,187 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ResourceSource } from "../agents/agent-config.ts";
+import { parseCsv, parseFrontmatter } from "../utils/frontmatter.ts";
+import { parseGitUrl } from "../utils/git.ts";
+import { packageRoot, projectCrewRoot, userPiRoot } from "../utils/paths.ts";
+import type { TeamConfig, TeamRole } from "./team-config.ts";
+
+export interface TeamDiscoveryResult {
+	builtin: TeamConfig[];
+	user: TeamConfig[];
+	project: TeamConfig[];
+}
+
+function parseRoleSkills(value: string | undefined): string[] | false | undefined {
+	if (!value) return undefined;
+	if (value === "false") return false;
+	const skills = value
+		.split(",")
+		.map((entry) => entry.trim())
+		.filter(Boolean);
+	return skills.length ? skills : undefined;
+}
+
+function parseRoleLine(line: string): TeamRole | undefined {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("-")) return undefined;
+	const value = trimmed.slice(1).trim();
+	if (!value) return undefined;
+	const separator = value.indexOf(":");
+	const namePart = separator >= 0 ? value.slice(0, separator) : value;
+	const restPart = separator >= 0 ? value.slice(separator + 1) : "";
+	const name = namePart.trim();
+	if (!name) return undefined;
+	const metadata: Record<string, string> = {};
+	let descriptionSource = restPart.replace(/\bskills\s*=\s*([\w-]+(?:\s*,\s*[\w-]+)*)/g, (_match, raw: string) => {
+		metadata.skills = raw.replace(/\s*,\s*/g, ",").trim();
+		return "";
+	});
+	descriptionSource = descriptionSource.replace(/\b(agent|model|maxConcurrency)\s*=\s*(\S+)/g, (_match, key: string, raw: string) => {
+		metadata[key] = raw.trim();
+		return "";
+	});
+	const description = descriptionSource.replace(/\s+/g, " ").trim() || undefined;
+	const maxConcurrency = metadata.maxConcurrency
+		? (() => {
+				const p = Number.parseInt(metadata.maxConcurrency, 10);
+				return p > 0 ? p : undefined;
+			})()
+		: undefined;
+	return {
+		name,
+		agent: metadata.agent ?? name,
+		description,
+		model: metadata.model,
+		skills: parseRoleSkills(metadata.skills),
+		maxConcurrency: maxConcurrency && maxConcurrency > 0 ? maxConcurrency : undefined,
+	};
+}
+
+function parseCost(value: string | undefined): "free" | "cheap" | "expensive" | undefined {
+	return value === "free" || value === "cheap" || value === "expensive" ? value : undefined;
+}
+
+function parseTeamSource(
+	rawSource: string | undefined,
+	fallback: ResourceSource,
+): { source: ResourceSource; sourceUrl: string | undefined } {
+	if (!rawSource) return { source: fallback, sourceUrl: undefined };
+	const parsed = parseGitUrl(rawSource);
+	if (!parsed) return { source: fallback, sourceUrl: undefined };
+	return { source: "git", sourceUrl: parsed.repo };
+}
+
+function parseTeamFile(filePath: string, source: ResourceSource): TeamConfig | undefined {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		const { frontmatter, body } = parseFrontmatter(content);
+		const name = frontmatter.name?.trim() || path.basename(filePath, ".team.md");
+		const roles = body
+			.split("\n")
+			.map(parseRoleLine)
+			.filter((role): role is TeamRole => role !== undefined);
+		const triggers = parseCsv(frontmatter.triggers ?? frontmatter.trigger);
+		const useWhen = parseCsv(frontmatter.useWhen);
+		const avoidWhen = parseCsv(frontmatter.avoidWhen);
+		const cost = parseCost(frontmatter.cost);
+		const category = frontmatter.category?.trim() || undefined;
+		const sourceInfo = parseTeamSource(frontmatter.source, source);
+		return {
+			name,
+			description: frontmatter.description?.trim() || "No description provided.",
+			source: sourceInfo.source,
+			sourceUrl: sourceInfo.sourceUrl,
+			filePath,
+			roles,
+			defaultWorkflow: frontmatter.defaultWorkflow || frontmatter.workflow || undefined,
+			workspaceMode: frontmatter.workspaceMode?.trim() === "worktree" ? "worktree" : "single",
+			maxConcurrency: frontmatter.maxConcurrency ? Number.parseInt(frontmatter.maxConcurrency, 10) : undefined,
+			routing: triggers || useWhen || avoidWhen || cost || category ? { triggers, useWhen, avoidWhen, cost, category } : undefined,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function readTeamDir(dir: string, source: ResourceSource): TeamConfig[] {
+	if (!fs.existsSync(dir)) return [];
+	return fs
+		.readdirSync(dir)
+		.filter((entry) => entry.endsWith(".team.md"))
+		.map((entry) => parseTeamFile(path.join(dir, entry), source))
+		.filter((team): team is TeamConfig => team !== undefined)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ─── Team Discovery Cache (F15) ──────────────────────────────────────────
+// Mirrors the Workflow Discovery Cache (see workflows/discover-workflows.ts).
+// `discoverTeams(cwd)` is called from recommend/scheduler paths and previously
+// re-scanned 3 roots on every call. 5 s TTL + dir-stamp invalidation keeps
+// changes (e.g. user edits a `.team.md`) visible within a few seconds without
+// paying a full re-scan per call.
+const TEAM_DISCOVERY_TTL_MS = 5000;
+const TEAM_DISCOVERY_MAX_ENTRIES = 32;
+interface CachedTeamEntry {
+	result: TeamDiscoveryResult;
+	expiresAt: number;
+	dirStamp: string;
+}
+const teamCache = new Map<string, CachedTeamEntry>();
+
+function teamDirStamp(cwd: string): string {
+	const dirs = [path.join(packageRoot(), "teams"), path.join(userPiRoot(), "teams"), path.join(projectCrewRoot(cwd), "teams")];
+	let out = "";
+	for (const d of dirs) {
+		try {
+			out += `${fs.statSync(d).mtimeMs}|`;
+		} catch {
+			out += "0|";
+		}
+	}
+	return out;
+}
+
+/** Drop one or all cached entries. Called from management actions and tests. */
+export function invalidateTeamDiscoveryCache(cwd?: string): void {
+	if (cwd) {
+		teamCache.delete(cwd);
+	} else {
+		teamCache.clear();
+	}
+}
+
+export function discoverTeams(cwd: string): TeamDiscoveryResult {
+	// F15: serve from cache when both TTL is fresh AND dir-stamp is unchanged.
+	const now = Date.now();
+	const stamp = teamDirStamp(cwd);
+	const cached = teamCache.get(cwd);
+	if (cached && cached.expiresAt > now && cached.dirStamp === stamp) {
+		return cached.result;
+	}
+	const result: TeamDiscoveryResult = {
+		builtin: readTeamDir(path.join(packageRoot(), "teams"), "builtin"),
+		user: readTeamDir(path.join(userPiRoot(), "teams"), "user"),
+		project: readTeamDir(path.join(projectCrewRoot(cwd), "teams"), "project"),
+	};
+	teamCache.set(cwd, {
+		result,
+		expiresAt: now + TEAM_DISCOVERY_TTL_MS,
+		dirStamp: stamp,
+	});
+	while (teamCache.size > TEAM_DISCOVERY_MAX_ENTRIES) {
+		const oldest = teamCache.keys().next().value;
+		if (oldest === undefined) break;
+		teamCache.delete(oldest);
+	}
+	return result;
+}
+
+export function allTeams(discovery: TeamDiscoveryResult | undefined): TeamConfig[] {
+	if (!discovery) return [];
+	const byName = new Map<string, TeamConfig>();
+	for (const team of [...discovery.project, ...discovery.builtin, ...discovery.user]) {
+		byName.set(team.name, team);
+	}
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/teams/team-config.ts

@@ -0,0 +1,27 @@
+import type { ResourceSource, RoutingMetadata } from "../agents/agent-config.ts";
+
+export interface TeamRole {
+	name: string;
+	agent: string;
+	description?: string;
+	model?: string;
+	/** Additional skills for this role; false disables role-default injected skills for tasks using this role. */
+	skills?: string[] | false;
+	maxConcurrency?: number;
+}
+
+export interface TeamConfig {
+	name: string;
+	description: string;
+	source: ResourceSource;
+	filePath: string;
+	roles: TeamRole[];
+	defaultWorkflow?: string;
+	workspaceMode?: "single" | "worktree";
+	maxConcurrency?: number;
+	routing?: RoutingMetadata;
+	/**
+	 * Optional git-based source URL when this team config is sourced from a remote URL.
+	 */
+	sourceUrl?: string;
+}

package/src/teams/team-serializer.ts

@@ -0,0 +1,38 @@
+import type { TeamConfig, TeamRole } from "./team-config.ts";
+
+function line(key: string, value: string | string[] | undefined): string | undefined {
+	if (value === undefined) return undefined;
+	if (Array.isArray(value)) return `${key}: ${value.join(", ")}`;
+	return `${key}: ${value}`;
+}
+
+function serializeRole(role: TeamRole): string {
+	const parts = [`agent=${role.agent}`];
+	if (role.model) parts.push(`model=${role.model}`);
+	if (role.skills === false) parts.push("skills=false");
+	else if (role.skills?.length) parts.push(`skills=${role.skills.join(",")}`);
+	if (role.maxConcurrency !== undefined) parts.push(`maxConcurrency=${role.maxConcurrency}`);
+	if (role.description) parts.push(role.description);
+	return `- ${role.name}: ${parts.join(" ")}`;
+}
+
+export function serializeTeam(team: TeamConfig): string {
+	const lines = [
+		"---",
+		`name: ${team.name}`,
+		`description: ${team.description}`,
+		team.defaultWorkflow ? `defaultWorkflow: ${team.defaultWorkflow}` : undefined,
+		team.workspaceMode ? `workspaceMode: ${team.workspaceMode}` : undefined,
+		team.maxConcurrency !== undefined ? `maxConcurrency: ${team.maxConcurrency}` : undefined,
+		line("triggers", team.routing?.triggers),
+		line("useWhen", team.routing?.useWhen),
+		line("avoidWhen", team.routing?.avoidWhen),
+		line("cost", team.routing?.cost),
+		line("category", team.routing?.category),
+		"---",
+		"",
+		...team.roles.map(serializeRole),
+		"",
+	].filter((entry): entry is string => entry !== undefined);
+	return lines.join("\n");
+}

package/src/tools/safe-bash-extension.ts

@@ -0,0 +1,54 @@
+/**
+ * Safe Bash Extension for pi-crew
+ * Wraps the built-in bash tool with dangerous command blocking.
+ *
+ * Delegates pattern matching to the core `safe-bash.ts` module which uses
+ * linear-time string scanning (no ReDoS-vulnerable regex).
+ *
+ * Usage:
+ * 1. Enable in config: { "tools": { "bash": { "safeMode": true } } }
+ * 2. Or use via agent config: { "extensions": ["path/to/safe-bash-extension.ts"] }
+ * 3. Or set env var: PI_CREW_SAFE_BASH=true
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createBashTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { checkCommand } from "./safe-bash.ts";
+
+export default function safeBashExtension(pi: ExtensionAPI): void {
+	const cwd = process.cwd();
+	const bashTool = createBashTool(cwd);
+
+	pi.registerTool({
+		name: "safe_bash",
+		label: "Safe Bash",
+		description: "Execute a bash command safely. Blocks dangerous commands like `rm -rf /`, `sudo`, `curl | sh`, etc.",
+		parameters: Type.Object({
+			command: Type.String({ description: "Bash command to execute" }),
+			/** Timeout in seconds (optional). Default: no timeout. If exceeded, the command is killed. */
+			timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
+			description: Type.Optional(
+				Type.String({
+					description: "Description of what this command does (optional)",
+				}),
+			),
+		}),
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const danger = checkCommand(params.command);
+			if (danger) {
+				return {
+					details: {},
+					content: [
+						{
+							type: "text" as const,
+							text: `🚫 ${danger}\n\nCommand blocked by safety policy. If this is a false positive, ask the user for confirmation or use force: true with explicit user approval.`,
+						},
+					],
+				};
+			}
+			// Safe - delegate to real bash tool
+			return bashTool.execute(toolCallId, params, signal, onUpdate);
+		},
+	});
+}