pi-crew 0.2.2 → 0.2.3

package/src/utils/resolve-shell.ts

@@ -0,0 +1,34 @@
+import * as fs from "node:fs";
+
+/**
+ * Resolve the bash executable path, with Windows fallbacks for Git Bash.
+ */
+export function resolveBashCmd(): string {
+	if (process.platform !== "win32") return "bash";
+	const candidates = [
+		process.env.SHELL,
+		"C:\\Program Files\\Git\\bin\\bash.exe",
+		"C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+	];
+	for (const cand of candidates) {
+		if (cand && fs.existsSync(cand)) return cand;
+	}
+	return "bash";
+}
+
+/**
+ * Choose the right shell command and arguments for a script path.
+ * On Windows, powershell (.ps1) and batch (.cmd/.bat) run natively.
+ */
+export function resolveShellForScript(scriptPath: string): { command: string; args: string[] } {
+	if (process.platform === "win32") {
+		if (scriptPath.endsWith(".ps1")) {
+			return { command: "powershell", args: ["-File", scriptPath] };
+		}
+		if (scriptPath.endsWith(".cmd") || scriptPath.endsWith(".bat")) {
+			// Node >= 20 blocks direct spawn of .bat/.cmd without shell (CVE-2024-27980)
+			return { command: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", scriptPath] };
+		}
+	}
+	return { command: resolveBashCmd(), args: [scriptPath] };
+}

package/src/utils/sleep.ts

@@ -1,3 +1,5 @@
+import { execFileSync } from "node:child_process";
+
 /**
  * Synchronous sleep using Atomics.wait (non-busy) with low-CPU fallback.
  *
@@ -14,7 +16,6 @@ export function sleepSync(ms: number): void {
 		// On Unix, try spawning the `sleep` command to avoid CPU busy-wait.
 		if (process.platform !== "win32" && ms >= 10) {
 			try {
-				const { execFileSync } = require("node:child_process") as typeof import("node:child_process");
 				execFileSync("sleep", [(ms / 1000).toFixed(3)], { timeout: ms + 1000, stdio: "pipe" });
 				return;
 			} catch {

package/src/worktree/cleanup.ts

@@ -13,7 +13,7 @@ export interface WorktreeCleanupResult {
 }
 
 function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).trim();
 }
 
 function isDirty(worktreePath: string): boolean {
@@ -54,8 +54,11 @@ export function cleanupRunWorktrees(manifest: TeamRunManifest, options: { force?
 			result.preserved.push({ path: worktreePath, reason: "dirty worktree preserved" });
 			continue;
 		}
+		const args = ["worktree", "remove"];
+		if (options.force) args.push("--force");
+		args.push(worktreePath);
 		try {
-			git(manifest.cwd, ["worktree", "remove", options.force ? "--force" : "", worktreePath].filter(Boolean));
+			git(manifest.cwd, args);
 			result.removed.push(worktreePath);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);

package/src/worktree/worktree-manager.ts

@@ -4,6 +4,8 @@ import * as path from "node:path";
 import { loadConfig } from "../config/config.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 
 export interface PreparedTaskWorkspace {
@@ -23,7 +25,7 @@ export interface WorktreeDiffStat {
 }
 
 function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).trim();
 }
 
 function sanitizeBranchPart(value: string): string {
@@ -44,7 +46,10 @@ export function assertCleanLeader(repoRoot: string): void {
 function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
 	const source = path.join(repoRoot, "node_modules");
 	const target = path.join(worktreePath, "node_modules");
-	if (!fs.existsSync(source) || fs.existsSync(target)) return false;
+	let sourceStat: fs.Stats;
+	try { sourceStat = fs.statSync(source); } catch { return false; }
+	if (!sourceStat.isDirectory()) return false;
+	if (fs.existsSync(target)) return false;
 	try {
 		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
 		return true;
@@ -72,6 +77,9 @@ function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot:
 		input: JSON.stringify({ version: 1, repoRoot, worktreePath, agentCwd: worktreePath, branch, runId: manifest.runId, taskId: task.id, agent: task.agent }),
 		timeout: cfg.setupHookTimeoutMs ?? 30_000,
 		shell: false,
+		env: sanitizeEnvSecrets(process.env, {
+			allowList: ["PATH", "HOME", "USERPROFILE", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL", "PI_*"],
+		}),
 	});
 	if (result.error) throw new Error(`worktree setup hook failed: ${result.error.message}`);
 	if (result.status !== 0) throw new Error(`worktree setup hook failed with exit code ${result.status}: ${result.stderr || result.stdout || "no output"}`);
@@ -84,12 +92,29 @@ function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot:
 		const parsed = JSON.parse(lastLine) as { syntheticPaths?: unknown };
 		if (!Array.isArray(parsed.syntheticPaths)) return [];
 		return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
-	} catch {
-		// Hook output was not valid JSON — treat as no synthetic paths
+	} catch (error) {
+		logInternalError("worktree.setupHook.parse", error, `lastLine=${(trimmed.split(/\r?\n/).pop() ?? "").slice(0, 200)}`);
 		return [];
 	}
 }
 
+function branchExists(repoRoot: string, branch: string): { local: boolean; remoteOnly: boolean } {
+	let local = false;
+	try { git(repoRoot, ["rev-parse", "--verify", `refs/heads/${branch}`]); local = true; } catch {}
+	if (local) return { local: true, remoteOnly: false };
+	// Check remote-tracking branch
+	try {
+		const out = execFileSync("git", ["for-each-ref", "--format=%(refname)", `refs/remotes/*/${branch}`],
+			{ cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+		return { local: false, remoteOnly: out.length > 0 };
+	} catch { return { local: false, remoteOnly: false }; }
+}
+
+function pruneStaleWorktrees(repoRoot: string): void {
+	try { execFileSync("git", ["worktree", "prune"], { cwd: repoRoot, stdio: "ignore" }); }
+	catch { /* best-effort */ }
+}
+
 export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskState): PreparedTaskWorkspace {
 	if (manifest.workspaceMode !== "worktree") return { cwd: task.cwd };
 	const repoRoot = findGitRoot(manifest.cwd);
@@ -111,7 +136,24 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		}
 		return { cwd: worktreePath, worktreePath, branch, reused: true };
 	}
-	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	pruneStaleWorktrees(repoRoot);
+	const exists = branchExists(repoRoot, branch);
+	try {
+		if (exists.local) {
+			git(repoRoot, ["worktree", "add", worktreePath, branch]);
+		} else {
+			if (exists.remoteOnly) {
+				logInternalError("worktree.branchRemoteOnly", new Error(`Branch '${branch}' exists only on remote; creating local from HEAD instead of tracking remote.`), `branch=${branch}`);
+			}
+			git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		if (/already checked out|is already used by worktree/i.test(msg)) {
+			throw new Error(`Branch '${branch}' is checked out at another worktree. Run \`team cleanup runId=${manifest.runId} force=true\` or manually remove the conflicting worktree.`);
+		}
+		throw error;
+	}
 	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
 	const nodeModulesLinked = loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
 	return { cwd: worktreePath, worktreePath, branch, reused: false, nodeModulesLinked, syntheticPaths };