@ag-eco/agentplate-cli 0.13.0

package/src/utils/process-scan.ts

@@ -0,0 +1,76 @@
+/**
+ * Process-table scanning helpers.
+ *
+ * Used to detect runaway daemon processes that are not tracked by a PID file —
+ * for example, the multi-`ap watch` situation observed on 2026-04-30 where
+ * three concurrent watchdogs were running because earlier releases had no
+ * PID-file exclusion lock.
+ *
+ * Implementation note: `ps` is used directly because we only need to find
+ * processes by command-line substring, and Bun has no built-in process-table
+ * API. The `ps -o pid=,command=` form is portable across macOS (BSD) and
+ * Linux (procps) for the columns we read.
+ */
+
+export interface WatchdogProcess {
+	pid: number;
+	/** The full command line as reported by `ps`. */
+	command: string;
+}
+
+/**
+ * Find running processes that look like an `ap watch` daemon.
+ *
+ * Matches on the command-line substring `ap watch` (the daemon spawn form)
+ * and excludes the current process so callers do not accidentally treat
+ * themselves as a foreign daemon.
+ *
+ * Returns an empty list if `ps` is unavailable or fails — callers must not
+ * rely on this for correctness, only for diagnostics and `--kill-others`.
+ */
+export async function findRunningWatchdogProcesses(): Promise<WatchdogProcess[]> {
+	const proc = Bun.spawn(["ps", "-A", "-o", "pid=,command="], {
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) {
+		return [];
+	}
+	const text = await new Response(proc.stdout).text();
+	const ownPid = process.pid;
+	const out: WatchdogProcess[] = [];
+
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (line === "") continue;
+
+		// `ps -o pid=,command=` outputs: `   1234 /path/to/binary args...`
+		// (leading whitespace is allowed, then PID, then a single space, then
+		// the rest of the command).
+		const match = line.match(/^(\d+)\s+(.+)$/);
+		if (!match) continue;
+		const pidStr = match[1];
+		const command = match[2];
+		if (pidStr === undefined || command === undefined) continue;
+		const pid = Number.parseInt(pidStr, 10);
+		if (!Number.isFinite(pid) || pid <= 0) continue;
+		if (pid === ownPid) continue;
+
+		// Match the spawn form: `bun run /path/to/ap watch`. We also tolerate
+		// direct invocation `agentplate watch` and `ap watch`.
+		if (!isWatchdogCommand(command)) continue;
+
+		out.push({ pid, command });
+	}
+
+	return out;
+}
+
+function isWatchdogCommand(command: string): boolean {
+	// Anchor on a `watch` token preceded by an `ap` or `agentplate` token.
+	// Avoids false positives like "watch ap.log" or unrelated `watch` commands.
+	if (!/\bwatch\b/.test(command)) return false;
+	if (/\b(ap|agentplate)\b[^\n]*\bwatch\b/.test(command)) return true;
+	return false;
+}

package/src/utils/time.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { parseRelativeTime } from "./time.ts";
+
+describe("parseRelativeTime", () => {
+	test("parses '30s' as ~30 seconds ago", () => {
+		const before = Date.now();
+		const result = parseRelativeTime("30s");
+		const after = Date.now();
+		expect(result.getTime()).toBeGreaterThanOrEqual(before - 30 * 1000 - 50);
+		expect(result.getTime()).toBeLessThanOrEqual(after - 30 * 1000 + 50);
+	});
+
+	test("parses '5m' as ~5 minutes ago", () => {
+		const before = Date.now();
+		const result = parseRelativeTime("5m");
+		const expected = before - 5 * 60 * 1000;
+		expect(Math.abs(result.getTime() - expected)).toBeLessThan(100);
+	});
+
+	test("parses '2h' as ~2 hours ago", () => {
+		const before = Date.now();
+		const result = parseRelativeTime("2h");
+		const expected = before - 2 * 60 * 60 * 1000;
+		expect(Math.abs(result.getTime() - expected)).toBeLessThan(100);
+	});
+
+	test("parses '1d' as ~1 day ago", () => {
+		const before = Date.now();
+		const result = parseRelativeTime("1d");
+		const expected = before - 24 * 60 * 60 * 1000;
+		expect(Math.abs(result.getTime() - expected)).toBeLessThan(100);
+	});
+
+	test("parses ISO 8601 timestamp", () => {
+		const result = parseRelativeTime("2026-01-15T10:30:00.000Z");
+		expect(result.toISOString()).toBe("2026-01-15T10:30:00.000Z");
+	});
+
+	test("returns invalid Date for garbage input", () => {
+		const result = parseRelativeTime("not-a-time");
+		expect(Number.isNaN(result.getTime())).toBe(true);
+	});
+});

package/src/utils/time.ts

@@ -0,0 +1,37 @@
+/**
+ * Time parsing utilities.
+ */
+
+/**
+ * Parse relative time formats like "1h", "30m", "2d", "10s" into a Date object.
+ * Falls back to parsing as ISO 8601 if not in relative format.
+ */
+export function parseRelativeTime(timeStr: string): Date {
+	const relativeMatch = /^(\d+)(s|m|h|d)$/.exec(timeStr);
+	if (relativeMatch) {
+		const value = Number.parseInt(relativeMatch[1] ?? "0", 10);
+		const unit = relativeMatch[2];
+		const now = Date.now();
+		let offsetMs = 0;
+
+		switch (unit) {
+			case "s":
+				offsetMs = value * 1000;
+				break;
+			case "m":
+				offsetMs = value * 60 * 1000;
+				break;
+			case "h":
+				offsetMs = value * 60 * 60 * 1000;
+				break;
+			case "d":
+				offsetMs = value * 24 * 60 * 60 * 1000;
+				break;
+		}
+
+		return new Date(now - offsetMs);
+	}
+
+	// Not a relative format, treat as ISO 8601
+	return new Date(timeStr);
+}

package/src/utils/version.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { fetchLatestVersion, getCurrentVersion, getInstalledVersion } from "./version.ts";
+
+describe("getCurrentVersion", () => {
+	test("returns a semver string", async () => {
+		const version = await getCurrentVersion();
+		expect(version).toMatch(/^\d+\.\d+\.\d+/);
+	});
+});
+
+describe("fetchLatestVersion", () => {
+	test("fetches a semver string from npm registry", async () => {
+		const version = await fetchLatestVersion("@ag-eco/agentplate-cli");
+		expect(version).toMatch(/^\d+\.\d+\.\d+/);
+	});
+
+	test("throws for nonexistent package", async () => {
+		await expect(fetchLatestVersion("@nonexistent/package-xyz-999")).rejects.toThrow();
+	});
+});
+
+describe("getInstalledVersion", () => {
+	test("returns version for an installed CLI (bun)", async () => {
+		const version = await getInstalledVersion("bun");
+		expect(version).not.toBeNull();
+		expect(version).toMatch(/^\d+\.\d+\.\d+/);
+	});
+
+	test("returns null for nonexistent CLI", async () => {
+		const version = await getInstalledVersion("nonexistent-cli-xyz-999");
+		expect(version).toBeNull();
+	});
+});

package/src/utils/version.ts

@@ -0,0 +1,70 @@
+/**
+ * Version detection and npm registry utilities.
+ */
+
+/**
+ * Get the current installed version of agentplate from package.json.
+ */
+export 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;
+}
+
+/**
+ * Fetch the latest published version of an npm package from the registry.
+ */
+export 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;
+}
+
+/**
+ * Get the installed version of a CLI tool by running `--version`.
+ * Tries `--version --json` first, then falls back to plain text.
+ */
+export async function getInstalledVersion(cli: string): Promise<string | null> {
+	// Try --version --json first
+	try {
+		const proc = Bun.spawn([cli, "--version", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			try {
+				const data = JSON.parse(stdout.trim()) as { version?: string };
+				if (data.version) return data.version;
+			} catch {
+				// Not valid JSON, fall through to plain text
+			}
+		}
+	} catch {
+		// CLI not found — fall through to plain text fallback
+	}
+
+	// Fallback: --version plain text
+	try {
+		const proc = Bun.spawn([cli, "--version"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			const match = stdout.match(/(\d+\.\d+\.\d+)/);
+			if (match?.[1]) return match[1];
+		}
+	} catch {
+		// CLI not found
+	}
+
+	return null;
+}

package/src/version.ts

@@ -0,0 +1,5 @@
+/**
+ * Single source of truth for the package version, shared by every bundled bin
+ * (ap/agentplate, lm/loam, sr, tl). Updated by scripts/version-bump.ts.
+ */
+export const VERSION = "0.13.0";