agent-relay 1.2.0 → 1.3.0

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

package/dist/daemon/user-directory.js

@@ -0,0 +1,233 @@
+/**
+ * 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}/
+ *         └── ...
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogger } from '../resiliency/logger.js';
+const logger = createLogger('user-directory');
+const PROVIDER_CONFIGS = {
+    claude: {
+        dir: '.claude',
+        credentialsFile: '.credentials.json',
+    },
+    codex: {
+        dir: '.codex',
+        credentialsFile: 'credentials.json',
+    },
+    gemini: {
+        dir: '.config/gcloud',
+        credentialsFile: 'application_default_credentials.json',
+    },
+    opencode: {
+        dir: '.opencode',
+        credentialsFile: 'credentials.json',
+    },
+    droid: {
+        dir: '.factory',
+        credentialsFile: 'credentials.json',
+    },
+};
+/**
+ * All supported providers for initialization
+ */
+const ALL_PROVIDERS = Object.keys(PROVIDER_CONFIGS);
+/**
+ * Service for managing per-user directories on workspace volumes.
+ * Enables multi-user credential storage without conflicts.
+ */
+export class UserDirectoryService {
+    baseDir;
+    usersDir;
+    /**
+     * Create a new UserDirectoryService.
+     * @param baseDir - Base data directory (e.g., /data)
+     */
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.usersDir = path.join(baseDir, 'users');
+        // Ensure users directory exists
+        this.ensureDirectory(this.usersDir);
+        logger.info(`UserDirectoryService initialized at ${this.usersDir}`);
+    }
+    /**
+     * 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) {
+        this.validateUserId(userId);
+        const userHome = path.join(this.usersDir, userId);
+        this.ensureDirectory(userHome);
+        return userHome;
+    }
+    /**
+     * 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, provider) {
+        this.validateUserId(userId);
+        const config = PROVIDER_CONFIGS[provider];
+        if (!config) {
+            // For unknown providers, use .{provider} directory
+            const userHome = this.getUserHome(userId);
+            const providerDir = path.join(userHome, `.${provider}`);
+            this.ensureDirectory(providerDir);
+            return providerDir;
+        }
+        const userHome = this.getUserHome(userId);
+        const providerDir = path.join(userHome, config.dir);
+        this.ensureDirectory(providerDir);
+        return providerDir;
+    }
+    /**
+     * Initialize a complete user environment with all provider directories.
+     *
+     * @param userId - User ID
+     * @returns User's home directory path
+     */
+    initializeUserEnvironment(userId) {
+        this.validateUserId(userId);
+        const userHome = this.getUserHome(userId);
+        // Create all provider directories
+        for (const provider of ALL_PROVIDERS) {
+            this.ensureProviderDir(userId, provider);
+        }
+        logger.info(`Initialized user environment for ${userId} at ${userHome}`);
+        return userHome;
+    }
+    /**
+     * 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) {
+        const userHome = this.getUserHome(userId);
+        return {
+            HOME: userHome,
+            XDG_CONFIG_HOME: path.join(userHome, '.config'),
+            AGENT_RELAY_USER_ID: userId,
+        };
+    }
+    /**
+     * List all user IDs that have directories.
+     *
+     * @returns Array of user IDs
+     */
+    listUsers() {
+        try {
+            const entries = fs.readdirSync(this.usersDir, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Check if a user has an existing directory.
+     *
+     * @param userId - User ID
+     * @returns True if directory exists
+     */
+    hasUserDirectory(userId) {
+        const userHome = path.join(this.usersDir, userId);
+        return fs.existsSync(userHome);
+    }
+    /**
+     * 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, provider) {
+        const config = PROVIDER_CONFIGS[provider];
+        if (!config) {
+            const userHome = this.getUserHome(userId);
+            return path.join(userHome, `.${provider}`, 'credentials.json');
+        }
+        const providerDir = this.ensureProviderDir(userId, provider);
+        return path.join(providerDir, config.credentialsFile);
+    }
+    /**
+     * Validate a user ID to prevent path traversal and other issues.
+     *
+     * @param userId - User ID to validate
+     * @throws Error if userId is invalid
+     */
+    validateUserId(userId) {
+        if (!userId || userId.trim() === '') {
+            throw new Error('User ID cannot be empty');
+        }
+        // Prevent path traversal
+        if (userId.includes('..') || userId.includes('/') || userId.includes('\\')) {
+            throw new Error('User ID contains invalid characters');
+        }
+        // Ensure resolved path is within users directory
+        const resolved = path.resolve(this.usersDir, userId);
+        if (!resolved.startsWith(this.usersDir)) {
+            throw new Error('User ID would escape users directory');
+        }
+    }
+    /**
+     * Ensure a directory exists, creating it recursively if needed.
+     */
+    ensureDirectory(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+}
+/**
+ * Get the default data directory for user directories.
+ * Uses AGENT_RELAY_DATA_DIR if set, otherwise /data (for Fly.io volumes).
+ */
+export function getDefaultDataDir() {
+    return process.env.AGENT_RELAY_DATA_DIR || '/data';
+}
+/**
+ * Singleton instance for the workspace.
+ */
+let _instance = null;
+/**
+ * Get the singleton UserDirectoryService instance.
+ */
+export function getUserDirectoryService() {
+    if (!_instance) {
+        _instance = new UserDirectoryService(getDefaultDataDir());
+    }
+    return _instance;
+}
+/**
+ * Create a new UserDirectoryService for testing or custom paths.
+ */
+export function createUserDirectoryService(baseDir) {
+    return new UserDirectoryService(baseDir);
+}
+//# sourceMappingURL=user-directory.js.map