@narumitw/pi-subagents 2.1.3 → 3.0.0

package/src/create-stateful-transport.ts

@@ -1,157 +0,0 @@
-import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-import type { SubagentSettings, SubagentTransportKind } from "./agents/types.js";
-import { cachedModuleLoader, throwIfAborted } from "./cached-module-loader.js";
-import type { ChildSessionFactory, ParentRuntimeSnapshot } from "./in-process-transport.js";
-import type { PeerTransportRuntime } from "./peer-transport.js";
-import type { AgentMailboxMessage, ManagedAgent, TurnOutcome } from "./registry.js";
-import type { SubagentTransport } from "./transport.js";
-import type { TransportProgressCallback } from "./transport-types.js";
-
-export interface CreateStatefulTransportOptions {
-	kind: SubagentTransportKind;
-	modelRegistry: ModelRegistry;
-	getParentRuntime(): ParentRuntimeSnapshot;
-	getSettings(): SubagentSettings | undefined;
-	createInProcessSession?: ChildSessionFactory;
-	peerRuntime?: PeerTransportRuntime;
-	loadTransport?: () => Promise<SubagentTransport>;
-}
-
-export function createStatefulTransport(
-	options: CreateStatefulTransportOptions,
-): SubagentTransport {
-	return new LazyStatefulTransport(
-		options.kind,
-		cachedModuleLoader(options.loadTransport ?? (() => loadStatefulTransport(options))),
-	);
-}
-
-class LazyStatefulTransport implements SubagentTransport {
-	private loaded: SubagentTransport | undefined;
-	private loading: Promise<SubagentTransport> | undefined;
-	private closed = false;
-	private shutdownPromise: Promise<void> | undefined;
-
-	constructor(
-		readonly kind: SubagentTransportKind,
-		private readonly loadImplementation: () => Promise<SubagentTransport>,
-	) {}
-
-	async runTurn(
-		agent: ManagedAgent,
-		task: string,
-		signal: AbortSignal,
-		onProgress?: TransportProgressCallback,
-	): Promise<TurnOutcome> {
-		if (this.closed) throw new Error("Subagent transport is shut down");
-		throwIfAborted(signal, "Subagent transport loading was cancelled");
-		let transport: SubagentTransport;
-		try {
-			transport = await this.load();
-		} catch (error) {
-			throwIfAborted(signal, "Subagent transport loading was cancelled");
-			throw error;
-		}
-		throwIfAborted(signal, "Subagent transport loading was cancelled");
-		if (this.closed) {
-			await this.shutdownLoaded();
-			throw new Error("Subagent transport shut down while loading");
-		}
-		return transport.runTurn(agent, task, signal, onProgress);
-	}
-
-	async deliverMessage(agent: ManagedAgent, message: AgentMailboxMessage): Promise<boolean> {
-		const transport = this.loaded;
-		if (!transport?.deliverMessage || this.closed) return false;
-		return transport.deliverMessage(agent, message);
-	}
-
-	async release(agent: ManagedAgent): Promise<void> {
-		const transport =
-			this.loaded ?? (this.loading ? await this.loading.catch(() => undefined) : undefined);
-		if (!transport || this.closed) return;
-		await transport.release?.(agent);
-	}
-
-	async shutdown(): Promise<void> {
-		this.closed = true;
-		if (this.loading && !this.loaded) await this.loading.catch(() => undefined);
-		await this.shutdownLoaded();
-	}
-
-	private async load(): Promise<SubagentTransport> {
-		if (this.loaded) return this.loaded;
-		if (!this.loading) {
-			this.loading = this.loadImplementation()
-				.then((transport) => {
-					this.loaded = transport;
-					return transport;
-				})
-				.finally(() => {
-					this.loading = undefined;
-				});
-		}
-		return this.loading;
-	}
-
-	private async shutdownLoaded(): Promise<void> {
-		if (!this.loaded) return;
-		if (!this.shutdownPromise) {
-			this.shutdownPromise = Promise.resolve(this.loaded.shutdown?.());
-		}
-		await this.shutdownPromise;
-	}
-}
-
-async function loadStatefulTransport(
-	options: CreateStatefulTransportOptions,
-): Promise<SubagentTransport> {
-	const subprocess = async () => {
-		const { SubprocessTransport } = await import("./subprocess-transport.js");
-		return new SubprocessTransport({
-			getSettings: options.getSettings,
-			peerRuntime: options.peerRuntime,
-		});
-	};
-	const inProcess = async () => {
-		const [{ discoverAgents }, { InProcessTransport }] = await Promise.all([
-			import("./agents/discovery.js"),
-			import("./in-process-transport.js"),
-		]);
-		return new InProcessTransport({
-			modelRegistry: options.modelRegistry,
-			peerRuntime: options.peerRuntime,
-			getParentRuntime: options.getParentRuntime,
-			createSession: options.createInProcessSession,
-			discoverAgent: (agent) =>
-				discoverAgents(agent.cwd, agent.agentScope ?? "user", options.getSettings()).agents.find(
-					(candidate) => candidate.name === agent.agent,
-				),
-		});
-	};
-	const rpc = async () => {
-		const { RpcTransport } = await import("./rpc-transport.js");
-		return new RpcTransport({
-			getSettings: options.getSettings,
-			getParentRuntime: options.getParentRuntime,
-			peerRuntime: options.peerRuntime,
-		});
-	};
-	switch (options.kind) {
-		case "subprocess":
-			return subprocess();
-		case "in-process":
-			return inProcess();
-		case "rpc":
-			return rpc();
-		case "auto": {
-			const { AutoTransport } = await import("./auto-transport.js");
-			return new AutoTransport({
-				subprocess: new LazyStatefulTransport("subprocess", cachedModuleLoader(subprocess)),
-				inProcess: new LazyStatefulTransport("in-process", cachedModuleLoader(inProcess)),
-				rpc: new LazyStatefulTransport("rpc", cachedModuleLoader(rpc)),
-				getSettings: options.getSettings,
-			});
-		}
-	}
-}

package/src/cwd-policy.ts

@@ -1,183 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getAgentDir, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
-import type { ConsultationCwdPolicy, DelegationCwdPolicy } from "./agents/types.js";
-import { safeTerminalLine } from "./safe-text.js";
-
-export type TargetBoundary = "current-workspace" | "external";
-export type TargetTrustKind =
-	| "session-trusted"
-	| "session-untrusted"
-	| "saved-trusted"
-	| "saved-denied"
-	| "unsaved"
-	| "trust-error";
-
-export interface ResolvedTargetTrust {
-	kind: TargetTrustKind;
-	projectTrusted: boolean;
-	sourcePath?: string;
-	warning?: string;
-}
-
-export interface ResolvedSubagentTarget {
-	cwd: string;
-	workspace: string;
-	boundary: TargetBoundary;
-	trust: ResolvedTargetTrust;
-}
-
-export interface TargetPolicyAudit {
-	cwd: string;
-	boundary: TargetBoundary;
-	trust: {
-		kind: TargetTrustKind;
-		projectTrusted: boolean;
-		sourcePath?: string;
-		warning?: string;
-	};
-}
-
-export function targetPolicyAudit(target: ResolvedSubagentTarget): TargetPolicyAudit {
-	return {
-		cwd: safeTerminalLine(target.cwd),
-		boundary: target.boundary,
-		trust: {
-			...target.trust,
-			sourcePath: target.trust.sourcePath ? safeTerminalLine(target.trust.sourcePath) : undefined,
-			warning: target.trust.warning ? safeTerminalLine(target.trust.warning, 512) : undefined,
-		},
-	};
-}
-
-export interface ResolveSubagentTargetOptions {
-	workspace: string;
-	requestedCwd?: string;
-	currentProjectTrusted: boolean;
-	agentDir?: string;
-}
-
-export function resolveSubagentTarget(
-	options: ResolveSubagentTargetOptions,
-): ResolvedSubagentTarget {
-	const workspace = canonicalDirectory(options.workspace, "Current workspace");
-	const requested = path.resolve(options.workspace, options.requestedCwd ?? options.workspace);
-	const cwd = canonicalDirectory(requested, "Subagent working directory");
-	const boundary: TargetBoundary = isEqualOrDescendant(cwd, workspace)
-		? "current-workspace"
-		: "external";
-	if (boundary === "current-workspace") {
-		return {
-			cwd,
-			workspace,
-			boundary,
-			trust: {
-				kind: options.currentProjectTrusted ? "session-trusted" : "session-untrusted",
-				projectTrusted: options.currentProjectTrusted,
-				sourcePath: workspace,
-			},
-		};
-	}
-	try {
-		const entry = new ProjectTrustStore(options.agentDir ?? getAgentDir()).getEntry(cwd);
-		if (!entry) {
-			return {
-				cwd,
-				workspace,
-				boundary,
-				trust: { kind: "unsaved", projectTrusted: false },
-			};
-		}
-		return {
-			cwd,
-			workspace,
-			boundary,
-			trust: {
-				kind: entry.decision ? "saved-trusted" : "saved-denied",
-				projectTrusted: entry.decision,
-				sourcePath: entry.path,
-			},
-		};
-	} catch {
-		return {
-			cwd,
-			workspace,
-			boundary,
-			trust: {
-				kind: "trust-error",
-				projectTrusted: false,
-				warning: safeTerminalLine(
-					"Could not resolve Pi trust store; protected target resources were disabled. Repair trust with Pi /trust and restart Pi.",
-					512,
-				),
-			},
-		};
-	}
-}
-
-export function assertConsultationTargetAllowed(
-	target: ResolvedSubagentTarget,
-	policy: ConsultationCwdPolicy,
-): void {
-	if (policy === "current-workspace" && target.boundary !== "current-workspace") {
-		throw new Error(
-			`Read-only consultation target is outside the current workspace: ${safeTerminalLine(target.cwd)}`,
-		);
-	}
-}
-
-export function assertDelegationTargetAllowed(
-	target: ResolvedSubagentTarget,
-	policy: DelegationCwdPolicy,
-): void {
-	if (target.boundary === "current-workspace" || policy === "anywhere") return;
-	if (policy === "trusted-targets" && target.trust.kind === "saved-trusted") return;
-	if (policy === "current-workspace") {
-		throw new Error(
-			`General delegation target is outside the current workspace: ${safeTerminalLine(target.cwd)}`,
-		);
-	}
-	const reason =
-		target.trust.kind === "trust-error"
-			? target.trust.warning
-			: `Target trust is ${target.trust.kind}.`;
-	throw new Error(
-		[
-			`General delegation target is not a saved-trusted folder: ${safeTerminalLine(target.cwd)}`,
-			reason,
-			"Open Pi in that folder, manage trust with /trust, restart Pi, or choose Anywhere in /subagents settings.",
-		]
-			.filter(Boolean)
-			.join(" "),
-	);
-}
-
-function canonicalDirectory(value: string, label: string): string {
-	let canonical: string;
-	try {
-		canonical = fs.realpathSync(value);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-			throw new Error(`${label} does not exist: ${safeTerminalLine(value)}`);
-		}
-		throw new Error(
-			`${label} cannot be resolved: ${safeTerminalLine(value)}: ${formatError(error)}`,
-		);
-	}
-	if (!fs.statSync(canonical).isDirectory()) {
-		throw new Error(`${label} is not a directory: ${safeTerminalLine(canonical)}`);
-	}
-	return canonical;
-}
-
-function isEqualOrDescendant(candidate: string, workspace: string): boolean {
-	const relative = path.relative(workspace, candidate);
-	return (
-		relative === "" ||
-		(!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative))
-	);
-}
-
-function formatError(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}