@bingjiang0611/rotom 0.1.0-alpha.0

package/extensions/third-party/node_modules/pi-subagents/src/shared/accessible-dir.ts

@@ -0,0 +1,47 @@
+import * as fs from "node:fs";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
+
+type AccessibleDirFs = Pick<typeof fs, "accessSync" | "mkdirSync">;
+
+type AccessibleDirOptions = {
+	fs?: AccessibleDirFs;
+	retryDirectoryErrors?: boolean;
+	retryDelaysMs?: readonly number[];
+	wait?: (delayMs: number) => void;
+	pid?: number;
+};
+
+export function ensureAccessibleDir(dirPath: string, options: AccessibleDirOptions = {}): string {
+	const fsImpl = options.fs ?? fs;
+	const pid = options.pid ?? process.pid;
+	const retryDirectoryErrors = options.retryDirectoryErrors ?? process.platform === "win32";
+	const retryDelaysMs = retryDirectoryErrors ? options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];
+	const wait = options.wait ?? waitForFileSystemRetry;
+
+	const mkdirWithRetry = (target: string): void => {
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.mkdirSync(target, { recursive: true });
+		}, { retryDelaysMs, wait });
+	};
+	const accessWithRetry = (target: string): void => {
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.accessSync(target, fs.constants.R_OK | fs.constants.W_OK);
+		}, { retryDelaysMs, wait });
+	};
+	const fallbackPath = (): string => {
+		const fallback = `${dirPath}-${pid}`;
+		mkdirWithRetry(fallback);
+		accessWithRetry(fallback);
+		return fallback;
+	};
+
+	try {
+		mkdirWithRetry(dirPath);
+		accessWithRetry(dirPath);
+		return dirPath;
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException | undefined)?.code;
+		if (code !== "EPERM" && code !== "EACCES") throw error;
+		return fallbackPath();
+	}
+}

package/extensions/third-party/node_modules/pi-subagents/src/shared/agent-stream-options.ts

@@ -0,0 +1,5 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+
+export function agentStreamOptions(streamFn: StreamFn): { streamFunction: StreamFn; streamFn: StreamFn } {
+	return { streamFunction: streamFn, streamFn };
+}

package/extensions/third-party/node_modules/pi-subagents/src/shared/artifacts.ts

@@ -0,0 +1,281 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CHAIN_RUNS_DIR, TEMP_ARTIFACTS_DIR, type ArtifactPaths, type ArtifactDirPreference } from "./types.ts";
+import { getAgentDir } from "./utils.ts";
+const CLEANUP_MARKER_FILE = ".last-cleanup";
+export const PROJECT_SUBAGENTS_RELATIVE_DIR = ".pi/subagents";
+
+const PROJECT_ARTIFACT_PATHS = [
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/output.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_input.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_output.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker.jsonl`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_transcript.jsonl`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_meta.json`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/progress/run/progress.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/output.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/run/output.md`,
+	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/chain-runs/run.json`,
+];
+
+function globMatchesPath(pattern: string, filePath: string): boolean {
+	let expression = "^";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const character = pattern[index];
+		if (character === undefined) break;
+		if (character === "*" && pattern[index + 1] === "*") {
+			index += 1;
+			if (pattern[index + 1] === "/") {
+				index += 1;
+				expression += "(?:.*/)?";
+			} else {
+				expression += ".*";
+			}
+		} else if (character === "*") {
+			expression += "[^/]*";
+		} else if (character === "?") {
+			expression += "[^/]";
+		} else if (character === "[") {
+			const end = pattern.indexOf("]", index + 1);
+			if (end === -1) expression += "\\[";
+			else {
+				expression += pattern.slice(index, end + 1);
+				index = end;
+			}
+		} else {
+			expression += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+		}
+	}
+	try {
+		return new RegExp(`${expression}$`).test(filePath);
+	} catch {
+		return false;
+	}
+}
+
+function normalizePattern(pattern: string): string {
+	return pattern.replace(/^\.\//, "").replace(/^\//, "").replace(/\/+$/, "");
+}
+
+function patternMatchesArtifactPath(pattern: string, artifactPath: string): boolean {
+	const normalized = normalizePattern(pattern);
+	return normalized === PROJECT_SUBAGENTS_RELATIVE_DIR
+		|| normalized === "*"
+		|| artifactPath.startsWith(`${normalized}/`)
+		|| globMatchesPath(normalized, artifactPath);
+}
+
+function ignoreFileExcludesProjectArtifacts(filePath: string): boolean {
+	if (!fs.existsSync(filePath)) return false;
+	try {
+		const excluded = new Set<string>();
+		for (const rawLine of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+			const line = rawLine.trim();
+			if (!line || line.startsWith("#")) continue;
+			const negated = line.startsWith("!");
+			const pattern = negated ? line.slice(1) : line;
+			for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+				if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
+				if (negated) excluded.delete(artifactPath);
+				else excluded.add(artifactPath);
+			}
+		}
+		return excluded.size === PROJECT_ARTIFACT_PATHS.length;
+	} catch {
+		return false;
+	}
+}
+
+function filesIncludeProjectArtifacts(files: unknown): boolean | undefined {
+	if (!Array.isArray(files)) return undefined;
+	const included = new Set<string>();
+	for (const entry of files) {
+		if (typeof entry !== "string") continue;
+		const negated = entry.startsWith("!");
+		const pattern = negated ? entry.slice(1) : entry;
+		for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+			if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
+			if (negated) included.delete(artifactPath);
+			else included.add(artifactPath);
+		}
+	}
+	return included.size > 0;
+}
+
+/** Returns a package-publishing warning when project artifacts can enter npm packages. */
+export function getProjectArtifactPackagingWarning(cwd: string): string | undefined {
+	const packagePath = path.join(cwd, "package.json");
+	if (!fs.existsSync(packagePath)) return undefined;
+
+	let packageJson: Record<string, unknown>;
+	try {
+		const parsed: unknown = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+		packageJson = parsed as Record<string, unknown>;
+	} catch {
+		return undefined;
+	}
+
+	const filesIncludeArtifacts = filesIncludeProjectArtifacts(packageJson.files);
+	if (filesIncludeArtifacts === false) return undefined;
+
+	const npmIgnorePath = path.join(cwd, ".npmignore");
+	const ignorePath = fs.existsSync(npmIgnorePath) ? npmIgnorePath : path.join(cwd, ".gitignore");
+	if (filesIncludeArtifacts === undefined && ignoreFileExcludesProjectArtifacts(ignorePath)) return undefined;
+
+	return "Project-scoped subagent artifacts can be included when this package is published. Add '.pi/subagents/' to .npmignore, restrict package.json files, or set artifactDir to 'session' or 'temp'.";
+}
+
+export function getProjectSubagentsDir(cwd: string): string {
+	return path.join(cwd, PROJECT_SUBAGENTS_RELATIVE_DIR);
+}
+
+export function getProjectArtifactsDir(cwd: string): string {
+	return path.join(getProjectSubagentsDir(cwd), "artifacts");
+}
+
+export function getProjectChainRunsDir(cwd: string): string {
+	return path.join(getProjectSubagentsDir(cwd), "chain-runs");
+}
+
+export function getChainRunsDir(
+	projectCwd: string,
+	dirPreference: ArtifactDirPreference = "session",
+): string {
+	switch (dirPreference) {
+		case "project":
+			return getProjectChainRunsDir(projectCwd);
+		case "session":
+		case "temp":
+			return CHAIN_RUNS_DIR;
+		default:
+			throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
+	}
+}
+
+export function getArtifactsDir(
+	sessionFile: string | null,
+	projectCwd?: string,
+	dirPreference: ArtifactDirPreference = "session",
+): string {
+	switch (dirPreference) {
+		case "session":
+			if (sessionFile) {
+				const sessionDir = path.dirname(sessionFile);
+				return path.join(sessionDir, "subagent-artifacts");
+			}
+			return TEMP_ARTIFACTS_DIR;
+		case "temp":
+			return TEMP_ARTIFACTS_DIR;
+		case "project":
+			if (projectCwd) return getProjectArtifactsDir(projectCwd);
+			if (sessionFile) {
+				const sessionDir = path.dirname(sessionFile);
+				return path.join(sessionDir, "subagent-artifacts");
+			}
+			return TEMP_ARTIFACTS_DIR;
+		default:
+			throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
+	}
+}
+
+export function getArtifactPaths(artifactsDir: string, runId: string, agent: string, index?: number): ArtifactPaths {
+	const suffix = index !== undefined ? `_${index}` : "";
+	const safeAgent = agent.replace(/[^\w.-]/g, "_");
+	const base = `${runId}_${safeAgent}${suffix}`;
+	return {
+		inputPath: path.join(artifactsDir, `${base}_input.md`),
+		outputPath: path.join(artifactsDir, `${base}_output.md`),
+		jsonlPath: path.join(artifactsDir, `${base}.jsonl`),
+		transcriptPath: path.join(artifactsDir, `${base}_transcript.jsonl`),
+		metadataPath: path.join(artifactsDir, `${base}_meta.json`),
+	};
+}
+
+export function ensureArtifactsDir(dir: string): void {
+	fs.mkdirSync(dir, { recursive: true });
+}
+
+export function writeArtifact(filePath: string, content: string): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, content, "utf-8");
+}
+
+export function formatOutputArtifactContent(input: {
+	output: string;
+	error?: string;
+	transcriptPath?: string;
+	metadataPath?: string;
+}): string {
+	if (input.output.trim() || !input.error) return input.output;
+	const lines = ["Subagent run failed before producing output.", "", "Error:", input.error];
+	if (input.transcriptPath) lines.push("", `Transcript: ${input.transcriptPath}`);
+	if (input.metadataPath) lines.push(`Metadata: ${input.metadataPath}`);
+	return lines.join("\n");
+}
+
+export function writeMetadata(filePath: string, metadata: object): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+
+export function appendJsonl(filePath: string, line: string): void {
+	fs.appendFileSync(filePath, `${line}\n`);
+}
+
+export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
+	if (maxAgeDays <= 0 || !fs.existsSync(dir)) return;
+
+	const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
+	const now = Date.now();
+
+	if (fs.existsSync(markerPath)) {
+		const stat = fs.statSync(markerPath);
+		if (now - stat.mtimeMs < 24 * 60 * 60 * 1000) return;
+	}
+
+	const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+	const cutoff = now - maxAgeMs;
+
+	for (const file of fs.readdirSync(dir)) {
+		if (file === CLEANUP_MARKER_FILE) continue;
+		const filePath = path.join(dir, file);
+		try {
+			const stat = fs.statSync(filePath);
+			if (stat.mtimeMs < cutoff) {
+				fs.unlinkSync(filePath);
+			}
+		} catch {
+			// Artifact cleanup is best-effort housekeeping. Skip files that disappear
+			// or become unreadable while scanning so one bad entry does not block the rest.
+		}
+	}
+
+	fs.writeFileSync(markerPath, String(now));
+}
+
+export function cleanupAllArtifactDirs(maxAgeDays: number): void {
+	cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+
+	const sessionsBase = path.join(getAgentDir(), "sessions");
+	if (!fs.existsSync(sessionsBase)) return;
+
+	let dirs: string[];
+	try {
+		dirs = fs.readdirSync(sessionsBase);
+	} catch {
+		// Session artifact cleanup is best-effort. If the sessions root cannot be read,
+		// skip cleanup instead of failing extension startup.
+		return;
+	}
+
+	for (const dir of dirs) {
+		const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
+		try {
+			cleanupOldArtifacts(artifactsDir, maxAgeDays);
+		} catch {
+			// Session cleanup is best-effort. Keep going so one unreadable session dir
+			// does not block cleanup for the rest.
+		}
+	}
+}

package/extensions/third-party/node_modules/pi-subagents/src/shared/atomic-json.ts

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
+
+type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
+
+const MAX_PATH_COMPONENT_BYTES = 255;
+
+type AtomicJsonWriterOptions = {
+	fs?: AtomicJsonFs;
+	now?: () => number;
+	pid?: number;
+	random?: () => number;
+	mode?: number;
+	retryRenameErrors?: boolean;
+	retryDirectoryErrors?: boolean;
+	retryDelaysMs?: readonly number[];
+	wait?: (delayMs: number) => void;
+};
+
+function renameWithRetry(
+	fsImpl: AtomicJsonFs,
+	sourcePath: string,
+	targetPath: string,
+	retryDelaysMs: readonly number[],
+	wait: (delayMs: number) => void,
+): void {
+	runFileSystemOperationWithRetry(() => {
+		fsImpl.renameSync(sourcePath, targetPath);
+	}, { retryDelaysMs, wait });
+}
+
+function tempBaseName(filePath: string, pid: number, nowMs: number, randomId: string): string {
+	const suffix = `.${pid}.${nowMs}.${randomId}.tmp`;
+	const preferred = `.${path.basename(filePath)}${suffix}`;
+	if (Buffer.byteLength(preferred, "utf-8") <= MAX_PATH_COMPONENT_BYTES) return preferred;
+	return `.${createHash("sha256").update(path.basename(filePath)).digest("hex")}${suffix}`;
+}
+
+export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
+	const fsImpl = options.fs ?? fs;
+	const now = options.now ?? Date.now;
+	const pid = options.pid ?? process.pid;
+	const random = options.random ?? Math.random;
+	const mode = options.mode;
+	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+	const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
+	const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
+	const wait = options.wait ?? waitForFileSystemRetry;
+	return (filePath: string, payload: object): void => {
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		}, { retryDelaysMs: directoryRetryDelaysMs, wait });
+		const tempPath = path.join(
+			path.dirname(filePath),
+			tempBaseName(filePath, pid, now(), random().toString(36).slice(2)),
+		);
+		let writeError: unknown;
+		try {
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
+			renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
+		} catch (error) {
+			writeError = error;
+			throw error;
+		} finally {
+			try {
+				fsImpl.rmSync(tempPath, { force: true });
+			} catch (cleanupError) {
+				// Preserve the write/rename failure: cleanup is best effort and must
+				// not hide the error callers need to classify or report.
+				if (writeError === undefined) throw cleanupError;
+			}
+		}
+	};
+}
+
+export const writeAtomicJson = createAtomicJsonWriter();
+export const writePrivateAtomicJson = createAtomicJsonWriter({ mode: 0o600 });

package/extensions/third-party/node_modules/pi-subagents/src/shared/capacity-resilient-json.ts

@@ -0,0 +1,102 @@
+import { isStorageCapacityError } from "./file-system-retry.ts";
+import { writeAtomicJson } from "./atomic-json.ts";
+
+type TimerApi = {
+	setTimeout(handler: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+};
+
+const defaultTimerApi: TimerApi = {
+	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+export type CapacityResilientJsonWriterOptions = {
+	/** The underlying write operation. It must be atomic for each target path. */
+	write?: (filePath: string, payload: object) => void;
+	/** Keep retry timers referenced by the event loop (needed by child runners). */
+	keepAlive?: boolean;
+	retryDelayMs?: number;
+	timerApi?: TimerApi;
+	onError?: (error: unknown, filePath: string) => void;
+	onSuccess?: (filePath: string, payload: object) => void;
+};
+
+export type CapacityResilientJsonWriter = {
+	write(filePath: string, payload: object, writeOperation?: (filePath: string, payload: object) => void): void;
+	pendingCount(): number;
+	dispose(): void;
+};
+
+/**
+ * Defers only storage-capacity failures, retaining the newest payload per path.
+ * Initial/ordinary writes remain synchronous and preserve their throwing contract;
+ * only ENOSPC-like failures enter the guarded retry loop.
+ */
+export function createCapacityResilientJsonWriter(options: CapacityResilientJsonWriterOptions = {}): CapacityResilientJsonWriter {
+	const defaultWrite = options.write ?? writeAtomicJson;
+	const keepAlive = options.keepAlive ?? false;
+	const retryDelayMs = options.retryDelayMs ?? 1_000;
+	const timerApi = options.timerApi ?? defaultTimerApi;
+	const onError = options.onError ?? ((error, filePath) => console.error(`Failed to persist JSON '${filePath}':`, error));
+	const onSuccess = options.onSuccess;
+	const reportError = (error: unknown, filePath: string): void => {
+		try {
+			onError(error, filePath);
+		} catch (callbackError) {
+			console.error(`Failed to report JSON persistence error for '${filePath}':`, callbackError);
+		}
+	};
+	const notifySuccess = (filePath: string, payload: object): void => {
+		if (!onSuccess) return;
+		try {
+			onSuccess(filePath, payload);
+		} catch (error) {
+			reportError(error, filePath);
+		}
+	};
+	const pending = new Map<string, { payload: object; write: (filePath: string, payload: object) => void }>();
+	let retryTimer: unknown;
+
+	const scheduleRetry = (): void => {
+		if (retryTimer !== undefined) return;
+		retryTimer = timerApi.setTimeout(() => {
+			retryTimer = undefined;
+			for (const [filePath, entry] of pending) {
+				try {
+					entry.write(filePath, entry.payload);
+					pending.delete(filePath);
+					notifySuccess(filePath, entry.payload);
+				} catch (error) {
+					if (isStorageCapacityError(error)) continue;
+					pending.delete(filePath);
+					reportError(error, filePath);
+				}
+			}
+			if (pending.size > 0) scheduleRetry();
+		}, retryDelayMs);
+		if (!keepAlive && typeof retryTimer === "object" && retryTimer !== null && "unref" in retryTimer && typeof retryTimer.unref === "function") {
+			retryTimer.unref();
+		}
+	};
+
+	return {
+		write(filePath, payload, writeOperation = defaultWrite): void {
+			try {
+				writeOperation(filePath, payload);
+				pending.delete(filePath);
+				notifySuccess(filePath, payload);
+			} catch (error) {
+				if (!isStorageCapacityError(error)) throw error;
+				pending.set(filePath, { payload, write: writeOperation });
+				scheduleRetry();
+			}
+		},
+		pendingCount: () => pending.size,
+		dispose: (): void => {
+			if (retryTimer !== undefined) timerApi.clearTimeout(retryTimer);
+			retryTimer = undefined;
+			pending.clear();
+		},
+	};
+}