pi-crew 0.2.2 → 0.2.4

package/src/runtime/semaphore.ts

@@ -1,131 +1,131 @@
-/**
- * Phase 6: Semaphore and fail-fast parallel execution.
- *
- * Adapted from oh-my-pi's `parallel.ts` Semaphore class and
- * `mapWithConcurrencyLimit` implementation. Provides:
- * - Explicit acquire/release Semaphore for concurrency control
- * - Fail-fast on first error (via Promise.race)
- * - AbortSignal support for graceful cancellation
- * - Partial results on abort
- */
-
-/**
- * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
- */
-export class Semaphore {
-	#max: number;
-	#current = 0;
-	#queue: Array<() => void> = [];
-
-	constructor(max: number) {
-		this.#max = Math.max(1, max);
-	}
-
-	async acquire(): Promise<void> {
-		if (this.#current < this.#max) {
-			this.#current++;
-			return;
-		}
-		const { promise, resolve } = (() => {
-			let res: () => void;
-			const p = new Promise<void>((r) => { res = r; });
-			return { promise: p, resolve: res! };
-		})();
-		this.#queue.push(resolve);
-		return promise;
-	}
-
-	release(): void {
-		const next = this.#queue.shift();
-		if (next) {
-			next();
-		} else if (this.#current > 0) {
-			this.#current--;
-		}
-		// Guard: over-release is a no-op to prevent #current going negative
-	}
-
-	/** Current number of acquired slots. */
-	get current(): number {
-		return this.#current;
-	}
-
-	/** Number of waiters in the queue. */
-	get waiting(): number {
-		return this.#queue.length;
-	}
-}
-
-/**
- * Result of parallel execution with fail-fast support.
- */
-export interface ParallelResult<R> {
-	/** Results array — undefined entries indicate tasks that were skipped due to abort. */
-	results: (R | undefined)[];
-	/** Whether execution was aborted before all tasks completed. */
-	aborted: boolean;
-	/** The first error that triggered fail-fast, if any. */
-	firstError?: unknown;
-}
-
-/**
- * Execute items with a concurrency limit, fail-fast, and abort signal support.
- *
- * - On first error: aborts remaining workers and rethrows.
- * - On external abort: returns partial results with `aborted: true`.
- * - Results are returned in the same order as input items.
- *
- * Adapted from oh-my-pi's `mapWithConcurrencyLimit`.
- */
-export async function mapWithFailFast<T, R>(
-	items: T[],
-	concurrency: number,
-	fn: (item: T, index: number, signal: AbortSignal) => Promise<R>,
-	signal?: AbortSignal,
-): Promise<ParallelResult<R>> {
-	const limit = Math.max(1, Math.min(concurrency, items.length));
-	const results: (R | undefined)[] = new Array(items.length);
-	let nextIndex = 0;
-
-	// Internal abort controller for fail-fast
-	const abortController = new AbortController();
-	const workerSignal = signal
-		? AbortSignal.any([signal, abortController.signal])
-		: abortController.signal;
-
-	// Promise that rejects on first error — used for fail-fast
-	let rejectFirst: (error: unknown) => void;
-	const firstErrorPromise = new Promise<never>((_, reject) => {
-		rejectFirst = reject;
-	});
-
-	const worker = async (): Promise<void> => {
-		while (true) {
-			if (workerSignal.aborted) return;
-			const index = nextIndex++;
-			if (index >= items.length) return;
-			try {
-				results[index] = await fn(items[index], index, workerSignal);
-			} catch (error) {
-				if (!workerSignal.aborted) {
-					abortController.abort();
-					rejectFirst(error);
-					throw error;
-				}
-			}
-		}
-	};
-
-	const workers = Array.from({ length: limit }, () => worker());
-
-	try {
-		await Promise.race([Promise.all(workers), firstErrorPromise]);
-	} catch (error) {
-		if (signal?.aborted) {
-			return { results, aborted: true, firstError: error };
-		}
-		throw error;
-	}
-
-	return { results, aborted: signal?.aborted ?? false };
-}
+/**
+ * Phase 6: Semaphore and fail-fast parallel execution.
+ *
+ * Adapted from oh-my-pi's `parallel.ts` Semaphore class and
+ * `mapWithConcurrencyLimit` implementation. Provides:
+ * - Explicit acquire/release Semaphore for concurrency control
+ * - Fail-fast on first error (via Promise.race)
+ * - AbortSignal support for graceful cancellation
+ * - Partial results on abort
+ */
+
+/**
+ * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ */
+export class Semaphore {
+	#max: number;
+	#current = 0;
+	#queue: Array<() => void> = [];
+
+	constructor(max: number) {
+		this.#max = Math.max(1, max);
+	}
+
+	async acquire(): Promise<void> {
+		if (this.#current < this.#max) {
+			this.#current++;
+			return;
+		}
+		const { promise, resolve } = (() => {
+			let res: () => void;
+			const p = new Promise<void>((r) => { res = r; });
+			return { promise: p, resolve: res! };
+		})();
+		this.#queue.push(resolve);
+		return promise;
+	}
+
+	release(): void {
+		const next = this.#queue.shift();
+		if (next) {
+			next();
+		} else if (this.#current > 0) {
+			this.#current--;
+		}
+		// Guard: over-release is a no-op to prevent #current going negative
+	}
+
+	/** Current number of acquired slots. */
+	get current(): number {
+		return this.#current;
+	}
+
+	/** Number of waiters in the queue. */
+	get waiting(): number {
+		return this.#queue.length;
+	}
+}
+
+/**
+ * Result of parallel execution with fail-fast support.
+ */
+export interface ParallelResult<R> {
+	/** Results array — undefined entries indicate tasks that were skipped due to abort. */
+	results: (R | undefined)[];
+	/** Whether execution was aborted before all tasks completed. */
+	aborted: boolean;
+	/** The first error that triggered fail-fast, if any. */
+	firstError?: unknown;
+}
+
+/**
+ * Execute items with a concurrency limit, fail-fast, and abort signal support.
+ *
+ * - On first error: aborts remaining workers and rethrows.
+ * - On external abort: returns partial results with `aborted: true`.
+ * - Results are returned in the same order as input items.
+ *
+ * Adapted from oh-my-pi's `mapWithConcurrencyLimit`.
+ */
+export async function mapWithFailFast<T, R>(
+	items: T[],
+	concurrency: number,
+	fn: (item: T, index: number, signal: AbortSignal) => Promise<R>,
+	signal?: AbortSignal,
+): Promise<ParallelResult<R>> {
+	const limit = Math.max(1, Math.min(concurrency, items.length));
+	const results: (R | undefined)[] = new Array(items.length);
+	let nextIndex = 0;
+
+	// Internal abort controller for fail-fast
+	const abortController = new AbortController();
+	const workerSignal = signal
+		? AbortSignal.any([signal, abortController.signal])
+		: abortController.signal;
+
+	// Promise that rejects on first error — used for fail-fast
+	let rejectFirst: (error: unknown) => void;
+	const firstErrorPromise = new Promise<never>((_, reject) => {
+		rejectFirst = reject;
+	});
+
+	const worker = async (): Promise<void> => {
+		while (true) {
+			if (workerSignal.aborted) return;
+			const index = nextIndex++;
+			if (index >= items.length) return;
+			try {
+				results[index] = await fn(items[index], index, workerSignal);
+			} catch (error) {
+				if (!workerSignal.aborted) {
+					abortController.abort();
+					rejectFirst(error);
+					throw error;
+				}
+			}
+		}
+	};
+
+	const workers = Array.from({ length: limit }, () => worker());
+
+	try {
+		await Promise.race([Promise.all(workers), firstErrorPromise]);
+	} catch (error) {
+		if (signal?.aborted) {
+			return { results, aborted: true, firstError: error };
+		}
+		throw error;
+	}
+
+	return { results, aborted: signal?.aborted ?? false };
+}

package/src/runtime/sensitive-paths.ts

@@ -1,92 +1,92 @@
-/**
- * Sensitive file detection for worker constraints.
- *
- * Inspired by caveman's compress.py — prevents workers from reading
- * or compressing files that contain secrets, credentials, or PII.
- *
- * Workers should refuse operations on matching paths. This is enforced
- * in the worker prompt and validated here for defense-in-depth.
- */
-
-import * as path from "node:path";
-
-/** Basenames that almost certainly hold secrets or PII */
-const SENSITIVE_BASENAMES = /\.(?:env|pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg)(?:\..+)?$/i;
-const SENSITIVE_EXACT = /^(?:\.env|\.netrc|\.npmrc|\.pypirc|credentials|secrets?|passwords?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|authorized_keys|known_hosts|jwt\.json|session\.cookie|\.token)$/i;
-
-/** Path components that indicate sensitive directories */
-const SENSITIVE_DIRS = new Set([".ssh", ".aws", ".gnupg", ".kube", ".docker", ".config/gcloud", ".config/gh"]);
-
-/** Name tokens that suggest sensitive content */
-const SENSITIVE_TOKENS = ["secret", "credential", "password", "passwd", "apikey", "accesskey", "token", "privatekey"];
-
-/**
- * Check if a file path looks like it contains sensitive data.
- * Returns true if the path should be refused for worker operations.
- */
-export function isSensitivePath(filePath: string): boolean {
-	const resolved = path.resolve(filePath);
-	const basename = path.basename(resolved);
-	const lower = basename.toLowerCase();
-
-	// Check exact sensitive filenames
-	if (SENSITIVE_EXACT.test(basename)) return true;
-
-	// Check sensitive extensions
-	if (SENSITIVE_BASENAMES.test(basename)) return true;
-
-	// Check path components
-	const parts = resolved.split(/[/\\]/).map((p) => p.toLowerCase());
-	for (const dir of SENSITIVE_DIRS) {
-		const dirParts = dir.split("/");
-		for (let i = 0; i <= parts.length - dirParts.length; i++) {
-			const slice = parts.slice(i, i + dirParts.length);
-			if (slice.join("/") === dir) return true;
-		}
-	}
-
-	// Check name tokens with word-boundary awareness to reduce false positives.
-	// Strategy: split filename on separators to get "words", then check if
-	// any token matches. For substring matching in the normalized form,
-	// we require the token to end at a segment boundary or string end.
-	// This matches 'secret', 'secrets' but NOT 'secretary'.
-	const words = lower.split(/[_\-\s.\W]+/).filter(Boolean);
-	const normalized = lower.replace(/[_\-\s.]/g, "");
-	for (const token of SENSITIVE_TOKENS) {
-		// Check individual words — exact match or token is prefix and word is <= token+2 chars
-		for (const word of words) {
-			if (word === token) return true;
-			// 'secrets' starts with 'secret' and is only 1 char longer → match
-			// 'secretary' starts with 'secret' but is 4 chars longer → no match
-			if (word.startsWith(token) && word.length <= token.length + 2) return true;
-		}
-		// Check fully-normalized form for compound tokens like 'api-key' → 'apikey'
-		// The token must appear as a complete segment (not a partial substring).
-		// After the token, the remaining chars must be a complete word (extension).
-		const idx = normalized.indexOf(token);
-		if (idx !== -1) {
-			const after = idx + token.length;
-			if (after === normalized.length) return true;
-			// Check if remaining chars after token correspond to a known word segment
-			const remaining = normalized.slice(after);
-			if (words.some((w) => remaining === w || remaining.startsWith(w))) return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Build a worker prompt constraint block listing forbidden paths.
- * This goes into the worker system prompt to prevent accidental reads.
- */
-export function buildSensitivePathConstraint(): string {
-	return [
-		"## Security Constraints",
-		"NEVER read, compress, or include content from:",
-		"- Files matching: .env*, *.pem, *.key, *.p12, credentials*, secrets*, passwords*, id_rsa*",
-		"- Directories: .ssh/, .aws/, .gnupg/, .kube/, .docker/",
-		"- Files with names containing: secret, credential, password, apikey, token, privatekey",
-		"If asked to read such a file, refuse and explain the security risk.",
-	].join("\n");
-}
+/**
+ * Sensitive file detection for worker constraints.
+ *
+ * Inspired by caveman's compress.py — prevents workers from reading
+ * or compressing files that contain secrets, credentials, or PII.
+ *
+ * Workers should refuse operations on matching paths. This is enforced
+ * in the worker prompt and validated here for defense-in-depth.
+ */
+
+import * as path from "node:path";
+
+/** Basenames that almost certainly hold secrets or PII */
+const SENSITIVE_BASENAMES = /\.(?:env|pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg)(?:\..+)?$/i;
+const SENSITIVE_EXACT = /^(?:\.env|\.netrc|\.npmrc|\.pypirc|credentials|secrets?|passwords?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|authorized_keys|known_hosts|jwt\.json|session\.cookie|\.token)$/i;
+
+/** Path components that indicate sensitive directories */
+const SENSITIVE_DIRS = new Set([".ssh", ".aws", ".gnupg", ".kube", ".docker", ".config/gcloud", ".config/gh"]);
+
+/** Name tokens that suggest sensitive content */
+const SENSITIVE_TOKENS = ["secret", "credential", "password", "passwd", "apikey", "accesskey", "token", "privatekey"];
+
+/**
+ * Check if a file path looks like it contains sensitive data.
+ * Returns true if the path should be refused for worker operations.
+ */
+export function isSensitivePath(filePath: string): boolean {
+	const resolved = path.resolve(filePath);
+	const basename = path.basename(resolved);
+	const lower = basename.toLowerCase();
+
+	// Check exact sensitive filenames
+	if (SENSITIVE_EXACT.test(basename)) return true;
+
+	// Check sensitive extensions
+	if (SENSITIVE_BASENAMES.test(basename)) return true;
+
+	// Check path components
+	const parts = resolved.split(/[/\\]/).map((p) => p.toLowerCase());
+	for (const dir of SENSITIVE_DIRS) {
+		const dirParts = dir.split("/");
+		for (let i = 0; i <= parts.length - dirParts.length; i++) {
+			const slice = parts.slice(i, i + dirParts.length);
+			if (slice.join("/") === dir) return true;
+		}
+	}
+
+	// Check name tokens with word-boundary awareness to reduce false positives.
+	// Strategy: split filename on separators to get "words", then check if
+	// any token matches. For substring matching in the normalized form,
+	// we require the token to end at a segment boundary or string end.
+	// This matches 'secret', 'secrets' but NOT 'secretary'.
+	const words = lower.split(/[_\-\s.\W]+/).filter(Boolean);
+	const normalized = lower.replace(/[_\-\s.]/g, "");
+	for (const token of SENSITIVE_TOKENS) {
+		// Check individual words — exact match or token is prefix and word is <= token+2 chars
+		for (const word of words) {
+			if (word === token) return true;
+			// 'secrets' starts with 'secret' and is only 1 char longer → match
+			// 'secretary' starts with 'secret' but is 4 chars longer → no match
+			if (word.startsWith(token) && word.length <= token.length + 2) return true;
+		}
+		// Check fully-normalized form for compound tokens like 'api-key' → 'apikey'
+		// The token must appear as a complete segment (not a partial substring).
+		// After the token, the remaining chars must be a complete word (extension).
+		const idx = normalized.indexOf(token);
+		if (idx !== -1) {
+			const after = idx + token.length;
+			if (after === normalized.length) return true;
+			// Check if remaining chars after token correspond to a known word segment
+			const remaining = normalized.slice(after);
+			if (words.some((w) => remaining === w || remaining.startsWith(w))) return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Build a worker prompt constraint block listing forbidden paths.
+ * This goes into the worker system prompt to prevent accidental reads.
+ */
+export function buildSensitivePathConstraint(): string {
+	return [
+		"## Security Constraints",
+		"NEVER read, compress, or include content from:",
+		"- Files matching: .env*, *.pem, *.key, *.p12, credentials*, secrets*, passwords*, id_rsa*",
+		"- Directories: .ssh/, .aws/, .gnupg/, .kube/, .docker/",
+		"- Files with names containing: secret, credential, password, apikey, token, privatekey",
+		"If asked to read such a file, refuse and explain the security risk.",
+	].join("\n");
+}

package/src/runtime/session-usage.ts

@@ -1,79 +1,79 @@
-import * as fs from "node:fs";
-import type { UsageState } from "../state/types.ts";
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
-	for (const key of keys) {
-		const value = obj[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-	return undefined;
-}
-
-function usageFromValue(value: unknown): UsageState | undefined {
-	const obj = asRecord(value);
-	if (!obj) return undefined;
-	const direct: UsageState = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
-		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
-		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = usageFromValue(obj[key]);
-		if (nested) return nested;
-	}
-	const message = asRecord(obj.message);
-	return message ? usageFromValue(message.usage) : undefined;
-}
-
-function addUsage(total: UsageState, usage: UsageState): UsageState {
-	return {
-		input: (total.input ?? 0) + (usage.input ?? 0),
-		output: (total.output ?? 0) + (usage.output ?? 0),
-		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
-		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
-		cost: (total.cost ?? 0) + (usage.cost ?? 0),
-		turns: (total.turns ?? 0) + (usage.turns ?? 0),
-	};
-}
-
-function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
-	if (foundKeys.size === 0) return undefined;
-	const compact: UsageState = {};
-	for (const key of foundKeys) compact[key] = total[key];
-	return compact;
-}
-
-export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
-	let total: UsageState = {};
-	const foundKeys = new Set<keyof UsageState>();
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
-			if (!usage) continue;
-			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
-			total = addUsage(total, usage);
-		} catch {
-			// Session JSONL can contain partial/corrupt lines after interrupted workers.
-		}
-	}
-	return compactUsage(total, foundKeys);
-}
-
-export function parseSessionUsage(filePath: string): UsageState | undefined {
-	try {
-		if (!fs.existsSync(filePath)) return undefined;
-		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
-	} catch {
-		return undefined;
-	}
-}
+import * as fs from "node:fs";
+import type { UsageState } from "../state/types.ts";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = obj[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return undefined;
+}
+
+function usageFromValue(value: unknown): UsageState | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: UsageState = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+		const nested = usageFromValue(obj[key]);
+		if (nested) return nested;
+	}
+	const message = asRecord(obj.message);
+	return message ? usageFromValue(message.usage) : undefined;
+}
+
+function addUsage(total: UsageState, usage: UsageState): UsageState {
+	return {
+		input: (total.input ?? 0) + (usage.input ?? 0),
+		output: (total.output ?? 0) + (usage.output ?? 0),
+		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
+		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+		cost: (total.cost ?? 0) + (usage.cost ?? 0),
+		turns: (total.turns ?? 0) + (usage.turns ?? 0),
+	};
+}
+
+function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
+	if (foundKeys.size === 0) return undefined;
+	const compact: UsageState = {};
+	for (const key of foundKeys) compact[key] = total[key];
+	return compact;
+}
+
+export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
+	let total: UsageState = {};
+	const foundKeys = new Set<keyof UsageState>();
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
+			if (!usage) continue;
+			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
+			total = addUsage(total, usage);
+		} catch {
+			// Session JSONL can contain partial/corrupt lines after interrupted workers.
+		}
+	}
+	return compactUsage(total, foundKeys);
+}
+
+export function parseSessionUsage(filePath: string): UsageState | undefined {
+	try {
+		if (!fs.existsSync(filePath)) return undefined;
+		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return undefined;
+	}
+}