opc-agent 3.0.1 → 4.0.1

package/src/channels/matrix.ts

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

package/src/channels/mattermost.ts

@@ -0,0 +1,57 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface MattermostChannelConfig {
+  serverUrl: string;
+  token: string;
+  teamId?: string;
+  defaultChannelId?: string;
+}
+
+export class MattermostChannel extends BaseChannel {
+  readonly type = 'mattermost';
+  private config: MattermostChannelConfig;
+  private running = false;
+  private ws: any = null;
+
+  constructor(config: MattermostChannelConfig) {
+    super();
+    if (!config.serverUrl || !config.token) {
+      throw new Error('MattermostChannel requires serverUrl and token in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    // Verify connection by hitting the API
+    const res = await fetch(`${this.config.serverUrl}/api/v4/users/me`, {
+      headers: { Authorization: `Bearer ${this.config.token}` },
+    }).catch(() => null);
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.running = false;
+  }
+
+  async send(channelId: string, text: string): Promise<void> {
+    if (!this.running) {
+      throw new Error('MattermostChannel: not started. Call start() first.');
+    }
+    const res = await fetch(`${this.config.serverUrl}/api/v4/posts`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.config.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ channel_id: channelId, message: text }),
+    });
+    if (!res.ok) {
+      throw new Error(`Mattermost API failed: ${res.status}`);
+    }
+  }
+}

package/src/channels/msteams.ts

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

package/src/channels/nostr.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,34 @@
+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

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

@@ -0,0 +1,34 @@
+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.');
+  }
+}

package/src/channels/twitch.ts

@@ -0,0 +1,65 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface TwitchChannelConfig {
+  username: string;
+  oauthToken: string;
+  channels: string[];
+}
+
+export class TwitchChannel extends BaseChannel {
+  readonly type = 'twitch';
+  private config: TwitchChannelConfig;
+  private client: any = null;
+  private running = false;
+
+  constructor(config: TwitchChannelConfig) {
+    super();
+    if (!config.username || !config.oauthToken || !config.channels?.length) {
+      throw new Error('TwitchChannel requires username, oauthToken, and channels in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    let tmi: any;
+    try {
+      tmi = require('tmi.js');
+    } catch {
+      throw new Error('Install tmi.js to use the TwitchChannel. Run: npm install tmi.js');
+    }
+    this.client = new tmi.Client({
+      identity: { username: this.config.username, password: this.config.oauthToken },
+      channels: this.config.channels,
+    });
+    await this.client.connect();
+    this.running = true;
+
+    this.client.on('message', async (channel: string, tags: any, message: string, self: boolean) => {
+      if (self || !this.handler) return;
+      const msg: Message = {
+        id: tags.id || Date.now().toString(),
+        role: 'user',
+        content: message,
+        timestamp: Date.now(),
+        metadata: { channel, username: tags.username, tags },
+      };
+      await this.handler(msg);
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.client) {
+      await this.client.disconnect();
+      this.client = null;
+    }
+    this.running = false;
+  }
+
+  async send(channel: string, text: string): Promise<void> {
+    if (!this.running || !this.client) {
+      throw new Error('TwitchChannel: not started. Call start() first.');
+    }
+    await this.client.say(channel, text);
+  }
+}

package/src/channels/voice-call.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+
+export interface VoiceCallConfig {
+  provider: 'twilio' | 'vonage' | 'webrtc' | 'sip';
+  credentials?: Record<string, string>;
+  sttProvider?: string;
+  ttsProvider?: string;
+}
+
+interface ActiveCall {
+  callId: string;
+  from: string;
+  to: string;
+  status: 'ringing' | 'active' | 'ended';
+  startedAt: number;
+}
+
+export class VoiceCallManager extends EventEmitter {
+  private config: VoiceCallConfig;
+  private calls = new Map<string, ActiveCall>();
+  private audioListeners = new Map<string, ((audio: Buffer) => void)[]>();
+
+  constructor(config: VoiceCallConfig) {
+    super();
+    this.config = config;
+  }
+
+  private ensureCredentials(): void {
+    if (!this.config.credentials || Object.keys(this.config.credentials).length === 0) {
+      throw new Error(
+        `Voice call provider "${this.config.provider}" requires credentials. ` +
+        `Please configure credentials for ${this.config.provider} in your VoiceCallConfig.`
+      );
+    }
+  }
+
+  async startCall(to: string): Promise<string> {
+    this.ensureCredentials();
+    const callId = randomUUID();
+    const call: ActiveCall = {
+      callId,
+      from: 'self',
+      to,
+      status: 'ringing',
+      startedAt: Date.now(),
+    };
+    this.calls.set(callId, call);
+    // Simulate connection
+    setTimeout(() => {
+      const c = this.calls.get(callId);
+      if (c && c.status === 'ringing') c.status = 'active';
+    }, 100);
+    return callId;
+  }
+
+  async endCall(callId: string): Promise<void> {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    call.status = 'ended';
+    this.audioListeners.delete(callId);
+  }
+
+  onIncoming(callback: (callId: string, from: string) => void): void {
+    this.on('incoming', callback);
+  }
+
+  simulateIncoming(from: string): string {
+    const callId = randomUUID();
+    const call: ActiveCall = { callId, from, to: 'self', status: 'ringing', startedAt: Date.now() };
+    this.calls.set(callId, call);
+    this.emit('incoming', callId, from);
+    return callId;
+  }
+
+  async sendAudio(callId: string, audio: Buffer): Promise<void> {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    if (call.status !== 'active') throw new Error(`Call ${callId} is not active`);
+    // Stub: would send audio to provider
+  }
+
+  onAudio(callId: string, callback: (audio: Buffer) => void): void {
+    const listeners = this.audioListeners.get(callId) || [];
+    listeners.push(callback);
+    this.audioListeners.set(callId, listeners);
+  }
+
+  getCallStatus(callId: string): 'ringing' | 'active' | 'ended' {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    return call.status;
+  }
+
+  listActiveCalls(): Array<{ callId: string; from: string; startedAt: number }> {
+    return Array.from(this.calls.values())
+      .filter(c => c.status !== 'ended')
+      .map(({ callId, from, startedAt }) => ({ callId, from, startedAt }));
+  }
+}

package/src/channels/whatsapp.ts

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

package/src/cli/chat.ts

@@ -0,0 +1,99 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createProvider } from '../providers';
+
+const OPC_HOME = path.join(os.homedir(), '.opc');
+const CONFIG_PATH = path.join(OPC_HOME, 'config.json');
+
+const c = {
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+};
+
+function loadConfig(): Record<string, any> {
+  if (!fs.existsSync(CONFIG_PATH)) return {};
+  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')); } catch { return {}; }
+}
+
+export async function runChat(): Promise<void> {
+  const config = loadConfig();
+
+  if (!config.provider || !config.model) {
+    console.log(`${c.red('✘')} 未找到配置。请先运行 ${c.cyan('opc setup')} 完成初始设置。`);
+    process.exit(1);
+  }
+
+  const agentId = config.defaultAgent;
+  let agentConfig: Record<string, any> = {};
+  if (agentId) {
+    const agentPath = path.join(OPC_HOME, 'agents', agentId, 'config.json');
+    if (fs.existsSync(agentPath)) {
+      try { agentConfig = JSON.parse(fs.readFileSync(agentPath, 'utf-8')); } catch { /* ignore */ }
+    }
+  }
+
+  const agentName = agentConfig.name || 'AI 助手';
+  const systemPrompt = agentConfig.description
+    ? `你是「${agentName}」，${agentConfig.description}。请用简洁友好的方式回答。`
+    : `你是「${agentName}」，一个智能 AI 助手。请用简洁友好的方式回答。`;
+
+  console.log('');
+  console.log(c.bold(`💬 与「${agentName}」对话`));
+  console.log(c.dim('   输入 /quit 退出'));
+  console.log('');
+
+  let provider: any;
+  try {
+    provider = createProvider({
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+    } as any);
+  } catch (err: any) {
+    console.log(`${c.red('✘')} 无法初始化模型: ${err.message}`);
+    console.log(c.dim(`  Provider: ${config.provider}, Model: ${config.model}`));
+    process.exit(1);
+  }
+
+  const messages: Array<{ role: string; content: string }> = [
+    { role: 'system', content: systemPrompt },
+  ];
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const askQuestion = (): void => {
+    rl.question(c.cyan('你: '), async (input: string) => {
+      const trimmed = input.trim();
+      if (!trimmed) { askQuestion(); return; }
+      if (trimmed === '/quit' || trimmed === '/exit' || trimmed === '/q') {
+        console.log(c.dim('\n👋 再见！'));
+        rl.close();
+        return;
+      }
+
+      messages.push({ role: 'user', content: trimmed });
+
+      try {
+        process.stdout.write(c.green(`${agentName}: `));
+        const response = await provider.chat(messages);
+        const reply = typeof response === 'string' ? response : response?.content || response?.message?.content || JSON.stringify(response);
+        console.log(reply);
+        console.log('');
+        messages.push({ role: 'assistant', content: reply });
+      } catch (err: any) {
+        console.log(c.red(`\n  错误: ${err.message}`));
+        console.log('');
+      }
+
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}