@katyella/legio 0.1.0

package/src/commands/down.test.ts

@@ -0,0 +1,308 @@
+/**
+ * Tests for legio down command.
+ *
+ * Uses DI (DownDeps) to inject mock subprocess calls. No real coordinator/server
+ * in tests.
+ *
+ * WHY DI instead of mock.module: mock.module() in vitest is process-global
+ * and leaks across test files. DI keeps mocks scoped to each test invocation.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DownDeps } from "./down.ts";
+import { downCommand } from "./down.ts";
+
+/** Builds a mock runCommand with configurable results per command prefix. */
+function makeRunCommand(
+	responses: Record<string, { stdout: string; stderr: string; exitCode: number }>,
+): NonNullable<DownDeps["_runCommand"]> {
+	return async (cmd) => {
+		const key = cmd.join(" ");
+		for (const [prefix, result] of Object.entries(responses)) {
+			if (key.startsWith(prefix)) return result;
+		}
+		return { stdout: "", stderr: `Unexpected command: ${key}`, exitCode: 1 };
+	};
+}
+
+/** Coordinator stop success response. */
+const COORD_STOP_OK = {
+	stdout:
+		"Coordinator stopped (session: session-123)\nWatchdog stopped\nNo monitor running\nRun completed\n",
+	stderr: "",
+	exitCode: 0,
+};
+
+/** Coordinator stop failure (not running). */
+const COORD_STOP_FAIL = {
+	stdout: "",
+	stderr: "Error [AGENT_ERROR]: No active coordinator session found",
+	exitCode: 1,
+};
+
+/** Server stop success response. */
+const SERVER_STOP_OK = { stdout: "Server stopped (PID 42000)\n", stderr: "", exitCode: 0 };
+
+/** Server stop response when not running. */
+const SERVER_NOT_RUNNING = { stdout: "Server not running\n", stderr: "", exitCode: 0 };
+
+/** Server stop response when stale PID cleaned. */
+const SERVER_STALE_PID = {
+	stdout: "Server not running (stale PID file cleaned up)\n",
+	stderr: "",
+	exitCode: 0,
+};
+
+describe("downCommand", () => {
+	let capturedStdout: string;
+	let _capturedStderr: string;
+	let originalStdout: typeof process.stdout.write;
+	let originalStderr: typeof process.stderr.write;
+
+	beforeEach(() => {
+		capturedStdout = "";
+		_capturedStderr = "";
+		originalStdout = process.stdout.write;
+		originalStderr = process.stderr.write;
+		process.stdout.write = vi.fn((chunk: unknown) => {
+			capturedStdout += String(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+		process.stderr.write = vi.fn((chunk: unknown) => {
+			_capturedStderr += String(chunk);
+			return true;
+		}) as typeof process.stderr.write;
+	});
+
+	afterEach(() => {
+		process.stdout.write = originalStdout;
+		process.stderr.write = originalStderr;
+	});
+
+	it("prints help for --help", async () => {
+		await downCommand(["--help"]);
+		expect(capturedStdout).toContain("legio down");
+		expect(capturedStdout).toContain("--json");
+	});
+
+	it("prints help for -h", async () => {
+		await downCommand(["-h"]);
+		expect(capturedStdout).toContain("legio down");
+	});
+
+	it("prints Nothing to stop when coordinator not running and server not running", async () => {
+		const deps: DownDeps = {
+			_runCommand: makeRunCommand({
+				"legio coordinator stop": COORD_STOP_FAIL,
+				"legio server stop": SERVER_NOT_RUNNING,
+			}),
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		expect(capturedStdout).toContain("Nothing to stop");
+	});
+
+	it("prints Nothing to stop when server has stale PID", async () => {
+		const deps: DownDeps = {
+			_runCommand: makeRunCommand({
+				"legio coordinator stop": COORD_STOP_FAIL,
+				"legio server stop": SERVER_STALE_PID,
+			}),
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		expect(capturedStdout).toContain("Nothing to stop");
+	});
+
+	it("stops coordinator when running", async () => {
+		const commands: string[][] = [];
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				commands.push(cmd);
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") return COORD_STOP_OK;
+				if (cmd[0] === "legio" && cmd[1] === "server") return SERVER_NOT_RUNNING;
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		const ranStop = commands.some(
+			(c) => c[0] === "legio" && c[1] === "coordinator" && c[2] === "stop",
+		);
+		expect(ranStop).toBe(true);
+		expect(capturedStdout).toContain("Legio stack stopped");
+	});
+
+	it("stops server when running", async () => {
+		const commands: string[][] = [];
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				commands.push(cmd);
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") return COORD_STOP_FAIL;
+				if (cmd[0] === "legio" && cmd[1] === "server" && cmd[2] === "stop") return SERVER_STOP_OK;
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		const serverStopped = commands.some(
+			(c) => c[0] === "legio" && c[1] === "server" && c[2] === "stop",
+		);
+		expect(serverStopped).toBe(true);
+		expect(capturedStdout).toContain("Legio stack stopped");
+	});
+
+	it("stops both coordinator and server when both running", async () => {
+		const commands: string[][] = [];
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				commands.push(cmd);
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") return COORD_STOP_OK;
+				if (cmd[0] === "legio" && cmd[1] === "server") return SERVER_STOP_OK;
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		const coordStopped = commands.some(
+			(c) => c[0] === "legio" && c[1] === "coordinator" && c[2] === "stop",
+		);
+		const serverStopped = commands.some(
+			(c) => c[0] === "legio" && c[1] === "server" && c[2] === "stop",
+		);
+		expect(coordStopped).toBe(true);
+		expect(serverStopped).toBe(true);
+		expect(capturedStdout).toContain("Legio stack stopped");
+	});
+
+	it("always calls legio server stop (delegates PID checking)", async () => {
+		const commands: string[][] = [];
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				commands.push(cmd);
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") return COORD_STOP_OK;
+				if (cmd[0] === "legio" && cmd[1] === "server") return SERVER_NOT_RUNNING;
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		const serverStopCalled = commands.some(
+			(c) => c[0] === "legio" && c[1] === "server" && c[2] === "stop",
+		);
+		expect(serverStopCalled).toBe(true);
+	});
+
+	it("outputs JSON with correct fields when --json passed (nothing to stop)", async () => {
+		const deps: DownDeps = {
+			_runCommand: makeRunCommand({
+				"legio coordinator stop": COORD_STOP_FAIL,
+				"legio server stop": SERVER_NOT_RUNNING,
+			}),
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand(["--json"], deps);
+
+		const parsed = JSON.parse(capturedStdout.trim()) as {
+			coordinatorStopped: boolean;
+			serverStopped: boolean;
+			nothingToStop: boolean;
+		};
+		expect(parsed.coordinatorStopped).toBe(false);
+		expect(parsed.serverStopped).toBe(false);
+		expect(parsed.nothingToStop).toBe(true);
+	});
+
+	it("outputs JSON with coordinatorStopped=true when coordinator stops", async () => {
+		const deps: DownDeps = {
+			_runCommand: makeRunCommand({
+				"legio coordinator stop": COORD_STOP_OK,
+				"legio server stop": SERVER_NOT_RUNNING,
+			}),
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand(["--json"], deps);
+
+		const parsed = JSON.parse(capturedStdout.trim()) as {
+			coordinatorStopped: boolean;
+			serverStopped: boolean;
+			nothingToStop: boolean;
+		};
+		expect(parsed.coordinatorStopped).toBe(true);
+		expect(parsed.serverStopped).toBe(false);
+		expect(parsed.nothingToStop).toBe(false);
+	});
+
+	it("outputs JSON with serverStopped=true when server stops", async () => {
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") return COORD_STOP_FAIL;
+				if (cmd[0] === "legio" && cmd[1] === "server") return SERVER_STOP_OK;
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand(["--json"], deps);
+
+		const parsed = JSON.parse(capturedStdout.trim()) as {
+			coordinatorStopped: boolean;
+			serverStopped: boolean;
+			nothingToStop: boolean;
+		};
+		expect(parsed.coordinatorStopped).toBe(false);
+		expect(parsed.serverStopped).toBe(true);
+		expect(parsed.nothingToStop).toBe(false);
+	});
+
+	it("is graceful when coordinator stop fails (does not throw)", async () => {
+		const deps: DownDeps = {
+			_runCommand: makeRunCommand({
+				"legio coordinator stop": COORD_STOP_FAIL,
+				"legio server stop": SERVER_NOT_RUNNING,
+			}),
+			_projectRoot: "/tmp/test-project",
+		};
+
+		// Should not throw — graceful no-op
+		await expect(downCommand([], deps)).resolves.toBeUndefined();
+		expect(capturedStdout).toContain("Nothing to stop");
+	});
+
+	it("stops coordinator before attempting to stop server", async () => {
+		const order: string[] = [];
+		const deps: DownDeps = {
+			_runCommand: async (cmd) => {
+				if (cmd[0] === "legio" && cmd[1] === "coordinator") {
+					order.push("coordinator");
+					return COORD_STOP_OK;
+				}
+				if (cmd[0] === "legio" && cmd[1] === "server") {
+					order.push("server");
+					return SERVER_STOP_OK;
+				}
+				return { stdout: "", stderr: "unexpected", exitCode: 1 };
+			},
+			_projectRoot: "/tmp/test-project",
+		};
+
+		await downCommand([], deps);
+
+		expect(order[0]).toBe("coordinator");
+		expect(order[1]).toBe("server");
+	});
+});

package/src/commands/down.ts

@@ -0,0 +1,124 @@
+/**
+ * CLI command: legio down
+ *
+ * Single command to cleanly stop the full legio stack:
+ * 1. Stop coordinator (if running) via legio coordinator stop
+ *    This also stops the watchdog and monitor agents.
+ * 2. Stop gateway (if running) via legio gateway stop
+ * 3. Stop server (if running) via legio server stop
+ *
+ * Running legio down when nothing is running prints "Nothing to stop".
+ */
+
+import { spawn } from "node:child_process";
+
+function hasFlag(args: string[], flag: string): boolean {
+	return args.includes(flag);
+}
+
+/**
+ * Run an external command and collect stdout/stderr + exit code.
+ */
+async function runCommand(
+	cmd: string[],
+	opts?: { cwd?: string },
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const [command, ...args] = cmd;
+	if (!command) {
+		return { stdout: "", stderr: "Empty command", exitCode: 1 };
+	}
+	return new Promise((resolve) => {
+		const proc = spawn(command, args, {
+			cwd: opts?.cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const stdoutChunks: Buffer[] = [];
+		const stderrChunks: Buffer[] = [];
+		proc.stdout?.on("data", (chunk: Buffer) => stdoutChunks.push(chunk));
+		proc.stderr?.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
+		proc.on("close", (code) => {
+			resolve({
+				stdout: Buffer.concat(stdoutChunks).toString(),
+				stderr: Buffer.concat(stderrChunks).toString(),
+				exitCode: code ?? 1,
+			});
+		});
+	});
+}
+
+/** Dependency injection interface for testing. */
+export interface DownDeps {
+	_runCommand?: (
+		cmd: string[],
+		opts?: { cwd?: string },
+	) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
+	_projectRoot?: string;
+}
+
+const DOWN_HELP = `legio down — Stop the full legio stack
+
+Usage: legio down [options]
+
+Options:
+  --json         JSON output
+  --help, -h     Show this help
+
+legio down stops the coordinator (including watchdog and monitor), the
+gateway agent, and the server. Running legio down when nothing is running
+is a safe no-op.`;
+
+/**
+ * Entry point for \`legio down [options]\`.
+ *
+ * @param args - CLI arguments after "down"
+ * @param deps - Optional dependency injection for testing
+ */
+export async function downCommand(args: string[], deps: DownDeps = {}): Promise<void> {
+	if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+		process.stdout.write(`${DOWN_HELP}\n`);
+		return;
+	}
+
+	const json = hasFlag(args, "--json");
+	const run = deps._runCommand ?? runCommand;
+	const projectRoot = deps._projectRoot ?? process.cwd();
+
+	let coordinatorStopped = false;
+	let gatewayStopped = false;
+	let serverStopped = false;
+
+	// 1. Stop coordinator (if running) — also stops watchdog + monitor
+	const coordStop = await run(["legio", "coordinator", "stop"], { cwd: projectRoot });
+	if (coordStop.exitCode === 0) {
+		coordinatorStopped = true;
+		if (!json && coordStop.stdout) process.stdout.write(coordStop.stdout);
+	}
+	// Non-zero exit means coordinator was not running — that's fine, not an error.
+
+	// 2. Stop gateway (if running) — non-fatal if not running
+	const gatewayStop = await run(["legio", "gateway", "stop"], { cwd: projectRoot });
+	if (gatewayStop.exitCode === 0) {
+		gatewayStopped = true;
+		if (!json && gatewayStop.stdout) process.stdout.write(gatewayStop.stdout);
+	}
+	// Non-zero exit means gateway was not running — that's fine, not an error.
+
+	// 3. Stop server — delegate all PID checking to `legio server stop`
+	const serverStop = await run(["legio", "server", "stop"], { cwd: projectRoot });
+	if (serverStop.exitCode === 0 && !serverStop.stdout.includes("not running")) {
+		serverStopped = true;
+		if (!json && serverStop.stdout) process.stdout.write(serverStop.stdout);
+	}
+
+	const nothingToStop = !coordinatorStopped && !gatewayStopped && !serverStopped;
+
+	if (json) {
+		process.stdout.write(
+			`${JSON.stringify({ coordinatorStopped, gatewayStopped, serverStopped, nothingToStop })}\n`,
+		);
+	} else if (nothingToStop) {
+		process.stdout.write("Nothing to stop\n");
+	} else {
+		process.stdout.write("Legio stack stopped\n");
+	}
+}