opc-agent 1.2.0 → 1.2.1

package/src/channels/slack.ts

@@ -1,160 +1,160 @@
-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> {
+    // 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;
+  }
+}

package/src/channels/telegram.ts

@@ -1,90 +1,90 @@
-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 — 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);
+    }
+  }
+}