agent-relay 1.3.0 → 1.3.2

package/dist/daemon/router.d.ts

@@ -6,6 +6,8 @@ import { type Envelope, type SendEnvelope, type AckPayload, type ShadowConfig, t
 import type { ChannelJoinPayload, ChannelLeavePayload, ChannelMessagePayload } from '../protocol/channels.js';
 import type { StorageAdapter } from '../storage/adapter.js';
 import type { AgentRegistry } from './agent-registry.js';
+import { type RateLimitConfig } from './rate-limiter.js';
+import { type DeliveryReliabilityOptions } from './delivery-tracker.js';
 export interface RoutableConnection {
     id: string;
     agentName?: string;
@@ -32,14 +34,6 @@ export interface CrossMachineHandler {
     sendCrossMachineMessage(targetDaemonId: string, targetAgent: string, fromAgent: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
     isRemoteAgent(agentName: string): RemoteAgentInfo | undefined;
 }
-export interface DeliveryReliabilityOptions {
-    /** How long to wait for an ACK before retrying (ms) */
-    ackTimeoutMs: number;
-    /** Maximum attempts (initial send counts as attempt 1) */
-    maxAttempts: number;
-    /** How long to keep retrying before dropping (ms) */
-    deliveryTtlMs: number;
-}
 /** Internal shadow relationship with resolved defaults */
 interface ShadowRelationship extends ShadowConfig {
     shadowAgent: string;
@@ -49,11 +43,10 @@ export declare class Router {
     private connections;
     private agents;
     private subscriptions;
-    private pendingDeliveries;
     private processingAgents;
-    private deliveryOptions;
     private registry?;
     private crossMachineHandler?;
+    private deliveryTracker;
     /** Shadow relationships: primaryAgent -> list of shadow configs */
     private shadowsByPrimary;
     /** Reverse lookup: shadowAgent -> primaryAgent (for cleanup) */
@@ -68,12 +61,16 @@ export declare class Router {
     private static readonly PROCESSING_TIMEOUT_MS;
     /** Callback when processing state changes (for real-time dashboard updates) */
     private onProcessingStateChange?;
+    /** Rate limiter for per-agent throttling */
+    private rateLimiter;
     constructor(options?: {
         storage?: StorageAdapter;
         delivery?: Partial<DeliveryReliabilityOptions>;
         registry?: AgentRegistry;
         onProcessingStateChange?: () => void;
         crossMachineHandler?: CrossMachineHandler;
+        /** Rate limit configuration. Set to null to disable rate limiting. */
+        rateLimit?: Partial<RateLimitConfig> | null;
     });
     /**
      * Set or update the cross-machine handler.
@@ -177,6 +174,17 @@ export declare class Router {
      */
     get connectionCount(): number;
     get pendingDeliveryCount(): number;
+    /**
+     * Get rate limiter statistics.
+     */
+    getRateLimiterStats(): {
+        agentCount: number;
+        config: RateLimitConfig;
+    };
+    /**
+     * Reset rate limit for a specific agent (admin operation).
+     */
+    resetRateLimit(agentName: string): void;
     /**
      * Get list of agents currently processing (thinking).
      * Returns an object with agent names as keys and processing info as values.
@@ -209,7 +217,6 @@ export declare class Router {
      * Track a delivery and schedule retries until ACKed or TTL/attempts exhausted.
      */
     private trackDelivery;
-    private scheduleRetry;
     /**
      * Broadcast a system message to all connected agents.
      * Used for system notifications like agent death announcements.

package/dist/daemon/router.js

@@ -2,24 +2,20 @@
  * Message router for the agent relay daemon.
  * Handles routing messages between agents, topic subscriptions, and broadcast.
  */
-import { v4 as uuid } from 'uuid';
+import { generateId } from '../utils/id-generator.js';
 import { PROTOCOL_VERSION, } from '../protocol/types.js';
 import { routerLog } from '../utils/logger.js';
-const DEFAULT_DELIVERY_OPTIONS = {
-    ackTimeoutMs: 5000,
-    maxAttempts: 5,
-    deliveryTtlMs: 60_000,
-};
+import { RateLimiter, NoOpRateLimiter } from './rate-limiter.js';
+import { DeliveryTracker, } from './delivery-tracker.js';
 export class Router {
     storage;
     connections = new Map(); // connectionId -> Connection
     agents = new Map(); // agentName -> Connection
     subscriptions = new Map(); // topic -> Set<agentName>
-    pendingDeliveries = new Map(); // deliverId -> pending
     processingAgents = new Map(); // agentName -> processing state
-    deliveryOptions;
     registry;
     crossMachineHandler;
+    deliveryTracker;
     /** Shadow relationships: primaryAgent -> list of shadow configs */
     shadowsByPrimary = new Map();
     /** Reverse lookup: shadowAgent -> primaryAgent (for cleanup) */
@@ -34,12 +30,22 @@ export class Router {
     static PROCESSING_TIMEOUT_MS = 30_000;
     /** Callback when processing state changes (for real-time dashboard updates) */
     onProcessingStateChange;
+    /** Rate limiter for per-agent throttling */
+    rateLimiter;
     constructor(options = {}) {
         this.storage = options.storage;
-        this.deliveryOptions = { ...DEFAULT_DELIVERY_OPTIONS, ...options.delivery };
         this.registry = options.registry;
         this.onProcessingStateChange = options.onProcessingStateChange;
         this.crossMachineHandler = options.crossMachineHandler;
+        this.deliveryTracker = new DeliveryTracker({
+            storage: this.storage,
+            delivery: options.delivery,
+            getConnection: (id) => this.connections.get(id),
+        });
+        // Initialize rate limiter (null = disabled)
+        this.rateLimiter = options.rateLimit === null
+            ? new NoOpRateLimiter()
+            : new RateLimiter(options.rateLimit);
     }
     /**
      * Set or update the cross-machine handler.
@@ -239,7 +245,7 @@ export class Router {
             const triggerEnvelope = {
                 v: PROTOCOL_VERSION,
                 type: 'SEND',
-                id: uuid(),
+                id: generateId(),
                 ts: Date.now(),
                 from: primaryAgent,
                 to: shadow.shadowAgent,
@@ -287,6 +293,11 @@ export class Router {
             routerLog.warn('Dropping message - sender has no name');
             return;
         }
+        // Check rate limit
+        if (!this.rateLimiter.tryAcquire(senderName)) {
+            routerLog.warn(`Rate limited: ${senderName}`);
+            return;
+        }
         // Agent is responding - clear their processing state
         this.clearProcessing(senderName);
         this.registry?.recordSend(senderName);
@@ -435,22 +446,27 @@ export class Router {
      * Broadcast to all agents (optionally filtered by topic subscription).
      */
     broadcast(from, envelope, topic) {
+        // Build recipients list from both agents and users
         const recipients = topic
             ? this.subscriptions.get(topic) ?? new Set()
-            : new Set(this.agents.keys());
-        for (const agentName of recipients) {
-            if (agentName === from)
+            : new Set([...this.agents.keys(), ...this.users.keys()]);
+        for (const recipientName of recipients) {
+            if (recipientName === from)
                 continue; // Don't send to self
-            const target = this.agents.get(agentName);
+            // Check both agents and users maps (consistent with sendDirect)
+            const target = this.agents.get(recipientName) ?? this.users.get(recipientName);
             if (target) {
-                const deliver = this.createDeliverEnvelope(from, agentName, envelope, target);
+                const isUserTarget = target.entityType === 'user';
+                const deliver = this.createDeliverEnvelope(from, recipientName, envelope, target);
                 const sent = target.send(deliver);
                 this.persistDeliverEnvelope(deliver, true); // Mark as broadcast
                 if (sent) {
                     this.trackDelivery(target, deliver);
-                    this.registry?.recordReceive(agentName);
-                    // Mark recipient as processing
-                    this.setProcessing(agentName, deliver.id);
+                    this.registry?.recordReceive(recipientName);
+                    // Only mark AI agents as processing; humans don't need processing indicators
+                    if (!isUserTarget) {
+                        this.setProcessing(recipientName, deliver.id);
+                    }
                 }
             }
         }
@@ -464,7 +480,7 @@ export class Router {
         return {
             v: PROTOCOL_VERSION,
             type: 'DELIVER',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             from,
             to,
@@ -524,7 +540,19 @@ export class Router {
         return this.connections.size;
     }
     get pendingDeliveryCount() {
-        return this.pendingDeliveries.size;
+        return this.deliveryTracker.pendingCount;
+    }
+    /**
+     * Get rate limiter statistics.
+     */
+    getRateLimiterStats() {
+        return this.rateLimiter.getStats();
+    }
+    /**
+     * Reset rate limit for a specific agent (admin operation).
+     */
+    resetRateLimit(agentName) {
+        this.rateLimiter.reset(agentName);
     }
     /**
      * Get list of agents currently processing (thinking).
@@ -580,103 +608,19 @@ export class Router {
      */
     handleAck(connection, envelope) {
         const ackId = envelope.payload.ack_id;
-        const pending = this.pendingDeliveries.get(ackId);
-        if (!pending)
-            return;
-        // Only accept ACKs from the same connection that received the deliver
-        if (pending.connectionId !== connection.id)
-            return;
-        if (pending.timer) {
-            clearTimeout(pending.timer);
-        }
-        this.pendingDeliveries.delete(ackId);
-        const statusUpdate = this.storage?.updateMessageStatus?.(ackId, 'acked');
-        if (statusUpdate instanceof Promise) {
-            statusUpdate.catch(err => {
-                routerLog.error('Failed to record ACK status', { error: String(err) });
-            });
-        }
-        routerLog.debug(`ACK received for ${ackId}`);
+        this.deliveryTracker.handleAck(connection.id, ackId);
     }
     /**
      * Clear pending deliveries for a connection (e.g., on disconnect).
      */
     clearPendingForConnection(connectionId) {
-        for (const [id, pending] of this.pendingDeliveries.entries()) {
-            if (pending.connectionId === connectionId) {
-                if (pending.timer)
-                    clearTimeout(pending.timer);
-                this.pendingDeliveries.delete(id);
-            }
-        }
+        this.deliveryTracker.clearPendingForConnection(connectionId);
     }
     /**
      * Track a delivery and schedule retries until ACKed or TTL/attempts exhausted.
      */
     trackDelivery(target, deliver) {
-        const pending = {
-            envelope: deliver,
-            connectionId: target.id,
-            attempts: 1,
-            firstSentAt: Date.now(),
-        };
-        pending.timer = this.scheduleRetry(deliver.id);
-        this.pendingDeliveries.set(deliver.id, pending);
-    }
-    scheduleRetry(deliverId) {
-        return setTimeout(() => {
-            const pending = this.pendingDeliveries.get(deliverId);
-            if (!pending)
-                return;
-            const now = Date.now();
-            const elapsed = now - pending.firstSentAt;
-            if (elapsed > this.deliveryOptions.deliveryTtlMs) {
-                routerLog.warn(`Dropping ${deliverId} after TTL`, { ttlMs: this.deliveryOptions.deliveryTtlMs });
-                this.pendingDeliveries.delete(deliverId);
-                // Mark message as failed in storage
-                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
-                if (statusUpdate instanceof Promise) {
-                    statusUpdate.catch(err => {
-                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
-                    });
-                }
-                return;
-            }
-            if (pending.attempts >= this.deliveryOptions.maxAttempts) {
-                routerLog.warn(`Dropping ${deliverId} after max attempts`, { maxAttempts: this.deliveryOptions.maxAttempts });
-                this.pendingDeliveries.delete(deliverId);
-                // Mark message as failed in storage
-                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
-                if (statusUpdate instanceof Promise) {
-                    statusUpdate.catch(err => {
-                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
-                    });
-                }
-                return;
-            }
-            const target = this.connections.get(pending.connectionId);
-            if (!target) {
-                routerLog.warn(`Dropping ${deliverId} - connection unavailable`);
-                this.pendingDeliveries.delete(deliverId);
-                // Mark message as failed in storage
-                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
-                if (statusUpdate instanceof Promise) {
-                    statusUpdate.catch(err => {
-                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
-                    });
-                }
-                return;
-            }
-            pending.attempts++;
-            const sent = target.send(pending.envelope);
-            if (!sent) {
-                routerLog.warn(`Retry failed for ${deliverId}`, { attempt: pending.attempts });
-            }
-            else {
-                routerLog.debug(`Retried ${deliverId}`, { attempt: pending.attempts });
-            }
-            pending.timer = this.scheduleRetry(deliverId);
-        }, this.deliveryOptions.ackTimeoutMs);
+        this.deliveryTracker.track(target, deliver);
     }
     /**
      * Broadcast a system message to all connected agents.
@@ -686,7 +630,7 @@ export class Router {
         const envelope = {
             v: PROTOCOL_VERSION,
             type: 'SEND',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             from: '_system',
             to: '*',
@@ -776,7 +720,7 @@ export class Router {
                 const joinNotification = {
                     v: PROTOCOL_VERSION,
                     type: 'CHANNEL_JOIN',
-                    id: uuid(),
+                    id: generateId(),
                     ts: Date.now(),
                     from: memberName,
                     payload: envelope.payload,
@@ -828,7 +772,7 @@ export class Router {
                 const leaveNotification = {
                     v: PROTOCOL_VERSION,
                     type: 'CHANNEL_LEAVE',
-                    id: uuid(),
+                    id: generateId(),
                     ts: Date.now(),
                     from: memberName,
                     payload: envelope.payload,
@@ -871,7 +815,7 @@ export class Router {
                 const deliverEnvelope = {
                     v: PROTOCOL_VERSION,
                     type: 'CHANNEL_MESSAGE',
-                    id: uuid(),
+                    id: generateId(),
                     ts: Date.now(),
                     from: senderName,
                     payload: envelope.payload,

package/dist/daemon/server.d.ts

@@ -5,6 +5,7 @@
 import { type ConnectionConfig } from './connection.js';
 import { type StorageAdapter, type StorageConfig } from '../storage/adapter.js';
 import { type RemoteAgent } from './cloud-sync.js';
+import { ConsensusIntegration, type ConsensusIntegrationConfig } from './consensus-integration.js';
 export interface DaemonConfig extends ConnectionConfig {
     socketPath: string;
     pidFilePath: string;
@@ -16,8 +17,10 @@ export interface DaemonConfig extends ConnectionConfig {
     teamDir?: string;
     /** Enable cloud sync for cross-machine agent communication */
     cloudSync?: boolean;
-    /** Cloud API URL (defaults to https://api.agent-relay.com) */
+    /** Cloud API URL (defaults to https://agent-relay.com) */
     cloudUrl?: string;
+    /** Consensus mechanism for multi-agent decisions (enabled by default, set to false to disable) */
+    consensus?: boolean | Partial<ConsensusIntegrationConfig>;
 }
 export declare const DEFAULT_SOCKET_PATH = "/tmp/agent-relay.sock";
 export declare const DEFAULT_DAEMON_CONFIG: DaemonConfig;
@@ -33,6 +36,7 @@ export declare class Daemon {
     private processingStateInterval?;
     private cloudSync?;
     private remoteAgents;
+    private consensus?;
     /** Callback for log output from agents (used by dashboard for streaming) */
     onLogOutput?: (agentName: string, data: string, timestamp: number) => void;
     /** Interval for writing processing state file (500ms for responsive UI) */
@@ -112,5 +116,13 @@ export declare class Daemon {
      * Check if daemon is running.
      */
     get isRunning(): boolean;
+    /**
+     * Check if consensus is enabled.
+     */
+    get consensusEnabled(): boolean;
+    /**
+     * Get the consensus integration (for API access).
+     */
+    getConsensus(): ConsensusIntegration | undefined;
 }
 //# sourceMappingURL=server.d.ts.map

package/dist/daemon/server.js

@@ -14,7 +14,8 @@ import { getProjectPaths } from '../utils/project-namespace.js';
 import { AgentRegistry } from './agent-registry.js';
 import { daemonLog as log } from '../utils/logger.js';
 import { getCloudSync } from './cloud-sync.js';
-import { v4 as uuid } from 'uuid';
+import { generateId } from '../utils/id-generator.js';
+import { createConsensusIntegration, } from './consensus-integration.js';
 export const DEFAULT_SOCKET_PATH = '/tmp/agent-relay.sock';
 export const DEFAULT_DAEMON_CONFIG = {
     ...DEFAULT_CONFIG,
@@ -33,6 +34,7 @@ export class Daemon {
     processingStateInterval;
     cloudSync;
     remoteAgents = [];
+    consensus;
     /** Callback for log output from agents (used by dashboard for streaming) */
     onLogOutput;
     /** Interval for writing processing state file (500ms for responsive UI) */
@@ -115,6 +117,14 @@ export class Daemon {
                 isRemoteAgent: this.isRemoteAgent.bind(this),
             },
         });
+        // Initialize consensus (enabled by default, can be disabled with consensus: false)
+        if (this.config.consensus !== false) {
+            const consensusConfig = typeof this.config.consensus === 'object'
+                ? this.config.consensus
+                : {};
+            this.consensus = createConsensusIntegration(this.router, consensusConfig);
+            log.info('Consensus mechanism enabled');
+        }
         this.storageInitialized = true;
     }
     /**
@@ -160,20 +170,41 @@ export class Daemon {
      * Initialize cloud sync service for cross-machine agent communication.
      */
     async initCloudSync() {
-        // Check for cloud config file
+        // Check for cloud config file OR environment variables
         const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
             path.join(os.homedir(), '.local', 'share', 'agent-relay');
         const configPath = path.join(dataDir, 'cloud-config.json');
-        if (!fs.existsSync(configPath)) {
+        const hasConfigFile = fs.existsSync(configPath);
+        const hasEnvApiKey = !!process.env.AGENT_RELAY_API_KEY;
+        // Allow cloud sync if config file exists OR API key is set via env var
+        // This enables cloud-hosted workspaces (Fly.io) to sync messages without a config file
+        if (!hasConfigFile && !hasEnvApiKey) {
             log.info('Cloud sync disabled (not linked to cloud)');
             return;
         }
         try {
-            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            let apiKey;
+            let cloudUrl;
+            if (hasConfigFile) {
+                // Use config file (local daemons linked via CLI)
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                apiKey = config.apiKey;
+                cloudUrl = config.cloudUrl;
+            }
+            else {
+                // Use env vars (cloud-hosted workspaces like Fly.io)
+                apiKey = process.env.AGENT_RELAY_API_KEY;
+                // CLOUD_API_URL is set by Fly.io provisioner, AGENT_RELAY_CLOUD_URL is the standard
+                cloudUrl = process.env.AGENT_RELAY_CLOUD_URL || process.env.CLOUD_API_URL;
+                log.info('Using environment variables for cloud sync', { hasApiKey: !!apiKey, hasCloudUrl: !!cloudUrl });
+            }
+            // Get project root for workspace detection via git remote
+            const projectPaths = getProjectPaths();
             this.cloudSync = getCloudSync({
-                apiKey: config.apiKey,
-                cloudUrl: config.cloudUrl || this.config.cloudUrl,
+                apiKey,
+                cloudUrl: cloudUrl || this.config.cloudUrl,
                 enabled: this.config.cloudSync !== false,
+                projectDirectory: projectPaths.projectRoot,
             });
             // Listen for remote agent updates
             this.cloudSync.on('remote-agents-updated', (agents) => {
@@ -191,6 +222,10 @@ export class Daemon {
                 // Handle commands like credential updates, config changes, etc.
             });
             await this.cloudSync.start();
+            // Set storage adapter for message sync to cloud
+            if (this.storage) {
+                this.cloudSync.setStorage(this.storage);
+            }
             log.info('Cloud sync enabled');
         }
         catch (err) {
@@ -233,7 +268,7 @@ export class Daemon {
         const envelope = {
             v: 1,
             type: 'SEND',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             from: `${msg.from.daemonName}:${msg.from.agent}`,
             to: msg.to,
@@ -461,9 +496,24 @@ export class Daemon {
      */
     handleMessage(connection, envelope) {
         switch (envelope.type) {
-            case 'SEND':
-                this.router.route(connection, envelope);
+            case 'SEND': {
+                const sendEnvelope = envelope;
+                // Check for consensus commands (messages to _consensus)
+                if (this.consensus?.enabled && sendEnvelope.to === '_consensus') {
+                    const from = connection.agentName ?? 'unknown';
+                    const result = this.consensus.processIncomingMessage(from, sendEnvelope.payload.body);
+                    if (result.isConsensusCommand) {
+                        log.info(`Consensus ${result.type} from ${from}`, {
+                            success: result.result?.success,
+                            proposalId: result.result?.proposal?.id,
+                        });
+                        // Don't route consensus commands to the router
+                        return;
+                    }
+                }
+                this.router.route(connection, sendEnvelope);
                 break;
+            }
             case 'SUBSCRIBE':
                 if (connection.agentName && envelope.topic) {
                     this.router.subscribe(connection.agentName, envelope.topic);
@@ -532,6 +582,18 @@ export class Daemon {
     get isRunning() {
         return this.running;
     }
+    /**
+     * Check if consensus is enabled.
+     */
+    get consensusEnabled() {
+        return this.consensus?.enabled ?? false;
+    }
+    /**
+     * Get the consensus integration (for API access).
+     */
+    getConsensus() {
+        return this.consensus;
+    }
 }
 // Run as standalone if executed directly
 const isMainModule = import.meta.url === `file://${process.argv[1]}`;

package/dist/daemon/sync-queue.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Optimized Cloud Sync Queue
+ *
+ * Handles batched, compressed, resilient message syncing to cloud.
+ * Features:
+ * - Adaptive batching (size/time/bytes triggers)
+ * - Gzip compression for payloads over threshold
+ * - Disk spillover for offline resilience
+ * - Retry with exponential backoff
+ * - Startup reconciliation
+ */
+import type { StoredMessage } from '../storage/adapter.js';
+export interface SyncQueueConfig {
+    /** Cloud API URL */
+    cloudUrl: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Maximum messages per batch (default: 100) */
+    batchSize: number;
+    /** Maximum time to wait before flush in ms (default: 200) */
+    batchDelayMs: number;
+    /** Maximum bytes in memory before flush (default: 512KB) */
+    maxBatchBytes: number;
+    /** Compress payloads larger than this (default: 1KB) */
+    compressionThreshold: number;
+    /** Directory for spill files (default: /tmp/agent-relay-sync) */
+    spillDir: string;
+    /** Maximum spill files to keep (default: 100) */
+    maxSpillFiles: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries: number;
+    /** Base retry delay in ms (default: 1000) */
+    retryDelayMs: number;
+    /** Log sync operations (default: false) */
+    verbose: boolean;
+}
+export declare const DEFAULT_SYNC_QUEUE_CONFIG: SyncQueueConfig;
+export interface SyncResult {
+    synced: number;
+    duplicates: number;
+    failed: number;
+    compressed: boolean;
+    bytesTransferred: number;
+}
+export interface SyncQueueStats {
+    queuedMessages: number;
+    queuedBytes: number;
+    totalSynced: number;
+    totalFailed: number;
+    totalCompressed: number;
+    totalBytesTransferred: number;
+    spilledFiles: number;
+    lastSyncAt?: number;
+    lastError?: string;
+}
+export declare class SyncQueue {
+    private config;
+    private queue;
+    private queueBytes;
+    private flushTimer?;
+    private flushing;
+    private flushPromise?;
+    private stats;
+    constructor(config: Partial<SyncQueueConfig>);
+    /**
+     * Queue a message for sync to cloud.
+     * May trigger an immediate flush if thresholds are exceeded.
+     */
+    enqueue(message: StoredMessage): Promise<void>;
+    /**
+     * Enqueue multiple messages at once.
+     */
+    enqueueBatch(messages: StoredMessage[]): Promise<void>;
+    /**
+     * Flush all queued messages to cloud.
+     */
+    flush(): Promise<SyncResult>;
+    /**
+     * Sync a batch of messages to cloud with retry and spillover.
+     */
+    private syncBatch;
+    /**
+     * Send messages to cloud API with optional compression.
+     */
+    private sendToCloud;
+    /**
+     * Spill failed batch to disk for later recovery.
+     */
+    private spillToDisk;
+    /**
+     * Recover and sync messages from spill files.
+     * Call this on startup to resume failed syncs.
+     */
+    recoverSpilledMessages(): Promise<{
+        recovered: number;
+        failed: number;
+    }>;
+    /**
+     * Cleanup old spill files beyond the limit.
+     */
+    private cleanupSpillFiles;
+    /**
+     * Get sync queue statistics.
+     */
+    getStats(): SyncQueueStats;
+    /**
+     * Reset statistics (for testing or periodic reporting).
+     */
+    resetStats(): void;
+    /**
+     * Gracefully close the queue, flushing any pending messages.
+     */
+    close(): Promise<void>;
+    private sleep;
+}
+//# sourceMappingURL=sync-queue.d.ts.map