hermes-web-ui 0.3.7 → 0.4.0

package/dist/server/services/group-chat/rooms-db.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoom = createRoom;
+exports.listRooms = listRooms;
+exports.getRoom = getRoom;
+exports.updateRoom = updateRoom;
+exports.deleteRoom = deleteRoom;
+exports.addRoomAgent = addRoomAgent;
+exports.removeRoomAgent = removeRoomAgent;
+exports.getRoomAgents = getRoomAgents;
+exports.updateRoomAgentSession = updateRoomAgentSession;
+exports.addMessage = addMessage;
+exports.getRoomMessages = getRoomMessages;
+exports.getLatestRound = getLatestRound;
+exports.getRecentContext = getRecentContext;
+const os_1 = require("os");
+const path_1 = require("path");
+// ---------------------------------------------------------------------------
+// Database singleton
+// ---------------------------------------------------------------------------
+const SQLITE_AVAILABLE = (() => {
+    const [major, minor] = process.versions.node.split('.').map(Number);
+    return major > 22 || (major === 22 && minor >= 5);
+})();
+function dbPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.hermes-web-ui', 'rooms.db');
+}
+let _db = null;
+function getDb() {
+    if (_db)
+        return _db;
+    if (!SQLITE_AVAILABLE) {
+        throw new Error('Group chat requires Node.js >= 22.5 for SQLite support');
+    }
+    const { DatabaseSync } = require('node:sqlite');
+    const dir = (0, path_1.join)((0, os_1.homedir)(), '.hermes-web-ui');
+    const { mkdirSync } = require('fs');
+    mkdirSync(dir, { recursive: true });
+    _db = new DatabaseSync(dbPath(), { open: true });
+    _db.exec('PRAGMA journal_mode=WAL');
+    _db.exec('PRAGMA foreign_keys=ON');
+    initSchema(_db);
+    return _db;
+}
+function initSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS rooms (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      settings TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS room_agents (
+      room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+      agent_name TEXT NOT NULL,
+      profile TEXT NOT NULL,
+      session_id TEXT DEFAULT '',
+      role_prompt TEXT DEFAULT '',
+      PRIMARY KEY (room_id, agent_name)
+    );
+
+    CREATE TABLE IF NOT EXISTS room_messages (
+      id TEXT PRIMARY KEY,
+      room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      agent_name TEXT DEFAULT '',
+      content TEXT NOT NULL,
+      mentions TEXT DEFAULT '[]',
+      round INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_room_messages_room
+      ON room_messages(room_id, created_at);
+  `);
+}
+// ---------------------------------------------------------------------------
+// Room CRUD
+// ---------------------------------------------------------------------------
+function createRoom(name) {
+    const db = getDb();
+    const now = Date.now();
+    const id = crypto.randomUUID();
+    db.prepare('INSERT INTO rooms (id, name, settings, created_at, updated_at) VALUES (?, ?, ?, ?, ?)')
+        .run(id, name, '{}', now, now);
+    return { id, name, settings: '{}', created_at: now, updated_at: now };
+}
+function listRooms() {
+    const db = getDb();
+    return db.prepare('SELECT * FROM rooms ORDER BY updated_at DESC').all();
+}
+function getRoom(roomId) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM rooms WHERE id = ?').get(roomId);
+}
+function updateRoom(roomId, updates) {
+    const db = getDb();
+    const sets = [];
+    const values = [];
+    if (updates.name !== undefined) {
+        sets.push('name = ?');
+        values.push(updates.name);
+    }
+    if (updates.settings !== undefined) {
+        sets.push('settings = ?');
+        values.push(updates.settings);
+    }
+    if (sets.length === 0)
+        return false;
+    sets.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(roomId);
+    const result = db.prepare(`UPDATE rooms SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+    return result.changes > 0;
+}
+function deleteRoom(roomId) {
+    const db = getDb();
+    db.prepare('DELETE FROM room_messages WHERE room_id = ?').run(roomId);
+    db.prepare('DELETE FROM room_agents WHERE room_id = ?').run(roomId);
+    const result = db.prepare('DELETE FROM rooms WHERE id = ?').run(roomId);
+    return result.changes > 0;
+}
+// ---------------------------------------------------------------------------
+// Room Agents
+// ---------------------------------------------------------------------------
+function addRoomAgent(roomId, agent) {
+    const db = getDb();
+    const row = db.prepare('INSERT OR IGNORE INTO room_agents (room_id, agent_name, profile, session_id, role_prompt) VALUES (?, ?, ?, ?, ?)').run(roomId, agent.agent_name, agent.profile, '', agent.role_prompt || '');
+    if (row.changes === 0)
+        return null;
+    return getRoomAgent(roomId, agent.agent_name);
+}
+function removeRoomAgent(roomId, agentName) {
+    const db = getDb();
+    const result = db.prepare('DELETE FROM room_agents WHERE room_id = ? AND agent_name = ?')
+        .run(roomId, agentName);
+    return result.changes > 0;
+}
+function getRoomAgents(roomId) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM room_agents WHERE room_id = ?').all(roomId);
+}
+function getRoomAgent(roomId, agentName) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM room_agents WHERE room_id = ? AND agent_name = ?')
+        .get(roomId, agentName);
+}
+function updateRoomAgentSession(roomId, agentName, sessionId) {
+    const db = getDb();
+    db.prepare('UPDATE room_agents SET session_id = ? WHERE room_id = ? AND agent_name = ?')
+        .run(sessionId, roomId, agentName);
+}
+// ---------------------------------------------------------------------------
+// Messages
+// ---------------------------------------------------------------------------
+function addMessage(msg) {
+    const db = getDb();
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const mentions = msg.mentions ? JSON.stringify(msg.mentions) : '[]';
+    const round = msg.round ?? getLatestRound(msg.room_id);
+    db.prepare('INSERT INTO room_messages (id, room_id, role, agent_name, content, mentions, round, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(id, msg.room_id, msg.role, msg.agent_name || '', msg.content, mentions, round, now);
+    // Update room timestamp
+    db.prepare('UPDATE rooms SET updated_at = ? WHERE id = ?').run(now, msg.room_id);
+    return { id, room_id: msg.room_id, role: msg.role, agent_name: msg.agent_name || '', content: msg.content, mentions, round, created_at: now };
+}
+function getRoomMessages(roomId, limit = 100, offset = 0) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM room_messages WHERE room_id = ? ORDER BY created_at ASC LIMIT ? OFFSET ?').all(roomId, limit, offset);
+}
+function getLatestRound(roomId) {
+    const db = getDb();
+    const row = db.prepare('SELECT MAX(round) as max_round FROM room_messages WHERE room_id = ?')
+        .get(roomId);
+    return (row?.max_round ?? -1) + 1;
+}
+/**
+ * Get recent context messages relevant to a specific agent.
+ * Returns messages where:
+ *   - mentions is empty (public message, no @mentions)
+ *   - mentions includes agentName
+ *   - message is FROM this agent
+ */
+function getRecentContext(roomId, agentName, limit = 20) {
+    const db = getDb();
+    return db.prepare(`
+    SELECT * FROM room_messages
+    WHERE room_id = ?
+      AND (
+        json_array_length(mentions) = 0
+        OR agent_name = ?
+        OR mentions LIKE ?
+      )
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(roomId, agentName, `%"${agentName}"%`, limit);
+}

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

@@ -0,0 +1,133 @@
+import type { GatewayManager } from '../gateway-manager';
+interface AgentConfig {
+    profile: string;
+    name: string;
+    description: string;
+    invited: number;
+}
+interface MessageData {
+    id: string;
+    roomId: string;
+    senderId: string;
+    senderName: string;
+    content: string;
+    timestamp: number;
+}
+interface MemberData {
+    id: string;
+    name: string;
+    joinedAt: number;
+}
+interface JoinResult {
+    roomId: string;
+    roomName: string;
+    members: MemberData[];
+    messages: MessageData[];
+    rooms: string[];
+}
+export interface AgentEventHandler {
+    onMessage?: (data: {
+        roomId: string;
+        msg: MessageData;
+    }) => void;
+    onTyping?: (data: {
+        roomId: string;
+        userId: string;
+        userName: string;
+    }) => void;
+    onStopTyping?: (data: {
+        roomId: string;
+        userId: string;
+        userName: string;
+    }) => void;
+    onMemberJoined?: (data: {
+        roomId: string;
+        memberId: string;
+        memberName: string;
+        members: MemberData[];
+    }) => void;
+    onMemberLeft?: (data: {
+        roomId: string;
+        memberId: string;
+        memberName: string;
+        members: MemberData[];
+    }) => void;
+}
+declare class AgentClient {
+    readonly agentId: string;
+    readonly profile: string;
+    readonly name: string;
+    private socket;
+    private joinedRooms;
+    private handlers;
+    private port;
+    private _reconnecting;
+    private gatewayManager;
+    constructor(config: AgentConfig, handlers?: AgentEventHandler);
+    get connected(): boolean;
+    get id(): string | undefined;
+    setGatewayManager(manager: GatewayManager): void;
+    connect(port?: number): Promise<void>;
+    disconnect(): void;
+    joinRoom(roomId: string): Promise<JoinResult>;
+    sendMessage(roomId: string, content: string): Promise<string>;
+    startTyping(roomId: string): void;
+    stopTyping(roomId: string): void;
+    getJoinedRooms(): string[];
+    private deleteSession;
+    private ensureConnected;
+    /**
+     * Forward a user message to Hermes gateway and stream the reply back to the room.
+     */
+    private handleUserMessage;
+    private bindEvents;
+}
+export declare class AgentClients {
+    private rooms;
+    /**
+     * Create an agent client and connect it to the server.
+     * The agent will NOT auto-join any room — call addAgentToRoom separately.
+     */
+    createAgent(config: AgentConfig, handlers?: AgentEventHandler, port?: number): Promise<AgentClient>;
+    /**
+     * Connect an agent to a room.
+     */
+    addAgentToRoom(roomId: string, client: AgentClient): Promise<JoinResult>;
+    /**
+     * Remove an agent from a room and disconnect it.
+     */
+    removeAgentFromRoom(roomId: string, agentId: string): void;
+    /**
+     * Get all agents in a room.
+     */
+    getAgents(roomId: string): AgentClient[];
+    /**
+     * Get a specific agent in a room.
+     */
+    getAgent(roomId: string, agentId: string): AgentClient | undefined;
+    /**
+     * Get all room IDs that have agents.
+     */
+    getRoomIds(): string[];
+    /**
+     * Send a message from a specific agent in a room.
+     */
+    sendMessage(roomId: string, agentId: string, content: string): Promise<string>;
+    /**
+     * Broadcast a message from all agents in a room.
+     */
+    broadcastFromRoom(roomId: string, content: string): Promise<string[]>;
+    /**
+     * Disconnect all agents in a room.
+     */
+    disconnectRoom(roomId: string): void;
+    /**
+     * Disconnect all agents in all rooms.
+     */
+    disconnectAll(): void;
+    /**
+     * Set gateway manager for all existing and future agents.
+     */
+    setGatewayManager(manager: GatewayManager): void;
+}
+export {};

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;