agendex-cli 2.0.0 → 2.0.1

package/dist/cli.js

@@ -4473,6 +4473,158 @@ function spawnBrowser(command, args, options = {}) {
   child.unref();
 }
 
+// src/help.ts
+var COMMAND_WIDTH = 38;
+var FLAG_WIDTH = 18;
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  gray: "\x1B[90m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var HELP_GROUPS = [
+  {
+    title: "Quick start",
+    commands: [
+      {
+        command: "start",
+        description: "Start the background sync daemon",
+        examples: ["agendex", "agendex start"]
+      },
+      { command: "status", description: "Show local/cloud health and recommended next steps" },
+      {
+        command: "open",
+        description: "Open the Agendex dashboard in your browser",
+        examples: ["agendex open --url <self-hosted-url>"]
+      }
+    ]
+  },
+  {
+    title: "Cloud account",
+    commands: [
+      {
+        command: "login",
+        description: "Authenticate via browser OAuth",
+        examples: ["agendex login --url <self-hosted-url>"]
+      },
+      { command: "logout", description: "Clear the stored cloud token" },
+      { command: "view <url>", description: "Open a shared plan URL in your browser" }
+    ]
+  },
+  {
+    title: "Plan sources",
+    commands: [
+      { command: "configure", description: "Select which agents/adapters to index" },
+      {
+        command: "add-dir <path>",
+        description: "Add a custom directory to scan for plans",
+        examples: ["agendex add-dir ~/plans --live"]
+      },
+      { command: "remove-dir <path>", description: "Remove a custom plan directory" },
+      { command: "list-dirs", description: "List configured custom plan directories" }
+    ]
+  },
+  {
+    title: "Sync & upload",
+    commands: [
+      {
+        command: "sync",
+        description: "Run a one-shot scan and cloud sync",
+        examples: ["agendex sync --force"]
+      },
+      {
+        command: "upload <path>",
+        description: "Upload a single Markdown plan file",
+        examples: ["agendex upload plan.md --agent claude-code --open"]
+      }
+    ]
+  },
+  {
+    title: "Hooks & review",
+    commands: [
+      { command: "hooks status", description: "Show Claude Code, Codex, and Pi hook status" },
+      {
+        command: "hooks install <agent|all>",
+        description: "Install hook integration",
+        examples: ["agendex hooks install claude-code --preview"]
+      },
+      { command: "hooks uninstall <agent|all>", description: "Remove managed hook entries" },
+      { command: "review-plan --hook --agent <agent>", description: "Run hook-native plan review" }
+    ]
+  },
+  {
+    title: "Maintenance",
+    commands: [
+      { command: "cleanup", description: "Interactively remove cloud daemon records" },
+      { command: "cleanup --stale", description: "Auto-remove stale cloud daemon records" },
+      { command: "upgrade", description: "Upgrade the globally installed CLI" },
+      { command: "upgrade --force", description: "Reinstall latest even when up to date" },
+      { command: "help", description: "Show this help message" },
+      { command: "--version, -v", description: "Print CLI version" }
+    ]
+  }
+];
+var FLAGS = [
+  { flag: "--dev", description: "Use the dev environment (~/.agendex-dev config dir)" }
+];
+function supportsColor() {
+  if (process.env.NO_COLOR)
+    return false;
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0")
+    return true;
+  return Boolean(process.stdout.isTTY);
+}
+function paint(enabled, code, text) {
+  return enabled ? `${code}${text}${ANSI.reset}` : text;
+}
+function createStyles(color) {
+  return {
+    title: (text) => paint(color, `${ANSI.bold}${ANSI.cyan}`, text),
+    section: (text) => paint(color, ANSI.yellow, text),
+    command: (text) => paint(color, ANSI.green, text),
+    muted: (text) => paint(color, ANSI.gray, text)
+  };
+}
+function commandLine(styles, entry) {
+  return `    ${styles.command(entry.command.padEnd(COMMAND_WIDTH))}${entry.description}`;
+}
+function exampleLine(styles, examples) {
+  return `      ${styles.muted(examples.join("  |  "))}`;
+}
+function flagLine(styles, flag) {
+  return `  ${styles.command(flag.flag.padEnd(FLAG_WIDTH))}${flag.description}`;
+}
+function renderHelp(options) {
+  const styles = createStyles(options.color ?? supportsColor());
+  const lines = [];
+  lines.push(styles.title("Agendex: local coding-agent plan sync"));
+  lines.push(styles.muted(`CLI v${options.cliVersion}`));
+  lines.push("");
+  lines.push(`Usage: ${styles.command("agendex")} ${styles.muted("[OPTIONS] [COMMAND]")}`);
+  lines.push("");
+  lines.push(styles.section("Commands:"));
+  for (const group of HELP_GROUPS) {
+    lines.push(`  ${styles.section(`${group.title}:`)}`);
+    for (const command of group.commands) {
+      lines.push(commandLine(styles, command));
+      if (command.examples && command.examples.length > 0) {
+        lines.push(exampleLine(styles, command.examples));
+      }
+    }
+    lines.push("");
+  }
+  lines.push(styles.section("Flags:"));
+  for (const flag of FLAGS)
+    lines.push(flagLine(styles, flag));
+  lines.push("");
+  lines.push(styles.section("Tip:"));
+  lines.push(`  ${styles.muted("Run")} ${styles.command("agendex status")} ${styles.muted("to see daemon health, cloud sync state, and next steps.")}`);
+  return lines.join(`
+`);
+}
+
 // src/daemon.ts
 import { spawn as spawn2 } from "node:child_process";
 import { hostname as osHostname2 } from "node:os";
@@ -5676,6 +5828,254 @@ async function runHookReviewCommand(args) {
   return 1;
 }
 
+// src/status.ts
+var LABEL_WIDTH = 18;
+var ACTION_WIDTH = 26;
+var ANSI2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  gray: "\x1B[90m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m"
+};
+function supportsColor2() {
+  if (process.env.NO_COLOR)
+    return false;
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0")
+    return true;
+  return Boolean(process.stdout.isTTY);
+}
+function paint2(enabled, code, text) {
+  return enabled ? `${code}${text}${ANSI2.reset}` : text;
+}
+function createStyles2(color) {
+  return {
+    title: (text) => paint2(color, `${ANSI2.bold}${ANSI2.cyan}`, text),
+    section: (text) => paint2(color, ANSI2.yellow, text),
+    key: (text) => paint2(color, ANSI2.green, text),
+    value: (text) => text,
+    muted: (text) => paint2(color, ANSI2.gray, text),
+    status(kind, text) {
+      if (kind === "success")
+        return paint2(color, ANSI2.green, text);
+      if (kind === "warning")
+        return paint2(color, ANSI2.yellow, text);
+      if (kind === "danger")
+        return paint2(color, ANSI2.red, text);
+      if (kind === "info")
+        return paint2(color, ANSI2.blue, text);
+      return paint2(color, ANSI2.gray, text);
+    }
+  };
+}
+function badge(styles, kind, label) {
+  let icon = "•";
+  if (kind === "success")
+    icon = "✓";
+  else if (kind === "warning")
+    icon = "!";
+  else if (kind === "danger")
+    icon = "×";
+  return styles.status(kind, `${icon} ${label}`);
+}
+function isPresent(value) {
+  return value !== null && value !== undefined;
+}
+function row(styles, label, status, detail) {
+  const labelCell = styles.key(label.padEnd(LABEL_WIDTH));
+  const suffix = detail ? `  ${styles.muted(detail)}` : "";
+  return `  ${labelCell}${status}${suffix}`;
+}
+function actionRow(styles, command, description) {
+  return `  ${styles.key(command.padEnd(ACTION_WIDTH))}${description}`;
+}
+function listItem(styles, value) {
+  return `    ${styles.muted("•")} ${value}`;
+}
+function summarizeList(items, maxItems = 4) {
+  if (items.length === 0)
+    return "";
+  if (items.length <= maxItems)
+    return items.join(", ");
+  const visible = items.slice(0, maxItems).join(", ");
+  return `${visible} +${items.length - maxItems} more`;
+}
+function formatDuration(ms) {
+  const safeMs = Number.isFinite(ms) ? Math.max(0, Math.floor(ms)) : 0;
+  const seconds = Math.floor(safeMs / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60)
+    return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours < 24)
+    return `${hours}h ${remainingMinutes}m`;
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return `${days}d ${remainingHours}h`;
+}
+function localDaemonDetail(options, now) {
+  if (!options.running)
+    return "run `agendex start` to begin background sync";
+  const parts = [];
+  if (isPresent(options.pidInfo?.pid))
+    parts.push(`PID ${options.pidInfo.pid}`);
+  if (isPresent(options.pidInfo?.startedAtMs)) {
+    parts.push(`up ${formatDuration(now - options.pidInfo.startedAtMs)}`);
+  } else {
+    parts.push("uptime unknown");
+  }
+  if (options.pidInfo?.hostname)
+    parts.push(`host ${options.pidInfo.hostname}`);
+  else
+    parts.push("host unknown");
+  return parts.join(" • ");
+}
+function isDeviceAlive(device, now) {
+  if (!isPresent(device.lastSeenAt))
+    return false;
+  return now - device.lastSeenAt < CLI_DAEMON_STALE_AFTER_MS;
+}
+function sortDevices(devices, localDeviceId, now) {
+  return [...devices].sort((a, b) => {
+    const localDiff = Number(b.deviceId === localDeviceId) - Number(a.deviceId === localDeviceId);
+    if (localDiff !== 0)
+      return localDiff;
+    const aliveDiff = Number(isDeviceAlive(b, now)) - Number(isDeviceAlive(a, now));
+    if (aliveDiff !== 0)
+      return aliveDiff;
+    return (a.hostname ?? "").localeCompare(b.hostname ?? "");
+  });
+}
+function deviceLines({ styles, device, localDeviceId, now }) {
+  const alive = isDeviceAlive(device, now);
+  const statusText = alive ? "✓ alive" : "! stale";
+  const statusCell = styles.status(alive ? "success" : "warning", statusText.padEnd(12));
+  const hostname2 = device.hostname ?? "unknown host";
+  const isLocalDevice = localDeviceId !== undefined && device.deviceId === localDeviceId;
+  const localMarker = isLocalDevice ? " (this machine)" : "";
+  const pid = isPresent(device.pid) ? `PID ${device.pid}` : "PID unknown";
+  const uptime = isPresent(device.startedAtMs) ? `up ${formatDuration(now - device.startedAtMs)}` : "uptime unknown";
+  const seen = isPresent(device.lastSeenAt) ? `seen ${formatDuration(now - device.lastSeenAt)} ago` : "last seen unknown";
+  const ip = device.ipAddress ?? "IP unknown";
+  return [
+    `  ${statusCell}${styles.value(hostname2)}${styles.muted(localMarker)}`,
+    `              ${styles.muted([pid, uptime, seen, ip].join(" • "))}`
+  ];
+}
+function addCloudDaemonLines({ lines, styles, options, cloudReady, now }) {
+  if (!cloudReady) {
+    lines.push(row(styles, "Daemon registry", badge(styles, "warning", "offline"), "login required"));
+    return;
+  }
+  if (options.cloudDaemonError?.kind === "auth-expired") {
+    lines.push(row(styles, "Daemon registry", badge(styles, "danger", "token expired"), "run `agendex login`"));
+    return;
+  }
+  if (options.cloudDaemonError?.kind === "unavailable") {
+    lines.push(row(styles, "Daemon registry", badge(styles, "warning", "unavailable"), options.cloudDaemonError.message ?? "will retry on the next status check"));
+    return;
+  }
+  const devices = options.devices ?? [];
+  if (devices.length === 0) {
+    lines.push(row(styles, "Daemon registry", badge(styles, "info", "empty"), "no cloud daemons reported"));
+    return;
+  }
+  const aliveCount = devices.filter((device) => isDeviceAlive(device, now)).length;
+  const staleCount = devices.length - aliveCount;
+  lines.push(row(styles, "Daemon registry", badge(styles, "success", `${devices.length} device${devices.length === 1 ? "" : "s"}`), `${aliveCount} alive • ${staleCount} stale`));
+  const localDeviceId = options.config?.deviceId;
+  for (const device of sortDevices(devices, localDeviceId, now)) {
+    lines.push(...deviceLines({ styles, device, localDeviceId, now }));
+  }
+}
+function nextActions(options, now) {
+  const config = options.config;
+  const cloudReady = Boolean(config?.cloudToken && config.convexUrl);
+  const adapters = config?.enabledAdapters ?? [];
+  const devices = options.devices ?? [];
+  const hasStaleDevices = devices.some((device) => !isDeviceAlive(device, now));
+  const authExpired = options.cloudDaemonError?.kind === "auth-expired";
+  const actions = [];
+  if (!options.running) {
+    actions.push({ command: "agendex start", description: "Start the background sync daemon" });
+  }
+  if (!cloudReady || authExpired) {
+    actions.push({ command: "agendex login", description: "Connect or refresh cloud sync" });
+  }
+  if (adapters.length === 0) {
+    actions.push({
+      command: "agendex configure",
+      description: "Choose which agent plan sources to index"
+    });
+  }
+  if (hasStaleDevices) {
+    actions.push({
+      command: "agendex cleanup --stale",
+      description: "Remove stale cloud daemon records"
+    });
+  }
+  if (cloudReady) {
+    actions.push({
+      command: "agendex sync",
+      description: "Run a one-shot scan and cloud sync now"
+    });
+  }
+  actions.push({ command: "agendex open", description: "Open the Agendex dashboard" });
+  const seen = new Set;
+  return actions.filter((action) => {
+    if (seen.has(action.command))
+      return false;
+    seen.add(action.command);
+    return true;
+  });
+}
+function renderStatus(options) {
+  const styles = createStyles2(options.color ?? supportsColor2());
+  const now = options.now ?? Date.now();
+  const config = options.config;
+  const adapters = config?.enabledAdapters ?? [];
+  const customDirs = config?.customPlanDirs ?? [];
+  const cloudReady = Boolean(config?.cloudToken && config.convexUrl);
+  const lines = [];
+  lines.push(styles.title("Agendex status"));
+  lines.push(styles.muted(`Config: ${options.configPath}`));
+  lines.push("");
+  lines.push(styles.section("Local:"));
+  lines.push(row(styles, "Daemon", options.running ? badge(styles, "success", "running") : badge(styles, "warning", "not running"), localDaemonDetail(options, now)));
+  lines.push(row(styles, "Config file", config ? badge(styles, "success", "found") : badge(styles, "warning", "missing"), config ? `v${config.configVersion}` : "created on first start/configure"));
+  lines.push(row(styles, "Local API token", config?.token ? badge(styles, "success", "set") : badge(styles, "warning", "missing"), config?.token ? "ready for OSS API auth" : "generated when the local app starts"));
+  lines.push(row(styles, "CLI version", styles.value(`v${options.cliVersion}`)));
+  lines.push("");
+  lines.push(styles.section("Cloud:"));
+  lines.push(row(styles, "Account", cloudReady ? badge(styles, "success", "logged in") : badge(styles, "warning", "not logged in"), config?.convexUrl ?? "run `agendex login` to enable cloud sync"));
+  if (config?.siteUrl) {
+    lines.push(row(styles, "Web app", styles.value(config.siteUrl)));
+  }
+  lines.push(row(styles, "Device ID", config?.deviceId ? badge(styles, "success", "registered") : badge(styles, "warning", "missing"), config?.deviceId ?? "created on the next daemon heartbeat"));
+  addCloudDaemonLines({ lines, styles, options, cloudReady, now });
+  lines.push("");
+  lines.push(styles.section("Plan sources:"));
+  lines.push(row(styles, "Adapters", adapters.length > 0 ? badge(styles, "success", `${adapters.length} enabled`) : badge(styles, "warning", "none enabled"), adapters.length > 0 ? summarizeList(adapters) : "run `agendex configure`"));
+  lines.push(row(styles, "Custom dirs", customDirs.length > 0 ? badge(styles, "info", `${customDirs.length} configured`) : badge(styles, "info", "none"), customDirs.length > 0 ? "additional scan roots" : "using built-in agent directories"));
+  for (const dir of customDirs)
+    lines.push(listItem(styles, dir));
+  lines.push("");
+  lines.push(styles.section("Next steps:"));
+  for (const action of nextActions(options, now)) {
+    lines.push(actionRow(styles, action.command, action.description));
+  }
+  return lines.join(`
+`);
+}
+
 // src/sync.ts
 import { hostname as osHostname3 } from "node:os";
 async function syncAll(force = false) {
@@ -5744,7 +6144,7 @@ import { join as join15 } from "node:path";
 // package.json
 var package_default = {
   name: "agendex-cli",
-  version: "2.0.0",
+  version: "2.0.1",
   description: "Agendex CLI for login, sync, and daemon workflows",
   homepage: "https://github.com/Tyru5/Agendex#readme",
   bugs: {
@@ -6304,18 +6704,15 @@ async function main() {
         return 0;
       }
       process.kill(pid, "SIGTERM");
-      const deadline = Date.now() + 5000;
-      while (isRunning(pid) && Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 200));
-      }
-      if (isRunning(pid)) {
+      const stopped = await waitForProcessExit(pid, 5000);
+      if (!stopped) {
         writeStderr("[agendex] daemon did not stop in time");
-      } else {
-        removePid();
-        await sendShutdown();
-        writeStdout(`[agendex] daemon stopped (PID ${pid})`);
+        return 1;
       }
-      return isRunning(pid) ? 1 : 0;
+      removePid();
+      await sendShutdown();
+      writeStdout(`[agendex] daemon stopped (PID ${pid})`);
+      return 0;
     }
     case "login": {
       const urlIdx = args.indexOf("--url");
@@ -6338,160 +6735,19 @@ async function main() {
       return 0;
     }
     case "upload": {
-      return await runUpload(args);
+      return runUpload(args);
     }
     case "hooks": {
-      return await runHooksCommand(args, cliEntry);
+      return runHooksCommand(args, cliEntry);
     }
     case "review-plan": {
-      return await runHookReviewCommand(args);
+      return runHookReviewCommand(args);
     }
     case "cleanup": {
-      const config = loadConfig();
-      if (!config?.cloudToken || !config?.convexUrl) {
-        writeStderr("[agendex] not logged in. Run `agendex login` first.");
-        return 1;
-      }
-      let allDevices;
-      try {
-        allDevices = await fetchDevices();
-      } catch (err) {
-        if (err instanceof AuthExpiredError) {
-          writeStderr("[agendex] cloud token expired. Run `agendex login` to re-authenticate.");
-          return 1;
-        }
-        throw err;
-      }
-      if (allDevices.length === 0) {
-        writeStdout("[agendex] no daemons found");
-        return 0;
-      }
-      const now = Date.now();
-      const staleDevices = allDevices.filter((d2) => {
-        const age = d2.lastSeenAt ? now - d2.lastSeenAt : Number.POSITIVE_INFINITY;
-        return age >= CLI_DAEMON_STALE_AFTER_MS;
-      });
-      if (args.includes("--stale")) {
-        if (staleDevices.length === 0) {
-          writeStdout("[agendex] no stale daemons to remove");
-          return 0;
-        }
-        const staleIds = staleDevices.map((d2) => d2.deviceId).filter((id) => id != null);
-        if (staleIds.length === 0) {
-          writeStdout("[agendex] stale daemons have no device IDs and cannot be removed");
-          return 0;
-        }
-        const result2 = await deleteDaemons(staleIds);
-        if (result2.ok) {
-          writeStdout(`[agendex] removed ${result2.deleted} stale daemon(s)`);
-        } else {
-          writeStderr("[agendex] failed to remove stale daemons");
-          return 1;
-        }
-        return 0;
-      }
-      if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        writeStderr("[agendex] interactive cleanup requires a TTY. Use --stale to auto-remove stale daemons.");
-        return 1;
-      }
-      const { promptForDaemonCleanup: promptForDaemonCleanup2 } = await Promise.resolve().then(() => (init_cleanup(), exports_cleanup));
-      const deviceIds = allDevices.filter((d2) => d2.deviceId != null).map((d2) => {
-        const age = d2.lastSeenAt ? now - d2.lastSeenAt : Number.POSITIVE_INFINITY;
-        const status = age < CLI_DAEMON_STALE_AFTER_MS ? "alive" : "stale";
-        return {
-          deviceId: d2.deviceId,
-          hostname: d2.hostname ?? "unknown",
-          pid: d2.pid,
-          status
-        };
-      });
-      if (deviceIds.length === 0) {
-        writeStdout("[agendex] no daemons with device IDs to remove");
-        return 0;
-      }
-      const selected = await promptForDaemonCleanup2(deviceIds);
-      if (!selected)
-        return 0;
-      const result = await deleteDaemons(selected);
-      if (result.ok) {
-        writeStdout(`[agendex] removed ${result.deleted} daemon(s)`);
-      } else {
-        writeStderr("[agendex] failed to remove daemons");
-        return 1;
-      }
-      return 0;
+      return runCleanupCommand(args);
     }
     case "add-dir": {
-      const dirPath = args.find((a) => a !== "add-dir" && a !== "--dev" && !a.startsWith("--"));
-      if (!dirPath || !dirPath.trim()) {
-        writeStderr("[agendex] usage: agendex add-dir <path>");
-        return 1;
-      }
-      const resolved = resolveCustomPlanDirPath(dirPath);
-      if (!existsSync13(resolved)) {
-        writeStderr(`[agendex] path does not exist: ${resolved}`);
-        return 1;
-      }
-      if (!statSync2(resolved).isDirectory()) {
-        writeStderr(`[agendex] path is not a directory: ${resolved}`);
-        return 1;
-      }
-      if (args.includes("--live")) {
-        const cfg = loadConfig();
-        const token = cfg?.token;
-        if (!token) {
-          writeStderr("[agendex] no local token found in config — is the server running?");
-          return 1;
-        }
-        const port = process.env.PORT ?? "4890";
-        const { request } = await import("node:http");
-        const body = JSON.stringify({ path: resolved });
-        try {
-          const res = await new Promise((resolve12, reject) => {
-            const req = request(`http://localhost:${port}/api/v1/plan-sources`, {
-              method: "POST",
-              headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json",
-                "Content-Length": String(Buffer.byteLength(body))
-              }
-            }, (res2) => {
-              let data = "";
-              res2.setEncoding("utf8");
-              res2.on("data", (chunk) => {
-                data += chunk;
-              });
-              res2.on("end", () => resolve12({ status: res2.statusCode ?? 0, body: data }));
-              res2.on("error", reject);
-            });
-            req.on("error", reject);
-            req.write(body);
-            req.end();
-          });
-          if (res.status >= 200 && res.status < 300) {
-            writeStdout(`[agendex] added custom plan dir: ${resolved}`);
-            writeStdout(`[agendex] server notified — scanning + watching now`);
-          } else {
-            writeStderr(`[agendex] server returned ${res.status}: ${res.body}`);
-            return 1;
-          }
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          writeStderr(`[agendex] could not reach local server on port ${port}: ${msg}`);
-          return 1;
-        }
-      } else {
-        const cfg = loadConfig();
-        const currentDirs = cfg?.customPlanDirs ?? [];
-        const updated = normalizeCustomPlanDirs([...currentDirs, resolved]);
-        saveConfig({
-          ...cfg ?? { configVersion: 3, enabledAdapters: [] },
-          customPlanDirs: updated
-        });
-        writeStdout(`[agendex] added custom plan dir: ${resolved}`);
-        writeStdout(`[agendex] daemon will pick up the change automatically`);
-      }
-      return 0;
+      return runAddDirCommand(args);
     }
     case "remove-dir": {
       const dirPath = args.find((a) => a !== "remove-dir" && a !== "--dev" && !a.startsWith("--"));
@@ -6532,110 +6788,40 @@ async function main() {
       const pidInfo = readPidInfo();
       const pid = pidInfo?.pid ?? null;
       const running = pid ? isRunning(pid) : false;
-      writeStdout(`[agendex] Config version: ${config?.configVersion ?? "none"}`);
-      writeStdout(`[agendex] Local token: ${config?.token ? "set" : "not set"}`);
-      writeStdout(`[agendex] Cloud token: ${config?.cloudToken ? "set" : "not set"}`);
-      writeStdout(`[agendex] Convex URL: ${config?.convexUrl ?? "not set"}`);
-      writeStdout(`[agendex] Enabled adapters: ${config?.enabledAdapters.join(", ") || "none"}`);
-      const customDirs = config?.customPlanDirs ?? [];
-      writeStdout(`[agendex] Custom plan dirs: ${customDirs.length > 0 ? customDirs.length : "none"}`);
-      for (const dir of customDirs) {
-        writeStdout(`  - ${dir}`);
-      }
-      writeStdout(`[agendex] Daemon: ${running ? `running (PID ${pid})` : "not running"}`);
-      if (running && pidInfo?.startedAtMs) {
-        writeStdout(`[agendex] Uptime: ${formatDuration(Date.now() - pidInfo.startedAtMs)}`);
-      } else if (running) {
-        writeStdout(`[agendex] Uptime: unknown (restart daemon to populate)`);
-      } else {
-        writeStdout(`[agendex] Uptime: n/a`);
-      }
-      if (running && pidInfo?.hostname) {
-        writeStdout(`[agendex] Hostname: ${pidInfo.hostname}`);
-      } else if (running) {
-        writeStdout(`[agendex] Hostname: unknown (restart daemon to populate)`);
-      } else {
-        writeStdout(`[agendex] Hostname: n/a`);
-      }
-      writeStdout(`[agendex] CLI version: ${CLI_VERSION}`);
-      try {
-        if (config?.cloudToken && config?.convexUrl) {
-          const allDevices = await fetchDevices();
-          if (allDevices.length > 0) {
-            const now = Date.now();
-            const localDeviceId = config.deviceId;
-            writeStdout(`[agendex] All daemons:`);
-            for (const device of allDevices) {
-              const age = device.lastSeenAt ? now - device.lastSeenAt : Number.POSITIVE_INFINITY;
-              const status = age < CLI_DAEMON_STALE_AFTER_MS ? "alive" : "stale";
-              const uptimeStr = device.startedAtMs != null ? formatDuration(now - device.startedAtMs) : "~";
-              const pidStr = device.pid != null ? String(device.pid) : "~";
-              const hostnameStr = device.hostname ?? "~";
-              const ipStr = device.ipAddress ?? "~";
-              const isLocal = localDeviceId && device.deviceId === localDeviceId;
-              writeStdout(`- hostname: ${hostnameStr}${isLocal ? " (this machine)" : ""}
-  ip: ${ipStr}
-  pid: ${pidStr}
-  uptime: ${uptimeStr}
-  status: ${status}`);
-            }
+      let devices = null;
+      let cloudDaemonError = null;
+      if (config?.cloudToken && config?.convexUrl) {
+        try {
+          devices = await fetchDevices();
+        } catch (err) {
+          if (err instanceof AuthExpiredError) {
+            cloudDaemonError = { kind: "auth-expired" };
           } else {
-            writeStdout(`[agendex] All daemons: none`);
+            cloudDaemonError = {
+              kind: "unavailable",
+              message: err instanceof Error ? err.message : String(err)
+            };
           }
         }
-      } catch (err) {
-        if (err instanceof AuthExpiredError) {
-          writeStderr(`[agendex] Cloud token expired — cloud sync and daemon tracking are inactive.`);
-          writeStderr(`[agendex] Run \`agendex login\` to re-authenticate.`);
-        }
       }
+      writeStdout(renderStatus({
+        config,
+        configPath: getConfigPath(),
+        pidInfo,
+        running,
+        cliVersion: CLI_VERSION,
+        devices,
+        cloudDaemonError
+      }));
       return 0;
     }
     case "upgrade": {
-      return await runUpgrade({ force: args.includes("--force") });
+      return runUpgrade({ force: args.includes("--force") });
     }
     case "help":
     case "--help":
     case "-h": {
-      writeStdout(`
-agendex - CLI for syncing local agent plans to the cloud
-
-Usage:
-  agendex              Start daemon (default, backgrounds itself)
-  agendex start        Start daemon (backgrounds itself)
-  agendex stop         Stop the running daemon
-  agendex login        Authenticate via browser OAuth (agendex.dev)
-  agendex login --url <url>  Login to a self-hosted instance
-  agendex open         Open the Agendex web app in your browser
-  agendex open --url <url>  Open a self-hosted instance
-  agendex view <url>   Open a shared plan URL in your browser
-  agendex logout       Clear stored cloud token
-  agendex configure    Select which agents/adapters to index
-  agendex hooks status Show Claude Code, Codex, and Pi hook status
-  agendex hooks install <agent|all>  Install hook integration (--preview required for claude-code)
-  agendex hooks uninstall <agent|all>  Remove managed Agendex hook entries
-  agendex review-plan --hook --agent <agent>  Hook-native plan review command
-  agendex add-dir <path>  Add a custom directory to scan for plans
-  agendex add-dir <path> --live  Add dir and notify running server immediately
-  agendex remove-dir <path>  Remove a custom directory
-  agendex list-dirs    List custom plan directories
-  agendex sync         One-shot scan + sync to cloud (skips unchanged plans)
-  agendex sync --force Re-sync all plans, ignoring cache
-  agendex upload <path>  Upload a single Markdown plan file to the cloud
-  agendex upload <path> --agent <name>  Override the uploaded plan's agent label
-  agendex upload <path> --open  Open the uploaded plan in the browser after upload
-  agendex cleanup      Interactively remove cloud daemons
-  agendex cleanup --stale  Auto-remove all stale daemons
-  agendex status       Show current config state + daemon status
-  agendex upgrade      Upgrade the globally installed CLI to the latest version
-  agendex upgrade --force  Reinstall latest even if already up to date
-  agendex help         Show this help message
-  agendex --version    Print CLI version
-  agendex -v           Print CLI version
-
-Flags:
-  --dev                Use dev environment (~/.agendex-dev/ config dir)
-`.trim());
+      writeStdout(renderHelp({ cliVersion: CLI_VERSION }));
       return 0;
     }
     default: {
@@ -6645,6 +6831,173 @@ Flags:
     }
   }
 }
+function waitForProcessExit(pid, timeoutMs) {
+  return new Promise((resolve12) => {
+    const deadline = Date.now() + timeoutMs;
+    const interval = setInterval(() => {
+      if (!isRunning(pid)) {
+        clearInterval(interval);
+        resolve12(true);
+        return;
+      }
+      if (Date.now() >= deadline) {
+        clearInterval(interval);
+        resolve12(false);
+      }
+    }, 200);
+  });
+}
+async function runCleanupCommand(commandArgs) {
+  const config = loadConfig();
+  if (!config?.cloudToken || !config?.convexUrl) {
+    writeStderr("[agendex] not logged in. Run `agendex login` first.");
+    return 1;
+  }
+  let allDevices;
+  try {
+    allDevices = await fetchDevices();
+  } catch (err) {
+    if (err instanceof AuthExpiredError) {
+      writeStderr("[agendex] cloud token expired. Run `agendex login` to re-authenticate.");
+      return 1;
+    }
+    throw err;
+  }
+  if (allDevices.length === 0) {
+    writeStdout("[agendex] no daemons found");
+    return 0;
+  }
+  const now = Date.now();
+  const staleDevices = allDevices.filter((device) => {
+    const age = device.lastSeenAt !== null ? now - device.lastSeenAt : Number.POSITIVE_INFINITY;
+    return age >= CLI_DAEMON_STALE_AFTER_MS;
+  });
+  if (commandArgs.includes("--stale")) {
+    if (staleDevices.length === 0) {
+      writeStdout("[agendex] no stale daemons to remove");
+      return 0;
+    }
+    const staleIds = staleDevices.flatMap((device) => device.deviceId === null ? [] : [device.deviceId]);
+    if (staleIds.length === 0) {
+      writeStdout("[agendex] stale daemons have no device IDs and cannot be removed");
+      return 0;
+    }
+    const result2 = await deleteDaemons(staleIds);
+    if (result2.ok) {
+      writeStdout(`[agendex] removed ${result2.deleted} stale daemon(s)`);
+    } else {
+      writeStderr("[agendex] failed to remove stale daemons");
+      return 1;
+    }
+    return 0;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    writeStderr("[agendex] interactive cleanup requires a TTY. Use --stale to auto-remove stale daemons.");
+    return 1;
+  }
+  const { promptForDaemonCleanup: promptForDaemonCleanup2 } = await Promise.resolve().then(() => (init_cleanup(), exports_cleanup));
+  const deviceIds = allDevices.flatMap((device) => {
+    if (device.deviceId === null)
+      return [];
+    const age = device.lastSeenAt !== null ? now - device.lastSeenAt : Number.POSITIVE_INFINITY;
+    const status = age < CLI_DAEMON_STALE_AFTER_MS ? "alive" : "stale";
+    return [
+      {
+        deviceId: device.deviceId,
+        hostname: device.hostname ?? "unknown",
+        pid: device.pid,
+        status
+      }
+    ];
+  });
+  if (deviceIds.length === 0) {
+    writeStdout("[agendex] no daemons with device IDs to remove");
+    return 0;
+  }
+  const selected = await promptForDaemonCleanup2(deviceIds);
+  if (!selected)
+    return 0;
+  const result = await deleteDaemons(selected);
+  if (result.ok) {
+    writeStdout(`[agendex] removed ${result.deleted} daemon(s)`);
+  } else {
+    writeStderr("[agendex] failed to remove daemons");
+    return 1;
+  }
+  return 0;
+}
+async function runAddDirCommand(commandArgs) {
+  const dirPath = commandArgs.find((arg) => arg !== "add-dir" && arg !== "--dev" && !arg.startsWith("--"));
+  if (dirPath === undefined || dirPath.trim() === "") {
+    writeStderr("[agendex] usage: agendex add-dir <path>");
+    return 1;
+  }
+  const resolved = resolveCustomPlanDirPath(dirPath);
+  if (!existsSync13(resolved)) {
+    writeStderr(`[agendex] path does not exist: ${resolved}`);
+    return 1;
+  }
+  if (!statSync2(resolved).isDirectory()) {
+    writeStderr(`[agendex] path is not a directory: ${resolved}`);
+    return 1;
+  }
+  if (commandArgs.includes("--live")) {
+    const cfg = loadConfig();
+    const token = cfg?.token;
+    if (!token) {
+      writeStderr("[agendex] no local token found in config — is the server running?");
+      return 1;
+    }
+    const port = process.env.PORT ?? "4890";
+    const { request } = await import("node:http");
+    const body = JSON.stringify({ path: resolved });
+    try {
+      const res = await new Promise((resolve12, reject) => {
+        const req = request(`http://localhost:${port}/api/v1/plan-sources`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "Content-Length": String(Buffer.byteLength(body))
+          }
+        }, (res2) => {
+          let data = "";
+          res2.setEncoding("utf8");
+          res2.on("data", (chunk) => {
+            data += chunk;
+          });
+          res2.on("end", () => resolve12({ status: res2.statusCode ?? 0, body: data }));
+          res2.on("error", reject);
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+      });
+      if (res.status >= 200 && res.status < 300) {
+        writeStdout(`[agendex] added custom plan dir: ${resolved}`);
+        writeStdout(`[agendex] server notified — scanning + watching now`);
+      } else {
+        writeStderr(`[agendex] server returned ${res.status}: ${res.body}`);
+        return 1;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeStderr(`[agendex] could not reach local server on port ${port}: ${msg}`);
+      return 1;
+    }
+  } else {
+    const cfg = loadConfig();
+    const currentDirs = cfg?.customPlanDirs ?? [];
+    const updated = normalizeCustomPlanDirs([...currentDirs, resolved]);
+    saveConfig({
+      ...cfg ?? { configVersion: 3, enabledAdapters: [] },
+      customPlanDirs: updated
+    });
+    writeStdout(`[agendex] added custom plan dir: ${resolved}`);
+    writeStdout(`[agendex] daemon will pick up the change automatically`);
+  }
+  return 0;
+}
 var exitCode = await main().catch((err) => {
   writeStderr(`[agendex] ${err instanceof Error ? err.message : err}`);
   return 1;
@@ -6675,17 +7028,3 @@ function writeStderr(message) {
   writeSync(process.stderr.fd, `${message}
 `);
 }
-function formatDuration(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-  const days = Math.floor(totalSeconds / 86400);
-  const hours = Math.floor(totalSeconds % 86400 / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  if (days > 0)
-    return `${days}d ${hours}h ${minutes}m ${seconds}s`;
-  if (hours > 0)
-    return `${hours}h ${minutes}m ${seconds}s`;
-  if (minutes > 0)
-    return `${minutes}m ${seconds}s`;
-  return `${seconds}s`;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agendex-cli",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Agendex CLI for login, sync, and daemon workflows",
   "homepage": "https://github.com/Tyru5/Agendex#readme",
   "repository": {