@tmustier/pi-agent-teams 0.1.2 → 0.3.0

package/extensions/teams/activity-tracker.ts

@@ -0,0 +1,234 @@
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+
+// ── Transcript types ──
+
+export type TranscriptEntry =
+	| { kind: "text"; text: string; timestamp: number }
+	| { kind: "tool_start"; toolName: string; timestamp: number }
+	| { kind: "tool_end"; toolName: string; durationMs: number; timestamp: number }
+	| { kind: "turn_end"; turnNumber: number; tokens: number; timestamp: number };
+
+const MAX_TRANSCRIPT = 200;
+
+export class TranscriptLog {
+	private entries: TranscriptEntry[] = [];
+
+	push(entry: TranscriptEntry): void {
+		this.entries.push(entry);
+		if (this.entries.length > MAX_TRANSCRIPT) {
+			this.entries.splice(0, this.entries.length - MAX_TRANSCRIPT);
+		}
+	}
+
+	getEntries(): readonly TranscriptEntry[] {
+		return this.entries;
+	}
+
+	get length(): number {
+		return this.entries.length;
+	}
+
+	reset(): void {
+		this.entries = [];
+	}
+}
+
+export class TranscriptTracker {
+	private logs = new Map<string, TranscriptLog>();
+	private toolStarts = new Map<string, Map<string, number>>(); // name -> toolCallId -> startTimestamp
+	private pendingText = new Map<string, string>(); // name -> accumulated text
+	private turnCounts = new Map<string, number>();
+	private lastTokens = new Map<string, number>(); // name -> tokens from last message_end
+
+	handleEvent(name: string, ev: AgentEvent): void {
+		const log = this.getOrCreate(name);
+		const now = Date.now();
+
+		if (ev.type === "message_update") {
+			const ame = ev.assistantMessageEvent;
+			if (ame.type === "text_delta") {
+				const cur = this.pendingText.get(name) ?? "";
+				this.pendingText.set(name, cur + ame.delta);
+				// Flush complete lines
+				this.flushText(name, log, now, false);
+			}
+			return;
+		}
+
+		if (ev.type === "tool_execution_start") {
+			// Flush any pending text before a tool starts
+			this.flushText(name, log, now, true);
+			const starts = this.toolStarts.get(name) ?? new Map<string, number>();
+			starts.set(ev.toolCallId, now);
+			this.toolStarts.set(name, starts);
+			log.push({ kind: "tool_start", toolName: ev.toolName, timestamp: now });
+			return;
+		}
+
+		if (ev.type === "tool_execution_end") {
+			const starts = this.toolStarts.get(name);
+			const startTs = starts?.get(ev.toolCallId);
+			const durationMs = startTs === undefined ? 0 : now - startTs;
+			starts?.delete(ev.toolCallId);
+			log.push({ kind: "tool_end", toolName: ev.toolName, durationMs, timestamp: now });
+			return;
+		}
+
+		if (ev.type === "message_end") {
+			// Capture tokens for use in the turn_end entry
+			const msg: unknown = ev.message;
+			if (isRecord(msg)) {
+				const usage = msg.usage;
+				if (isRecord(usage) && typeof usage.totalTokens === "number") {
+					this.lastTokens.set(name, (this.lastTokens.get(name) ?? 0) + usage.totalTokens);
+				}
+			}
+			return;
+		}
+
+		if (ev.type === "agent_end") {
+			// Flush remaining text
+			this.flushText(name, log, now, true);
+			const turn = (this.turnCounts.get(name) ?? 0) + 1;
+			this.turnCounts.set(name, turn);
+			const tokens = this.lastTokens.get(name) ?? 0;
+			log.push({ kind: "turn_end", turnNumber: turn, tokens, timestamp: now });
+			this.lastTokens.set(name, 0);
+			return;
+		}
+	}
+
+	get(name: string): TranscriptLog {
+		return this.logs.get(name) ?? new TranscriptLog();
+	}
+
+	reset(name: string): void {
+		this.logs.delete(name);
+		this.toolStarts.delete(name);
+		this.pendingText.delete(name);
+		this.turnCounts.delete(name);
+		this.lastTokens.delete(name);
+	}
+
+	private getOrCreate(name: string): TranscriptLog {
+		const existing = this.logs.get(name);
+		if (existing) return existing;
+		const created = new TranscriptLog();
+		this.logs.set(name, created);
+		return created;
+	}
+
+	private flushText(name: string, log: TranscriptLog, timestamp: number, force: boolean): void {
+		const buf = this.pendingText.get(name);
+		if (!buf) return;
+
+		// Split into lines; keep the last incomplete line unless forced
+		const parts = buf.split("\n");
+		if (force) {
+			// Flush everything
+			for (const part of parts) {
+				const trimmed = part.trimEnd();
+				if (trimmed) log.push({ kind: "text", text: trimmed, timestamp });
+			}
+			this.pendingText.delete(name);
+		} else if (parts.length > 1) {
+			// Flush all complete lines, keep the last (potentially incomplete) part
+			for (let i = 0; i < parts.length - 1; i++) {
+				const part = parts[i];
+				if (part === undefined) continue;
+				const trimmed = part.trimEnd();
+				if (trimmed) log.push({ kind: "text", text: trimmed, timestamp });
+			}
+			this.pendingText.set(name, parts[parts.length - 1] ?? "");
+		}
+	}
+}
+
+// ── Activity types ──
+
+type TrackedEventType = "tool_execution_start" | "tool_execution_end" | "agent_end" | "message_end";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+	return typeof v === "object" && v !== null;
+}
+
+export interface TeammateActivity {
+	toolUseCount: number;
+	currentToolName: string | null;
+	lastToolName: string | null;
+	turnCount: number;
+	totalTokens: number;
+	recentEvents: Array<{ type: TrackedEventType; toolName?: string; timestamp: number }>;
+}
+
+const MAX_RECENT = 10;
+
+function emptyActivity(): TeammateActivity {
+	return {
+		toolUseCount: 0,
+		currentToolName: null,
+		lastToolName: null,
+		turnCount: 0,
+		totalTokens: 0,
+		recentEvents: [],
+	};
+}
+
+export class ActivityTracker {
+	private data = new Map<string, TeammateActivity>();
+
+	handleEvent(name: string, ev: AgentEvent): void {
+		const a = this.getOrCreate(name);
+		const now = Date.now();
+
+		if (ev.type === "tool_execution_start") {
+			a.currentToolName = ev.toolName;
+			a.recentEvents.push({ type: ev.type, toolName: ev.toolName, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "tool_execution_end") {
+			const toolName = a.currentToolName ?? ev.toolName;
+			a.toolUseCount++;
+			a.lastToolName = toolName;
+			a.currentToolName = null;
+			a.recentEvents.push({ type: ev.type, toolName, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "agent_end") {
+			a.turnCount++;
+			a.recentEvents.push({ type: ev.type, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "message_end") {
+			const msg: unknown = ev.message;
+			if (!isRecord(msg)) return;
+			const usage = msg.usage;
+			if (!isRecord(usage)) return;
+			const totalTokens = usage.totalTokens;
+			if (typeof totalTokens === "number") a.totalTokens += totalTokens;
+		}
+	}
+
+	get(name: string): TeammateActivity {
+		return this.data.get(name) ?? emptyActivity();
+	}
+
+	reset(name: string): void {
+		this.data.delete(name);
+	}
+
+	private getOrCreate(name: string): TeammateActivity {
+		const existing = this.data.get(name);
+		if (existing) return existing;
+
+		const created = emptyActivity();
+		this.data.set(name, created);
+		return created;
+	}
+}

package/extensions/teams/fs-lock.ts

@@ -4,6 +4,10 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
+function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
+	return typeof err === "object" && err !== null && "code" in err;
+}
+
 export interface LockOptions {
 	/** How long to wait to acquire the lock before failing. */
 	timeoutMs?: number;
@@ -18,10 +22,12 @@ export interface LockOptions {
 export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, opts: LockOptions = {}): Promise<T> {
 	const timeoutMs = opts.timeoutMs ?? 10_000;
 	const staleMs = opts.staleMs ?? 60_000;
-	const pollMs = opts.pollMs ?? 50;
+	const basePollMs = opts.pollMs ?? 50;
+	const maxPollMs = Math.max(basePollMs, 1_000);
 	const start = Date.now();
 
 	let fd: number | null = null;
+	let attempt = 0;
 
 	while (fd === null) {
 		try {
@@ -32,8 +38,8 @@ export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, op
 				label: opts.label,
 			};
 			fs.writeFileSync(fd, JSON.stringify(payload));
-		} catch (err: any) {
-			if (err?.code !== "EEXIST") throw err;
+		} catch (err: unknown) {
+			if (!isErrnoException(err) || err.code !== "EEXIST") throw err;
 
 			// Stale lock handling
 			try {
@@ -41,16 +47,26 @@ export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, op
 				const age = Date.now() - st.mtimeMs;
 				if (age > staleMs) {
 					fs.unlinkSync(lockFilePath);
+					attempt = 0;
 					continue;
 				}
 			} catch {
 				// ignore: stat/unlink failures fall through to wait
 			}
 
-			if (Date.now() - start > timeoutMs) {
+			const elapsedMs = Date.now() - start;
+			if (elapsedMs > timeoutMs) {
 				throw new Error(`Timeout acquiring lock: ${lockFilePath}`);
 			}
-			await sleep(pollMs);
+
+			attempt += 1;
+			const expBackoff = Math.min(maxPollMs, basePollMs * 2 ** Math.min(attempt, 6));
+			const jitterFactor = 0.5 + Math.random(); // [0.5, 1.5)
+			const jitteredBackoff = Math.min(maxPollMs, Math.round(expBackoff * jitterFactor));
+
+			const remainingMs = timeoutMs - elapsedMs;
+			const sleepMs = Math.max(1, Math.min(remainingMs, jitteredBackoff));
+			await sleep(sleepMs);
 		}
 	}
 

package/extensions/teams/leader-inbox.ts

@@ -0,0 +1,175 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { popUnreadMessages, writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import {
+	TEAM_MAILBOX_NS,
+	isIdleNotification,
+	isPeerDmSent,
+	isPlanApprovalRequest,
+	isShutdownApproved,
+	isShutdownRejected,
+} from "./protocol.js";
+import { ensureTeamConfig, setMemberStatus, upsertMember } from "./team-config.js";
+
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+
+export async function pollLeaderInbox(opts: {
+	ctx: ExtensionContext;
+	teamId: string;
+	teamDir: string;
+	taskListId: string;
+	leadName: string;
+	style: TeamsStyle;
+	pendingPlanApprovals: Map<string, { requestId: string; name: string; taskId?: string }>;
+}): Promise<void> {
+	const { ctx, teamId, teamDir, taskListId, leadName, style, pendingPlanApprovals } = opts;
+	const strings = getTeamsStrings(style);
+
+	let msgs: Awaited<ReturnType<typeof popUnreadMessages>>;
+	try {
+		msgs = await popUnreadMessages(teamDir, TEAM_MAILBOX_NS, leadName);
+	} catch (err: unknown) {
+		ctx.ui.notify(err instanceof Error ? err.message : String(err), "warning");
+		return;
+	}
+	if (!msgs.length) return;
+
+	for (const m of msgs) {
+		const approved = isShutdownApproved(m.text);
+		if (approved) {
+			const name = sanitizeName(approved.from);
+			const cfg = await ensureTeamConfig(teamDir, {
+				teamId,
+				taskListId,
+				leadName,
+				style,
+			});
+			if (!cfg.members.some((mm) => mm.name === name)) {
+				await upsertMember(teamDir, { name, role: "worker", status: "offline" });
+			}
+			await setMemberStatus(teamDir, name, "offline", {
+				lastSeenAt: approved.timestamp,
+				meta: {
+					shutdownApprovedRequestId: approved.requestId,
+					shutdownApprovedAt: approved.timestamp ?? new Date().toISOString(),
+				},
+			});
+			ctx.ui.notify(`${formatMemberDisplayName(style, name)} shut down`, "info");
+			continue;
+		}
+
+		const rejected = isShutdownRejected(m.text);
+		if (rejected) {
+			const name = sanitizeName(rejected.from);
+			await setMemberStatus(teamDir, name, "online", {
+				lastSeenAt: rejected.timestamp,
+				meta: {
+					shutdownRejectedAt: rejected.timestamp ?? new Date().toISOString(),
+					shutdownRejectedReason: rejected.reason,
+				},
+			});
+			ctx.ui.notify(`${formatMemberDisplayName(style, name)} refused shutdown: ${rejected.reason}`, "warning");
+			continue;
+		}
+
+		const planReq = isPlanApprovalRequest(m.text);
+		if (planReq) {
+			const name = sanitizeName(planReq.from);
+			const preview = planReq.plan.length > 500 ? planReq.plan.slice(0, 500) + "..." : planReq.plan;
+			ctx.ui.notify(`${formatMemberDisplayName(style, name)} requests plan approval:\n${preview}`, "info");
+			pendingPlanApprovals.set(name, {
+				requestId: planReq.requestId,
+				name,
+				taskId: planReq.taskId,
+			});
+			continue;
+		}
+
+		const peerDm = isPeerDmSent(m.text);
+		if (peerDm) {
+			ctx.ui.notify(`${peerDm.from} → ${peerDm.to}: ${peerDm.summary}`, "info");
+			continue;
+		}
+
+		const idle = isIdleNotification(m.text);
+		if (idle) {
+			const name = sanitizeName(idle.from);
+			if (idle.failureReason) {
+				const cfg = await ensureTeamConfig(teamDir, {
+					teamId,
+					taskListId,
+					leadName,
+					style,
+				});
+				if (!cfg.members.some((mm) => mm.name === name)) {
+					await upsertMember(teamDir, { name, role: "worker", status: "offline" });
+				}
+				await setMemberStatus(teamDir, name, "offline", {
+					lastSeenAt: idle.timestamp,
+					meta: { offlineReason: idle.failureReason },
+				});
+				ctx.ui.notify(`${name} went offline (${idle.failureReason})`, "warning");
+			} else {
+				const desiredSessionName = `pi agent teams - ${strings.memberTitle.toLowerCase()} ${name}`;
+
+				const cfg = await ensureTeamConfig(teamDir, {
+					teamId,
+					taskListId,
+					leadName,
+					style,
+				});
+
+				const member = cfg.members.find((mm) => mm.name === name);
+				const existingSessionNameRaw = member?.meta?.["sessionName"];
+				const existingSessionName = typeof existingSessionNameRaw === "string" ? existingSessionNameRaw : undefined;
+				const shouldSendName = existingSessionName !== desiredSessionName;
+
+				if (!member) {
+					// Manual tmux worker: learn from idle notifications.
+					await upsertMember(teamDir, {
+						name,
+						role: "worker",
+						status: "online",
+						lastSeenAt: idle.timestamp,
+						meta: { sessionName: desiredSessionName },
+					});
+				} else {
+					await setMemberStatus(teamDir, name, "online", {
+						lastSeenAt: idle.timestamp,
+						meta: { sessionName: desiredSessionName },
+					});
+				}
+
+				if (shouldSendName) {
+					try {
+						const ts = new Date().toISOString();
+						await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+							from: leadName,
+							text: JSON.stringify({
+								type: "set_session_name",
+								name: desiredSessionName,
+								from: leadName,
+								timestamp: ts,
+							}),
+							timestamp: ts,
+						});
+					} catch {
+						// ignore
+					}
+				}
+
+				if (idle.completedTaskId && idle.completedStatus === "failed") {
+					ctx.ui.notify(`${name} aborted task #${idle.completedTaskId}`, "warning");
+				} else if (idle.completedTaskId) {
+					ctx.ui.notify(`${name} is idle task #${idle.completedTaskId}`, "info");
+				} else {
+					ctx.ui.notify(`${name} is idle`, "info");
+				}
+			}
+			continue;
+		}
+
+		ctx.ui.notify(`Message from ${m.from}: ${m.text}`, "info");
+	}
+}

package/extensions/teams/leader-info-commands.ts

@@ -0,0 +1,139 @@
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { sanitizeName } from "./names.js";
+import { getTeamDir, getTeamsRootDir } from "./paths.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
+import type { TeamConfig, TeamMember } from "./team-config.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+
+export async function handleTeamListCommand(opts: {
+	ctx: ExtensionCommandContext;
+	teammates: Map<string, TeammateRpc>;
+	getTeamConfig: () => TeamConfig | null;
+	style: TeamsStyle;
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, teammates, getTeamConfig, style, refreshTasks, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+
+	await refreshTasks();
+
+	const teamConfig = getTeamConfig();
+	const cfgWorkers = (teamConfig?.members ?? []).filter((m) => m.role === "worker");
+	const cfgByName = new Map<string, TeamMember>();
+	for (const m of cfgWorkers) cfgByName.set(m.name, m);
+
+	const names = new Set<string>();
+	for (const name of teammates.keys()) names.add(name);
+	for (const name of cfgByName.keys()) names.add(name);
+
+	if (names.size === 0) {
+		ctx.ui.notify(`No ${strings.memberTitle.toLowerCase()}s`, "info");
+		renderWidget();
+		return;
+	}
+
+	const lines: string[] = [];
+	for (const name of Array.from(names).sort()) {
+		const rpc = teammates.get(name);
+		const cfg = cfgByName.get(name);
+		const status = rpc ? rpc.status : cfg?.status ?? "offline";
+		const kind = rpc ? "rpc" : cfg ? "manual" : "unknown";
+		lines.push(`${formatMemberDisplayName(style, name)}: ${status} (${kind})`);
+	}
+
+	ctx.ui.notify(lines.join("\n"), "info");
+	renderWidget();
+}
+
+export async function handleTeamIdCommand(opts: {
+	ctx: ExtensionCommandContext;
+	taskListId: string | null;
+	leadName: string;
+	style: TeamsStyle;
+}): Promise<void> {
+	const { ctx, taskListId, leadName, style } = opts;
+
+	const teamId = ctx.sessionManager.getSessionId();
+	const effectiveTlId = taskListId ?? teamId;
+	const teamsRoot = getTeamsRootDir();
+	const teamDir = getTeamDir(teamId);
+
+	ctx.ui.notify(
+		[
+			`teamId: ${teamId}`,
+			`taskListId: ${effectiveTlId}`,
+			`leadName: ${leadName}`,
+			`style: ${style}`,
+			`teamsRoot: ${teamsRoot}`,
+			`teamDir: ${teamDir}`,
+		].join("\n"),
+		"info",
+	);
+}
+
+export async function handleTeamEnvCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	taskListId: string | null;
+	leadName: string;
+	style: TeamsStyle;
+	getTeamsExtensionEntryPath: () => string | null;
+	shellQuote: (v: string) => string;
+}): Promise<void> {
+	const { ctx, rest, taskListId, leadName, style, getTeamsExtensionEntryPath, shellQuote } = opts;
+
+	const nameRaw = rest[0];
+	if (!nameRaw) {
+		ctx.ui.notify("Usage: /team env <name>", "error");
+		return;
+	}
+
+	const name = sanitizeName(nameRaw);
+	const teamId = ctx.sessionManager.getSessionId();
+	const effectiveTlId = taskListId ?? teamId;
+	const teamsRoot = getTeamsRootDir();
+	const teamDir = getTeamDir(teamId);
+	const autoClaim = (process.env.PI_TEAMS_DEFAULT_AUTO_CLAIM ?? "1") === "1" ? "1" : "0";
+
+	const teamsEntry = getTeamsExtensionEntryPath();
+	const piCmd = teamsEntry ? `pi --no-extensions -e ${shellQuote(teamsEntry)}` : "pi";
+
+	const env: Record<string, string> = {
+		PI_TEAMS_ROOT_DIR: teamsRoot,
+		PI_TEAMS_WORKER: "1",
+		PI_TEAMS_TEAM_ID: teamId,
+		PI_TEAMS_TASK_LIST_ID: effectiveTlId,
+		PI_TEAMS_AGENT_NAME: name,
+		PI_TEAMS_LEAD_NAME: leadName,
+		PI_TEAMS_STYLE: style,
+		PI_TEAMS_AUTO_CLAIM: autoClaim,
+	};
+
+	const exportLines = Object.entries(env)
+		.map(([k, v]) => `export ${k}=${shellQuote(v)}`)
+		.join("\n");
+
+	const oneLiner = Object.entries(env)
+		.map(([k, v]) => `${k}=${shellQuote(v)}`)
+		.join(" ")
+		.concat(` ${piCmd}`);
+
+	ctx.ui.notify(
+		[
+			`teamId: ${teamId}`,
+			`taskListId: ${effectiveTlId}`,
+			`leadName: ${leadName}`,
+			`teamsRoot: ${teamsRoot}`,
+			`teamDir: ${teamDir}`,
+			"",
+			"Env (copy/paste):",
+			exportLines,
+			"",
+			"Run:",
+			oneLiner,
+		].join("\n"),
+		"info",
+	);
+}