opc-agent 1.3.2 → 2.0.0

package/src/channels/slack.ts

@@ -1,160 +1,217 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-/**
- * Slack Channel — v0.8.0
- * Slack Bot with Socket Mode / Events API support, threads, and slash commands.
- */
-
-export interface SlackChannelConfig {
-  /** Bot token (xoxb-...) */
-  botToken: string;
-  /** App-level token for Socket Mode (xapp-...) */
-  appToken?: string;
-  /** Signing secret for Events API verification */
-  signingSecret?: string;
-  /** Use Socket Mode (true) or Events API (false) */
-  socketMode?: boolean;
-  /** Port for Events API webhook server (default: 3001) */
-  port?: number;
-  /** Slash commands to register */
-  slashCommands?: SlashCommandConfig[];
-}
-
-export interface SlashCommandConfig {
-  command: string;
-  description: string;
-  handler?: (payload: SlashCommandPayload) => Promise<string>;
-}
-
-export interface SlashCommandPayload {
-  command: string;
-  text: string;
-  userId: string;
-  channelId: string;
-  triggerId: string;
-}
-
-export interface SlackMessageEvent {
-  type: string;
-  channel: string;
-  user: string;
-  text: string;
-  ts: string;
-  threadTs?: string;
-  botId?: string;
-}
-
-export class SlackChannel extends BaseChannel {
-  type = 'slack';
-  private config: SlackChannelConfig;
-  private running = false;
-  private slashHandlers: Map<string, SlashCommandConfig> = new Map();
-
-  constructor(config: SlackChannelConfig) {
-    super();
-    this.config = config;
-
-    for (const cmd of config.slashCommands ?? []) {
-      this.slashHandlers.set(cmd.command, cmd);
-    }
-  }
-
-  async start(): Promise<void> {
-    this.running = true;
-
-    if (this.config.socketMode && this.config.appToken) {
-      await this.startSocketMode();
-    } else {
-      await this.startEventsAPI();
-    }
-  }
-
-  async stop(): Promise<void> {
-    this.running = false;
-    // Cleanup connections
-  }
-
-  /** Start Socket Mode connection */
-  private async startSocketMode(): Promise<void> {
-    // TODO: Implement with @slack/socket-mode
-    // const { SocketModeClient } = await import('@slack/socket-mode');
-    // const client = new SocketModeClient({ appToken: this.config.appToken! });
-    // client.on('message', (event) => this.handleMessage(event));
-    // await client.start();
-  }
-
-  /** Start Events API HTTP server */
-  private async startEventsAPI(): Promise<void> {
-    // TODO: Implement with express or http
-    // const port = this.config.port ?? 3001;
-    // Listen for POST /slack/events and /slack/commands
-  }
-
-  /** Handle incoming Slack message */
-  async handleMessage(event: SlackMessageEvent): Promise<void> {
-    // Ignore bot messages
-    if (event.botId) return;
-
-    const message = this.slackToMessage(event);
-    if (this.handler) {
-      const reply = await this.handler(message);
-      await this.sendMessage(event.channel, reply.content, event.threadTs ?? event.ts);
-    }
-  }
-
-  /** Handle slash command */
-  async handleSlashCommand(payload: SlashCommandPayload): Promise<string> {
-    const cmd = this.slashHandlers.get(payload.command);
-    if (cmd?.handler) {
-      return cmd.handler(payload);
-    }
-
-    // Default: pass to message handler
-    const message: Message = {
-      id: `slack-cmd-${Date.now()}`,
-      role: 'user',
-      content: `${payload.command} ${payload.text}`.trim(),
-      timestamp: Date.now(),
-      metadata: {
-        channel: 'slack',
-        channelId: payload.channelId,
-        userId: payload.userId,
-        isSlashCommand: true,
-      },
-    };
-
-    if (this.handler) {
-      const reply = await this.handler(message);
-      return reply.content;
-    }
-    return 'Command received.';
-  }
-
-  /** Convert Slack event to Message */
-  private slackToMessage(event: SlackMessageEvent): Message {
-    return {
-      id: event.ts,
-      role: 'user',
-      content: event.text,
-      timestamp: parseFloat(event.ts) * 1000,
-      metadata: {
-        channel: 'slack',
-        channelId: event.channel,
-        userId: event.user,
-        threadTs: event.threadTs,
-      },
-    };
-  }
-
-  /** Send a message to a Slack channel */
-  async sendMessage(channel: string, text: string, threadTs?: string): Promise<void> {
-    // 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;
-  }
-}
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+/**
+ * Slack Channel — v0.8.0
+ * Slack Bot with Socket Mode / Events API support, threads, and slash commands.
+ */
+
+export interface SlackChannelConfig {
+  /** Bot token (xoxb-...) */
+  botToken: string;
+  /** App-level token for Socket Mode (xapp-...) */
+  appToken?: string;
+  /** Signing secret for Events API verification */
+  signingSecret?: string;
+  /** Use Socket Mode (true) or Events API (false) */
+  socketMode?: boolean;
+  /** Port for Events API webhook server (default: 3001) */
+  port?: number;
+  /** Slash commands to register */
+  slashCommands?: SlashCommandConfig[];
+}
+
+export interface SlashCommandConfig {
+  command: string;
+  description: string;
+  handler?: (payload: SlashCommandPayload) => Promise<string>;
+}
+
+export interface SlashCommandPayload {
+  command: string;
+  text: string;
+  userId: string;
+  channelId: string;
+  triggerId: string;
+}
+
+export interface SlackMessageEvent {
+  type: string;
+  channel: string;
+  user: string;
+  text: string;
+  ts: string;
+  threadTs?: string;
+  botId?: string;
+}
+
+export class SlackChannel extends BaseChannel {
+  type = 'slack';
+  private config: SlackChannelConfig;
+  private running = false;
+  private slashHandlers: Map<string, SlashCommandConfig> = new Map();
+
+  constructor(config: SlackChannelConfig) {
+    super();
+    this.config = config;
+
+    for (const cmd of config.slashCommands ?? []) {
+      this.slashHandlers.set(cmd.command, cmd);
+    }
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+
+    if (this.config.socketMode && this.config.appToken) {
+      await this.startSocketMode();
+    } else {
+      await this.startEventsAPI();
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+    // Cleanup connections
+  }
+
+  /** Start Socket Mode connection */
+  private async startSocketMode(): Promise<void> {
+    // TODO: Implement with @slack/socket-mode
+    // const { SocketModeClient } = await import('@slack/socket-mode');
+    // const client = new SocketModeClient({ appToken: this.config.appToken! });
+    // client.on('message', (event) => this.handleMessage(event));
+    // await client.start();
+  }
+
+  /** Start Events API HTTP server */
+  private async startEventsAPI(): Promise<void> {
+    const http = await import('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: Buffer[] = [];
+      for await (const chunk of req) chunks.push(chunk as Buffer);
+      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 as SlackMessageEvent;
+        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: SlackMessageEvent): Promise<void> {
+    // Ignore bot messages
+    if (event.botId) return;
+
+    const message = this.slackToMessage(event);
+    if (this.handler) {
+      const reply = await this.handler(message);
+      await this.sendMessage(event.channel, reply.content, event.threadTs ?? event.ts);
+    }
+  }
+
+  /** Handle slash command */
+  async handleSlashCommand(payload: SlashCommandPayload): Promise<string> {
+    const cmd = this.slashHandlers.get(payload.command);
+    if (cmd?.handler) {
+      return cmd.handler(payload);
+    }
+
+    // Default: pass to message handler
+    const message: Message = {
+      id: `slack-cmd-${Date.now()}`,
+      role: 'user',
+      content: `${payload.command} ${payload.text}`.trim(),
+      timestamp: Date.now(),
+      metadata: {
+        channel: 'slack',
+        channelId: payload.channelId,
+        userId: payload.userId,
+        isSlashCommand: true,
+      },
+    };
+
+    if (this.handler) {
+      const reply = await this.handler(message);
+      return reply.content;
+    }
+    return 'Command received.';
+  }
+
+  /** Convert Slack event to Message */
+  private slackToMessage(event: SlackMessageEvent): Message {
+    return {
+      id: event.ts,
+      role: 'user',
+      content: event.text,
+      timestamp: parseFloat(event.ts) * 1000,
+      metadata: {
+        channel: 'slack',
+        channelId: event.channel,
+        userId: event.user,
+        threadTs: event.threadTs,
+      },
+    };
+  }
+
+  /** Send a message to a Slack channel */
+  async sendMessage(channel: string, text: string, threadTs?: string): Promise<void> {
+    const body: Record<string, string> = { 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() as { ok: boolean; error?: string };
+    if (!data.ok) {
+      console.error(`[SlackChannel] chat.postMessage failed: ${data.error}`);
+    }
+  }
+}

package/src/channels/telegram.ts

@@ -2,21 +2,45 @@ 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.
+ * 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 server: import('http').Server | null = null;
   private port: number;
 
-  constructor(options: { token?: string; webhookUrl?: string; 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 = 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(): Promise<void> {
@@ -25,39 +49,88 @@ export class TelegramChannel extends BaseChannel {
       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 {
-        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);
-        }
+        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) => {
@@ -68,23 +141,72 @@ export class TelegramChannel extends BaseChannel {
     });
   }
 
-  async stop(): Promise<void> {
+  private async stopWebhook(): 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`;
+  // ─── 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 {
-      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;
+    }
+  }
+
+  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;
   }
 }