@michael-joseph-miller/ant-bot 0.1.0

package/dist/index.js

@@ -0,0 +1,1562 @@
+#!/usr/bin/env node
+import { createRequire as __antbotCreateRequire } from 'node:module';
+const require = __antbotCreateRequire(import.meta.url);
+import {
+  SettingsSchema
+} from "./chunk-DYIJTUMY.js";
+
+// packages/cli/src/index.ts
+import fs10 from "node:fs";
+import readline2 from "node:readline/promises";
+import path11 from "node:path";
+
+// packages/cli/src/args.ts
+var KNOWN_COMMANDS = [
+  "start",
+  "stop",
+  "restart",
+  "status",
+  "doctor",
+  "open",
+  "skill",
+  "backup",
+  "restore",
+  "update"
+];
+var CliError = class extends Error {
+};
+var COMMAND_FLAGS = {
+  start: {
+    port: { type: "number" },
+    foreground: { type: "boolean", default: false },
+    open: { type: "boolean", default: false }
+  },
+  stop: {},
+  restart: {
+    port: { type: "number" }
+  },
+  status: {},
+  doctor: {},
+  open: {},
+  skill: {},
+  backup: {
+    out: { type: "string" }
+  },
+  restore: {
+    yes: { type: "boolean", default: false }
+  },
+  update: {
+    check: { type: "boolean", default: false },
+    yes: { type: "boolean", default: false }
+  }
+};
+function isKnownCommand(value) {
+  return KNOWN_COMMANDS.includes(value);
+}
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    return { command: null, help: true, version: false, positionals: [], flags: {} };
+  }
+  const first = argv[0];
+  if (first === "--version" || first === "-v") {
+    return { command: null, help: false, version: true, positionals: [], flags: {} };
+  }
+  if (first === "--help" || first === "-h") {
+    return { command: null, help: true, version: false, positionals: [], flags: {} };
+  }
+  if (first.startsWith("-")) {
+    throw new CliError(`Unknown option: ${first}
+Run "antbot --help" for usage.`);
+  }
+  if (!isKnownCommand(first)) {
+    throw new CliError(`Unknown command: "${first}"
+Run "antbot --help" for usage.`);
+  }
+  const command = first;
+  const spec = COMMAND_FLAGS[command];
+  const rest = argv.slice(1);
+  const flags = {};
+  for (const [name, def] of Object.entries(spec)) {
+    if (def.default !== void 0) flags[name] = def.default;
+  }
+  const positionals = [];
+  let help = false;
+  for (let i = 0; i < rest.length; i++) {
+    const tok = rest[i];
+    if (tok === "--help" || tok === "-h") {
+      help = true;
+      continue;
+    }
+    if (tok.startsWith("--")) {
+      let name = tok.slice(2);
+      let inlineValue;
+      const eq = name.indexOf("=");
+      if (eq !== -1) {
+        inlineValue = name.slice(eq + 1);
+        name = name.slice(0, eq);
+      }
+      const def = spec[name];
+      if (!def) {
+        throw new CliError(`Unknown flag "--${name}" for command "${command}"`);
+      }
+      if (def.type === "boolean") {
+        flags[name] = inlineValue === void 0 ? true : inlineValue !== "false";
+        continue;
+      }
+      const raw = inlineValue !== void 0 ? inlineValue : rest[++i];
+      if (raw === void 0) {
+        throw new CliError(`Flag "--${name}" requires a value`);
+      }
+      if (def.type === "number") {
+        const num = Number(raw);
+        if (Number.isNaN(num)) {
+          throw new CliError(`Flag "--${name}" must be a number, got "${raw}"`);
+        }
+        flags[name] = num;
+      } else {
+        flags[name] = raw;
+      }
+      continue;
+    }
+    positionals.push(tok);
+  }
+  return { command, help, version: false, positionals, flags };
+}
+
+// packages/cli/src/help.ts
+var GLOBAL_HELP = `antbot \u2014 a local daemon and web UI for a roster of persistent Claude teammates.
+
+Usage: antbot <command> [options]
+
+Getting started:
+  antbot doctor        Check your environment (Node, claude CLI + login, data dir, port)
+  antbot open          Open the web UI, starting the daemon if it isn't running
+
+Daemon:
+  start [options]      Start the daemon in the background
+  stop                 Stop the daemon
+  restart [--port N]   Stop and start again
+  status               Show whether the daemon is running, and where
+  open                 Open the web UI (starts the daemon first if needed)
+  doctor               Diagnose the local environment
+
+Data:
+  skill <subcommand>   Manage the skills your bots can use
+  backup [--out PATH]  Archive the database, config, skills, and bot memory
+  restore <path>       Restore from a backup archive
+
+Maintenance:
+  update [--check]     Update ant-bot to the latest published version
+
+Options:
+  -h, --help           Show help; "antbot <command> --help" for one command
+  -v, --version        Show the CLI version
+
+Environment:
+  ANTBOT_HOME          Data directory (default: ~/.ant-bot)
+
+The UI lives at http://127.0.0.1:4780 and is served by the daemon itself.`;
+var COMMAND_HELP = {
+  start: `antbot start \u2014 start the daemon in the background
+
+Usage: antbot start [--port N] [--open] [--foreground]
+
+  --port N       Port to listen on (default: from config, usually 4780)
+  --open         Open the web UI once the daemon is healthy
+  --foreground   Run in this terminal instead of detaching (Ctrl-C stops it)
+
+Detached output goes to the log in your data directory; "antbot status" tells
+you where that is. Starting an already-running daemon is a no-op.`,
+  stop: `antbot stop \u2014 stop the daemon
+
+Usage: antbot stop
+
+Sends SIGTERM, then SIGKILL if it hasn't exited after 10 seconds. Stopping a
+daemon that isn't running succeeds quietly.`,
+  restart: `antbot restart \u2014 stop the daemon and start it again
+
+Usage: antbot restart [--port N]
+
+  --port N   Port to listen on when starting back up
+
+Bots, threads, and memory survive a restart.`,
+  status: `antbot status \u2014 show daemon status
+
+Usage: antbot status
+
+Prints the URL, version, data directory, and bot count. Exits non-zero when the
+daemon is not running, so it works in scripts.`,
+  doctor: `antbot doctor \u2014 diagnose the local environment
+
+Usage: antbot doctor
+
+Checks Node.js version, the claude CLI, Claude authentication, ANTHROPIC_API_KEY,
+data directory permissions, port availability, better-sqlite3, and Playwright's
+Chromium install. Each failure prints the command that fixes it.
+
+Exits non-zero if any check fails.`,
+  open: `antbot open \u2014 open the web UI
+
+Usage: antbot open
+
+Prints the URL and hands it to your browser. If the daemon isn't running yet,
+it is started first \u2014 so this is the only command you need day to day.`,
+  skill: `antbot skill \u2014 manage the skills your bots can use
+
+Usage:
+  antbot skill list
+  antbot skill add <source>
+  antbot skill remove <slug>
+  antbot skill lint [path]
+
+A skill is a directory containing a SKILL.md. \`add\` accepts:
+
+  owner/repo                        a GitHub repository
+  github.com/owner/repo             the same, written out
+  github.com/owner/repo#v2          pinned to a branch or tag
+  github.com/owner/repo/tree/main/x one skill inside a monorepo
+  git@github.com:owner/repo.git     any git URL
+  ./path/to/skill                   a local directory
+  https://host/path/SKILL.md        a single skill file
+
+A repository holding several skills installs all of them. Re-installing an
+existing skill upgrades it in place and keeps it assigned to its bots.
+
+Skills committed to the ant-bot project's own skills/ directory are installed
+automatically on every start.
+
+\`lint\` checks skills against the Agent Skills spec (skills/SPEC.md) and needs
+no running daemon. With no path it checks everything installed; give it a path
+to check one skill you are still writing, or a directory of them:
+
+  antbot skill lint                 every installed skill
+  antbot skill lint ./skills        a directory of skills
+  antbot skill lint ./skills/my-skill   one skill
+
+Exit status is 1 if anything is an error, 0 if only warnings.`,
+  backup: `antbot backup \u2014 create a backup archive
+
+Usage: antbot backup [--out PATH]
+
+  --out PATH   Output path for the tar.gz (default: ~/.ant-bot/backups/<timestamp>.tar.gz)
+
+Includes antbot.db, config.toml, skills, and each bot's memory directory.
+Excludes browser-profile and attachments.`,
+  update: `antbot update \u2014 update ant-bot to the latest published version
+
+Usage: antbot update [--check] [--yes]
+
+  --check   Report whether a newer version exists and exit; change nothing
+  --yes     Skip the confirmation prompt
+
+Runs the package manager that installed this copy, then restarts the daemon if
+it was running. The check is cached for a day, so it costs no network most of
+the time. ant-bot never updates itself in the background: the daemon holds a
+live database handle and may be mid-turn.
+
+In a git checkout there is nothing for a package manager to update \u2014 use
+\`git pull && pnpm install\` instead.`,
+  restore: `antbot restore \u2014 restore from a backup archive
+
+Usage: antbot restore <path> [--yes]
+
+  --yes   Skip the confirmation prompt
+
+Overwrites files in your data directory. Stop the daemon first.`
+};
+function commandHelp(command) {
+  return COMMAND_HELP[command];
+}
+
+// packages/cli/src/version.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function readVersionFrom(here, exists, read) {
+  let dir = path.resolve(here);
+  for (; ; ) {
+    const pkg = path.join(dir, "package.json");
+    if (exists(pkg)) {
+      try {
+        return JSON.parse(read(pkg)).version ?? "0.0.0";
+      } catch {
+        return "0.0.0";
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return "0.0.0";
+    dir = parent;
+  }
+}
+function getCliVersion() {
+  return readVersionFrom(
+    path.dirname(fileURLToPath(import.meta.url)),
+    (p) => fs.existsSync(p),
+    (p) => fs.readFileSync(p, "utf8")
+  );
+}
+
+// packages/cli/src/doctor.ts
+import path2 from "node:path";
+function pass(name, message) {
+  return { name, status: "pass", message };
+}
+function warn(name, message, hint) {
+  return { name, status: "warn", message, hint };
+}
+function fail(name, message, hint) {
+  return { name, status: "fail", message, hint };
+}
+function checkNodeVersion(deps) {
+  const major = Number.parseInt(deps.nodeVersion.split(".")[0] ?? "0", 10);
+  if (Number.isFinite(major) && major >= 24) {
+    return pass("Node.js version", `v${deps.nodeVersion}`);
+  }
+  return fail(
+    "Node.js version",
+    `v${deps.nodeVersion} (ant-bot requires >= 24)`,
+    "Install Node.js 24 or later, e.g. via nvm: `nvm install 24`."
+  );
+}
+async function checkClaudeCli(deps) {
+  try {
+    const res = await deps.exec("claude", ["--version"]);
+    if (res.code === 0) {
+      return pass("claude CLI", res.stdout.trim() || "installed");
+    }
+    return fail(
+      "claude CLI",
+      `"claude --version" exited with code ${res.code}`,
+      "Install with `npm i -g @anthropic-ai/claude-code`."
+    );
+  } catch {
+    return fail(
+      "claude CLI",
+      "not found on PATH",
+      "Install with `npm i -g @anthropic-ai/claude-code`."
+    );
+  }
+}
+function checkClaudeAuth(deps) {
+  const credentialsPath = path2.join(deps.homeDir, ".claude", ".credentials.json");
+  const claudeJsonPath = path2.join(deps.homeDir, ".claude.json");
+  if (deps.fileExists(credentialsPath)) {
+    return pass("Claude authentication", `Found ${credentialsPath}`);
+  }
+  if (deps.fileExists(claudeJsonPath) && deps.fileSize(claudeJsonPath) > 50) {
+    return pass("Claude authentication", `Found ${claudeJsonPath}`);
+  }
+  return warn(
+    "Claude authentication",
+    "No Claude Code credentials found",
+    "Run `claude` once and log in."
+  );
+}
+function checkApiKeyEnv(deps) {
+  const value = deps.env.ANTHROPIC_API_KEY;
+  if (!value) {
+    return pass("ANTHROPIC_API_KEY", "Not set (turns bill to your Claude subscription)");
+  }
+  return warn(
+    "ANTHROPIC_API_KEY",
+    "Set in environment",
+    "Set, but ant-bot strips it so turns bill to your subscription. Set billingMode='api' in settings if you want API billing instead."
+  );
+}
+function checkDataDirWritable(deps) {
+  if (deps.isDirWritable(deps.dataDir)) {
+    return pass("Data directory", `${deps.dataDir} is writable`);
+  }
+  return fail(
+    "Data directory",
+    `${deps.dataDir} is not writable`,
+    `Check permissions on ${deps.dataDir}.`
+  );
+}
+async function checkPortAvailability(deps) {
+  const state = await deps.probePort(deps.port);
+  if (state === "free") {
+    return pass("Port", `Port ${deps.port} is free`);
+  }
+  const health = await deps.healthCheck(deps.port);
+  if (health.ok) {
+    return pass(
+      "Port",
+      `Port ${deps.port} is in use by a running antbot daemon${health.version ? ` (v${health.version})` : ""}`
+    );
+  }
+  return fail(
+    "Port",
+    `Port ${deps.port} is in use by another process`,
+    `Stop the other process or run \`antbot start --port <N>\`.`
+  );
+}
+async function checkBetterSqlite3(deps) {
+  try {
+    await deps.importBetterSqlite3();
+    return pass("better-sqlite3", "native module loads");
+  } catch (err) {
+    return fail(
+      "better-sqlite3",
+      `failed to load (${err.message})`,
+      "Run `pnpm rebuild better-sqlite3`."
+    );
+  }
+}
+async function checkPlaywrightChromium(deps) {
+  try {
+    const pw = await deps.importPlaywright();
+    const execPath = pw.chromium.executablePath();
+    if (deps.fileExists(execPath)) {
+      return pass("Playwright Chromium", execPath);
+    }
+    return warn(
+      "Playwright Chromium",
+      `Expected browser binary at ${execPath}`,
+      "Run `npx playwright install chromium`."
+    );
+  } catch (err) {
+    return warn(
+      "Playwright Chromium",
+      `Could not verify Chromium install (${err.message})`,
+      "Run `npx playwright install chromium`."
+    );
+  }
+}
+async function runDoctor(deps) {
+  const results = [
+    checkNodeVersion(deps),
+    await checkClaudeCli(deps),
+    checkClaudeAuth(deps),
+    checkApiKeyEnv(deps),
+    checkDataDirWritable(deps),
+    await checkPortAvailability(deps),
+    await checkBetterSqlite3(deps),
+    await checkPlaywrightChromium(deps)
+  ];
+  const exitCode = results.some((r) => r.status === "fail") ? 1 : 0;
+  return { results, exitCode };
+}
+
+// packages/cli/src/proc.ts
+import { spawn } from "node:child_process";
+function runCommand(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { cwd: opts.cwd });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+  });
+}
+
+// packages/cli/src/net.ts
+import net from "node:net";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function probePort(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const socket = net.connect({ port, host });
+    let settled = false;
+    const done = (state) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(state);
+    };
+    socket.setTimeout(1e3);
+    socket.once("connect", () => done("occupied"));
+    socket.once("timeout", () => done("free"));
+    socket.once("error", () => done("free"));
+  });
+}
+async function getHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return { ok: false };
+    const body = await res.json().catch(() => null);
+    return { ok: true, version: typeof body?.version === "string" ? body.version : void 0 };
+  } catch {
+    return { ok: false };
+  }
+}
+async function getBotCount(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/bots`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return null;
+    const body = await res.json().catch(() => null);
+    if (Array.isArray(body)) return body.length;
+    if (body && typeof body === "object" && Array.isArray(body.bots)) {
+      return body.bots.length;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function waitForHealth(port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const health = await getHealth(port);
+    if (health.ok) return true;
+    await sleep(300);
+  } while (Date.now() < deadline);
+  return false;
+}
+var BASE = (port) => `http://127.0.0.1:${port}`;
+async function unwrap(res) {
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new Error(body?.error ?? `HTTP ${res.status}`);
+  }
+  return await res.json();
+}
+async function getJson(port, path12) {
+  return unwrap(await fetch(`${BASE(port)}${path12}`, { signal: AbortSignal.timeout(1e4) }));
+}
+async function postJson(port, path12, body) {
+  return unwrap(
+    await fetch(`${BASE(port)}${path12}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      // Cloning a repository can take a while on a slow link.
+      signal: AbortSignal.timeout(18e4)
+    })
+  );
+}
+async function deleteJson(port, path12) {
+  return unwrap(
+    await fetch(`${BASE(port)}${path12}`, { method: "DELETE", signal: AbortSignal.timeout(1e4) })
+  );
+}
+
+// packages/server/dist/config/config.js
+import fs3 from "node:fs";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+// packages/server/dist/config/paths.js
+import os from "node:os";
+import path3 from "node:path";
+import fs2 from "node:fs";
+function resolvePaths(root) {
+  const base = root ?? process.env.ANTBOT_HOME ?? path3.join(os.homedir(), ".ant-bot");
+  return {
+    root: base,
+    db: path3.join(base, "antbot.db"),
+    config: path3.join(base, "config.toml"),
+    workspace: path3.join(base, "workspace"),
+    attachments: path3.join(base, "attachments"),
+    skills: path3.join(base, "skills"),
+    browserProfile: path3.join(base, "browser-profile"),
+    backups: path3.join(base, "backups"),
+    secrets: path3.join(base, "secrets.json"),
+    logs: path3.join(base, "logs")
+  };
+}
+function ensureDirs(p) {
+  for (const d of [
+    p.root,
+    p.workspace,
+    p.attachments,
+    p.skills,
+    p.backups,
+    p.logs,
+    path3.join(p.workspace, "projects"),
+    path3.join(p.workspace, "bots")
+  ]) {
+    fs2.mkdirSync(d, { recursive: true });
+  }
+}
+
+// packages/server/dist/config/config.js
+var DEFAULT_PORT = 4780;
+var DEFAULT_HOST = "127.0.0.1";
+function loadConfig(root) {
+  const paths = resolvePaths(root);
+  ensureDirs(paths);
+  let raw = {};
+  if (fs3.existsSync(paths.config)) {
+    try {
+      raw = parseToml(fs3.readFileSync(paths.config, "utf8"));
+    } catch {
+      raw = {};
+    }
+  }
+  const server = raw.server ?? {};
+  const settings = SettingsSchema.parse({
+    ...typeof raw.settings === "object" && raw.settings ? raw.settings : {},
+    timezone: raw.settings?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC"
+  });
+  const cfg = {
+    paths,
+    settings,
+    port: Number(process.env.ANTBOT_PORT ?? server.port ?? DEFAULT_PORT),
+    host: String(server.host ?? DEFAULT_HOST)
+  };
+  if (!fs3.existsSync(paths.config))
+    writeConfig(cfg);
+  return cfg;
+}
+function writeConfig(cfg) {
+  fs3.writeFileSync(cfg.paths.config, stringifyToml({ server: { port: cfg.port, host: cfg.host }, settings: cfg.settings }));
+}
+
+// packages/cli/src/serverBridge.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+function packageRootOf(from, exists) {
+  let dir = path4.resolve(from);
+  for (; ; ) {
+    if (exists(path4.join(dir, "package.json"))) return dir;
+    const parent = path4.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolveServerPackageDir(deps) {
+  try {
+    return deps.realpath(path4.dirname(deps.resolve("@antbot/server/package.json")));
+  } catch {
+  }
+  const pkg = packageRootOf(deps.here, deps.exists);
+  if (pkg) {
+    const link = path4.join(pkg, "node_modules", "@antbot", "server");
+    if (deps.exists(link)) {
+      try {
+        return deps.realpath(link);
+      } catch {
+      }
+    }
+    return pkg;
+  }
+  return null;
+}
+var require_ = createRequire(import.meta.url);
+function findServerPackageDir() {
+  return resolveServerPackageDir({
+    here: path4.dirname(fileURLToPath2(import.meta.url)),
+    resolve: (s) => require_.resolve(s),
+    realpath: (p) => fs4.realpathSync(p),
+    exists: (p) => fs4.existsSync(p)
+  });
+}
+async function importServerDependency(specifier) {
+  const serverDir = findServerPackageDir();
+  if (!serverDir) {
+    throw new Error(`could not locate the @antbot/server package to resolve "${specifier}"`);
+  }
+  const req = createRequire(path4.join(serverDir, "package.json"));
+  const resolved = req.resolve(specifier);
+  return import(pathToFileURL(resolved).href);
+}
+function serverModuleCandidates(bareSpecifier, bundledFile, deps) {
+  const out = [bareSpecifier];
+  const pkg = packageRootOf(deps.here, deps.exists);
+  if (pkg) {
+    const sibling = path4.join(pkg, "dist", bundledFile);
+    if (deps.exists(sibling)) out.push(pathToFileURL(sibling).href);
+  }
+  return out;
+}
+function candidates(bare, bundled) {
+  return serverModuleCandidates(bare, bundled, {
+    here: path4.dirname(fileURLToPath2(import.meta.url)),
+    exists: (p) => fs4.existsSync(p)
+  });
+}
+async function importFirst(specs, what) {
+  let firstError;
+  for (const spec of specs) {
+    try {
+      return await import(spec);
+    } catch (err) {
+      firstError ??= err;
+    }
+  }
+  throw new Error(`could not load ${what}: ${firstError?.message ?? "not found"}`);
+}
+async function startAntbotServer(opts) {
+  const mod = await importFirst(candidates("@antbot/server", "server.js"), "the ant-bot daemon");
+  if (typeof mod.startServer !== "function") {
+    throw new Error("@antbot/server does not export startServer() yet.");
+  }
+  return mod.startServer(opts);
+}
+async function importSkillSpec() {
+  return await importFirst(
+    candidates("@antbot/server/skills/spec.js", "skills-spec.js"),
+    "the skill spec validator"
+  );
+}
+
+// packages/cli/src/color.ts
+var noColor = Boolean(process.env.NO_COLOR) || !process.stdout.isTTY;
+function wrap(code) {
+  return (s) => noColor ? s : `\x1B[${code}m${s}\x1B[0m`;
+}
+var bold = wrap("1");
+var dim = wrap("2");
+var red = wrap("31");
+var green = wrap("32");
+var yellow = wrap("33");
+var cyan = wrap("36");
+
+// packages/cli/src/daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import fs6 from "node:fs";
+import path6 from "node:path";
+
+// packages/cli/src/pid.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+function pidFilePath(dataDir) {
+  return path5.join(dataDir, "antbot.pid");
+}
+function readPidFile(file) {
+  try {
+    const raw = fs5.readFileSync(file, "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data.pid === "number" && typeof data.port === "number") {
+      return { pid: data.pid, port: data.port, startedAt: data.startedAt ?? 0 };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writePidFile(file, data) {
+  fs5.mkdirSync(path5.dirname(file), { recursive: true });
+  fs5.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+function removePidFile(file) {
+  try {
+    fs5.unlinkSync(file);
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/daemon.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function loadPaths() {
+  const paths = resolvePaths();
+  ensureDirs(paths);
+  return paths;
+}
+async function cmdStartForeground(port, openAfter = false) {
+  const cfg = loadConfig();
+  const resolvedPort = port ?? cfg.port;
+  try {
+    const instance = await startAntbotServer({ port: resolvedPort, host: cfg.host });
+    console.log(green(`antbot listening on http://${cfg.host}:${resolvedPort}`));
+    if (openAfter) openInBrowser(`http://127.0.0.1:${resolvedPort}`);
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      console.log(dim(`Received ${signal}, shutting down...`));
+      try {
+        await instance.close?.();
+      } finally {
+        process.exit(0);
+      }
+    };
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    return 0;
+  } catch (err) {
+    console.error(red(`Failed to start antbot: ${err.message}`));
+    return 1;
+  }
+}
+async function cmdStartDetached(port, openAfter = false) {
+  const cfg = loadConfig();
+  const paths = loadPaths();
+  const resolvedPort = port ?? cfg.port ?? DEFAULT_PORT;
+  const pidPath = pidFilePath(paths.root);
+  const existing = readPidFile(pidPath);
+  if (existing && isProcessAlive(existing.pid)) {
+    console.log(`antbot is already running at http://127.0.0.1:${existing.port} (pid ${existing.pid}).`);
+    if (openAfter) openInBrowser(`http://127.0.0.1:${existing.port}`);
+    return 0;
+  }
+  if (existing) removePidFile(pidPath);
+  const logPath = path6.join(paths.logs, "antbot.log");
+  fs6.mkdirSync(paths.logs, { recursive: true });
+  const logFd = fs6.openSync(logPath, "a");
+  const selfEntry = process.argv[1];
+  if (!selfEntry) {
+    console.error(red("Could not determine the antbot entry point to spawn."));
+    return 1;
+  }
+  const child = spawn2(
+    process.execPath,
+    [selfEntry, "start", "--foreground", "--port", String(resolvedPort)],
+    { detached: true, stdio: ["ignore", logFd, logFd] }
+  );
+  child.unref();
+  if (!child.pid) {
+    console.error(red("Failed to spawn the antbot daemon."));
+    return 1;
+  }
+  writePidFile(pidPath, { pid: child.pid, port: resolvedPort, startedAt: Date.now() });
+  console.log(`Starting antbot (pid ${child.pid}) on port ${resolvedPort}...`);
+  const ok = await waitForHealth(resolvedPort, 3e4);
+  if (!ok) {
+    console.error(red(`Timed out waiting for antbot to become healthy. Check ${logPath}`));
+    return 1;
+  }
+  console.log(green(`antbot is running at http://127.0.0.1:${resolvedPort}`));
+  if (openAfter) openInBrowser(`http://127.0.0.1:${resolvedPort}`);
+  return 0;
+}
+async function cmdStop() {
+  const paths = loadPaths();
+  const pidPath = pidFilePath(paths.root);
+  const data = readPidFile(pidPath);
+  if (!data || !isProcessAlive(data.pid)) {
+    console.log("antbot is not running.");
+    if (data) removePidFile(pidPath);
+    return 0;
+  }
+  console.log(`Stopping antbot (pid ${data.pid})...`);
+  try {
+    process.kill(data.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + 1e4;
+  while (Date.now() < deadline && isProcessAlive(data.pid)) {
+    await sleep2(200);
+  }
+  if (isProcessAlive(data.pid)) {
+    console.log(yellow("Process did not exit in time, sending SIGKILL."));
+    try {
+      process.kill(data.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removePidFile(pidPath);
+  console.log(green("antbot stopped."));
+  return 0;
+}
+async function cmdStatus() {
+  const paths = loadPaths();
+  const pidPath = pidFilePath(paths.root);
+  const data = readPidFile(pidPath);
+  const alive = !!data && isProcessAlive(data.pid);
+  if (!alive || !data) {
+    const cfgPort = loadConfig().port ?? DEFAULT_PORT;
+    const probe = await getHealth(cfgPort);
+    if (!probe.ok) {
+      console.log(red("antbot is not running."));
+      return 1;
+    }
+    const count = await getBotCount(cfgPort);
+    console.log(green("antbot is running (started outside the CLI \u2014 no pidfile)"));
+    console.log(`  URL:      http://127.0.0.1:${cfgPort}`);
+    console.log(`  Version:  ${probe.version ?? "unknown"}`);
+    console.log(`  Data dir: ${paths.root}`);
+    console.log(`  Bots:     ${count ?? "unknown"}`);
+    console.log(yellow("  Note: `antbot stop` cannot stop it; stop it where it was started."));
+    return 0;
+  }
+  const health = await getHealth(data.port);
+  const botCount = health.ok ? await getBotCount(data.port) : null;
+  console.log(green(`antbot is running (pid ${data.pid})`));
+  console.log(`  URL:      http://127.0.0.1:${data.port}`);
+  console.log(`  Version:  ${health.version ?? "unknown"}`);
+  console.log(`  Data dir: ${paths.root}`);
+  console.log(`  Bots:     ${botCount ?? "unknown"}`);
+  if (!health.ok) {
+    console.log(yellow("  Warning: process is alive but /api/health is not responding."));
+  }
+  return health.ok ? 0 : 1;
+}
+function openInBrowser(url) {
+  console.log(url);
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const child = spawn2(opener, [url], {
+      stdio: "ignore",
+      detached: true,
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => {
+      console.log(dim(`Could not launch a browser automatically. Open ${url} manually.`));
+    });
+    child.unref();
+  } catch {
+    console.log(dim(`Could not launch a browser automatically. Open ${url} manually.`));
+  }
+}
+async function cmdRestart(port) {
+  const stopCode = await cmdStop();
+  if (stopCode !== 0) return stopCode;
+  return cmdStartDetached(port);
+}
+async function cmdOpen() {
+  const paths = loadPaths();
+  const cfg = loadConfig();
+  const pidPath = pidFilePath(paths.root);
+  const data = readPidFile(pidPath);
+  const port = data?.port ?? cfg.port ?? DEFAULT_PORT;
+  const health = await getHealth(port);
+  if (!health.ok) {
+    console.log(dim("antbot is not running \u2014 starting it first..."));
+    const code = await cmdStartDetached(port);
+    if (code !== 0) return code;
+  }
+  openInBrowser(`http://127.0.0.1:${port}`);
+  return 0;
+}
+
+// packages/cli/src/backup.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+function computeBackupItems(input) {
+  const items = [
+    { source: input.dbPath, archivePath: "antbot.db" },
+    { source: input.configPath, archivePath: "config.toml" },
+    { source: input.skillsDir, archivePath: "skills" }
+  ];
+  for (const slug of input.botSlugs) {
+    items.push({
+      source: path7.join(input.botsDir, slug, "memory"),
+      archivePath: `workspace/bots/${slug}/memory`
+    });
+  }
+  return items;
+}
+function listBotSlugs(botsDir) {
+  try {
+    return fs7.readdirSync(botsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+async function createBackup(opts) {
+  const botSlugs = listBotSlugs(opts.botsDir);
+  const allItems = computeBackupItems({
+    dbPath: opts.dbPath,
+    configPath: opts.configPath,
+    skillsDir: opts.skillsDir,
+    botsDir: opts.botsDir,
+    botSlugs
+  });
+  const items = allItems.filter((item) => fs7.existsSync(item.source));
+  if (items.length === 0) {
+    throw new Error("Nothing to back up: no antbot.db, config.toml, skills, or bot memory found.");
+  }
+  fs7.mkdirSync(path7.dirname(opts.outPath), { recursive: true });
+  const relPaths = items.map((item) => path7.relative(opts.root, item.source));
+  const args = ["czf", opts.outPath, "-C", opts.root, ...relPaths];
+  let res;
+  try {
+    res = await runCommand("tar", args);
+  } catch (err) {
+    throw new Error(
+      `Could not run "tar": ${err.message}. Is tar installed and on PATH?`,
+      { cause: err }
+    );
+  }
+  if (res.code !== 0) {
+    throw new Error(`tar exited with code ${res.code}: ${res.stderr.trim()}`);
+  }
+  const { size } = fs7.statSync(opts.outPath);
+  return { outPath: opts.outPath, bytes: size, items };
+}
+async function restoreBackup(opts) {
+  if (!fs7.existsSync(opts.archivePath)) {
+    throw new Error(`Backup file not found: ${opts.archivePath}`);
+  }
+  fs7.mkdirSync(opts.root, { recursive: true });
+  let res;
+  try {
+    res = await runCommand("tar", ["xzf", opts.archivePath, "-C", opts.root]);
+  } catch (err) {
+    throw new Error(
+      `Could not run "tar": ${err.message}. Is tar installed and on PATH?`,
+      { cause: err }
+    );
+  }
+  if (res.code !== 0) {
+    throw new Error(`tar exited with code ${res.code}: ${res.stderr.trim()}`);
+  }
+}
+
+// packages/cli/src/skill.ts
+import fs8 from "node:fs";
+import path8 from "node:path";
+var USAGE = `Usage:
+  antbot skill list
+  antbot skill add <source>
+  antbot skill remove <slug>
+  antbot skill lint [path]`;
+async function runSkillCommand(argv, port) {
+  const [sub, ...rest] = argv;
+  if (!sub || sub === "list") return listSkills(port);
+  if (sub === "add") return addSkill(rest, port);
+  if (sub === "remove" || sub === "rm") return removeSkill(rest, port);
+  if (sub === "lint" || sub === "check") return lintSkills(rest);
+  console.error(red(`Unknown subcommand "${sub}".
+${USAGE}`));
+  return 2;
+}
+function notRunning(err) {
+  console.error(red(`Could not reach the antbot daemon: ${err.message}`));
+  console.error(dim("Start it with `antbot start`."));
+  return 1;
+}
+async function listSkills(port) {
+  let skills;
+  try {
+    skills = await getJson(port, "/api/skills");
+  } catch (err) {
+    return notRunning(err);
+  }
+  if (!skills.length) {
+    console.log("No skills installed. Add one with `antbot skill add <source>`.");
+    return 0;
+  }
+  const width = Math.max(...skills.map((s) => s.slug.length));
+  for (const s of skills) {
+    console.log(`${bold(s.slug.padEnd(width))}  ${s.description || s.name}`);
+  }
+  console.log("");
+  console.log(dim(`${skills.length} skill(s). Assign them to a bot in Bot settings \u2192 Skills.`));
+  return 0;
+}
+async function addSkill(args, port) {
+  const source = args[0];
+  if (!source) {
+    console.error(red(`A source is required.
+${USAGE}`));
+    return 2;
+  }
+  let res;
+  try {
+    res = await postJson(port, "/api/skills/install", { source });
+  } catch (err) {
+    const message = err.message;
+    if (/ECONNREFUSED|not reach/i.test(message)) return notRunning(err);
+    console.error(red(message));
+    return 1;
+  }
+  for (const item of res.installed) {
+    console.log(item.manifest.replace(/^✓ Installed/, green("\u2713 Installed")));
+    if (item.replaced) console.log(dim("  (upgraded in place; existing bot assignments kept)"));
+    console.log("");
+  }
+  const names = res.installed.map((i) => i.skill.slug).join(", ");
+  console.log(dim(`Assign to a bot in Bot settings \u2192 Skills: ${names}`));
+  return 0;
+}
+async function removeSkill(args, port) {
+  const slug = args[0];
+  if (!slug) {
+    console.error(red(`A slug is required.
+${USAGE}`));
+    return 2;
+  }
+  let skills;
+  try {
+    skills = await getJson(port, "/api/skills");
+  } catch (err) {
+    return notRunning(err);
+  }
+  const match = skills.find((s) => s.slug === slug || s.name === slug);
+  if (!match) {
+    console.error(red(`No skill named "${slug}".`));
+    console.error(dim(`Installed: ${skills.map((s) => s.slug).join(", ") || "(none)"}`));
+    return 1;
+  }
+  try {
+    await deleteJson(port, `/api/skills/${match.id}`);
+  } catch (err) {
+    return notRunning(err);
+  }
+  console.log(green(`\u2713 Removed '${match.slug}'`));
+  console.log(dim(yellow("Bots that had it assigned no longer have it.")));
+  return 0;
+}
+async function lintSkills(args) {
+  const target = args[0];
+  let spec;
+  try {
+    spec = await importSkillSpec();
+  } catch (err) {
+    console.error(red(`Could not load the skill validator: ${err.message}`));
+    return 1;
+  }
+  let results;
+  let scanned;
+  if (target) {
+    const dir = path8.resolve(target);
+    if (!fs8.existsSync(dir)) {
+      console.error(red(`No such directory: ${dir}`));
+      return 2;
+    }
+    scanned = dir;
+    results = fs8.existsSync(path8.join(dir, "SKILL.md")) ? [{ slug: path8.basename(dir), violations: spec.validateSkillDir(dir) }] : spec.validateSkillsIn(dir);
+  } else {
+    scanned = path8.join(loadPaths().skills, "skills");
+    results = spec.validateSkillsIn(scanned);
+  }
+  if (results.length === 0) {
+    console.log(`No skills found in ${scanned}.`);
+    return 0;
+  }
+  let errors = 0;
+  let warnings = 0;
+  const width = Math.max(...results.map((r) => r.slug.length));
+  for (const { slug, violations } of results) {
+    if (violations.length === 0) {
+      console.log(`${green("\u2713")} ${bold(slug.padEnd(width))}  ${dim("conforms to the spec")}`);
+      continue;
+    }
+    const worst = violations.some((v) => v.level === "error") ? red("\u2717") : yellow("\u26A0");
+    console.log(`${worst} ${bold(slug.padEnd(width))}`);
+    for (const v of violations) {
+      if (v.level === "error") errors++;
+      else warnings++;
+      const tag = v.level === "error" ? red("error") : yellow("warn ");
+      console.log(`   ${tag} ${dim(v.code)}  ${v.message}`);
+    }
+  }
+  console.log("");
+  if (errors > 0) {
+    console.log(red(`${errors} error(s), ${warnings} warning(s) across ${results.length} skill(s).`));
+    console.log(dim("See skills/SPEC.md, or the skill-author skill, for how to fix each one."));
+    return 1;
+  }
+  if (warnings > 0) {
+    console.log(yellow(`${warnings} warning(s) across ${results.length} skill(s).`));
+    return 0;
+  }
+  console.log(green(`All ${results.length} skill(s) conform to the spec.`));
+  return 0;
+}
+
+// packages/cli/src/updateCommand.ts
+import fs9 from "node:fs";
+import path10 from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// packages/cli/src/update.ts
+import path9 from "node:path";
+var PACKAGE_NAME = "@michael-joseph-miller/ant-bot";
+var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
+var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+function parse(version) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(version.trim());
+  if (!m) return null;
+  return { parts: [Number(m[1]), Number(m[2]), Number(m[3])], prerelease: m[4] ?? null };
+}
+function compareVersions(a, b) {
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return 0;
+  for (let i = 0; i < 3; i++) {
+    if (pa.parts[i] !== pb.parts[i]) return pa.parts[i] - pb.parts[i];
+  }
+  if (pa.prerelease === pb.prerelease) return 0;
+  if (pa.prerelease === null) return 1;
+  if (pb.prerelease === null) return -1;
+  return pa.prerelease < pb.prerelease ? -1 : 1;
+}
+function isUpgrade(current, latest) {
+  const c = parse(current);
+  const l = parse(latest);
+  if (!c || !l) return false;
+  if (l.prerelease !== null && c.prerelease === null) return false;
+  return compareVersions(latest, current) > 0;
+}
+function planUpdateCheck(cache, now, ttlMs = UPDATE_CHECK_TTL_MS) {
+  if (!cache || typeof cache.checkedAt !== "number" || typeof cache.latest !== "string") return "fetch";
+  if (cache.checkedAt > now) return "fetch";
+  return now - cache.checkedAt < ttlMs ? "use-cache" : "fetch";
+}
+function detectPackageManager(installPath2) {
+  const p = installPath2.split(path9.sep).join("/");
+  if (/\/\.bun\//.test(p)) return "bun";
+  if (/\/\.pnpm\//.test(p) || /\/pnpm\/(global|store)\//.test(p) || /\/Library\/pnpm\//.test(p)) return "pnpm";
+  if (/\/\.yarn\//.test(p) || /\/yarn\/global\//.test(p) || /\/\.config\/yarn\//.test(p)) return "yarn";
+  return "npm";
+}
+function updateCommand(pm, pkg = PACKAGE_NAME) {
+  switch (pm) {
+    case "pnpm":
+      return { cmd: "pnpm", args: ["add", "-g", `${pkg}@latest`] };
+    case "yarn":
+      return { cmd: "yarn", args: ["global", "add", `${pkg}@latest`] };
+    case "bun":
+      return { cmd: "bun", args: ["add", "-g", `${pkg}@latest`] };
+    case "npm":
+    default:
+      return { cmd: "npm", args: ["install", "-g", `${pkg}@latest`] };
+  }
+}
+function isCheckoutInstall(installPath2, exists) {
+  if (installPath2.split(path9.sep).includes("node_modules")) return false;
+  let dir = path9.resolve(installPath2);
+  for (; ; ) {
+    if (exists(path9.join(dir, ".git"))) return true;
+    const parent = path9.dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+function updateNotice(current, latest) {
+  if (!latest || !isUpgrade(current, latest)) return null;
+  return `A newer ant-bot is available: ${current} \u2192 ${latest}. Run \`antbot update\`.`;
+}
+async function checkForUpdate(deps) {
+  let cache = null;
+  try {
+    const raw = deps.readCache();
+    if (raw) cache = JSON.parse(raw);
+  } catch {
+  }
+  let latest;
+  let cached = false;
+  if (planUpdateCheck(cache, deps.now, deps.ttlMs) === "use-cache") {
+    latest = cache.latest;
+    cached = true;
+  } else {
+    try {
+      latest = await deps.fetchLatest();
+      if (latest) {
+        deps.writeCache(`${JSON.stringify({ latest, checkedAt: deps.now })}
+`);
+      }
+    } catch {
+      latest = cache?.latest ?? null;
+      cached = latest !== null;
+    }
+  }
+  return {
+    current: deps.currentVersion,
+    latest,
+    isUpgrade: latest !== null && isUpgrade(deps.currentVersion, latest),
+    cached,
+    notice: updateNotice(deps.currentVersion, latest)
+  };
+}
+async function fetchLatestVersion(timeoutMs = 3e3) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: ac.signal,
+      headers: { accept: "application/vnd.npm.install-v1+json" }
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return typeof body.version === "string" ? body.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// packages/cli/src/updateCommand.ts
+var CACHE_FILE = "update-check.json";
+function cachePath() {
+  return path10.join(loadPaths().root, CACHE_FILE);
+}
+function installPath() {
+  return path10.dirname(fileURLToPath3(import.meta.url));
+}
+async function currentUpdateStatus() {
+  const file = cachePath();
+  return checkForUpdate({
+    currentVersion: getCliVersion(),
+    now: Date.now(),
+    readCache: () => {
+      try {
+        return fs9.readFileSync(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    writeCache: (contents) => {
+      try {
+        fs9.mkdirSync(path10.dirname(file), { recursive: true });
+        fs9.writeFileSync(file, contents, "utf8");
+      } catch {
+      }
+    },
+    fetchLatest: () => fetchLatestVersion()
+  });
+}
+async function printUpdateNotice() {
+  if (isCheckoutInstall(installPath(), (p) => fs9.existsSync(p))) return;
+  const status = await currentUpdateStatus();
+  if (status.notice) console.log(yellow(`  ${status.notice}`));
+}
+async function runUpdateCommand(opts) {
+  const here = installPath();
+  const current = getCliVersion();
+  if (isCheckoutInstall(here, (p) => fs9.existsSync(p))) {
+    console.error(red("This is a git checkout, not a package-manager install."));
+    console.error(dim("Update it with:  git pull && pnpm install"));
+    return 2;
+  }
+  const status = await currentUpdateStatus();
+  if (status.latest === null) {
+    console.error(red("Could not reach the npm registry to check for updates."));
+    return 1;
+  }
+  if (!status.isUpgrade) {
+    console.log(green(`ant-bot ${current} is up to date.`) + (status.cached ? dim(" (cached)") : ""));
+    return 0;
+  }
+  console.log(bold(`ant-bot ${current} \u2192 ${status.latest}`));
+  if (opts.check) return 0;
+  const pm = detectPackageManager(here);
+  const { cmd, args } = updateCommand(pm);
+  if (!opts.yes) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(`Run \`${cmd} ${args.join(" ")}\`? [y/N] `);
+    rl.close();
+    if (!/^y(es)?$/i.test(answer.trim())) {
+      console.log("Aborted.");
+      return 0;
+    }
+  }
+  console.log(dim(`$ ${cmd} ${args.join(" ")}`));
+  const result = await runCommand(cmd, args);
+  if (result.code !== 0) {
+    console.error(red(`${cmd} exited with code ${result.code}`));
+    if (result.stderr) console.error(dim(result.stderr.trim()));
+    return 1;
+  }
+  try {
+    fs9.rmSync(cachePath(), { force: true });
+  } catch {
+  }
+  console.log(green(`Updated to ${status.latest}.`));
+  console.log(dim("Restart a running daemon to pick it up:  antbot restart"));
+  return 0;
+}
+
+// packages/cli/src/index.ts
+async function runDoctorCommand() {
+  const paths = loadPaths();
+  const port = 4780;
+  const report = await runDoctor({
+    nodeVersion: process.versions.node,
+    env: process.env,
+    homeDir: process.env.HOME ?? process.env.USERPROFILE ?? "",
+    dataDir: paths.root,
+    port,
+    fileExists: (p) => fs10.existsSync(p),
+    fileSize: (p) => {
+      try {
+        return fs10.statSync(p).size;
+      } catch {
+        return 0;
+      }
+    },
+    isDirWritable: (dir) => {
+      try {
+        fs10.mkdirSync(dir, { recursive: true });
+        fs10.accessSync(dir, fs10.constants.W_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    exec: (cmd, args) => runCommand(cmd, args),
+    probePort: (p) => probePort(p),
+    healthCheck: (p) => getHealth(p),
+    importBetterSqlite3: () => importServerDependency("better-sqlite3"),
+    importPlaywright: async () => {
+      const mod = await importServerDependency("playwright");
+      const pw = mod.default ?? mod;
+      if (!pw.chromium) throw new Error("playwright module has no chromium export");
+      return { chromium: pw.chromium };
+    }
+  });
+  renderDoctorTable(report.results);
+  return report.exitCode;
+}
+function symbolFor(status) {
+  if (status === "pass") return green("\u2713");
+  if (status === "warn") return yellow("\u26A0");
+  return red("\u2717");
+}
+function renderDoctorTable(results) {
+  const nameWidth = Math.max(...results.map((r) => r.name.length));
+  for (const r of results) {
+    console.log(`${symbolFor(r.status)} ${bold(r.name.padEnd(nameWidth))}  ${r.message}`);
+    if (r.hint && r.status !== "pass") {
+      console.log(`   ${dim(`-> ${r.hint}`)}`);
+    }
+  }
+  const failed = results.filter((r) => r.status === "fail").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  console.log("");
+  if (failed > 0) {
+    console.log(red(`${failed} check(s) failed, ${warned} warning(s).`));
+  } else if (warned > 0) {
+    console.log(yellow(`All checks passed with ${warned} warning(s).`));
+  } else {
+    console.log(green("All checks passed."));
+  }
+}
+async function runBackupCommand(outFlag) {
+  const paths = loadPaths();
+  const outPath = outFlag ?? path11.join(paths.backups, `antbot-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.tar.gz`);
+  try {
+    const result = await createBackup({
+      root: paths.root,
+      dbPath: paths.db,
+      configPath: paths.config,
+      skillsDir: paths.skills,
+      botsDir: path11.join(paths.workspace, "bots"),
+      outPath
+    });
+    const kb = (result.bytes / 1024).toFixed(1);
+    console.log(green(`Backup written to ${result.outPath} (${kb} KB)`));
+    return 0;
+  } catch (err) {
+    console.error(red(err.message));
+    return 1;
+  }
+}
+async function runRestoreCommand(archivePath, skipConfirm) {
+  if (!archivePath) {
+    console.error(red("Usage: antbot restore <path> [--yes]"));
+    return 2;
+  }
+  const paths = loadPaths();
+  if (!skipConfirm) {
+    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(
+      `This will overwrite files under ${paths.root} with the contents of ${archivePath}. Continue? [y/N] `
+    );
+    rl.close();
+    if (!/^y(es)?$/i.test(answer.trim())) {
+      console.log("Aborted.");
+      return 0;
+    }
+  }
+  try {
+    await restoreBackup({ archivePath, root: paths.root });
+    console.log(green(`Restored ${archivePath} into ${paths.root}`));
+    return 0;
+  } catch (err) {
+    console.error(red(err.message));
+    return 1;
+  }
+}
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(red(err.message));
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (parsed.version) {
+    console.log(getCliVersion());
+    process.exit(0);
+  }
+  if (parsed.help || !parsed.command) {
+    console.log(parsed.command ? commandHelp(parsed.command) : GLOBAL_HELP);
+    process.exit(0);
+  }
+  const command = parsed.command;
+  switch (command) {
+    case "start": {
+      const port = typeof parsed.flags.port === "number" ? parsed.flags.port : void 0;
+      const foreground = Boolean(parsed.flags.foreground);
+      const openAfter = Boolean(parsed.flags.open);
+      if (foreground) {
+        const code = await cmdStartForeground(port, openAfter);
+        if (code !== 0) process.exit(code);
+        return;
+      }
+      process.exit(await cmdStartDetached(port, openAfter));
+      return;
+    }
+    case "stop":
+      process.exit(await cmdStop());
+      return;
+    case "restart":
+      process.exit(await cmdRestart(typeof parsed.flags.port === "number" ? parsed.flags.port : void 0));
+      return;
+    // The update notice is printed here rather than inside the commands themselves: it is the
+    // only thing in the CLI that touches the network, and keeping it at the dispatch layer means
+    // neither cmdStatus nor runDoctor grows a dependency on it.
+    case "status": {
+      const code = await cmdStatus();
+      await printUpdateNotice();
+      process.exit(code);
+      return;
+    }
+    case "doctor": {
+      const code = await runDoctorCommand();
+      await printUpdateNotice();
+      process.exit(code);
+      return;
+    }
+    case "open":
+      process.exit(await cmdOpen());
+      return;
+    case "skill": {
+      const cfg = loadConfig();
+      process.exit(await runSkillCommand(parsed.positionals, cfg.port));
+      return;
+    }
+    case "backup":
+      process.exit(await runBackupCommand(typeof parsed.flags.out === "string" ? parsed.flags.out : void 0));
+      return;
+    case "restore":
+      process.exit(await runRestoreCommand(parsed.positionals[0], Boolean(parsed.flags.yes)));
+      return;
+    case "update":
+      process.exit(
+        await runUpdateCommand({ check: Boolean(parsed.flags.check), yes: Boolean(parsed.flags.yes) })
+      );
+      return;
+    default: {
+      const _exhaustive = command;
+      throw new Error(`Unhandled command: ${String(_exhaustive)}`);
+    }
+  }
+}
+main().catch((err) => {
+  console.error(red(`antbot: ${err.stack ?? err.message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map