pi-crew 0.9.50 → 0.9.52

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

@@ -1,194 +0,0 @@
-/**
- * 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 {}
-    // 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 {}
-    }
-    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

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

package/src/subagents/index.ts

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

package/src/subagents/live/control.ts

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

package/src/subagents/live/manager.ts

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

package/src/subagents/live/realtime.ts

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

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

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

package/src/subagents/manager.ts

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

package/src/subagents/spawn.ts

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

package/src/teams/discover-teams.ts

@@ -1,187 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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