hermes-web-ui 0.3.6 → 0.3.8

package/dist/server/routes/hermes/group-chat.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupChatRoutes = void 0;
+const router_1 = __importDefault(require("@koa/router"));
+const roomsDb = __importStar(require("../../services/group-chat/rooms-db"));
+exports.groupChatRoutes = new router_1.default();
+// ---------------------------------------------------------------------------
+// Rooms
+// ---------------------------------------------------------------------------
+exports.groupChatRoutes.get('/api/hermes/group-chat/rooms', async (ctx) => {
+    const rooms = roomsDb.listRooms();
+    ctx.body = { rooms };
+});
+exports.groupChatRoutes.post('/api/hermes/group-chat/rooms', async (ctx) => {
+    const { name } = ctx.request.body;
+    if (!name?.trim()) {
+        ctx.status = 400;
+        ctx.body = { error: 'name is required' };
+        return;
+    }
+    const room = roomsDb.createRoom(name.trim());
+    ctx.body = { room };
+});
+exports.groupChatRoutes.get('/api/hermes/group-chat/rooms/:roomId', async (ctx) => {
+    const { roomId } = ctx.params;
+    const room = roomsDb.getRoom(roomId);
+    if (!room) {
+        ctx.status = 404;
+        ctx.body = { error: 'Room not found' };
+        return;
+    }
+    const agents = roomsDb.getRoomAgents(roomId);
+    ctx.body = { room, agents };
+});
+exports.groupChatRoutes.put('/api/hermes/group-chat/rooms/:roomId', async (ctx) => {
+    const { roomId } = ctx.params;
+    const { name, settings } = ctx.request.body;
+    const updated = roomsDb.updateRoom(roomId, { name, settings });
+    if (!updated) {
+        ctx.status = 404;
+        ctx.body = { error: 'Room not found' };
+        return;
+    }
+    ctx.body = { success: true };
+});
+exports.groupChatRoutes.delete('/api/hermes/group-chat/rooms/:roomId', async (ctx) => {
+    const { roomId } = ctx.params;
+    roomsDb.deleteRoom(roomId);
+    ctx.body = { success: true };
+});
+// ---------------------------------------------------------------------------
+// Agents
+// ---------------------------------------------------------------------------
+exports.groupChatRoutes.get('/api/hermes/group-chat/rooms/:roomId/agents', async (ctx) => {
+    const { roomId } = ctx.params;
+    const agents = roomsDb.getRoomAgents(roomId);
+    ctx.body = { agents };
+});
+exports.groupChatRoutes.post('/api/hermes/group-chat/rooms/:roomId/agents', async (ctx) => {
+    const { roomId } = ctx.params;
+    const { agent_name, profile, role_prompt } = ctx.request.body;
+    if (!agent_name?.trim() || !profile?.trim()) {
+        ctx.status = 400;
+        ctx.body = { error: 'agent_name and profile are required' };
+        return;
+    }
+    // Validate agent_name only contains word characters
+    if (!/^\w+$/.test(agent_name.trim())) {
+        ctx.status = 400;
+        ctx.body = { error: 'agent_name must only contain letters, numbers, and underscores' };
+        return;
+    }
+    const agent = roomsDb.addRoomAgent(roomId, {
+        agent_name: agent_name.trim(),
+        profile: profile.trim(),
+        role_prompt,
+    });
+    if (!agent) {
+        ctx.status = 409;
+        ctx.body = { error: 'Agent already exists in this room' };
+        return;
+    }
+    ctx.body = { agent };
+});
+exports.groupChatRoutes.delete('/api/hermes/group-chat/rooms/:roomId/agents/:agentName', async (ctx) => {
+    const { roomId, agentName } = ctx.params;
+    roomsDb.removeRoomAgent(roomId, agentName);
+    ctx.body = { success: true };
+});
+// ---------------------------------------------------------------------------
+// Messages
+// ---------------------------------------------------------------------------
+exports.groupChatRoutes.get('/api/hermes/group-chat/rooms/:roomId/messages', async (ctx) => {
+    const { roomId } = ctx.params;
+    const limit = parseInt(ctx.query.limit) || 100;
+    const offset = parseInt(ctx.query.offset) || 0;
+    const messages = roomsDb.getRoomMessages(roomId, limit, offset);
+    ctx.body = { messages };
+});

package/dist/server/routes/hermes/logs.js

@@ -38,28 +38,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logRoutes = void 0;
 const router_1 = __importDefault(require("@koa/router"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
 const hermesCli = __importStar(require("../../services/hermes/hermes-cli"));
 exports.logRoutes = new router_1.default();
+const WEBUI_LOG_FILE = (0, path_1.join)((0, os_1.homedir)(), '.hermes-web-ui', 'server.log');
 // List available log files
 exports.logRoutes.get('/api/hermes/logs', async (ctx) => {
     const files = await hermesCli.listLogFiles();
+    if ((0, fs_1.existsSync)(WEBUI_LOG_FILE)) {
+        try {
+            const stat = (0, fs_1.statSync)(WEBUI_LOG_FILE);
+            const size = stat.size > 1024 * 1024
+                ? `${(stat.size / 1024 / 1024).toFixed(1)}MB`
+                : `${(stat.size / 1024).toFixed(1)}KB`;
+            const modified = stat.mtime.toLocaleString();
+            files.push({ name: 'webui', size, modified });
+        }
+        catch { }
+    }
     ctx.body = { files };
 });
 // Parse a single log line into structured entry
 function parseLine(line) {
-    // Match: 2026-04-11 20:16:16,289 INFO aiohttp.access: message
-    const match = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\s+(DEBUG|INFO|WARNING|ERROR|CRITICAL)\s+(\S+?):\s(.*)$/);
+    // Match: 2026-04-11 20:16:16,289 INFO aiohttp.access: message (agent log format)
+    let match = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\s+(DEBUG|INFO|WARNING|ERROR|CRITICAL)\s+(\S+?):\s(.*)$/);
     if (match) {
-        return {
-            timestamp: match[1],
-            level: match[2],
-            logger: match[3],
-            message: match[4],
-            raw: line,
-        };
+        return { timestamp: match[1], level: match[2], logger: match[3], message: match[4], raw: line };
+    }
+    // Match: [Lark] [2026-04-19 18:46:54,864] [INFO] message (gateway log format)
+    match = line.match(/^\[(\S+?)\]\s+\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\]\s+\[(DEBUG|INFO|WARNING|ERROR|CRITICAL)\]\s(.*)$/);
+    if (match) {
+        return { timestamp: match[2], level: match[3], logger: match[1], message: match[4], raw: line };
     }
-    // Unparseable line (e.g. traceback continuation)
-    return null;
+    // Unparseable line — keep as raw entry so nothing is lost
+    return { timestamp: '', level: '', logger: '', message: line, raw: line };
 }
 // Read log lines (parsed)
 exports.logRoutes.get('/api/hermes/logs/:name', async (ctx) => {
@@ -68,6 +83,30 @@ exports.logRoutes.get('/api/hermes/logs/:name', async (ctx) => {
     const level = ctx.query.level || undefined;
     const session = ctx.query.session || undefined;
     const since = ctx.query.since || undefined;
+    // Handle hermes-web-ui's own server log
+    if (logName === 'webui') {
+        try {
+            if (!(0, fs_1.existsSync)(WEBUI_LOG_FILE)) {
+                ctx.body = { entries: [] };
+                return;
+            }
+            const content = await (0, promises_1.readFile)(WEBUI_LOG_FILE, 'utf-8');
+            const rawLines = content.split('\n');
+            const sliced = rawLines.length > lines ? rawLines.slice(-lines) : rawLines;
+            const entries = [];
+            for (const line of sliced) {
+                if (!line.trim())
+                    continue;
+                entries.push(parseLine(line));
+            }
+            ctx.body = { entries };
+        }
+        catch (err) {
+            ctx.status = 500;
+            ctx.body = { error: err.message };
+        }
+        return;
+    }
     try {
         const content = await hermesCli.readLogs(logName, lines, level, session, since);
         const rawLines = content.split('\n');

package/dist/server/routes/hermes/proxy-handler.js

@@ -27,22 +27,24 @@ async function waitForGatewayReady(upstream, timeoutMs = 5000) {
     }
     return false;
 }
+/** Resolve profile name from request */
+function resolveProfile(ctx) {
+    return ctx.get('x-hermes-profile') || ctx.query.profile || 'default';
+}
 /** Resolve upstream URL for a request based on profile header/query */
 function resolveUpstream(ctx) {
     const mgr = (0, gateways_1.getGatewayManager)();
     if (mgr) {
-        // Check X-Hermes-Profile header or ?profile= query param
-        const profile = ctx.get('x-hermes-profile') || ctx.query.profile;
-        if (profile) {
+        const profile = resolveProfile(ctx);
+        if (profile && profile !== 'default') {
             return mgr.getUpstream(profile);
         }
-        // Default to active profile's upstream
         return mgr.getUpstream();
     }
-    // Fallback: static upstream from config
     return config_1.config.upstream.replace(/\/$/, '');
 }
 async function proxy(ctx) {
+    const profile = resolveProfile(ctx);
     const upstream = resolveUpstream(ctx);
     // Rewrite path for upstream gateway:
     //   /api/hermes/v1/* -> /v1/*  (upstream uses /v1/ prefix)
@@ -58,7 +60,7 @@ async function proxy(ctx) {
         if (lower === 'host') {
             headers['host'] = new URL(upstream).host;
         }
-        else if (lower === 'authorization' || lower === 'origin' || lower === 'referer' || lower === 'connection') {
+        else if (lower === 'origin' || lower === 'referer' || lower === 'connection') {
             continue;
         }
         else {
@@ -67,6 +69,14 @@ async function proxy(ctx) {
                 headers[key] = v;
         }
     }
+    // Inject Hermes gateway API key from profile's .env
+    const mgr = (0, gateways_1.getGatewayManager)();
+    if (mgr) {
+        const apiKey = mgr.getApiKey(profile);
+        if (apiKey) {
+            headers['authorization'] = `Bearer ${apiKey}`;
+        }
+    }
     try {
         // Build request body from raw body
         let body;

package/dist/server/routes/upload.js

@@ -23,28 +23,58 @@ exports.uploadRoutes.post('/upload', async (ctx) => {
         return;
     }
     await (0, promises_1.mkdir)(config_1.config.uploadDir, { recursive: true });
-    // Read raw body
+    // Read raw body as Buffer
     const chunks = [];
     for await (const chunk of ctx.req)
         chunks.push(chunk);
-    const body = Buffer.concat(chunks).toString('latin1');
-    const parts = body.split(boundary).slice(1, -1);
+    const raw = Buffer.concat(chunks);
+    const boundaryBuf = Buffer.from(boundary);
+    const parts = splitMultipart(raw, boundaryBuf);
     const results = [];
     for (const part of parts) {
-        const headerEnd = part.indexOf('\r\n\r\n');
+        const headerEnd = part.indexOf(Buffer.from('\r\n\r\n'));
         if (headerEnd === -1)
             continue;
-        const header = part.substring(0, headerEnd);
-        const data = part.substring(headerEnd + 4, part.length - 2);
-        const filenameMatch = header.match(/filename="([^"]+)"/);
-        if (!filenameMatch)
-            continue;
-        const filename = filenameMatch[1];
+        const headerBuf = part.subarray(0, headerEnd);
+        const header = headerBuf.toString('utf-8');
+        const data = part.subarray(headerEnd + 4, part.length - 2);
+        // Try RFC 5987 filename* first, fall back to filename
+        let filename = '';
+        const filenameStarMatch = header.match(/filename\*=UTF-8''(.+)/i);
+        if (filenameStarMatch) {
+            filename = decodeURIComponent(filenameStarMatch[1]);
+        }
+        else {
+            const filenameMatch = header.match(/filename="([^"]+)"/);
+            if (!filenameMatch)
+                continue;
+            filename = filenameMatch[1];
+        }
         const ext = filename.includes('.') ? '.' + filename.split('.').pop() : '';
         const savedName = (0, crypto_1.randomBytes)(8).toString('hex') + ext;
         const savedPath = `${config_1.config.uploadDir}/${savedName}`;
-        await (0, promises_1.writeFile)(savedPath, Buffer.from(data, 'binary'));
+        await (0, promises_1.writeFile)(savedPath, data);
         results.push({ name: filename, path: savedPath });
     }
     ctx.body = { files: results };
 });
+/**
+ * Split a multipart Buffer by boundary, returning part Buffers.
+ * Avoids string decoding so multi-byte characters (e.g. Chinese filenames) are preserved.
+ */
+function splitMultipart(raw, boundary) {
+    const parts = [];
+    let start = 0;
+    while (true) {
+        const idx = raw.indexOf(boundary, start);
+        if (idx === -1)
+            break;
+        if (start > 0) {
+            // Skip the \r\n after boundary
+            const partStart = start + 2;
+            parts.push(raw.subarray(partStart, idx));
+        }
+        start = idx + boundary.length;
+    }
+    return parts;
+}

package/dist/server/services/group-chat/coordinator.d.ts

@@ -0,0 +1,14 @@
+import * as roomsDb from './rooms-db';
+export type AgentStatus = 'thinking' | 'responding' | 'done' | 'error';
+export interface CoordinatorCallbacks {
+    onDelta: (roomId: string, agentName: string, text: string) => void;
+    onAgentStatus: (roomId: string, agentName: string, status: AgentStatus) => void;
+    onAgentComplete: (roomId: string, agentName: string, message: roomsDb.RoomMessage) => void;
+    onAgentError: (roomId: string, agentName: string, error: string) => void;
+}
+export declare function parseMentions(text: string): string[];
+export declare function buildAgentContext(roomId: string, agentName: string, agents: roomsDb.RoomAgent[], maxMessages?: number): Array<{
+    role: string;
+    content: string;
+}>;
+export declare function processMessage(roomId: string, content: string, callbacks: CoordinatorCallbacks): Promise<void>;

package/dist/server/services/group-chat/coordinator.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMentions = parseMentions;
+exports.buildAgentContext = buildAgentContext;
+exports.processMessage = processMessage;
+const roomsDb = __importStar(require("./rooms-db"));
+const gateways_1 = require("../../routes/hermes/gateways");
+// ---------------------------------------------------------------------------
+// @mention parsing
+// ---------------------------------------------------------------------------
+function parseMentions(text) {
+    const pattern = /@(\w+)/g;
+    const mentions = [];
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        mentions.push(match[1]);
+    }
+    return [...new Set(mentions)];
+}
+// ---------------------------------------------------------------------------
+// Context building
+// ---------------------------------------------------------------------------
+function buildAgentContext(roomId, agentName, agents, maxMessages = 20) {
+    const recentMessages = roomsDb.getRecentContext(roomId, agentName, maxMessages);
+    const context = [];
+    // Add role prompt
+    const agent = agents.find((a) => a.agent_name === agentName);
+    if (agent?.role_prompt) {
+        context.push({ role: 'system', content: agent.role_prompt });
+    }
+    else {
+        context.push({
+            role: 'system',
+            content: `You are ${agentName}, participating in a group chat. Respond concisely. You can see messages where you were @mentioned and public messages (no @mentions).`,
+        });
+    }
+    // Convert recent messages (DESC from DB → reverse to ASC chronological)
+    for (const msg of recentMessages.reverse()) {
+        if (msg.role === 'user') {
+            context.push({ role: 'user', content: msg.content });
+        }
+        else if (msg.role === 'assistant' && msg.agent_name) {
+            context.push({ role: 'assistant', content: `[${msg.agent_name}] ${msg.content}` });
+        }
+    }
+    return context;
+}
+// ---------------------------------------------------------------------------
+// Main: process a user message
+// ---------------------------------------------------------------------------
+async function processMessage(roomId, content, callbacks) {
+    const mentions = parseMentions(content);
+    const agents = roomsDb.getRoomAgents(roomId);
+    if (agents.length === 0)
+        return;
+    // Determine responding agents
+    const respondingAgents = mentions.length > 0
+        ? agents.filter((a) => mentions.includes(a.agent_name))
+        : agents;
+    if (respondingAgents.length === 0)
+        return;
+    // Store user message
+    const round = roomsDb.getLatestRound(roomId);
+    roomsDb.addMessage({
+        room_id: roomId,
+        role: 'user',
+        content,
+        mentions,
+        round,
+    });
+    // Fan out to agents in parallel
+    const tasks = respondingAgents.map((agent) => invokeAgent(roomId, agent, round, content, callbacks).catch(() => { }));
+    await Promise.allSettled(tasks);
+}
+// ---------------------------------------------------------------------------
+// Invoke a single agent
+// ---------------------------------------------------------------------------
+async function invokeAgent(roomId, agent, round, userMessage, callbacks) {
+    const agentName = agent.agent_name;
+    let upstream = '';
+    let apiKey = null;
+    try {
+        callbacks.onAgentStatus(roomId, agentName, 'thinking');
+        // Resolve gateway URL and API key for this agent's profile
+        const manager = (0, gateways_1.getGatewayManager)();
+        if (!manager)
+            throw new Error('GatewayManager not initialized');
+        upstream = manager.getUpstream(agent.profile);
+        apiKey = manager.getApiKey(agent.profile);
+        // Build conversation context
+        const agents = roomsDb.getRoomAgents(roomId);
+        const context = buildAgentContext(roomId, agentName, agents);
+        // Start run via Hermes API Server
+        const headers = { 'Content-Type': 'application/json' };
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        const body = { input: userMessage };
+        if (context.length > 0)
+            body.conversation_history = context;
+        if (agent.session_id)
+            body.session_id = agent.session_id;
+        const runRes = await fetch(`${upstream}/v1/runs`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(120_000),
+        });
+        if (!runRes.ok) {
+            const errText = await runRes.text();
+            throw new Error(`Hermes API error ${runRes.status}: ${errText.slice(0, 200)}`);
+        }
+        const runData = await runRes.json();
+        const runId = runData.run_id || runData.id;
+        if (!runId)
+            throw new Error('No run_id returned from Hermes API');
+        // Persist session_id for subsequent messages
+        if (runData.session_id && runData.session_id !== agent.session_id) {
+            roomsDb.updateRoomAgentSession(roomId, agentName, runData.session_id);
+        }
+        callbacks.onAgentStatus(roomId, agentName, 'responding');
+        // Stream SSE events
+        const sseHeaders = {};
+        if (apiKey)
+            sseHeaders['Authorization'] = `Bearer ${apiKey}`;
+        const sseRes = await fetch(`${upstream}/v1/runs/${runId}/events`, {
+            headers: sseHeaders,
+            signal: AbortSignal.timeout(300_000),
+        });
+        if (!sseRes.ok || !sseRes.body) {
+            throw new Error(`Failed to stream events: ${sseRes.status}`);
+        }
+        let fullContent = '';
+        const reader = sseRes.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (data === '[DONE]')
+                        continue;
+                    try {
+                        const event = JSON.parse(data);
+                        if (event.event === 'message.delta' && event.delta) {
+                            fullContent += event.delta;
+                            callbacks.onDelta(roomId, agentName, event.delta);
+                        }
+                        if (event.event === 'run.completed' || event.event === 'run.failed') {
+                            // If delta contained in completed event
+                            if (event.event === 'run.completed' && event.response) {
+                                fullContent = event.response;
+                            }
+                        }
+                    }
+                    catch {
+                        // skip malformed JSON
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (!fullContent)
+            fullContent = '(no response)';
+        // Store completed response
+        const msg = roomsDb.addMessage({
+            room_id: roomId,
+            role: 'assistant',
+            agent_name: agentName,
+            content: fullContent,
+            round,
+        });
+        callbacks.onAgentStatus(roomId, agentName, 'done');
+        callbacks.onAgentComplete(roomId, agentName, msg);
+    }
+    catch (err) {
+        const errorMsg = err?.message || 'Unknown error';
+        callbacks.onAgentStatus(roomId, agentName, 'error');
+        callbacks.onAgentError(roomId, agentName, errorMsg);
+        roomsDb.addMessage({
+            room_id: roomId,
+            role: 'system',
+            agent_name: agentName,
+            content: `Error: ${errorMsg}`,
+            round,
+        });
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Server as SocketIOServer } from 'socket.io';
+import type { Server as HttpServer } from 'http';
+export declare function setupGroupChatSocketIO(httpServer: HttpServer): SocketIOServer;
+export declare function getGroupChatIO(): SocketIOServer | null;
+export declare function disconnectGroupChatIO(): void;