@os-eco/overstory-cli 0.6.8 → 0.6.10

package/src/commands/upgrade.ts

@@ -0,0 +1,259 @@
+/**
+ * CLI command: ov upgrade [--check] [--all] [--json]
+ *
+ * Upgrades overstory (and optionally all os-eco tools) to their latest npm versions.
+ * --check: Compare current vs latest without installing.
+ * --all:   Upgrade all 4 ecosystem tools (overstory, mulch, seeds, canopy).
+ * --json:  Output result as JSON envelope.
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { muted, printError, printHint, printSuccess, printWarning } from "../logging/color.ts";
+
+const OVERSTORY_PACKAGE = "@os-eco/overstory-cli";
+
+const ALL_PACKAGES = [
+	"@os-eco/overstory-cli",
+	"@os-eco/mulch-cli",
+	"@os-eco/seeds-cli",
+	"@os-eco/canopy-cli",
+] as const;
+
+export interface UpgradeOptions {
+	check?: boolean;
+	all?: boolean;
+	json?: boolean;
+}
+
+async function getCurrentVersion(): Promise<string> {
+	const pkgPath = new URL("../../package.json", import.meta.url);
+	const pkg = JSON.parse(await Bun.file(pkgPath).text()) as { version: string };
+	return pkg.version;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+	if (!res.ok) {
+		throw new Error(
+			`Failed to fetch npm registry for ${packageName}: ${res.status} ${res.statusText}`,
+		);
+	}
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+async function runInstall(packageName: string): Promise<number> {
+	const proc = Bun.spawn(["bun", "install", "-g", `${packageName}@latest`], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	return proc.exited;
+}
+
+interface PackageResult {
+	package: string;
+	current: string;
+	latest: string;
+	upToDate: boolean;
+	updated: boolean;
+	error?: string;
+}
+
+async function upgradePackage(packageName: string): Promise<PackageResult> {
+	let latest: string;
+	try {
+		latest = await fetchLatestVersion(packageName);
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		return {
+			package: packageName,
+			current: "unknown",
+			latest: "unknown",
+			upToDate: false,
+			updated: false,
+			error,
+		};
+	}
+
+	const exitCode = await runInstall(packageName);
+	if (exitCode !== 0) {
+		return {
+			package: packageName,
+			current: "unknown",
+			latest,
+			upToDate: false,
+			updated: false,
+			error: `bun install failed with exit code ${exitCode}`,
+		};
+	}
+	return { package: packageName, current: "unknown", latest, upToDate: false, updated: true };
+}
+
+async function executeUpgradeSingle(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	let current: string;
+	let latest: string;
+	try {
+		[current, latest] = await Promise.all([
+			getCurrentVersion(),
+			fetchLatestVersion(OVERSTORY_PACKAGE),
+		]);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("upgrade", msg);
+		} else {
+			printError("Failed to check for updates", msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	const upToDate = current === latest;
+
+	if (checkOnly) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate });
+		} else if (upToDate) {
+			printSuccess("Already up to date", current);
+		} else {
+			printWarning(`Update available: ${current} → ${latest}`);
+			printHint("Run 'ov upgrade' to install the latest version");
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	if (upToDate) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate: true, updated: false });
+		} else {
+			printSuccess("Already up to date", current);
+		}
+		return;
+	}
+
+	if (!json) {
+		process.stdout.write(
+			`${muted(`Upgrading ${OVERSTORY_PACKAGE} from ${current} to ${latest}...`)}\n`,
+		);
+	}
+
+	const exitCode = await runInstall(OVERSTORY_PACKAGE);
+
+	if (exitCode !== 0) {
+		if (json) {
+			jsonError("upgrade", `bun install failed with exit code ${exitCode}`);
+		} else {
+			printError("Upgrade failed", `bun install exited with code ${exitCode}`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		jsonOutput("upgrade", { current, latest, upToDate: false, updated: true });
+	} else {
+		printSuccess("Upgraded to", latest);
+	}
+}
+
+async function executeUpgradeAll(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	// Fetch all latest versions in parallel
+	const latestResults = await Promise.allSettled(
+		ALL_PACKAGES.map((pkg) => fetchLatestVersion(pkg)),
+	);
+
+	if (checkOnly) {
+		// For --check --all, we just report status without installing
+		const results: Array<{ package: string; latest: string; error?: string }> = [];
+		let anyOutdated = false;
+
+		for (let i = 0; i < ALL_PACKAGES.length; i++) {
+			const pkg = ALL_PACKAGES[i] as string;
+			const result = latestResults[i];
+			if (result === undefined || result.status === "rejected") {
+				const error =
+					result?.status === "rejected"
+						? result.reason instanceof Error
+							? result.reason.message
+							: String(result.reason)
+						: "unknown error";
+				results.push({ package: pkg, latest: "unknown", error });
+				anyOutdated = true;
+			} else {
+				results.push({ package: pkg, latest: result.value });
+				// We can't easily get current versions for all tools without spawning them
+				// so for --all --check we just report latest versions available
+			}
+		}
+
+		if (json) {
+			jsonOutput("upgrade", { packages: results });
+		} else {
+			for (const r of results) {
+				if (r.error) {
+					printError(`${r.package}`, r.error);
+				} else {
+					process.stdout.write(`  ${r.package} → ${r.latest}\n`);
+				}
+			}
+			if (anyOutdated) process.exitCode = 1;
+		}
+		return;
+	}
+
+	// Install all packages
+	if (!json) {
+		process.stdout.write(`${muted("Upgrading all os-eco tools to latest...")}\n`);
+	}
+
+	const results: PackageResult[] = await Promise.all(
+		ALL_PACKAGES.map((pkg) => upgradePackage(pkg)),
+	);
+
+	const anyError = results.some((r) => r.error !== undefined);
+
+	if (json) {
+		if (anyError) {
+			jsonError("upgrade", `One or more packages failed to upgrade`);
+		} else {
+			jsonOutput("upgrade", { packages: results, updated: true });
+		}
+	} else {
+		for (const r of results) {
+			if (r.error) {
+				printError(`Failed to upgrade ${r.package}`, r.error);
+			} else {
+				printSuccess(`Upgraded ${r.package} to`, r.latest);
+			}
+		}
+	}
+
+	if (anyError) process.exitCode = 1;
+}
+
+export async function executeUpgrade(opts: UpgradeOptions): Promise<void> {
+	if (opts.all) {
+		await executeUpgradeAll(opts);
+	} else {
+		await executeUpgradeSingle(opts);
+	}
+}
+
+export function createUpgradeCommand(): Command {
+	return new Command("upgrade")
+		.description("Upgrade overstory to the latest version from npm")
+		.option("--check", "Check for updates without installing")
+		.option("--all", "Upgrade all os-eco ecosystem tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: UpgradeOptions) => {
+			await executeUpgrade(opts);
+		});
+}

package/src/commands/watch.ts

@@ -10,6 +10,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { OverstoryError } from "../errors.ts";
+import { printError, printHint, printSuccess } from "../logging/color.ts";
 import type { HealthCheck } from "../types.ts";
 import { startDaemon } from "../watchdog/daemon.ts";
 import { isProcessRunning } from "../watchdog/health.ts";
@@ -130,9 +131,8 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		// 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`,
+			printError(
+				`Watchdog already running (PID: ${existingPid}). Kill it first or remove ${pidFilePath}`,
 			);
 			process.exitCode = 1;
 			return;
@@ -168,16 +168,14 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		// 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`);
+		printSuccess("Watchdog started in background", `PID: ${childPid}, interval: ${intervalMs}ms`);
+		printHint(`PID file: ${pidFilePath}`);
 		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");
+	printSuccess("Watchdog running", `interval: ${intervalMs}ms`);
+	printHint("Press Ctrl+C to stop.");
 
 	// Write PID file so `--background` check and external tools can find us
 	await writePidFile(pidFilePath, process.pid);
@@ -200,7 +198,7 @@ async function runWatch(opts: { interval?: string; background?: boolean }): Prom
 		stop();
 		// Clean up PID file on graceful shutdown
 		removePidFile(pidFilePath).finally(() => {
-			process.stdout.write("\nWatchdog stopped.\n");
+			printSuccess("Watchdog stopped.");
 			process.exit(0);
 		});
 	});

package/src/commands/worktree.test.ts

@@ -220,21 +220,27 @@ describe("worktreeCommand", () => {
 			await worktreeCommand(["list", "--json"]);
 			const out = output();
 
-			const parsed = JSON.parse(out.trim()) as Array<{
-				path: string;
-				branch: string;
-				head: string;
-				agentName: string | null;
-				state: string | null;
-				taskId: string | null;
-			}>;
-
-			expect(parsed).toHaveLength(1);
-			expect(parsed[0]?.path).toBe(worktreePath);
-			expect(parsed[0]?.branch).toBe("overstory/test-agent/task-1");
-			expect(parsed[0]?.agentName).toBe("test-agent");
-			expect(parsed[0]?.state).toBe("working");
-			expect(parsed[0]?.taskId).toBe("task-1");
+			const parsed = JSON.parse(out.trim()) as {
+				success: boolean;
+				command: string;
+				worktrees: Array<{
+					path: string;
+					branch: string;
+					head: string;
+					agentName: string | null;
+					state: string | null;
+					taskId: string | null;
+				}>;
+			};
+
+			expect(parsed.success).toBe(true);
+			expect(parsed.command).toBe("worktree list");
+			expect(parsed.worktrees).toHaveLength(1);
+			expect(parsed.worktrees[0]?.path).toBe(worktreePath);
+			expect(parsed.worktrees[0]?.branch).toBe("overstory/test-agent/task-1");
+			expect(parsed.worktrees[0]?.agentName).toBe("test-agent");
+			expect(parsed.worktrees[0]?.state).toBe("working");
+			expect(parsed.worktrees[0]?.taskId).toBe("task-1");
 		});
 
 		test("worktrees without sessions show unknown state", async () => {

package/src/commands/worktree.ts

@@ -10,6 +10,7 @@ import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
 import { printHint, printSuccess, printWarning } from "../logging/color.ts";
 import { createMailStore } from "../mail/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
@@ -50,7 +51,7 @@ async function handleList(root: string, json: boolean): Promise<void> {
 				taskId: session?.taskId ?? null,
 			};
 		});
-		process.stdout.write(`${JSON.stringify(entries, null, "\t")}\n`);
+		jsonOutput("worktree list", { worktrees: entries });
 		return;
 	}
 
@@ -238,9 +239,14 @@ async function handleClean(
 		}
 
 		if (json) {
-			process.stdout.write(
-				`${JSON.stringify({ cleaned, failed, skipped, pruned: pruneCount, mailPurged, seedsPreserved })}\n`,
-			);
+			jsonOutput("worktree clean", {
+				cleaned,
+				failed,
+				skipped,
+				pruned: pruneCount,
+				mailPurged,
+				seedsPreserved,
+			});
 		} else if (
 			cleaned.length === 0 &&
 			pruneCount === 0 &&

package/src/doctor/databases.test.ts

@@ -307,4 +307,42 @@ describe("checkDatabases", () => {
 		expect(integrityCheck?.status).toBe("fail");
 		expect(integrityCheck?.message).toContain("Failed to open or validate");
 	});
+
+	test("fix() enables WAL mode on database", () => {
+		// Create mail.db without WAL mode
+		const mailDb = new Database(join(tempDir, "mail.db"));
+		mailDb.exec(`
+			CREATE TABLE messages (
+				id TEXT PRIMARY KEY,
+				from_agent TEXT NOT NULL,
+				to_agent TEXT NOT NULL,
+				subject TEXT NOT NULL,
+				body TEXT NOT NULL,
+				type TEXT NOT NULL DEFAULT 'status',
+				priority TEXT NOT NULL DEFAULT 'normal',
+				thread_id TEXT,
+				payload TEXT,
+				read INTEGER NOT NULL DEFAULT 0,
+				created_at TEXT NOT NULL DEFAULT (datetime('now'))
+			)
+		`);
+		mailDb.close();
+
+		const checks = checkDatabases(mockConfig, tempDir) as DoctorCheck[];
+
+		const walCheck = checks.find((c) => c?.name === "mail.db WAL mode");
+		expect(walCheck?.status).toBe("warn");
+		expect(walCheck?.fix).toBeDefined();
+
+		const actions = walCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		expect((actions as string[]).some((a) => a.includes("WAL mode"))).toBe(true);
+		expect((actions as string[]).some((a) => a.includes("mail.db"))).toBe(true);
+
+		// Verify WAL mode is now enabled
+		const verifyDb = new Database(join(tempDir, "mail.db"));
+		const journalMode = verifyDb.prepare<{ journal_mode: string }, []>("PRAGMA journal_mode").get();
+		verifyDb.close();
+		expect(journalMode?.journal_mode?.toLowerCase()).toBe("wal");
+	});
 });

package/src/doctor/databases.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
 
@@ -187,6 +188,12 @@ export const checkDatabases: DoctorCheckFn = (_config, overstoryDir): DoctorChec
 					message: `Database ${dbSpec.name} is not using WAL mode`,
 					details: ["WAL mode improves concurrent access performance"],
 					fixable: true,
+					fix: () => {
+						const fixDb = new Database(dbPath);
+						fixDb.exec("PRAGMA journal_mode=WAL");
+						fixDb.close();
+						return [`Enabled WAL mode on ${dbSpec.name}`];
+					},
 				});
 			} else {
 				checks.push({
@@ -222,13 +229,3 @@ export const checkDatabases: DoctorCheckFn = (_config, overstoryDir): DoctorChec
 
 	return checks;
 };
-
-/** Helper to check if file exists (synchronous). */
-function existsSync(path: string): boolean {
-	try {
-		const { existsSync } = require("node:fs");
-		return existsSync(path);
-	} catch {
-		return false;
-	}
-}