pi-crew 0.2.2 → 0.2.4

package/src/state/blob-store.ts

@@ -1,117 +1,117 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createHash } from "node:crypto";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-
-const SHA256_HEX = /^[a-f0-9]{64}$/i;
-
-function validateBlobHash(hash: string): void {
-	if (!SHA256_HEX.test(hash)) throw new Error(`Invalid blob hash: ${hash}`);
-}
-
-const BLOBS_DIR = "blobs";
-const BLOB_META_DIR = "blob-metadata";
-const SHA256_PREFIX = "sha256";
-
-export interface BlobMetadata {
-	blobHash: string;
-	blobAlgorithm: string;
-	runId: string;
-	taskId?: string;
-	mime: string;
-	producer: string;
-	originalPath: string;
-	sizeBytes: number;
-	redacted: boolean;
-	retention: "run" | "project" | "temporary";
-	createdAt: string;
-}
-
-export interface BlobWriteResult {
-	hash: string;
-	algorithm: string;
-	blobPath: string;
-	metadataPath: string;
-	sizeBytes: number;
-}
-
-function sha256Of(content: string | Buffer): string {
-	return createHash("sha256").update(typeof content === "string" ? content : content).digest("hex");
-}
-
-/**
- * Write content-addressed blob to the blobs directory under artifactsRoot.
- * Content is deduplicated by hash; metadata sidecar is always written.
- */
-export function writeBlob(artifactsRoot: string, input: {
-	content: string | Buffer;
-	runId: string;
-	taskId?: string;
-	mime?: string;
-	producer: string;
-	originalPath: string;
-	redacted?: boolean;
-	retention?: BlobMetadata["retention"];
-}): BlobWriteResult {
-	const content = input.content;
-	const hash = sha256Of(content);
-	const algorithm = SHA256_PREFIX;
-	const blobDir = path.join(artifactsRoot, BLOBS_DIR, algorithm);
-	const metaDir = path.join(artifactsRoot, BLOB_META_DIR);
-	fs.mkdirSync(blobDir, { recursive: true });
-	fs.mkdirSync(metaDir, { recursive: true });
-
-	const blobPath = path.join(blobDir, hash);
-	if (!fs.existsSync(blobPath)) {
-		fs.writeFileSync(blobPath, content, typeof input.content === "string" ? "utf-8" : undefined);
-	}
-
-	const metadata: BlobMetadata = {
-		blobHash: hash,
-		blobAlgorithm: algorithm,
-		runId: input.runId,
-		taskId: input.taskId,
-		mime: input.mime ?? "text/plain",
-		producer: input.producer,
-		originalPath: input.originalPath,
-		sizeBytes: Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content, "utf-8"),
-		redacted: input.redacted ?? false,
-		retention: input.retention ?? "run",
-		createdAt: new Date().toISOString(),
-	};
-
-	const metadataPath = path.join(metaDir, `${hash}.json`);
-	fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
-
-	return { hash, algorithm, blobPath: resolveRealContainedPath(artifactsRoot, blobPath), metadataPath: resolveRealContainedPath(artifactsRoot, metadataPath), sizeBytes: metadata.sizeBytes };
-}
-
-/**
- * Read a content-addressed blob by hash.
- * Validates hash format and enforces path containment.
- */
-export function readBlob(artifactsRoot: string, hash: string): Buffer | undefined {
-	validateBlobHash(hash);
-	try {
-		const blobDir = path.join(artifactsRoot, BLOBS_DIR, SHA256_PREFIX);
-		const blobPath = resolveRealContainedPath(blobDir, hash);
-		return fs.readFileSync(blobPath);
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Read blob metadata by hash.
- * Validates hash format and enforces path containment.
- */
-export function readBlobMetadata(artifactsRoot: string, hash: string): BlobMetadata | undefined {
-	validateBlobHash(hash);
-	try {
-		const metaDir = path.join(artifactsRoot, BLOB_META_DIR);
-		const metaPath = resolveRealContainedPath(metaDir, `${hash}.json`);
-		return JSON.parse(fs.readFileSync(metaPath, "utf-8")) as BlobMetadata;
-	} catch {
-		return undefined;
-	}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+
+const SHA256_HEX = /^[a-f0-9]{64}$/i;
+
+function validateBlobHash(hash: string): void {
+	if (!SHA256_HEX.test(hash)) throw new Error(`Invalid blob hash: ${hash}`);
+}
+
+const BLOBS_DIR = "blobs";
+const BLOB_META_DIR = "blob-metadata";
+const SHA256_PREFIX = "sha256";
+
+export interface BlobMetadata {
+	blobHash: string;
+	blobAlgorithm: string;
+	runId: string;
+	taskId?: string;
+	mime: string;
+	producer: string;
+	originalPath: string;
+	sizeBytes: number;
+	redacted: boolean;
+	retention: "run" | "project" | "temporary";
+	createdAt: string;
+}
+
+export interface BlobWriteResult {
+	hash: string;
+	algorithm: string;
+	blobPath: string;
+	metadataPath: string;
+	sizeBytes: number;
+}
+
+function sha256Of(content: string | Buffer): string {
+	return createHash("sha256").update(typeof content === "string" ? content : content).digest("hex");
+}
+
+/**
+ * Write content-addressed blob to the blobs directory under artifactsRoot.
+ * Content is deduplicated by hash; metadata sidecar is always written.
+ */
+export function writeBlob(artifactsRoot: string, input: {
+	content: string | Buffer;
+	runId: string;
+	taskId?: string;
+	mime?: string;
+	producer: string;
+	originalPath: string;
+	redacted?: boolean;
+	retention?: BlobMetadata["retention"];
+}): BlobWriteResult {
+	const content = input.content;
+	const hash = sha256Of(content);
+	const algorithm = SHA256_PREFIX;
+	const blobDir = path.join(artifactsRoot, BLOBS_DIR, algorithm);
+	const metaDir = path.join(artifactsRoot, BLOB_META_DIR);
+	fs.mkdirSync(blobDir, { recursive: true });
+	fs.mkdirSync(metaDir, { recursive: true });
+
+	const blobPath = path.join(blobDir, hash);
+	if (!fs.existsSync(blobPath)) {
+		fs.writeFileSync(blobPath, content, typeof input.content === "string" ? "utf-8" : undefined);
+	}
+
+	const metadata: BlobMetadata = {
+		blobHash: hash,
+		blobAlgorithm: algorithm,
+		runId: input.runId,
+		taskId: input.taskId,
+		mime: input.mime ?? "text/plain",
+		producer: input.producer,
+		originalPath: input.originalPath,
+		sizeBytes: Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content, "utf-8"),
+		redacted: input.redacted ?? false,
+		retention: input.retention ?? "run",
+		createdAt: new Date().toISOString(),
+	};
+
+	const metadataPath = path.join(metaDir, `${hash}.json`);
+	fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+
+	return { hash, algorithm, blobPath: resolveRealContainedPath(artifactsRoot, blobPath), metadataPath: resolveRealContainedPath(artifactsRoot, metadataPath), sizeBytes: metadata.sizeBytes };
+}
+
+/**
+ * Read a content-addressed blob by hash.
+ * Validates hash format and enforces path containment.
+ */
+export function readBlob(artifactsRoot: string, hash: string): Buffer | undefined {
+	validateBlobHash(hash);
+	try {
+		const blobDir = path.join(artifactsRoot, BLOBS_DIR, SHA256_PREFIX);
+		const blobPath = resolveRealContainedPath(blobDir, hash);
+		return fs.readFileSync(blobPath);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Read blob metadata by hash.
+ * Validates hash format and enforces path containment.
+ */
+export function readBlobMetadata(artifactsRoot: string, hash: string): BlobMetadata | undefined {
+	validateBlobHash(hash);
+	try {
+		const metaDir = path.join(artifactsRoot, BLOB_META_DIR);
+		const metaPath = resolveRealContainedPath(metaDir, `${hash}.json`);
+		return JSON.parse(fs.readFileSync(metaPath, "utf-8")) as BlobMetadata;
+	} catch {
+		return undefined;
+	}
 }

package/src/state/contracts.ts

@@ -1,111 +1,111 @@
-export const TEAM_RUN_STATUSES = ["queued", "planning", "running", "blocked", "completed", "failed", "cancelled"] as const;
-export type TeamRunStatus = typeof TEAM_RUN_STATUSES[number];
-
-export const TEAM_TASK_STATUSES = ["queued", "running", "waiting", "completed", "failed", "cancelled", "skipped"] as const;
-export type TeamTaskStatus = typeof TEAM_TASK_STATUSES[number];
-
-export const TEAM_TERMINAL_RUN_STATUSES: ReadonlySet<TeamRunStatus> = new Set(["blocked", "completed", "failed", "cancelled"]);
-export const TEAM_TERMINAL_TASK_STATUSES: ReadonlySet<TeamTaskStatus> = new Set(["completed", "failed", "cancelled", "skipped"]);
-
-export const TEAM_RUN_STATUS_TRANSITIONS: Readonly<Record<TeamRunStatus, readonly TeamRunStatus[]>> = {
-	queued: ["planning", "running", "cancelled", "failed"],
-	planning: ["running", "blocked", "cancelled", "failed"],
-	running: ["blocked", "completed", "failed", "cancelled"],
-	blocked: ["running", "cancelled", "failed"],
-	completed: ["running", "cancelled"],
-	failed: ["running", "cancelled"],
-	cancelled: ["running"],
-};
-
-export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, readonly TeamTaskStatus[]>> = {
-	queued: ["running", "cancelled", "skipped", "failed"],
-	running: ["completed", "failed", "cancelled", "queued", "waiting"],
-	waiting: ["running", "queued", "completed", "failed", "cancelled"],
-	completed: ["queued"],
-	failed: ["queued", "cancelled"],
-	cancelled: ["queued"],
-	skipped: ["queued", "cancelled"],
-};
-
-export const TEAM_EVENT_TYPES = [
-	"run.created",
-	"run.queued",
-	"run.planning",
-	"run.running",
-	"run.blocked",
-	"run.completed",
-	"run.failed",
-	"run.cancelled",
-	"task.created",
-	"task.started",
-	"task.progress",
-	"task.blocked",
-	"task.green",
-	"task.red",
-	"task.completed",
-	"task.failed",
-	"task.cancelled",
-	"task.skipped",
-	"review.approved",
-	"review.rejected",
-	"policy.action",
-	"policy.escalated",
-	"recovery.attempted",
-	"recovery.escalated",
-	"branch.stale",
-	"mailbox.timeout",
-	"worktree.cleanup",
-	"worktree.dirty",
-	"async.spawned",
-	"async.started",
-	"async.completed",
-	"async.failed",
-	"async.stale",
-	"task.waiting",
-	"task.resumed",
-	"task.retried",
-	"supervisor.contact",
-] as const;
-export type TeamEventType = typeof TEAM_EVENT_TYPES[number];
-
-export const TEAM_WAKEABLE_EVENT_TYPES: ReadonlySet<TeamEventType> = new Set([
-	"run.blocked",
-	"run.completed",
-	"run.failed",
-	"run.cancelled",
-	"task.completed",
-	"task.failed",
-	"task.cancelled",
-	"task.skipped",
-	"async.completed",
-	"async.failed",
-	"async.stale",
-]);
-
-export function isTeamRunStatus(value: unknown): value is TeamRunStatus {
-	return typeof value === "string" && TEAM_RUN_STATUSES.includes(value as TeamRunStatus);
-}
-
-export function isTeamTaskStatus(value: unknown): value is TeamTaskStatus {
-	return typeof value === "string" && TEAM_TASK_STATUSES.includes(value as TeamTaskStatus);
-}
-
-export function isTerminalRunStatus(status: TeamRunStatus): boolean {
-	return TEAM_TERMINAL_RUN_STATUSES.has(status);
-}
-
-export function isTerminalTaskStatus(status: TeamTaskStatus): boolean {
-	return TEAM_TERMINAL_TASK_STATUSES.has(status);
-}
-
-export function canTransitionRunStatus(from: TeamRunStatus, to: TeamRunStatus): boolean {
-	return from === to || (TEAM_RUN_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
-}
-
-export function canTransitionTaskStatus(from: TeamTaskStatus, to: TeamTaskStatus): boolean {
-	return from === to || (TEAM_TASK_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
-}
-
-export function isWakeableTeamEventType(type: TeamEventType): boolean {
-	return TEAM_WAKEABLE_EVENT_TYPES.has(type);
-}
+export const TEAM_RUN_STATUSES = ["queued", "planning", "running", "blocked", "completed", "failed", "cancelled"] as const;
+export type TeamRunStatus = typeof TEAM_RUN_STATUSES[number];
+
+export const TEAM_TASK_STATUSES = ["queued", "running", "waiting", "completed", "failed", "cancelled", "skipped"] as const;
+export type TeamTaskStatus = typeof TEAM_TASK_STATUSES[number];
+
+export const TEAM_TERMINAL_RUN_STATUSES: ReadonlySet<TeamRunStatus> = new Set(["blocked", "completed", "failed", "cancelled"]);
+export const TEAM_TERMINAL_TASK_STATUSES: ReadonlySet<TeamTaskStatus> = new Set(["completed", "failed", "cancelled", "skipped"]);
+
+export const TEAM_RUN_STATUS_TRANSITIONS: Readonly<Record<TeamRunStatus, readonly TeamRunStatus[]>> = {
+	queued: ["planning", "running", "cancelled", "failed"],
+	planning: ["running", "blocked", "cancelled", "failed"],
+	running: ["blocked", "completed", "failed", "cancelled"],
+	blocked: ["running", "cancelled", "failed"],
+	completed: ["running", "cancelled"],
+	failed: ["running", "cancelled"],
+	cancelled: ["running"],
+};
+
+export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, readonly TeamTaskStatus[]>> = {
+	queued: ["running", "cancelled", "skipped", "failed"],
+	running: ["completed", "failed", "cancelled", "queued", "waiting"],
+	waiting: ["running", "queued", "completed", "failed", "cancelled"],
+	completed: ["queued"],
+	failed: ["queued", "cancelled"],
+	cancelled: ["queued"],
+	skipped: ["queued", "cancelled"],
+};
+
+export const TEAM_EVENT_TYPES = [
+	"run.created",
+	"run.queued",
+	"run.planning",
+	"run.running",
+	"run.blocked",
+	"run.completed",
+	"run.failed",
+	"run.cancelled",
+	"task.created",
+	"task.started",
+	"task.progress",
+	"task.blocked",
+	"task.green",
+	"task.red",
+	"task.completed",
+	"task.failed",
+	"task.cancelled",
+	"task.skipped",
+	"review.approved",
+	"review.rejected",
+	"policy.action",
+	"policy.escalated",
+	"recovery.attempted",
+	"recovery.escalated",
+	"branch.stale",
+	"mailbox.timeout",
+	"worktree.cleanup",
+	"worktree.dirty",
+	"async.spawned",
+	"async.started",
+	"async.completed",
+	"async.failed",
+	"async.stale",
+	"task.waiting",
+	"task.resumed",
+	"task.retried",
+	"supervisor.contact",
+] as const;
+export type TeamEventType = typeof TEAM_EVENT_TYPES[number];
+
+export const TEAM_WAKEABLE_EVENT_TYPES: ReadonlySet<TeamEventType> = new Set([
+	"run.blocked",
+	"run.completed",
+	"run.failed",
+	"run.cancelled",
+	"task.completed",
+	"task.failed",
+	"task.cancelled",
+	"task.skipped",
+	"async.completed",
+	"async.failed",
+	"async.stale",
+]);
+
+export function isTeamRunStatus(value: unknown): value is TeamRunStatus {
+	return typeof value === "string" && TEAM_RUN_STATUSES.includes(value as TeamRunStatus);
+}
+
+export function isTeamTaskStatus(value: unknown): value is TeamTaskStatus {
+	return typeof value === "string" && TEAM_TASK_STATUSES.includes(value as TeamTaskStatus);
+}
+
+export function isTerminalRunStatus(status: TeamRunStatus): boolean {
+	return TEAM_TERMINAL_RUN_STATUSES.has(status);
+}
+
+export function isTerminalTaskStatus(status: TeamTaskStatus): boolean {
+	return TEAM_TERMINAL_TASK_STATUSES.has(status);
+}
+
+export function canTransitionRunStatus(from: TeamRunStatus, to: TeamRunStatus): boolean {
+	return from === to || (TEAM_RUN_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
+}
+
+export function canTransitionTaskStatus(from: TeamTaskStatus, to: TeamTaskStatus): boolean {
+	return from === to || (TEAM_TASK_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
+}
+
+export function isWakeableTeamEventType(type: TeamEventType): boolean {
+	return TEAM_WAKEABLE_EVENT_TYPES.has(type);
+}