@yvhitxcel/opencode-remote 0.15.0

package/dist/patch_spawn.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'node:module';
+import Module from 'node:module';
+import { platform } from 'os';
+const require = createRequire(import.meta.url);
+const childProcess = require('node:child_process');
+// Suppress only DEP0190 warning (shell args concatenation) from SDK internals
+const originalEmit = process.emit;
+process.emit = function (name, warning) {
+    if (name === 'warning' && warning && warning.code === 'DEP0190') return;
+    return originalEmit.apply(this, arguments);
+};
+const originalSpawn = childProcess.spawn;
+childProcess.spawn = function patchedSpawn(command, args, options = {}) {
+    // On Windows, use shell for commands that need PATH resolution
+    const isWindows = platform() === 'win32';
+    if (isWindows && !options.shell && typeof command === 'string' && !command.includes('\\') && !command.includes('/')) {
+        options = { ...options, shell: true };
+    }
+    return originalSpawn.call(this, command, args, options);
+};
+const originalLoad = Module._load;
+Module._load = function (request, parent, isMain) {
+    const result = originalLoad.apply(this, arguments);
+    if (request === 'child_process' || request === 'node:child_process') {
+        result.spawn = childProcess.spawn;
+    }
+    return result;
+};

package/dist/plugins/agents/acp/acp-adapter.js

@@ -0,0 +1,42 @@
+// ACP (Agent Communication Protocol) remote agent adapter
+export class ACPAdapter {
+    name;
+    aliases;
+    config;
+    
+    constructor(config) {
+        this.name = config.name;
+        this.aliases = config.aliases || [];
+        this.config = config;
+    }
+    
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.config.endpoint}/health`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(5000),
+            });
+            return response.ok;
+        } catch {
+            return false;
+        }
+    }
+    
+    async sendPrompt(_sessionId, prompt, history) {
+        try {
+            const response = await fetch(`${this.config.endpoint}/prompt`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ prompt, history: history || [] }),
+                signal: AbortSignal.timeout(120000),
+            });
+            if (!response.ok) {
+                return `❌ ACP agent error: ${response.statusText}`;
+            }
+            const data = await response.json();
+            return data.text || data.content || JSON.stringify(data);
+        } catch (error) {
+            return `❌ ACP agent error: ${error.message}`;
+        }
+    }
+}

package/dist/plugins/agents/claude-code/index.js

@@ -0,0 +1,69 @@
+// Claude Code CLI agent adapter
+import { spawn } from 'child_process';
+import { platform } from 'os';
+
+export class ClaudeCodeAgentAdapter {
+    name = 'claude-code';
+    aliases = ['cc', 'claude'];
+
+    async isAvailable() {
+        return new Promise((resolve) => {
+            const command = platform() === 'win32' ? 'where' : 'which';
+            const proc = spawn(command, ['claude'], { stdio: 'ignore', shell: true });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
+        const projectDir = options.projectDir;
+        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+
+        // 构建命令参数
+        const args = ['--print', contextualPrompt];
+        // `cwd` is set via spawn opts below, no need for --project flag
+
+        return this.callClaude(args, projectDir);
+    }
+
+    buildContextualPrompt(prompt, history) {
+        if (!history || history.length === 0) return prompt;
+        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
+        return `Previous:\n${historyText}\n\n${prompt}`;
+    }
+
+    callClaude(args, projectDir) {
+        return new Promise((resolve) => {
+            const opts = {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            };
+            // 如果指定了项目目录，在该目录下执行
+            if (projectDir) {
+                opts.cwd = projectDir;
+            }
+
+            console.log(`[claude-code] Spawning: claude ${args.join(' ')} in ${opts.cwd || process.cwd()}`);
+            const proc = spawn('claude', args, opts);
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+
+            const timeout = setTimeout(() => {
+                console.log(`[claude-code] Process still running after 30s, stderr so far: ${stderr.slice(-200)}`);
+            }, 30000);
+
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                console.log(`[claude-code] Process exited with code ${code}, stdout=${stdout.length} bytes, stderr=${stderr.length} bytes`);
+                resolve(code === 0 ? stdout.trim() : `❌ Claude Code 错误: ${stderr}`);
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                console.log(`[claude-code] Spawn error: ${err.message}`);
+                resolve(`❌ Claude Code 启动失败: ${err.message}`);
+            });
+        });
+    }
+}

package/dist/plugins/agents/codex/index.js

@@ -0,0 +1,44 @@
+// OpenAI Codex CLI agent adapter
+import { spawn } from 'child_process';
+import { platform } from 'os';
+
+export class CodexAgentAdapter {
+    name = 'codex';
+    aliases = ['cx'];
+    
+    async isAvailable() {
+        return new Promise((resolve) => {
+            const command = platform() === 'win32' ? 'where' : 'which';
+            const proc = spawn(command, ['codex'], { stdio: 'ignore', shell: true });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    
+    async sendPrompt(_sessionId, prompt, history) {
+        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+        return this.callCodex(contextualPrompt);
+    }
+    
+    buildContextualPrompt(prompt, history) {
+        if (!history || history.length === 0) return prompt;
+        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
+        return `Context:\n${historyText}\n\n${prompt}`;
+    }
+    
+    callCodex(prompt) {
+        return new Promise((resolve) => {
+            const proc = spawn('codex', ['--prompt', prompt], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            proc.on('close', (code) => {
+                resolve(code === 0 ? stdout.trim() : `❌ Codex 错误: ${stderr}`);
+            });
+        });
+    }
+}

package/dist/plugins/agents/copilot/index.js

@@ -0,0 +1,44 @@
+// GitHub Copilot CLI agent adapter
+import { spawn } from 'child_process';
+import { platform } from 'os';
+
+export class CopilotAgentAdapter {
+    name = 'copilot';
+    aliases = ['copilot-cli', 'copilot'];
+    
+    async isAvailable() {
+        return new Promise((resolve) => {
+            const command = platform() === 'win32' ? 'where' : 'which';
+            const proc = spawn(command, ['copilot'], { stdio: 'ignore', shell: true });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    
+    async sendPrompt(_sessionId, prompt, history) {
+        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+        return this.callCopilot(contextualPrompt);
+    }
+    
+    buildContextualPrompt(prompt, history) {
+        if (!history || history.length === 0) return prompt;
+        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
+        return `Context:\n${historyText}\n\n${prompt}`;
+    }
+    
+    callCopilot(prompt) {
+        return new Promise((resolve) => {
+            const proc = spawn('copilot', ['suggest', '--prompt', prompt], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            proc.on('close', (code) => {
+                resolve(code === 0 ? stdout.trim() : `❌ Copilot 错误: ${stderr}`);
+            });
+        });
+    }
+}

package/dist/plugins/agents/opencode/index.js

@@ -0,0 +1,66 @@
+// OpenCode CLI agent adapter
+import { spawn } from 'child_process';
+import { platform } from 'os';
+
+export class OpenCodeAgentAdapter {
+    name = 'opencode';
+    aliases = ['oc', 'opencodeai'];
+    
+    async isAvailable() {
+        return new Promise((resolve) => {
+            const command = platform() === 'win32' ? 'where' : 'which';
+            const proc = spawn(command, ['opencode'], { stdio: 'ignore', shell: true });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    
+    async sendPrompt(_sessionId, prompt, history) {
+        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+        return this.callOpenCode(contextualPrompt);
+    }
+    
+    buildContextualPrompt(prompt, history) {
+        if (!history || history.length === 0) return prompt;
+        const historyText = history
+            .map(msg => `[${msg.role === 'user' ? 'User' : 'Assistant'}]: ${msg.content}`)
+            .join('\n\n');
+        return `Previous conversation:\n${historyText}\n\nCurrent request: ${prompt}`;
+    }
+    
+    callOpenCode(prompt) {
+        return new Promise((resolve) => {
+            const proc = spawn('opencode', ['run', '--format', 'json', prompt], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+            
+            let stdout = '';
+            let stderr = '';
+            let fullText = '';
+            
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+                const lines = stdout.split('\n');
+                stdout = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim()) continue;
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.text) fullText += event.text;
+                    } catch {}
+                }
+            });
+            
+            proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            
+            proc.on('close', (code) => {
+                if (code !== 0) {
+                    resolve(`❌ OpenCode 错误。请运行 \`opencode auth login\` 配置认证。`);
+                } else {
+                    resolve(fullText || '完成');
+                }
+            });
+        });
+    }
+}

package/dist/telegram/bot.js

@@ -0,0 +1,288 @@
+// Telegram Bot adapter with multi-agent support
+import { Bot } from 'grammy';
+import { splitMessage } from '../utils/message-split.js';
+import { registry } from '../core/registry.js';
+import { sessionManager } from '../core/session.js';
+import { initOpenCode, createSession, sendMessage as sendToOpenCode, checkConnection } from '../opencode/client.js';
+import { parseMessage, routeMessage } from '../core/router.js';
+
+export class TelegramAdapter {
+    name = 'telegram';
+    bot = null;
+    config = null;
+    messageHandler = null;
+    isRunning = false;
+    typingIntervals = new Map();
+    
+    async start(config) {
+        this.config = config;
+        
+        if (!config.telegramBotToken || config.telegramBotToken === 'your_bot_token_here') {
+            throw new Error('Telegram bot token not configured. Run "opencode-remote config" first.');
+        }
+        
+        this.bot = new Bot(config.telegramBotToken);
+        
+        this.bot.on('message:text', async (ctx) => {
+            console.log('[Telegram] Received message:', ctx.message.text);
+            
+            if (ctx.message.from.is_bot) {
+                console.log('[Telegram] Ignoring bot message');
+                return;
+            }
+            
+            if (!this.messageHandler) {
+                console.log('[Telegram] No message handler registered');
+                return;
+            }
+            
+            try {
+                const message = {
+                    id: ctx.message.message_id.toString(),
+                    threadId: ctx.chat.id.toString(),
+                    userId: ctx.message.from?.id?.toString() || 'unknown',
+                    text: ctx.message.text || '',
+                    timestamp: new Date(ctx.message.date * 1000),
+                    channelId: 'default',
+                };
+                
+                const msgCtx = {
+                    message,
+                    platform: 'telegram',
+                    channelId: 'default',
+                };
+                
+                await this.messageHandler(msgCtx);
+            } catch (err) {
+                console.error('[Telegram] Error in message handler:', err);
+            }
+        });
+        
+        this.bot.start().then(() => {
+            console.log('[Telegram] Bot stopped gracefully');
+        }).catch((err) => {
+            if (this.isRunning) {
+                console.error('[Telegram] Bot polling error:', err);
+            }
+        });
+        
+        this.isRunning = true;
+        console.log('🚀 Telegram adapter started');
+    }
+    
+    async stop() {
+        this.isRunning = false;
+        
+        for (const interval of this.typingIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.typingIntervals.clear();
+        
+        if (this.bot) {
+            await this.bot.stop();
+            this.bot = null;
+        }
+        
+        console.log('👋 Telegram adapter stopped');
+    }
+    
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    
+    async sendMessage(threadId, text) {
+        if (!this.bot) {
+            throw new Error('Telegram adapter not started');
+        }
+        
+        const chunks = splitMessage(text, { maxLength: 4000, addContinuationMarker: false });
+        
+        for (const chunk of chunks) {
+            await this.bot.api.sendMessage(threadId, chunk, { parse_mode: 'Markdown' });
+        }
+    }
+    
+    async sendTyping(threadId, isTyping) {
+        if (!this.bot) {
+            return;
+        }
+        
+        if (isTyping) {
+            try {
+                await this.bot.api.sendChatAction(threadId, 'typing');
+            } catch {
+                // Ignore errors
+            }
+            
+            const existing = this.typingIntervals.get(threadId);
+            if (existing) {
+                clearInterval(existing);
+            }
+            
+            const interval = setInterval(async () => {
+                try {
+                    await this.bot.api.sendChatAction(threadId, 'typing');
+                } catch {
+                    // Ignore errors
+                }
+            }, 4000);
+            
+            this.typingIntervals.set(threadId, interval);
+        } else {
+            const interval = this.typingIntervals.get(threadId);
+            if (interval) {
+                clearInterval(interval);
+                this.typingIntervals.delete(threadId);
+            }
+        }
+    }
+}
+
+export const telegramAdapter = new TelegramAdapter();
+
+// Legacy startBot function for backward compatibility
+export async function startBot() {
+    const { loadConfig } = await import('../core/config.js');
+    const config = loadConfig();
+    
+    if (!config.telegramBotToken || config.telegramBotToken === 'your_bot_token_here') {
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('  ❌ Telegram Bot Token not configured');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        console.log('  To get your bot token:');
+        console.log('  1. Open Telegram app');
+        console.log('  2. Search for @BotFather');
+        console.log('  3. Send: /newbot');
+        console.log('  4. Follow the instructions to create your bot');
+        console.log('  5. Copy the token');
+        console.log('');
+        console.log('  Then run: opencode-remote config');
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        process.exit(1);
+    }
+    
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  OpenCode Remote Control');
+    console.log('  Control OpenCode from Telegram');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    
+    // Initialize session manager
+    await sessionManager.start();
+    
+    // Load plugins
+    await registry.loadBuiltInPlugins();
+    
+    // Initialize Telegram adapter
+    await telegramAdapter.start(config);
+    
+    // Set up message handler
+    let openCodeSessions = new Map();
+    let opencodeSessionId = null;
+
+    telegramAdapter.onMessage(async (ctx) => {
+        const { message, platform, channelId } = ctx;
+
+        telegramAdapter.sendTyping(message.threadId, true).catch(() => {});
+
+        try {
+            const parsed = parseMessage(message.text);
+
+            if (parsed.type === 'command' && parsed.command === 'reset') {
+                openCodeSessions.delete(message.threadId);
+                opencodeSessionId = null;
+                try {
+                    const session = await sessionManager.getExistingSession(platform, channelId, message.threadId);
+                    if (session) await sessionManager.resetConversation(platform, channelId, message.threadId);
+                } catch (e) { console.warn('[Telegram] Error resetting session:', e.message); }
+            }
+
+            if (parsed.type === 'default') {
+                const connected = await checkConnection();
+                if (!connected) {
+                    await telegramAdapter.sendTyping(message.threadId, false);
+                    await telegramAdapter.sendMessage(message.threadId, '❌ OpenCode 离线，请检查服务是否运行');
+                    return;
+                }
+
+                let session = openCodeSessions.get(message.threadId);
+                if (!session) {
+                    const newSession = await createSession(message.threadId, `Telegram ${message.threadId}`);
+                    if (!newSession) {
+                        await telegramAdapter.sendTyping(message.threadId, false);
+                        await telegramAdapter.sendMessage(message.threadId, '❌ 无法创建 OpenCode 会话');
+                        return;
+                    }
+                    session = newSession;
+                    openCodeSessions.set(message.threadId, session);
+                }
+                opencodeSessionId = session.sessionId;
+
+                const response = await sendToOpenCode(session, parsed.prompt, {
+                    onTextDelta: () => {},
+                    onEvent: (event) => {
+                        if (event.type === 'tool.call') {
+                            const props = event.properties || {};
+                            const toolName = props.name || 'unknown';
+                            telegramAdapter.sendMessage(message.threadId, `🔧 ${toolName}`).catch(() => {});
+                        }
+                    },
+                });
+
+                await telegramAdapter.sendTyping(message.threadId, false);
+
+                if (response) {
+                    const chunks = splitMessage(response);
+                    for (const chunk of chunks) {
+                        if (chunk.trim()) await telegramAdapter.sendMessage(message.threadId, chunk);
+                    }
+                }
+                return;
+            }
+
+            const result = await routeMessage(parsed, {
+                threadId: message.threadId,
+                channelId,
+                platform,
+                defaultAgent: 'opencode',
+                opencodeSessionId,
+            });
+
+            await telegramAdapter.sendTyping(message.threadId, false);
+
+            if (typeof result === 'string') {
+                await telegramAdapter.sendMessage(message.threadId, result);
+            } else if (result) {
+                let fullResponse = '';
+                for await (const chunk of result) {
+                    fullResponse += chunk;
+                }
+                if (fullResponse) await telegramAdapter.sendMessage(message.threadId, fullResponse);
+            }
+        } catch (error) {
+            console.error('Error handling message:', error);
+            await telegramAdapter.sendTyping(message.threadId, false);
+            await telegramAdapter.sendMessage(message.threadId, '❌ 处理失败，请重试。');
+        }
+    });
+    
+    console.log('🚀 Starting Telegram bot...');
+    console.log('');
+    console.log('Available commands:');
+    console.log('  /start - Start bot');
+    console.log('  /help - Show all commands');
+    console.log('  /agents - List available agents');
+    console.log('  /new - Start new conversation');
+    console.log('  /reset - Reset session');
+    console.log('  /oc <prompt> - Use OpenCode');
+    console.log('  /cc <prompt> - Use Claude Code');
+    console.log('  /cx <prompt> - Use Codex');
+    console.log('');
+    
+    // Keep process alive
+    await new Promise(() => {});
+}

package/dist/utils/message-split.js

@@ -0,0 +1,38 @@
+// Shared message splitting utility
+export function splitMessage(text, options = {}) {
+    const { maxLength = 2000, addContinuationMarker = true, continuationMarker = '\n\n[continued...]' } = options;
+    
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    
+    const chunks = [];
+    let remaining = text;
+    
+    while (remaining.length > maxLength) {
+        let splitPoint = remaining.lastIndexOf('\n```\n', maxLength);
+        if (splitPoint < maxLength / 2) {
+            splitPoint = remaining.lastIndexOf('\n\n', maxLength);
+        }
+        if (splitPoint < maxLength / 2) {
+            splitPoint = remaining.lastIndexOf('\n', maxLength);
+        }
+        if (splitPoint < maxLength / 2) {
+            splitPoint = maxLength;
+        }
+        chunks.push(remaining.slice(0, splitPoint).trim());
+        remaining = remaining.slice(splitPoint).trim();
+    }
+    
+    if (remaining) {
+        chunks.push(remaining);
+    }
+    
+    if (addContinuationMarker && chunks.length > 1) {
+        for (let i = 0; i < chunks.length - 1; i++) {
+            chunks[i] += continuationMarker;
+        }
+    }
+    
+    return chunks;
+}