@creatornader/agent-bridge 0.2.0

package/dist/cli.js

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+import {
+  runMigrations
+} from "./chunk-6MAZ6YLZ.js";
+import {
+  readClientConfigFile,
+  resolveClientConfig
+} from "./chunk-KVR4JBRF.js";
+import {
+  createClientRuntime
+} from "./chunk-JTC5YURG.js";
+import {
+  BridgeHttpError,
+  LegacySupabaseError,
+  legacyContextMetadata,
+  legacyNumericMessageId
+} from "./chunk-AXL2I7FH.js";
+import "./chunk-WEULPMUY.js";
+import "./chunk-YD6YJATN.js";
+import "./chunk-CKSKUBDQ.js";
+import "./chunk-BV6W4AJK.js";
+
+// src/cli.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+import { mkdtempSync } from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
+import pg from "pg";
+
+// src/client-installer.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { spawnSync } from "child_process";
+function desktopConfigPath(env) {
+  if (process.platform === "win32") {
+    const appData = env.APPDATA;
+    if (!appData) throw new Error("APPDATA is required for Claude Desktop installation");
+    return join(appData, "Claude", "claude_desktop_config.json");
+  }
+  const home = env.HOME ?? homedir();
+  return process.platform === "darwin" ? join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+function safeComponent(value) {
+  const readable = value.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 48) || "client";
+  const suffix = createHash("sha256").update(value).digest("hex").slice(0, 12);
+  return `${readable}-${suffix}`;
+}
+function clientBackendConfigPath(runtime, instance, env) {
+  const home = env.HOME ?? homedir();
+  return join(
+    home,
+    ".agent-bridge",
+    "clients",
+    `${runtime}-${safeComponent(instance)}.config`
+  );
+}
+function replacePrivateFile(path, content) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  if (process.platform !== "win32") chmodSync(dirname(path), 448);
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, content, { mode: 384 });
+  renameSync(temporary, path);
+  if (process.platform !== "win32") chmodSync(path, 384);
+}
+function writeBackendConfig(runtime, identity, instance, options) {
+  const env = options.env;
+  const home = env.HOME ?? homedir();
+  const sharedPath = env.AGENT_BRIDGE_CONFIG ?? join(home, ".agent-bridge", "config");
+  const shared = readClientConfigFile(sharedPath);
+  const configuredProvider = env.AGENT_BRIDGE_PROVIDER?.trim() || shared.AGENT_BRIDGE_PROVIDER?.trim();
+  const inferredGateway = !configuredProvider && Boolean(
+    env.AGENT_BRIDGE_TOKEN?.trim() || shared.AGENT_BRIDGE_TOKEN?.trim()
+  );
+  const provider = configuredProvider === "legacy" || configuredProvider === "supabase" ? "legacy-supabase" : configuredProvider ?? (inferredGateway ? "gateway" : void 0);
+  const clientToken = options.token?.trim() || env.AGENT_BRIDGE_CLIENT_TOKEN?.trim();
+  if (provider === "gateway" && !clientToken) {
+    throw new Error(
+      "gateway client installation requires --token or AGENT_BRIDGE_CLIENT_TOKEN"
+    );
+  }
+  const resolved = resolveClientConfig({
+    ...env,
+    AGENT_BRIDGE_AGENT: void 0,
+    AGENT_BRIDGE_INSTANCE: void 0,
+    AGENT_BRIDGE_TOKEN: clientToken ?? env.AGENT_BRIDGE_TOKEN
+  }, identity);
+  const values = {
+    AGENT_BRIDGE_PROVIDER: resolved.provider,
+    AGENT_BRIDGE_WORKSPACE: resolved.principal.workspace,
+    AGENT_BRIDGE_URL: resolved.url,
+    AGENT_BRIDGE_TOKEN: resolved.provider === "gateway" ? resolved.credential : void 0,
+    AGENT_BRIDGE_KEY: resolved.provider === "legacy-supabase" ? resolved.credential : void 0,
+    AGENT_BRIDGE_DB: resolved.provider === "local" ? resolved.databasePath : void 0,
+    AGENT_BRIDGE_EDGE_DB: resolved.provider === "gateway" ? resolved.edgeDatabasePath : void 0
+  };
+  for (const value of Object.values(values)) {
+    if (value?.includes("\n") || value?.includes("\r")) {
+      throw new Error("client backend config values cannot contain newlines");
+    }
+  }
+  const path = clientBackendConfigPath(runtime, instance, env);
+  replacePrivateFile(
+    path,
+    `${Object.entries(values).filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${value}`).join("\n")}
+`
+  );
+  return path;
+}
+function writeJsonConfig(path, identity, instance, backendConfigPath, command) {
+  let config = {};
+  if (existsSync(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf8"));
+      if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error();
+      config = parsed;
+    } catch {
+      throw new Error(`Claude Desktop config is not valid JSON: ${path}`);
+    }
+  }
+  const currentServers = config.mcpServers;
+  const mcpServers = currentServers && !Array.isArray(currentServers) && typeof currentServers === "object" ? currentServers : {};
+  const next = {
+    ...config,
+    mcpServers: {
+      ...mcpServers,
+      "agent-bridge": {
+        command,
+        env: {
+          AGENT_BRIDGE_AGENT: identity,
+          AGENT_BRIDGE_INSTANCE: instance,
+          AGENT_BRIDGE_CONFIG: backendConfigPath
+        }
+      }
+    }
+  };
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+  renameSync(temporary, path);
+}
+function installClient(runtime, identity, options = {}, execute = (command, args) => spawnSync(command, args, { encoding: "utf8" })) {
+  const normalizedIdentity = identity.trim();
+  if (!normalizedIdentity || normalizedIdentity.length > 128) throw new Error("--identity is required");
+  const instance = options.instance?.trim() || `${runtime}-${randomUUID()}`;
+  if (instance.length > 128) throw new Error("--instance exceeds 128 characters");
+  if (options.scope && !["local", "user", "project"].includes(options.scope)) {
+    throw new Error("scope must be local, user, or project");
+  }
+  const command = options.command?.trim() || "agent-bridge-mcp";
+  const env = options.env ?? process.env;
+  const expectedPath = clientBackendConfigPath(runtime, instance, env);
+  const previous = existsSync(expectedPath) ? readFileSync(expectedPath) : void 0;
+  try {
+    const backendConfigPath = writeBackendConfig(runtime, normalizedIdentity, instance, {
+      token: options.token,
+      env
+    });
+    if (runtime === "claude-desktop") {
+      const path = desktopConfigPath(env);
+      writeJsonConfig(path, normalizedIdentity, instance, backendConfigPath, command);
+      return { runtime, identity: normalizedIdentity, instance, method: "json-config", configPath: path, backendConfigPath, restartRequired: true };
+    }
+    const executable = runtime === "codex" ? "codex" : "claude";
+    const args = runtime === "codex" ? [
+      "mcp",
+      "add",
+      "agent-bridge",
+      "--env",
+      `AGENT_BRIDGE_AGENT=${normalizedIdentity}`,
+      "--env",
+      `AGENT_BRIDGE_INSTANCE=${instance}`,
+      "--env",
+      `AGENT_BRIDGE_CONFIG=${backendConfigPath}`,
+      "--",
+      command
+    ] : [
+      "mcp",
+      "add",
+      "--scope",
+      options.scope ?? "user",
+      "agent-bridge",
+      "-e",
+      `AGENT_BRIDGE_AGENT=${normalizedIdentity}`,
+      "-e",
+      `AGENT_BRIDGE_INSTANCE=${instance}`,
+      "-e",
+      `AGENT_BRIDGE_CONFIG=${backendConfigPath}`,
+      "--",
+      command
+    ];
+    const result = execute(executable, args);
+    if (result.error || result.status !== 0) {
+      const detail = result.stderr?.trim() || result.error?.message || `exit ${result.status}`;
+      throw new Error(`${runtime} MCP installation failed: ${detail}`);
+    }
+    return { runtime, identity: normalizedIdentity, instance, method: "native-cli", backendConfigPath, restartRequired: true };
+  } catch (error) {
+    try {
+      if (previous) replacePrivateFile(expectedPath, previous);
+      else rmSync(expectedPath, { force: true });
+    } catch (rollbackError) {
+      const detail = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+      throw new Error(`${error instanceof Error ? error.message : String(error)}; client config rollback failed: ${detail}`);
+    }
+    throw error;
+  }
+}
+
+// src/cli.ts
+var SUPPORTED_OPTIONS = /* @__PURE__ */ new Set([
+  "agent",
+  "as",
+  "atrib-receipt-id",
+  "category",
+  "causation-id",
+  "config",
+  "content",
+  "content-type",
+  "correlation-id",
+  "cursor",
+  "data",
+  "db",
+  "dead",
+  "delivery-id",
+  "error",
+  "expires-at",
+  "force",
+  "idempotency-key",
+  "ids",
+  "informed-by",
+  "instance",
+  "interval-ms",
+  "json",
+  "key",
+  "kind",
+  "lease-ms",
+  "lease-token",
+  "limit",
+  "max-attempts",
+  "max-interval-ms",
+  "message-id",
+  "metadata",
+  "payload",
+  "payload-ciphertext",
+  "payload-mime",
+  "payload-ref",
+  "polls",
+  "priority",
+  "project",
+  "provider",
+  "reply-to-id",
+  "since",
+  "source",
+  "target",
+  "target-agent",
+  "target-agents",
+  "thread-id",
+  "token",
+  "type",
+  "unacked-by",
+  "url",
+  "workspace",
+  "identity",
+  "command",
+  "scope",
+  "runtime",
+  "capability",
+  "max-pages",
+  "max-push"
+]);
+var BOOLEAN_OPTIONS = /* @__PURE__ */ new Set(["dead", "force", "json"]);
+function parse(argv) {
+  const command = argv[0] ?? "help";
+  const options = {};
+  const positionals = [];
+  for (let i = 1; i < argv.length; i++) {
+    const value = argv[i];
+    if (!value.startsWith("--")) {
+      positionals.push(value);
+      continue;
+    }
+    const key = value.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      if (!BOOLEAN_OPTIONS.has(key)) throw new Error(`--${key} requires a value`);
+      options[key] = true;
+    } else {
+      i++;
+      const previous = options[key];
+      options[key] = previous === void 0 ? next : Array.isArray(previous) ? [...previous, next] : [String(previous), next];
+    }
+  }
+  return { command, options, positionals };
+}
+function one(options, key) {
+  const value = options[key];
+  return Array.isArray(value) ? value[value.length - 1] : typeof value === "string" ? value : void 0;
+}
+function list(options, key) {
+  const value = options[key];
+  return (Array.isArray(value) ? value : value ? [String(value)] : []).flatMap((item) => item.split(",")).map((item) => item.trim()).filter(Boolean);
+}
+function boolean(options, key) {
+  const value = options[key];
+  const selected = Array.isArray(value) ? value[value.length - 1] : value;
+  if (selected === void 0) return false;
+  if (selected === true || selected === "true") return true;
+  if (selected === false || selected === "false") return false;
+  throw new Error(`--${key} must be true or false`);
+}
+function integer(options, key, fallback) {
+  const raw = one(options, key);
+  const result = raw === void 0 ? fallback : Number(raw);
+  if (!Number.isSafeInteger(result) || result < 0) throw new Error(`--${key} must be a non-negative integer`);
+  return result;
+}
+function json(options, key) {
+  const raw = one(options, key);
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`--${key} must be valid JSON`);
+  }
+}
+function since(options) {
+  const raw = one(options, "since");
+  if (!raw) return void 0;
+  const relative = raw.match(/^(\d+)(h|d)$/);
+  if (!relative) return raw;
+  const amount = Number(relative[1]);
+  const milliseconds = amount * (relative[2] === "h" ? 36e5 : 864e5);
+  return new Date(Date.now() - milliseconds).toISOString();
+}
+function output(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function cursor(path) {
+  try {
+    return readFileSync2(path, "utf8").trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function saveCursor(path, value) {
+  if (!value) return;
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync2(temporary, `${value}
+`, { mode: 384 });
+  renameSync2(temporary, path);
+}
+function help() {
+  process.stdout.write(`agent-bridge: provider-neutral agent messaging
+
+Commands:
+  init, doctor, status, pending, migrate, sync, demo, join, presence
+  send (post), inbox (get), history, acknowledge, claim, extend, ack, nack, watch
+  clients install <codex|claude-code|claude-desktop> --identity <name>
+`);
+}
+function rejectUnknownOptions(options) {
+  const unknown = Object.keys(options).filter((key) => !SUPPORTED_OPTIONS.has(key));
+  if (unknown.length) throw new Error(`unknown option: --${unknown[0]}`);
+}
+async function initialize(options) {
+  const home = process.env.HOME ?? homedir2();
+  const configPath = one(options, "config") ?? process.env.AGENT_BRIDGE_CONFIG ?? join2(home, ".agent-bridge", "config");
+  if (existsSync2(configPath) && !boolean(options, "force")) {
+    throw new Error(`Config already exists at ${configPath}; pass --force to replace it`);
+  }
+  const provider = one(options, "provider") ?? process.env.AGENT_BRIDGE_PROVIDER ?? "local";
+  if (one(options, "instance")) {
+    throw new Error("--instance is client-scoped; set it in the active client process");
+  }
+  const values = {
+    AGENT_BRIDGE_PROVIDER: provider,
+    AGENT_BRIDGE_WORKSPACE: one(options, "workspace") ?? process.env.AGENT_BRIDGE_WORKSPACE ?? (provider === "legacy-supabase" || provider === "legacy" || provider === "supabase" ? "*" : "default"),
+    AGENT_BRIDGE_DB: one(options, "db") ?? process.env.AGENT_BRIDGE_DB,
+    AGENT_BRIDGE_EDGE_DB: process.env.AGENT_BRIDGE_EDGE_DB,
+    AGENT_BRIDGE_URL: one(options, "url") ?? process.env.AGENT_BRIDGE_URL,
+    AGENT_BRIDGE_KEY: one(options, "key") ?? process.env.AGENT_BRIDGE_KEY
+  };
+  const verificationToken = one(options, "token") ?? process.env.AGENT_BRIDGE_TOKEN;
+  for (const value of Object.values(values)) {
+    if (value?.includes("\n") || value?.includes("\r")) throw new Error("config values cannot contain newlines");
+  }
+  mkdirSync2(dirname2(configPath), { recursive: true });
+  const temporary = `${configPath}.${process.pid}.tmp`;
+  writeFileSync2(
+    temporary,
+    Object.entries(values).filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${value}`).join("\n") + "\n",
+    { mode: 384 }
+  );
+  let config;
+  try {
+    config = resolveClientConfig(
+      {
+        HOME: home,
+        AGENT_BRIDGE_CONFIG: temporary,
+        AGENT_BRIDGE_TOKEN: verificationToken
+      },
+      "agent-bridge-init"
+    );
+    const runtime = await createClientRuntime(config);
+    try {
+      if (config.provider === "gateway") await runtime.store.verifyRemote?.();
+    } finally {
+      await runtime.close();
+    }
+    renameSync2(temporary, configPath);
+  } catch (error) {
+    rmSync2(temporary, { force: true });
+    throw error;
+  }
+  output({ status: "ok", config: configPath, provider: config.provider, workspace: config.principal.workspace, identity: "process-scoped", database: config.provider === "local" ? config.databasePath : null });
+}
+function configFor(options, command) {
+  const explicit = command === "send" ? one(options, "source") ?? one(options, "agent") : command === "acknowledge" || command === "ack" && Boolean(one(options, "ids")) ? one(options, "agent") : one(options, "as");
+  const project = one(options, "project");
+  const environment = one(options, "instance") ? { ...process.env, AGENT_BRIDGE_INSTANCE: one(options, "instance") } : process.env;
+  const config = resolveClientConfig(environment, explicit);
+  if (!project || project === config.principal.workspace) return config;
+  if (config.provider === "gateway") {
+    throw new Error("--project cannot override the workspace bound to a gateway credential");
+  }
+  return resolveClientConfig(
+    { ...environment, AGENT_BRIDGE_WORKSPACE: project },
+    explicit
+  );
+}
+function draft(options, positionals) {
+  const content = one(options, "content") ?? positionals.join(" ");
+  const metadataInput = json(options, "metadata");
+  if (metadataInput !== void 0 && (metadataInput === null || typeof metadataInput !== "object" || Array.isArray(metadataInput))) throw new Error("--metadata must be a JSON object");
+  const metadata = metadataInput ?? {};
+  const envelope = typeof metadata.message_envelope === "object" && metadata.message_envelope ? { ...metadata.message_envelope } : {};
+  if (one(options, "payload-ref")) envelope.payload_ref = one(options, "payload-ref");
+  if (one(options, "payload-ciphertext")) envelope.payload_ciphertext = one(options, "payload-ciphertext");
+  if (Object.keys(envelope).length) metadata.message_envelope = envelope;
+  return {
+    type: one(options, "type") ?? one(options, "kind") ?? one(options, "category") ?? "operational",
+    content,
+    targets: [...list(options, "target"), ...list(options, "target-agent"), ...list(options, "target-agents")],
+    priority: one(options, "priority"),
+    threadId: one(options, "thread-id"),
+    replyToId: one(options, "reply-to-id"),
+    correlationId: one(options, "correlation-id"),
+    causationId: one(options, "causation-id"),
+    id: one(options, "message-id"),
+    idempotencyKey: one(options, "idempotency-key"),
+    expiresAt: one(options, "expires-at"),
+    contentType: one(options, "content-type") ?? one(options, "payload-mime"),
+    atribReceiptId: one(options, "atrib-receipt-id"),
+    informedBy: list(options, "informed-by"),
+    data: json(options, "data") ?? json(options, "payload"),
+    metadata
+  };
+}
+async function localDemo() {
+  const directory = mkdtempSync(join2(tmpdir(), "agent-bridge-demo-"));
+  const databasePath = join2(directory, "demo.sqlite3");
+  const base = { provider: "local", databasePath, edgeDatabasePath: join2(directory, "edge.sqlite3"), cursorPath: join2(directory, "cursor"), configPath: join2(directory, "config"), credential: void 0, url: void 0 };
+  let sender;
+  let worker;
+  try {
+    sender = await createClientRuntime({ ...base, principal: { workspace: "demo", agent: "demo-sender", instance: "sender-1" } });
+    const sent = await sender.service.publish(sender.config.principal, { type: "request", content: "deterministic local task", targets: ["demo-worker"], idempotencyKey: "demo-task-v1" });
+    await sender.close();
+    sender = void 0;
+    worker = await createClientRuntime({ ...base, principal: { workspace: "demo", agent: "demo-worker", instance: "worker-1" } });
+    const history = await worker.service.history(worker.config.principal);
+    const claim = await worker.service.claim(worker.config.principal, { leaseMs: 5e3 });
+    if (!claim) throw new Error("demo claim failed");
+    const acked = await worker.service.ack(worker.config.principal, claim.delivery.id, claim.leaseToken);
+    output({ status: "ok", principals: ["demo-sender", "demo-worker"], sent: sent.created, read: history.messages.length === 1, claimed: claim.delivery.state === "claimed", acknowledged: acked?.state === "acked" });
+  } finally {
+    await worker?.close();
+    await sender?.close();
+    rmSync2(directory, { recursive: true, force: true });
+  }
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const { command: raw, options, positionals } = parse(argv);
+  const command = { post: "send", get: "inbox", receipt: "acknowledge" }[raw] ?? raw;
+  if (["help", "-h", "--help"].includes(command)) {
+    help();
+    return;
+  }
+  rejectUnknownOptions(options);
+  if (command === "clients") {
+    if (positionals[0] !== "install" || !positionals[1]) {
+      throw new Error("usage: agent-bridge clients install <runtime> --identity <name>");
+    }
+    const runtime2 = positionals[1];
+    if (!["codex", "claude-code", "claude-desktop"].includes(runtime2)) {
+      throw new Error(`unsupported install runtime: ${runtime2}`);
+    }
+    const scope = one(options, "scope");
+    if (scope && !["local", "user", "project"].includes(scope)) {
+      throw new Error("--scope must be local, user, or project");
+    }
+    output(installClient(runtime2, one(options, "identity") ?? "", {
+      command: one(options, "command"),
+      scope,
+      instance: one(options, "instance"),
+      token: one(options, "token"),
+      env: process.env
+    }));
+    return;
+  }
+  if (command === "demo") {
+    await localDemo();
+    return;
+  }
+  if (command === "init") {
+    await initialize(options);
+    return;
+  }
+  if (command === "migrate") {
+    const databaseUrl = process.env.AGENT_BRIDGE_DATABASE_URL;
+    if (!databaseUrl) throw new Error("AGENT_BRIDGE_DATABASE_URL is required");
+    const pool = new pg.Pool({ connectionString: databaseUrl, max: 1 });
+    try {
+      const applied = await runMigrations(
+        pool,
+        fileURLToPath(new URL("../sql/migrations", import.meta.url))
+      );
+      output({ status: "ok", applied });
+    } finally {
+      await pool.end();
+    }
+    return;
+  }
+  const config = configFor(options, command);
+  const runtime = await createClientRuntime(config);
+  try {
+    if (command === "doctor" || command === "status") {
+      const diagnostics = await runtime.store.diagnostics?.(config.principal) ?? { schemaVersion: config.provider === "legacy-supabase" ? "legacy-v1" : "local-v2", deliverySupported: false, pending: null, claimed: null, retrying: null, dead: null };
+      output({ status: "ok", connected: true, provider: config.provider, workspace: config.principal.workspace, agent: config.principal.agent, instance: config.principal.instance ?? null, schemaVersion: diagnostics.schemaVersion, endpoint: config.url ?? null, database: config.provider === "local" ? config.databasePath : null, cursorPath: config.cursorPath, lastCursor: cursor(config.cursorPath) ?? null, queue: diagnostics });
+      return;
+    }
+    if (command === "pending") {
+      const diagnostics = await runtime.store.diagnostics?.(config.principal);
+      const page = await runtime.service.history(config.principal, {
+        limit: 1,
+        unacknowledgedBy: config.principal.agent
+      });
+      const pendingDeliveries = diagnostics?.pending ?? 0;
+      const retryingDeliveries = diagnostics?.retrying ?? 0;
+      const oldest = diagnostics?.oldestAvailableAt ? Date.parse(diagnostics.oldestAvailableAt) : Number.POSITIVE_INFINITY;
+      const deliveryAvailable = pendingDeliveries > 0 || retryingDeliveries > 0 && oldest <= Date.now();
+      const unread = page.messages.length > 0;
+      const available = deliveryAvailable || unread;
+      output({
+        available,
+        unread,
+        deliveryAvailable,
+        pending: pendingDeliveries,
+        retrying: retryingDeliveries,
+        authoritative: !diagnostics || !("remoteReachable" in diagnostics) || diagnostics.remoteReachable !== false
+      });
+      if (!available) process.exitCode = 1;
+      return;
+    }
+    if (command === "send") {
+      output(await runtime.service.publish(config.principal, draft(options, positionals)));
+      return;
+    }
+    if (command === "join") {
+      output(await runtime.service.heartbeat(config.principal, { leaseMs: integer(options, "lease-ms", 6e4), runtimeType: one(options, "runtime"), capabilities: list(options, "capability") }));
+      return;
+    }
+    if (command === "presence") {
+      output({ agents: await runtime.service.presence(config.principal) });
+      return;
+    }
+    if (command === "sync") {
+      if (!runtime.store.sync) throw new Error("sync is available only with the gateway provider");
+      output(await runtime.store.sync({
+        maxPush: integer(options, "max-push", integer(options, "limit", 100)),
+        maxPages: integer(options, "max-pages", 20)
+      }));
+      return;
+    }
+    if (command === "history" || command === "inbox") {
+      const page = await runtime.service.history(config.principal, { cursor: one(options, "cursor"), limit: integer(options, "limit", 20), types: list(options, "type").concat(list(options, "category")), source: one(options, "source"), since: since(options), unacknowledgedBy: one(options, "unacked-by"), threadId: one(options, "thread-id"), latest: raw === "get" });
+      if (raw === "get") {
+        output(page.messages.map((message) => ({ id: config.provider === "legacy-supabase" ? Number(message.sequence) : message.id, source: message.source, category: message.type, content: message.content, priority: message.priority, project: message.workspace === "*" ? null : message.workspace, metadata: legacyContextMetadata(message), created_at: message.createdAt })));
+      } else output(page);
+      return;
+    }
+    if (command === "acknowledge" || command === "ack" && one(options, "ids")) {
+      const rawIds = list(options, "ids");
+      const acknowledged = config.provider === "legacy-supabase" && runtime.store.recordLegacyReceipt && rawIds.every((id) => /^\d+$/.test(id)) ? await runtime.store.recordLegacyReceipt(rawIds, config.principal.agent) : await runtime.service.acknowledge(
+        config.principal,
+        rawIds.map(legacyNumericMessageId)
+      );
+      output({ acknowledged, agent: config.principal.agent });
+      return;
+    }
+    if (command === "claim") {
+      output(await runtime.service.claim(config.principal, { leaseMs: integer(options, "lease-ms", 3e4), maxAttempts: integer(options, "max-attempts", 5) }));
+      return;
+    }
+    const deliveryId = one(options, "delivery-id") ?? positionals[0];
+    const leaseToken = one(options, "lease-token") ?? positionals[1];
+    if (!deliveryId || !leaseToken) {
+      if (["extend", "ack", "nack"].includes(command)) throw new Error("--delivery-id and --lease-token are required");
+    }
+    if (command === "extend") {
+      output(await runtime.service.extend(config.principal, deliveryId, leaseToken, integer(options, "lease-ms", 3e4)));
+      return;
+    }
+    if (command === "ack") {
+      output(await runtime.service.ack(config.principal, deliveryId, leaseToken));
+      return;
+    }
+    if (command === "nack") {
+      output(await runtime.service.nack(config.principal, deliveryId, leaseToken, one(options, "error") ?? "negative acknowledgment", boolean(options, "dead")));
+      return;
+    }
+    if (command === "watch") {
+      const polls = one(options, "polls") === void 0 ? Number.POSITIVE_INFINITY : integer(options, "polls", 0);
+      const baseInterval = Math.min(integer(options, "interval-ms", 1e3), 6e4);
+      const maxInterval = Math.max(baseInterval, Math.min(integer(options, "max-interval-ms", 3e4), 3e5));
+      let interval = baseInterval;
+      let current = cursor(config.cursorPath);
+      let seen = 0;
+      for (let i = 0; i < polls; i++) {
+        try {
+          const page = await runtime.service.history(config.principal, { cursor: current, limit: integer(options, "limit", 50) });
+          for (const message of page.messages) output(message);
+          seen += page.messages.length;
+          current = page.cursor;
+          saveCursor(config.cursorPath, current);
+          interval = page.messages.length ? baseInterval : Math.min(maxInterval, Math.max(baseInterval, interval * 2));
+        } catch (error) {
+          const status = error instanceof BridgeHttpError || error instanceof LegacySupabaseError ? error.status : void 0;
+          const retryable = status !== void 0 && (status === 0 || status === 408 || status === 425 || status === 429 || status >= 500);
+          if (!retryable) throw error;
+          interval = Math.min(maxInterval, Math.max(baseInterval, interval * 2));
+        }
+        if (i + 1 < polls) {
+          const jittered = Math.round(interval * (0.9 + Math.random() * 0.2));
+          await new Promise((resolve) => setTimeout(resolve, jittered));
+        }
+      }
+      if (!seen && boolean(options, "json")) output({ status: "ok", messages: 0, cursor: current ?? null });
+      return;
+    }
+    throw new Error(`Unknown command: ${raw}`);
+  } finally {
+    await runtime.close();
+  }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) runCli().catch((error) => {
+  process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map