opc-agent 1.4.0 → 2.0.1

package/dist/channels/telegram.js

@@ -35,58 +35,105 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelegramChannel = void 0;
 const index_1 = require("./index");
-/**
- * Telegram channel — basic webhook handler for Telegram Bot API.
- * Set TELEGRAM_BOT_TOKEN env var or pass in config.
- */
 class TelegramChannel extends index_1.BaseChannel {
     type = 'telegram';
     token;
+    mode;
     webhookUrl;
-    server = null;
     port;
-    constructor(options = {}) {
+    // Polling state
+    offset = 0;
+    polling = false;
+    // Webhook state
+    server = null;
+    constructor(config = {}) {
         super();
-        this.token = options.token ?? process.env.TELEGRAM_BOT_TOKEN ?? '';
-        this.webhookUrl = options.webhookUrl;
-        this.port = options.port ?? 3001;
+        this.token = config.token ?? process.env.TELEGRAM_BOT_TOKEN ?? '';
+        this.mode = config.mode ?? 'polling';
+        this.webhookUrl = config.webhookUrl;
+        this.port = config.port ?? 3001;
     }
     async start() {
         if (!this.token) {
             console.warn('[TelegramChannel] No bot token provided. Set TELEGRAM_BOT_TOKEN or pass token in config.');
             return;
         }
+        if (this.mode === 'webhook') {
+            await this.startWebhook();
+        }
+        else {
+            await this.startPolling();
+        }
+    }
+    async stop() {
+        if (this.mode === 'webhook') {
+            await this.stopWebhook();
+        }
+        else {
+            this.polling = false;
+        }
+    }
+    // ─── Polling Mode ────────────────────────────────────────
+    async startPolling() {
+        // Delete any existing webhook so polling works
+        await this.apiCall('deleteWebhook');
+        console.log(`[TelegramChannel] Started long-polling mode`);
+        this.polling = true;
+        this.poll();
+    }
+    async poll() {
+        while (this.polling) {
+            try {
+                const updates = await this.getUpdates();
+                for (const update of updates) {
+                    await this.processUpdate(update);
+                }
+            }
+            catch (err) {
+                console.error('[TelegramChannel] Polling error:', err);
+                // Back off on error
+                if (this.polling) {
+                    await new Promise((r) => setTimeout(r, 5000));
+                }
+            }
+        }
+    }
+    async getUpdates() {
+        const url = `https://api.telegram.org/bot${this.token}/getUpdates?offset=${this.offset}&timeout=30&allowed_updates=["message"]`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 40000); // 30s long-poll + 10s buffer
+        try {
+            const res = await fetch(url, { signal: controller.signal });
+            const data = (await res.json());
+            if (data.ok && data.result.length > 0) {
+                this.offset = data.result[data.result.length - 1].update_id + 1;
+            }
+            return data.result || [];
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    // ─── Webhook Mode ────────────────────────────────────────
+    async startWebhook() {
+        if (this.webhookUrl) {
+            await this.apiCall('setWebhook', { url: `${this.webhookUrl}/webhook/${this.token}` });
+        }
         const express = (await Promise.resolve().then(() => __importStar(require('express')))).default;
         const app = express();
         app.use(express.json());
         app.post(`/webhook/${this.token}`, async (req, res) => {
             try {
-                const update = req.body;
-                if (update.message?.text && this.handler) {
-                    const msg = {
-                        id: `tg_${update.message.message_id}`,
-                        role: 'user',
-                        content: update.message.text,
-                        timestamp: update.message.date * 1000,
-                        metadata: {
-                            sessionId: `tg_${update.message.chat.id}`,
-                            chatId: update.message.chat.id,
-                            userId: update.message.from?.id,
-                            platform: 'telegram',
-                        },
-                    };
-                    const response = await this.handler(msg);
-                    await this.sendMessage(update.message.chat.id, response.content);
-                }
+                await this.processUpdate(req.body);
                 res.json({ ok: true });
             }
             catch (err) {
-                console.error('[TelegramChannel] Error handling update:', err);
+                console.error('[TelegramChannel] Webhook error:', err);
                 res.status(500).json({ error: 'Internal error' });
             }
         });
         app.get('/health', (_req, res) => {
-            res.json({ status: 'ok', channel: 'telegram' });
+            res.json({ status: 'ok', channel: 'telegram', mode: 'webhook' });
         });
         return new Promise((resolve) => {
             this.server = app.listen(this.port, () => {
@@ -95,25 +142,70 @@ class TelegramChannel extends index_1.BaseChannel {
             });
         });
     }
-    async stop() {
+    async stopWebhook() {
         return new Promise((resolve, reject) => {
             if (!this.server)
                 return resolve();
             this.server.close((err) => (err ? reject(err) : resolve()));
         });
     }
+    // ─── Shared ──────────────────────────────────────────────
+    async processUpdate(update) {
+        const message = update.message || update.edited_message;
+        if (!message?.text || !this.handler)
+            return;
+        const msg = {
+            id: `tg_${message.message_id}`,
+            role: 'user',
+            content: message.text,
+            timestamp: message.date * 1000,
+            metadata: {
+                sessionId: `tg_${message.chat.id}`,
+                chatId: message.chat.id,
+                userId: message.from?.id,
+                username: message.from?.username,
+                firstName: message.from?.first_name,
+                platform: 'telegram',
+                chatType: message.chat.type,
+            },
+        };
+        const response = await this.handler(msg);
+        await this.sendMessage(message.chat.id, response.content);
+    }
     async sendMessage(chatId, text) {
-        const url = `https://api.telegram.org/bot${this.token}/sendMessage`;
+        // Telegram max message length is 4096
+        const chunks = this.splitText(text, 4096);
+        for (const chunk of chunks) {
+            await this.apiCall('sendMessage', {
+                chat_id: chatId,
+                text: chunk,
+                parse_mode: 'Markdown',
+            });
+        }
+    }
+    async apiCall(method, body) {
+        const url = `https://api.telegram.org/bot${this.token}/${method}`;
         try {
-            await fetch(url, {
+            const res = await fetch(url, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ chat_id: chatId, text, parse_mode: 'Markdown' }),
+                body: body ? JSON.stringify(body) : undefined,
             });
+            return await res.json();
         }
         catch (err) {
-            console.error('[TelegramChannel] Failed to send message:', err);
+            console.error(`[TelegramChannel] API call ${method} failed:`, err);
+            throw err;
+        }
+    }
+    splitText(text, maxLen) {
+        if (text.length <= maxLen)
+            return [text];
+        const parts = [];
+        for (let i = 0; i < text.length; i += maxLen) {
+            parts.push(text.slice(i, i + maxLen));
         }
+        return parts;
     }
 }
 exports.TelegramChannel = TelegramChannel;

package/dist/channels/websocket.d.ts

@@ -1,15 +1,58 @@
 import { BaseChannel } from './index';
 /**
- * WebSocket channel — real-time bidirectional communication.
+ * WebSocket Channel — v1.1.0
+ *
+ * Enhanced with:
+ * - Room support (multiple clients in a room)
+ * - Heartbeat/ping-pong to detect disconnected clients
+ * - Reconnection handling (session persistence)
+ * - Binary message support
+ * - Connection authentication (optional token in query string)
  */
+export interface WebSocketChannelConfig {
+    port?: number;
+    /** Heartbeat interval in ms (default: 30000) */
+    heartbeatInterval?: number;
+    /** Valid auth tokens (if empty, no auth required) */
+    authTokens?: string[];
+    /** Max clients per room (default: 100) */
+    maxClientsPerRoom?: number;
+}
 export declare class WebSocketChannel extends BaseChannel {
     readonly type = "websocket";
     private wss;
-    private port;
+    private config;
     private clients;
-    constructor(port?: number);
+    private rooms;
+    private heartbeatTimer;
+    constructor(configOrPort?: number | WebSocketChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
+    /** Handle text (JSON) messages */
+    private handleTextMessage;
+    /** Handle binary messages */
+    private handleBinaryMessage;
+    /** Join a room */
+    joinRoom(sessionId: string, roomId: string): boolean;
+    /** Leave a room */
+    leaveRoom(sessionId: string, roomId: string): void;
+    /** Remove client completely */
+    private removeClient;
+    /** Get room member session IDs */
+    getRoomMembers(roomId: string): string[];
+    /** Get all rooms */
+    getRooms(): string[];
+    /** Broadcast to all clients */
     broadcast(content: string): void;
+    /** Broadcast to all clients in a room */
+    broadcastToRoom(roomId: string, data: any, excludeSessionId?: string): void;
+    /** Send to specific session */
+    sendToSession(sessionId: string, data: any): boolean;
+    /** Get connection stats */
+    getStats(): {
+        clients: number;
+        rooms: number;
+        roomDetails: Record<string, number>;
+    };
 }
 //# sourceMappingURL=websocket.d.ts.map

package/dist/channels/websocket.js

@@ -3,79 +3,348 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketChannel = void 0;
 const index_1 = require("./index");
 const ws_1 = require("ws");
-/**
- * WebSocket channel — real-time bidirectional communication.
- */
 class WebSocketChannel extends index_1.BaseChannel {
     type = 'websocket';
     wss = null;
-    port;
-    clients = new Set();
-    constructor(port = 3002) {
+    config;
+    clients = new Map(); // sessionId -> ClientInfo
+    rooms = new Map(); // roomId -> Set<sessionId>
+    heartbeatTimer = null;
+    constructor(configOrPort = 3002) {
         super();
-        this.port = port;
+        if (typeof configOrPort === 'number') {
+            this.config = { port: configOrPort, heartbeatInterval: 30000, authTokens: [], maxClientsPerRoom: 100 };
+        }
+        else {
+            this.config = {
+                port: configOrPort.port ?? 3002,
+                heartbeatInterval: configOrPort.heartbeatInterval ?? 30000,
+                authTokens: configOrPort.authTokens ?? [],
+                maxClientsPerRoom: configOrPort.maxClientsPerRoom ?? 100,
+            };
+        }
     }
     async start() {
         return new Promise((resolve) => {
-            this.wss = new ws_1.WebSocketServer({ port: this.port });
-            this.wss.on('connection', (ws) => {
-                this.clients.add(ws);
-                ws.on('message', async (data) => {
-                    if (!this.handler)
+            this.wss = new ws_1.WebSocketServer({ port: this.config.port });
+            this.wss.on('connection', (ws, req) => {
+                const url = new URL(req.url ?? '/', `http://localhost:${this.config.port}`);
+                const token = url.searchParams.get('token');
+                const sessionId = url.searchParams.get('sessionId') ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                // Authentication check
+                if (this.config.authTokens.length > 0) {
+                    if (!token || !this.config.authTokens.includes(token)) {
+                        ws.close(4001, 'Unauthorized');
                         return;
+                    }
+                }
+                // Handle reconnection: if sessionId already exists, replace the connection
+                const existing = this.clients.get(sessionId);
+                if (existing) {
+                    try {
+                        existing.ws.close(4000, 'Replaced by new connection');
+                    }
+                    catch { }
+                }
+                const clientInfo = {
+                    ws,
+                    sessionId,
+                    rooms: existing?.rooms ?? new Set(),
+                    isAlive: true,
+                    authenticated: true,
+                    connectedAt: Date.now(),
+                    lastMessageAt: Date.now(),
+                };
+                this.clients.set(sessionId, clientInfo);
+                // Re-register in rooms after reconnect
+                for (const roomId of clientInfo.rooms) {
+                    const room = this.rooms.get(roomId);
+                    if (room)
+                        room.add(sessionId);
+                }
+                ws.on('pong', () => {
+                    clientInfo.isAlive = true;
+                });
+                ws.on('message', async (data, isBinary) => {
+                    clientInfo.lastMessageAt = Date.now();
+                    clientInfo.isAlive = true;
+                    if (isBinary) {
+                        await this.handleBinaryMessage(clientInfo, data);
+                        return;
+                    }
                     try {
                         const parsed = JSON.parse(data.toString());
-                        const msg = {
-                            id: parsed.id ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-                            role: 'user',
-                            content: parsed.content ?? parsed.message ?? data.toString(),
-                            timestamp: Date.now(),
-                            metadata: {
-                                sessionId: parsed.sessionId ?? 'ws-default',
-                                platform: 'websocket',
-                            },
-                        };
-                        const response = await this.handler(msg);
-                        ws.send(JSON.stringify({
-                            id: response.id,
-                            content: response.content,
-                            timestamp: response.timestamp,
-                        }));
+                        await this.handleTextMessage(clientInfo, parsed);
                     }
-                    catch (err) {
+                    catch {
                         ws.send(JSON.stringify({ error: 'Invalid message format' }));
                     }
                 });
                 ws.on('close', () => {
-                    this.clients.delete(ws);
+                    // Don't immediately remove - allow reconnection window
+                    const info = this.clients.get(sessionId);
+                    if (info && info.ws === ws) {
+                        // Mark as disconnected but keep for potential reconnection
+                        setTimeout(() => {
+                            const current = this.clients.get(sessionId);
+                            if (current && current.ws === ws) {
+                                this.removeClient(sessionId);
+                            }
+                        }, 60000); // 60s reconnection window
+                    }
                 });
-                ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+                ws.send(JSON.stringify({
+                    type: 'connected',
+                    sessionId,
+                    timestamp: Date.now(),
+                }));
             });
+            // Start heartbeat
+            this.heartbeatTimer = setInterval(() => {
+                for (const [sessionId, info] of this.clients) {
+                    if (!info.isAlive) {
+                        try {
+                            info.ws.terminate();
+                        }
+                        catch { }
+                        this.removeClient(sessionId);
+                        continue;
+                    }
+                    info.isAlive = false;
+                    try {
+                        info.ws.ping();
+                    }
+                    catch { }
+                }
+            }, this.config.heartbeatInterval);
             this.wss.on('listening', () => {
-                console.log(`[WebSocketChannel] Listening on port ${this.port}`);
+                console.log(`[WebSocketChannel] Listening on port ${this.config.port}`);
                 resolve();
             });
         });
     }
     async stop() {
-        for (const client of this.clients) {
-            client.close();
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        for (const [, info] of this.clients) {
+            try {
+                info.ws.close();
+            }
+            catch { }
         }
         this.clients.clear();
+        this.rooms.clear();
         return new Promise((resolve, reject) => {
             if (!this.wss)
                 return resolve();
             this.wss.close((err) => (err ? reject(err) : resolve()));
         });
     }
+    /** Handle text (JSON) messages */
+    async handleTextMessage(client, parsed) {
+        const type = parsed.type ?? 'message';
+        switch (type) {
+            case 'join': {
+                const roomId = parsed.room;
+                if (!roomId) {
+                    client.ws.send(JSON.stringify({ error: 'room is required for join' }));
+                    return;
+                }
+                this.joinRoom(client.sessionId, roomId);
+                client.ws.send(JSON.stringify({ type: 'joined', room: roomId, members: this.getRoomMembers(roomId).length }));
+                return;
+            }
+            case 'leave': {
+                const roomId = parsed.room;
+                if (roomId) {
+                    this.leaveRoom(client.sessionId, roomId);
+                    client.ws.send(JSON.stringify({ type: 'left', room: roomId }));
+                }
+                return;
+            }
+            case 'room_message': {
+                const roomId = parsed.room;
+                const content = parsed.content ?? parsed.message;
+                if (roomId && content) {
+                    this.broadcastToRoom(roomId, {
+                        type: 'room_message',
+                        room: roomId,
+                        from: client.sessionId,
+                        content,
+                        timestamp: Date.now(),
+                    }, client.sessionId);
+                }
+                return;
+            }
+            case 'ping': {
+                client.ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
+                return;
+            }
+            default: {
+                // Regular chat message
+                if (!this.handler)
+                    return;
+                const msg = {
+                    id: parsed.id ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    role: 'user',
+                    content: parsed.content ?? parsed.message ?? JSON.stringify(parsed),
+                    timestamp: Date.now(),
+                    metadata: {
+                        sessionId: client.sessionId,
+                        platform: 'websocket',
+                        room: parsed.room,
+                    },
+                };
+                const response = await this.handler(msg);
+                client.ws.send(JSON.stringify({
+                    id: response.id,
+                    content: response.content,
+                    timestamp: response.timestamp,
+                }));
+            }
+        }
+    }
+    /** Handle binary messages */
+    async handleBinaryMessage(client, data) {
+        // Emit binary data with metadata
+        client.ws.send(JSON.stringify({
+            type: 'binary_ack',
+            size: data.length,
+            timestamp: Date.now(),
+        }));
+        // If handler exists, pass as base64
+        if (this.handler) {
+            const msg = {
+                id: `ws_bin_${Date.now()}`,
+                role: 'user',
+                content: `[binary:${data.length} bytes]`,
+                timestamp: Date.now(),
+                metadata: {
+                    sessionId: client.sessionId,
+                    platform: 'websocket',
+                    binary: true,
+                    binaryData: data.toString('base64'),
+                },
+            };
+            const response = await this.handler(msg);
+            client.ws.send(JSON.stringify({
+                id: response.id,
+                content: response.content,
+                timestamp: response.timestamp,
+            }));
+        }
+    }
+    /** Join a room */
+    joinRoom(sessionId, roomId) {
+        const client = this.clients.get(sessionId);
+        if (!client)
+            return false;
+        if (!this.rooms.has(roomId)) {
+            this.rooms.set(roomId, new Set());
+        }
+        const room = this.rooms.get(roomId);
+        if (room.size >= this.config.maxClientsPerRoom) {
+            client.ws.send(JSON.stringify({ error: 'Room is full', room: roomId }));
+            return false;
+        }
+        room.add(sessionId);
+        client.rooms.add(roomId);
+        // Notify other room members
+        this.broadcastToRoom(roomId, {
+            type: 'member_joined',
+            room: roomId,
+            sessionId,
+            members: room.size,
+            timestamp: Date.now(),
+        }, sessionId);
+        return true;
+    }
+    /** Leave a room */
+    leaveRoom(sessionId, roomId) {
+        const client = this.clients.get(sessionId);
+        if (client)
+            client.rooms.delete(roomId);
+        const room = this.rooms.get(roomId);
+        if (room) {
+            room.delete(sessionId);
+            if (room.size === 0) {
+                this.rooms.delete(roomId);
+            }
+            else {
+                this.broadcastToRoom(roomId, {
+                    type: 'member_left',
+                    room: roomId,
+                    sessionId,
+                    members: room.size,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    /** Remove client completely */
+    removeClient(sessionId) {
+        const client = this.clients.get(sessionId);
+        if (!client)
+            return;
+        for (const roomId of client.rooms) {
+            this.leaveRoom(sessionId, roomId);
+        }
+        this.clients.delete(sessionId);
+    }
+    /** Get room member session IDs */
+    getRoomMembers(roomId) {
+        return [...(this.rooms.get(roomId) ?? [])];
+    }
+    /** Get all rooms */
+    getRooms() {
+        return [...this.rooms.keys()];
+    }
+    /** Broadcast to all clients */
     broadcast(content) {
         const msg = JSON.stringify({ type: 'broadcast', content, timestamp: Date.now() });
-        for (const client of this.clients) {
-            if (client.readyState === 1) { // OPEN
-                client.send(msg);
+        for (const [, info] of this.clients) {
+            if (info.ws.readyState === 1) {
+                info.ws.send(msg);
+            }
+        }
+    }
+    /** Broadcast to all clients in a room */
+    broadcastToRoom(roomId, data, excludeSessionId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            return;
+        const msg = typeof data === 'string' ? data : JSON.stringify(data);
+        for (const sessionId of room) {
+            if (sessionId === excludeSessionId)
+                continue;
+            const client = this.clients.get(sessionId);
+            if (client && client.ws.readyState === 1) {
+                client.ws.send(msg);
             }
         }
     }
+    /** Send to specific session */
+    sendToSession(sessionId, data) {
+        const client = this.clients.get(sessionId);
+        if (!client || client.ws.readyState !== 1)
+            return false;
+        client.ws.send(typeof data === 'string' ? data : JSON.stringify(data));
+        return true;
+    }
+    /** Get connection stats */
+    getStats() {
+        const roomDetails = {};
+        for (const [roomId, members] of this.rooms) {
+            roomDetails[roomId] = members.size;
+        }
+        return {
+            clients: this.clients.size,
+            rooms: this.rooms.size,
+            roomDetails,
+        };
+    }
 }
 exports.WebSocketChannel = WebSocketChannel;
 //# sourceMappingURL=websocket.js.map