@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/sqlite.d.ts

@@ -1,5 +1,5 @@
-import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, D as DeliveryState, R as RetryPolicy, A as AgentPresence, a as BridgeDeliveryEvent } from './bridge-domain-BcnBeHOn.js';
-import { b as MessageQuery, M as MessagePage, B as BridgeDiagnostics, I as InsertMessageResult, a as BridgeStore, C as ClaimOptions } from './bridge-store-BuGjxTn4.js';
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, g as DeliveryState, R as RetryPolicy, A as AgentPresence, a as BridgeDeliveryEvent } from './bridge-domain-CBX3IVqC.js';
+import { d as MessageQuery, M as MessagePage, B as BridgeDiagnostics, I as InsertMessageResult, a as BridgeStore, C as ClaimOptions, c as DeliveryQuery, b as DeliveryPage, D as DeliveryEventPage } from './bridge-store-DPVSCwfs.js';
 
 type PendingMessage = Omit<BridgeMessage, "sequence" | "createdAt">;
 interface EdgeScope {
@@ -20,11 +20,24 @@ interface EdgeEnqueueResult {
 }
 interface EdgeStats {
     pending: number;
+    due: number;
+    scheduled: number;
+    leased: number;
     blocked: number;
     cached: number;
     pullCursor?: string;
     lastSyncAt?: string;
     lastError?: string;
+    oldestDueAt?: string;
+    queueLagMs: number;
+    oldestBlockedAt?: string;
+    blockedAgeMs: number | null;
+    blockedMaxAttempts: number;
+    blockedLastError?: string;
+    nextRetryAt?: string;
+    lastOutboundSyncAt?: string;
+    lastInboundSyncAt?: string;
+    lastAttemptAt?: string;
 }
 declare class EdgeConflictError extends Error {
     readonly code = "edge_idempotency_conflict";
@@ -37,25 +50,30 @@ declare class SQLiteEdgeStore {
     private readonly scope;
     private readonly busyTimeoutMs;
     private readonly db;
+    private readonly databasePath;
+    private readonly preexistingFiles;
     private readonly key;
     private initialized;
+    private initialization?;
     constructor(path: string, scope: EdgeScope, busyTimeoutMs?: number);
     private restrictFiles;
     get scopeKey(): string;
     initialize(): Promise<void>;
+    private initializeOnce;
     private ready;
     enqueue(input: PendingMessage, now?: Date): Promise<EdgeEnqueueResult>;
     claimNext(now?: Date, leaseMs?: number): Promise<EdgeOutboxRecord | undefined>;
     retry(record: EdgeOutboxRecord, error: string, availableAt: Date): Promise<void>;
-    block(record: EdgeOutboxRecord, error: string): Promise<void>;
-    commit(record: EdgeOutboxRecord, message: BridgeMessage, cacheVisible: boolean, now?: Date): Promise<void>;
+    block(record: EdgeOutboxRecord, error: string, now?: Date): Promise<void>;
+    commit(record: EdgeOutboxRecord, message: BridgeMessage, now?: Date): Promise<void>;
     private cacheOne;
     cachePage(messages: BridgeMessage[], cursor: string | undefined, now?: Date): Promise<void>;
     cacheLatest(messages: BridgeMessage[], now?: Date): Promise<void>;
     list(query?: MessageQuery): Promise<MessagePage>;
     pullCursor(): Promise<string | undefined>;
     noteError(error: string): Promise<void>;
-    stats(): Promise<EdgeStats>;
+    noteAttempt(now?: Date): Promise<void>;
+    stats(now?: Date): Promise<EdgeStats>;
     close(): Promise<void>;
 }
 
@@ -66,6 +84,8 @@ interface SyncInsertResult extends InsertMessageResult {
 interface CachedMessagePage extends MessagePage {
     source: "remote" | "cache";
     stale: boolean;
+    degraded: boolean;
+    acknowledgements: "authoritative" | "unknown";
     lastSyncedAt?: string;
 }
 interface SyncReport {
@@ -82,12 +102,28 @@ interface SyncReport {
     failureRetryable?: boolean;
 }
 interface SyncDiagnostics extends BridgeDiagnostics {
-    remoteReachable: boolean;
+    remoteReachable: boolean | null;
     outboxPending: number;
     outboxBlocked: number;
     cachedMessages: number;
     lastSyncAt?: string;
     lastSyncError?: string;
+    outboxDue: number;
+    outboxScheduled: number;
+    outboxLeased: number;
+    outboxOldestDueAt?: string;
+    outboxQueueLagMs: number;
+    outboxOldestBlockedAt?: string;
+    outboxBlockedAgeMs: number | null;
+    outboxBlockedMaxAttempts: number;
+    outboxBlockedLastError?: string;
+    outboxNextRetryAt?: string;
+    lastOutboundSyncAt?: string;
+    lastInboundSyncAt?: string;
+    lastSyncAttemptAt?: string;
+    syncLoopState: "disabled" | "idle" | "running" | "backoff" | "stopped" | "failed";
+    syncLoopError?: string;
+    remoteError?: string;
 }
 interface SyncingBridgeStoreOptions {
     now?: () => Date;
@@ -95,6 +131,8 @@ interface SyncingBridgeStoreOptions {
     baseDelayMs?: number;
     maxDelayMs?: number;
     leaseMs?: number;
+    autoSync?: boolean;
+    idleDelayMs?: number;
 }
 declare function isRetryableSyncError(error: unknown): boolean;
 declare class SyncingBridgeStore implements BridgeStore {
@@ -106,26 +144,54 @@ declare class SyncingBridgeStore implements BridgeStore {
     private readonly baseDelayMs;
     private readonly maxDelayMs;
     private readonly leaseMs;
+    private readonly autoSync;
+    private readonly idleDelayMs;
     private remoteReady;
+    private stopped;
+    private wakeTimer;
+    private wake;
+    private background;
+    private readonly closeController;
+    private backgroundError;
+    private wakeRequested;
+    private remoteReachable;
+    private loopState;
     constructor(edge: SQLiteEdgeStore, remote: BridgeStore, principal: BridgePrincipal, options?: SyncingBridgeStoreOptions);
     initialize(): Promise<void>;
+    private startTransportLoop;
+    private wait;
+    private wakeTransport;
+    private fatal;
+    private assertHealthy;
+    private transportLoop;
     verifyRemote(): Promise<void>;
     private ensureRemote;
     private assertPrincipal;
     private delay;
+    private cancelled;
     private flushOne;
     insertMessage(message: PendingMessage): Promise<SyncInsertResult>;
     private pull;
     sync(options?: {
         maxPush?: number;
         maxPages?: number;
+        signal?: AbortSignal;
     }): Promise<SyncReport>;
     listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<CachedMessagePage>;
-    recordReceipt(workspace: string, messageIds: string[], principal: string, readAt?: Date): Promise<number>;
+    recordReceipt(principal: BridgePrincipal, messageIds: string[], readAt?: Date): Promise<number>;
     claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
     renewDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
-    diagnostics(principal: BridgePrincipal): Promise<SyncDiagnostics>;
+    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
+    listDeliveries(principal: BridgePrincipal, query?: DeliveryQuery): Promise<DeliveryPage>;
+    listDeliveryEvents(principal: BridgePrincipal, id: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<DeliveryEventPage>;
+    cancelDelivery(principal: BridgePrincipal, id: string): Promise<BridgeDelivery | null>;
+    requeueDelivery(principal: BridgePrincipal, id: string): Promise<BridgeDelivery | null>;
+    diagnostics(principal: BridgePrincipal, options?: {
+        mode?: "snapshot" | "probe";
+    }): Promise<SyncDiagnostics>;
     heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
     listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
     close(): Promise<void>;
@@ -135,21 +201,37 @@ declare class SQLiteBridgeStore implements BridgeStore {
     private readonly path;
     private readonly busyTimeoutMs;
     private readonly db;
+    private readonly databasePath;
+    private readonly preexistingFiles;
     private initialized;
+    private initialization?;
     constructor(path?: string, busyTimeoutMs?: number);
     private restrictFiles;
     initialize(): Promise<void>;
+    private initializeOnce;
     private ready;
     insertMessage(input: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
     listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
-    recordReceipt(workspace: string, messageIds: string[], principal: string, readAt?: Date): Promise<number>;
+    recordReceipt(principal: BridgePrincipal, messageIds: string[], readAt?: Date): Promise<number>;
     claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
     renewDelivery(principal: BridgePrincipal, id: string, token: string, leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
     diagnostics(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
     heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
     listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
-    listDeliveryEvents(deliveryId: string): Promise<BridgeDeliveryEvent[]>;
+    listDeliveries(principal: BridgePrincipal, query?: DeliveryQuery): Promise<{
+        deliveries: BridgeDelivery[];
+        cursor: string | undefined;
+    }>;
+    listDeliveryEvents(principal: BridgePrincipal, deliveryId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        events: BridgeDeliveryEvent[];
+        cursor: string | undefined;
+    }>;
+    cancelDelivery(principal: BridgePrincipal, id: string): Promise<BridgeDelivery | null>;
+    requeueDelivery(principal: BridgePrincipal, id: string): Promise<BridgeDelivery | null>;
     close(): Promise<void>;
 }
 

package/dist/sqlite.js

@@ -1,16 +1,19 @@
 #!/usr/bin/env node
 import {
   EdgeConflictError,
-  SQLiteBridgeStore,
   SQLiteEdgeStore,
   SyncingBridgeStore,
   edgeMessageFingerprint,
   edgeScopeKey,
   isRetryableSyncError,
   stableIdempotency
-} from "./chunk-WEULPMUY.js";
-import "./chunk-YD6YJATN.js";
-import "./chunk-BV6W4AJK.js";
+} from "./chunk-Q6PPMXJC.js";
+import {
+  SQLiteBridgeStore
+} from "./chunk-5GMB3A77.js";
+import "./chunk-NCO7RLBM.js";
+import "./chunk-VOQIDTCJ.js";
+import "./chunk-BZLMF5O5.js";
 export {
   EdgeConflictError,
   SQLiteBridgeStore,