indus-swarms 0.1.0

package/extensions/teams/index.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "indusagi-coding-agent";
+import { runLeader } from "./leader.js";
+import { runWorker } from "./worker.js";
+
+/**
+ * pi-teams
+ *
+ * Two roles in one extension (Claude-style):
+ * - Leader process: spawn teammates, manage task list + mailbox UI/commands
+ * - Worker process: poll mailbox + auto-claim tasks from shared task list
+ */
+
+const IS_WORKER = process.env.PI_TEAMS_WORKER === "1";
+
+export default function (pi: ExtensionAPI) {
+	if (IS_WORKER) runWorker(pi);
+	else runLeader(pi);
+}

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

@@ -0,0 +1,221 @@
+import type { ExtensionCommandContext } from "indusagi-coding-agent";
+import { getTeamDir } from "./paths.js";
+import {
+	acquireTeamAttachClaim,
+	releaseTeamAttachClaim,
+	TEAM_ATTACH_CLAIM_STALE_MS,
+} from "./team-attach-claim.js";
+import { loadTeamConfig } from "./team-config.js";
+import { listDiscoveredTeams } from "./team-discovery.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
+import type { TeamsStyle } from "./teams-style.js";
+
+function formatClaimAge(heartbeatAt?: string): string {
+	if (!heartbeatAt) return "unknown";
+	const heartbeatMs = Date.parse(heartbeatAt);
+	if (!Number.isFinite(heartbeatMs)) return "unknown";
+	const ageMs = Math.max(0, Date.now() - heartbeatMs);
+	const ageSec = Math.floor(ageMs / 1000);
+	return `${ageSec}s`;
+}
+
+export async function handleTeamAttachCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	defaultTeamId: string;
+	teammates: Map<string, TeammateRpc>;
+	getActiveTeamId: () => string;
+	setActiveTeamId: (teamId: string) => void;
+	setStyle: (style: TeamsStyle) => void;
+	setTaskListId: (id: string) => void;
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const {
+		ctx,
+		rest,
+		defaultTeamId,
+		teammates,
+		getActiveTeamId,
+		setActiveTeamId,
+		setStyle,
+		setTaskListId,
+		refreshTasks,
+		renderWidget,
+	} = opts;
+
+	const tokens = rest.map((t) => t.trim()).filter((t) => t.length > 0);
+	const activeTeamId = getActiveTeamId();
+	if (tokens.length === 0 || tokens[0] === "help") {
+		ctx.ui.notify(
+			[
+				"Usage:",
+				"  /team attach list",
+				"  /team attach <teamId> [--claim]",
+				"",
+				`current: ${activeTeamId}${activeTeamId === defaultTeamId ? " (session)" : " (attached)"}`,
+				`session: ${defaultTeamId}`,
+			].join("\n"),
+			"info",
+		);
+		return;
+	}
+
+	if (tokens[0] === "list") {
+		const teams = await listDiscoveredTeams();
+		if (teams.length === 0) {
+			ctx.ui.notify("No existing teams found", "info");
+			return;
+		}
+
+		const lines: string[] = ["Known teams:"];
+		for (const t of teams.slice(0, 30)) {
+			const marks: string[] = [];
+			if (t.teamId === activeTeamId) marks.push("current");
+			if (t.teamId === defaultTeamId) marks.push("session");
+			if (t.attachedBySessionId) {
+				const ownerMark = t.attachedBySessionId === defaultTeamId ? "claimed:you" : `claimed:${t.attachedBySessionId}`;
+				const staleMark = t.attachClaimStale ? "stale" : "live";
+				const age = formatClaimAge(t.attachHeartbeatAt);
+				marks.push(`${ownerMark}:${staleMark}:${age}`);
+			}
+			const mark = marks.length ? ` [${marks.join(",")}]` : "";
+			lines.push(
+				`- ${t.teamId}${mark} · style=${t.style} · workers=${t.onlineWorkerCount}/${t.workerCount} · taskList=${t.taskListId}`,
+			);
+		}
+		if (teams.length > 30) lines.push(`... +${teams.length - 30} more`);
+		ctx.ui.notify(lines.join("\n"), "info");
+		return;
+	}
+
+	const unknownFlags = tokens.filter((t) => t.startsWith("--") && t !== "--claim");
+	if (unknownFlags.length > 0) {
+		ctx.ui.notify(`Unknown attach flag(s): ${unknownFlags.join(", ")}`, "error");
+		return;
+	}
+	const forceClaim = tokens.includes("--claim");
+	const positional = tokens.filter((t) => !t.startsWith("--"));
+	const targetTeamId = positional[0]?.trim() ?? "";
+	if (!targetTeamId || positional.length !== 1) {
+		ctx.ui.notify("Usage: /team attach <teamId> [--claim]", "error");
+		return;
+	}
+	if (targetTeamId === activeTeamId) {
+		ctx.ui.notify(`Already attached to team: ${targetTeamId}`, "info");
+		return;
+	}
+
+	if (teammates.size > 0) {
+		ctx.ui.notify(
+			`Refusing to attach while ${teammates.size} RPC teammate(s) are running. Run /team shutdown first.`,
+			"error",
+		);
+		return;
+	}
+
+	const targetDir = getTeamDir(targetTeamId);
+	const cfg = await loadTeamConfig(targetDir);
+	if (!cfg) {
+		ctx.ui.notify(`Team not found: ${targetTeamId}\nExpected config at: ${targetDir}/config.json`, "error");
+		return;
+	}
+
+	if (process.stdout.isTTY && process.stdin.isTTY) {
+		const ok = await ctx.ui.confirm(
+			"Attach to team",
+			[
+				`Attach this session to team ${cfg.teamId}?`,
+				"",
+				`taskListId: ${cfg.taskListId}`,
+				`style: ${cfg.style ?? "normal"}`,
+				`workers: ${cfg.members.filter((m) => m.role === "worker").length}`,
+				forceClaim ? "mode: force-claim" : "mode: normal claim",
+			].join("\n"),
+		);
+		if (!ok) return;
+	}
+
+	const claimResult = await acquireTeamAttachClaim(targetDir, defaultTeamId, {
+		force: forceClaim,
+		staleMs: TEAM_ATTACH_CLAIM_STALE_MS,
+	});
+	if (!claimResult.ok) {
+		const heldFor = formatClaimAge(claimResult.claim.heartbeatAt);
+		ctx.ui.notify(
+			[
+				`Team ${cfg.teamId} is currently claimed by session ${claimResult.claim.holderSessionId}.`,
+				`last heartbeat: ${heldFor} ago`,
+				"Run '/team attach <teamId> --claim' to force takeover.",
+			].join("\n"),
+			"error",
+		);
+		return;
+	}
+
+	const previouslyAttachedTeamId = activeTeamId !== defaultTeamId ? activeTeamId : null;
+	if (previouslyAttachedTeamId && previouslyAttachedTeamId !== cfg.teamId) {
+		const previousDir = getTeamDir(previouslyAttachedTeamId);
+		await releaseTeamAttachClaim(previousDir, defaultTeamId);
+	}
+
+	setActiveTeamId(cfg.teamId);
+	setTaskListId(cfg.taskListId);
+	setStyle(cfg.style ?? "normal");
+	await refreshTasks();
+	renderWidget();
+
+	const lines: string[] = [
+		`Attached to team: ${cfg.teamId}`,
+		`taskListId: ${cfg.taskListId}`,
+		`style: ${cfg.style ?? "normal"}`,
+	];
+	if (claimResult.replacedClaim && claimResult.replacedClaim.holderSessionId !== defaultTeamId) {
+		lines.push(`claim: took over from ${claimResult.replacedClaim.holderSessionId}`);
+	}
+	ctx.ui.notify(lines.join("\n"), "info");
+}
+
+export async function handleTeamDetachCommand(opts: {
+	ctx: ExtensionCommandContext;
+	defaultTeamId: string;
+	teammates: Map<string, TeammateRpc>;
+	getActiveTeamId: () => string;
+	setActiveTeamId: (teamId: string) => void;
+	setTaskListId: (id: string) => void;
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, defaultTeamId, teammates, getActiveTeamId, setActiveTeamId, setTaskListId, refreshTasks, renderWidget } = opts;
+
+	const activeTeamId = getActiveTeamId();
+	if (activeTeamId === defaultTeamId) {
+		ctx.ui.notify("Already using this session's team", "info");
+		return;
+	}
+	if (teammates.size > 0) {
+		ctx.ui.notify(
+			`Refusing to detach while ${teammates.size} RPC teammate(s) are running. Run /team shutdown first.`,
+			"error",
+		);
+		return;
+	}
+
+	const activeDir = getTeamDir(activeTeamId);
+	const releaseResult = await releaseTeamAttachClaim(activeDir, defaultTeamId);
+
+	setActiveTeamId(defaultTeamId);
+	setTaskListId(defaultTeamId);
+	await refreshTasks();
+	renderWidget();
+
+	if (releaseResult === "not_owner") {
+		ctx.ui.notify(
+			`Detached from external team ${activeTeamId}, but attach claim belonged to another session.`,
+			"warning",
+		);
+		return;
+	}
+
+	ctx.ui.notify(`Detached from external team. Back to session team: ${defaultTeamId}`, "info");
+}

package/extensions/teams/leader-inbox.ts

@@ -0,0 +1,214 @@
+import type { ExtensionContext } from "indusagi-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 { getTask } from "./task-store.js";
+
+import type { TeamsHookInvocation } from "./hooks.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 }>;
+	enqueueHook?: (invocation: TeamsHookInvocation) => void;
+}): Promise<void> {
+	const { ctx, teamId, teamDir, taskListId, leadName, style, pendingPlanApprovals, enqueueHook } = 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)} ${strings.shutdownCompletedVerb}`, "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)} ${strings.shutdownRefusedVerb}: ${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);
+
+			// Hook: always emit "idle" (best-effort, non-blocking)
+			try {
+				enqueueHook?.({
+					event: "idle",
+					teamId,
+					teamDir,
+					taskListId,
+					style,
+					memberName: name,
+					timestamp: idle.timestamp,
+					completedTask: null,
+				});
+			} catch {
+				// ignore hook enqueue errors
+			}
+
+			// Hook: task completion / failure
+			if (idle.completedTaskId) {
+				const completedTask = await getTask(teamDir, taskListId, idle.completedTaskId);
+				try {
+					enqueueHook?.({
+						event: idle.completedStatus === "failed" ? "task_failed" : "task_completed",
+						teamId,
+						teamDir,
+						taskListId,
+						style,
+						memberName: name,
+						timestamp: idle.timestamp,
+						completedTask,
+					});
+				} catch {
+					// ignore hook enqueue errors
+				}
+			}
+
+			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,140 @@
+import type { ExtensionCommandContext } from "indusagi-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;
+	teamId: string;
+	taskListId: string | null;
+	leadName: string;
+	style: TeamsStyle;
+}): Promise<void> {
+	const { ctx, teamId, taskListId, leadName, style } = opts;
+	const sessionTeamId = ctx.sessionManager.getSessionId();
+	const effectiveTlId = taskListId ?? teamId;
+	const teamsRoot = getTeamsRootDir();
+	const teamDir = getTeamDir(teamId);
+
+	ctx.ui.notify(
+		[
+			`teamId: ${teamId}`,
+			...(teamId !== sessionTeamId ? [`sessionTeamId: ${sessionTeamId}`] : []),
+			`taskListId: ${effectiveTlId}`,
+			`leadName: ${leadName}`,
+			`style: ${style}`,
+			`teamsRoot: ${teamsRoot}`,
+			`teamDir: ${teamDir}`,
+		].join("\n"),
+		"info",
+	);
+}
+
+export async function handleTeamEnvCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	taskListId: string | null;
+	leadName: string;
+	style: TeamsStyle;
+	getTeamsExtensionEntryPath: () => string | null;
+	shellQuote: (v: string) => string;
+}): Promise<void> {
+	const { ctx, rest, teamId, 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 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 cliCmd = teamsEntry ? `indusagi --no-extensions -e ${shellQuote(teamsEntry)}` : "indusagi";
+
+	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(` ${cliCmd}`);
+
+	ctx.ui.notify(
+		[
+			`teamId: ${teamId}`,
+			`taskListId: ${effectiveTlId}`,
+			`leadName: ${leadName}`,
+			`teamsRoot: ${teamsRoot}`,
+			`teamDir: ${teamDir}`,
+			"",
+			"Env (copy/paste):",
+			exportLines,
+			"",
+			"Run:",
+			oneLiner,
+		].join("\n"),
+		"info",
+	);
+}