@melihmucuk/pi-crew 1.0.17 → 1.0.19

package/extension/crew.ts

@@ -0,0 +1,377 @@
+import { randomBytes } from "node:crypto";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { AgentSession, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "./catalog.js";
+import type { BootstrapContext, SubagentRunner, SubagentRunnerCallbacks } from "./subagent-session.js";
+import { SubagentSessionRunner } from "./subagent-session.js";
+import {
+	type SendMessageFn,
+	type SteeringPayload,
+	type SubagentStatus,
+	sendSteeringMessage,
+} from "./ui.js";
+
+export interface ActiveRuntimeBinding {
+	sessionId: string;
+	isIdle: () => boolean;
+	sendMessage: SendMessageFn;
+}
+
+interface PendingMessage {
+	ownerSessionId: string;
+	payload: SteeringPayload;
+	queuedAt: number;
+}
+
+export interface SubagentState {
+	id: string;
+	agentConfig: AgentConfig;
+	task: string;
+	status: SubagentStatus;
+	ownerSessionId: string;
+	session: AgentSession | null;
+	turns: number;
+	contextTokens: number;
+	model: string | undefined;
+	error?: string;
+	result?: string;
+	unsubscribe?: () => void;
+}
+
+export interface ActiveAgentSummary {
+	id: string;
+	agentName: string;
+	status: SubagentStatus;
+	turns: number;
+	contextTokens: number;
+	model: string | undefined;
+}
+
+export interface AbortOwnedResult {
+	abortedIds: string[];
+	missingIds: string[];
+	foreignIds: string[];
+}
+
+interface AbortOptions {
+	reason: string;
+}
+
+export interface SpawnContext {
+	model: Model<Api> | undefined;
+	modelRegistry: ModelRegistry;
+	agentDir: string;
+	parentSessionFile?: string;
+	onWarning?: (message: string) => void;
+}
+
+type SettledSubagentStatus = Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">;
+
+const PENDING_MESSAGE_TTL_MS = 86_400_000;
+
+function toBootstrapContext(ctx: SpawnContext): BootstrapContext {
+	return {
+		model: ctx.model,
+		modelRegistry: ctx.modelRegistry,
+		agentDir: ctx.agentDir,
+		parentSessionFile: ctx.parentSessionFile,
+	};
+}
+
+function generateId(name: string, existingIds: Set<string>): string {
+	for (let i = 0; i < 10; i++) {
+		const id = `${name}-${randomBytes(4).toString("hex")}`;
+		if (!existingIds.has(id)) return id;
+	}
+	return `${name}-${randomBytes(8).toString("hex")}`;
+}
+
+function isAbortableStatus(status: SubagentStatus): boolean {
+	return status === "running" || status === "waiting";
+}
+
+function buildActiveAgentSummary(state: SubagentState): ActiveAgentSummary {
+	return {
+		id: state.id,
+		agentName: state.agentConfig.name,
+		status: state.status,
+		turns: state.turns,
+		contextTokens: state.contextTokens,
+		model: state.model,
+	};
+}
+
+/**
+ * Process-global coordinator for subagent state, ownership, delivery, and cleanup.
+ */
+export class CrewRuntime {
+	private readonly agents = new Map<string, SubagentState>();
+	private readonly runner: SubagentRunner;
+	private readonly refreshCallbacks = new Map<string, () => void>();
+	private activeBinding: ActiveRuntimeBinding | undefined;
+	private pendingMessages: PendingMessage[] = [];
+	private flushScheduled = false;
+	private readonly now: () => number;
+	private readonly scheduleFlush: (callback: () => void) => void;
+
+	constructor(opts: {
+		now?: () => number;
+		scheduleFlush?: (callback: () => void) => void;
+		createRunner?: (callbacks: SubagentRunnerCallbacks) => SubagentRunner;
+	} = {}) {
+		this.now = opts.now ?? Date.now;
+		this.scheduleFlush = opts.scheduleFlush ?? ((callback) => setTimeout(callback, 0));
+		const callbacks: SubagentRunnerCallbacks = {
+			isCurrent: (state) => this.agents.get(state.id) === state,
+			onProgress: (ownerSessionId) => this.refreshWidgetFor(ownerSessionId),
+			onSettled: (state, status, outcome) => this.settleAgent(state, status, outcome),
+		};
+		this.runner = opts.createRunner?.(callbacks) ?? new SubagentSessionRunner(callbacks);
+	}
+
+	activateSession(binding: ActiveRuntimeBinding, refreshWidget?: () => void): void {
+		if (refreshWidget) this.refreshCallbacks.set(binding.sessionId, refreshWidget);
+		this.activeBinding = binding;
+		this.schedulePendingFlushFor(binding.sessionId);
+		refreshWidget?.();
+	}
+
+	deactivateSession(sessionId: string): void {
+		if (this.activeBinding?.sessionId === sessionId) this.activeBinding = undefined;
+		this.refreshCallbacks.delete(sessionId);
+	}
+
+	spawn(
+		agentConfig: AgentConfig,
+		task: string,
+		cwd: string,
+		ownerSessionId: string,
+		ctx: SpawnContext,
+		extensionResolvedPath: string,
+	): string {
+		const state = this.createAgent(agentConfig, task, ownerSessionId);
+		this.refreshWidgetFor(ownerSessionId);
+		this.runner.start(state, {
+			cwd,
+			ctx: toBootstrapContext(ctx),
+			extensionResolvedPath,
+			onWarning: ctx.onWarning,
+		});
+		return state.id;
+	}
+
+	respond(id: string, message: string, callerSessionId: string): { error?: string } {
+		const transition = this.startSubagentResponse(id, callerSessionId);
+		if (!transition.ok) return { error: transition.error };
+
+		this.refreshWidgetFor(transition.state.ownerSessionId);
+		this.runner.respond(transition.state, message);
+		return {};
+	}
+
+	done(id: string, callerSessionId: string): { error?: string } {
+		const transition = this.validateSubagentDone(id, callerSessionId);
+		if (!transition.ok) return { error: transition.error };
+
+		this.disposeAgent(transition.state);
+		return {};
+	}
+
+	abort(id: string, opts: AbortOptions): boolean {
+		const state = this.agents.get(id);
+		if (!state || !isAbortableStatus(state.status)) return false;
+
+		this.runner.abort(state);
+		this.settleAgent(state, "aborted", { error: opts.reason });
+		return true;
+	}
+
+	abortOwned(ids: string[], callerSessionId: string, opts: AbortOptions): AbortOwnedResult {
+		const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+		const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
+
+		for (const id of uniqueIds) {
+			const state = this.agents.get(id);
+			if (!state || !isAbortableStatus(state.status)) {
+				result.missingIds.push(id);
+				continue;
+			}
+			if (state.ownerSessionId !== callerSessionId) {
+				result.foreignIds.push(id);
+				continue;
+			}
+			if (this.abort(id, opts)) result.abortedIds.push(id);
+			else result.missingIds.push(id);
+		}
+
+		return result;
+	}
+
+	abortAllOwned(callerSessionId: string, opts: AbortOptions): string[] {
+		const ids = Array.from(this.agents.values())
+			.filter((state) => state.ownerSessionId === callerSessionId && isAbortableStatus(state.status))
+			.map((state) => state.id);
+		for (const id of ids) this.abort(id, opts);
+		return ids;
+	}
+
+	abortAll(): void {
+		const allAgents = Array.from(this.agents.values()).filter((state) => isAbortableStatus(state.status));
+		for (const state of allAgents) this.abort(state.id, { reason: "Aborted during shutdown" });
+	}
+
+	getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[] {
+		return Array.from(this.agents.values())
+			.filter((state) => isAbortableStatus(state.status) && state.ownerSessionId === ownerSessionId)
+			.map(buildActiveAgentSummary);
+	}
+
+	private createAgent(agentConfig: AgentConfig, task: string, ownerSessionId: string): SubagentState {
+		const id = generateId(agentConfig.name, new Set(this.agents.keys()));
+		const state: SubagentState = {
+			id,
+			agentConfig,
+			task,
+			status: "running",
+			ownerSessionId,
+			session: null,
+			turns: 0,
+			contextTokens: 0,
+			model: undefined,
+		};
+		this.agents.set(id, state);
+		return state;
+	}
+
+	private refreshWidgetFor(sessionId: string): void {
+		this.refreshCallbacks.get(sessionId)?.();
+	}
+
+	private settleAgent(state: SubagentState, nextStatus: SettledSubagentStatus, opts: { result?: string; error?: string }): void {
+		if (this.agents.get(state.id) !== state) return;
+
+		state.status = nextStatus;
+		state.result = opts.result;
+		state.error = opts.error;
+
+		this.deliver(state.ownerSessionId, {
+			id: state.id,
+			agentName: state.agentConfig.name,
+			sessionFile: state.session?.sessionFile,
+			status: state.status,
+			result: state.result,
+			error: state.error,
+		});
+
+		if (state.status !== "waiting") this.disposeAgent(state);
+		else this.refreshWidgetFor(state.ownerSessionId);
+	}
+
+	private disposeAgent(state: SubagentState): void {
+		state.unsubscribe?.();
+		state.session?.dispose();
+		this.agents.delete(state.id);
+		this.refreshWidgetFor(state.ownerSessionId);
+	}
+
+	private validateOwnedSubagent(
+		id: string,
+		callerSessionId: string,
+		missingMessage: string,
+	): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const state = this.agents.get(id);
+		if (!state) return { ok: false, error: missingMessage };
+		if (state.ownerSessionId !== callerSessionId) {
+			return { ok: false, error: `Subagent "${id}" belongs to a different session` };
+		}
+		return { ok: true, state };
+	}
+
+	private startSubagentResponse(id: string, callerSessionId: string): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const owned = this.validateOwnedSubagent(id, callerSessionId, `No subagent with id "${id}"`);
+		if (!owned.ok) return owned;
+		if (owned.state.status !== "waiting") {
+			return { ok: false, error: `Subagent "${id}" is not waiting for a response (status: ${owned.state.status})` };
+		}
+		if (!owned.state.session) return { ok: false, error: `Subagent "${id}" has no active session` };
+
+		owned.state.status = "running";
+		return owned;
+	}
+
+	private validateSubagentDone(id: string, callerSessionId: string): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const owned = this.validateOwnedSubagent(id, callerSessionId, `No active subagent with id "${id}"`);
+		if (!owned.ok) return owned;
+		if (owned.state.status !== "waiting") return { ok: false, error: `Subagent "${id}" is not in waiting state` };
+		return owned;
+	}
+
+	private countRunningForOwner(ownerSessionId: string, excludeId: string): number {
+		let count = 0;
+		for (const state of this.agents.values()) {
+			if (state.id !== excludeId && state.ownerSessionId === ownerSessionId && state.status === "running") count++;
+		}
+		return count;
+	}
+
+	private schedulePendingFlushFor(sessionId: string): void {
+		if (!this.pendingMessages.some((entry) => entry.ownerSessionId === sessionId)) return;
+
+		this.flushScheduled = true;
+		this.scheduleFlush(() => {
+			this.flushScheduled = false;
+			this.flushPending();
+		});
+	}
+
+	private deliver(ownerSessionId: string, payload: SteeringPayload): void {
+		if (!this.activeBinding || ownerSessionId !== this.activeBinding.sessionId || this.flushScheduled) {
+			this.queue(ownerSessionId, payload);
+			return;
+		}
+		this.send(ownerSessionId, payload);
+	}
+
+	private queue(ownerSessionId: string, payload: SteeringPayload): void {
+		this.pendingMessages.push({ ownerSessionId, payload, queuedAt: this.now() });
+	}
+
+	private cleanStaleMessages(): void {
+		const cutoff = this.now() - PENDING_MESSAGE_TTL_MS;
+		this.pendingMessages = this.pendingMessages.filter((entry) => entry.queuedAt >= cutoff);
+	}
+
+	private flushPending(): void {
+		if (!this.activeBinding) return;
+		const targetSessionId = this.activeBinding.sessionId;
+		this.cleanStaleMessages();
+
+		const toDeliver: PendingMessage[] = [];
+		const remaining: PendingMessage[] = [];
+		for (const entry of this.pendingMessages) {
+			if (entry.ownerSessionId === targetSessionId) toDeliver.push(entry);
+			else remaining.push(entry);
+		}
+		this.pendingMessages = remaining;
+
+		for (const entry of toDeliver) this.send(entry.ownerSessionId, entry.payload);
+	}
+
+	private send(ownerSessionId: string, payload: SteeringPayload): void {
+		if (!this.activeBinding || this.activeBinding.sessionId !== ownerSessionId) {
+			this.queue(ownerSessionId, payload);
+			return;
+		}
+
+		const remaining = this.countRunningForOwner(ownerSessionId, payload.id);
+		const isIdle = this.activeBinding.isIdle();
+		const triggerResultTurn = payload.status === "waiting" || !(isIdle && remaining > 0);
+
+		sendSteeringMessage(payload, this.activeBinding.sendMessage, { isIdle, triggerTurn: triggerResultTurn });
+	}
+}
+
+const crewRuntimeKey = Symbol.for("pi-crew.runtime");
+const globalWithCrewRuntime = globalThis as typeof globalThis & Record<symbol, CrewRuntime | undefined>;
+
+export const crewRuntime = globalWithCrewRuntime[crewRuntimeKey] ??= new CrewRuntime();

package/extension/index.ts

@@ -1,13 +1,25 @@
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { crewRuntime } from "./runtime/crew-runtime.js";
-import { registerCrewMessageRenderers } from "./integration/register-renderers.js";
-import { registerCrewTools } from "./integration/register-tools.js";
-import { updateWidget } from "./status-widget.js";
+import { crewRuntime, type CrewRuntime } from "./crew.js";
+import { registerCrewTools } from "./tools.js";
+import { registerCrewMessageRenderers, updateWidget } from "./ui.js";
 
 const extensionDir = dirname(fileURLToPath(import.meta.url));
 
+interface ProcessHooks {
+	once(event: "SIGINT", listener: () => void): unknown;
+	on(event: "beforeExit", listener: () => void): unknown;
+	exit(code?: number): never;
+}
+
+interface RegisterPiCrewExtensionOptions {
+	crew?: CrewRuntime;
+	extensionDir?: string;
+	processHooks?: ProcessHooks;
+	processHooksSetupKey?: symbol;
+}
+
 // Process-level cleanup for subagents on exit
 const processHooksSetupKey = Symbol.for("pi-crew.processHooksSetup");
 const globalWithProcessHooks = globalThis as typeof globalThis & Record<
@@ -15,29 +27,30 @@ const globalWithProcessHooks = globalThis as typeof globalThis & Record<
 	boolean | undefined
 >;
 
-function setupProcessHooks() {
-	if (globalWithProcessHooks[processHooksSetupKey]) return;
-	globalWithProcessHooks[processHooksSetupKey] = true;
+function setupProcessHooks(crew: CrewRuntime, processHooks: ProcessHooks, setupKey: symbol) {
+	if (globalWithProcessHooks[setupKey]) return;
+	globalWithProcessHooks[setupKey] = true;
 
-	process.once('SIGINT', () => {
-		crewRuntime.abortAll();
-		process.exit(130);
+	processHooks.once("SIGINT", () => {
+		crew.abortAll();
+		processHooks.exit(130);
 	});
-	process.on('beforeExit', () => crewRuntime.abortAll());
+	processHooks.on("beforeExit", () => crew.abortAll());
 }
 
-export default function (pi: ExtensionAPI) {
+export function registerPiCrewExtension(pi: ExtensionAPI, options: RegisterPiCrewExtensionOptions = {}) {
+	const crew = options.crew ?? crewRuntime;
 	let currentCtx: ExtensionContext | undefined;
 
-	setupProcessHooks();
+	setupProcessHooks(crew, options.processHooks ?? process, options.processHooksSetupKey ?? processHooksSetupKey);
 
 	const refreshWidget = () => {
-		if (currentCtx) updateWidget(currentCtx, crewRuntime);
+		if (currentCtx) updateWidget(currentCtx, crew);
 	};
 
 	const activateSession = (ctx: ExtensionContext) => {
 		currentCtx = ctx;
-		crewRuntime.activateSession(
+		crew.activateSession(
 			{
 				sessionId: ctx.sessionManager.getSessionId(),
 				isIdle: () => ctx.isIdle(),
@@ -53,13 +66,17 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", (event, ctx) => {
 		const sessionId = ctx.sessionManager.getSessionId();
-		crewRuntime.deactivateSession(sessionId);
+		crew.deactivateSession(sessionId);
 
 		if (event.reason === "quit") {
-			crewRuntime.abortAll();
+			crew.abortAll();
 		}
 	});
 
-	registerCrewTools(pi, crewRuntime, extensionDir);
+	registerCrewTools(pi, crew, options.extensionDir ?? extensionDir);
 	registerCrewMessageRenderers(pi);
 }
+
+export default function (pi: ExtensionAPI) {
+	registerPiCrewExtension(pi);
+}