pi-crew 0.9.26 → 0.9.27

package/scripts/profile-startup.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Profile pi-crew register cold load.
+ *
+ * Usage:
+ *   node scripts/profile-startup.mjs               # default 5 iters
+ *   node scripts/profile-startup.mjs --iters 10
+ *
+ * Outputs:
+ *   .profile/startup-<timestamp>.cpuprofile  (open in Chrome DevTools)
+ *   .profile/summary.json                    (top frames JSON)
+ *
+ * Implementation note: spawns a child Node with --cpu-prof so the profile
+ * captures only the cold-load path (no measurement noise from this driver).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+
+const root = path.resolve(import.meta.dirname, "..");
+const profileDir = path.join(root, ".profile");
+const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+
+const args = process.argv.slice(2);
+let iters = 5;
+for (let i = 0; i < args.length; i++) {
+	if (args[i] === "--iters" && args[i + 1]) {
+		iters = Number(args[i + 1]);
+		i++;
+	}
+}
+
+fs.mkdirSync(profileDir, { recursive: true });
+
+const driverPath = path.join(profileDir, `_driver-${timestamp}.mjs`);
+const registerImportSpec = pathToFileURL(path.join(root, "src/extension/register.ts")).href;
+const driverSrc = `
+import { performance } from "node:perf_hooks";
+const start = performance.now();
+const { registerPiTeams } = await import(${JSON.stringify(registerImportSpec)});
+const importMs = performance.now() - start;
+
+function createEvents() {
+	const handlers = new Map();
+	return {
+		on(event, handler) {
+			const set = handlers.get(event) ?? new Set();
+			set.add(handler);
+			handlers.set(event, set);
+			return () => set.delete(handler);
+		},
+		emit(event, payload) {
+			for (const h of handlers.get(event) ?? []) h(payload);
+		},
+	};
+}
+function createPi(events) {
+	return {
+		events,
+		on(_e, _h) {},
+		registerCommand() {},
+		registerTool() {},
+		appendEntry() {},
+		getSessionName() { return undefined; },
+		setSessionName() {},
+	};
+}
+
+const samples = [];
+for (let i = 0; i < ${iters}; i++) {
+	const t0 = performance.now();
+	const events = createEvents();
+	const pi = createPi(events);
+	registerPiTeams(pi);
+	samples.push(performance.now() - t0);
+}
+process.stdout.write(JSON.stringify({ importMs, samples }) + "\\n");
+`;
+fs.writeFileSync(driverPath, driverSrc, "utf-8");
+
+const cpuProfilePath = path.join(profileDir, `startup-${timestamp}.cpuprofile`);
+console.log(`[profile] Running ${iters} iterations with --cpu-prof...`);
+
+const result = spawnSync(process.execPath, [
+	"--cpu-prof",
+	`--cpu-prof-dir=${profileDir}`,
+	`--cpu-prof-name=startup-${timestamp}.cpuprofile`,
+	"--experimental-strip-types",
+	"--no-warnings",
+	driverPath,
+], { encoding: "utf-8", cwd: root });
+
+fs.unlinkSync(driverPath);
+
+if (result.status !== 0) {
+	console.error("[profile] driver failed:", result.stderr || result.stdout);
+	process.exit(result.status ?? 1);
+}
+
+let parsed;
+try {
+	parsed = JSON.parse(result.stdout.trim().split("\n").pop());
+} catch (error) {
+	console.error("[profile] could not parse driver output:", result.stdout);
+	process.exit(2);
+}
+
+const samples = parsed.samples;
+samples.sort((a, b) => a - b);
+const p = (q) => samples[Math.min(samples.length - 1, Math.floor((samples.length - 1) * q))];
+const summary = {
+	timestamp,
+	iters,
+	importMs: round(parsed.importMs),
+	registerMs: { min: round(samples[0]), p50: round(p(0.5)), p95: round(p(0.95)), p99: round(p(0.99)), max: round(samples[samples.length - 1]) },
+	cpuProfile: path.relative(root, cpuProfilePath).replace(/\\/g, "/"),
+};
+fs.writeFileSync(path.join(profileDir, "summary.json"), JSON.stringify(summary, null, 2) + "\n", "utf-8");
+
+console.log("[profile] Summary:", JSON.stringify(summary, null, 2));
+console.log("[profile] CPU profile:", cpuProfilePath);
+console.log("[profile] Open in Chrome DevTools → Performance → Load profile.");
+
+function round(n) { return Math.round(n * 100) / 100; }

package/scripts/release-smoke.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Release smoke test — verifies packed tarball loads correctly in a temp project.
+ * Run: node scripts/release-smoke.mjs
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+
+const root = path.resolve(import.meta.dirname, "..");
+
+function log(msg) {
+	console.log(`[release-smoke] ${msg}`);
+}
+
+function run(cmd, cwd) {
+	log(`  $ ${cmd}`);
+	execSync(cmd, { cwd, stdio: "pipe", timeout: 60_000 });
+}
+
+try {
+	// 1. Read version from package.json
+	const rootPkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+	const version = rootPkg.version;
+	log(`Package version: ${version}`);
+
+	// 2. Pack tarball
+	log("Packing tarball...");
+	execSync("npm pack", { cwd: root, stdio: "pipe", timeout: 60_000 });
+	const tarballName = `pi-crew-${version}.tgz`;
+	const tarballPath = path.join(root, tarballName);
+	if (!fs.existsSync(tarballPath)) throw new Error(`Tarball not found: ${tarballPath}`);
+	log(`  Tarball: ${tarballName}`);
+
+	// 3. Create temp project
+	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-smoke-"));
+	log(`Temp project: ${tmpDir}`);
+	try {
+		run("npm init -y", tmpDir);
+
+		// 4. Install packed tarball
+		run(`npm install ${tarballPath}`, tmpDir);
+
+		// 5. Verify extension loads
+		const pkgPath = path.join(tmpDir, "node_modules", "pi-crew", "package.json");
+		if (!fs.existsSync(pkgPath)) throw new Error("pi-crew package not found in node_modules");
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		log(`  Installed version: ${pkg.version}`);
+
+		// 6. Verify key entrypoints exist
+		const srcRegister = path.join(tmpDir, "node_modules", "pi-crew", "src", "extension", "register.ts");
+		if (fs.existsSync(srcRegister)) {
+			log(`  Extension register entrypoint found: ${srcRegister}`);
+		} else {
+			throw new Error("Could not find extension register entrypoint");
+		}
+
+		// 7. Verify version consistency
+		if (pkg.version !== version) {
+			throw new Error(`Version mismatch: root=${version} installed=${pkg.version}`);
+		}
+		log(`  Version consistency: OK ${pkg.version}`);
+
+		log("Release smoke test PASSED!");
+	} finally {
+		fs.rmSync(tmpDir, { recursive: true, force: true });
+		// Clean up tarball
+		try { fs.unlinkSync(tarballPath); } catch {}
+	}
+} catch (error) {
+	console.error("Release smoke test FAILED:", error instanceof Error ? error.message : String(error));
+	process.exit(1);
+}

package/scripts/run-bench.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * Run all benches, collect JSON output, write to test/bench/results.json.
+ *
+ * Each bench prints a single JSON line on stdout (NDJSON). Earlier lines may
+ * be ignored. Failures abort the run.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = path.resolve(import.meta.dirname, "..");
+const benchDir = path.join(root, "test", "bench");
+const benches = fs.readdirSync(benchDir).filter((f) => f.endsWith(".bench.ts"));
+
+const results = {};
+for (const bench of benches) {
+	const benchPath = path.join(benchDir, bench);
+	console.log(`[bench] running ${bench}...`);
+	const t0 = Date.now();
+	const result = spawnSync(process.execPath, [
+		"--experimental-strip-types",
+		"--no-warnings",
+		benchPath,
+	], { encoding: "utf-8", cwd: root, timeout: 600_000 });
+	if (result.status !== 0) {
+		console.error(result.stderr || result.stdout);
+		process.exit(result.status ?? 1);
+	}
+	const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+	const lines = result.stdout.trim().split("\n").filter(Boolean);
+	let parsed;
+	for (const line of lines.reverse()) {
+		try { parsed = JSON.parse(line); break; } catch { /* skip non-JSON */ }
+	}
+	if (!parsed?.name) {
+		console.error(`[bench] could not parse JSON output from ${bench}\n${result.stdout}`);
+		process.exit(2);
+	}
+	results[parsed.name] = parsed;
+	console.log(`[bench]   ${parsed.name} done in ${elapsed}s`);
+}
+
+const outPath = path.join(benchDir, "results.json");
+const payload = { capturedAt: new Date().toISOString(), node: process.version, platform: process.platform, results };
+fs.writeFileSync(outPath, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+console.log(`[bench] wrote ${outPath}`);

package/scripts/run-real-chain.ts

@@ -0,0 +1,41 @@
+/**
+ * Real end-to-end chain execution test.
+ *
+ * Runs two ACTUAL team runs sequentially via the chain feature, with step 2's
+ * worker receiving step 1's handoff context (including output text). Prints
+ * both step runIds for inspection.
+ *
+ * Usage: npx tsx scripts/run-real-chain.ts
+ */
+
+import type { TeamContext } from "../src/extension/team-tool/context.ts";
+import { handleRun } from "../src/extension/team-tool/run.ts";
+
+const chain = '"Say the numbers 1, 2, 3" -> "What was the last number in the previous step? Add 2 to it."';
+const ctx: TeamContext = { cwd: process.cwd() };
+
+console.log("[run-real-chain] Executing chain:", chain);
+console.log("[run-real-chain] Working directory:", process.cwd());
+console.log("[run-real-chain] This will spawn REAL team runs. Please wait...\n");
+
+const result = await handleRun({ action: "run", chain }, ctx);
+
+console.log("\n=== CHAIN RESULT (details) ===");
+console.log(JSON.stringify(result.details, null, 2));
+
+const text = result.content?.[0];
+if (text && "text" in text) {
+	console.log("\n=== SUMMARY ===");
+	console.log(text.text);
+}
+
+// Extract runIds for easy inspection.
+const runIds = (result.details as { data?: { runIds?: string[] } }).data?.runIds;
+if (runIds && runIds.length > 0) {
+	console.log("\n=== STEP RUN IDS ===");
+	for (let i = 0; i < runIds.length; i++) {
+		console.log(`Step ${i + 1}: ${runIds[i]}`);
+	}
+} else {
+	console.log("\n[run-real-chain] WARNING: no runIds found in result.");
+}

package/scripts/test-issue-29-crash.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Crash reproduction test for issue #29: verifies the defense-in-depth fix
+ * in subagent-manager.ts:start() prevents unhandled rejections from
+ * crashing the host process.
+ *
+ * Strategy: spawn a subagent whose runner throws, then do NOT await
+ * record.promise. Without the fix, this triggers unhandledRejection which
+ * Node.js converts to uncaughtException. With the fix, the .catch inside
+ * start() absorbs the rejection.
+ *
+ * Run with: npx tsx scripts/test-issue-29-crash.ts
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-issue-29-crash-"));
+fs.mkdirSync(path.join(tmpDir, ".pi"), { recursive: true });
+
+console.log("Issue #29 CRASH reproduction test");
+console.log(`Project: ${tmpDir}`);
+console.log();
+
+let crashed = false;
+let crashError: Error | undefined;
+const crashEvents: string[] = [];
+
+process.on("uncaughtException", (error) => {
+	crashed = true;
+	crashError = error;
+	crashEvents.push(`uncaughtException: ${error.message}`);
+	console.error(`[CRASH] uncaughtException: ${error.message}`);
+});
+
+process.on("unhandledRejection", (reason) => {
+	crashed = true;
+	const err = reason instanceof Error ? reason : new Error(String(reason));
+	crashError = err;
+	crashEvents.push(`unhandledRejection: ${err.message}`);
+	console.error(`[CRASH] unhandledRejection: ${err.message}`);
+});
+
+async function main(): Promise<void> {
+	const piCrewRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+	const { SubagentManager } = await import(path.join(piCrewRoot, "src/runtime/subagent-manager.ts"));
+
+	const mgr = new SubagentManager();
+
+	const runnerThatThrows = async (): Promise<never> => {
+		throw new Error("simulated subagent failure (issue #29 crash test)");
+	};
+
+	const record = mgr.spawn(
+		{
+			cwd: tmpDir,
+			type: "test",
+			description: "issue-29 crash test",
+			prompt: "throw",
+			background: false,
+		},
+		runnerThatThrows as Parameters<typeof mgr.spawn>[1],
+	);
+
+	console.log(`Spawned subagent ${record.id}`);
+
+	// Do NOT await — this is the scenario that crashes pi.
+	console.log("Waiting 300ms without awaiting record.promise...");
+	await new Promise((resolve) => setTimeout(resolve, 300));
+
+	console.log();
+	console.log(`Results:`);
+	console.log(`  record.status = ${record.status}`);
+	console.log(`  process.crashed = ${crashed}`);
+	console.log(`  crashEvents = ${JSON.stringify(crashEvents)}`);
+	console.log();
+
+	fs.rmSync(tmpDir, { recursive: true, force: true });
+
+	if (crashed) {
+		console.error("✗ FAIL: process crashed (uncaughtException/unhandledRejection fired)");
+		console.error("  The defense-in-depth fix in subagent-manager.ts did NOT prevent the crash.");
+		if (crashError?.stack) {
+			console.error("  Stack trace:");
+			console.error(
+				crashError.stack
+					.split("\n")
+					.slice(0, 10)
+					.map((l) => `    ${l}`)
+					.join("\n"),
+			);
+		}
+		process.exit(1);
+	}
+
+	if (record.status !== "error") {
+		console.error(`✗ FAIL: record.status should be 'error', got '${record.status}'`);
+		process.exit(1);
+	}
+
+	console.log("✓ PASS: no crash, record marked 'error'");
+	process.exit(0);
+}
+
+main().catch((error) => {
+	console.error("Test script itself crashed:");
+	console.error(error);
+	process.exit(1);
+});

package/scripts/test-issue-29-e2e.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * End-to-end test for issue #29: "Hardcoded .crew/state/runs path crashes pi
+ * (uncaughtException) in .pi-based projects".
+ *
+ * This script reproduces the EXACT scenario from the issue:
+ *  1. Create a .pi/-only project (no .crew/ directory).
+ *  2. Set up an uncaughtException + unhandledRejection detector.
+ *  3. Trigger the bug path: start a subagent whose runner throws, then
+ *     NOT await record.promise (mimics the indirect caller pattern
+ *     described in the issue).
+ *  4. Exit 0 if no crash, exit 1 if crash detected.
+ *
+ * Run with: npx tsx scripts/test-issue-29-e2e.ts
+ *
+ * The script must be run via `tsx` so that the dynamic ESM import of
+ * subagent-manager resolves correctly.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ── Step 1: Set up a .pi/-only project (no .crew/) ──────────────────────
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-issue-29-e2e-"));
+fs.mkdirSync(path.join(tmpDir, ".pi"), { recursive: true });
+// CRITICALLY: no .crew/ directory
+const projectRoot = tmpDir;
+
+console.log("=".repeat(72));
+console.log("Issue #29 end-to-end reproduction test");
+console.log("=".repeat(72));
+console.log(`Project root: ${projectRoot}`);
+console.log(`Has .pi/:  ${fs.existsSync(path.join(projectRoot, ".pi"))}`);
+console.log(`Has .crew/: ${fs.existsSync(path.join(projectRoot, ".crew"))} (should be false)`);
+console.log();
+
+// ── Step 2: Install crash detectors ──────────────────────────────────────
+let crashed = false;
+let crashError: Error | undefined;
+
+process.on("uncaughtException", (error) => {
+	crashed = true;
+	crashError = error;
+	console.error("✗ FATAL: uncaughtException fired");
+	console.error("  This is the bug described in issue #29.");
+	console.error(`  Error: ${error.message}`);
+	if (error.stack) console.error(`  Stack: ${error.stack.split("\n").slice(0, 8).join("\n")}`);
+});
+
+process.on("unhandledRejection", (reason) => {
+	crashed = true;
+	const reasonErr = reason instanceof Error ? reason : new Error(String(reason));
+	crashError = reasonErr;
+	console.error("✗ FATAL: unhandledRejection fired");
+	console.error("  This is the bug described in issue #29.");
+	console.error(`  Reason: ${reasonErr.message}`);
+	if (reasonErr.stack) console.error(`  Stack: ${reasonErr.stack.split("\n").slice(0, 8).join("\n")}`);
+});
+
+// ── Step 3: Trigger the bug path ─────────────────────────────────────────
+
+async function main(): Promise<void> {
+	const piCrewRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+	// Dynamic import so the .ts files are loaded through tsx, not require.
+	const { SubagentManager } = await import(path.join(piCrewRoot, "src/runtime/subagent-manager.ts"));
+	const { waitForRun } = await import(path.join(piCrewRoot, "src/runtime/run-tracker.ts"));
+	const { projectCrewRoot } = await import(path.join(piCrewRoot, "src/utils/paths.ts"));
+
+	// Verify the resolver returns the .pi/teams/ path for our project.
+	const resolvedRoot = projectCrewRoot(projectRoot);
+	console.log(`projectCrewRoot(projectRoot) = ${resolvedRoot}`);
+	const expectedRoot = path.join(projectRoot, ".pi", "teams");
+	if (resolvedRoot !== expectedRoot) {
+		console.error(`✗ projectCrewRoot returned ${resolvedRoot}, expected ${expectedRoot}`);
+		process.exit(1);
+	}
+	console.log("✓ projectCrewRoot correctly resolves to .pi/teams/");
+	console.log();
+
+	// ── Test 3a: Direct waitForRun() crash path ─────────────────────────
+	console.log("Test 3a: Direct waitForRun() with non-existent runId");
+	console.log("-".repeat(72));
+	const startA = Date.now();
+	try {
+		await waitForRun("team_e2e_never_exists_xyz", projectRoot, {
+			timeoutMs: 500,
+			pollIntervalMs: 50,
+		});
+		console.error("✗ waitForRun should have thrown");
+	} catch (error) {
+		const msg = (error as Error).message;
+		const elapsed = Date.now() - startA;
+		console.log(`✓ waitForRun threw after ${elapsed}ms (as expected)`);
+		console.log(`  Message: ${msg}`);
+		if (msg.includes(".pi/teams")) {
+			console.log("✓ Error message references .pi/teams/ (resolver applied)");
+		} else if (msg.includes(".crew/state/runs")) {
+			console.error(`✗ Error message still references .crew/state/runs/ (BUG NOT FIXED)`);
+			process.exit(1);
+		} else {
+			console.error(`✗ Error message doesn't reference expected path: ${msg}`);
+			process.exit(1);
+		}
+	}
+	console.log();
+
+	// ── Test 3b: Indirect crash path via SubagentManager ────────────────
+	// This is the ACTUAL crash path: subagent fails → record.promise rejects
+	// → no caller awaits → unhandled rejection → pi crashes.
+	console.log("Test 3b: SubagentManager with runner that throws (no awaiter)");
+	console.log("-".repeat(72));
+	const mgr = new SubagentManager();
+
+	const runnerThatThrows = async (): Promise<never> => {
+		// Simulate a failed run lookup inside the subagent — this is what
+		// waitForRun() throws when the run directory doesn't exist.
+		// The runner returns a synthetic result, and then pollRunToTerminal
+		// would call waitForRun internally, but to keep the test focused we
+		// throw directly from the runner (mimics any unhandled subagent failure).
+		throw new Error(
+			`Run team_e2e_simulated not found. No run directory at ${path.join(projectRoot, ".crew", "state", "runs", "team_e2e_simulated")}`,
+		);
+	};
+
+	const record = mgr.spawn(
+		{
+			cwd: projectRoot,
+			type: "test",
+			description: "issue-29-e2e test",
+			prompt: "simulate failure",
+			background: false,
+		},
+		runnerThatThrows as Parameters<typeof mgr.spawn>[1],
+	);
+
+	console.log(`Spawned subagent ${record.id} (status: ${record.status})`);
+
+	// CRITICALLY: do NOT await record.promise — this is the scenario
+	// described in the issue where the throw escapes as an unhandled
+	// rejection because no caller awaits.
+	console.log("Waiting 500ms without awaiting record.promise...");
+	await new Promise((resolve) => setTimeout(resolve, 500));
+
+	console.log(`After 500ms:`);
+	console.log(`  record.status = ${record.status}`);
+	console.log(`  process.crashed = ${crashed}`);
+	console.log();
+
+	// ── Step 4: Final verdict ───────────────────────────────────────────
+	if (crashed) {
+		console.error("=".repeat(72));
+		console.error("✗ TEST FAILED: process crashed (uncaughtException or unhandledRejection)");
+		console.error("=".repeat(72));
+		console.error("The fix in commit a80fe6c did NOT prevent the crash.");
+		process.exit(1);
+	}
+
+	if (record.status !== "error") {
+		console.error(`✗ TEST FAILED: record.status should be 'error', got '${record.status}'`);
+		process.exit(1);
+	}
+
+	console.log("=".repeat(72));
+	console.log("✓ ALL TESTS PASSED");
+	console.log("  - projectCrewRoot correctly resolves .pi/teams/");
+	console.log("  - waitForRun() throws with .pi/teams/ in error message");
+	console.log("  - SubagentManager rejection is caught by defense-in-depth .catch");
+	console.log("  - No uncaughtException or unhandledRejection fired");
+	console.log("=".repeat(72));
+
+	// Cleanup
+	fs.rmSync(tmpDir, { recursive: true, force: true });
+	process.exit(0);
+}
+
+main().catch((error) => {
+	console.error("Test script itself crashed:");
+	console.error(error);
+	process.exit(1);
+});