agent-relay 1.3.2 → 1.5.0

package/dist/daemon/router.js

@@ -6,9 +6,11 @@ import { generateId } from '../utils/id-generator.js';
 import { PROTOCOL_VERSION, } from '../protocol/types.js';
 import { routerLog } from '../utils/logger.js';
 import { RateLimiter, NoOpRateLimiter } from './rate-limiter.js';
+import * as crypto from 'node:crypto';
 import { DeliveryTracker, } from './delivery-tracker.js';
 export class Router {
     storage;
+    channelMembershipStore;
     connections = new Map(); // connectionId -> Connection
     agents = new Map(); // agentName -> Connection
     subscriptions = new Map(); // topic -> Set<agentName>
@@ -34,6 +36,7 @@ export class Router {
     rateLimiter;
     constructor(options = {}) {
         this.storage = options.storage;
+        this.channelMembershipStore = options.channelMembershipStore;
         this.registry = options.registry;
         this.onProcessingStateChange = options.onProcessingStateChange;
         this.crossMachineHandler = options.crossMachineHandler;
@@ -47,6 +50,45 @@ export class Router {
             ? new NoOpRateLimiter()
             : new RateLimiter(options.rateLimit);
     }
+    /**
+     * Restore channel memberships from persisted storage.
+     */
+    async restoreChannelMemberships() {
+        if (!this.storage && !this.channelMembershipStore)
+            return;
+        try {
+            if (this.channelMembershipStore) {
+                const memberships = await this.channelMembershipStore.loadMemberships();
+                for (const membership of memberships) {
+                    this.handleMembershipUpdate({
+                        channel: membership.channel,
+                        member: membership.member,
+                        action: 'join',
+                    });
+                }
+            }
+            if (this.storage) {
+                const messages = await this.storage.getMessages({ order: 'asc' });
+                for (const msg of messages) {
+                    const channel = msg.to;
+                    const data = msg.data;
+                    const membership = data?._channelMembership;
+                    if (!channel || !membership?.member) {
+                        continue;
+                    }
+                    const action = membership.action ?? 'join';
+                    this.handleMembershipUpdate({
+                        channel,
+                        member: membership.member,
+                        action,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            routerLog.error('Failed to restore channel memberships', { error: String(err) });
+        }
+    }
     /**
      * Set or update the cross-machine handler.
      */
@@ -96,28 +138,36 @@ export class Router {
         this.connections.delete(connection.id);
         if (connection.agentName) {
             const isUser = connection.entityType === 'user';
+            let wasCurrentConnection = false;
             if (isUser) {
                 const currentUser = this.users.get(connection.agentName);
                 if (currentUser?.id === connection.id) {
                     this.users.delete(connection.agentName);
+                    wasCurrentConnection = true;
                 }
             }
             else {
                 const current = this.agents.get(connection.agentName);
                 if (current?.id === connection.id) {
                     this.agents.delete(connection.agentName);
+                    wasCurrentConnection = true;
                 }
             }
-            // Remove from all subscriptions
-            for (const subscribers of this.subscriptions.values()) {
-                subscribers.delete(connection.agentName);
+            // Only clean up channel/subscription state if this was the current connection.
+            // If a new connection replaced this one, we don't want to remove channel memberships
+            // that the new connection should inherit.
+            if (wasCurrentConnection) {
+                // Remove from all subscriptions
+                for (const subscribers of this.subscriptions.values()) {
+                    subscribers.delete(connection.agentName);
+                }
+                // Remove from all channels and notify remaining members
+                this.removeFromAllChannels(connection.agentName);
+                // Clean up shadow relationships
+                this.unbindShadow(connection.agentName);
+                // Clear processing state
+                this.clearProcessing(connection.agentName);
             }
-            // Remove from all channels and notify remaining members
-            this.removeFromAllChannels(connection.agentName);
-            // Clean up shadow relationships
-            this.unbindShadow(connection.agentName);
-            // Clear processing state
-            this.clearProcessing(connection.agentName);
         }
         this.clearPendingForConnection(connection.id);
     }
@@ -303,7 +353,7 @@ export class Router {
         this.registry?.recordSend(senderName);
         const to = envelope.to;
         const topic = envelope.topic;
-        routerLog.debug(`${senderName} -> ${to}`, { preview: envelope.payload.body?.substring(0, 50) });
+        routerLog.info(`Route ${senderName} -> ${to}`, { preview: envelope.payload.body?.substring(0, 50) });
         if (to === '*') {
             // Broadcast to all (except sender)
             this.broadcast(senderName, envelope, topic);
@@ -382,7 +432,7 @@ export class Router {
         }
         const deliver = this.createDeliverEnvelope(from, to, envelope, target);
         const sent = target.send(deliver);
-        routerLog.debug(`Delivered to ${to}`, { success: sent });
+        routerLog.info(`Delivered ${from} -> ${to}`, { success: sent, preview: envelope.payload.body?.substring(0, 40) });
         this.persistDeliverEnvelope(deliver);
         if (sent) {
             this.trackDelivery(target, deliver);
@@ -694,14 +744,18 @@ export class Router {
     /**
      * Handle a CHANNEL_JOIN message.
      * Adds the member to the channel and notifies existing members.
+     * If payload.member is set, adds that member (admin mode).
+     * Otherwise, adds the connection's agent name.
      */
     handleChannelJoin(connection, envelope) {
-        const memberName = connection.agentName;
+        // Use payload.member if provided (admin mode), otherwise use connection's name
+        const memberName = envelope.payload.member ?? connection.agentName;
         if (!memberName) {
-            routerLog.warn('CHANNEL_JOIN from connection without name');
+            routerLog.warn('CHANNEL_JOIN from connection without name and no member specified');
             return;
         }
         const channel = envelope.payload.channel;
+        const isAdminJoin = Boolean(envelope.payload.member);
         // Get or create channel
         let members = this.channels.get(channel);
         if (!members) {
@@ -713,79 +767,78 @@ export class Router {
             routerLog.debug(`${memberName} already in ${channel}`);
             return;
         }
-        // Notify existing members about the new joiner
-        for (const existingMember of members) {
-            const memberConn = this.getConnectionByName(existingMember);
-            if (memberConn) {
-                const joinNotification = {
-                    v: PROTOCOL_VERSION,
-                    type: 'CHANNEL_JOIN',
-                    id: generateId(),
-                    ts: Date.now(),
-                    from: memberName,
-                    payload: envelope.payload,
-                };
-                memberConn.send(joinNotification);
+        // Only notify existing members for non-admin joins (agents joining themselves)
+        // Admin joins are silent to avoid spamming notifications when syncing
+        if (!isAdminJoin) {
+            const existingMembers = members ? Array.from(members) : [];
+            for (const existingMember of existingMembers) {
+                const memberConn = this.getConnectionByName(existingMember);
+                if (memberConn) {
+                    const joinNotification = {
+                        v: PROTOCOL_VERSION,
+                        type: 'CHANNEL_JOIN',
+                        id: generateId(),
+                        ts: Date.now(),
+                        from: memberName,
+                        payload: envelope.payload,
+                    };
+                    memberConn.send(joinNotification);
+                }
             }
         }
-        // Add the new member
-        members.add(memberName);
-        // Track which channels this member is in
-        let memberChannelSet = this.memberChannels.get(memberName);
-        if (!memberChannelSet) {
-            memberChannelSet = new Set();
-            this.memberChannels.set(memberName, memberChannelSet);
+        const added = this.addChannelMember(channel, memberName, { persist: true });
+        if (!added) {
+            routerLog.debug(`${memberName} already in ${channel}`);
+            return;
         }
-        memberChannelSet.add(channel);
-        routerLog.info(`${memberName} joined ${channel} (${members.size} members)`);
+        routerLog.info(`${memberName} joined ${channel} (${this.channels.get(channel)?.size ?? 0} members)${isAdminJoin ? ' [admin]' : ''}`);
     }
     /**
      * Handle a CHANNEL_LEAVE message.
      * Removes the member from the channel and notifies remaining members.
+     * If payload.member is provided, removes that member instead (admin mode).
      */
     handleChannelLeave(connection, envelope) {
-        const memberName = connection.agentName;
+        // Use payload.member if provided (admin mode), otherwise use connection's name
+        const memberName = envelope.payload.member ?? connection.agentName;
         if (!memberName) {
-            routerLog.warn('CHANNEL_LEAVE from connection without name');
+            routerLog.warn('CHANNEL_LEAVE from connection without name and no member specified');
             return;
         }
         const channel = envelope.payload.channel;
+        const isAdminRemove = Boolean(envelope.payload.member);
         const members = this.channels.get(channel);
         if (!members || !members.has(memberName)) {
             routerLog.debug(`${memberName} not in ${channel}, ignoring leave`);
             return;
         }
-        // Remove from channel
-        members.delete(memberName);
-        // Remove from member's channel list
-        const memberChannelSet = this.memberChannels.get(memberName);
-        if (memberChannelSet) {
-            memberChannelSet.delete(channel);
-            if (memberChannelSet.size === 0) {
-                this.memberChannels.delete(memberName);
-            }
+        const removed = this.removeChannelMember(channel, memberName, { persist: true });
+        if (!removed) {
+            routerLog.debug(`${memberName} not in ${channel}, ignoring leave`);
+            return;
         }
-        // Notify remaining members
-        for (const remainingMember of members) {
-            const memberConn = this.getConnectionByName(remainingMember);
-            if (memberConn) {
-                const leaveNotification = {
-                    v: PROTOCOL_VERSION,
-                    type: 'CHANNEL_LEAVE',
-                    id: generateId(),
-                    ts: Date.now(),
-                    from: memberName,
-                    payload: envelope.payload,
-                };
-                memberConn.send(leaveNotification);
+        // Only notify remaining members for non-admin removes
+        // Admin removes are silent to avoid spamming notifications
+        if (!isAdminRemove) {
+            const remainingMembers = this.channels.get(channel);
+            if (remainingMembers) {
+                for (const remainingMember of remainingMembers) {
+                    const memberConn = this.getConnectionByName(remainingMember);
+                    if (memberConn) {
+                        const leaveNotification = {
+                            v: PROTOCOL_VERSION,
+                            type: 'CHANNEL_LEAVE',
+                            id: generateId(),
+                            ts: Date.now(),
+                            from: memberName,
+                            payload: envelope.payload,
+                        };
+                        memberConn.send(leaveNotification);
+                    }
+                }
             }
         }
-        // Clean up empty channels
-        if (members.size === 0) {
-            this.channels.delete(channel);
-            routerLog.debug(`Channel ${channel} deleted (empty)`);
-        }
-        routerLog.info(`${memberName} left ${channel}`);
+        routerLog.info(`${memberName} left ${channel}${isAdminRemove ? ' [admin]' : ''}`);
     }
     /**
      * Route a channel message to all members except the sender.
@@ -798,18 +851,33 @@ export class Router {
         }
         const channel = envelope.payload.channel;
         const members = this.channels.get(channel);
+        routerLog.info(`routeChannelMessage: channel=${channel} sender=${senderName} members=${members ? Array.from(members).join(',') : 'NONE'}`);
         if (!members) {
-            routerLog.warn(`Message to non-existent channel ${channel}`);
+            routerLog.warn(`Message to non-existent channel ${channel} (available channels: ${Array.from(this.channels.keys()).join(', ')})`);
             return;
         }
-        if (!members.has(senderName)) {
-            routerLog.warn(`${senderName} not a member of ${channel}`);
+        // Case-insensitive membership check
+        const senderMemberName = this.findMemberInSet(members, senderName);
+        if (!senderMemberName) {
+            routerLog.warn(`${senderName} not a member of ${channel} (members: ${Array.from(members).join(', ')})`);
             return;
         }
-        // Route to all members except sender
+        // Route to all members except the sender (no echo)
+        const allMembers = Array.from(members);
+        routerLog.info(`Routing channel message from ${senderName} to ${channel}`, {
+            totalMembers: allMembers.length,
+            members: allMembers,
+        });
+        let deliveredCount = 0;
+        const undeliveredMembers = [];
+        const connectedAgents = Array.from(this.agents.keys());
+        const connectedUsers = Array.from(this.users.keys());
+        routerLog.info(`Connected entities: agents=[${connectedAgents.join(',')}] users=[${connectedUsers.join(',')}]`);
         for (const memberName of members) {
-            if (memberName === senderName)
+            // Case-insensitive comparison to skip sender
+            if (this.namesMatch(memberName, senderName)) {
                 continue;
+            }
             const memberConn = this.getConnectionByName(memberName);
             if (memberConn) {
                 const deliverEnvelope = {
@@ -820,12 +888,29 @@ export class Router {
                     from: senderName,
                     payload: envelope.payload,
                 };
-                memberConn.send(deliverEnvelope);
+                const sent = memberConn.send(deliverEnvelope);
+                if (sent) {
+                    deliveredCount++;
+                    routerLog.info(`Delivered to ${memberName} (${memberConn.entityType || 'agent'})`);
+                }
+                else {
+                    routerLog.warn(`Failed to send to ${memberName}`);
+                    undeliveredMembers.push(memberName);
+                }
+            }
+            else {
+                routerLog.warn(`Member ${memberName} is registered in channel but NOT connected to daemon - message not delivered`);
+                undeliveredMembers.push(memberName);
             }
         }
         // Persist channel message
         this.persistChannelMessage(envelope, senderName);
-        routerLog.debug(`${senderName} -> ${channel}: ${envelope.payload.body.substring(0, 50)}`);
+        const recipientCount = allMembers.length - 1; // Exclude sender
+        routerLog.info(`${senderName} -> ${channel}: delivered to ${deliveredCount}/${recipientCount} members`);
+        // Log warning if some members didn't receive the message
+        if (undeliveredMembers.length > 0) {
+            routerLog.warn(`Channel message undelivered to: [${undeliveredMembers.join(', ')}] - these agents may need to reconnect to the relay daemon`);
+        }
     }
     /**
      * Persist a channel message to storage.
@@ -833,6 +918,12 @@ export class Router {
     persistChannelMessage(envelope, from) {
         if (!this.storage)
             return;
+        const payloadData = {
+            ...envelope.payload.data,
+            _isChannelMessage: true,
+            _channel: envelope.payload.channel,
+            _mentions: envelope.payload.mentions,
+        };
         this.storage.saveMessage({
             id: envelope.id,
             ts: envelope.ts,
@@ -841,12 +932,7 @@ export class Router {
             topic: undefined,
             kind: 'message',
             body: envelope.payload.body,
-            data: {
-                ...envelope.payload.data,
-                _isChannelMessage: true,
-                _channel: envelope.payload.channel,
-                _mentions: envelope.payload.mentions,
-            },
+            data: payloadData,
             thread: envelope.payload.thread,
             status: 'unread',
             is_urgent: false,
@@ -855,6 +941,44 @@ export class Router {
             routerLog.error('Failed to persist channel message', { error: String(err) });
         });
     }
+    persistChannelMembership(channel, member, action, opts) {
+        if (this.storage) {
+            this.storage.saveMessage({
+                id: crypto.randomUUID(),
+                ts: Date.now(),
+                from: '__system__',
+                to: channel,
+                topic: undefined,
+                kind: 'state', // membership events stored as state
+                body: `${action}:${member}`,
+                data: {
+                    _channelMembership: {
+                        member,
+                        action,
+                        invitedBy: opts?.invitedBy,
+                    },
+                },
+                status: 'read',
+                is_urgent: false,
+                is_broadcast: true,
+            }).catch((err) => {
+                routerLog.error('Failed to persist channel membership', { error: String(err) });
+            });
+        }
+        if (this.channelMembershipStore) {
+            const persistPromise = action === 'leave'
+                ? this.channelMembershipStore.removeMember(channel, member)
+                : this.channelMembershipStore.addMember(channel, member);
+            persistPromise.catch((err) => {
+                routerLog.error('Failed to sync channel membership to cloud store', {
+                    channel,
+                    member,
+                    action,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        }
+    }
     /**
      * Get all members of a channel.
      */
@@ -895,9 +1019,124 @@ export class Router {
     }
     /**
      * Get a connection by name (checks both agents and users).
+     * Uses case-insensitive lookup to handle mismatched casing.
      */
     getConnectionByName(name) {
-        return this.agents.get(name) ?? this.users.get(name);
+        // Try exact match first
+        const exact = this.agents.get(name) ?? this.users.get(name);
+        if (exact)
+            return exact;
+        // Fall back to case-insensitive search
+        const lowerName = name.toLowerCase();
+        for (const [key, conn] of this.agents) {
+            if (key.toLowerCase() === lowerName)
+                return conn;
+        }
+        for (const [key, conn] of this.users) {
+            if (key.toLowerCase() === lowerName)
+                return conn;
+        }
+        return undefined;
+    }
+    /**
+     * Check if a member is in a Set (case-insensitive).
+     * Returns the actual stored name if found, undefined otherwise.
+     */
+    findMemberInSet(members, name) {
+        // Try exact match first
+        if (members.has(name))
+            return name;
+        // Fall back to case-insensitive search
+        const lowerName = name.toLowerCase();
+        for (const member of members) {
+            if (member.toLowerCase() === lowerName)
+                return member;
+        }
+        return undefined;
+    }
+    /**
+     * Check if two names match (case-insensitive).
+     */
+    namesMatch(a, b) {
+        return a.toLowerCase() === b.toLowerCase();
+    }
+    /**
+     * Auto-join a member to a channel without notifications.
+     * Used for default channel membership (e.g., #general).
+     * @param memberName - The agent or user name to add
+     * @param channel - The channel to join (e.g., '#general')
+     */
+    autoJoinChannel(memberName, channel, options) {
+        // Get or create channel
+        let members = this.channels.get(channel);
+        if (!members) {
+            members = new Set();
+            this.channels.set(channel, members);
+        }
+        // Check if already a member
+        const added = this.addChannelMember(channel, memberName, { persist: options?.persist });
+        if (added) {
+            routerLog.debug(`Auto-joined ${memberName} to ${channel}`);
+        }
+    }
+    addChannelMember(channel, memberName, options) {
+        let members = this.channels.get(channel);
+        if (!members) {
+            members = new Set();
+            this.channels.set(channel, members);
+        }
+        // Case-insensitive check for existing membership
+        const existingMember = this.findMemberInSet(members, memberName);
+        if (existingMember) {
+            return false;
+        }
+        members.add(memberName);
+        const memberChannelSet = this.memberChannels.get(memberName) ?? new Set();
+        memberChannelSet.add(channel);
+        this.memberChannels.set(memberName, memberChannelSet);
+        if (options?.persist ?? true) {
+            this.persistChannelMembership(channel, memberName, 'join');
+        }
+        return true;
+    }
+    removeChannelMember(channel, memberName, options) {
+        const members = this.channels.get(channel);
+        if (!members) {
+            return false;
+        }
+        // Case-insensitive lookup to find actual stored name
+        const actualMemberName = this.findMemberInSet(members, memberName);
+        if (!actualMemberName) {
+            return false;
+        }
+        members.delete(actualMemberName);
+        if (members.size === 0) {
+            this.channels.delete(channel);
+        }
+        // Also try case-insensitive for memberChannels cleanup
+        const memberChannelSet = this.memberChannels.get(actualMemberName) ?? this.memberChannels.get(memberName);
+        if (memberChannelSet) {
+            memberChannelSet.delete(channel);
+            if (memberChannelSet.size === 0) {
+                this.memberChannels.delete(actualMemberName);
+                this.memberChannels.delete(memberName); // Clean up both potential keys
+            }
+        }
+        if (options?.persist ?? true) {
+            this.persistChannelMembership(channel, actualMemberName, 'leave');
+        }
+        return true;
+    }
+    handleMembershipUpdate(update) {
+        if (!update.channel || !update.member) {
+            return;
+        }
+        if (update.action === 'leave') {
+            this.removeChannelMember(update.channel, update.member, { persist: false });
+        }
+        else {
+            this.addChannelMember(update.channel, update.member, { persist: false });
+        }
     }
 }
 //# sourceMappingURL=router.js.map

package/dist/daemon/server.d.ts

@@ -37,6 +37,7 @@ export declare class Daemon {
     private cloudSync?;
     private remoteAgents;
     private consensus?;
+    private cloudSyncDebounceTimer?;
     /** 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) */
@@ -51,6 +52,11 @@ export declare class Daemon {
      * This file contains agents currently processing/thinking after receiving a message.
      */
     private writeProcessingStateFile;
+    /**
+     * Write currently connected agents to connected-agents.json for CLI consumption.
+     * This file contains agents with active socket connections (vs agents.json which is historical).
+     */
+    private writeConnectedAgentsFile;
     /**
      * Initialize storage adapter (called during start).
      */
@@ -85,8 +91,17 @@ export declare class Daemon {
     isRemoteAgent(agentName: string): RemoteAgent | undefined;
     /**
      * Notify cloud sync about local agent changes.
+     * Debounced to prevent flooding the cloud API with rapid connect/disconnect events.
      */
     private notifyCloudSync;
+    /**
+     * Actually perform the cloud sync (called after debounce).
+     */
+    private doCloudSync;
+    /**
+     * Check if an agent is internal (should be hidden from cloud sync and listings).
+     */
+    private isInternalAgent;
     /**
      * Stop the daemon.
      */