opc-agent 3.0.1 → 4.0.1

package/dist/channels/signal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalChannel = void 0;
+const index_1 = require("./index");
+class SignalChannel extends index_1.BaseChannel {
+    type = 'signal';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('signal-cli');
+        }
+        catch {
+            throw new Error('Install signal-cli to use the SignalChannel. Run: npm install signal-cli');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('SignalChannel: not yet connected. Call start() first.');
+    }
+}
+exports.SignalChannel = SignalChannel;
+//# sourceMappingURL=signal.js.map

package/dist/channels/sms.d.ts

@@ -0,0 +1,15 @@
+import { BaseChannel } from './index';
+export interface SMSChannelConfig {
+    accountSid?: string;
+    authToken?: string;
+    fromNumber?: string;
+}
+export declare class SMSChannel extends BaseChannel {
+    readonly type = "sms";
+    private config;
+    constructor(config?: SMSChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(chatId: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=sms.d.ts.map

package/dist/channels/sms.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMSChannel = void 0;
+const index_1 = require("./index");
+class SMSChannel extends index_1.BaseChannel {
+    type = 'sms';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('twilio');
+        }
+        catch {
+            throw new Error('Install twilio to use the SMSChannel. Run: npm install twilio');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('SMSChannel: not yet connected. Call start() first.');
+    }
+}
+exports.SMSChannel = SMSChannel;
+//# sourceMappingURL=sms.js.map

package/dist/channels/twitch.d.ts

@@ -0,0 +1,17 @@
+import { BaseChannel } from './index';
+export interface TwitchChannelConfig {
+    username: string;
+    oauthToken: string;
+    channels: string[];
+}
+export declare class TwitchChannel extends BaseChannel {
+    readonly type = "twitch";
+    private config;
+    private client;
+    private running;
+    constructor(config: TwitchChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(channel: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=twitch.d.ts.map

package/dist/channels/twitch.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwitchChannel = void 0;
+const index_1 = require("./index");
+class TwitchChannel extends index_1.BaseChannel {
+    type = 'twitch';
+    config;
+    client = null;
+    running = false;
+    constructor(config) {
+        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() {
+        let tmi;
+        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, tags, message, self) => {
+            if (self || !this.handler)
+                return;
+            const msg = {
+                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() {
+        if (this.client) {
+            await this.client.disconnect();
+            this.client = null;
+        }
+        this.running = false;
+    }
+    async send(channel, text) {
+        if (!this.running || !this.client) {
+            throw new Error('TwitchChannel: not started. Call start() first.');
+        }
+        await this.client.say(channel, text);
+    }
+}
+exports.TwitchChannel = TwitchChannel;
+//# sourceMappingURL=twitch.js.map

package/dist/channels/voice-call.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+export interface VoiceCallConfig {
+    provider: 'twilio' | 'vonage' | 'webrtc' | 'sip';
+    credentials?: Record<string, string>;
+    sttProvider?: string;
+    ttsProvider?: string;
+}
+export declare class VoiceCallManager extends EventEmitter {
+    private config;
+    private calls;
+    private audioListeners;
+    constructor(config: VoiceCallConfig);
+    private ensureCredentials;
+    startCall(to: string): Promise<string>;
+    endCall(callId: string): Promise<void>;
+    onIncoming(callback: (callId: string, from: string) => void): void;
+    simulateIncoming(from: string): string;
+    sendAudio(callId: string, audio: Buffer): Promise<void>;
+    onAudio(callId: string, callback: (audio: Buffer) => void): void;
+    getCallStatus(callId: string): 'ringing' | 'active' | 'ended';
+    listActiveCalls(): Array<{
+        callId: string;
+        from: string;
+        startedAt: number;
+    }>;
+}
+//# sourceMappingURL=voice-call.d.ts.map

package/dist/channels/voice-call.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceCallManager = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+class VoiceCallManager extends events_1.EventEmitter {
+    config;
+    calls = new Map();
+    audioListeners = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    ensureCredentials() {
+        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) {
+        this.ensureCredentials();
+        const callId = (0, crypto_1.randomUUID)();
+        const call = {
+            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) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error(`Call ${callId} not found`);
+        call.status = 'ended';
+        this.audioListeners.delete(callId);
+    }
+    onIncoming(callback) {
+        this.on('incoming', callback);
+    }
+    simulateIncoming(from) {
+        const callId = (0, crypto_1.randomUUID)();
+        const call = { callId, from, to: 'self', status: 'ringing', startedAt: Date.now() };
+        this.calls.set(callId, call);
+        this.emit('incoming', callId, from);
+        return callId;
+    }
+    async sendAudio(callId, audio) {
+        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, callback) {
+        const listeners = this.audioListeners.get(callId) || [];
+        listeners.push(callback);
+        this.audioListeners.set(callId, listeners);
+    }
+    getCallStatus(callId) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error(`Call ${callId} not found`);
+        return call.status;
+    }
+    listActiveCalls() {
+        return Array.from(this.calls.values())
+            .filter(c => c.status !== 'ended')
+            .map(({ callId, from, startedAt }) => ({ callId, from, startedAt }));
+    }
+}
+exports.VoiceCallManager = VoiceCallManager;
+//# sourceMappingURL=voice-call.js.map

package/dist/channels/whatsapp.d.ts

@@ -0,0 +1,14 @@
+import { BaseChannel } from './index';
+export interface WhatsAppChannelConfig {
+    phoneNumber?: string;
+    authDir?: string;
+}
+export declare class WhatsAppChannel extends BaseChannel {
+    readonly type = "whatsapp";
+    private config;
+    constructor(config?: WhatsAppChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(chatId: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=whatsapp.d.ts.map

package/dist/channels/whatsapp.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppChannel = void 0;
+const index_1 = require("./index");
+class WhatsAppChannel extends index_1.BaseChannel {
+    type = 'whatsapp';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('@whiskeysockets/baileys');
+        }
+        catch {
+            throw new Error('Install @whiskeysockets/baileys to use the WhatsAppChannel. Run: npm install @whiskeysockets/baileys');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('WhatsAppChannel: not yet connected. Call start() first.');
+    }
+}
+exports.WhatsAppChannel = WhatsAppChannel;
+//# sourceMappingURL=whatsapp.js.map

package/dist/cli/chat.d.ts

@@ -0,0 +1,2 @@
+export declare function runChat(): Promise<void>;
+//# sourceMappingURL=chat.d.ts.map

package/dist/cli/chat.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChat = runChat;
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const providers_1 = require("../providers");
+const OPC_HOME = path.join(os.homedir(), '.opc');
+const CONFIG_PATH = path.join(OPC_HOME, 'config.json');
+const c = {
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+function loadConfig() {
+    if (!fs.existsSync(CONFIG_PATH))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+async function runChat() {
+    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 = {};
+    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;
+    try {
+        provider = (0, providers_1.createProvider)({
+            provider: config.provider,
+            model: config.model,
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+        });
+    }
+    catch (err) {
+        console.log(`${c.red('✘')} 无法初始化模型: ${err.message}`);
+        console.log(c.dim(`  Provider: ${config.provider}, Model: ${config.model}`));
+        process.exit(1);
+    }
+    const messages = [
+        { role: 'system', content: systemPrompt },
+    ];
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const askQuestion = () => {
+        rl.question(c.cyan('你: '), async (input) => {
+            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) {
+                console.log(c.red(`\n  错误: ${err.message}`));
+                console.log('');
+            }
+            askQuestion();
+        });
+    };
+    askQuestion();
+}
+//# sourceMappingURL=chat.js.map

package/dist/cli/setup.d.ts

@@ -0,0 +1,4 @@
+import * as readline from 'readline';
+export declare function createRL(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): readline.Interface;
+export declare function runSetup(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map