indus-swarms 0.1.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "indus-swarms",
+  "version": "0.1.0",
+  "description": "Claude Code agent teams style workflow for Pi.",
+  "license": "MIT",
+  "author": "Varun Israni",
+  "private": false,
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "indus",
+    "agent",
+    "teams",
+    "indus-swarms"
+  ],
+
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "scripts": {
+    "lint": "eslint 'extensions/**/*.ts' 'scripts/**/*.ts' 'scripts/**/*.mts'",
+    "typecheck": "tsc -p tsconfig.strict.json",
+    "check": "npm run typecheck && npm run lint",
+    "smoke-test": "tsx scripts/smoke-test.mts",
+    "integration-claim-test": "tsx scripts/integration-claim-test.mts",
+    "integration-spawn-overrides-test": "tsx scripts/integration-spawn-overrides-test.mts",
+    "integration-hooks-remediation-test": "tsx scripts/integration-hooks-remediation-test.mts",
+    "integration-todo-test": "tsx scripts/integration-todo-test.mts"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "indusagi": "^0.12.7",
+    "indusagi-coding-agent": "^0.1.23",
+    "@sinclair/typebox": "^0.34.48",
+    "eslint": "^9.39.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0"
+  },
+  "peerDependencies": {
+    "indusagi": "*",
+    "indusagi-coding-agent": "*",
+    "@sinclair/typebox": "*"
+  }
+}

package/scripts/e2e-rpc-test.mjs

@@ -0,0 +1,277 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
+
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+async function waitFor(fn, { timeoutMs = 120_000, pollMs = 200, label = "condition" } = {}) {
+	const start = Date.now();
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		if (await fn()) return;
+		if (Date.now() - start > timeoutMs) throw new Error(`Timeout waiting for ${label}`);
+		await sleep(pollMs);
+	}
+}
+
+function safeJsonParse(line) {
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+}
+
+function mkTempTeamsRootDir() {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-teams-root-"));
+	return dir;
+}
+
+async function run() {
+	const repoRoot = process.cwd();
+	const extensionPath = path.join(repoRoot, "extensions/teams/index.ts");
+	if (!fs.existsSync(extensionPath)) throw new Error(`Extension not found: ${extensionPath}`);
+
+	const teamsRootDir = mkTempTeamsRootDir();
+	console.log("teamsRootDir:", teamsRootDir);
+
+	const env = {
+		...process.env,
+		// Keep the real PI agent dir for credentials/settings, but isolate Teams artifacts.
+		PI_TEAMS_ROOT_DIR: teamsRootDir,
+		// Ensure the leader runs in leader mode even when this script is executed from inside a worker.
+		PI_TEAMS_WORKER: "0",
+		PI_TEAMS_TEAM_ID: "",
+		PI_TEAMS_AGENT_NAME: "",
+		PI_TEAMS_TASK_LIST_ID: "",
+		PI_TEAMS_LEAD_NAME: "",
+		PI_TEAMS_AUTO_CLAIM: "",
+	};
+
+	const args = [
+		"--mode",
+		"rpc",
+		"--no-session",
+		"--no-tools",
+		"--provider",
+		"openai-codex",
+		"--model",
+		"gpt-5.1-codex-mini",
+		"--thinking",
+		"minimal",
+		"--no-extensions",
+		"-e",
+		extensionPath,
+	];
+
+	const proc = spawn("indusagi", args, { env, stdio: ["pipe", "pipe", "pipe"] });
+
+	let stderr = "";
+	proc.stderr.on("data", (d) => {
+		stderr += d.toString();
+	});
+
+	const pending = new Map();
+	let nextId = 1;
+
+	const rl = readline.createInterface({ input: proc.stdout, crlfDelay: Infinity });
+	let leaderSessionId = null;
+
+	rl.on("line", (line) => {
+		const obj = safeJsonParse(line);
+		if (!obj) return;
+
+		if (obj.type === "response") {
+			if (obj.id && pending.has(obj.id)) {
+				pending.get(obj.id).resolve(obj);
+				pending.delete(obj.id);
+			}
+			return;
+		}
+
+		if (obj.type === "extension_ui_request") {
+			// Useful visibility in CI/logs
+			if (obj.method === "notify") {
+				console.log(`[notify:${obj.notifyType ?? "info"}] ${obj.message}`);
+			}
+			return;
+		}
+
+		// Other agent events can be noisy; keep minimal.
+		if (obj.type === "extension_error") {
+			console.log(`[extension_error] ${obj.error}`);
+		}
+	});
+
+	const send = (command) => {
+		const id = command.id ?? `req-${nextId++}`;
+		const full = { ...command, id };
+		proc.stdin.write(JSON.stringify(full) + "\n");
+		return new Promise((resolve, reject) => {
+			pending.set(id, { resolve, reject });
+			setTimeout(() => {
+				if (!pending.has(id)) return;
+				pending.delete(id);
+				reject(new Error(`Timeout waiting for response: ${id} (${full.type})`));
+			}, 30_000);
+		});
+	};
+
+	try {
+		// ---------------------------------------------------------------------
+		// Get session id (used as teamId/taskListId)
+		// ---------------------------------------------------------------------
+		const stateResp = await send({ type: "get_state" });
+		leaderSessionId = stateResp.data?.sessionId;
+		if (!leaderSessionId) throw new Error(`No sessionId in get_state response: ${JSON.stringify(stateResp)}`);
+		console.log("leaderSessionId:", leaderSessionId);
+
+		let teamDir;
+		let cfgPath;
+
+		// ---------------------------------------------------------------------
+		// Spawn worker
+		// ---------------------------------------------------------------------
+		await send({ type: "prompt", message: "/team spawn alice fresh" });
+
+		// Discover the teamId directory (leader uses its sessionId as teamId, but RPC get_state may differ).
+		await waitFor(
+			() => {
+				try {
+					const dirs = fs
+						.readdirSync(teamsRootDir, { withFileTypes: true })
+						.filter((e) => e.isDirectory())
+						.map((e) => e.name);
+					return dirs.some((d) => fs.existsSync(path.join(teamsRootDir, d, "config.json")));
+				} catch {
+					return false;
+				}
+			},
+			{ label: "team config created" },
+		);
+
+		const teamDirs = fs
+			.readdirSync(teamsRootDir, { withFileTypes: true })
+			.filter((e) => e.isDirectory())
+			.map((e) => e.name);
+
+		const teamIdDir =
+			teamDirs.find((d) => fs.existsSync(path.join(teamsRootDir, d, "config.json"))) ?? teamDirs.sort()[0];
+
+		teamDir = path.join(teamsRootDir, teamIdDir);
+		cfgPath = path.join(teamDir, "config.json");
+
+		await waitFor(
+			async () => {
+				try {
+					const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+					return Array.isArray(cfg.members) && cfg.members.some((m) => m.name === "alice" && m.status === "online");
+				} catch {
+					return false;
+				}
+			},
+			{ label: "team config member alice online" },
+		);
+		console.log("OK: alice online in config.json");
+
+		// ---------------------------------------------------------------------
+		// Teammate session naming (leader-driven)
+		// ---------------------------------------------------------------------
+		await waitFor(
+			async () => {
+				try {
+					const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+					const alice = cfg.members?.find((m) => m.name === "alice");
+					return alice?.meta?.sessionName === "pi agent teams - comrade alice";
+				} catch {
+					return false;
+				}
+			},
+			{ label: "alice sessionName recorded in config" },
+		);
+		console.log("OK: alice sessionName recorded in config");
+
+		// ---------------------------------------------------------------------
+		// Graceful teammate shutdown (mailbox handshake)
+		// ---------------------------------------------------------------------
+		await send({ type: "prompt", message: "/team shutdown alice e2e" });
+
+		await waitFor(
+			async () => {
+				try {
+					const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+					return Array.isArray(cfg.members) && cfg.members.some((m) => m.name === "alice" && m.status === "offline");
+				} catch {
+					return false;
+				}
+			},
+			{ label: "alice offline after /team shutdown alice", timeoutMs: 60_000, pollMs: 500 },
+		);
+		console.log("OK: alice offline after /team shutdown alice");
+
+		// ---------------------------------------------------------------------
+		// Shutdown
+		// ---------------------------------------------------------------------
+		await send({ type: "prompt", message: "/team shutdown" });
+
+		// RPC mode nuance: prompt is fire-and-forget. Extension commands run async,
+		// but rpc-mode only checks the shutdownRequested flag after handling *another*
+		// input line. Keep sending cheap commands until the process exits.
+		const kickTimer = setInterval(() => {
+			try {
+				proc.stdin.write(JSON.stringify({ type: "get_state", id: `kick-${Date.now()}` }) + "\n");
+			} catch {
+				// ignore
+			}
+		}, 250);
+
+		await new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				reject(new Error(`Timeout waiting for pi to exit. stderr=${stderr}`));
+			}, 30_000);
+
+			proc.on("close", (code) => {
+				clearInterval(kickTimer);
+				clearTimeout(timeout);
+				if (code === 0) resolve();
+				else reject(new Error(`pi exited with code ${code}. stderr=${stderr}`));
+			});
+		});
+
+		// Verify alice offline after shutdown
+		try {
+			const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+			const alice = cfg.members?.find((m) => m.name === "alice");
+			if (alice) console.log("alice final status:", alice.status);
+		} catch {
+			// ignore
+		}
+
+		console.log("OK: e2e rpc test passed");
+	} finally {
+		try {
+			rl.close();
+		} catch {
+			// ignore
+		}
+		try {
+			proc.kill("SIGTERM");
+		} catch {
+			// ignore
+		}
+		try {
+			fs.rmSync(teamsRootDir, { recursive: true, force: true });
+		} catch {
+			// ignore
+		}
+	}
+}
+
+run().catch((e) => {
+	console.error(e);
+	process.exit(1);
+});

package/scripts/integration-claim-test.mts

@@ -0,0 +1,157 @@
+/**
+ * Integration test: spawn N real Pi worker processes (PI_TEAMS_WORKER=1) and
+ * verify that unassigned tasks are auto-claimed + completed.
+ *
+ * This is intentionally "dumb": tasks are trivial and should complete quickly.
+ * It exists to validate the end-to-end loop (task-store -> claim -> agent_end -> completeTask).
+ *
+ * Usage:
+ *   npx tsx scripts/integration-claim-test.mts
+ *   npx tsx scripts/integration-claim-test.mts --agents 2 --tasks 3 --timeoutSec 90
+ */
+
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import type { ChildProcess } from "node:child_process";
+
+import { ensureTeamConfig } from "../extensions/teams/team-config.js";
+import { getTeamDir } from "../extensions/teams/paths.js";
+import { createTask, listTasks, type TeamTask } from "../extensions/teams/task-store.js";
+
+import { sleep, spawnTeamsWorkerRpc, terminateAll } from "./lib/pi-workers.js";
+
+function parseArgs(argv: readonly string[]): { agents: number; tasks: number; timeoutSec: number } {
+	let agents = 2;
+	let tasks = 3;
+	let timeoutSec = 60;
+
+	for (let i = 0; i < argv.length; i += 1) {
+		const a = argv[i];
+		if (a === "--agents") {
+			const v = argv[i + 1];
+			if (v) agents = Number.parseInt(v, 10);
+			i += 1;
+			continue;
+		}
+		if (a === "--tasks") {
+			const v = argv[i + 1];
+			if (v) tasks = Number.parseInt(v, 10);
+			i += 1;
+			continue;
+		}
+		if (a === "--timeoutSec") {
+			const v = argv[i + 1];
+			if (v) timeoutSec = Number.parseInt(v, 10);
+			i += 1;
+			continue;
+		}
+	}
+
+	if (!Number.isFinite(agents) || agents < 1) agents = 2;
+	if (!Number.isFinite(tasks) || tasks < 1) tasks = 3;
+	if (!Number.isFinite(timeoutSec) || timeoutSec < 10) timeoutSec = 60;
+
+	return { agents, tasks, timeoutSec };
+}
+
+function allCompleted(ts: TeamTask[]): boolean {
+	return ts.length > 0 && ts.every((t) => t.status === "completed");
+}
+
+const { agents, tasks, timeoutSec } = parseArgs(process.argv.slice(2));
+
+if (agents < 2 || tasks < 3) {
+	console.error("This test expects at least --agents 2 and --tasks 3.");
+	process.exit(2);
+}
+
+const teamId = randomUUID();
+const teamDir = getTeamDir(teamId);
+const sessionsDir = path.join(os.homedir(), ".pi", "agent", "teams", teamId, "sessions");
+const logsDir = path.join(os.homedir(), ".pi", "agent", "teams", teamId, "logs");
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptDir, "..");
+const entryPath = path.join(repoRoot, "extensions", "teams", "index.ts");
+
+const systemAppend = [
+	"You are a teammate in an automated integration test.",
+	"Keep replies extremely short.",
+	"If you are assigned or auto-claim a task that says 'Reply with: okX', respond with exactly 'okX' and nothing else.",
+].join(" ");
+
+console.log(`TeamId: ${teamId}`);
+console.log(`TeamDir: ${teamDir}`);
+console.log(`Spawning ${agents} worker(s), creating ${tasks} task(s)`);
+
+await ensureTeamConfig(teamDir, { teamId, taskListId: teamId, leadName: "team-lead", style: "normal" });
+
+// Create unowned tasks so at least one must be auto-claimed.
+for (let i = 1; i <= tasks; i += 1) {
+	await createTask(teamDir, teamId, {
+		subject: `T${i}: reply ok${i}`,
+		description: `Reply with: ok${i}`,
+	});
+}
+
+const children: ChildProcess[] = [];
+let cleaningUp = false;
+const cleanup = async (): Promise<void> => {
+	if (cleaningUp) return;
+	cleaningUp = true;
+	await terminateAll(children);
+};
+
+process.on("SIGINT", () => {
+	void cleanup().finally(() => process.exit(130));
+});
+process.on("SIGTERM", () => {
+	void cleanup().finally(() => process.exit(143));
+});
+
+try {
+	for (let i = 1; i <= agents; i += 1) {
+		children.push(
+			spawnTeamsWorkerRpc({
+				cwd: repoRoot,
+				entryPath,
+				sessionsDir,
+				teamId,
+				taskListId: teamId,
+				agentName: `agent${i}`,
+				leadName: "team-lead",
+				style: "normal",
+				autoClaim: true,
+				planRequired: false,
+				systemAppend,
+				logDir: logsDir,
+			}),
+		);
+	}
+
+	const deadline = Date.now() + timeoutSec * 1000;
+	while (Date.now() < deadline) {
+		const ts = await listTasks(teamDir, teamId);
+		const done = ts.filter((t) => t.status === "completed").length;
+		const inProgress = ts.filter((t) => t.status === "in_progress").length;
+		const pending = ts.filter((t) => t.status === "pending").length;
+		console.log(`tasks: completed=${done} in_progress=${inProgress} pending=${pending}`);
+		if (allCompleted(ts)) {
+			console.log("PASS: all tasks completed");
+			const owners = ts.map((t) => `${t.id}:${t.owner ?? "-"}`);
+			console.log(`owners: ${owners.join(" ")}`);
+			process.exitCode = 0;
+			break;
+		}
+		await sleep(1000);
+	}
+
+	if (process.exitCode !== 0) {
+		console.error(`FAIL: timeout after ${timeoutSec}s (inspect logs under ${logsDir})`);
+		process.exitCode = 1;
+	}
+} finally {
+	await cleanup();
+}