@katyella/legio 0.1.0

package/src/e2e/chat-flow.test.ts

@@ -0,0 +1,346 @@
+/**
+ * E2E tests for the chat flow: POST and GET routes for coordinator and agent chat.
+ *
+ * Tests:
+ *   1. POST /api/coordinator/chat stores message with from=human, to=coordinator, audience=human
+ *   2. POST /api/agents/:name/chat stores message in mail.db
+ *   3. GET /api/coordinator/chat/history returns bidirectional messages
+ *   4. GET /api/agents/:name/chat/history returns bidirectional messages
+ *   5. History excludes audience=agent messages
+ *   6. Limit param works
+ *
+ * Uses real SQLite databases in temp directories. No mocking of store logic.
+ * Mock setup mirrors routes.test.ts (see header there for rationale).
+ *
+ */
+
+import { accessSync, constants as fsConstants, readFileSync } from "node:fs";
+import { vi } from "vitest";
+
+// Stub the global Bun object because production modules (e.g., config.ts) still use Bun APIs
+// and have not yet been migrated to Node.js equivalents. This shim provides only the subset
+// of the Bun API surface required by the code paths exercised by these chat tests.
+vi.stubGlobal("Bun", {
+	file: (path: string) => ({
+		exists: async () => {
+			try {
+				accessSync(path, fsConstants.F_OK);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		text: async () => readFileSync(path, "utf-8"),
+		json: async () => JSON.parse(readFileSync(path, "utf-8")),
+	}),
+	spawn: () => {
+		throw new Error("Bun.spawn not available in Node.js/vitest environment");
+	},
+	sleep: (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)),
+	write: async (path: string, content: string) => {
+		const { writeFileSync } = await import("node:fs");
+		writeFileSync(path, content, "utf-8");
+	},
+});
+
+// Mock the beads client so tests can run without `bd` on PATH.
+vi.mock("../beads/client.ts", () => ({
+	createBeadsClient: () => ({
+		ready: async () => [],
+		list: async () => [],
+		show: async (id: string) => {
+			throw new Error(`bd not available: ${id}`);
+		},
+		create: async () => "bead-test-001",
+		claim: async () => {},
+		close: async () => {},
+	}),
+}));
+
+// Mock tmux so tests don't interfere with real developer tmux sessions.
+const { mockIsSessionAlive, mockSendKeys } = vi.hoisted(() => ({
+	mockIsSessionAlive: vi.fn().mockResolvedValue(true),
+	mockSendKeys: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../worktree/tmux.ts", () => ({
+	isSessionAlive: mockIsSessionAlive,
+	sendKeys: mockSendKeys,
+}));
+
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createMailStore } from "../mail/store.ts";
+import { handleApiRequest } from "../server/routes.ts";
+import { createSessionStore } from "../sessions/store.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeRequest(path: string, query?: Record<string, string>): Request {
+	const url = new URL(`http://localhost${path}`);
+	if (query) {
+		for (const [k, v] of Object.entries(query)) {
+			url.searchParams.set(k, v);
+		}
+	}
+	return new Request(url.toString(), { method: "GET" });
+}
+
+function makePostRequest(path: string, body: unknown): Request {
+	return new Request(`http://localhost${path}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	});
+}
+
+// ---------------------------------------------------------------------------
+// Test setup
+// ---------------------------------------------------------------------------
+
+let tempDir: string;
+let legioDir: string;
+let projectRoot: string;
+
+beforeEach(async () => {
+	tempDir = await (async () => {
+		const base = join(tmpdir(), `chat-flow-test-${Date.now()}`);
+		await mkdir(base, { recursive: true });
+		return base;
+	})();
+	legioDir = join(tempDir, ".legio");
+	projectRoot = tempDir;
+	await mkdir(legioDir, { recursive: true });
+
+	// Write minimal config.yaml for loadConfig
+	await writeFile(
+		join(legioDir, "config.yaml"),
+		[
+			"project:",
+			"  name: test",
+			"  canonicalBranch: main",
+			"agents:",
+			"  maxDepth: 2",
+			"coordinator:",
+			"  model: claude-sonnet-4-6",
+		].join("\n"),
+	);
+});
+
+afterEach(async () => {
+	await rm(tempDir, { recursive: true, force: true });
+});
+
+async function dispatch(path: string, query?: Record<string, string>): Promise<Response> {
+	return handleApiRequest(makeRequest(path, query), legioDir, projectRoot);
+}
+
+async function dispatchPost(path: string, body: unknown): Promise<Response> {
+	return handleApiRequest(makePostRequest(path, body), legioDir, projectRoot);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("E2E: chat flow", () => {
+	it("POST /api/coordinator/chat stores message with from=human, to=coordinator, audience=human", async () => {
+		// Seed orchestrator-tmux.json so resolveTerminalSession returns a session name
+		await writeFile(
+			join(legioDir, "orchestrator-tmux.json"),
+			JSON.stringify({ tmuxSession: "legio-fake-orchestrator" }),
+		);
+
+		const res = await dispatchPost("/api/coordinator/chat", { text: "hello coordinator" });
+		expect(res.status).toBe(201);
+
+		const body = (await res.json()) as { from: string; to: string; audience: string; body: string };
+		expect(body.from).toBe("human");
+		expect(body.to).toBe("coordinator");
+		expect(body.audience).toBe("human");
+		expect(body.body).toBe("hello coordinator");
+
+		// Verify the message was persisted in mail.db
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		const messages = mailStore.getAll({ from: "human", to: "coordinator" });
+		mailStore.close();
+		expect(messages.length).toBe(1);
+		expect(messages[0]?.audience).toBe("human");
+		expect(messages[0]?.body).toBe("hello coordinator");
+	});
+
+	it("POST /api/agents/:name/chat stores message in mail.db", async () => {
+		// Seed sessions.db with test-agent in working state
+		const sessStore = createSessionStore(join(legioDir, "sessions.db"));
+		const now = new Date().toISOString();
+		sessStore.upsert({
+			id: "sess-chat-001",
+			agentName: "test-agent",
+			capability: "builder",
+			worktreePath: "/tmp/wt/test-agent",
+			branchName: "legio/test-agent/task-1",
+			beadId: "task-1",
+			tmuxSession: "legio-fake-test-agent",
+			state: "working",
+			pid: 12345,
+			parentAgent: null,
+			depth: 1,
+			runId: "run-001",
+			startedAt: now,
+			lastActivity: now,
+			escalationLevel: 0,
+			stalledSince: null,
+		});
+		sessStore.close();
+
+		const res = await dispatchPost("/api/agents/test-agent/chat", { text: "hello agent" });
+		expect(res.status).toBe(201);
+
+		const body = (await res.json()) as { from: string; to: string; audience: string };
+		expect(body.from).toBe("human");
+		expect(body.to).toBe("test-agent");
+		expect(body.audience).toBe("human");
+
+		// Verify persisted in mail.db
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		const messages = mailStore.getAll({ from: "human", to: "test-agent" });
+		mailStore.close();
+		expect(messages.length).toBe(1);
+		expect(messages[0]?.body).toBe("hello agent");
+	});
+
+	it("GET /api/coordinator/chat/history returns bidirectional messages", async () => {
+		// Seed both directions: human→coordinator and coordinator→human
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		mailStore.insert({
+			id: "msg-human-to-coord",
+			from: "human",
+			to: "coordinator",
+			subject: "chat",
+			body: "user message",
+			type: "status",
+			priority: "normal",
+			threadId: null,
+			audience: "human",
+		});
+		mailStore.insert({
+			id: "msg-coord-to-human",
+			from: "coordinator",
+			to: "human",
+			subject: "response",
+			body: "coordinator reply",
+			type: "result",
+			priority: "normal",
+			threadId: null,
+			audience: "human",
+		});
+		mailStore.close();
+
+		const res = await dispatch("/api/coordinator/chat/history");
+		expect(res.status).toBe(200);
+
+		const messages = (await res.json()) as Array<{ from: string; to: string }>;
+		expect(messages.length).toBe(2);
+		expect(messages.some((m) => m.from === "human" && m.to === "coordinator")).toBe(true);
+		expect(messages.some((m) => m.from === "coordinator" && m.to === "human")).toBe(true);
+	});
+
+	it("GET /api/agents/:name/chat/history returns bidirectional messages", async () => {
+		// Seed both directions: human→agent and agent→human
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		mailStore.insert({
+			id: "msg-human-to-agent",
+			from: "human",
+			to: "my-agent",
+			subject: "chat",
+			body: "user asks",
+			type: "status",
+			priority: "normal",
+			threadId: null,
+			audience: "human",
+		});
+		mailStore.insert({
+			id: "msg-agent-to-human",
+			from: "my-agent",
+			to: "human",
+			subject: "response",
+			body: "agent responds",
+			type: "result",
+			priority: "normal",
+			threadId: null,
+			audience: "human",
+		});
+		mailStore.close();
+
+		const res = await dispatch("/api/agents/my-agent/chat/history");
+		expect(res.status).toBe(200);
+
+		const messages = (await res.json()) as Array<{ from: string; to: string }>;
+		expect(messages.length).toBe(2);
+		expect(messages.some((m) => m.from === "human" && m.to === "my-agent")).toBe(true);
+		expect(messages.some((m) => m.from === "my-agent" && m.to === "human")).toBe(true);
+	});
+
+	it("GET /api/coordinator/chat/history excludes audience=agent messages", async () => {
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		mailStore.insert({
+			id: "msg-human-visible",
+			from: "human",
+			to: "coordinator",
+			subject: "chat",
+			body: "visible message",
+			type: "status",
+			priority: "normal",
+			threadId: null,
+			audience: "human",
+		});
+		mailStore.insert({
+			id: "msg-agent-hidden",
+			from: "human",
+			to: "coordinator",
+			subject: "internal",
+			body: "agent-only message",
+			type: "status",
+			priority: "normal",
+			threadId: null,
+			audience: "agent",
+		});
+		mailStore.close();
+
+		const res = await dispatch("/api/coordinator/chat/history");
+		expect(res.status).toBe(200);
+
+		const messages = (await res.json()) as Array<{ id: string; audience: string }>;
+		// Only the human-audience message should appear
+		expect(messages.length).toBe(1);
+		expect(messages[0]?.id).toBe("msg-human-visible");
+		expect(messages.some((m) => m.id === "msg-agent-hidden")).toBe(false);
+	});
+
+	it("GET /api/coordinator/chat/history respects limit param", async () => {
+		const mailStore = createMailStore(join(legioDir, "mail.db"));
+		for (let i = 0; i < 5; i++) {
+			mailStore.insert({
+				id: `msg-limit-${i}`,
+				from: "human",
+				to: "coordinator",
+				subject: "chat",
+				body: `message ${i}`,
+				type: "status",
+				priority: "normal",
+				threadId: null,
+				audience: "human",
+			});
+		}
+		mailStore.close();
+
+		const res = await dispatch("/api/coordinator/chat/history", { limit: "2" });
+		expect(res.status).toBe(200);
+
+		const messages = (await res.json()) as unknown[];
+		expect(messages.length).toBe(2);
+	});
+});

package/src/e2e/init-sling-lifecycle.test.ts

@@ -0,0 +1,288 @@
+import { access, readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+
+/** Test helper: check whether a file exists using Node.js fs/promises. */
+async function fileExists(path: string): Promise<boolean> {
+	return access(path).then(
+		() => true,
+		() => false,
+	);
+}
+
+/** Test helper: read a file as UTF-8 text using Node.js fs/promises. */
+function fileText(path: string): Promise<string> {
+	return readFile(path, "utf-8");
+}
+
+import { createManifestLoader } from "../agents/manifest.ts";
+import { writeOverlay } from "../agents/overlay.ts";
+import { initCommand } from "../commands/init.ts";
+import { loadConfig } from "../config.ts";
+import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
+import type { OverlayConfig } from "../types.ts";
+
+/**
+ * E2E test: init→sling lifecycle on a throwaway external project.
+ *
+ * Validates the "project-agnostic" promise by running legio init on a
+ * fresh temp git repo (NOT the legio repo itself), then verifying all
+ * artifacts, loading config + manifest via real APIs, and generating an overlay.
+ *
+ * Uses real filesystem and real git repos. No mocks.
+ * Suppresses stdout because initCommand prints status lines.
+ */
+
+const EXPECTED_AGENT_DEFS = [
+	"builder.md",
+	"coordinator.md",
+	"cto.md",
+	"gateway.md",
+	"lead.md",
+	"merger.md",
+	"monitor.md",
+	"reviewer.md",
+	"scout.md",
+	"supervisor.md",
+];
+
+describe("E2E: init→sling lifecycle on external project", () => {
+	let tempDir: string;
+	let originalCwd: string;
+	let originalWrite: typeof process.stdout.write;
+
+	beforeEach(async () => {
+		tempDir = await createTempGitRepo();
+		originalCwd = process.cwd();
+		process.chdir(tempDir);
+
+		// Suppress stdout noise from initCommand
+		originalWrite = process.stdout.write;
+		process.stdout.write = (() => true) as typeof process.stdout.write;
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		process.stdout.write = originalWrite;
+		await cleanupTempDir(tempDir);
+	});
+
+	test("init creates all expected artifacts", async () => {
+		await initCommand([]);
+
+		const legioDir = join(tempDir, ".legio");
+
+		// config.yaml exists
+		expect(await fileExists(join(legioDir, "config.yaml"))).toBe(true);
+
+		// agent-manifest.json exists and is valid JSON
+		expect(await fileExists(join(legioDir, "agent-manifest.json"))).toBe(true);
+		const manifestText = await fileText(join(legioDir, "agent-manifest.json"));
+		const manifestJson = JSON.parse(manifestText);
+		expect(manifestJson).toBeDefined();
+		expect(manifestJson.version).toBe("1.0");
+		expect(typeof manifestJson.agents).toBe("object");
+
+		// hooks.json exists
+		expect(await fileExists(join(legioDir, "hooks.json"))).toBe(true);
+
+		// .gitignore exists
+		expect(await fileExists(join(legioDir, ".gitignore"))).toBe(true);
+
+		// agent-defs/ contains all 9 agent definition files
+		const agentDefsDir = join(legioDir, "agent-defs");
+		const agentDefFiles = (await readdir(agentDefsDir)).filter((f) => f.endsWith(".md")).sort();
+		expect(agentDefFiles).toEqual(EXPECTED_AGENT_DEFS);
+
+		// Required subdirectories exist
+		const expectedDirs = ["agents", "worktrees", "specs", "logs"];
+		for (const dirName of expectedDirs) {
+			const dirPath = join(legioDir, dirName);
+			const dirStat = await stat(dirPath);
+			expect(dirStat.isDirectory()).toBe(true);
+		}
+	});
+
+	test("loadConfig returns valid config pointing to temp dir", async () => {
+		await initCommand([]);
+
+		const config = await loadConfig(tempDir);
+
+		// project.root should point to the temp directory
+		expect(config.project.root).toBe(tempDir);
+
+		// agents.baseDir should be the relative path to agent-defs
+		expect(config.agents.baseDir).toBe(".legio/agent-defs");
+
+		// canonicalBranch should be detected (main for our test repos)
+		expect(config.project.canonicalBranch).toBeTruthy();
+
+		// name should be set (from dir basename or git remote)
+		expect(config.project.name).toBeTruthy();
+	});
+
+	test("manifest loads successfully with all 9 agents", async () => {
+		await initCommand([]);
+
+		const manifestPath = join(tempDir, ".legio", "agent-manifest.json");
+		const agentDefsDir = join(tempDir, ".legio", "agent-defs");
+		const loader = createManifestLoader(manifestPath, agentDefsDir);
+
+		const manifest = await loader.load();
+
+		// All 9 agents present
+		const agentNames = Object.keys(manifest.agents).sort();
+		expect(agentNames).toEqual([
+			"builder",
+			"coordinator",
+			"cto",
+			"lead",
+			"merger",
+			"monitor",
+			"reviewer",
+			"scout",
+			"supervisor",
+		]);
+
+		// Each agent has a valid file reference
+		for (const [_name, def] of Object.entries(manifest.agents)) {
+			expect(def.file).toMatch(/\.md$/);
+			// Verify the referenced .md file actually exists
+			expect(await fileExists(join(agentDefsDir, def.file))).toBe(true);
+		}
+
+		// Validation returns no errors
+		const errors = loader.validate();
+		expect(errors).toEqual([]);
+	});
+
+	test("manifest capability index is consistent", async () => {
+		await initCommand([]);
+
+		const manifestPath = join(tempDir, ".legio", "agent-manifest.json");
+		const agentDefsDir = join(tempDir, ".legio", "agent-defs");
+		const loader = createManifestLoader(manifestPath, agentDefsDir);
+
+		const manifest = await loader.load();
+
+		// capabilityIndex should map capabilities to agent names
+		expect(Object.keys(manifest.capabilityIndex).length).toBeGreaterThan(0);
+
+		// Each capability in the index should reference agents that declare it
+		for (const [cap, names] of Object.entries(manifest.capabilityIndex)) {
+			for (const name of names) {
+				const agent = manifest.agents[name];
+				expect(agent).toBeDefined();
+				expect(agent?.capabilities).toContain(cap);
+			}
+		}
+	});
+
+	test("overlay generation works for external project", async () => {
+		await initCommand([]);
+
+		const agentDefsDir = join(tempDir, ".legio", "agent-defs");
+		const baseDefinition = await fileText(join(agentDefsDir, "builder.md"));
+
+		const overlayConfig: OverlayConfig = {
+			agentName: "test-agent",
+			beadId: "test-bead-001",
+			specPath: null,
+			branchName: "legio/test-agent/test-bead-001",
+			worktreePath: join(tempDir, ".legio", "worktrees", "test-agent"),
+			fileScope: [],
+			mulchDomains: [],
+			parentAgent: null,
+			depth: 0,
+			canSpawn: false,
+			capability: "builder",
+			baseDefinition,
+		};
+
+		// Write the overlay into a subdirectory of the temp dir (simulating a worktree)
+		const worktreePath = join(tempDir, ".legio", "worktrees", "test-agent");
+		const { mkdir } = await import("node:fs/promises");
+		await mkdir(worktreePath, { recursive: true });
+
+		await writeOverlay(worktreePath, overlayConfig, tempDir);
+
+		// Verify the overlay was written
+		const overlayPath = join(worktreePath, ".claude", "CLAUDE.md");
+		expect(await fileExists(overlayPath)).toBe(true);
+
+		const content = await fileText(overlayPath);
+
+		// Verify template placeholders were replaced
+		expect(content).toContain("test-agent");
+		expect(content).toContain("test-bead-001");
+		expect(content).toContain("legio/test-agent/test-bead-001");
+		expect(content).not.toContain("{{AGENT_NAME}}");
+		expect(content).not.toContain("{{BEAD_ID}}");
+		expect(content).not.toContain("{{BRANCH_NAME}}");
+	});
+
+	test("full init→config→manifest→overlay pipeline succeeds", async () => {
+		// This test validates the entire lifecycle in sequence:
+		// init → load config → load manifest → generate overlay
+
+		// Step 1: Init
+		await initCommand([]);
+
+		// Step 2: Load config
+		const config = await loadConfig(tempDir);
+		expect(config.project.root).toBe(tempDir);
+
+		// Step 3: Load manifest using config paths
+		const manifestPath = join(config.project.root, config.agents.manifestPath);
+		const agentDefsDir = join(config.project.root, config.agents.baseDir);
+		const loader = createManifestLoader(manifestPath, agentDefsDir);
+		await loader.load();
+
+		// Verify builder agent exists (the one we'll use for overlay)
+		const builder = loader.getAgent("builder");
+		expect(builder).toBeDefined();
+		expect(builder?.canSpawn).toBe(false);
+
+		// Verify lead agent can spawn
+		const lead = loader.getAgent("lead");
+		expect(lead).toBeDefined();
+		expect(lead?.canSpawn).toBe(true);
+
+		// Step 4: Generate overlay using a realistic config
+		const builderDef = await fileText(join(agentDefsDir, "builder.md"));
+		const overlayConfig: OverlayConfig = {
+			agentName: "lifecycle-builder",
+			beadId: "lifecycle-001",
+			specPath: join(tempDir, ".legio", "specs", "lifecycle-001.md"),
+			branchName: "legio/lifecycle-builder/lifecycle-001",
+			worktreePath: join(tempDir, ".legio", "worktrees", "lifecycle-builder"),
+			fileScope: ["src/main.ts", "src/utils.ts"],
+			mulchDomains: ["typescript"],
+			parentAgent: "orchestrator",
+			depth: 0,
+			canSpawn: false,
+			capability: "builder",
+			baseDefinition: builderDef,
+		};
+
+		const worktreePath = join(tempDir, ".legio", "worktrees", "lifecycle-builder");
+		const { mkdir } = await import("node:fs/promises");
+		await mkdir(worktreePath, { recursive: true });
+
+		await writeOverlay(worktreePath, overlayConfig, tempDir);
+
+		const overlayContent = await fileText(join(worktreePath, ".claude", "CLAUDE.md"));
+
+		// Verify all overlay fields rendered correctly
+		expect(overlayContent).toContain("lifecycle-builder");
+		expect(overlayContent).toContain("lifecycle-001");
+		expect(overlayContent).toContain("legio/lifecycle-builder/lifecycle-001");
+		expect(overlayContent).toContain("orchestrator");
+		expect(overlayContent).toContain("`src/main.ts`");
+		expect(overlayContent).toContain("`src/utils.ts`");
+		expect(overlayContent).toContain("mulch prime typescript");
+
+		// No unresolved placeholders
+		expect(overlayContent).not.toMatch(/\{\{[A-Z_]+\}\}/);
+	});
+});

package/src/errors.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "vitest";
+import { isRunningAsRoot } from "./errors.ts";
+
+describe("isRunningAsRoot", () => {
+	test("returns false in normal test environment (not root)", () => {
+		// This test runs as a regular user during development and CI.
+		// process.getuid() should return a non-zero UID.
+		if (typeof process.getuid === "function") {
+			expect(process.getuid()).not.toBe(0);
+		}
+		expect(isRunningAsRoot()).toBe(false);
+	});
+
+	test("returns false when process.getuid is not available (Windows)", () => {
+		// Simulate a platform without process.getuid by overriding it to undefined
+		const original = process.getuid;
+		(process as unknown as Record<string, unknown>).getuid = undefined;
+		expect(isRunningAsRoot()).toBe(false);
+		process.getuid = original;
+	});
+});