opc-agent 4.1.1 → 4.1.3

package/src/channels/nostr.ts

@@ -1,33 +0,0 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-export interface NostrChannelConfig {
-  privateKey?: string;
-  relays?: string[];
-}
-
-export class NostrChannel extends BaseChannel {
-  readonly type = 'nostr';
-  private config: NostrChannelConfig;
-
-  constructor(config: NostrChannelConfig = {}) {
-    super();
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    try {
-      require('nostr-tools');
-    } catch {
-      throw new Error('Install nostr-tools to use the NostrChannel. Run: npm install nostr-tools');
-    }
-  }
-
-  async stop(): Promise<void> {
-    // cleanup
-  }
-
-  async send(chatId: string, text: string): Promise<void> {
-    throw new Error('NostrChannel: not yet connected. Call start() first.');
-  }
-}

package/src/channels/qq.ts

@@ -1,34 +0,0 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-export interface QQChannelConfig {
-  appId?: string;
-  token?: string;
-  sandbox?: boolean;
-}
-
-export class QQChannel extends BaseChannel {
-  readonly type = 'qq';
-  private config: QQChannelConfig;
-
-  constructor(config: QQChannelConfig = {}) {
-    super();
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    try {
-      require('qq-bot-sdk');
-    } catch {
-      throw new Error('Install qq-bot-sdk to use the QQChannel. Run: npm install qq-bot-sdk');
-    }
-  }
-
-  async stop(): Promise<void> {
-    // cleanup
-  }
-
-  async send(chatId: string, text: string): Promise<void> {
-    throw new Error('QQChannel: not yet connected. Call start() first.');
-  }
-}

package/src/channels/signal.ts

@@ -1,33 +0,0 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-export interface SignalChannelConfig {
-  signalCliPath?: string;
-  phoneNumber?: string;
-}
-
-export class SignalChannel extends BaseChannel {
-  readonly type = 'signal';
-  private config: SignalChannelConfig;
-
-  constructor(config: SignalChannelConfig = {}) {
-    super();
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    try {
-      require('signal-cli');
-    } catch {
-      throw new Error('Install signal-cli to use the SignalChannel. Run: npm install signal-cli');
-    }
-  }
-
-  async stop(): Promise<void> {
-    // cleanup
-  }
-
-  async send(chatId: string, text: string): Promise<void> {
-    throw new Error('SignalChannel: not yet connected. Call start() first.');
-  }
-}

package/src/channels/slack.ts

@@ -1,217 +0,0 @@
-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/sms.ts

@@ -1,34 +0,0 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-export interface SMSChannelConfig {
-  accountSid?: string;
-  authToken?: string;
-  fromNumber?: string;
-}
-
-export class SMSChannel extends BaseChannel {
-  readonly type = 'sms';
-  private config: SMSChannelConfig;
-
-  constructor(config: SMSChannelConfig = {}) {
-    super();
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    try {
-      require('twilio');
-    } catch {
-      throw new Error('Install twilio to use the SMSChannel. Run: npm install twilio');
-    }
-  }
-
-  async stop(): Promise<void> {
-    // cleanup
-  }
-
-  async send(chatId: string, text: string): Promise<void> {
-    throw new Error('SMSChannel: not yet connected. Call start() first.');
-  }
-}