opc-agent 1.4.0 → 2.0.0

package/dist/tools/mcp-client.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+const child_process_1 = require("child_process");
+class MCPClient {
+    process = null;
+    config = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = '';
+    connected = false;
+    async connect(config) {
+        this.config = config;
+        this.process = (0, child_process_1.spawn)(config.command, config.args ?? [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...config.env },
+        });
+        this.process.stdout.on('data', (data) => {
+            this.buffer += data.toString();
+            this.processBuffer();
+        });
+        this.process.on('error', (err) => {
+            for (const [, p] of this.pending)
+                p.reject(err);
+            this.pending.clear();
+        });
+        this.process.on('exit', () => {
+            this.connected = false;
+            for (const [, p] of this.pending)
+                p.reject(new Error('MCP server exited'));
+            this.pending.clear();
+        });
+        // Send initialize
+        await this.sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'opc-agent', version: '0.7.0' },
+        });
+        // Send initialized notification
+        this.sendNotification('notifications/initialized', {});
+        this.connected = true;
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const p = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) {
+                        p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+                    }
+                    else {
+                        p.resolve(msg.result);
+                    }
+                }
+            }
+            catch { /* skip non-JSON lines */ }
+        }
+    }
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin?.writable) {
+                reject(new Error('MCP server not connected'));
+                return;
+            }
+            const id = this.nextId++;
+            this.pending.set(id, { resolve, reject });
+            const msg = JSON.stringify({ jsonrpc: '2.0', method, params: params ?? {}, id });
+            this.process.stdin.write(msg + '\n');
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timed out: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process?.stdin?.writable)
+            return;
+        const msg = JSON.stringify({ jsonrpc: '2.0', method, params });
+        this.process.stdin.write(msg + '\n');
+    }
+    async listTools() {
+        const result = await this.sendRequest('tools/list');
+        return (result.tools ?? []).map((t) => ({
+            name: t.name,
+            description: t.description ?? '',
+            inputSchema: t.inputSchema ?? {},
+        }));
+    }
+    async callTool(name, input) {
+        const result = await this.sendRequest('tools/call', { name, arguments: input });
+        const content = (result.content ?? [])
+            .map((c) => c.text ?? JSON.stringify(c))
+            .join('\n');
+        return { content, isError: result.isError ?? false };
+    }
+    async disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.connected = false;
+        this.pending.clear();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.MCPClient = MCPClient;
+//# sourceMappingURL=mcp-client.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channels/telegram.ts

@@ -1,90 +1,212 @@
-import type { Message } from '../core/types';
-import { BaseChannel } from './index';
-
-/**
- * Telegram channel — basic webhook handler for Telegram Bot API.
- * Set TELEGRAM_BOT_TOKEN env var or pass in config.
- */
-export class TelegramChannel extends BaseChannel {
-  readonly type = 'telegram';
-  private token: string;
-  private webhookUrl?: string;
-  private server: import('http').Server | null = null;
-  private port: number;
-
-  constructor(options: { token?: string; webhookUrl?: string; port?: number } = {}) {
-    super();
-    this.token = options.token ?? process.env.TELEGRAM_BOT_TOKEN ?? '';
-    this.webhookUrl = options.webhookUrl;
-    this.port = options.port ?? 3001;
-  }
-
-  async start(): Promise<void> {
-    if (!this.token) {
-      console.warn('[TelegramChannel] No bot token provided. Set TELEGRAM_BOT_TOKEN or pass token in config.');
-      return;
-    }
-
-    const express = (await import('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: Message = {
-            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);
-        }
-        res.json({ ok: true });
-      } catch (err) {
-        console.error('[TelegramChannel] Error handling update:', err);
-        res.status(500).json({ error: 'Internal error' });
-      }
-    });
-
-    app.get('/health', (_req, res) => {
-      res.json({ status: 'ok', channel: 'telegram' });
-    });
-
-    return new Promise((resolve) => {
-      this.server = app.listen(this.port, () => {
-        console.log(`[TelegramChannel] Webhook server on port ${this.port}`);
-        resolve();
-      });
-    });
-  }
-
-  async stop(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.server) return resolve();
-      this.server.close((err) => (err ? reject(err) : resolve()));
-    });
-  }
-
-  private async sendMessage(chatId: number, text: string): Promise<void> {
-    const url = `https://api.telegram.org/bot${this.token}/sendMessage`;
-    try {
-      await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ chat_id: chatId, text, parse_mode: 'Markdown' }),
-      });
-    } catch (err) {
-      console.error('[TelegramChannel] Failed to send message:', err);
-    }
-  }
-}
+import type { Message } from '../core/types';
+import { BaseChannel } from './index';
+
+/**
+ * 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 class TelegramChannel extends BaseChannel {
+  readonly type = 'telegram';
+  private token: string;
+  private mode: 'polling' | 'webhook';
+  private webhookUrl?: string;
+  private port: number;
+
+  // Polling state
+  private offset: number = 0;
+  private polling: boolean = false;
+
+  // Webhook state
+  private server: import('http').Server | null = null;
+
+  constructor(config: TelegramChannelConfig = {}) {
+    super();
+    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(): Promise<void> {
+    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(): Promise<void> {
+    if (this.mode === 'webhook') {
+      await this.stopWebhook();
+    } else {
+      this.polling = false;
+    }
+  }
+
+  // ─── Polling Mode ────────────────────────────────────────
+
+  private async startPolling(): Promise<void> {
+    // Delete any existing webhook so polling works
+    await this.apiCall('deleteWebhook');
+    console.log(`[TelegramChannel] Started long-polling mode`);
+    this.polling = true;
+    this.poll();
+  }
+
+  private async poll(): Promise<void> {
+    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));
+        }
+      }
+    }
+  }
+
+  private async getUpdates(): Promise<any[]> {
+    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()) as { ok: boolean; result: any[] };
+      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 ────────────────────────────────────────
+
+  private async startWebhook(): Promise<void> {
+    if (this.webhookUrl) {
+      await this.apiCall('setWebhook', { url: `${this.webhookUrl}/webhook/${this.token}` });
+    }
+
+    const express = (await import('express')).default;
+    const app = express();
+    app.use(express.json());
+
+    app.post(`/webhook/${this.token}`, async (req, res) => {
+      try {
+        await this.processUpdate(req.body);
+        res.json({ ok: true });
+      } catch (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', mode: 'webhook' });
+    });
+
+    return new Promise((resolve) => {
+      this.server = app.listen(this.port, () => {
+        console.log(`[TelegramChannel] Webhook server on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  private async stopWebhook(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (!this.server) return resolve();
+      this.server.close((err) => (err ? reject(err) : resolve()));
+    });
+  }
+
+  // ─── Shared ──────────────────────────────────────────────
+
+  private async processUpdate(update: any): Promise<void> {
+    const message = update.message || update.edited_message;
+    if (!message?.text || !this.handler) return;
+
+    const msg: Message = {
+      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: number | string, text: string): Promise<void> {
+    // 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',
+      });
+    }
+  }
+
+  private async apiCall(method: string, body?: Record<string, unknown>): Promise<any> {
+    const url = `https://api.telegram.org/bot${this.token}/${method}`;
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+      return await res.json();
+    } catch (err) {
+      console.error(`[TelegramChannel] API call ${method} failed:`, err);
+      throw err;
+    }
+  }
+
+  private splitText(text: string, maxLen: number): string[] {
+    if (text.length <= maxLen) return [text];
+    const parts: string[] = [];
+    for (let i = 0; i < text.length; i += maxLen) {
+      parts.push(text.slice(i, i + maxLen));
+    }
+    return parts;
+  }
+}