opc-agent 1.4.0 → 2.0.1

package/dist/channels/feishu.d.ts

@@ -8,11 +8,8 @@ import { BaseChannel } from './index';
  * - URL verification challenge
  * - Message card (interactive) responses
  * - Group chat & P2P messaging
- *
- * Env vars:
- *   FEISHU_APP_ID, FEISHU_APP_SECRET — app credentials
- *   FEISHU_VERIFICATION_TOKEN — event subscription verification
- *   FEISHU_ENCRYPT_KEY — (optional) event encryption key
+ * - Event deduplication
+ * - No external dependencies (uses Node.js built-in http/https)
  */
 export interface FeishuChannelConfig {
     /** Feishu App ID */
@@ -23,7 +20,7 @@ export interface FeishuChannelConfig {
     verificationToken?: string;
     /** Encrypt key (optional, for encrypted events) */
     encryptKey?: string;
-    /** Webhook server port (default: 3002) */
+    /** Webhook server port (default: 8081) */
     port?: number;
     /** API base URL (use 'https://open.larksuite.com' for Lark international) */
     apiBase?: string;
@@ -37,11 +34,29 @@ export declare class FeishuChannel extends BaseChannel {
     constructor(config?: FeishuChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
+    /** Handle Feishu event */
+    private handleEvent;
+    /** Parse Feishu event body (exported for testing) */
+    static parseEventBody(body: any): {
+        type: string;
+        challenge?: string;
+        eventType?: string;
+        content?: string;
+        chatId?: string;
+        senderId?: string;
+        messageId?: string;
+    };
     /** Get tenant access token (cached) */
     private getAccessToken;
     /** Send a text message to a chat */
     sendTextMessage(chatId: string, text: string): Promise<void>;
     /** Send an interactive card message */
     sendCardMessage(chatId: string, card: Record<string, unknown>): Promise<void>;
+    /** Read request body */
+    private readBody;
+    /** HTTPS POST */
+    private httpsPost;
+    /** HTTPS POST with Bearer auth */
+    private httpsPostWithAuth;
 }
 //# sourceMappingURL=feishu.d.ts.map

package/dist/channels/feishu.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeishuChannel = void 0;
 const index_1 = require("./index");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
 class FeishuChannel extends index_1.BaseChannel {
     type = 'feishu';
     config;
@@ -48,7 +50,7 @@ class FeishuChannel extends index_1.BaseChannel {
             appSecret: config.appSecret ?? process.env.FEISHU_APP_SECRET ?? '',
             verificationToken: config.verificationToken ?? process.env.FEISHU_VERIFICATION_TOKEN ?? '',
             encryptKey: config.encryptKey ?? process.env.FEISHU_ENCRYPT_KEY,
-            port: config.port ?? 3002,
+            port: config.port ?? 8081,
             apiBase: config.apiBase ?? 'https://open.feishu.cn',
         };
     }
@@ -57,163 +59,260 @@ class FeishuChannel extends index_1.BaseChannel {
             console.warn('[FeishuChannel] Missing appId/appSecret. Set FEISHU_APP_ID and FEISHU_APP_SECRET.');
             return;
         }
-        const express = (await Promise.resolve().then(() => __importStar(require('express')))).default;
-        const app = express();
-        app.use(express.json());
-        // Event subscription endpoint
-        app.post('/feishu/event', async (req, res) => {
+        this.server = http.createServer(async (req, res) => {
+            if (req.method === 'GET' && req.url === '/health') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'ok', channel: 'feishu' }));
+                return;
+            }
+            if (req.method !== 'POST') {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
             try {
-                const body = req.body;
-                // URL verification challenge
-                if (body.type === 'url_verification') {
-                    res.json({ challenge: body.challenge });
-                    return;
-                }
-                // Deduplicate events
-                const eventId = body.header?.event_id;
-                if (eventId && this.processedEvents.has(eventId)) {
-                    res.json({ ok: true });
-                    return;
-                }
-                if (eventId) {
-                    this.processedEvents.add(eventId);
-                    // Prune old events (keep last 1000)
-                    if (this.processedEvents.size > 1000) {
-                        const arr = [...this.processedEvents];
-                        this.processedEvents = new Set(arr.slice(-500));
-                    }
-                }
-                // Verify token
-                if (this.config.verificationToken && body.header?.token !== this.config.verificationToken) {
-                    res.status(403).json({ error: 'Invalid verification token' });
-                    return;
-                }
-                // Handle im.message.receive_v1
-                const event = body.event;
-                if (body.header?.event_type === 'im.message.receive_v1' && this.handler) {
-                    const msgBody = event?.message;
-                    if (!msgBody) {
-                        res.json({ ok: true });
-                        return;
-                    }
-                    // Only handle text messages for now
-                    const msgType = msgBody.message_type;
-                    let content = '';
-                    if (msgType === 'text') {
-                        try {
-                            const parsed = JSON.parse(msgBody.content);
-                            content = parsed.text ?? '';
-                        }
-                        catch {
-                            content = msgBody.content ?? '';
-                        }
-                    }
-                    else {
-                        // Acknowledge non-text silently
-                        res.json({ ok: true });
-                        return;
-                    }
-                    // Strip @bot mentions
-                    content = content.replace(/@_user_\d+/g, '').trim();
-                    if (!content) {
-                        res.json({ ok: true });
-                        return;
-                    }
-                    const chatId = msgBody.chat_id;
-                    const senderId = event.sender?.sender_id?.open_id ?? 'unknown';
-                    const msg = {
-                        id: `feishu_${msgBody.message_id}`,
-                        role: 'user',
-                        content,
-                        timestamp: parseInt(msgBody.create_time, 10) || Date.now(),
-                        metadata: {
-                            sessionId: `feishu_${chatId}`,
-                            chatId,
-                            userId: senderId,
-                            platform: 'feishu',
-                            messageId: msgBody.message_id,
-                            chatType: msgBody.chat_type, // 'p2p' or 'group'
-                        },
-                    };
-                    const response = await this.handler(msg);
-                    await this.sendTextMessage(chatId, response.content);
-                }
-                res.json({ ok: true });
+                const body = await this.readBody(req);
+                const parsed = JSON.parse(body);
+                await this.handleEvent(parsed, res);
             }
             catch (err) {
-                console.error('[FeishuChannel] Error handling event:', err);
-                res.status(500).json({ error: 'Internal error' });
+                console.error('[FeishuChannel] Error:', err);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Internal error' }));
             }
         });
-        app.get('/health', (_req, res) => {
-            res.json({ status: 'ok', channel: 'feishu' });
-        });
-        this.server = app.listen(this.config.port, () => {
-            console.log(`[FeishuChannel] Listening on port ${this.config.port}`);
+        return new Promise((resolve) => {
+            this.server.listen(this.config.port, () => {
+                console.log(`[FeishuChannel] Listening on port ${this.config.port}`);
+                resolve();
+            });
         });
     }
     async stop() {
-        if (this.server) {
-            this.server.close();
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                return resolve();
+            this.server.close((err) => (err ? reject(err) : resolve()));
             this.server = null;
+        });
+    }
+    /** Handle Feishu event */
+    async handleEvent(body, res) {
+        // URL verification challenge
+        if (body.type === 'url_verification') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ challenge: body.challenge }));
+            return;
+        }
+        // Deduplicate events
+        const eventId = body.header?.event_id;
+        if (eventId && this.processedEvents.has(eventId)) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        if (eventId) {
+            this.processedEvents.add(eventId);
+            if (this.processedEvents.size > 1000) {
+                const arr = [...this.processedEvents];
+                this.processedEvents = new Set(arr.slice(-500));
+            }
+        }
+        // Verify token
+        if (this.config.verificationToken && body.header?.token !== this.config.verificationToken) {
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid verification token' }));
+            return;
+        }
+        // Handle im.message.receive_v1
+        const event = body.event;
+        if (body.header?.event_type === 'im.message.receive_v1' && this.handler) {
+            const msgBody = event?.message;
+            if (!msgBody) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+                return;
+            }
+            const msgType = msgBody.message_type;
+            let content = '';
+            if (msgType === 'text') {
+                try {
+                    const parsed = JSON.parse(msgBody.content);
+                    content = parsed.text ?? '';
+                }
+                catch {
+                    content = msgBody.content ?? '';
+                }
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+                return;
+            }
+            // Strip @bot mentions
+            content = content.replace(/@_user_\d+/g, '').trim();
+            if (!content) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+                return;
+            }
+            const chatId = msgBody.chat_id;
+            const senderId = event.sender?.sender_id?.open_id ?? 'unknown';
+            const msg = {
+                id: `feishu_${msgBody.message_id}`,
+                role: 'user',
+                content,
+                timestamp: parseInt(msgBody.create_time, 10) || Date.now(),
+                metadata: {
+                    sessionId: `feishu_${chatId}`,
+                    chatId,
+                    userId: senderId,
+                    platform: 'feishu',
+                    messageId: msgBody.message_id,
+                    chatType: msgBody.chat_type,
+                },
+            };
+            // Don't block the response
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+            try {
+                const response = await this.handler(msg);
+                await this.sendTextMessage(chatId, response.content);
+            }
+            catch (err) {
+                console.error('[FeishuChannel] Handler error:', err);
+            }
+            return;
         }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+    }
+    /** Parse Feishu event body (exported for testing) */
+    static parseEventBody(body) {
+        if (body.type === 'url_verification') {
+            return { type: 'url_verification', challenge: body.challenge };
+        }
+        const eventType = body.header?.event_type;
+        const event = body.event;
+        if (eventType === 'im.message.receive_v1' && event?.message) {
+            const msgBody = event.message;
+            let content = '';
+            if (msgBody.message_type === 'text') {
+                try {
+                    const parsed = JSON.parse(msgBody.content);
+                    content = parsed.text ?? '';
+                }
+                catch {
+                    content = msgBody.content ?? '';
+                }
+            }
+            return {
+                type: 'message',
+                eventType,
+                content: content.replace(/@_user_\d+/g, '').trim(),
+                chatId: msgBody.chat_id,
+                senderId: event.sender?.sender_id?.open_id,
+                messageId: msgBody.message_id,
+            };
+        }
+        return { type: 'unknown', eventType };
     }
     /** Get tenant access token (cached) */
     async getAccessToken() {
         if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
             return this.tokenCache.token;
         }
-        const resp = await fetch(`${this.config.apiBase}/open-apis/auth/v3/tenant_access_token/internal`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                app_id: this.config.appId,
-                app_secret: this.config.appSecret,
-            }),
+        const body = JSON.stringify({
+            app_id: this.config.appId,
+            app_secret: this.config.appSecret,
         });
-        const data = await resp.json();
+        const result = await this.httpsPost(`${this.config.apiBase}/open-apis/auth/v3/tenant_access_token/internal`, body);
+        const data = JSON.parse(result);
         if (data.code !== 0) {
-            throw new Error(`[FeishuChannel] Failed to get access token: ${JSON.stringify(data)}`);
+            throw new Error(`[FeishuChannel] Failed to get access token: ${result}`);
         }
         this.tokenCache = {
             token: data.tenant_access_token,
-            expiresAt: Date.now() + (data.expire - 60) * 1000, // refresh 60s early
+            expiresAt: Date.now() + (data.expire - 60) * 1000,
         };
         return this.tokenCache.token;
     }
     /** Send a text message to a chat */
     async sendTextMessage(chatId, text) {
         const token = await this.getAccessToken();
-        const resp = await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${token}`,
-            },
-            body: JSON.stringify({
-                receive_id: chatId,
-                msg_type: 'text',
-                content: JSON.stringify({ text }),
-            }),
+        const body = JSON.stringify({
+            receive_id: chatId,
+            msg_type: 'text',
+            content: JSON.stringify({ text }),
         });
-        if (!resp.ok) {
-            console.error('[FeishuChannel] Failed to send message:', await resp.text());
-        }
+        const url = `${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`;
+        await this.httpsPostWithAuth(url, body, token);
     }
     /** Send an interactive card message */
     async sendCardMessage(chatId, card) {
         const token = await this.getAccessToken();
-        await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${token}`,
-            },
-            body: JSON.stringify({
-                receive_id: chatId,
-                msg_type: 'interactive',
-                content: JSON.stringify(card),
-            }),
+        const body = JSON.stringify({
+            receive_id: chatId,
+            msg_type: 'interactive',
+            content: JSON.stringify(card),
+        });
+        const url = `${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`;
+        await this.httpsPostWithAuth(url, body, token);
+    }
+    /** 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);
+        });
+    }
+    /** 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();
+        });
+    }
+    /** HTTPS POST with Bearer auth */
+    httpsPostWithAuth(url, body, token) {
+        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),
+                    'Authorization': `Bearer ${token}`,
+                },
+            }, (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();
         });
     }
 }

package/dist/channels/telegram.d.ts

@@ -1,21 +1,42 @@
 import { BaseChannel } from './index';
 /**
- * Telegram channel — basic webhook handler for Telegram Bot API.
- * Set TELEGRAM_BOT_TOKEN env var or pass in config.
+ * Telegram channel — supports both long-polling and webhook modes.
+ *
+ * Config:
+ *   token: bot token (or TELEGRAM_BOT_TOKEN env var)
+ *   mode: 'polling' | 'webhook' (default: 'polling')
+ *   webhookUrl: required for webhook mode
+ *   port: webhook server port (default: 3001)
+ *
+ * Polling mode requires no public URL — ideal for dev/local.
+ * Webhook mode is more efficient for production.
  */
+export interface TelegramChannelConfig {
+    token?: string;
+    mode?: 'polling' | 'webhook';
+    webhookUrl?: string;
+    port?: number;
+}
 export declare class TelegramChannel extends BaseChannel {
     readonly type = "telegram";
     private token;
+    private mode;
     private webhookUrl?;
-    private server;
     private port;
-    constructor(options?: {
-        token?: string;
-        webhookUrl?: string;
-        port?: number;
-    });
+    private offset;
+    private polling;
+    private server;
+    constructor(config?: TelegramChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
-    private sendMessage;
+    private startPolling;
+    private poll;
+    private getUpdates;
+    private startWebhook;
+    private stopWebhook;
+    private processUpdate;
+    sendMessage(chatId: number | string, text: string): Promise<void>;
+    private apiCall;
+    private splitText;
 }
 //# sourceMappingURL=telegram.d.ts.map