agent-relay 1.2.3 → 1.3.1

package/dist/daemon/router.d.ts

@@ -2,12 +2,15 @@
  * Message router for the agent relay daemon.
  * Handles routing messages between agents, topic subscriptions, and broadcast.
  */
-import { type Envelope, type SendEnvelope, type AckPayload, type ShadowConfig, type SpeakOnTrigger } from '../protocol/types.js';
+import { type Envelope, type SendEnvelope, type AckPayload, type ShadowConfig, type SpeakOnTrigger, type EntityType } from '../protocol/types.js';
+import type { ChannelJoinPayload, ChannelLeavePayload, ChannelMessagePayload } from '../protocol/channels.js';
 import type { StorageAdapter } from '../storage/adapter.js';
 import type { AgentRegistry } from './agent-registry.js';
 export interface RoutableConnection {
     id: string;
     agentName?: string;
+    /** Entity type: 'agent' (default) or 'user' for human users */
+    entityType?: EntityType;
     cli?: string;
     program?: string;
     model?: string;
@@ -55,6 +58,12 @@ export declare class Router {
     private shadowsByPrimary;
     /** Reverse lookup: shadowAgent -> primaryAgent (for cleanup) */
     private primaryByShadow;
+    /** Channel membership: channel -> Set of member names */
+    private channels;
+    /** User entities (human users, not agents) */
+    private users;
+    /** Reverse lookup: member name -> Set of channels they're in */
+    private memberChannels;
     /** Default timeout for processing indicator (30 seconds) */
     private static readonly PROCESSING_TIMEOUT_MS;
     /** Callback when processing state changes (for real-time dashboard updates) */
@@ -78,6 +87,10 @@ export declare class Router {
      * Unregister a connection.
      */
     unregister(connection: RoutableConnection): void;
+    /**
+     * Remove a member from all channels they're in.
+     */
+    private removeFromAllChannels;
     /**
      * Subscribe an agent to a topic.
      */
@@ -206,6 +219,52 @@ export declare class Router {
      * Replay any pending (unacked) messages for a resumed session.
      */
     replayPending(connection: RoutableConnection): Promise<void>;
+    /**
+     * Handle a CHANNEL_JOIN message.
+     * Adds the member to the channel and notifies existing members.
+     */
+    handleChannelJoin(connection: RoutableConnection, envelope: Envelope<ChannelJoinPayload>): void;
+    /**
+     * Handle a CHANNEL_LEAVE message.
+     * Removes the member from the channel and notifies remaining members.
+     */
+    handleChannelLeave(connection: RoutableConnection, envelope: Envelope<ChannelLeavePayload>): void;
+    /**
+     * Route a channel message to all members except the sender.
+     */
+    routeChannelMessage(connection: RoutableConnection, envelope: Envelope<ChannelMessagePayload>): void;
+    /**
+     * Persist a channel message to storage.
+     */
+    private persistChannelMessage;
+    /**
+     * Get all members of a channel.
+     */
+    getChannelMembers(channel: string): string[];
+    /**
+     * Get all channels.
+     */
+    getChannels(): string[];
+    /**
+     * Get all channels a member is in.
+     */
+    getChannelsForMember(memberName: string): string[];
+    /**
+     * Check if a name belongs to a user (not an agent).
+     */
+    isUser(name: string): boolean;
+    /**
+     * Check if a name belongs to an agent (not a user).
+     */
+    isAgent(name: string): boolean;
+    /**
+     * Get list of connected user names (human users only).
+     */
+    getUsers(): string[];
+    /**
+     * Get a connection by name (checks both agents and users).
+     */
+    private getConnectionByName;
 }
 export {};
 //# sourceMappingURL=router.d.ts.map

package/dist/daemon/router.js

@@ -24,6 +24,12 @@ export class Router {
     shadowsByPrimary = new Map();
     /** Reverse lookup: shadowAgent -> primaryAgent (for cleanup) */
     primaryByShadow = new Map();
+    /** Channel membership: channel -> Set of member names */
+    channels = new Map();
+    /** User entities (human users, not agents) */
+    users = new Map();
+    /** Reverse lookup: member name -> Set of channels they're in */
+    memberChannels = new Map();
     /** Default timeout for processing indicator (30 seconds) */
     static PROCESSING_TIMEOUT_MS = 30_000;
     /** Callback when processing state changes (for real-time dashboard updates) */
@@ -47,21 +53,34 @@ export class Router {
     register(connection) {
         this.connections.set(connection.id, connection);
         if (connection.agentName) {
-            // Handle existing connection with same name (disconnect old)
-            const existing = this.agents.get(connection.agentName);
-            if (existing && existing.id !== connection.id) {
-                existing.close();
-                this.connections.delete(existing.id);
+            const isUser = connection.entityType === 'user';
+            if (isUser) {
+                // Handle existing user connection with same name (disconnect old)
+                const existingUser = this.users.get(connection.agentName);
+                if (existingUser && existingUser.id !== connection.id) {
+                    existingUser.close();
+                    this.connections.delete(existingUser.id);
+                }
+                this.users.set(connection.agentName, connection);
+                routerLog.info(`User registered: ${connection.agentName}`);
+            }
+            else {
+                // Handle existing agent connection with same name (disconnect old)
+                const existing = this.agents.get(connection.agentName);
+                if (existing && existing.id !== connection.id) {
+                    existing.close();
+                    this.connections.delete(existing.id);
+                }
+                this.agents.set(connection.agentName, connection);
+                this.registry?.registerOrUpdate({
+                    name: connection.agentName,
+                    cli: connection.cli,
+                    program: connection.program,
+                    model: connection.model,
+                    task: connection.task,
+                    workingDirectory: connection.workingDirectory,
+                });
             }
-            this.agents.set(connection.agentName, connection);
-            this.registry?.registerOrUpdate({
-                name: connection.agentName,
-                cli: connection.cli,
-                program: connection.program,
-                model: connection.model,
-                task: connection.task,
-                workingDirectory: connection.workingDirectory,
-            });
         }
     }
     /**
@@ -70,14 +89,25 @@ export class Router {
     unregister(connection) {
         this.connections.delete(connection.id);
         if (connection.agentName) {
-            const current = this.agents.get(connection.agentName);
-            if (current?.id === connection.id) {
-                this.agents.delete(connection.agentName);
+            const isUser = connection.entityType === 'user';
+            if (isUser) {
+                const currentUser = this.users.get(connection.agentName);
+                if (currentUser?.id === connection.id) {
+                    this.users.delete(connection.agentName);
+                }
+            }
+            else {
+                const current = this.agents.get(connection.agentName);
+                if (current?.id === connection.id) {
+                    this.agents.delete(connection.agentName);
+                }
             }
             // 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
@@ -85,6 +115,25 @@ export class Router {
         }
         this.clearPendingForConnection(connection.id);
     }
+    /**
+     * Remove a member from all channels they're in.
+     */
+    removeFromAllChannels(memberName) {
+        const memberChannelSet = this.memberChannels.get(memberName);
+        if (!memberChannelSet)
+            return;
+        for (const channelName of memberChannelSet) {
+            const members = this.channels.get(channelName);
+            if (members) {
+                members.delete(memberName);
+                // Clean up empty channels
+                if (members.size === 0) {
+                    this.channels.delete(channelName);
+                }
+            }
+        }
+        this.memberChannels.delete(memberName);
+    }
     /**
      * Subscribe an agent to a topic.
      */
@@ -308,7 +357,8 @@ export class Router {
      * Send a direct message to a specific agent.
      */
     sendDirect(from, to, envelope) {
-        const target = this.agents.get(to);
+        const target = this.agents.get(to) ?? this.users.get(to);
+        const isUserTarget = target?.entityType === 'user';
         // If agent not found locally, check if it's on a remote machine
         if (!target) {
             const remoteAgent = this.crossMachineHandler?.isRemoteAgent(to);
@@ -326,8 +376,10 @@ export class Router {
         if (sent) {
             this.trackDelivery(target, deliver);
             this.registry?.recordReceive(to);
-            // Mark recipient as processing
-            this.setProcessing(to, deliver.id);
+            // Only mark AI agents as processing; humans don't need processing indicators
+            if (!isUserTarget) {
+                this.setProcessing(to, deliver.id);
+            }
         }
         return sent;
     }
@@ -694,5 +746,214 @@ export class Router {
             }
         }
     }
+    // ==================== Channel Methods ====================
+    /**
+     * Handle a CHANNEL_JOIN message.
+     * Adds the member to the channel and notifies existing members.
+     */
+    handleChannelJoin(connection, envelope) {
+        const memberName = connection.agentName;
+        if (!memberName) {
+            routerLog.warn('CHANNEL_JOIN from connection without name');
+            return;
+        }
+        const channel = envelope.payload.channel;
+        // 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
+        if (members.has(memberName)) {
+            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: uuid(),
+                    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);
+        }
+        memberChannelSet.add(channel);
+        routerLog.info(`${memberName} joined ${channel} (${members.size} members)`);
+    }
+    /**
+     * Handle a CHANNEL_LEAVE message.
+     * Removes the member from the channel and notifies remaining members.
+     */
+    handleChannelLeave(connection, envelope) {
+        const memberName = connection.agentName;
+        if (!memberName) {
+            routerLog.warn('CHANNEL_LEAVE from connection without name');
+            return;
+        }
+        const channel = envelope.payload.channel;
+        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);
+            }
+        }
+        // Notify remaining members
+        for (const remainingMember of members) {
+            const memberConn = this.getConnectionByName(remainingMember);
+            if (memberConn) {
+                const leaveNotification = {
+                    v: PROTOCOL_VERSION,
+                    type: 'CHANNEL_LEAVE',
+                    id: uuid(),
+                    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}`);
+    }
+    /**
+     * Route a channel message to all members except the sender.
+     */
+    routeChannelMessage(connection, envelope) {
+        const senderName = connection.agentName;
+        if (!senderName) {
+            routerLog.warn('CHANNEL_MESSAGE from connection without name');
+            return;
+        }
+        const channel = envelope.payload.channel;
+        const members = this.channels.get(channel);
+        if (!members) {
+            routerLog.warn(`Message to non-existent channel ${channel}`);
+            return;
+        }
+        if (!members.has(senderName)) {
+            routerLog.warn(`${senderName} not a member of ${channel}`);
+            return;
+        }
+        // Route to all members except sender
+        for (const memberName of members) {
+            if (memberName === senderName)
+                continue;
+            const memberConn = this.getConnectionByName(memberName);
+            if (memberConn) {
+                const deliverEnvelope = {
+                    v: PROTOCOL_VERSION,
+                    type: 'CHANNEL_MESSAGE',
+                    id: uuid(),
+                    ts: Date.now(),
+                    from: senderName,
+                    payload: envelope.payload,
+                };
+                memberConn.send(deliverEnvelope);
+            }
+        }
+        // Persist channel message
+        this.persistChannelMessage(envelope, senderName);
+        routerLog.debug(`${senderName} -> ${channel}: ${envelope.payload.body.substring(0, 50)}`);
+    }
+    /**
+     * Persist a channel message to storage.
+     */
+    persistChannelMessage(envelope, from) {
+        if (!this.storage)
+            return;
+        this.storage.saveMessage({
+            id: envelope.id,
+            ts: envelope.ts,
+            from,
+            to: envelope.payload.channel, // Channel name as "to"
+            topic: undefined,
+            kind: 'message',
+            body: envelope.payload.body,
+            data: {
+                ...envelope.payload.data,
+                _isChannelMessage: true,
+                _channel: envelope.payload.channel,
+                _mentions: envelope.payload.mentions,
+            },
+            thread: envelope.payload.thread,
+            status: 'unread',
+            is_urgent: false,
+            is_broadcast: true, // Channel messages are effectively broadcasts
+        }).catch((err) => {
+            routerLog.error('Failed to persist channel message', { error: String(err) });
+        });
+    }
+    /**
+     * Get all members of a channel.
+     */
+    getChannelMembers(channel) {
+        const members = this.channels.get(channel);
+        return members ? Array.from(members) : [];
+    }
+    /**
+     * Get all channels.
+     */
+    getChannels() {
+        return Array.from(this.channels.keys());
+    }
+    /**
+     * Get all channels a member is in.
+     */
+    getChannelsForMember(memberName) {
+        const channels = this.memberChannels.get(memberName);
+        return channels ? Array.from(channels) : [];
+    }
+    /**
+     * Check if a name belongs to a user (not an agent).
+     */
+    isUser(name) {
+        return this.users.has(name);
+    }
+    /**
+     * Check if a name belongs to an agent (not a user).
+     */
+    isAgent(name) {
+        return this.agents.has(name);
+    }
+    /**
+     * Get list of connected user names (human users only).
+     */
+    getUsers() {
+        return Array.from(this.users.keys());
+    }
+    /**
+     * Get a connection by name (checks both agents and users).
+     */
+    getConnectionByName(name) {
+        return this.agents.get(name) ?? this.users.get(name);
+    }
 }
 //# sourceMappingURL=router.js.map

package/dist/daemon/user-directory.d.ts

@@ -0,0 +1,111 @@
+/**
+ * User Directory Service
+ *
+ * Manages per-user directories on workspace volumes for CLI credential storage.
+ * Each user gets their own home directory at /data/users/{userId}/ with
+ * provider-specific subdirectories for credentials.
+ *
+ * Structure:
+ * /data/
+ * └── users/
+ *     ├── {userId1}/
+ *     │   ├── .claude/
+ *     │   │   └── .credentials.json
+ *     │   ├── .codex/
+ *     │   │   └── credentials.json
+ *     │   └── .config/
+ *     │       └── gcloud/
+ *     │           └── application_default_credentials.json
+ *     └── {userId2}/
+ *         └── ...
+ */
+/**
+ * Service for managing per-user directories on workspace volumes.
+ * Enables multi-user credential storage without conflicts.
+ */
+export declare class UserDirectoryService {
+    private baseDir;
+    private usersDir;
+    /**
+     * Create a new UserDirectoryService.
+     * @param baseDir - Base data directory (e.g., /data)
+     */
+    constructor(baseDir: string);
+    /**
+     * Get the home directory path for a user.
+     * Creates the directory if it doesn't exist.
+     *
+     * @param userId - User ID (UUID or similar)
+     * @returns Absolute path to user's home directory
+     * @throws Error if userId is invalid
+     */
+    getUserHome(userId: string): string;
+    /**
+     * Ensure a provider's credential directory exists for a user.
+     *
+     * @param userId - User ID
+     * @param provider - Provider name (claude, codex, gemini, etc.)
+     * @returns Absolute path to provider directory
+     */
+    ensureProviderDir(userId: string, provider: string): string;
+    /**
+     * Initialize a complete user environment with all provider directories.
+     *
+     * @param userId - User ID
+     * @returns User's home directory path
+     */
+    initializeUserEnvironment(userId: string): string;
+    /**
+     * Get environment variables for spawning an agent with user-specific HOME.
+     *
+     * @param userId - User ID
+     * @returns Environment variables to merge with process.env
+     */
+    getUserEnvironment(userId: string): Record<string, string>;
+    /**
+     * List all user IDs that have directories.
+     *
+     * @returns Array of user IDs
+     */
+    listUsers(): string[];
+    /**
+     * Check if a user has an existing directory.
+     *
+     * @param userId - User ID
+     * @returns True if directory exists
+     */
+    hasUserDirectory(userId: string): boolean;
+    /**
+     * Get the path to a provider's credentials file for a user.
+     *
+     * @param userId - User ID
+     * @param provider - Provider name
+     * @returns Absolute path to credentials file
+     */
+    getProviderCredentialPath(userId: string, provider: string): string;
+    /**
+     * Validate a user ID to prevent path traversal and other issues.
+     *
+     * @param userId - User ID to validate
+     * @throws Error if userId is invalid
+     */
+    private validateUserId;
+    /**
+     * Ensure a directory exists, creating it recursively if needed.
+     */
+    private ensureDirectory;
+}
+/**
+ * Get the default data directory for user directories.
+ * Uses AGENT_RELAY_DATA_DIR if set, otherwise /data (for Fly.io volumes).
+ */
+export declare function getDefaultDataDir(): string;
+/**
+ * Get the singleton UserDirectoryService instance.
+ */
+export declare function getUserDirectoryService(): UserDirectoryService;
+/**
+ * Create a new UserDirectoryService for testing or custom paths.
+ */
+export declare function createUserDirectoryService(baseDir: string): UserDirectoryService;
+//# sourceMappingURL=user-directory.d.ts.map