@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/chunk-Q6PPMXJC.js

@@ -0,0 +1,1050 @@
+#!/usr/bin/env node
+import {
+  assertEdgeUpgradeCandidate,
+  installEdgeMarkers,
+  retrySqliteBusy
+} from "./chunk-5GMB3A77.js";
+import {
+  preparePrivateSqliteLocation,
+  securePrivatePath,
+  verifyPrivatePathAccess
+} from "./chunk-NCO7RLBM.js";
+import {
+  cursorScope,
+  decodeCursor,
+  encodeCursor
+} from "./chunk-BZLMF5O5.js";
+
+// src/sqlite-edge-store.ts
+import { createHash, randomUUID } from "crypto";
+import { existsSync, lstatSync } from "fs";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function openDatabase(path) {
+  const { DatabaseSync } = require2("node:sqlite");
+  return new DatabaseSync(path);
+}
+var MAX_SEQUENCE = 9223372036854775807n;
+var schema = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = FULL;
+PRAGMA foreign_keys = ON;
+CREATE TABLE IF NOT EXISTS edge_scopes (
+  scope_key TEXT PRIMARY KEY,
+  endpoint_hash TEXT NOT NULL,
+  workspace TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  pull_cursor TEXT,
+  last_sync_at TEXT,
+  last_error TEXT,
+  last_outbound_sync_at TEXT,
+  last_inbound_sync_at TEXT,
+  last_attempt_at TEXT,
+  cache_contract INTEGER NOT NULL DEFAULT 1
+);
+CREATE TABLE IF NOT EXISTS edge_outbox (
+  position INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope_key TEXT NOT NULL REFERENCES edge_scopes(scope_key),
+  message_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  payload_hash TEXT NOT NULL,
+  draft_json TEXT NOT NULL,
+  state TEXT NOT NULL CHECK(state IN ('pending', 'blocked')),
+  attempts INTEGER NOT NULL DEFAULT 0,
+  available_at TEXT NOT NULL,
+  lease_token TEXT,
+  lease_expires_at TEXT,
+  last_error TEXT,
+  blocked_at TEXT,
+  created_at TEXT NOT NULL,
+  UNIQUE(scope_key, message_id),
+  UNIQUE(scope_key, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS edge_outbox_due
+  ON edge_outbox(scope_key, state, available_at, position);
+CREATE TABLE IF NOT EXISTS edge_inbox (
+  scope_key TEXT NOT NULL REFERENCES edge_scopes(scope_key),
+  message_id TEXT NOT NULL,
+  remote_sequence TEXT NOT NULL,
+  sequence_key TEXT NOT NULL,
+  workspace TEXT NOT NULL,
+  project TEXT,
+  source TEXT NOT NULL,
+  type TEXT NOT NULL,
+  thread_id TEXT,
+  created_at TEXT NOT NULL,
+  expires_at TEXT,
+  message_json TEXT NOT NULL,
+  PRIMARY KEY(scope_key, message_id),
+  UNIQUE(scope_key, sequence_key)
+);
+CREATE INDEX IF NOT EXISTS edge_inbox_cursor
+  ON edge_inbox(scope_key, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_source
+  ON edge_inbox(scope_key, source, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_thread
+  ON edge_inbox(scope_key, thread_id, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_created
+  ON edge_inbox(scope_key, created_at, sequence_key);
+`;
+var EdgeConflictError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.code = "edge_idempotency_conflict";
+  }
+};
+function canonical(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+}
+function intent(message) {
+  const deliveryPolicy = message.deliveryPolicy ?? (message.targets.length ? { mode: "leased", maxAttempts: 5, retryBaseDelayMs: 1e3, retryMaxDelayMs: 6e4, retryJitterRatio: 0.2 } : { mode: "mailbox" });
+  return {
+    workspace: message.workspace,
+    project: message.project ?? null,
+    source: message.source,
+    type: message.type,
+    content: message.content,
+    contentType: message.contentType,
+    data: message.data ?? null,
+    targets: [...message.targets].sort(),
+    threadId: message.threadId ?? null,
+    replyToId: message.replyToId ?? null,
+    correlationId: message.correlationId ?? null,
+    causationId: message.causationId ?? null,
+    priority: message.priority,
+    expiresAt: message.expiresAt ?? null,
+    atribReceiptId: message.atribReceiptId ?? null,
+    informedBy: [...message.informedBy ?? []].sort(),
+    metadata: message.metadata ?? null,
+    deliveryPolicy
+  };
+}
+function edgeMessageFingerprint(message) {
+  return createHash("sha256").update(canonical(intent(message))).digest("hex");
+}
+function stableIdempotency(message) {
+  return message.idempotencyKey ? message : { ...message, idempotencyKey: `agent-bridge:id:${message.id}` };
+}
+function edgeScopeKey(scope) {
+  return createHash("sha256").update(`${scope.endpoint.replace(/\/$/, "")}\0${scope.principal.workspace}\0${scope.principal.agent}`).digest("hex");
+}
+function sequenceKey(sequence) {
+  if (!/^(0|[1-9][0-9]*)$/.test(sequence) || BigInt(sequence) > MAX_SEQUENCE) {
+    throw new EdgeConflictError("remote sequence is invalid");
+  }
+  return sequence.padStart(19, "0");
+}
+function parseDraft(value) {
+  return JSON.parse(String(value));
+}
+function parseMessage(value) {
+  return JSON.parse(String(value));
+}
+var SQLiteEdgeStore = class {
+  constructor(path, scope, busyTimeoutMs = 2e3) {
+    this.path = path;
+    this.scope = scope;
+    this.busyTimeoutMs = busyTimeoutMs;
+    this.initialized = false;
+    const selected = preparePrivateSqliteLocation(path, true);
+    this.databasePath = selected;
+    this.preexistingFiles = new Set(selected === ":memory:" ? [] : [selected, `${selected}-wal`, `${selected}-shm`].filter(existsSync));
+    const before = selected === ":memory:" || !existsSync(selected) ? void 0 : lstatSync(selected);
+    this.db = openDatabase(selected);
+    try {
+      this.db.exec(`PRAGMA busy_timeout = ${Math.max(1, Math.trunc(this.busyTimeoutMs))}`);
+      this.restrictFiles();
+      if (before) {
+        const after = lstatSync(selected);
+        if (after.dev !== before.dev || after.ino !== before.ino) throw new Error("SQLite edge database path identity changed while opening");
+      }
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
+    this.key = edgeScopeKey(scope);
+  }
+  restrictFiles() {
+    if (this.databasePath === ":memory:") return;
+    for (const path of [this.databasePath, `${this.databasePath}-wal`, `${this.databasePath}-shm`]) {
+      if (!existsSync(path)) continue;
+      if (path === this.databasePath && this.preexistingFiles.has(path)) verifyPrivatePathAccess(path, "file");
+      else securePrivatePath(path, "file");
+    }
+  }
+  get scopeKey() {
+    return this.key;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (!this.initialization) {
+      this.initialization = this.initializeOnce().then(() => {
+        this.initialized = true;
+      }).catch((error) => {
+        this.initialization = void 0;
+        throw error;
+      });
+    }
+    return this.initialization;
+  }
+  async initializeOnce() {
+    assertEdgeUpgradeCandidate(this.db);
+    await retrySqliteBusy(() => this.db.exec(schema), this.busyTimeoutMs);
+    await retrySqliteBusy(() => this.db.exec("BEGIN IMMEDIATE"), this.busyTimeoutMs);
+    try {
+      const scopeColumns = this.db.prepare("PRAGMA table_info(edge_scopes)").all();
+      if (!scopeColumns.some((column) => column.name === "cache_contract")) {
+        this.db.exec("ALTER TABLE edge_scopes ADD COLUMN cache_contract INTEGER NOT NULL DEFAULT 0");
+      }
+      for (const name of ["last_outbound_sync_at", "last_inbound_sync_at", "last_attempt_at"]) {
+        if (!scopeColumns.some((column) => column.name === name)) {
+          this.db.exec(`ALTER TABLE edge_scopes ADD COLUMN ${name} TEXT`);
+        }
+      }
+      const columns = this.db.prepare("PRAGMA table_info(edge_inbox)").all();
+      if (!columns.some((column) => column.name === "project")) {
+        this.db.exec("ALTER TABLE edge_inbox ADD COLUMN project TEXT");
+      }
+      this.db.exec("CREATE INDEX IF NOT EXISTS edge_inbox_project ON edge_inbox(scope_key, project, sequence_key)");
+      const outboxColumns = this.db.prepare("PRAGMA table_info(edge_outbox)").all();
+      if (!outboxColumns.some((column) => column.name === "blocked_at")) {
+        this.db.exec("ALTER TABLE edge_outbox ADD COLUMN blocked_at TEXT");
+      }
+      installEdgeMarkers(this.db);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    this.restrictFiles();
+    const endpointHash = createHash("sha256").update(this.scope.endpoint.replace(/\/$/, "")).digest("hex");
+    this.db.prepare(`INSERT INTO edge_scopes (scope_key, endpoint_hash, workspace, agent)
+      VALUES (?, ?, ?, ?) ON CONFLICT(scope_key) DO NOTHING`).run(this.key, endpointHash, this.scope.principal.workspace, this.scope.principal.agent);
+    const contract = this.db.prepare("SELECT cache_contract FROM edge_scopes WHERE scope_key=?").get(this.key);
+    if (Number(contract.cache_contract) < 1) {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        this.db.prepare("UPDATE edge_scopes SET pull_cursor=NULL, cache_contract=1 WHERE scope_key=?").run(this.key);
+        this.db.exec("COMMIT");
+      } catch (error) {
+        this.db.exec("ROLLBACK");
+        throw error;
+      }
+    }
+  }
+  async ready() {
+    await this.initialize();
+  }
+  async enqueue(input, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    const draft = stableIdempotency(input);
+    const payloadHash = edgeMessageFingerprint(draft);
+    const serialized = canonical(draft);
+    const nowText = now.toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const existing = this.db.prepare(`SELECT * FROM edge_outbox
+        WHERE scope_key=? AND (message_id=? OR idempotency_key=?) ORDER BY position LIMIT 1`).get(this.key, draft.id, draft.idempotencyKey);
+      if (existing) {
+        if (String(existing.payload_hash) !== payloadHash) {
+          throw new EdgeConflictError("message ID or idempotency key is already bound to different content");
+        }
+        this.db.exec("COMMIT");
+        return { draft: parseDraft(existing.draft_json), created: false };
+      }
+      this.db.prepare(`INSERT INTO edge_outbox
+        (scope_key, message_id, idempotency_key, payload_hash, draft_json, state, available_at, created_at)
+        VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`).run(this.key, draft.id, draft.idempotencyKey, payloadHash, serialized, nowText, nowText);
+      this.db.exec("COMMIT");
+      return { draft, created: true };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async claimNext(now = /* @__PURE__ */ new Date(), leaseMs = 3e4) {
+    await this.ready();
+    const nowText = now.toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const head = this.db.prepare(`SELECT * FROM edge_outbox
+        WHERE scope_key=? AND state='pending' AND available_at<=?
+          AND (lease_expires_at IS NULL OR lease_expires_at<=?)
+        ORDER BY position LIMIT 1`).get(this.key, nowText, nowText);
+      if (!head) {
+        this.db.exec("COMMIT");
+        return void 0;
+      }
+      const leaseToken = randomUUID();
+      const leaseExpiresAt = new Date(now.getTime() + leaseMs).toISOString();
+      const updated = this.db.prepare(`UPDATE edge_outbox
+        SET lease_token=?, lease_expires_at=? WHERE scope_key=? AND position=?
+          AND (lease_expires_at IS NULL OR lease_expires_at<=?)`).run(leaseToken, leaseExpiresAt, this.key, Number(head.position), nowText);
+      if (!updated.changes) {
+        this.db.exec("COMMIT");
+        return void 0;
+      }
+      this.db.exec("COMMIT");
+      return {
+        position: Number(head.position),
+        draft: parseDraft(head.draft_json),
+        payloadHash: String(head.payload_hash),
+        attempts: Number(head.attempts),
+        leaseToken,
+        createdAt: String(head.created_at)
+      };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async retry(record, error, availableAt) {
+    await this.ready();
+    this.db.prepare(`UPDATE edge_outbox SET attempts=attempts+1, available_at=?,
+      lease_token=NULL, lease_expires_at=NULL, last_error=?
+      WHERE scope_key=? AND position=? AND lease_token=?`).run(availableAt.toISOString(), error.slice(0, 256), this.key, record.position, record.leaseToken);
+    await this.noteError(error);
+  }
+  async block(record, error, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.prepare(`UPDATE edge_outbox SET state='blocked', attempts=attempts+1,
+      lease_token=NULL, lease_expires_at=NULL, last_error=?, blocked_at=?
+      WHERE scope_key=? AND position=? AND lease_token=?`).run(error.slice(0, 256), now.toISOString(), this.key, record.position, record.leaseToken);
+    await this.noteError(error);
+  }
+  async commit(record, message, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.cacheOne(message);
+      const deleted = this.db.prepare(`DELETE FROM edge_outbox
+        WHERE scope_key=? AND position=? AND lease_token=?`).run(this.key, record.position, record.leaseToken);
+      if (deleted.changes !== 1) throw new EdgeConflictError("outbox lease was lost before commit");
+      this.db.prepare(`UPDATE edge_scopes SET last_sync_at=?, last_error=NULL WHERE scope_key=?`).run(now.toISOString(), this.key);
+      this.db.prepare("UPDATE edge_scopes SET last_outbound_sync_at=? WHERE scope_key=?").run(now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  cacheOne(message) {
+    const serialized = canonical(message);
+    const key = sequenceKey(message.sequence);
+    const byId = this.db.prepare(`SELECT remote_sequence, message_json FROM edge_inbox
+      WHERE scope_key=? AND message_id=?`).get(this.key, message.id);
+    const bySequence = this.db.prepare(`SELECT message_id, message_json FROM edge_inbox
+      WHERE scope_key=? AND sequence_key=?`).get(this.key, key);
+    if (byId || bySequence) {
+      if (!byId || String(byId.remote_sequence) !== message.sequence || String(byId.message_json) !== serialized || bySequence && String(bySequence.message_id) !== message.id) {
+        throw new EdgeConflictError("cached message conflicts with immutable remote history");
+      }
+      return;
+    }
+    this.db.prepare(`INSERT INTO edge_inbox
+      (scope_key, message_id, remote_sequence, sequence_key, workspace, project, source, type,
+       thread_id, created_at, expires_at, message_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      this.key,
+      message.id,
+      message.sequence,
+      key,
+      message.workspace,
+      message.project ?? null,
+      message.source,
+      message.type,
+      message.threadId ?? null,
+      message.createdAt,
+      message.expiresAt ?? null,
+      serialized
+    );
+  }
+  async cachePage(messages, cursor, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    const scope = cursorScope(this.scope.principal, { mailbox: "all", includeExpired: true });
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const message of messages) this.cacheOne(message);
+      const current = this.db.prepare("SELECT pull_cursor FROM edge_scopes WHERE scope_key=?").get(this.key);
+      const currentCursor = current.pull_cursor ? String(current.pull_cursor) : void 0;
+      const nextCursor = !cursor ? currentCursor : !currentCursor || sequenceKey(decodeCursor(cursor, scope)) >= sequenceKey(decodeCursor(currentCursor, scope)) ? cursor : currentCursor;
+      this.db.prepare(`UPDATE edge_scopes SET pull_cursor=?, last_sync_at=?, last_error=NULL
+        WHERE scope_key=?`).run(nextCursor ?? null, now.toISOString(), this.key);
+      this.db.prepare("UPDATE edge_scopes SET last_inbound_sync_at=? WHERE scope_key=?").run(now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async cacheLatest(messages, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const message of messages) this.cacheOne(message);
+      this.db.prepare(`UPDATE edge_scopes SET last_sync_at=?, last_error=NULL WHERE scope_key=?`).run(now.toISOString(), this.key);
+      this.db.prepare("UPDATE edge_scopes SET last_inbound_sync_at=? WHERE scope_key=?").run(now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async list(query = {}) {
+    await this.ready();
+    const scope = cursorScope(this.scope.principal, query);
+    const inputSequence = query.latest ? void 0 : decodeCursor(query.cursor, scope) ?? "0";
+    const cachedHighWater = query.latest ? void 0 : this.db.prepare(`SELECT remote_sequence
+      FROM edge_inbox WHERE scope_key=? ORDER BY sequence_key DESC LIMIT 1`).get(this.key);
+    const syncState = query.latest ? void 0 : this.db.prepare(
+      "SELECT pull_cursor FROM edge_scopes WHERE scope_key=?"
+    ).get(this.key);
+    const syncScope = cursorScope(this.scope.principal, {
+      mailbox: "all",
+      includeExpired: true
+    });
+    const syncSequence = syncState?.pull_cursor ? decodeCursor(String(syncState.pull_cursor), syncScope) ?? "0" : "0";
+    const highWaterSequence = query.latest ? void 0 : [
+      inputSequence ?? "0",
+      syncSequence,
+      cachedHighWater?.remote_sequence ? String(cachedHighWater.remote_sequence) : "0"
+    ].reduce((highest, candidate) => sequenceKey(candidate) > sequenceKey(highest) ? candidate : highest, "0");
+    const clauses = ["scope_key=?"];
+    const args = [this.key];
+    if (!query.latest) {
+      clauses.push("sequence_key>?");
+      args.push(sequenceKey(inputSequence ?? "0"));
+    }
+    if (!query.includeExpired) {
+      clauses.push("(expires_at IS NULL OR expires_at>?)");
+      args.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (query.types?.length) {
+      clauses.push(`type IN (${query.types.map(() => "?").join(",")})`);
+      args.push(...query.types);
+    }
+    if (query.source) {
+      clauses.push("source=?");
+      args.push(query.source);
+    }
+    const mailbox = query.mailbox ?? "inbox";
+    if (mailbox === "sent") {
+      clauses.push("source=?");
+      args.push(this.scope.principal.agent);
+    } else if (mailbox !== "all") {
+      clauses.push("(json_array_length(json_extract(message_json, '$.targets'))=0 OR EXISTS (SELECT 1 FROM json_each(json_extract(message_json, '$.targets')) WHERE value=?))");
+      args.push(this.scope.principal.agent);
+    } else {
+      clauses.push("(source=? OR json_array_length(json_extract(message_json, '$.targets'))=0 OR EXISTS (SELECT 1 FROM json_each(json_extract(message_json, '$.targets')) WHERE value=?))");
+      args.push(this.scope.principal.agent, this.scope.principal.agent);
+    }
+    if (query.project) {
+      clauses.push("project=?");
+      args.push(query.project);
+    }
+    if (query.since) {
+      clauses.push("created_at>=?");
+      args.push(query.since);
+    }
+    if (query.threadId) {
+      clauses.push("thread_id=?");
+      args.push(query.threadId);
+    }
+    const limit = Math.min(Math.max(Math.trunc(query.limit ?? 50), 1), 200);
+    const rows = this.db.prepare(`SELECT message_json FROM edge_inbox
+      WHERE ${clauses.join(" AND ")} ORDER BY sequence_key ${query.latest ? "DESC" : "ASC"} LIMIT ?`).all(...args, limit);
+    const messages = rows.map((row) => parseMessage(row.message_json));
+    const cursorMessage = query.latest ? messages[0] : messages[messages.length - 1];
+    if (query.latest || messages.length === limit) {
+      return { messages, cursor: cursorMessage ? encodeCursor(cursorMessage.sequence, scope) : query.cursor };
+    }
+    return {
+      messages,
+      cursor: highWaterSequence && highWaterSequence !== "0" ? encodeCursor(highWaterSequence, scope) : query.cursor
+    };
+  }
+  async pullCursor() {
+    await this.ready();
+    const row = this.db.prepare("SELECT pull_cursor FROM edge_scopes WHERE scope_key=?").get(this.key);
+    return row.pull_cursor ? String(row.pull_cursor) : void 0;
+  }
+  async noteError(error) {
+    await this.ready();
+    this.db.prepare("UPDATE edge_scopes SET last_error=? WHERE scope_key=?").run(error.slice(0, 256), this.key);
+  }
+  async noteAttempt(now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.prepare("UPDATE edge_scopes SET last_attempt_at=? WHERE scope_key=?").run(now.toISOString(), this.key);
+  }
+  async stats(now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    const nowText = now.toISOString();
+    const counts = this.db.prepare(`SELECT
+      sum(CASE WHEN state='pending' THEN 1 ELSE 0 END) AS pending,
+      sum(CASE WHEN state='pending' AND available_at<=? AND (lease_expires_at IS NULL OR lease_expires_at<=?) THEN 1 ELSE 0 END) AS due,
+      sum(CASE WHEN state='pending' AND available_at>? AND (lease_expires_at IS NULL OR lease_expires_at<=?) THEN 1 ELSE 0 END) AS scheduled,
+      sum(CASE WHEN state='pending' AND lease_expires_at>? THEN 1 ELSE 0 END) AS leased,
+      sum(CASE WHEN state='blocked' THEN 1 ELSE 0 END) AS blocked,
+      min(CASE WHEN state='pending' AND available_at<=? AND (lease_expires_at IS NULL OR lease_expires_at<=?) THEN available_at END) AS oldest_due,
+      min(CASE WHEN state='pending' AND available_at>? AND (lease_expires_at IS NULL OR lease_expires_at<=?) THEN available_at END) AS next_retry,
+      min(CASE WHEN state='blocked' THEN blocked_at END) AS oldest_blocked,
+      sum(CASE WHEN state='blocked' AND blocked_at IS NULL THEN 1 ELSE 0 END) AS blocked_age_unknown,
+      max(CASE WHEN state='blocked' THEN attempts ELSE 0 END) AS blocked_max_attempts
+      FROM edge_outbox WHERE scope_key=?`).get(nowText, nowText, nowText, nowText, nowText, nowText, nowText, nowText, nowText, this.key);
+    const blocked = this.db.prepare("SELECT last_error FROM edge_outbox WHERE scope_key=? AND state='blocked' ORDER BY coalesce(blocked_at,created_at) LIMIT 1").get(this.key);
+    const cache = this.db.prepare("SELECT count(*) AS count FROM edge_inbox WHERE scope_key=?").get(this.key);
+    const state = this.db.prepare(`SELECT pull_cursor, last_sync_at, last_error,
+      last_outbound_sync_at,last_inbound_sync_at,last_attempt_at
+      FROM edge_scopes WHERE scope_key=?`).get(this.key);
+    const oldestDueAt = counts.oldest_due ? String(counts.oldest_due) : void 0;
+    const oldestBlockedAt = Number(counts.blocked_age_unknown ?? 0) > 0 ? void 0 : counts.oldest_blocked ? String(counts.oldest_blocked) : void 0;
+    return {
+      pending: Number(counts.pending ?? 0),
+      due: Number(counts.due ?? 0),
+      scheduled: Number(counts.scheduled ?? 0),
+      leased: Number(counts.leased ?? 0),
+      blocked: Number(counts.blocked ?? 0),
+      cached: Number(cache.count ?? 0),
+      pullCursor: state.pull_cursor ? String(state.pull_cursor) : void 0,
+      lastSyncAt: state.last_sync_at ? String(state.last_sync_at) : void 0,
+      lastError: state.last_error ? String(state.last_error) : void 0,
+      oldestDueAt,
+      queueLagMs: oldestDueAt ? Math.max(0, now.getTime() - Date.parse(oldestDueAt)) : 0,
+      oldestBlockedAt,
+      blockedAgeMs: oldestBlockedAt ? Math.max(0, now.getTime() - Date.parse(oldestBlockedAt)) : null,
+      blockedMaxAttempts: Number(counts.blocked_max_attempts ?? 0),
+      blockedLastError: blocked?.last_error ? String(blocked.last_error) : void 0,
+      nextRetryAt: counts.next_retry ? String(counts.next_retry) : void 0,
+      lastOutboundSyncAt: state.last_outbound_sync_at ? String(state.last_outbound_sync_at) : void 0,
+      lastInboundSyncAt: state.last_inbound_sync_at ? String(state.last_inbound_sync_at) : void 0,
+      lastAttemptAt: state.last_attempt_at ? String(state.last_attempt_at) : void 0
+    };
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// src/syncing-bridge-store.ts
+function statusOf(error) {
+  if (!error || typeof error !== "object" || !("status" in error)) return void 0;
+  const status = Number(error.status);
+  return Number.isFinite(status) ? status : void 0;
+}
+function codeOf(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    if (typeof code === "string" && code) return code.slice(0, 128);
+  }
+  return error instanceof Error ? error.name.slice(0, 128) : "sync_error";
+}
+function isRetryableSyncError(error) {
+  const status = statusOf(error);
+  const code = codeOf(error);
+  if (["network_error", "request_timeout"].includes(code)) return true;
+  if (["invalid_input", "idempotency_conflict", "edge_idempotency_conflict", "principal_mismatch", "protocol_mismatch", "store_closed"].includes(code)) return false;
+  return status === 0 || status === 408 || status === 425 || status === 429 || status !== void 0 && status >= 500;
+}
+function provisional(draft, createdAt) {
+  return { ...draft, sequence: "0", createdAt };
+}
+var SyncingBridgeStore = class {
+  constructor(edge, remote, principal, options = {}) {
+    this.edge = edge;
+    this.remote = remote;
+    this.principal = principal;
+    this.stopped = false;
+    this.closeController = new AbortController();
+    this.wakeRequested = false;
+    this.remoteReachable = null;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.random = options.random ?? Math.random;
+    this.baseDelayMs = options.baseDelayMs ?? 1e3;
+    this.maxDelayMs = options.maxDelayMs ?? 5 * 6e4;
+    this.leaseMs = options.leaseMs ?? 3e4;
+    this.autoSync = options.autoSync ?? true;
+    this.idleDelayMs = Math.max(this.baseDelayMs + 1, options.idleDelayMs ?? 3e4);
+    this.loopState = this.autoSync ? "idle" : "disabled";
+  }
+  async initialize() {
+    await this.edge.initialize();
+    if (this.autoSync) this.startTransportLoop();
+  }
+  startTransportLoop() {
+    if (this.background) return;
+    this.background = this.transportLoop().catch((error) => {
+      this.backgroundError = error;
+      this.loopState = "failed";
+    });
+  }
+  async wait(delayMs) {
+    if (this.stopped) return;
+    if (this.wakeRequested) {
+      this.wakeRequested = false;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.wake = resolve;
+      this.wakeTimer = setTimeout(resolve, delayMs);
+      this.wakeTimer.unref?.();
+    });
+    this.wake = void 0;
+    this.wakeTimer = void 0;
+  }
+  wakeTransport() {
+    if (this.wake) {
+      if (this.wakeTimer) clearTimeout(this.wakeTimer);
+      this.wake();
+    } else this.wakeRequested = true;
+  }
+  fatal(error) {
+    if (this.backgroundError instanceof Error) return this.backgroundError;
+    const cause = error instanceof Error ? error : new Error(String(error));
+    const fatal = Object.assign(new Error(`fatal local edge failure: ${cause.message}`), {
+      code: "local_edge_commit_failed",
+      cause
+    });
+    this.backgroundError = fatal;
+    return fatal;
+  }
+  assertHealthy() {
+    if (this.backgroundError) throw this.backgroundError;
+  }
+  async transportLoop() {
+    let failures = 0;
+    await this.wait(this.delay(0));
+    while (!this.stopped) {
+      this.loopState = "running";
+      const report = await this.sync({ maxPush: 100, maxPages: 1, signal: this.closeController.signal });
+      if (this.stopped) break;
+      if (report.failureRetryable === false) {
+        this.backgroundError = Object.assign(
+          new Error(`gateway synchronization failed permanently: ${report.lastError ?? "sync_error"}`),
+          { code: report.lastError ?? "sync_error" }
+        );
+        this.loopState = "failed";
+        return;
+      }
+      failures = report.online ? 0 : Math.min(failures + 1, 20);
+      this.loopState = report.online ? "idle" : "backoff";
+      await this.wait(report.pending > 0 ? this.delay(Math.max(0, failures - 1)) : this.idleDelayMs);
+    }
+  }
+  async verifyRemote() {
+    await this.ensureRemote();
+  }
+  async ensureRemote(signal) {
+    if (!this.remoteReady) {
+      this.remoteReady = this.remote.initialize({ signal }).catch((error) => {
+        this.remoteReady = void 0;
+        throw error;
+      });
+    }
+    try {
+      await this.remoteReady;
+      this.remoteReachable = true;
+    } catch (error) {
+      this.remoteReachable = false;
+      throw error;
+    }
+  }
+  assertPrincipal(principal, includeInstance = true) {
+    if (principal.workspace !== this.principal.workspace || principal.agent !== this.principal.agent || includeInstance && principal.instance !== this.principal.instance) {
+      const error = new Error("principal does not match the synchronized edge scope");
+      Object.assign(error, { status: 403, code: "principal_mismatch" });
+      throw error;
+    }
+  }
+  delay(attempts) {
+    const exponential = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** Math.min(attempts, 20));
+    const jitter = 0.8 + this.random() * 0.4;
+    return Math.max(1, Math.round(exponential * jitter));
+  }
+  cancelled(signal) {
+    return this.stopped || Boolean(signal?.aborted);
+  }
+  async flushOne(signal) {
+    await this.edge.noteAttempt(this.now());
+    try {
+      await this.ensureRemote(signal);
+    } catch (error) {
+      await this.edge.noteError(codeOf(error));
+      return {
+        state: "retry",
+        error: error instanceof Error ? error : new Error(String(error)),
+        retryable: isRetryableSyncError(error)
+      };
+    }
+    const record = await this.edge.claimNext(this.now(), this.leaseMs);
+    if (!record) return { state: "empty" };
+    try {
+      const result = await this.remote.insertMessage(record.draft, { signal });
+      this.remoteReachable = true;
+      if (result.message.id !== record.draft.id) {
+        const error = new Error("idempotency key resolved to a different message ID");
+        Object.assign(error, { status: 409, code: "idempotency_conflict" });
+        await this.edge.block(record, codeOf(error), this.now());
+        return { state: "blocked", error, messageId: record.draft.id };
+      }
+      if (edgeMessageFingerprint(result.message) !== record.payloadHash) {
+        const error = new Error("idempotency key resolved to different message content");
+        Object.assign(error, { status: 409, code: "idempotency_conflict" });
+        await this.edge.block(record, codeOf(error), this.now());
+        return { state: "blocked", error, messageId: record.draft.id };
+      }
+      try {
+        await this.edge.commit(record, result.message, this.now());
+      } catch (error) {
+        return { state: "fatal", error: this.fatal(error) };
+      }
+      return { state: "committed", result, messageId: record.draft.id };
+    } catch (error) {
+      const caught = error instanceof Error ? error : new Error(String(error));
+      this.remoteReachable = isRetryableSyncError(error) ? false : true;
+      if (this.cancelled(signal)) {
+        await this.edge.retry(record, "request_cancelled", this.now());
+        return { state: "retry", error: caught, retryable: true };
+      }
+      if (isRetryableSyncError(error)) {
+        await this.edge.retry(
+          record,
+          codeOf(error),
+          new Date(this.now().getTime() + this.delay(record.attempts))
+        );
+        return { state: "retry", error: caught, retryable: true };
+      }
+      await this.edge.block(record, codeOf(error), this.now());
+      return { state: "blocked", error: caught, messageId: record.draft.id };
+    }
+  }
+  async insertMessage(message) {
+    this.assertHealthy();
+    this.assertPrincipal({ workspace: message.workspace, agent: message.source }, false);
+    let remoteError;
+    try {
+      await this.ensureRemote();
+    } catch (error) {
+      if (!isRetryableSyncError(error)) throw error;
+      remoteError = error;
+    }
+    const queued = await this.edge.enqueue(message, this.now());
+    const draft = queued.draft;
+    if (remoteError) {
+      await this.edge.noteError(codeOf(remoteError));
+      this.wakeTransport();
+      return {
+        message: provisional(draft, this.now().toISOString()),
+        created: queued.created,
+        disposition: "queued",
+        authoritative: false
+      };
+    }
+    const flushed = await this.flushOne();
+    if (flushed.state === "fatal") throw flushed.error;
+    if (flushed.state === "blocked" && flushed.messageId === draft.id) throw flushed.error;
+    if (flushed.state === "retry" && !flushed.retryable) throw flushed.error;
+    if (flushed.state === "committed" && flushed.messageId === draft.id) {
+      return { ...flushed.result, disposition: "committed", authoritative: true };
+    }
+    this.wakeTransport();
+    return {
+      message: provisional(draft, this.now().toISOString()),
+      created: queued.created,
+      disposition: "queued",
+      authoritative: false
+    };
+  }
+  async pull(maxPages, signal) {
+    let pulled = 0;
+    for (let pageNumber = 0; pageNumber < maxPages; pageNumber += 1) {
+      if (this.cancelled(signal)) break;
+      const before = await this.edge.pullCursor();
+      let page;
+      try {
+        await this.ensureRemote(signal);
+        page = await this.remote.listMessages(this.principal, {
+          cursor: before,
+          limit: 200,
+          includeExpired: true,
+          mailbox: "all"
+        }, { signal });
+        this.remoteReachable = true;
+      } catch (error) {
+        this.remoteReachable = isRetryableSyncError(error) ? false : true;
+        await this.edge.noteError(codeOf(error));
+        return {
+          online: false,
+          pulled,
+          error: error instanceof Error ? error : new Error(String(error)),
+          retryable: isRetryableSyncError(error)
+        };
+      }
+      try {
+        await this.edge.cachePage(page.messages, page.cursor, this.now());
+      } catch (error) {
+        throw this.fatal(error);
+      }
+      pulled += page.messages.length;
+      if (page.messages.length < 200 || !page.cursor || page.cursor === before) break;
+    }
+    return { online: true, pulled };
+  }
+  async sync(options = {}) {
+    this.assertHealthy();
+    await this.edge.initialize();
+    await this.edge.noteAttempt(this.now());
+    const maxPush = Math.min(Math.max(Math.trunc(options.maxPush ?? 100), 0), 1e3);
+    const maxPages = Math.min(Math.max(Math.trunc(options.maxPages ?? 20), 0), 100);
+    let pushed = 0;
+    let deduplicated = 0;
+    let online = true;
+    let lastError;
+    let failureRetryable;
+    if (options.signal?.aborted) {
+      const stats2 = await this.edge.stats(this.now());
+      return {
+        online: false,
+        pushed: 0,
+        deduplicated: 0,
+        pulled: 0,
+        pending: stats2.pending,
+        blocked: stats2.blocked,
+        cached: stats2.cached,
+        cursor: stats2.pullCursor,
+        lastSyncedAt: stats2.lastSyncAt,
+        lastError: "request_cancelled",
+        failureRetryable: true
+      };
+    }
+    for (let index = 0; index < maxPush; index += 1) {
+      if (this.cancelled(options.signal)) break;
+      const result = await this.flushOne(options.signal);
+      if (result.state === "empty") break;
+      if (result.state === "committed") {
+        pushed += 1;
+        if (!result.result.created) deduplicated += 1;
+        continue;
+      }
+      if (result.state === "fatal") throw result.error;
+      lastError = codeOf(result.error);
+      failureRetryable = result.state === "retry" ? result.retryable : void 0;
+      if (result.state === "retry") online = false;
+      if (result.state === "retry") break;
+    }
+    let pulled = 0;
+    if (maxPages > 0 && !this.cancelled(options.signal)) {
+      const pull = await this.pull(maxPages, options.signal);
+      online = online && pull.online;
+      pulled = pull.pulled;
+      if (pull.error) {
+        lastError = codeOf(pull.error);
+        failureRetryable = pull.retryable;
+      }
+    }
+    const stats = await this.edge.stats(this.now());
+    return {
+      online,
+      pushed,
+      deduplicated,
+      pulled,
+      pending: stats.pending,
+      blocked: stats.blocked,
+      cached: stats.cached,
+      cursor: stats.pullCursor,
+      lastSyncedAt: stats.lastSyncAt,
+      lastError: lastError ?? stats.lastError,
+      failureRetryable
+    };
+  }
+  async listMessages(principal, query = {}) {
+    this.assertHealthy();
+    this.assertPrincipal(principal);
+    await this.sync({ maxPush: 20, maxPages: 0 });
+    let remotePage;
+    try {
+      await this.ensureRemote();
+      remotePage = await this.remote.listMessages(principal, query);
+    } catch (error) {
+      const retryable = isRetryableSyncError(error);
+      this.remoteReachable = retryable ? false : true;
+      if (!retryable) throw error;
+      await this.edge.noteError(codeOf(error));
+      let cached;
+      let stats;
+      try {
+        cached = await this.edge.list(query);
+        stats = await this.edge.stats(this.now());
+      } catch (cacheError) {
+        throw this.fatal(cacheError);
+      }
+      return {
+        ...cached,
+        source: "cache",
+        stale: true,
+        degraded: true,
+        acknowledgements: query.receiptState && query.receiptState !== "any" || "unacknowledgedBy" in query ? "unknown" : "authoritative",
+        lastSyncedAt: stats.lastSyncAt
+      };
+    }
+    try {
+      this.remoteReachable = true;
+      await this.edge.cacheLatest(remotePage.messages, this.now());
+      const stats = await this.edge.stats(this.now());
+      return {
+        ...remotePage,
+        source: "remote",
+        stale: false,
+        degraded: false,
+        acknowledgements: "authoritative",
+        lastSyncedAt: stats.lastSyncAt
+      };
+    } catch (error) {
+      throw this.fatal(error);
+    }
+  }
+  async recordReceipt(principal, messageIds, readAt) {
+    this.assertPrincipal(principal, false);
+    await this.ensureRemote();
+    return this.remote.recordReceipt(principal, messageIds, readAt);
+  }
+  async claimDelivery(principal, options) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.claimDelivery(principal, options);
+  }
+  async renewDelivery(principal, deliveryId, leaseToken, leaseMs) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.renewDelivery(principal, deliveryId, leaseToken, leaseMs);
+  }
+  async settleDelivery(principal, deliveryId, leaseToken, state, error, _retryPolicy) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.settleDelivery(principal, deliveryId, leaseToken, state, error);
+  }
+  async listDeliveries(principal, query = {}) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.listDeliveries) throw new Error("delivery listing is not supported");
+    return this.remote.listDeliveries(principal, query);
+  }
+  async listDeliveryEvents(principal, id, query = {}) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.listDeliveryEvents) throw new Error("delivery event listing is not supported");
+    return this.remote.listDeliveryEvents(principal, id, query);
+  }
+  async cancelDelivery(principal, id) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.cancelDelivery) throw new Error("delivery cancellation is not supported");
+    return this.remote.cancelDelivery(principal, id);
+  }
+  async requeueDelivery(principal, id) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.requeueDelivery) throw new Error("delivery requeue is not supported");
+    return this.remote.requeueDelivery(principal, id);
+  }
+  async diagnostics(principal, options = {}) {
+    this.assertPrincipal(principal);
+    const edge = await this.edge.stats(this.now());
+    let remote;
+    let remoteError;
+    if (options.mode === "probe") {
+      try {
+        if (this.remote.diagnostics) remote = await this.remote.diagnostics(principal);
+        else await this.ensureRemote();
+        this.remoteReachable = true;
+      } catch (error) {
+        const retryable = isRetryableSyncError(error);
+        this.remoteReachable = retryable ? false : true;
+        remoteError = codeOf(error);
+      }
+    }
+    return {
+      schemaVersion: remote?.schemaVersion ?? "postgres-v2",
+      deliverySupported: remote?.deliverySupported ?? true,
+      pending: remote?.pending ?? null,
+      claimed: remote?.claimed ?? null,
+      retrying: remote?.retrying ?? null,
+      dead: remote?.dead ?? null,
+      cancelled: remote?.cancelled ?? null,
+      oldestAvailableAt: remote?.oldestAvailableAt,
+      due: remote?.due ?? null,
+      scheduled: remote?.scheduled ?? null,
+      expiredLeases: remote?.expiredLeases ?? null,
+      oldestDueAt: remote?.oldestDueAt,
+      queueLagMs: remote?.queueLagMs ?? null,
+      principal: { workspace: principal.workspace, agent: principal.agent },
+      remoteReachable: options.mode === "probe" ? this.remoteReachable : null,
+      outboxPending: edge.pending,
+      outboxBlocked: edge.blocked,
+      cachedMessages: edge.cached,
+      lastSyncAt: edge.lastSyncAt,
+      lastSyncError: edge.lastError,
+      outboxDue: edge.due,
+      outboxScheduled: edge.scheduled,
+      outboxLeased: edge.leased,
+      outboxOldestDueAt: edge.oldestDueAt,
+      outboxQueueLagMs: edge.queueLagMs,
+      outboxOldestBlockedAt: edge.oldestBlockedAt,
+      outboxBlockedAgeMs: edge.blockedAgeMs,
+      outboxBlockedMaxAttempts: edge.blockedMaxAttempts,
+      outboxBlockedLastError: edge.blockedLastError,
+      outboxNextRetryAt: edge.nextRetryAt,
+      lastOutboundSyncAt: edge.lastOutboundSyncAt,
+      lastInboundSyncAt: edge.lastInboundSyncAt,
+      lastSyncAttemptAt: edge.lastAttemptAt,
+      syncLoopState: this.backgroundError ? "failed" : this.loopState,
+      syncLoopError: this.backgroundError ? codeOf(this.backgroundError) : void 0,
+      remoteError
+    };
+  }
+  async heartbeat(principal, leaseMs, runtimeType, capabilities = []) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.heartbeat) throw new Error("presence is not supported by the remote provider");
+    return this.remote.heartbeat(principal, leaseMs, runtimeType, capabilities);
+  }
+  async listPresence(principal) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.listPresence) throw new Error("presence is not supported by the remote provider");
+    return this.remote.listPresence(principal);
+  }
+  async close() {
+    this.stopped = true;
+    this.loopState = "stopped";
+    this.closeController.abort(new Error("synchronization stopped"));
+    if (this.wakeTimer) clearTimeout(this.wakeTimer);
+    this.wake?.();
+    const results = await Promise.allSettled([
+      this.remote.close?.() ?? Promise.resolve(),
+      this.background ?? Promise.resolve()
+    ]);
+    const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (this.backgroundError) failures.push(this.backgroundError);
+    try {
+      await this.edge.close();
+    } catch (error) {
+      failures.push(error);
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw Object.assign(new Error("failed to close synchronized bridge store"), { errors: failures });
+  }
+};
+
+export {
+  EdgeConflictError,
+  edgeMessageFingerprint,
+  stableIdempotency,
+  edgeScopeKey,
+  SQLiteEdgeStore,
+  isRetryableSyncError,
+  SyncingBridgeStore
+};
+//# sourceMappingURL=chunk-Q6PPMXJC.js.map