@birdybeep/cli 0.0.1

package/dist/bin.cjs

@@ -0,0 +1,941 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/commands/agent.ts
+var import_claude_code = require("@birdybeep/claude-code");
+var import_codex = require("@birdybeep/codex");
+var import_opencode = require("@birdybeep/opencode");
+
+// src/framework.ts
+var import_node_fs = require("fs");
+var import_agent_core = require("@birdybeep/agent-core");
+var EXIT = { OK: 0, ERROR: 1, USAGE: 2 };
+function createIo(json, stdout, stderr) {
+  return {
+    json,
+    line: (text) => {
+      if (!json) stdout.write(`${text}
+`);
+    },
+    errline: (text) => stderr.write(`${text}
+`),
+    result: (value) => {
+      if (json) stdout.write(`${JSON.stringify(value)}
+`);
+    },
+    emit: (human, value) => {
+      if (json) stdout.write(`${JSON.stringify(value)}
+`);
+      else stdout.write(`${human}
+`);
+    }
+  };
+}
+var MissingInputError = class extends Error {
+  constructor(field) {
+    super(`missing required value: ${field}`);
+    this.field = field;
+    this.name = "MissingInputError";
+  }
+  field;
+};
+var GLOBAL_FLAG_TOKENS = /* @__PURE__ */ new Set([
+  "--json",
+  "--non-interactive",
+  "--version",
+  "-v",
+  "--help",
+  "-h"
+]);
+function parseGlobalFlags(argv) {
+  const flags = { json: false, nonInteractive: false, help: false, version: false };
+  const rest = [];
+  for (const token of argv) {
+    switch (token) {
+      case "--json":
+        flags.json = true;
+        break;
+      case "--non-interactive":
+        flags.nonInteractive = true;
+        break;
+      case "--version":
+      case "-v":
+        flags.version = true;
+        break;
+      case "--help":
+      case "-h":
+        flags.help = true;
+        break;
+      default:
+        rest.push(token);
+    }
+  }
+  return { flags, rest };
+}
+function isUnknownFlag(token) {
+  return token.startsWith("-") && !GLOBAL_FLAG_TOKENS.has(token);
+}
+function renderRootHelp(version, commands) {
+  const width = Math.max(...commands.map((c) => c.name.length));
+  const lines = commands.map((c) => `  ${c.name.padEnd(width)}  ${c.summary}`);
+  return [
+    `birdybeep ${version} \u2014 stream coding-agent lifecycle events to BirdyBeep.`,
+    "",
+    "Usage:",
+    "  birdybeep <command> [options]",
+    "",
+    "Commands:",
+    ...lines,
+    "",
+    "Global options:",
+    "  --json              Machine-readable JSON output",
+    "  --non-interactive   Never prompt; fail fast if input is required",
+    "  -h, --help          Show help (root or per-command)",
+    "  -v, --version       Show the CLI version"
+  ].join("\n");
+}
+function renderCommandHelp(path, command) {
+  const lines = [
+    `birdybeep ${path} \u2014 ${command.summary}`,
+    "",
+    "Usage:",
+    `  ${command.usage ?? `birdybeep ${path} [options]`}`
+  ];
+  if (command.subcommands && command.subcommands.length > 0) {
+    const width = Math.max(...command.subcommands.map((c) => c.name.length));
+    lines.push(
+      "",
+      "Subcommands:",
+      ...command.subcommands.map((c) => `  ${c.name.padEnd(width)}  ${c.summary}`)
+    );
+  }
+  return lines.join("\n");
+}
+async function dispatch(argv, deps) {
+  const { flags, rest } = parseGlobalFlags(argv);
+  const io = createIo(flags.json, deps.stdout, deps.stderr);
+  if (deps.ensureConfig !== false) {
+    try {
+      (0, import_node_fs.mkdirSync)((0, import_agent_core.birdyBeepConfigDir)(), { recursive: true, mode: 448 });
+    } catch {
+    }
+  }
+  if (flags.version) {
+    io.emit(deps.version, { version: deps.version });
+    return EXIT.OK;
+  }
+  let command = deps.commands.find((c) => c.name === rest[0]);
+  const pathParts = [];
+  let argsStart = 1;
+  if (command) {
+    pathParts.push(command.name);
+    if (command.subcommands && command.subcommands.length > 0) {
+      const sub = command.subcommands.find((c) => c.name === rest[1]);
+      if (sub) {
+        command = sub;
+        pathParts.push(sub.name);
+        argsStart = 2;
+      }
+    }
+  }
+  if (rest.length === 0 || flags.help && command === void 0) {
+    io.emit(renderRootHelp(deps.version, deps.commands), {
+      version: deps.version,
+      commands: deps.commands.map((c) => ({ name: c.name, summary: c.summary }))
+    });
+    return EXIT.OK;
+  }
+  if (command === void 0) {
+    io.errline(`birdybeep: unknown command "${rest[0]}". Run \`birdybeep --help\`.`);
+    return EXIT.USAGE;
+  }
+  const path = pathParts.join(" ");
+  if (flags.help) {
+    io.emit(renderCommandHelp(path, command), {
+      name: path,
+      summary: command.summary,
+      usage: command.usage,
+      subcommands: command.subcommands?.map((c) => ({ name: c.name, summary: c.summary }))
+    });
+    return EXIT.OK;
+  }
+  if (command.run === void 0) {
+    io.errline(renderCommandHelp(path, command));
+    return EXIT.USAGE;
+  }
+  const args = rest.slice(argsStart);
+  const unknown = args.find(isUnknownFlag);
+  if (unknown !== void 0) {
+    io.errline(`birdybeep ${path}: unknown option "${unknown}".`);
+    return EXIT.USAGE;
+  }
+  try {
+    return await command.run({ args, flags, io });
+  } catch (err) {
+    if (err instanceof MissingInputError) {
+      io.errline(
+        `birdybeep ${path}: ${err.message} (re-run without --non-interactive to be prompted).`
+      );
+      return EXIT.USAGE;
+    }
+    io.errline(`birdybeep ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    return EXIT.ERROR;
+  }
+}
+
+// src/commands/agent.ts
+var DEFAULT_ADAPTERS = [import_claude_code.claudeCodeAdapter, import_codex.codexAdapter, import_opencode.opencodeAdapter];
+var TARGET_TO_ID = {
+  claude: "claude_code",
+  codex: "codex",
+  opencode: "opencode"
+};
+var AGENT_TARGETS = ["all", "claude", "codex", "opencode"];
+function selectAdapters(target, adapters) {
+  if (target === "all") return adapters;
+  const id = TARGET_TO_ID[target];
+  if (id === void 0) return "unknown";
+  return adapters.filter((a) => a.id === id);
+}
+async function installSelected(adapters, ctx) {
+  const target = ctx.args[0] ?? "all";
+  const selected = selectAdapters(target, adapters);
+  if (selected === "unknown") {
+    ctx.io.errline(
+      `birdybeep agent install: unknown target "${target}" (expected ${AGENT_TARGETS.join("|")}).`
+    );
+    return EXIT.USAGE;
+  }
+  const outcomes = [];
+  for (const adapter of selected) {
+    const detection = await adapter.detect();
+    if (!detection.detected) {
+      outcomes.push({ harness: adapter.id, displayName: adapter.displayName, detected: false });
+      continue;
+    }
+    const result = await adapter.install();
+    outcomes.push({
+      harness: adapter.id,
+      displayName: adapter.displayName,
+      detected: true,
+      status: result.status,
+      changedFiles: result.changedFiles,
+      backupFiles: result.backupFiles,
+      requiredActions: result.requiredActions
+    });
+  }
+  if (ctx.flags.json) {
+    ctx.io.result({ target, results: outcomes });
+    return EXIT.OK;
+  }
+  if (outcomes.length === 0 || outcomes.every((o) => !o.detected)) {
+    ctx.io.line("No supported harnesses detected \u2014 nothing to install.");
+  }
+  for (const o of outcomes) {
+    if (!o.detected) {
+      ctx.io.line(`\u2013  ${o.displayName}: not detected (skipped)`);
+      continue;
+    }
+    const changed = (o.changedFiles ?? []).length > 0 ? o.changedFiles.join(", ") : "no changes";
+    ctx.io.line(`\u2713  ${o.displayName}: ${o.status} (${changed})`);
+    for (const action of o.requiredActions ?? []) ctx.io.line(`     \u2192 ${action}`);
+  }
+  return EXIT.OK;
+}
+async function uninstallSelected(adapters, ctx) {
+  const target = ctx.args[0] ?? "all";
+  const selected = selectAdapters(target, adapters);
+  if (selected === "unknown") {
+    ctx.io.errline(
+      `birdybeep agent uninstall: unknown target "${target}" (expected ${AGENT_TARGETS.join("|")}).`
+    );
+    return EXIT.USAGE;
+  }
+  const outcomes = [];
+  for (const adapter of selected) {
+    const result = await adapter.uninstall();
+    outcomes.push({
+      harness: adapter.id,
+      displayName: adapter.displayName,
+      changed: result.changed,
+      removedFiles: result.removedFiles,
+      restoredFiles: result.restoredFiles
+    });
+  }
+  if (ctx.flags.json) {
+    ctx.io.result({ target, results: outcomes });
+    return EXIT.OK;
+  }
+  for (const o of outcomes) {
+    if (!o.changed) {
+      ctx.io.line(`\u2013  ${o.displayName}: nothing to remove`);
+      continue;
+    }
+    const touched = [...o.removedFiles, ...o.restoredFiles].join(", ") || "config restored";
+    ctx.io.line(`\u2713  ${o.displayName}: removed (${touched})`);
+  }
+  return EXIT.OK;
+}
+function createAgentCommand(deps = {}) {
+  const adapters = deps.adapters ?? DEFAULT_ADAPTERS;
+  return {
+    name: "agent",
+    summary: "Install or uninstall harness adapters",
+    usage: "birdybeep agent <install|uninstall> [all|claude|codex|opencode]",
+    subcommands: [
+      {
+        name: "install",
+        summary: "Install adapters (all | claude | codex | opencode)",
+        usage: "birdybeep agent install [all|claude|codex|opencode]",
+        run: (ctx) => installSelected(adapters, ctx)
+      },
+      {
+        name: "uninstall",
+        summary: "Restore harness config to its pre-install state",
+        usage: "birdybeep agent uninstall [all|claude|codex|opencode]",
+        run: (ctx) => uninstallSelected(adapters, ctx)
+      }
+    ]
+  };
+}
+
+// src/commands/doctor.ts
+var import_agent_core4 = require("@birdybeep/agent-core");
+var import_claude_code2 = require("@birdybeep/claude-code");
+var import_codex2 = require("@birdybeep/codex");
+var import_opencode2 = require("@birdybeep/opencode");
+
+// src/config.ts
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+var import_agent_core2 = require("@birdybeep/agent-core");
+var DEFAULT_API_URL = "https://api.birdybeep.com";
+var CONFIG_FILE = "config.json";
+function cliConfigPath() {
+  return (0, import_node_path.join)((0, import_agent_core2.birdyBeepConfigDir)(), CONFIG_FILE);
+}
+function readCliConfig() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs2.readFileSync)(cliConfigPath(), "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeCliConfig(patch) {
+  const current = readCliConfig();
+  const merged = {};
+  const apiUrl = patch.apiUrl ?? current.apiUrl;
+  if (apiUrl !== void 0) merged.apiUrl = apiUrl;
+  (0, import_node_fs2.mkdirSync)((0, import_agent_core2.birdyBeepConfigDir)(), { recursive: true, mode: 448 });
+  (0, import_node_fs2.writeFileSync)(cliConfigPath(), `${JSON.stringify(merged, null, 2)}
+`, { mode: 384 });
+}
+function resolveApiUrl() {
+  const env = process.env["BIRDYBEEP_API_URL"];
+  if (env !== void 0 && env.length > 0) return env;
+  return readCliConfig().apiUrl ?? DEFAULT_API_URL;
+}
+
+// src/diagnostics.ts
+var import_agent_core3 = require("@birdybeep/agent-core");
+async function gatherIntegrations(adapters) {
+  return Promise.all(
+    adapters.map(async (a) => ({
+      harness: a.id,
+      displayName: a.displayName,
+      status: await a.status()
+    }))
+  );
+}
+async function isLoggedIn(tokenOptions = {}) {
+  return await (0, import_agent_core3.getToken)(tokenOptions) !== null;
+}
+function localQueueDepth() {
+  return new import_agent_core3.LocalEventQueue().size();
+}
+function machineIdentity() {
+  return (0, import_agent_core3.getMachineIdentity)();
+}
+
+// src/commands/doctor.ts
+var DEFAULT_ADAPTERS2 = [import_claude_code2.claudeCodeAdapter, import_codex2.codexAdapter, import_opencode2.opencodeAdapter];
+async function defaultProbeNetwork(baseUrl) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e3);
+    if (typeof timer.unref === "function") timer.unref();
+    const res = await fetch(baseUrl, { method: "HEAD", signal: controller.signal });
+    clearTimeout(timer);
+    return res.status < 500;
+  } catch {
+    return false;
+  }
+}
+function createDoctorCommand(deps = {}) {
+  const adapters = deps.adapters ?? DEFAULT_ADAPTERS2;
+  const probeNetwork = deps.probeNetwork ?? defaultProbeNetwork;
+  const makeSender = deps.createSender ?? ((baseUrl) => (0, import_agent_core4.createSender)(
+    deps.tokenOptions ? { baseUrl, tokenOptions: deps.tokenOptions } : { baseUrl }
+  ));
+  return {
+    name: "doctor",
+    summary: "Diagnose token, trust, restart, and offline-queue issues",
+    usage: "birdybeep doctor [--json]",
+    run: async (ctx) => {
+      const checks = [];
+      const apiUrl = resolveApiUrl();
+      const loggedIn = await isLoggedIn(deps.tokenOptions ?? {});
+      checks.push(
+        loggedIn ? { name: "Machine token", ok: true } : {
+          name: "Machine token",
+          ok: false,
+          detail: "No machine token found.",
+          remedy: "Run `birdybeep login` to pair this machine."
+        }
+      );
+      for (const adapter of adapters) {
+        const result = await adapter.doctor();
+        for (const c of result.checks) {
+          checks.push({
+            name: `${adapter.displayName}: ${c.name}`,
+            ok: c.ok,
+            ...c.detail !== void 0 ? { detail: c.detail } : {},
+            ...c.remedy !== void 0 ? { remedy: c.remedy } : {}
+          });
+        }
+      }
+      const depthBefore = localQueueDepth();
+      const drain = await makeSender(apiUrl).drainNow();
+      const depthAfter = localQueueDepth();
+      checks.push({
+        name: "Local queue",
+        ok: true,
+        detail: `${depthBefore} queued \u2192 ${drain.delivered} delivered, ${depthAfter} remaining`
+      });
+      const reachable = await probeNetwork(apiUrl);
+      checks.push(
+        reachable ? { name: "Backend reachable", ok: true } : {
+          name: "Backend reachable",
+          ok: false,
+          detail: `Could not reach ${apiUrl}.`,
+          remedy: "Check your network; queued events will retry automatically."
+        }
+      );
+      const ok = checks.every((c) => c.ok);
+      if (ctx.flags.json) {
+        ctx.io.result({
+          ok,
+          checks,
+          queue: { depthBefore, delivered: drain.delivered, depthAfter }
+        });
+      } else {
+        for (const c of checks) {
+          ctx.io.line(`${c.ok ? "\u2713" : "\u2717"}  ${c.name}${c.detail ? ` \u2014 ${c.detail}` : ""}`);
+          if (!c.ok && c.remedy) ctx.io.line(`     \u2192 ${c.remedy}`);
+        }
+        ctx.io.line(ok ? "\nAll checks passed." : "\nSome checks failed \u2014 see fixes above.");
+      }
+      return ok ? EXIT.OK : EXIT.ERROR;
+    }
+  };
+}
+
+// src/commands/hook.ts
+var import_agent_core5 = require("@birdybeep/agent-core");
+var import_claude_code3 = require("@birdybeep/claude-code");
+var import_codex3 = require("@birdybeep/codex");
+var import_opencode3 = require("@birdybeep/opencode");
+var RUNNERS = {
+  claude: import_claude_code3.runClaudeHook,
+  codex: import_codex3.runCodexHook,
+  opencode: import_opencode3.runOpenCodeHook
+};
+var HOOK_HARNESSES = ["claude", "codex", "opencode"];
+var STDIN_READ_TIMEOUT_MS = 3e3;
+function withTimeout(promise, ms, fallback) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(fallback), ms);
+    if (typeof timer.unref === "function") timer.unref();
+    void promise.then(finish, () => finish(fallback));
+  });
+}
+function isHarnessName(value) {
+  return value === "claude" || value === "codex" || value === "opencode";
+}
+function runHookCommand(harness, payload, sender) {
+  return RUNNERS[harness](payload, { sender });
+}
+function readStdinDefault() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+async function readHookPayload(args, readStdin) {
+  return args[1] ?? await readStdin();
+}
+function createHookCommand(deps = {}) {
+  const makeSender = deps.createSender ?? ((baseUrl) => (0, import_agent_core5.createSender)({ baseUrl }));
+  const readStdin = deps.readStdin ?? readStdinDefault;
+  const stdinTimeoutMs = deps.stdinTimeoutMs ?? STDIN_READ_TIMEOUT_MS;
+  return {
+    name: "hook",
+    summary: "Internal: normalize + send an event fired by a harness hook",
+    usage: "birdybeep hook <claude|codex|opencode>",
+    run: async (ctx) => {
+      const harness = ctx.args[0];
+      if (!isHarnessName(harness)) {
+        ctx.io.errline(`birdybeep hook: expected one of ${HOOK_HARNESSES.join("|")}`);
+        return EXIT.USAGE;
+      }
+      const raw = await withTimeout(readHookPayload(ctx.args, readStdin), stdinTimeoutMs, "");
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        ctx.io.result({ harness, outcome: "skipped" });
+        return EXIT.OK;
+      }
+      const sender = makeSender(resolveApiUrl());
+      const result = await runHookCommand(harness, payload, sender);
+      ctx.io.result({ harness, outcome: result.outcome, eventType: result.eventType });
+      return EXIT.OK;
+    }
+  };
+}
+
+// src/commands/login.ts
+var import_agent_core7 = require("@birdybeep/agent-core");
+var import_uqr = require("uqr");
+
+// src/pairing.ts
+var import_agent_core6 = require("@birdybeep/agent-core");
+function base(apiUrl) {
+  return apiUrl.replace(/\/$/, "");
+}
+async function pairStart(apiUrl, input, fetchImpl) {
+  const body = {
+    machine_label: input.machineLabel,
+    ...input.os !== void 0 ? { os: input.os } : {},
+    ...input.cliVersion !== void 0 ? { cli_version: input.cliVersion } : {}
+  };
+  const res = await fetchImpl(`${base(apiUrl)}/v1/pair/start`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`pairing could not be started (HTTP ${res.status})`);
+  const parsed = import_agent_core6.pairStartResponseSchema.safeParse(await res.json());
+  if (!parsed.success) throw new Error("pairing start returned an unexpected response shape");
+  return parsed.data;
+}
+async function pairTokenPoll(apiUrl, deviceCode, fetchImpl, machineFingerprint) {
+  const body = {
+    device_code: deviceCode,
+    ...machineFingerprint !== void 0 ? { machine_fingerprint: machineFingerprint } : {}
+  };
+  const res = await fetchImpl(`${base(apiUrl)}/v1/pair/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) return { status: "pending" };
+  const parsed = import_agent_core6.pairTokenResponseSchema.safeParse(await res.json());
+  if (!parsed.success) return { status: "pending" };
+  return {
+    status: "paired",
+    machineToken: parsed.data.machine_token,
+    machineId: parsed.data.machine_id
+  };
+}
+
+// src/version.ts
+var CLI_VERSION = "0.0.1".length > 0 ? "0.0.1" : "0.0.0";
+
+// src/commands/login.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+function renderQrMatrix(qrPayload) {
+  return (0, import_uqr.renderUnicodeCompact)(qrPayload, { border: 2 });
+}
+function createLoginCommand(deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const clock = deps.now ?? (() => Date.now());
+  const renderQr = deps.renderQr ?? renderQrMatrix;
+  const intervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  return {
+    name: "login",
+    summary: "Pair this machine with your BirdyBeep account (QR or manual)",
+    usage: "birdybeep login [--json]",
+    run: async (ctx) => {
+      const apiUrl = resolveApiUrl();
+      const identity = (0, import_agent_core7.getMachineIdentity)();
+      const start = await pairStart(
+        apiUrl,
+        { machineLabel: identity.label, os: identity.os, cliVersion: CLI_VERSION },
+        fetchImpl
+      );
+      if (ctx.flags.json) {
+        ctx.io.result({
+          status: "pairing_started",
+          user_code: start.user_code,
+          qr_payload: start.qr_payload,
+          expires_at: start.expires_at
+        });
+      } else {
+        ctx.io.line(
+          "To pair this machine, scan the code or open the link, then confirm in the app:"
+        );
+        const isTTY = deps.isTTY ?? process.stdout.isTTY === true;
+        if (isTTY) ctx.io.line(renderQr(start.qr_payload));
+        ctx.io.line(`   Scan or open:  ${start.qr_payload}`);
+        ctx.io.line(`   Code:  ${start.user_code}`);
+        ctx.io.line("Waiting for confirmation\u2026");
+      }
+      const deadline = Date.parse(start.expires_at);
+      let paired;
+      while (clock() < deadline) {
+        await sleep(intervalMs);
+        const poll = await pairTokenPoll(
+          apiUrl,
+          start.device_code,
+          fetchImpl,
+          identity.fingerprintHash
+        );
+        if (poll.status === "paired") {
+          paired = poll;
+          break;
+        }
+      }
+      if (paired === void 0 || paired.status !== "paired") {
+        ctx.io.result({ paired: false, reason: "timeout" });
+        ctx.io.errline(
+          "Pairing timed out before it was confirmed. Run `birdybeep login` to retry."
+        );
+        return EXIT.ERROR;
+      }
+      await (0, import_agent_core7.setToken)(paired.machineToken, deps.tokenOptions ?? {});
+      writeCliConfig({ apiUrl });
+      ctx.io.emit(`\u2713 Paired. Run \`birdybeep test\` to send a test Beep.`, {
+        paired: true,
+        machineId: paired.machineId
+      });
+      return EXIT.OK;
+    }
+  };
+}
+
+// src/commands/logout.ts
+var import_agent_core8 = require("@birdybeep/agent-core");
+function createLogoutCommand(deps = {}) {
+  return {
+    name: "logout",
+    summary: "Remove the local machine token",
+    usage: "birdybeep logout",
+    run: async (ctx) => {
+      await (0, import_agent_core8.clearToken)(deps.tokenOptions ?? {});
+      ctx.io.emit("Logged out \u2014 the machine token was removed.", { loggedOut: true });
+      return EXIT.OK;
+    }
+  };
+}
+
+// src/commands/queue.ts
+var import_agent_core9 = require("@birdybeep/agent-core");
+function createQueueCommand() {
+  return {
+    name: "queue",
+    summary: "Local event-queue maintenance",
+    usage: "birdybeep queue <clear>",
+    subcommands: [
+      {
+        name: "clear",
+        summary: "Clear the local offline event queue (debug)",
+        usage: "birdybeep queue clear",
+        run: (ctx) => {
+          const cleared = new import_agent_core9.LocalEventQueue().clear();
+          ctx.io.emit(`Cleared ${cleared} queued event(s).`, { cleared });
+          return EXIT.OK;
+        }
+      }
+    ]
+  };
+}
+
+// src/commands/report-status.ts
+var import_agent_core10 = require("@birdybeep/agent-core");
+var import_claude_code4 = require("@birdybeep/claude-code");
+var import_codex4 = require("@birdybeep/codex");
+var import_opencode4 = require("@birdybeep/opencode");
+var DEFAULT_ADAPTERS3 = [import_claude_code4.claudeCodeAdapter, import_codex4.codexAdapter, import_opencode4.opencodeAdapter];
+var ADAPTER_VERSIONS = {
+  claude_code: import_claude_code4.CLAUDE_CODE_ADAPTER_VERSION,
+  codex: import_codex4.CODEX_ADAPTER_VERSION,
+  opencode: import_opencode4.OPENCODE_ADAPTER_VERSION
+};
+var base2 = (apiUrl) => apiUrl.replace(/\/$/, "");
+async function gatherItems(adapters) {
+  return Promise.all(
+    adapters.map(async (a) => {
+      const [detection, status] = await Promise.all([a.detect(), a.status()]);
+      const item = { harness: a.id, status };
+      if (detection.version !== void 0) item.harness_version = detection.version;
+      const adapterVersion = ADAPTER_VERSIONS[a.id];
+      if (adapterVersion !== void 0) item.adapter_version = adapterVersion;
+      return item;
+    })
+  );
+}
+function createReportStatusCommand(deps = {}) {
+  const adapters = deps.adapters ?? DEFAULT_ADAPTERS3;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  return {
+    name: "report-status",
+    summary: "Internal: report integration status to the backend",
+    usage: "birdybeep report-status [--json]",
+    run: async (ctx) => {
+      const token = await (0, import_agent_core10.getToken)(deps.tokenOptions ?? {});
+      if (token === null) {
+        ctx.io.errline("Not logged in \u2014 run `birdybeep login` first.");
+        return EXIT.ERROR;
+      }
+      const items = await gatherItems(adapters);
+      if (items.length === 0) {
+        ctx.io.emit("No integrations to report.", { outcome: "reported", integrations: [] });
+        return EXIT.OK;
+      }
+      let effective = items.map((i) => ({ harness: i.harness, status: i.status }));
+      let outcome = "deferred";
+      let errorCode;
+      try {
+        const res = await fetchImpl(`${base2(resolveApiUrl())}/v1/integrations/status`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+          body: JSON.stringify({ integrations: items })
+        });
+        if (res.ok) {
+          outcome = "reported";
+          const parsed = import_agent_core10.integrationStatusResponseSchema.safeParse(
+            await res.json().catch(() => void 0)
+          );
+          if (parsed.success) {
+            effective = parsed.data.integrations.map((i) => ({
+              harness: i.harness,
+              status: i.status
+            }));
+          }
+        } else {
+          const env = import_agent_core10.errorEnvelopeSchema.safeParse(await res.json().catch(() => void 0));
+          errorCode = env.success ? env.data.error.code : void 0;
+          const terminal = errorCode !== void 0 ? errorCode === "unauthorized" || errorCode === "forbidden" || errorCode === "token_revoked" : res.status === 401 || res.status === 403;
+          outcome = terminal ? "terminal" : "deferred";
+        }
+      } catch {
+        outcome = "deferred";
+      }
+      if (ctx.flags.json) {
+        ctx.io.result({
+          outcome,
+          integrations: effective,
+          ...errorCode !== void 0 ? { error: errorCode } : {}
+        });
+      } else if (outcome === "terminal") {
+        ctx.io.errline(
+          `Report rejected (${errorCode ?? "auth"}) \u2014 your token may be revoked. Re-run \`birdybeep login\`.`
+        );
+      } else {
+        for (const e of effective) {
+          ctx.io.line(
+            outcome === "reported" ? `\u2713  ${e.harness}: ${e.status} (reported)` : `\u2022  ${e.harness}: ${e.status} (deferred \u2014 backend unreachable)`
+          );
+        }
+      }
+      return outcome === "terminal" ? EXIT.ERROR : EXIT.OK;
+    }
+  };
+}
+
+// src/commands/status.ts
+var import_agent_core11 = require("@birdybeep/agent-core");
+var import_claude_code5 = require("@birdybeep/claude-code");
+var import_codex5 = require("@birdybeep/codex");
+var import_opencode5 = require("@birdybeep/opencode");
+var DEFAULT_ADAPTERS4 = [import_claude_code5.claudeCodeAdapter, import_codex5.codexAdapter, import_opencode5.opencodeAdapter];
+function createStatusCommand(deps = {}) {
+  const adapters = deps.adapters ?? DEFAULT_ADAPTERS4;
+  const makeSender = deps.createSender ?? ((baseUrl) => (0, import_agent_core11.createSender)(
+    deps.tokenOptions ? { baseUrl, tokenOptions: deps.tokenOptions } : { baseUrl }
+  ));
+  return {
+    name: "status",
+    summary: "Show pairing + per-harness integration status",
+    usage: "birdybeep status [--json]",
+    run: async (ctx) => {
+      const machine = machineIdentity();
+      const loggedIn = await isLoggedIn(deps.tokenOptions ?? {});
+      const integrations = await gatherIntegrations(adapters);
+      const depthBefore = localQueueDepth();
+      const drain = await makeSender(resolveApiUrl()).drainNow();
+      const depthAfter = localQueueDepth();
+      const report = {
+        machine,
+        loggedIn,
+        integrations,
+        queue: { depthBefore, delivered: drain.delivered, depthAfter }
+      };
+      if (ctx.flags.json) {
+        ctx.io.result(report);
+      } else {
+        ctx.io.line(`Machine: ${machine.label} (${machine.os})`);
+        ctx.io.line(
+          loggedIn ? "Login:   paired" : "Login:   NOT logged in \u2014 run `birdybeep login`"
+        );
+        ctx.io.line("Integrations:");
+        for (const i of integrations) ctx.io.line(`  ${i.displayName}: ${i.status}`);
+        ctx.io.line(
+          `Queue:   ${depthBefore} queued \u2192 ${drain.delivered} delivered, ${depthAfter} remaining`
+        );
+      }
+      return loggedIn ? EXIT.OK : EXIT.ERROR;
+    }
+  };
+}
+
+// src/commands/test.ts
+var import_node_crypto = require("crypto");
+var import_agent_core12 = require("@birdybeep/agent-core");
+function buildTestEvent(opts = {}) {
+  const machine = (0, import_agent_core12.getMachineIdentity)();
+  return (0, import_agent_core12.normalizeEvent)(
+    {
+      event_type: "test",
+      status: "running",
+      harness: "claude_code",
+      // schema requires a harness; the "test" type distinguishes it
+      // Unique per run: a repeat `birdybeep test` inside the backend's dedupe window must
+      // still beep — a constant id made the second test silently "deduped" (9fh).
+      source_session_id: `birdybeep-cli-test-${(0, import_node_crypto.randomUUID)()}`,
+      machine: { label: machine.label, os: machine.os },
+      workspace: { cwd: process.cwd() },
+      title: "BirdyBeep test event",
+      body: "If you can see this, your machine is wired up correctly.",
+      metadata: { test: true }
+    },
+    opts
+  );
+}
+function createTestCommand(deps = {}) {
+  const makeSender = deps.createSender ?? ((baseUrl) => (0, import_agent_core12.createSender)(
+    deps.tokenOptions ? { baseUrl, tokenOptions: deps.tokenOptions } : { baseUrl }
+  ));
+  return {
+    name: "test",
+    summary: "Send a test event end-to-end",
+    usage: "birdybeep test [--json]",
+    run: async (ctx) => {
+      const event = buildTestEvent();
+      const result = await makeSender(resolveApiUrl()).send(event);
+      if (ctx.flags.json) {
+        ctx.io.result({
+          outcome: result.outcome,
+          ...result.status ? { status: result.status } : {},
+          ...result.decision ? { decision: result.decision } : {}
+        });
+      } else if (result.outcome === "delivered") {
+        if (result.decision === "notified" || result.decision === void 0) {
+          ctx.io.line("\u2713 Test event delivered \u2014 check your phone for a test Beep.");
+        } else if (result.decision === "suppressed") {
+          ctx.io.line(
+            "\u26A0 The backend accepted the test event but suppressed the push \u2014 this machine or integration is probably muted. Check mutes in the app, or run `birdybeep doctor`."
+          );
+        } else if (result.decision === "deduped") {
+          ctx.io.line(
+            "\u26A0 The backend accepted the test event but folded it into a recent duplicate \u2014 wait ~30s and run `birdybeep test` again."
+          );
+        } else {
+          ctx.io.line(
+            `\u26A0 The backend accepted the test event but decided "${result.decision}" \u2014 no push was sent. Run \`birdybeep doctor\`.`
+          );
+        }
+      } else if (result.outcome === "queued") {
+        ctx.io.line("\u2022 Offline \u2014 test event queued; it will deliver when you reconnect.");
+      } else {
+        ctx.io.line("\u2717 Test event was rejected by the backend. Run `birdybeep doctor`.");
+      }
+      return result.outcome === "dropped" ? EXIT.ERROR : EXIT.OK;
+    }
+  };
+}
+
+// src/commands.ts
+function buildCommands() {
+  return [
+    createLoginCommand(),
+    createLogoutCommand(),
+    createStatusCommand(),
+    createTestCommand(),
+    createDoctorCommand(),
+    createAgentCommand(),
+    createHookCommand(),
+    createQueueCommand(),
+    createReportStatusCommand()
+  ];
+}
+
+// src/cli.ts
+function runCli(argv, deps = {}) {
+  return dispatch(argv, {
+    version: CLI_VERSION,
+    commands: deps.commands ?? buildCommands(),
+    stdout: deps.stdout ?? process.stdout,
+    stderr: deps.stderr ?? process.stderr,
+    ...deps.ensureConfig !== void 0 ? { ensureConfig: deps.ensureConfig } : {}
+  });
+}
+
+// src/node-check.ts
+var MIN_NODE_MAJOR = 20;
+function parseNodeMajor(version) {
+  const match = /^v?(\d+)\./.exec(version);
+  return match ? Number(match[1]) : null;
+}
+function nodeVersionError(version) {
+  const major = parseNodeMajor(version);
+  if (major === null) return null;
+  return major < MIN_NODE_MAJOR ? `birdybeep requires Node ${MIN_NODE_MAJOR}+ (you have ${version}). Please upgrade Node and retry.` : null;
+}
+
+// src/bin.ts
+var versionError = nodeVersionError(process.versions.node);
+if (versionError !== null) {
+  process.stderr.write(`${versionError}
+`);
+  process.exitCode = 1;
+} else {
+  runCli(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (err) => {
+      process.stderr.write(`birdybeep: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  );
+}
+//# sourceMappingURL=bin.cjs.map