opc-agent 1.4.0 → 2.0.1

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

package/dist/channels/wechat.js

@@ -1,37 +1,167 @@
 "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.WeChatChannel = void 0;
 const index_1 = require("./index");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const crypto = __importStar(require("crypto"));
 class WeChatChannel extends index_1.BaseChannel {
     type = 'wechat';
     config;
     accessToken = null;
     tokenExpiry = 0;
+    server = null;
     constructor(config) {
         super();
         this.config = config;
     }
     async start() {
-        // TODO: Start HTTP server to receive WeChat push messages
-        // 1. Verify signature on GET requests
-        // 2. Parse XML messages on POST requests
-        // 3. Route to handler and reply with XML
+        const port = this.config.port ?? 8080;
+        this.server = http.createServer(async (req, res) => {
+            try {
+                if (req.method === 'GET') {
+                    await this.handleVerification(req, res);
+                }
+                else if (req.method === 'POST') {
+                    await this.handleIncoming(req, res);
+                }
+                else {
+                    res.writeHead(405);
+                    res.end('Method Not Allowed');
+                }
+            }
+            catch (err) {
+                console.error('[WeChatChannel] Error:', err);
+                res.writeHead(500);
+                res.end('Internal Server Error');
+            }
+        });
+        return new Promise((resolve) => {
+            this.server.listen(port, () => {
+                console.log(`[WeChatChannel] Listening on port ${port}`);
+                resolve();
+            });
+        });
     }
     async stop() {
-        // TODO: Stop HTTP server
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                return resolve();
+            this.server.close((err) => (err ? reject(err) : resolve()));
+        });
     }
-    /** Get or refresh access token */
-    async getAccessToken() {
-        if (this.accessToken && Date.now() < this.tokenExpiry) {
-            return this.accessToken;
+    /** Verify WeChat signature for GET requests */
+    async handleVerification(req, res) {
+        const url = new URL(req.url ?? '/', `http://localhost`);
+        const signature = url.searchParams.get('signature') ?? '';
+        const timestamp = url.searchParams.get('timestamp') ?? '';
+        const nonce = url.searchParams.get('nonce') ?? '';
+        const echostr = url.searchParams.get('echostr') ?? '';
+        if (this.verifySignature(signature, timestamp, nonce)) {
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end(echostr);
+        }
+        else {
+            res.writeHead(403);
+            res.end('Invalid signature');
+        }
+    }
+    /** Handle incoming POST messages (XML) */
+    async handleIncoming(req, res) {
+        const body = await this.readBody(req);
+        const wxMsg = WeChatChannel.parseXML(body);
+        if (!wxMsg) {
+            res.writeHead(400);
+            res.end('Bad Request');
+            return;
+        }
+        const replyText = await this.handleMessage(wxMsg);
+        if (replyText) {
+            const xml = WeChatChannel.formatXMLResponse(wxMsg.fromUserName, wxMsg.toUserName, replyText);
+            res.writeHead(200, { 'Content-Type': 'application/xml' });
+            res.end(xml);
         }
-        // TODO: Implement token refresh
-        // const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
-        // const res = await fetch(url);
-        // const data = await res.json();
-        // this.accessToken = data.access_token;
-        // this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
-        return this.accessToken ?? '';
+        else {
+            // Return "success" to prevent WeChat retries
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('success');
+        }
+    }
+    /** Verify WeChat signature */
+    verifySignature(signature, timestamp, nonce) {
+        const arr = [this.config.token, timestamp, nonce].sort();
+        const hash = crypto.createHash('sha1').update(arr.join('')).digest('hex');
+        return hash === signature;
+    }
+    /** Parse WeChat XML message using regex */
+    static parseXML(xml) {
+        const extract = (tag) => {
+            const cdataMatch = xml.match(new RegExp(`<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]></${tag}>`));
+            if (cdataMatch)
+                return cdataMatch[1];
+            const plainMatch = xml.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+            return plainMatch ? plainMatch[1] : '';
+        };
+        const toUserName = extract('ToUserName');
+        const fromUserName = extract('FromUserName');
+        const createTime = extract('CreateTime');
+        const msgType = extract('MsgType');
+        if (!toUserName || !fromUserName || !msgType)
+            return null;
+        return {
+            toUserName,
+            fromUserName,
+            createTime: parseInt(createTime, 10) || 0,
+            msgType: msgType,
+            content: extract('Content') || undefined,
+            msgId: extract('MsgId') || undefined,
+            event: extract('Event') || undefined,
+            eventKey: extract('EventKey') || undefined,
+        };
+    }
+    /** Format response as WeChat XML */
+    static formatXMLResponse(toUser, fromUser, content) {
+        const timestamp = Math.floor(Date.now() / 1000);
+        return `<xml>
+<ToUserName><![CDATA[${toUser}]]></ToUserName>
+<FromUserName><![CDATA[${fromUser}]]></FromUserName>
+<CreateTime>${timestamp}</CreateTime>
+<MsgType><![CDATA[text]]></MsgType>
+<Content><![CDATA[${content}]]></Content>
+</xml>`;
     }
     /** Handle incoming WeChat message */
     async handleMessage(wxMsg) {
@@ -45,11 +175,13 @@ class WeChatChannel extends index_1.BaseChannel {
         }
         return '';
     }
-    /** Handle WeChat events (subscribe, scan, etc.) */
+    /** Handle WeChat events */
     handleEvent(wxMsg) {
         switch (wxMsg.event) {
             case 'subscribe':
                 return 'Welcome! How can I help you?';
+            case 'unsubscribe':
+                return '';
             case 'SCAN':
                 return `QR code scanned: ${wxMsg.eventKey}`;
             default:
@@ -71,33 +203,88 @@ class WeChatChannel extends index_1.BaseChannel {
             },
         };
     }
+    /** Get or refresh access token */
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
+        const data = await this.httpsGet(url);
+        const parsed = JSON.parse(data);
+        if (parsed.access_token) {
+            this.accessToken = parsed.access_token;
+            this.tokenExpiry = Date.now() + (parsed.expires_in - 300) * 1000;
+            return this.accessToken;
+        }
+        throw new Error(`[WeChatChannel] Failed to get access token: ${data}`);
+    }
+    /** Send customer service message */
+    async sendMessage(openId, text) {
+        const token = await this.getAccessToken();
+        const url = `https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=${token}`;
+        const body = JSON.stringify({
+            touser: openId,
+            msgtype: 'text',
+            text: { content: text },
+        });
+        await this.httpsPost(url, body);
+    }
     /** Send template message */
     async sendTemplateMessage(data) {
-        // TODO: Implement
-        // const token = await this.getAccessToken();
-        // const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
-        // const res = await fetch(url, {
-        //   method: 'POST',
-        //   body: JSON.stringify({
-        //     touser: data.toUser,
-        //     template_id: data.templateId,
-        //     url: data.url,
-        //     data: data.data,
-        //   }),
-        // });
-        void data;
-        return true;
-    }
-    /** Generate QR code for login (stub) */
-    async generateLoginQR() {
-        // TODO: Implement with WeChat QR code API
-        // const token = await this.getAccessToken();
-        // POST to https://api.weixin.qq.com/cgi-bin/qrcode/create
-        return {
-            ticket: 'stub-ticket',
-            url: 'https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=stub-ticket',
-            expireSeconds: 300,
-        };
+        const token = await this.getAccessToken();
+        const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
+        const body = JSON.stringify({
+            touser: data.toUser,
+            template_id: data.templateId,
+            url: data.url,
+            data: data.data,
+        });
+        const result = await this.httpsPost(url, body);
+        const parsed = JSON.parse(result);
+        return parsed.errcode === 0;
+    }
+    /** Read request body */
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+            req.on('error', reject);
+        });
+    }
+    /** Simple HTTPS GET */
+    httpsGet(url) {
+        return new Promise((resolve, reject) => {
+            https.get(url, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+                res.on('error', reject);
+            }).on('error', reject);
+        });
+    }
+    /** Simple HTTPS POST */
+    httpsPost(url, body) {
+        return new Promise((resolve, reject) => {
+            const parsed = new URL(url);
+            const req = https.request({
+                hostname: parsed.hostname,
+                path: parsed.pathname + parsed.search,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+                res.on('error', reject);
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
     }
 }
 exports.WeChatChannel = WeChatChannel;