@katyella/legio 0.1.3 → 0.2.0

package/src/commands/watch.test.ts

@@ -1,152 +0,0 @@
-import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { watchCommand } from "./watch.ts";
-
-/**
- * Tests for `legio watch` command.
- *
- * IMPORTANT: We CANNOT test the actual daemon loop (it would hang the test).
- * Focus on:
- * - Help output (safe, returns immediately)
- * - Background mode: already-running detection
- * - Background mode: stale PID cleanup
- *
- * We do NOT test:
- * - Foreground mode (blocks forever with await new Promise(() => {}))
- * - Actual health check loop behavior
- */
-
-describe("watchCommand", () => {
-	let chunks: string[];
-	let stderrChunks: string[];
-	let originalWrite: typeof process.stdout.write;
-	let originalStderrWrite: typeof process.stderr.write;
-	let tempDir: string;
-	let originalCwd: string;
-	let originalExitCode: string | number | null | undefined;
-
-	beforeEach(async () => {
-		// Spy on stdout
-		chunks = [];
-		originalWrite = process.stdout.write;
-		process.stdout.write = ((chunk: string) => {
-			chunks.push(chunk);
-			return true;
-		}) as typeof process.stdout.write;
-
-		// Spy on stderr
-		stderrChunks = [];
-		originalStderrWrite = process.stderr.write;
-		process.stderr.write = ((chunk: string) => {
-			stderrChunks.push(chunk);
-			return true;
-		}) as typeof process.stderr.write;
-
-		// Save original exitCode
-		originalExitCode = process.exitCode;
-		process.exitCode = 0;
-
-		// Create temp dir with .legio/config.yaml structure
-		tempDir = await mkdtemp(join(tmpdir(), "watch-test-"));
-		const legioDir = join(tempDir, ".legio");
-		await mkdir(legioDir, { recursive: true });
-		await writeFile(
-			join(legioDir, "config.yaml"),
-			`project:\n  name: test\n  root: ${tempDir}\n  canonicalBranch: main\n`,
-		);
-
-		// Change to temp dir so loadConfig() works
-		originalCwd = process.cwd();
-		process.chdir(tempDir);
-	});
-
-	afterEach(async () => {
-		process.stdout.write = originalWrite;
-		process.stderr.write = originalStderrWrite;
-		process.exitCode = originalExitCode;
-		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
-	});
-
-	function output(): string {
-		return chunks.join("");
-	}
-
-	function stderr(): string {
-		return stderrChunks.join("");
-	}
-
-	test("--help flag shows help text with key info", async () => {
-		await watchCommand(["--help"]);
-		const out = output();
-
-		expect(out).toContain("legio watch");
-		expect(out).toContain("--interval");
-		expect(out).toContain("--background");
-		expect(out).toContain("Tier 0");
-	});
-
-	test("-h flag shows help text", async () => {
-		await watchCommand(["-h"]);
-		const out = output();
-
-		expect(out).toContain("legio watch");
-		expect(out).toContain("Tier 0");
-	});
-
-	test("background mode: already running detection", async () => {
-		// Write a PID file with a running process (use our own PID)
-		const pidFilePath = join(tempDir, ".legio", "watchdog.pid");
-		await writeFile(pidFilePath, `${process.pid}\n`);
-
-		// Try to start in background mode — should fail with "already running"
-		await watchCommand(["--background"]);
-
-		const err = stderr();
-		expect(err).toContain("already running");
-		expect(err).toContain(`${process.pid}`);
-		expect(process.exitCode).toBe(1);
-	});
-
-	test("background mode: stale PID cleanup", async () => {
-		// Write a PID file with a non-running process (999999 is very unlikely to exist)
-		const pidFilePath = join(tempDir, ".legio", "watchdog.pid");
-		await writeFile(pidFilePath, "999999\n");
-
-		// Verify the stale PID file exists before the test
-		const fileBeforeExists = await access(pidFilePath).then(
-			() => true,
-			() => false,
-		);
-		expect(fileBeforeExists).toBe(true);
-
-		// Try to start in background mode
-		// This will clean up the stale PID file, then attempt to spawn.
-		// The spawn will fail because there's no real legio binary in test env,
-		// but the important part is that the stale PID file gets removed.
-		try {
-			await watchCommand(["--background"]);
-		} catch {
-			// Expected to fail when trying to spawn — that's OK
-		}
-
-		// The stale PID file should have been removed during the check
-		// (Even if the spawn itself failed, the cleanup happens before spawn)
-		// Actually, looking at the code: if existingPid is not null but not running,
-		// it removes the PID file. Then it tries to spawn. So the file should be gone
-		// OR replaced with a new PID.
-
-		// Let's check: the file should either not exist, OR contain a different PID
-		const fileAfterExists = await access(pidFilePath).then(
-			() => true,
-			() => false,
-		);
-		if (fileAfterExists) {
-			const content = await readFile(pidFilePath, "utf-8");
-			expect(content.trim()).not.toBe("999999");
-		}
-		// If it doesn't exist, that's also valid (spawn failed before writing new PID)
-	});
-});

package/src/commands/watch.ts

@@ -1,238 +0,0 @@
-/**
- * CLI command: legio watch [--interval <ms>] [--background]
- *
- * Starts the Tier 0 mechanical watchdog daemon. Foreground mode shows real-time status.
- * Background mode spawns a detached process via node:child_process and writes a PID file.
- * Interval configurable, default 30000ms.
- */
-
-import { spawn } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { loadConfig } from "../config.ts";
-import { LegioError } from "../errors.ts";
-import type { HealthCheck } from "../types.ts";
-import { startDaemon } from "../watchdog/daemon.ts";
-import { isProcessRunning } from "../watchdog/health.ts";
-
-/**
- * Parse a named flag value from args.
- */
-function getFlag(args: string[], flag: string): string | undefined {
-	const idx = args.indexOf(flag);
-	if (idx === -1 || idx + 1 >= args.length) {
-		return undefined;
-	}
-	return args[idx + 1];
-}
-
-function hasFlag(args: string[], flag: string): boolean {
-	return args.includes(flag);
-}
-
-/**
- * Format a health check for display.
- */
-function formatCheck(check: HealthCheck): string {
-	const actionIcon =
-		check.action === "terminate"
-			? "💀"
-			: check.action === "escalate"
-				? "⚠️"
-				: check.action === "investigate"
-					? "🔍"
-					: "✅";
-	const pidLabel = check.pidAlive === null ? "n/a" : check.pidAlive ? "up" : "down";
-	let line = `${actionIcon} ${check.agentName}: ${check.state} (tmux=${check.tmuxAlive ? "up" : "down"}, pid=${pidLabel})`;
-	if (check.reconciliationNote) {
-		line += ` [${check.reconciliationNote}]`;
-	}
-	return line;
-}
-
-// isProcessRunning is imported from ../watchdog/health.ts (ZFC shared utility)
-
-/**
- * Read the PID from the watchdog PID file.
- * Returns null if the file doesn't exist or can't be parsed.
- */
-async function readPidFile(pidFilePath: string): Promise<number | null> {
-	try {
-		const text = await readFile(pidFilePath, "utf-8");
-		const pid = Number.parseInt(text.trim(), 10);
-		if (Number.isNaN(pid) || pid <= 0) {
-			return null;
-		}
-		return pid;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Write a PID to the watchdog PID file.
- */
-async function writePidFile(pidFilePath: string, pid: number): Promise<void> {
-	await writeFile(pidFilePath, `${pid}\n`);
-}
-
-/**
- * Remove the watchdog PID file.
- */
-async function removePidFile(pidFilePath: string): Promise<void> {
-	const { unlink } = await import("node:fs/promises");
-	try {
-		await unlink(pidFilePath);
-	} catch {
-		// File may already be gone — not an error
-	}
-}
-
-/**
- * Resolve the path to the legio binary for re-launching.
- * Uses `which legio` first, then falls back to process.argv.
- */
-async function resolveLegioBin(): Promise<string> {
-	try {
-		const result = await new Promise<{ exitCode: number; stdout: string }>((resolve) => {
-			const proc = spawn("which", ["legio"], { stdio: ["ignore", "pipe", "pipe"] });
-			const stdoutChunks: Buffer[] = [];
-			proc.stdout?.on("data", (chunk: Buffer) => stdoutChunks.push(chunk));
-			proc.on("close", (code: number | null) => {
-				resolve({ exitCode: code ?? 1, stdout: Buffer.concat(stdoutChunks).toString("utf-8") });
-			});
-		});
-		if (result.exitCode === 0) {
-			const binPath = result.stdout.trim();
-			if (binPath.length > 0) {
-				return binPath;
-			}
-		}
-	} catch {
-		// which not available or legio not on PATH
-	}
-
-	// Fallback: use the script that's currently running (process.argv[1])
-	const scriptPath = process.argv[1];
-	if (scriptPath) {
-		return scriptPath;
-	}
-
-	throw new LegioError("Cannot resolve legio binary path for background launch", "WATCH_ERROR");
-}
-
-/**
- * Entry point for `legio watch [--interval <ms>] [--background]`.
- */
-const WATCH_HELP = `legio watch — Start Tier 0 mechanical watchdog daemon
-
-Usage: legio watch [--interval <ms>] [--background]
-
-Tier numbering:
-  Tier 0  Mechanical daemon (heartbeat, tmux/pid liveness) — this command
-  Tier 1  Triage agent (ephemeral AI analysis of stalled agents)
-  Tier 2  Monitor agent (continuous patrol — not yet implemented)
-  Tier 3  Supervisor monitors (per-project)
-
-Options:
-  --interval <ms>    Health check interval in milliseconds (default: from config)
-  --background       Daemonize (run in background)
-  --help, -h         Show this help`;
-
-export async function watchCommand(args: string[]): Promise<void> {
-	if (args.includes("--help") || args.includes("-h")) {
-		process.stdout.write(`${WATCH_HELP}\n`);
-		return;
-	}
-
-	const intervalStr = getFlag(args, "--interval");
-	const background = hasFlag(args, "--background");
-
-	const cwd = process.cwd();
-	const config = await loadConfig(cwd);
-
-	const intervalMs = intervalStr
-		? Number.parseInt(intervalStr, 10)
-		: config.watchdog.tier0IntervalMs;
-
-	const zombieThresholdMs = config.watchdog.zombieThresholdMs;
-	const pidFilePath = join(config.project.root, ".legio", "watchdog.pid");
-
-	if (background) {
-		// Check if a watchdog is already running
-		const existingPid = await readPidFile(pidFilePath);
-		if (existingPid !== null && isProcessRunning(existingPid)) {
-			process.stderr.write(
-				`Error: Watchdog already running (PID: ${existingPid}). ` +
-					`Kill it first or remove ${pidFilePath}\n`,
-			);
-			process.exitCode = 1;
-			return;
-		}
-
-		// Clean up stale PID file if process is no longer running
-		if (existingPid !== null) {
-			await removePidFile(pidFilePath);
-		}
-
-		// Build the args for the child process, forwarding --interval but not --background
-		const childArgs: string[] = ["watch"];
-		if (intervalStr) {
-			childArgs.push("--interval", intervalStr);
-		}
-
-		// Resolve the legio binary path
-		const legioBin = await resolveLegioBin();
-
-		// Spawn a detached background process running `legio watch` (without --background)
-		const child = spawn(process.execPath, ["--import", "tsx", legioBin, ...childArgs], {
-			cwd,
-			stdio: "ignore",
-			detached: true,
-		});
-
-		// Unref the child so the parent can exit without waiting for it
-		child.unref();
-
-		const childPid = child.pid ?? 0;
-
-		// Write PID file for later cleanup
-		await writePidFile(pidFilePath, childPid);
-
-		process.stdout.write(
-			`Watchdog started in background (PID: ${childPid}, interval: ${intervalMs}ms)\n`,
-		);
-		process.stdout.write(`PID file: ${pidFilePath}\n`);
-		return;
-	}
-
-	// Foreground mode: show real-time health checks
-	process.stdout.write(`Watchdog running (interval: ${intervalMs}ms)\n`);
-	process.stdout.write("Press Ctrl+C to stop.\n\n");
-
-	// Write PID file so `--background` check and external tools can find us
-	await writePidFile(pidFilePath, process.pid);
-
-	const { stop } = startDaemon({
-		root: config.project.root,
-		intervalMs,
-		zombieThresholdMs,
-		onHealthCheck(check) {
-			const timestamp = new Date().toISOString().slice(11, 19);
-			process.stdout.write(`[${timestamp}] ${formatCheck(check)}\n`);
-		},
-	});
-
-	// Keep running until interrupted
-	process.on("SIGINT", () => {
-		stop();
-		// Clean up PID file on graceful shutdown
-		removePidFile(pidFilePath).finally(() => {
-			process.stdout.write("\nWatchdog stopped.\n");
-			process.exit(0);
-		});
-	});
-
-	// Block forever
-	await new Promise(() => {});
-}

package/src/test-helpers.test.ts

@@ -1,97 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { afterEach, describe, expect, test } from "vitest";
-import { cleanupTempDir, commitFile, createTempGitRepo, runGitInDir } from "./test-helpers.ts";
-
-describe("createTempGitRepo", () => {
-	let repoDir: string | undefined;
-
-	afterEach(async () => {
-		if (repoDir) {
-			await cleanupTempDir(repoDir);
-			repoDir = undefined;
-		}
-	});
-
-	test("creates a directory with an initialized git repo", async () => {
-		repoDir = await createTempGitRepo();
-
-		expect(existsSync(join(repoDir, ".git"))).toBe(true);
-	});
-
-	test("repo has at least one commit (HEAD exists)", async () => {
-		repoDir = await createTempGitRepo();
-
-		// runGitInDir throws on non-zero exit, resolving means exit code was 0
-		await runGitInDir(repoDir, ["rev-parse", "HEAD"]);
-		expect(true).toBe(true);
-	});
-
-	test("repo is on a branch (not detached HEAD)", async () => {
-		repoDir = await createTempGitRepo();
-
-		const stdout = await runGitInDir(repoDir, ["symbolic-ref", "HEAD"]);
-		expect(stdout.trim()).toMatch(/^refs\/heads\//);
-	});
-});
-
-describe("commitFile", () => {
-	let repoDir: string | undefined;
-
-	afterEach(async () => {
-		if (repoDir) {
-			await cleanupTempDir(repoDir);
-			repoDir = undefined;
-		}
-	});
-
-	test("creates file and commits it", async () => {
-		repoDir = await createTempGitRepo();
-
-		await commitFile(repoDir, "hello.txt", "world");
-
-		// File exists with correct content
-		const content = await readFile(join(repoDir, "hello.txt"), "utf-8");
-		expect(content).toBe("world");
-
-		// Git log shows the commit
-		const stdout = await runGitInDir(repoDir, ["log", "--oneline"]);
-		expect(stdout).toContain("add hello.txt");
-	});
-
-	test("creates nested directories as needed", async () => {
-		repoDir = await createTempGitRepo();
-
-		await commitFile(repoDir, "src/deep/nested/file.ts", "export const x = 1;");
-
-		expect(existsSync(join(repoDir, "src/deep/nested/file.ts"))).toBe(true);
-	});
-
-	test("uses custom commit message when provided", async () => {
-		repoDir = await createTempGitRepo();
-
-		await commitFile(repoDir, "readme.md", "# Hi", "docs: add readme");
-
-		const stdout = await runGitInDir(repoDir, ["log", "--oneline", "-1"]);
-		expect(stdout).toContain("docs: add readme");
-	});
-});
-
-describe("cleanupTempDir", () => {
-	test("removes directory and all contents", async () => {
-		const repoDir = await createTempGitRepo();
-		await commitFile(repoDir, "file.txt", "data");
-
-		expect(existsSync(repoDir)).toBe(true);
-
-		await cleanupTempDir(repoDir);
-
-		expect(existsSync(repoDir)).toBe(false);
-	});
-
-	test("does not throw when directory does not exist", async () => {
-		await cleanupTempDir("/tmp/legio-nonexistent-test-dir-12345");
-		// No error thrown = pass
-	});
-});