@yvhitxcel/opencode-remote 0.15.0

package/README.md

@@ -0,0 +1,82 @@
+# OpenCode Remote
+
+通过微信、Telegram、飞书等平台随时随地控制 OpenCode。
+
+## 功能特性
+
+- **多平台支持** — 微信、飞书、Telegram
+- **多 AI Agent** — OpenCode、Claude Code、Codex、GitHub Copilot
+- **会话管理** — 多会话并行，自动保存与恢复
+- **智能循环任务** — 长时间任务自动循环执行
+
+## 安装
+
+```bash
+npm install -g opencode-remote
+```
+
+## 快速开始
+
+```bash
+# 微信
+opencode-remote weixin
+
+# 飞书
+opencode-remote feishu
+
+# Telegram
+opencode-remote telegram
+```
+
+## 平台兼容性
+
+| 指令 | 说明 | 微信 | 飞书 | Telegram |
+|------|------|:----:|:----:|:--------:|
+| `/start` | 认领所有权 | ✅ | ✅ | ✅ |
+| `/help` | 显示帮助 | ✅ | ✅ | ✅ |
+| `/status` | 查看状态 | ✅ | ✅ | ✅ |
+| `/reset` | 重置会话 | ✅ | ✅ | ✅ |
+| `/restart` | 重启 Bot | ✅ | ✅ | ✅ |
+| `/stop` | 停止 Bot | ✅ | ✅ | ✅ |
+| `/sessions` | 浏览会话 | ✅ | ✅ | ✅ |
+| `/delsessions` | 删除会话 | ✅ | ✅ | ✅ |
+| `/loop` | 循环任务 | ✅ | ✅ | ✅ |
+| `/refresh` | 刷新上下文 | ✅ | ✅ | ✅ |
+| `/copy` | 复制回复 | ✅ | ✅ | ✅ |
+| `/revert` | 撤销消息 | ✅ | ✅ | ✅ |
+| `/model` | 切换 AI 模型 | ✅ | ✅ | ✅ |
+| `/agents` | 查看 Agent | ✅ | ✅ | ✅ |
+| `/oc` | 使用 OpenCode | ✅ | ✅ | ✅ |
+| `/cc` | 使用 Claude Code | ✅ | ✅ | ✅ |
+| `/edit` | 编辑消息 | ✅ | ✅ | ✅ |
+| `/upload` | 上传文件(需七牛云) | ✅ | ✅ | ✅ |
+| `/delete` | 删除上传文件 | ✅ | ✅ | ✅ |
+| `/diagnose` | 系统诊断 | ✅ | ✅ | ✅ |
+| `/expert` `/z` | 专家评审模式 | ✅ | ✅ | ✅ |
+
+> ✅ 可用   ❌ 未实现
+
+## 快速使用
+
+```bash
+# Telegram（最快，5分钟）
+opencode-remote telegram
+
+# 微信
+opencode-remote weixin
+
+# 飞书（需要企业版飞书账号）
+opencode-remote feishu
+```
+
+## 配置说明
+
+首次运行会在 `~/.opencode-remote/` 目录生成配置。详见 `.env.example`。
+
+## 系统要求
+
+- Node.js >= 18.0.0
+
+## 许可证
+
+MIT License

package/bin/opencode-remote.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = join(__dirname, '../dist/cli.js');
+
+let childProc = null;
+let shuttingDown = false;
+
+function spawnBot() {
+    if (shuttingDown) return;
+    if (childProc) {
+        try { childProc.kill('SIGTERM'); } catch {}
+    }
+
+    const args = process.argv.slice(2);
+
+    childProc = spawn('node', [cliPath, ...args], {
+        stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+        windowsHide: true,
+    });
+
+    // 转发输出
+    childProc.stdout.on('data', (d) => process.stdout.write(d));
+    childProc.stderr.on('data', (d) => process.stderr.write(d));
+
+    // 监听退出 - code 0 是正常停止，code 200 是 restart，其他是崩溃
+    childProc.on('close', (code) => {
+        console.log(`[parent] Child process closed with code: ${code}`);
+        if (shuttingDown) {
+            console.log('[parent] Shutting down, not restarting');
+            return;
+        }
+        if (code === 200 || code === null) {
+            // 200 = restart 命令，其他 null = 崩溃
+            console.log(`\n🔄 Bot exited (code ${code}), restarting...`);
+            setTimeout(spawnBot, 1000);
+        } else {
+            console.log(`[parent] Bot exited with code ${code}, not restarting`);
+        }
+    });
+}
+
+// 处理来自子进程的消息
+process.on('message', (msg) => {
+    if (msg === 'restart') {
+        console.log('\n[parent] Received restart signal from child');
+        shuttingDown = true;
+        if (childProc) {
+            childProc.kill('SIGTERM');
+        }
+        console.log('[parent] Restarting bot...');
+        shuttingDown = false;
+        setTimeout(spawnBot, 500);
+    }
+});
+
+// Handle Ctrl+C
+process.on('SIGINT', () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log('\nShutting down...');
+    if (childProc) childProc.kill('SIGTERM');
+    setTimeout(() => process.exit(0), 1000);
+});
+
+spawnBot();

package/bin/opencode-weixin.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = join(__dirname, '../dist/cli.js');
+
+spawn('node', [cliPath, 'weixin', ...process.argv.slice(1)], { stdio: 'inherit' });

package/dist/AGENTS.md

@@ -0,0 +1,20 @@
+# 项目开发指南 (AGENTS.md)
+
+> **记忆系统**: 每次会话必须加载 @MEMORY.md 获取项目记忆、技术决策和历史教训。
+
+---
+
+## 技术栈
+- **运行环境**: Node.js (CommonJS)
+- **核心功能**: 远程控制 OpenCode CLI, 记忆持久化层
+- **集成平台**: 微信 (WeChat), 飞书 (Feishu), Telegram
+
+## 关键命令
+- **启动**: `npm start` (根据 package.json 确定)
+- **部署**: 部署至 `node_modules/opencode-remote-control/dist`
+
+## 核心逻辑与规范
+1. **记忆存储**: 所有用户偏好和项目知识必须存储在 `~/.opencode-remote/memory/` (JSON 格式)，严禁存储在代码目录内。
+2. **注入机制**: 采用“拦截 -> 检索 -> 注入”流程，在转发指令给 OpenCode 前，由 `memory-manager.js` 检索相关记忆并静默注入 System Prompt。
+3. **代码风格**: 保持 CommonJS 风格，禁止在 dist 目录下创建临时测试文件。
+4. **纯净度**: 保持 `dist` 目录仅包含生产代码、必要配置文件及 `.md` 指南。

package/dist/MEMORY.md

@@ -0,0 +1,21 @@
+# MEMORY.md — 项目记忆
+
+## 核心决策
+- **记忆架构**: 采用全自动记忆层，存储路径统一为 `~/.opencode-remote/memory/`。
+- **注入流程**: 在 `bot.js` 的 `forwardToOpenCode` 阶段通过 `memory-manager.js` 自动检索并注入上下文。
+- **数据格式**: 采用 JSON 格式存储 `user_preferences.json` 和 `project_knowledge.json`。
+
+## 经验教训
+- [2026-04-11] 避免在 `dist` 目录下创建临时测试文件或实验性目录（如 `openchat`），确保生产环境纯净。
+- [2026-04-11] 记忆存储必须与代码目录分离，防止更新部署时数据丢失。
+
+## 主题文件路由表
+| 触发词 | 文件 | 说明 |
+|--------|------|------|
+| 记忆存储 | `.opencode-remote/memory/*.json` | 用户偏好与项目知识库 |
+| 注入逻辑 | `dist/weixin/bot.js` | 指令拦截与 Prompt 注入实现 |
+| 记忆管理 | `dist/weixin/memory-manager.js` | JSON 持久化读写逻辑 |
+
+## 待办/开放线程
+- [ ] 实现自动反思机制 (Reflection Loop)：任务完成后自动提取规律并写入记忆。
+- [ ] 优化 Token 截断与内存压缩逻辑。

package/dist/bot-runner.js

@@ -0,0 +1,180 @@
+// OpenCode Remote Control - Bot runner module
+import { loadConfig } from './core/config.js';
+import { hasTelegramConfig, hasFeishuConfig, hasWeixinConfig, printBanner } from './core/setup.js';
+import { startBot } from './telegram/bot.js';
+import { startFeishuBot } from './feishu/bot.js';
+import { startWeixinBot } from './weixin/bot.js';
+import { registry } from './core/registry.js';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export function createShutdownHandler() {
+    let isShuttingDown = false;
+    return () => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.log('\n🛑 Shutting down...');
+        setTimeout(() => {
+            console.log('Goodbye!');
+            process.exit(0);
+        }, 1000);
+    };
+}
+
+export async function runAgentsCommand() {
+    printBanner();
+    console.log('🤖 Available Agents\n');
+
+    await registry.loadBuiltInPlugins();
+
+    const agents = registry.listAgents();
+
+    if (agents.length === 0) {
+        console.log('No agents registered yet.');
+        console.log('');
+        console.log('Install an agent to get started:');
+        console.log('  • OpenCode: npm i -g opencode-ai');
+        console.log('  • Claude Code: npm i -g @anthropic-ai/claude-code');
+        console.log('  • Codex: npm i -g @openai/codex');
+        console.log('  • Copilot: gh extension install github/gh-copilot');
+        return;
+    }
+
+    console.log('Checking agent availability...\n');
+
+    const results = await Promise.allSettled(agents.map(async (name) => {
+        const agent = registry.getAgent(name);
+        const available = await agent?.isAvailable().catch(() => false);
+        return { name, available, aliases: agent?.aliases || [] };
+    }));
+
+    for (const result of results) {
+        if (result.status === 'fulfilled') {
+            const { name, available, aliases } = result.value;
+            const aliasStr = aliases.length ? ` (${aliases.join(', ')})` : '';
+            console.log(`  ${available ? '✅' : '❌'} ${name}${aliasStr}`);
+        }
+    }
+
+    console.log('\nUse /<agent> in chat to switch agents.');
+    console.log('Example: /cc to switch to Claude Code');
+}
+
+export async function runStart() {
+    const config = await loadConfig();
+    const hasTelegram = hasTelegramConfig(config);
+    const hasFeishu = hasFeishuConfig(config);
+    const hasWeixin = hasWeixinConfig();
+    if (!hasTelegram && !hasFeishu && !hasWeixin) {
+        console.log('❌ No bots configured!');
+        console.log('\nRun: opencode-remote config');
+        process.exit(1);
+    }
+
+    let shuttingDown = false;
+    const childProcs = [];
+
+    if (hasWeixin) {
+        runWeixinOnly();
+        return;
+    }
+
+    const promises = [];
+    if (hasTelegram) {
+        console.log('🤖 Starting Telegram bot...');
+        process.env.TELEGRAM_BOT_TOKEN = config.telegramBotToken;
+        promises.push(startBot().catch((err) => {
+            console.error('Telegram bot failed:', err);
+            return { status: 'rejected', reason: err };
+        }));
+    }
+    if (hasFeishu) {
+        console.log('🤖 Starting Feishu bot...');
+        promises.push(startFeishuBot(config).catch((err) => {
+            console.error('Feishu bot failed:', err);
+            return { status: 'rejected', reason: err };
+        }));
+    }
+
+    if (promises.length > 0) {
+        const results = await Promise.allSettled(promises);
+        const failed = results.filter((r) => r.status === 'rejected');
+        if (failed.length > 0) {
+            console.log(`\n⚠️ ${failed.length} bot(s) failed to start`);
+            process.exit(1);
+        }
+    }
+
+    if (!hasWeixin) {
+        console.log('\n✅ All bots started!');
+    }
+
+    process.once('SIGINT', () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        console.log('\n🛑 Shutting down...');
+        for (const p of childProcs) { try { p.kill('SIGTERM'); } catch {} }
+        setTimeout(() => process.exit(0), 2000);
+    });
+    process.once('SIGTERM', () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        for (const p of childProcs) { try { p.kill('SIGTERM'); } catch {} }
+        setTimeout(() => process.exit(0), 2000);
+    });
+
+    await new Promise(() => {});
+}
+
+export async function runTelegramOnly() {
+    const config = await loadConfig();
+    if (!hasTelegramConfig(config)) {
+        console.log('❌ Telegram bot not configured!');
+        console.log('\nRun: opencode-remote config');
+        process.exit(1);
+    }
+    printBanner();
+    console.log('🤖 Starting Telegram bot...');
+    process.env.TELEGRAM_BOT_TOKEN = config.telegramBotToken;
+    try {
+        await startBot();
+    }
+    catch (error) {
+        console.error('Failed to start:', error);
+        process.exit(1);
+    }
+}
+
+export async function runFeishuOnly() {
+    const config = await loadConfig();
+    if (!hasFeishuConfig(config)) {
+        console.log('❌ Feishu bot not configured!');
+        console.log('\nRun: opencode-remote config');
+        process.exit(1);
+    }
+    printBanner();
+    console.log('🤖 Starting Feishu bot...');
+    try {
+        await startFeishuBot(config);
+    }
+    catch (error) {
+        console.error('Failed to start:', error);
+        process.exit(1);
+    }
+}
+
+export async function runWeixinOnly() {
+    const config = await loadConfig();
+    printBanner();
+    console.log('🤖 Starting Weixin bot...');
+    try {
+        await startWeixinBot(config);
+    }
+    catch (error) {
+        console.error('Bot error:', error.message);
+        process.exit(1);
+    }
+}
+
+

package/dist/cli.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+// OpenCode Remote Control - CLI entry point
+import { watch } from 'fs';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { setGlobalProxy } from './opencode/client.js';
+import { printBanner, VERSION, runConfig, runConfigTimeout } from './core/setup.js';
+import { runStart, runTelegramOnly, runFeishuOnly, runWeixinOnly, runAgentsCommand } from './bot-runner.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function printHelp() {
+    console.log(`
+Usage: opencode-remote [command]
+
+Commands:
+  start              Start all configured bots (default)
+  telegram           Start Telegram bot only
+  feishu             Start Feishu bot only
+  weixin             Start Weixin (微信) bot only
+  config             Configure a channel (interactive selection)
+  config timeout     Set request timeout (for long-running tasks)
+  agents             List available AI agents
+  help               Show this help message
+  version            Show version information
+
+Options:
+  -v, --version      Show version number
+  --proxy <url>      Use HTTP/HTTPS proxy for all requests
+                     (e.g., --proxy http://192.168.1.100:7890)
+  --id <name>        Instance ID for multi-bot support
+                     (e.g., --id bot1, --id bot2)
+
+Proxy Configuration:
+  You can also set proxy via environment variables:
+    HTTP_PROXY, HTTPS_PROXY, ALL_PROXY
+
+Multi-Bot Support:
+  Run multiple Weixin bots with different accounts:
+    opencode-remote weixin --id bot1   # First Weixin account
+    opencode-remote weixin --id bot2   # Second Weixin account
+
+  Each instance has its own credentials and sessions.
+
+Weixin Bot Commands (send in WeChat):
+  /start — Claim ownership
+  /help — Show all commands
+  /status — Check connection
+  /stop — Interrupt task
+  /reset — Reset session
+  /restart — Restart bot
+  /sessions — Browse sessions
+  /delsessions — Delete sessions
+  /loop — Loop task
+  /refresh — Refresh context
+  /copy — Copy latest reply
+  /revert — Undo last message
+  /upload — Upload build artifacts
+  /model — Switch AI model
+
+Multi-Agent Commands:
+  /oc <prompt> — Use OpenCode (default)
+  /cc <prompt> — Use Claude Code
+  /cx <prompt> — Use Codex
+  /copilot <prompt> — Use GitHub Copilot
+  /agents — List all available agents
+
+Examples:
+  opencode-remote              # Start all bots
+  opencode-remote start        # Start all bots
+  opencode-remote telegram     # Start Telegram only
+  opencode-remote feishu       # Start Feishu only
+  opencode-remote weixin       # Start Weixin only
+  opencode-remote weixin --id bot1   # Start Weixin bot1
+  opencode-remote weixin --id bot2   # Start Weixin bot2
+  opencode-remote config       # Interactive channel selection
+  opencode-remote config timeout  # Set request timeout
+  opencode-remote --version    # Show version
+  opencode-remote --proxy http://192.168.1.100:7890  # With proxy
+`);
+}
+
+// Main CLI
+// 父进程管理：如果不是子进程，则启动父进程模式
+if (process.env.OPENCODE_CHILD !== '1') {
+    let childProc = null;
+    let shuttingDown = false;
+    let isRestart = false;
+
+    const spawnChild = (fromRestart = false) => {
+        if (shuttingDown) return;
+        if (childProc) {
+            try { childProc.kill('SIGTERM'); } catch {}
+        }
+
+        const args = process.argv.slice(2);
+        const childEnv = { ...process.env, OPENCODE_CHILD: '1' };
+        if (fromRestart) {
+            childEnv.OPENCODE_RESTART = '1';
+        }
+        childProc = spawn('node', [process.argv[1], ...args], {
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: childEnv,
+            windowsHide: true,
+        });
+
+        childProc.stdout.on('data', (d) => process.stdout.write(d));
+        childProc.stderr.on('data', (d) => process.stderr.write(d));
+
+        childProc.on('close', (code) => {
+            console.log(`[parent] Child process closed with code: ${code}`);
+            if (shuttingDown) {
+                console.log('[parent] Shutting down, not restarting');
+                return;
+            }
+            if (code === 200 || code === null) {
+                console.log(`\n🔄 Bot exited (code ${code}), restarting...`);
+                isRestart = true;
+                setTimeout(() => spawnChild(true), 1000);
+            } else {
+                console.log(`[parent] Bot exited with code ${code}, not restarting`);
+            }
+        });
+
+        childProc.on('error', (err) => {
+            console.error('[parent] Child error:', err.message);
+        });
+    };
+
+    // 文件监控 - 代码变化时自动重启
+    const distDir = __dirname;
+    let debounceTimer = null;
+    watch(distDir, { recursive: true }, (eventType, filename) => {
+        if (filename && filename.endsWith('.js') && !shuttingDown) {
+            clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => {
+                console.log(`\n📝 ${filename} changed, restarting...`);
+                if (childProc) {
+                    isRestart = true;
+                    childProc.kill('SIGTERM');
+                }
+            }, 500);
+        }
+    });
+
+    process.on('SIGINT', () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        console.log('\nShutting down...');
+        if (childProc) childProc.kill('SIGTERM');
+        setTimeout(() => process.exit(0), 1000);
+    });
+
+    process.on('SIGTERM', () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        if (childProc) childProc.kill('SIGTERM');
+        setTimeout(() => process.exit(0), 1000);
+    });
+
+    spawnChild();
+} else {
+    runCli();
+}
+
+function runCli() {
+    const args = process.argv.slice(2);
+    let proxyUrl = null;
+    let instanceId = null;
+    let command = 'start';
+    let subCommand = null;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--proxy') {
+            proxyUrl = args[++i];
+            if (!proxyUrl) {
+                console.error('Error: --proxy requires a URL argument');
+                process.exit(1);
+            }
+        }
+        else if (arg.startsWith('--proxy=')) {
+            proxyUrl = arg.slice('--proxy='.length);
+        }
+        else if (arg === '--id') {
+            instanceId = args[++i];
+            if (!instanceId) {
+                console.error('Error: --id requires an argument');
+                process.exit(1);
+            }
+        }
+        else if (arg.startsWith('--id=')) {
+            instanceId = arg.slice('--id='.length);
+        }
+        else if (arg === '--version' || arg === '-v') {
+            command = 'version';
+        }
+        else if (arg === '--help' || arg === '-h') {
+            command = 'help';
+        }
+        else if (!arg.startsWith('-')) {
+            if (command === 'start') {
+                command = arg;
+            }
+            else if (command === 'config' && !subCommand) {
+                subCommand = arg;
+            }
+        }
+    }
+    if (instanceId) {
+        process.env.OPENCODE_INSTANCE_ID = instanceId;
+    }
+    if (proxyUrl) {
+        setGlobalProxy(proxyUrl);
+    }
+    if (command === 'config' && subCommand === 'timeout') {
+        runConfigTimeout();
+        process.exit(0);
+    }
+    switch (command) {
+        case 'start':
+            runStart();
+            break;
+        case 'telegram':
+            runTelegramOnly();
+            break;
+        case 'feishu':
+            runFeishuOnly();
+            break;
+        case 'weixin':
+            runWeixinOnly();
+            break;
+        case 'config':
+            runConfig();
+            break;
+        case 'help':
+        case '--help':
+        case '-h':
+            printBanner();
+            printHelp();
+            break;
+        case 'version':
+        case '--version':
+        case '-v':
+            console.log(`opencode-remote v${VERSION}`);
+            break;
+        case 'agents':
+            runAgentsCommand();
+            break;
+        default:
+            console.log(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}