opc-agent 1.3.2 → 2.0.0

package/dist/channels/slack.js

@@ -1,4 +1,37 @@
 "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.SlackChannel = void 0;
 const index_1 = require("./index");
@@ -37,9 +70,51 @@ class SlackChannel extends index_1.BaseChannel {
     }
     /** Start Events API HTTP server */
     async startEventsAPI() {
-        // TODO: Implement with express or http
-        // const port = this.config.port ?? 3001;
-        // Listen for POST /slack/events and /slack/commands
+        const http = await Promise.resolve().then(() => __importStar(require('http')));
+        const port = this.config.port ?? 3001;
+        const server = http.createServer(async (req, res) => {
+            if (req.method !== 'POST') {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const chunks = [];
+            for await (const chunk of req)
+                chunks.push(chunk);
+            const body = JSON.parse(Buffer.concat(chunks).toString());
+            // URL verification challenge
+            if (body.type === 'url_verification') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ challenge: body.challenge }));
+                return;
+            }
+            // Event callback
+            if (body.type === 'event_callback' && body.event) {
+                const event = body.event;
+                if (event.type === 'message' || event.type === 'app_mention') {
+                    // Don't block the HTTP response
+                    this.handleMessage(event).catch(() => { });
+                }
+            }
+            // Slash commands (form-urlencoded, but we handle JSON for simplicity)
+            if (req.url === '/slack/commands' && body.command) {
+                const reply = await this.handleSlashCommand({
+                    command: body.command,
+                    text: body.text ?? '',
+                    userId: body.user_id,
+                    channelId: body.channel_id,
+                    triggerId: body.trigger_id,
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ response_type: 'ephemeral', text: reply }));
+                return;
+            }
+            res.writeHead(200);
+            res.end('ok');
+        });
+        server.listen(port, () => {
+            console.log(`[SlackChannel] Events API listening on port ${port}`);
+        });
     }
     /** Handle incoming Slack message */
     async handleMessage(event) {
@@ -94,13 +169,21 @@ class SlackChannel extends index_1.BaseChannel {
     }
     /** Send a message to a Slack channel */
     async sendMessage(channel, text, threadTs) {
-        // TODO: Implement with @slack/web-api
-        // const { WebClient } = await import('@slack/web-api');
-        // const client = new WebClient(this.config.botToken);
-        // await client.chat.postMessage({ channel, text, thread_ts: threadTs });
-        void channel;
-        void text;
-        void threadTs;
+        const body = { channel, text };
+        if (threadTs)
+            body.thread_ts = threadTs;
+        const res = await fetch('https://slack.com/api/chat.postMessage', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.config.botToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        if (!data.ok) {
+            console.error(`[SlackChannel] chat.postMessage failed: ${data.error}`);
+        }
     }
 }
 exports.SlackChannel = SlackChannel;

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

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/web.d.ts

@@ -9,6 +9,11 @@ export declare class WebChannel extends BaseChannel {
     private port;
     private streamHandler;
     private agentName;
+    private agentVersion;
+    private memoryType;
+    private skillNames;
+    private channelNames;
+    private analyticsProvider;
     private currentProvider;
     private stats;
     private eventHandlers;
@@ -23,6 +28,11 @@ export declare class WebChannel extends BaseChannel {
     trackSession(): void;
     constructor(port?: number, authConfig?: AuthConfig);
     setAgentName(name: string): void;
+    setAgentVersion(version: string): void;
+    setMemoryType(type: string): void;
+    setSkillNames(names: string[]): void;
+    setChannelNames(names: string[]): void;
+    setAnalyticsProvider(fn: () => any): void;
     onStreamMessage(handler: (msg: Message, res: Response) => Promise<void>): void;
     private setupRoutes;
     start(): Promise<void>;

package/dist/channels/web.js

@@ -286,6 +286,11 @@ class WebChannel extends index_1.BaseChannel {
     port;
     streamHandler = null;
     agentName = 'OPC Agent';
+    agentVersion = '1.0.0';
+    memoryType = 'in-memory';
+    skillNames = [];
+    channelNames = ['web'];
+    analyticsProvider = null;
     currentProvider = 'openai';
     stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now(), errors: 0 };
     eventHandlers = new Map();
@@ -326,6 +331,21 @@ class WebChannel extends index_1.BaseChannel {
     setAgentName(name) {
         this.agentName = name;
     }
+    setAgentVersion(version) {
+        this.agentVersion = version;
+    }
+    setMemoryType(type) {
+        this.memoryType = type;
+    }
+    setSkillNames(names) {
+        this.skillNames = names;
+    }
+    setChannelNames(names) {
+        this.channelNames = names;
+    }
+    setAnalyticsProvider(fn) {
+        this.analyticsProvider = fn;
+    }
     onStreamMessage(handler) {
         this.streamHandler = handler;
     }
@@ -334,7 +354,17 @@ class WebChannel extends index_1.BaseChannel {
             res.type('html').send(CHAT_HTML);
         });
         this.app.get('/health', (_req, res) => {
-            res.json({ status: 'ok', timestamp: Date.now() });
+            res.json({
+                status: 'ok',
+                agent: this.agentName,
+                version: this.agentVersion,
+                uptime: Date.now() - this.stats.startedAt,
+                memory: this.memoryType,
+                skills: this.skillNames,
+                channels: this.channelNames,
+                analytics: this.analyticsProvider ? this.analyticsProvider() : null,
+                timestamp: Date.now(),
+            });
         });
         this.app.get('/api/info', (_req, res) => {
             res.json({ name: this.agentName });
@@ -408,7 +438,8 @@ class WebChannel extends index_1.BaseChannel {
             res.type('html').send(DASHBOARD_HTML);
         });
         this.app.get('/api/dashboard', (_req, res) => {
-            res.json(this.stats);
+            const analytics = this.analyticsProvider ? this.analyticsProvider() : null;
+            res.json({ ...this.stats, analytics });
         });
         // --- Knowledge Base Upload ---
         this.app.post('/api/kb/upload', async (req, res) => {