@os-eco/overstory-cli 0.7.9 → 0.8.2

package/src/commands/coordinator.test.ts

@@ -15,11 +15,13 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { AgentError, ValidationError } from "../errors.ts";
+import { createMailStore } from "../mail/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import { createRunStore } from "../sessions/store.ts";
 import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
 import type { AgentSession } from "../types.ts";
 import {
+	askCoordinator,
 	buildCoordinatorBeacon,
 	type CoordinatorDeps,
 	coordinatorCommand,
@@ -1770,3 +1772,335 @@ describe("SessionStore round-trip", () => {
 		expect(exists).toBe(true);
 	});
 });
+
+// --- Helpers for send/output tests ---
+
+/** Read all messages from the mail store at mail.db for assertions. */
+function loadMailMessages() {
+	const mailDbPath = join(overstoryDir, "mail.db");
+	const mailStore = createMailStore(mailDbPath);
+	try {
+		return mailStore.getAll();
+	} finally {
+		mailStore.close();
+	}
+}
+
+describe("sendCoordinator", () => {
+	test("send succeeds with running coordinator — mail is in DB", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		let nudgeCalled = false;
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => {
+			nudgeCalled = true;
+			return { delivered: true };
+		};
+
+		await captureStdout(() => coordinatorCommand(["send", "--body", "hello world"], deps));
+
+		const messages = loadMailMessages();
+		expect(messages).toHaveLength(1);
+		expect(messages[0]?.from).toBe("operator");
+		expect(messages[0]?.to).toBe("coordinator");
+		expect(messages[0]?.body).toBe("hello world");
+		expect(messages[0]?.type).toBe("dispatch");
+		expect(nudgeCalled).toBe(true);
+	});
+
+	test("send fails when no coordinator running", async () => {
+		const { deps } = makeDeps();
+
+		await expect(coordinatorCommand(["send", "--body", "hello"], deps)).rejects.toThrow(AgentError);
+	});
+
+	test("send fails when coordinator tmux is dead — state updated to zombie", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": false });
+
+		await expect(coordinatorCommand(["send", "--body", "hello"], deps)).rejects.toThrow(AgentError);
+
+		const sessions = loadSessionsFromDb();
+		expect(sessions[0]?.state).toBe("zombie");
+	});
+
+	test("send --json outputs JSON with id and nudged fields", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => ({ delivered: true });
+
+		const output = await captureStdout(() =>
+			coordinatorCommand(["send", "--body", "hello", "--json"], deps),
+		);
+		const parsed = JSON.parse(output) as Record<string, unknown>;
+		expect(typeof parsed.id).toBe("string");
+		expect(parsed.nudged).toBe(true);
+	});
+
+	test("send with custom --subject uses subject in mail", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => ({ delivered: false });
+
+		await captureStdout(() =>
+			coordinatorCommand(
+				["send", "--body", "build feature X", "--subject", "Deploy feature X"],
+				deps,
+			),
+		);
+
+		const messages = loadMailMessages();
+		expect(messages[0]?.subject).toBe("Deploy feature X");
+	});
+});
+
+describe("outputCoordinator", () => {
+	test("output shows pane content", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._capturePaneContent = async () => "Hello from coordinator pane\n";
+
+		const output = await captureStdout(() => coordinatorCommand(["output"], deps));
+		expect(output).toContain("Hello from coordinator pane");
+	});
+
+	test("output fails when no coordinator running", async () => {
+		const { deps } = makeDeps();
+
+		await expect(coordinatorCommand(["output"], deps)).rejects.toThrow(AgentError);
+	});
+
+	test("output fails when coordinator tmux is dead — state updated to zombie", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": false });
+
+		await expect(coordinatorCommand(["output"], deps)).rejects.toThrow(AgentError);
+
+		const sessions = loadSessionsFromDb();
+		expect(sessions[0]?.state).toBe("zombie");
+	});
+
+	test("output --json wraps content in JSON", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._capturePaneContent = async () => "some output";
+
+		const output = await captureStdout(() => coordinatorCommand(["output", "--json"], deps));
+		const parsed = JSON.parse(output) as Record<string, unknown>;
+		expect(parsed.content).toBe("some output");
+		expect(typeof parsed.lines).toBe("number");
+	});
+
+	test("output --lines passes lines parameter to capturePaneContent", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		let capturedLines: number | undefined;
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._capturePaneContent = async (_name: string, lines?: number) => {
+			capturedLines = lines;
+			return "output";
+		};
+
+		await captureStdout(() => coordinatorCommand(["output", "--lines", "100"], deps));
+		expect(capturedLines).toBe(100);
+	});
+});
+
+describe("askCoordinator", () => {
+	test("sends mail and returns reply body on stdout", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => ({ delivered: true });
+		deps._pollIntervalMs = 50; // Fast polling for test
+
+		const mailDbPath = join(overstoryDir, "mail.db");
+		const outputChunks: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string) => {
+			outputChunks.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+
+		try {
+			// Start ask without awaiting — lets us insert the reply concurrently
+			const askPromise = askCoordinator(
+				"what is the status",
+				{ subject: "status check", timeout: 10, json: false },
+				deps,
+			);
+
+			// Wait for the ask to complete setup and send mail, then insert a reply
+			await Bun.sleep(300);
+			const replyStore = createMailStore(mailDbPath);
+			try {
+				const messages = replyStore.getAll({ from: "operator", to: "coordinator" });
+				const sent = messages[0];
+				if (sent) {
+					replyStore.insert({
+						id: "",
+						from: "coordinator",
+						to: "operator",
+						subject: `Re: ${sent.subject}`,
+						body: "Here is your answer",
+						type: "status",
+						priority: "normal",
+						threadId: sent.id,
+						payload: JSON.stringify({
+							correlationId: JSON.parse(sent.payload ?? "{}").correlationId,
+						}),
+					});
+				}
+			} finally {
+				replyStore.close();
+			}
+
+			await askPromise;
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+
+		expect(outputChunks.join("")).toBe("Here is your answer\n");
+	});
+
+	test("times out when no reply arrives", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => ({ delivered: false });
+		deps._pollIntervalMs = 50; // Fast polling so the 1s timeout exhausts quickly
+
+		let caughtError: unknown;
+		try {
+			await askCoordinator(
+				"will you answer?",
+				{ subject: "timeout test", timeout: 1, json: false },
+				deps,
+			);
+		} catch (err) {
+			caughtError = err;
+		}
+
+		expect(caughtError).toBeInstanceOf(AgentError);
+		const ae = caughtError as AgentError;
+		expect(ae.message).toContain("Timed out");
+	});
+
+	test("throws when coordinator is not running", async () => {
+		// No session in DB
+		const { deps } = makeDeps();
+
+		let caughtError: unknown;
+		try {
+			await askCoordinator("hello", { subject: "test", timeout: 5, json: false }, deps);
+		} catch (err) {
+			caughtError = err;
+		}
+
+		expect(caughtError).toBeInstanceOf(AgentError);
+		const ae = caughtError as AgentError;
+		expect(ae.message).toContain("No active coordinator");
+	});
+
+	test("throws when coordinator tmux session is dead", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		// Tmux reports session as dead
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": false });
+
+		let caughtError: unknown;
+		try {
+			await askCoordinator("hello", { subject: "test", timeout: 5, json: false }, deps);
+		} catch (err) {
+			caughtError = err;
+		}
+
+		expect(caughtError).toBeInstanceOf(AgentError);
+		const ae = caughtError as AgentError;
+		expect(ae.message).toContain("not alive");
+
+		// Session state should be updated to zombie
+		const sessions = loadSessionsFromDb();
+		expect(sessions[0]?.state).toBe("zombie");
+	});
+
+	test("JSON output includes correlationId and reply details", async () => {
+		const session = makeCoordinatorSession({ state: "working" });
+		saveSessionsToDb([session]);
+
+		const { deps } = makeDeps({ "overstory-test-project-coordinator": true });
+		deps._nudge = async () => ({ delivered: true });
+		deps._pollIntervalMs = 50;
+
+		const mailDbPath = join(overstoryDir, "mail.db");
+		let output = "";
+
+		const askPromise = captureStdout(async () => {
+			const innerAskPromise = askCoordinator(
+				"report status",
+				{ subject: "status", timeout: 10, json: true },
+				deps,
+			);
+
+			// Insert reply while ask is polling
+			await Bun.sleep(300);
+			const replyStore = createMailStore(mailDbPath);
+			try {
+				const messages = replyStore.getAll({ from: "operator", to: "coordinator" });
+				const sent = messages[0];
+				if (sent) {
+					replyStore.insert({
+						id: "",
+						from: "coordinator",
+						to: "operator",
+						subject: `Re: ${sent.subject}`,
+						body: "Status: all good",
+						type: "status",
+						priority: "normal",
+						threadId: sent.id,
+						payload: JSON.stringify({
+							correlationId: JSON.parse(sent.payload ?? "{}").correlationId,
+						}),
+					});
+				}
+			} finally {
+				replyStore.close();
+			}
+
+			await innerAskPromise;
+		});
+
+		output = await askPromise;
+
+		const parsed = JSON.parse(output) as Record<string, unknown>;
+		expect(parsed.success).toBe(true);
+		expect(parsed.command).toBe("coordinator ask");
+		expect(typeof parsed.correlationId).toBe("string");
+		expect(typeof parsed.sentId).toBe("string");
+		expect(typeof parsed.replyId).toBe("string");
+		expect(parsed.body).toBe("Status: all good");
+	});
+
+	test("command registration — createCoordinatorCommand has ask subcommand", () => {
+		const cmd = createCoordinatorCommand({});
+		const subcommandNames = cmd.commands.map((c) => c.name());
+		expect(subcommandNames).toContain("ask");
+	});
+});