pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/async-subagents/core/attachment-bridge.ts

@@ -0,0 +1,133 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getRunRoot } from "./paths.js";
+
+export interface BridgedImageAttachment {
+	absolutePath: string;
+	relativePath: string;
+	mimeType: string;
+}
+
+export interface BridgeImageAttachmentsResult {
+	attachments: BridgedImageAttachment[];
+	skipped: number;
+	error?: string;
+}
+
+const ATTACHMENT_DIR = "attachments";
+const ATTACHMENT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+export function bridgeImageAttachments(cwd: string, event: unknown): BridgeImageAttachmentsResult {
+	const images = extractImageContents(event);
+	if (images.length === 0) return { attachments: [], skipped: 0 };
+	try {
+		cleanupStaleImageAttachmentDirs(cwd);
+		const batchDir = createAttachmentBatchDir(cwd);
+		const attachments: BridgedImageAttachment[] = [];
+		let skipped = 0;
+		for (const [index, image] of images.entries()) {
+			const mimeType = typeof image.mimeType === "string" ? image.mimeType.toLowerCase() : "";
+			const ext = extensionForMimeType(mimeType);
+			const data = typeof image.data === "string" ? normalizeBase64Data(image.data) : undefined;
+			if (!ext || !data) {
+				skipped++;
+				continue;
+			}
+			const absolutePath = path.join(batchDir, `image-${index + 1}${ext}`);
+			fs.writeFileSync(absolutePath, Buffer.from(data, "base64"));
+			attachments.push({
+				absolutePath,
+				relativePath: toProjectRelativePath(cwd, absolutePath),
+				mimeType,
+			});
+		}
+		if (attachments.length === 0) removeEmptyDir(batchDir);
+		return { attachments, skipped };
+	} catch (error) {
+		return {
+			attachments: [],
+			skipped: images.length,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+export function removeImageAttachmentBridgeState(cwd: string): void {
+	fs.rmSync(getAttachmentRoot(cwd), { recursive: true, force: true });
+}
+
+function extractImageContents(event: unknown): Array<{ data?: unknown; mimeType?: unknown }> {
+	const images = (event as { images?: unknown } | undefined)?.images;
+	if (!Array.isArray(images)) return [];
+	return images.filter((image): image is { data?: unknown; mimeType?: unknown } => Boolean(image) && typeof image === "object");
+}
+
+function createAttachmentBatchDir(cwd: string): string {
+	const root = getAttachmentRoot(cwd);
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	const dir = path.join(root, `${timestamp}-${crypto.randomUUID().slice(0, 8)}`);
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function getAttachmentRoot(cwd: string): string {
+	return path.join(getRunRoot(cwd), ATTACHMENT_DIR);
+}
+
+function extensionForMimeType(mimeType: string): string | undefined {
+	switch (mimeType) {
+		case "image/jpeg":
+		case "image/jpg":
+			return ".jpg";
+		case "image/png":
+			return ".png";
+		case "image/gif":
+			return ".gif";
+		case "image/webp":
+			return ".webp";
+		default:
+			return undefined;
+	}
+}
+
+function normalizeBase64Data(data: string): string | undefined {
+	const trimmed = data.trim();
+	if (!trimmed) return undefined;
+	const dataUrlMatch = /^data:[^;]+;base64,(.+)$/i.exec(trimmed);
+	return dataUrlMatch ? dataUrlMatch[1] : trimmed;
+}
+
+function toProjectRelativePath(cwd: string, filePath: string): string {
+	return path.relative(cwd, filePath).split(path.sep).join("/");
+}
+
+function cleanupStaleImageAttachmentDirs(cwd: string, now = Date.now()): void {
+	const root = getAttachmentRoot(cwd);
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(root, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const fullPath = path.join(root, entry.name);
+		try {
+			if (now - fs.statSync(fullPath).mtimeMs > ATTACHMENT_MAX_AGE_MS) {
+				fs.rmSync(fullPath, { recursive: true, force: true });
+			}
+		} catch {
+			// Best-effort cleanup only.
+		}
+	}
+	removeEmptyDir(root);
+}
+
+function removeEmptyDir(dir: string): void {
+	try {
+		fs.rmdirSync(dir);
+	} catch {
+		// Directory is absent or non-empty.
+	}
+}

package/external/pi-tools-suite/src/async-subagents/core/cleanup.ts

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isDir } from "./paths.js";
+
+export function findCleanupCandidates(
+	runRoot: string,
+	days = 7,
+	keep = 20,
+): string[] {
+	if (!isDir(runRoot)) return [];
+
+	const runDirs = fs
+		.readdirSync(runRoot, { withFileTypes: true })
+		.filter((e) => e.isDirectory())
+		.map((e) => path.join(runRoot, e.name))
+		.sort()
+		.reverse();
+
+	const candidates: string[] = [];
+	const cutoffMs = days * 24 * 60 * 60 * 1000;
+
+	for (let i = 0; i < runDirs.length; i++) {
+		if (i < keep) continue;
+		const runDir = runDirs[i];
+		if (!isCompletedRun(runDir)) continue;
+		try {
+			const stat = fs.statSync(runDir);
+			if (Date.now() - stat.mtimeMs < cutoffMs) continue;
+		} catch {
+			continue;
+		}
+		candidates.push(runDir);
+	}
+
+	return candidates;
+}
+
+export function deleteRunDirs(runDirs: string[]): void {
+	for (const dir of runDirs) {
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+export const deleteCleanupCandidates = deleteRunDirs;
+
+export function cleanupCompletedRuns(
+	runRoot: string,
+	days = 7,
+	keep = 20,
+): string[] {
+	const candidates = findCleanupCandidates(runRoot, days, keep);
+	deleteRunDirs(candidates);
+	return candidates;
+}
+
+function isCompletedRun(runDir: string): boolean {
+	let foundAgent = false;
+	for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		const agentDir = path.join(runDir, entry.name);
+		if (!fs.existsSync(path.join(agentDir, "prompt.md"))) continue;
+		foundAgent = true;
+		if (!fs.existsSync(path.join(agentDir, "exit_code"))) return false;
+	}
+	return foundAgent;
+}

package/external/pi-tools-suite/src/async-subagents/core/concurrency.ts

@@ -0,0 +1,90 @@
+/**
+ * Simple concurrency limiter (semaphore) for spawn batches.
+ *
+ * Usage:
+ *   const sem = createSemaphore(5);
+ *   // Before spawning:
+ *   await sem.acquire(signal);
+ *   // After agent completes:
+ *   sem.release();
+ */
+
+export interface Semaphore {
+	/** Wait until a slot is available. Rejects if signal is aborted. */
+	acquire(signal?: AbortSignal): Promise<void>;
+	/** Release a slot, allowing the next queued acquire to proceed. */
+	release(): void;
+	/** Current number of slots in use. */
+	readonly active: number;
+	/** Number of waiters in the queue. */
+	readonly waiting: number;
+	/** Maximum concurrency (0 = unlimited). */
+	readonly limit: number;
+}
+
+interface Waiter {
+	resolve: () => void;
+	reject: (error: Error) => void;
+}
+
+/**
+ * Create a concurrency semaphore.
+ * @param limit - Maximum concurrent holders. 0 or negative means unlimited (acquire never blocks).
+ */
+export function createSemaphore(limit: number): Semaphore {
+	const effectiveLimit = limit > 0 ? limit : 0;
+	let active = 0;
+	const queue: Waiter[] = [];
+
+	function acquire(signal?: AbortSignal): Promise<void> {
+		if (signal?.aborted) return Promise.reject(new Error("Aborted"));
+		// Unlimited: never block.
+		if (effectiveLimit === 0) {
+			active++;
+			return Promise.resolve();
+		}
+		if (active < effectiveLimit) {
+			active++;
+			return Promise.resolve();
+		}
+		return new Promise<void>((resolve, reject) => {
+			const waiter: Waiter = { resolve, reject };
+			queue.push(waiter);
+
+			if (signal) {
+				const onAbort = () => {
+					const idx = queue.indexOf(waiter);
+					if (idx !== -1) {
+						queue.splice(idx, 1);
+						reject(new Error("Aborted"));
+					}
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				// Clean up listener when waiter is resolved normally.
+				const origResolve = waiter.resolve;
+				waiter.resolve = () => {
+					signal.removeEventListener("abort", onAbort);
+					origResolve();
+				};
+			}
+		});
+	}
+
+	function release(): void {
+		if (active <= 0) return;
+		active--;
+		if (queue.length > 0 && (effectiveLimit === 0 || active < effectiveLimit)) {
+			active++;
+			const next = queue.shift()!;
+			next.resolve();
+		}
+	}
+
+	return {
+		acquire,
+		release,
+		get active() { return active; },
+		get waiting() { return queue.length; },
+		get limit() { return effectiveLimit; },
+	};
+}