agent-relay 1.6.0 → 2.0.4

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

@@ -1,150 +0,0 @@
-/**
- * Cloud Sync Service
- *
- * Handles automatic bridging between local daemons via the cloud:
- * - Heartbeat to report status
- * - Agent discovery across machines
- * - Cross-machine message relay
- * - Credential sync from cloud
- */
-import { EventEmitter } from 'events';
-import type { StorageAdapter, StoredMessage } from '../storage/adapter.js';
-import { type SyncQueueConfig, type SyncQueueStats } from './sync-queue.js';
-export interface CloudSyncConfig {
-    apiKey?: string;
-    cloudUrl: string;
-    heartbeatInterval: number;
-    enabled: boolean;
-    /** Enable message sync to cloud (default: true if connected) */
-    messageSyncEnabled?: boolean;
-    /** Batch size for message sync (default: 100) */
-    messageSyncBatchSize?: number;
-    /** Use optimized sync queue with compression and spillover (default: true) */
-    useOptimizedSync?: boolean;
-    /** Sync queue configuration */
-    syncQueue?: Partial<SyncQueueConfig>;
-    /** Project directory for git remote detection (defaults to cwd) */
-    projectDirectory?: string;
-}
-export interface RemoteAgent {
-    name: string;
-    status: string;
-    daemonId: string;
-    daemonName: string;
-    machineId: string;
-}
-export interface CrossMachineMessage {
-    from: {
-        daemonId: string;
-        daemonName: string;
-        agent: string;
-    };
-    to: string;
-    content: string;
-    metadata?: Record<string, unknown>;
-    timestamp: string;
-}
-export declare class CloudSyncService extends EventEmitter {
-    private config;
-    private heartbeatTimer?;
-    private machineId;
-    private localAgents;
-    private remoteAgents;
-    private remoteUsers;
-    private connected;
-    private storage;
-    private lastMessageSyncTs;
-    private messageSyncInProgress;
-    private projectDirectory;
-    private repoFullName;
-    private syncQueue;
-    constructor(config?: Partial<CloudSyncConfig>);
-    /**
-     * Get or create a persistent machine ID
-     */
-    private getMachineId;
-    /**
-     * Start the cloud sync service
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the cloud sync service
-     */
-    stop(): Promise<void>;
-    /**
-     * Update local agent list (called by daemon when agents change)
-     */
-    updateAgents(agents: Array<{
-        name: string;
-        status: string;
-        isHuman?: boolean;
-        avatarUrl?: string;
-    }>): void;
-    /**
-     * Get all remote agents (from other machines)
-     */
-    getRemoteAgents(): RemoteAgent[];
-    /**
-     * Send a message to an agent on another machine
-     */
-    sendCrossMachineMessage(targetDaemonId: string, targetAgent: string, fromAgent: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
-    /**
-     * Send heartbeat to cloud
-     */
-    private sendHeartbeat;
-    /**
-     * Sync agents with cloud and get remote agents
-     */
-    private syncAgents;
-    /**
-     * Fetch queued messages from cloud
-     */
-    private fetchMessages;
-    /**
-     * Sync credentials from cloud (pull latest tokens)
-     */
-    syncCredentials(): Promise<Array<{
-        provider: string;
-        accessToken: string;
-        tokenType?: string;
-        expiresAt?: string;
-    }>>;
-    /**
-     * Check if connected to cloud
-     */
-    isConnected(): boolean;
-    /**
-     * Get machine ID
-     */
-    getMachineIdentifier(): string;
-    /**
-     * Set the storage adapter for message sync
-     */
-    setStorage(storage: StorageAdapter): void;
-    /**
-     * Queue a single message for sync to cloud.
-     * Use this for real-time sync as messages are created.
-     * Falls back to batch sync if optimized queue is not enabled.
-     */
-    queueMessageForSync(message: StoredMessage): Promise<void>;
-    /**
-     * Get sync queue statistics (if optimized sync is enabled).
-     */
-    getSyncQueueStats(): SyncQueueStats | null;
-    /**
-     * Force flush the sync queue.
-     */
-    flushSyncQueue(): Promise<void>;
-    /**
-     * Sync local messages to cloud storage
-     *
-     * Reads messages from local SQLite since last sync and posts them
-     * to the cloud API for centralized storage and search.
-     */
-    syncMessagesToCloud(): Promise<{
-        synced: number;
-        duplicates: number;
-    }>;
-}
-export declare function getCloudSync(config?: Partial<CloudSyncConfig>): CloudSyncService;
-//# sourceMappingURL=cloud-sync.d.ts.map

package/dist/daemon/cloud-sync.js

@@ -1,424 +0,0 @@
-/**
- * Cloud Sync Service
- *
- * Handles automatic bridging between local daemons via the cloud:
- * - Heartbeat to report status
- * - Agent discovery across machines
- * - Cross-machine message relay
- * - Credential sync from cloud
- */
-import { EventEmitter } from 'events';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { randomBytes } from 'crypto';
-import { createLogger } from '../utils/logger.js';
-import { SyncQueue } from './sync-queue.js';
-import { getRepoFullNameFromPath } from '../utils/git-remote.js';
-const log = createLogger('cloud-sync');
-export class CloudSyncService extends EventEmitter {
-    config;
-    heartbeatTimer;
-    machineId;
-    localAgents = new Map();
-    remoteAgents = [];
-    remoteUsers = [];
-    connected = false;
-    storage = null;
-    lastMessageSyncTs = 0;
-    messageSyncInProgress = false;
-    // Project context for workspace resolution
-    projectDirectory;
-    repoFullName = null;
-    // Optimized sync queue
-    syncQueue = null;
-    constructor(config = {}) {
-        super();
-        this.config = {
-            apiKey: config.apiKey || process.env.AGENT_RELAY_API_KEY,
-            cloudUrl: config.cloudUrl || process.env.AGENT_RELAY_CLOUD_URL || 'https://agent-relay.com',
-            heartbeatInterval: config.heartbeatInterval || 30000, // 30 seconds
-            enabled: config.enabled ?? true,
-            useOptimizedSync: config.useOptimizedSync ?? true,
-            syncQueue: config.syncQueue,
-            projectDirectory: config.projectDirectory,
-        };
-        // Generate or load machine ID for consistent identification
-        this.machineId = this.getMachineId();
-        // Initialize project context for workspace resolution
-        this.projectDirectory = this.config.projectDirectory || process.cwd();
-        this.repoFullName = getRepoFullNameFromPath(this.projectDirectory);
-        if (this.repoFullName) {
-            log.info('Detected git repository', { repoFullName: this.repoFullName });
-        }
-        // Initialize optimized sync queue if enabled and API key is available
-        if (this.config.useOptimizedSync && this.config.apiKey) {
-            this.syncQueue = new SyncQueue({
-                cloudUrl: this.config.cloudUrl,
-                apiKey: this.config.apiKey,
-                ...this.config.syncQueue,
-            });
-        }
-    }
-    /**
-     * Get or create a persistent machine ID
-     */
-    getMachineId() {
-        const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
-            path.join(os.homedir(), '.local', 'share', 'agent-relay');
-        const machineIdPath = path.join(dataDir, 'machine-id');
-        try {
-            if (fs.existsSync(machineIdPath)) {
-                return fs.readFileSync(machineIdPath, 'utf-8').trim();
-            }
-            // Generate new machine ID
-            const machineId = `${os.hostname()}-${randomBytes(8).toString('hex')}`;
-            fs.mkdirSync(dataDir, { recursive: true });
-            fs.writeFileSync(machineIdPath, machineId);
-            return machineId;
-        }
-        catch {
-            // Fallback: generate ephemeral ID
-            return `${os.hostname()}-${Date.now().toString(36)}`;
-        }
-    }
-    /**
-     * Start the cloud sync service
-     */
-    async start() {
-        if (!this.config.enabled || !this.config.apiKey) {
-            log.info('Disabled (no API key configured)');
-            log.info('Run `agent-relay cloud link` to connect to cloud');
-            return;
-        }
-        log.info('Starting cloud sync', { url: this.config.cloudUrl });
-        // Recover any spilled messages from previous runs
-        if (this.syncQueue) {
-            const { recovered, failed } = await this.syncQueue.recoverSpilledMessages();
-            if (recovered > 0 || failed > 0) {
-                log.info('Recovered spilled messages', { recovered, failed });
-            }
-        }
-        // Initial heartbeat
-        await this.sendHeartbeat();
-        // Start periodic heartbeat
-        this.heartbeatTimer = setInterval(() => this.sendHeartbeat().catch((err) => log.error('Heartbeat failed', { error: String(err) })), this.config.heartbeatInterval);
-        this.connected = true;
-        this.emit('connected');
-    }
-    /**
-     * Stop the cloud sync service
-     */
-    async stop() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = undefined;
-        }
-        // Gracefully close sync queue (flushes pending messages)
-        if (this.syncQueue) {
-            await this.syncQueue.close();
-        }
-        this.connected = false;
-        this.emit('disconnected');
-    }
-    /**
-     * Update local agent list (called by daemon when agents change)
-     */
-    updateAgents(agents) {
-        this.localAgents.clear();
-        for (const agent of agents) {
-            this.localAgents.set(agent.name, agent);
-        }
-        // Trigger immediate sync if connected
-        if (this.connected) {
-            this.syncAgents().catch((err) => log.error('Agent sync failed', { error: String(err) }));
-        }
-    }
-    /**
-     * Get all remote agents (from other machines)
-     */
-    getRemoteAgents() {
-        return this.remoteAgents;
-    }
-    /**
-     * Send a message to an agent on another machine
-     */
-    async sendCrossMachineMessage(targetDaemonId, targetAgent, fromAgent, content, metadata) {
-        if (!this.connected) {
-            throw new Error('Not connected to cloud');
-        }
-        const response = await fetch(`${this.config.cloudUrl}/api/daemons/message`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.config.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                targetDaemonId,
-                targetAgent,
-                message: {
-                    from: fromAgent,
-                    content,
-                    metadata,
-                },
-            }),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to send cross-machine message: ${error}`);
-        }
-    }
-    /**
-     * Send heartbeat to cloud
-     */
-    async sendHeartbeat() {
-        try {
-            const agents = Array.from(this.localAgents.entries()).map(([name, info]) => ({
-                name,
-                status: info.status,
-                isHuman: info.isHuman,
-                avatarUrl: info.avatarUrl,
-            }));
-            const response = await fetch(`${this.config.cloudUrl}/api/daemons/heartbeat`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    agents,
-                    metrics: {
-                        uptime: process.uptime(),
-                        memoryUsage: process.memoryUsage(),
-                    },
-                }),
-            });
-            if (!response.ok) {
-                if (response.status === 401) {
-                    log.error('Invalid API key. Run `agent-relay cloud link` to re-authenticate.');
-                    this.stop();
-                    return;
-                }
-                throw new Error(`Heartbeat failed: ${response.status}`);
-            }
-            const data = await response.json();
-            // Process any pending commands from cloud
-            if (data.commands && data.commands.length > 0) {
-                for (const cmd of data.commands) {
-                    this.emit('command', cmd);
-                }
-            }
-            // Fetch messages, sync agents, and sync local messages to cloud
-            await Promise.all([
-                this.fetchMessages(),
-                this.syncAgents(),
-                this.syncMessagesToCloud(),
-            ]);
-        }
-        catch (error) {
-            log.error('Heartbeat error', { error: String(error) });
-            this.emit('error', error);
-        }
-    }
-    /**
-     * Sync agents with cloud and get remote agents
-     */
-    async syncAgents() {
-        const agents = Array.from(this.localAgents.entries()).map(([name, info]) => ({
-            name,
-            status: info.status,
-            isHuman: info.isHuman,
-            avatarUrl: info.avatarUrl,
-        }));
-        const response = await fetch(`${this.config.cloudUrl}/api/daemons/agents`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.config.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ agents }),
-        });
-        if (!response.ok) {
-            throw new Error(`Agent sync failed: ${response.status}`);
-        }
-        const data = await response.json();
-        // Filter out our own agents
-        this.remoteAgents = data.allAgents.filter((a) => !this.localAgents.has(a.name));
-        if (this.remoteAgents.length > 0) {
-            this.emit('remote-agents-updated', this.remoteAgents);
-        }
-        // Handle remote users (humans connected via cloud dashboard)
-        if (data.allUsers) {
-            this.remoteUsers = data.allUsers.filter((u) => !this.localAgents.has(u.name));
-            if (this.remoteUsers.length > 0) {
-                this.emit('remote-users-updated', this.remoteUsers);
-            }
-        }
-    }
-    /**
-     * Fetch queued messages from cloud
-     */
-    async fetchMessages() {
-        const response = await fetch(`${this.config.cloudUrl}/api/daemons/messages`, {
-            headers: {
-                Authorization: `Bearer ${this.config.apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Message fetch failed: ${response.status}`);
-        }
-        const data = await response.json();
-        for (const msg of data.messages) {
-            this.emit('cross-machine-message', msg);
-        }
-    }
-    /**
-     * Sync credentials from cloud (pull latest tokens)
-     */
-    async syncCredentials() {
-        if (!this.connected) {
-            throw new Error('Not connected to cloud');
-        }
-        const response = await fetch(`${this.config.cloudUrl}/api/daemons/credentials`, {
-            headers: {
-                Authorization: `Bearer ${this.config.apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Credential sync failed: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.credentials;
-    }
-    /**
-     * Check if connected to cloud
-     */
-    isConnected() {
-        return this.connected;
-    }
-    /**
-     * Get machine ID
-     */
-    getMachineIdentifier() {
-        return this.machineId;
-    }
-    /**
-     * Set the storage adapter for message sync
-     */
-    setStorage(storage) {
-        this.storage = storage;
-        log.info('Storage adapter configured for message sync');
-    }
-    /**
-     * Queue a single message for sync to cloud.
-     * Use this for real-time sync as messages are created.
-     * Falls back to batch sync if optimized queue is not enabled.
-     */
-    async queueMessageForSync(message) {
-        if (!this.connected || this.config.messageSyncEnabled === false) {
-            return;
-        }
-        if (this.syncQueue) {
-            await this.syncQueue.enqueue(message);
-        }
-        // If no sync queue, messages will be synced on next heartbeat via syncMessagesToCloud
-    }
-    /**
-     * Get sync queue statistics (if optimized sync is enabled).
-     */
-    getSyncQueueStats() {
-        return this.syncQueue?.getStats() ?? null;
-    }
-    /**
-     * Force flush the sync queue.
-     */
-    async flushSyncQueue() {
-        if (this.syncQueue) {
-            await this.syncQueue.flush();
-        }
-    }
-    /**
-     * Sync local messages to cloud storage
-     *
-     * Reads messages from local SQLite since last sync and posts them
-     * to the cloud API for centralized storage and search.
-     */
-    async syncMessagesToCloud() {
-        // Skip if disabled, not connected, no storage, or sync in progress
-        if (!this.connected || !this.storage || this.messageSyncInProgress) {
-            return { synced: 0, duplicates: 0 };
-        }
-        if (this.config.messageSyncEnabled === false) {
-            return { synced: 0, duplicates: 0 };
-        }
-        this.messageSyncInProgress = true;
-        try {
-            const batchSize = this.config.messageSyncBatchSize || 100;
-            // Get messages since last sync
-            const messages = await this.storage.getMessages({
-                sinceTs: this.lastMessageSyncTs > 0 ? this.lastMessageSyncTs : undefined,
-                limit: batchSize,
-                order: 'asc',
-            });
-            if (messages.length === 0) {
-                return { synced: 0, duplicates: 0 };
-            }
-            // Transform to API format
-            const syncPayload = messages.map((msg) => ({
-                id: msg.id,
-                ts: msg.ts,
-                from: msg.from,
-                to: msg.to,
-                body: msg.body,
-                kind: msg.kind,
-                topic: msg.topic,
-                thread: msg.thread,
-                is_broadcast: msg.is_broadcast,
-                is_urgent: msg.is_urgent,
-                data: msg.data,
-                payload_meta: msg.payloadMeta,
-            }));
-            // Post to cloud with repo context for workspace resolution
-            const response = await fetch(`${this.config.cloudUrl}/api/daemons/messages/sync`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    messages: syncPayload,
-                    repoFullName: this.repoFullName,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`Message sync failed: ${response.status} - ${errorText}`);
-            }
-            const result = await response.json();
-            // Update last sync timestamp to the newest message we synced
-            if (messages.length > 0) {
-                this.lastMessageSyncTs = Math.max(...messages.map((m) => m.ts));
-            }
-            if (result.synced > 0) {
-                log.info(`Synced ${result.synced} messages to cloud`, { duplicates: result.duplicates });
-            }
-            return result;
-        }
-        catch (error) {
-            log.error('Message sync error', { error: String(error) });
-            return { synced: 0, duplicates: 0 };
-        }
-        finally {
-            this.messageSyncInProgress = false;
-        }
-    }
-}
-// Singleton instance
-let _cloudSync = null;
-export function getCloudSync(config) {
-    if (!_cloudSync) {
-        _cloudSync = new CloudSyncService(config);
-    }
-    return _cloudSync;
-}
-//# sourceMappingURL=cloud-sync.js.map

package/dist/daemon/connection.d.ts

@@ -1,130 +0,0 @@
-/**
- * Connection state machine for agent connections.
- *
- * States:
- *   CONNECTING -> HANDSHAKING -> ACTIVE -> CLOSING -> CLOSED
- *                     |            |
- *                     v            v
- *                   ERROR -------> CLOSED
- */
-import net from 'node:net';
-import { type Envelope, type AckPayload, type EntityType } from '../protocol/types.js';
-export type ConnectionState = 'CONNECTING' | 'HANDSHAKING' | 'ACTIVE' | 'CLOSING' | 'CLOSED' | 'ERROR';
-export interface ConnectionConfig {
-    maxFrameBytes: number;
-    heartbeatMs: number;
-    /** Multiplier for heartbeat timeout (timeout = heartbeatMs * multiplier). Default: 6 (30s with 5s heartbeat) */
-    heartbeatTimeoutMultiplier: number;
-    /** Optional handler to validate resume tokens and provide session state */
-    resumeHandler?: (params: {
-        agent: string;
-        resumeToken: string;
-    }) => Promise<{
-        sessionId: string;
-        resumeToken?: string;
-        seedSequences?: Array<{
-            topic?: string;
-            peer: string;
-            seq: number;
-        }>;
-    } | null>;
-    /** Optional callback to check if agent is currently processing (exempts from heartbeat timeout) */
-    isProcessing?: (agentName: string) => boolean;
-    /** Maximum messages in write queue before dropping (default: 2000) */
-    maxWriteQueueSize?: number;
-    /** High water mark - emit backpressure signal when queue exceeds this (default: 1500) */
-    writeQueueHighWaterMark?: number;
-    /** Low water mark - release backpressure when queue drops below this (default: 500) */
-    writeQueueLowWaterMark?: number;
-}
-export declare const DEFAULT_CONFIG: ConnectionConfig;
-export declare class Connection {
-    readonly id: string;
-    private socket;
-    private parser;
-    private config;
-    private _state;
-    private _agentName?;
-    private _entityType?;
-    private _cli?;
-    private _program?;
-    private _model?;
-    private _task?;
-    private _workingDirectory?;
-    private _displayName?;
-    private _avatarUrl?;
-    private _sessionId;
-    private _resumeToken;
-    private _isResumed;
-    private heartbeatTimer?;
-    private lastPongReceived?;
-    private sequences;
-    private writeQueue;
-    private draining;
-    private _backpressured;
-    private socketDrainHandler?;
-    onMessage?: (envelope: Envelope) => void;
-    onClose?: () => void;
-    onError?: (error: Error) => void;
-    onActive?: () => void;
-    onAck?: (envelope: Envelope<AckPayload>) => void;
-    onPong?: () => void;
-    /** Fires when write queue crosses high/low water marks */
-    onBackpressure?: (backpressured: boolean) => void;
-    constructor(socket: net.Socket, config?: Partial<ConnectionConfig>);
-    get state(): ConnectionState;
-    get agentName(): string | undefined;
-    get entityType(): EntityType | undefined;
-    get cli(): string | undefined;
-    get program(): string | undefined;
-    get model(): string | undefined;
-    get task(): string | undefined;
-    get workingDirectory(): string | undefined;
-    get displayName(): string | undefined;
-    get avatarUrl(): string | undefined;
-    get sessionId(): string;
-    get resumeToken(): string;
-    get isResumed(): boolean;
-    /** Whether this connection is currently backpressured (write queue above high water mark) */
-    get backpressured(): boolean;
-    /** Current number of messages queued for writing */
-    get writeQueueLength(): number;
-    private setupSocketHandlers;
-    private handleData;
-    private processFrame;
-    private handleHello;
-    private handleSend;
-    private handlePong;
-    private startHeartbeat;
-    private stopHeartbeat;
-    /**
-     * Seed a sequence counter for a stream so that the next value continues from the provided seq.
-     */
-    seedSequence(topic: string | undefined, peer: string, seq: number): void;
-    /**
-     * Get next sequence number for a stream.
-     */
-    getNextSeq(topic: string, peer: string): number;
-    /**
-     * Send an envelope to this connection.
-     *
-     * Uses a write queue to prevent blocking on slow consumers.
-     * Returns false if the connection is closed or the queue is full.
-     */
-    send(envelope: Envelope): boolean;
-    /**
-     * Schedule the drain loop to run on next tick if not already running.
-     */
-    private scheduleDrain;
-    /**
-     * Drain the write queue to the socket.
-     * Respects socket backpressure by waiting for 'drain' events.
-     */
-    private drain;
-    private sendError;
-    private handleClose;
-    private handleError;
-    private cleanup;
-    close(): void;
-}
-//# sourceMappingURL=connection.d.ts.map