hermes-web-ui 0.3.8 → 0.4.0

package/dist/server/services/hermes/group-chat/agent-clients.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClients = void 0;
+const socket_io_client_1 = require("socket.io-client");
+const auth_1 = require("../../auth");
+// ─── Agent Client (single connection) ─────────────────────────
+class AgentClient {
+    agentId;
+    profile;
+    name;
+    socket = null;
+    joinedRooms = new Set();
+    handlers;
+    port = 8648;
+    _reconnecting = false;
+    gatewayManager = null;
+    constructor(config, handlers = {}) {
+        this.agentId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+        this.profile = config.profile;
+        this.name = config.name;
+        this.handlers = handlers;
+    }
+    get connected() {
+        return this.socket?.connected ?? false;
+    }
+    get id() {
+        return this.socket?.id;
+    }
+    setGatewayManager(manager) {
+        this.gatewayManager = manager;
+    }
+    async connect(port = 8648) {
+        this.port = port;
+        const token = await (0, auth_1.getToken)();
+        this.socket = (0, socket_io_client_1.io)(`http://127.0.0.1:${port}/api/hermes/group-chat`, {
+            auth: {
+                token: token || undefined,
+                name: this.name,
+            },
+            transports: ['websocket'],
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 30000,
+        });
+        this.bindEvents();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('Connection timeout')), 10000);
+            this.socket.on('connect', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.socket.on('connect_error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+            this.joinedRooms.clear();
+        }
+    }
+    async joinRoom(roomId) {
+        this.ensureConnected();
+        return new Promise((resolve, reject) => {
+            this.socket.emit('join', { roomId }, (res) => {
+                if ('error' in res) {
+                    reject(new Error(res.error));
+                }
+                else {
+                    this.joinedRooms.add(roomId);
+                    resolve(res);
+                }
+            });
+        });
+    }
+    sendMessage(roomId, content) {
+        this.ensureConnected();
+        return new Promise((resolve, reject) => {
+            this.socket.emit('message', { roomId, content }, (res) => {
+                if (res.error) {
+                    reject(new Error(res.error));
+                }
+                else {
+                    resolve(res.id);
+                }
+            });
+        });
+    }
+    startTyping(roomId) {
+        this.ensureConnected();
+        this.socket.emit('typing', { roomId });
+    }
+    stopTyping(roomId) {
+        this.ensureConnected();
+        this.socket.emit('stop_typing', { roomId });
+    }
+    getJoinedRooms() {
+        return Array.from(this.joinedRooms);
+    }
+    async deleteSession(upstream, apiKey, runId) {
+        try {
+            await fetch(`${upstream}/v1/sessions/${runId}`, {
+                method: 'DELETE',
+                headers: {
+                    ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+        }
+        catch (err) {
+            console.warn(`[AgentClients] ${this.name}: failed to delete session ${runId}: ${err.message}`);
+        }
+    }
+    ensureConnected() {
+        if (!this.socket?.connected) {
+            throw new Error(`Agent "${this.name}" is not connected`);
+        }
+    }
+    // ─── Hermes Gateway Integration ────────────────────────────
+    /**
+     * Forward a user message to Hermes gateway and stream the reply back to the room.
+     */
+    async handleUserMessage(roomId, msg) {
+        if (!this.gatewayManager)
+            return;
+        // Ignore own messages and messages mentioning own name
+        if (msg.senderId === this.socket?.id)
+            return;
+        if (!msg.content.toLowerCase().includes(`@${this.name.toLowerCase()}`))
+            return;
+        const upstream = this.gatewayManager.getUpstream(this.profile);
+        const apiKey = this.gatewayManager.getApiKey(this.profile);
+        if (!upstream) {
+            console.error(`[AgentClients] ${this.name}: no gateway upstream for profile "${this.profile}"`);
+            return;
+        }
+        try {
+            // Notify room that agent is typing
+            this.startTyping(roomId);
+            // Generate unique session_id per agent per interaction
+            const sessionId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+            // Start a run on Hermes gateway
+            const runRes = await fetch(`${upstream}/v1/runs`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                },
+                body: JSON.stringify({
+                    input: msg.content,
+                    session_id: sessionId,
+                }),
+                signal: AbortSignal.timeout(120000),
+            });
+            if (!runRes.ok) {
+                const text = await runRes.text().catch(() => '');
+                console.error(`[AgentClients] ${this.name}: gateway run failed (${runRes.status}): ${text}`);
+                this.stopTyping(roomId);
+                return;
+            }
+            const { run_id } = await runRes.json();
+            if (!run_id) {
+                this.stopTyping(roomId);
+                return;
+            }
+            // Stream events from Hermes
+            const eventsUrl = new URL(`${upstream}/v1/runs/${run_id}/events`);
+            if (apiKey)
+                eventsUrl.searchParams.set('token', apiKey);
+            const source = new EventSource(eventsUrl.toString());
+            let fullContent = '';
+            source.onmessage = (e) => {
+                try {
+                    const parsed = JSON.parse(e.data);
+                    if (parsed.event === 'run.completed') {
+                        source.close();
+                        if (fullContent) {
+                            this.stopTyping(roomId);
+                            this.sendMessage(roomId, fullContent);
+                        }
+                        this.deleteSession(upstream, apiKey, sessionId).catch(() => { });
+                        return;
+                    }
+                    if (parsed.event === 'run.failed') {
+                        source.close();
+                        this.stopTyping(roomId);
+                        this.deleteSession(upstream, apiKey, sessionId).catch(() => { });
+                        return;
+                    }
+                    // Accumulate message deltas
+                    if (parsed.event === 'message' && parsed.delta) {
+                        fullContent += parsed.delta;
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            };
+            source.onerror = () => {
+                source.close();
+                this.stopTyping(roomId);
+            };
+        }
+        catch (err) {
+            console.error(`[AgentClients] ${this.name}: error handling message: ${err.message}`);
+            this.stopTyping(roomId);
+        }
+    }
+    bindEvents() {
+        const s = this.socket;
+        s.on('message', (msg) => {
+            // Forward to Hermes gateway for AI response
+            this.handleUserMessage(msg.roomId, msg).catch((err) => {
+                console.error(`[AgentClients] ${this.name}: handleUserMessage error: ${err.message}`);
+            });
+            // Also notify external handlers
+            this.handlers.onMessage?.({ roomId: msg.roomId, msg });
+        });
+        s.on('typing', (data) => {
+            this.handlers.onTyping?.(data);
+        });
+        s.on('stop_typing', (data) => {
+            this.handlers.onStopTyping?.(data);
+        });
+        s.on('member_joined', (data) => {
+            this.handlers.onMemberJoined?.(data);
+        });
+        s.on('member_left', (data) => {
+            this.handlers.onMemberLeft?.(data);
+        });
+        // Auto rejoin rooms on reconnect
+        s.io.on('reconnect', async () => {
+            if (this._reconnecting)
+                return;
+            this._reconnecting = true;
+            console.log(`[AgentClients] ${this.name} reconnecting, rejoining ${this.joinedRooms.size} rooms...`);
+            const rooms = Array.from(this.joinedRooms);
+            for (const roomId of rooms) {
+                try {
+                    await this.joinRoom(roomId);
+                }
+                catch (err) {
+                    console.error(`[AgentClients] ${this.name} failed to rejoin room ${roomId}: ${err.message}`);
+                }
+            }
+            this._reconnecting = false;
+        });
+    }
+}
+// ─── AgentClients (roomId -> agents) ──────────────────────────
+class AgentClients {
+    rooms = new Map();
+    /**
+     * Create an agent client and connect it to the server.
+     * The agent will NOT auto-join any room — call addAgentToRoom separately.
+     */
+    async createAgent(config, handlers, port) {
+        const client = new AgentClient(config, handlers);
+        await client.connect(port);
+        console.log(`[AgentClients] Connected: ${client.name} (${client.agentId})`);
+        return client;
+    }
+    /**
+     * Connect an agent to a room.
+     */
+    async addAgentToRoom(roomId, client) {
+        let room = this.rooms.get(roomId);
+        if (!room) {
+            room = new Map();
+            this.rooms.set(roomId, room);
+        }
+        room.set(client.agentId, client);
+        const result = await client.joinRoom(roomId);
+        console.log(`[AgentClients] ${client.name} joined room: ${roomId}`);
+        return result;
+    }
+    /**
+     * Remove an agent from a room and disconnect it.
+     */
+    removeAgentFromRoom(roomId, agentId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            return;
+        const client = room.get(agentId);
+        if (client) {
+            client.disconnect();
+            room.delete(agentId);
+            console.log(`[AgentClients] ${client.name} left room: ${roomId}`);
+        }
+        if (room.size === 0) {
+            this.rooms.delete(roomId);
+        }
+    }
+    /**
+     * Get all agents in a room.
+     */
+    getAgents(roomId) {
+        const room = this.rooms.get(roomId);
+        return room ? Array.from(room.values()) : [];
+    }
+    /**
+     * Get a specific agent in a room.
+     */
+    getAgent(roomId, agentId) {
+        return this.rooms.get(roomId)?.get(agentId);
+    }
+    /**
+     * Get all room IDs that have agents.
+     */
+    getRoomIds() {
+        return Array.from(this.rooms.keys());
+    }
+    /**
+     * Send a message from a specific agent in a room.
+     */
+    async sendMessage(roomId, agentId, content) {
+        const client = this.getAgent(roomId, agentId);
+        if (!client) {
+            throw new Error(`Agent "${agentId}" not found in room "${roomId}"`);
+        }
+        return client.sendMessage(roomId, content);
+    }
+    /**
+     * Broadcast a message from all agents in a room.
+     */
+    async broadcastFromRoom(roomId, content) {
+        const agents = this.getAgents(roomId);
+        return Promise.all(agents.map((agent) => agent.sendMessage(roomId, content)));
+    }
+    /**
+     * Disconnect all agents in a room.
+     */
+    disconnectRoom(roomId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            return;
+        room.forEach((client) => client.disconnect());
+        this.rooms.delete(roomId);
+        console.log(`[AgentClients] All agents disconnected from room: ${roomId}`);
+    }
+    /**
+     * Disconnect all agents in all rooms.
+     */
+    disconnectAll() {
+        this.rooms.forEach((room) => {
+            room.forEach((client) => client.disconnect());
+        });
+        this.rooms.clear();
+        console.log('[AgentClients] All agents disconnected');
+    }
+    /**
+     * Set gateway manager for all existing and future agents.
+     */
+    setGatewayManager(manager) {
+        this.rooms.forEach((room) => {
+            room.forEach((client) => client.setGatewayManager(manager));
+        });
+    }
+}
+exports.AgentClients = AgentClients;

package/dist/server/services/hermes/group-chat/index.d.ts

@@ -0,0 +1,72 @@
+import { Server } from 'socket.io';
+import type { Server as HttpServer } from 'http';
+import { AgentClients } from './agent-clients';
+interface ChatMessage {
+    id: string;
+    roomId: string;
+    senderId: string;
+    senderName: string;
+    content: string;
+    timestamp: number;
+}
+interface RoomAgent {
+    id: string;
+    roomId: string;
+    agentId: string;
+    profile: string;
+    name: string;
+    description: string;
+    invited: number;
+}
+declare class ChatStorage {
+    private db;
+    constructor(dbPath: string);
+    getRoom(roomId: string): {
+        id: string;
+        name: string;
+        inviteCode: string | null;
+    } | undefined;
+    getRoomByInviteCode(code: string): {
+        id: string;
+        name: string;
+        inviteCode: string | null;
+    } | undefined;
+    getAllRooms(): {
+        id: string;
+        name: string;
+        inviteCode: string | null;
+    }[];
+    saveRoom(id: string, name: string, inviteCode?: string): void;
+    updateRoomInviteCode(roomId: string, inviteCode: string): void;
+    getMessages(roomId: string, limit?: number): ChatMessage[];
+    addMessage(msg: ChatMessage): void;
+    pruneMessages(roomId: string, keep?: number): void;
+    getRoomAgents(roomId: string): RoomAgent[];
+    addRoomAgent(roomId: string, agentId: string, profile: string, name: string, description: string, invited: number): RoomAgent;
+    removeRoomAgent(agentId: string): void;
+    close(): void;
+}
+export declare class GroupChatServer {
+    private io;
+    private storage;
+    private rooms;
+    private userNames;
+    readonly agentClients: AgentClients;
+    private gatewayManager;
+    setGatewayManager(manager: any): void;
+    constructor(httpServer: HttpServer);
+    getIO(): Server;
+    getStorage(): ChatStorage;
+    getRoomIds(): string[];
+    private restoreAgents;
+    private authMiddleware;
+    private onConnection;
+    private handleJoin;
+    private handleMessage;
+    private handleTyping;
+    private handleStopTyping;
+    private handleDisconnect;
+    private leaveAllRooms;
+    private generateId;
+}
+export {};