opc-agent 2.0.0 → 2.0.1

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

package/dist/channels/wechat.d.ts

@@ -1,7 +1,14 @@
 import { BaseChannel } from './index';
 /**
- * WeChat Channel (Stub) — v0.8.0
- * WeChat Official Account message handling, template messages, QR code login.
+ * WeChat Official Account Channel — v1.0.0
+ *
+ * Handles:
+ * - GET verification (signature/timestamp/nonce/echostr)
+ * - POST XML message parsing and reply
+ * - Customer Service Message API for async replies
+ * - Access token management with caching
+ * - Template messages
+ * - Subscribe/unsubscribe events
  */
 export interface WeChatChannelConfig {
     /** WeChat Official Account AppID */
@@ -10,9 +17,9 @@ export interface WeChatChannelConfig {
     appSecret: string;
     /** Verification token for message validation */
     token: string;
-    /** AES encoding key for encrypted messages */
+    /** AES encoding key for encrypted messages (optional) */
     encodingAESKey?: string;
-    /** HTTP server port (default: 3002) */
+    /** HTTP server port (default: 8080) */
     port?: number;
 }
 export interface WeChatMessage {
@@ -39,24 +46,37 @@ export declare class WeChatChannel extends BaseChannel {
     private config;
     private accessToken;
     private tokenExpiry;
+    private server;
     constructor(config: WeChatChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
-    /** Get or refresh access token */
-    getAccessToken(): Promise<string>;
+    /** Verify WeChat signature for GET requests */
+    private handleVerification;
+    /** Handle incoming POST messages (XML) */
+    private handleIncoming;
+    /** Verify WeChat signature */
+    verifySignature(signature: string, timestamp: string, nonce: string): boolean;
+    /** Parse WeChat XML message using regex */
+    static parseXML(xml: string): WeChatMessage | null;
+    /** Format response as WeChat XML */
+    static formatXMLResponse(toUser: string, fromUser: string, content: string): string;
     /** Handle incoming WeChat message */
     handleMessage(wxMsg: WeChatMessage): Promise<string>;
-    /** Handle WeChat events (subscribe, scan, etc.) */
+    /** Handle WeChat events */
     private handleEvent;
     /** Convert WeChat message to internal Message */
     private wechatToMessage;
+    /** Get or refresh access token */
+    getAccessToken(): Promise<string>;
+    /** Send customer service message */
+    sendMessage(openId: string, text: string): Promise<void>;
     /** Send template message */
     sendTemplateMessage(data: TemplateMessageData): Promise<boolean>;
-    /** Generate QR code for login (stub) */
-    generateLoginQR(): Promise<{
-        ticket: string;
-        url: string;
-        expireSeconds: number;
-    }>;
+    /** Read request body */
+    private readBody;
+    /** Simple HTTPS GET */
+    private httpsGet;
+    /** Simple HTTPS POST */
+    private httpsPost;
 }
 //# sourceMappingURL=wechat.d.ts.map