@yvhitxcel/opencode-remote 0.16.2 → 0.17.0

package/dist/autonomous/decisions.js

@@ -0,0 +1,73 @@
+const pendingDecisions = new Map();
+
+export function hasPendingDecision(threadId) {
+    return pendingDecisions.has(threadId);
+}
+
+export function resolveDecision(threadId, input) {
+    const pd = pendingDecisions.get(threadId);
+    if (!pd) return false;
+    const num = parseInt(input, 10);
+    if (isNaN(num) || num < 1 || num > pd.options.length) return false;
+    clearTimeout(pd.timer);
+    pendingDecisions.delete(threadId);
+    pd.resolve(num);
+    return true;
+}
+
+export function sendDecision({ adapter, threadId, question, options, recommended, timeoutMs = 5 * 60 * 1000, broadcastTo = [] }) {
+    return new Promise((resolve) => {
+        if (pendingDecisions.has(threadId)) {
+            pendingDecisions.get(threadId).resolve(0);
+            clearTimeout(pendingDecisions.get(threadId).timer);
+            pendingDecisions.delete(threadId);
+        }
+
+        const lines = [
+            `🤖 需要你决定：`,
+            `${question}`,
+            ``,
+        ];
+        options.forEach((opt, i) => {
+            const mark = i + 1 === recommended ? ' ✅ 推荐' : '';
+            lines.push(`  ${i + 1}. ${opt}${mark}`);
+        });
+        const timeoutMin = Math.round(timeoutMs / 60000);
+        lines.push(``, `⏱ ${timeoutMin}分钟无回复自动选择推荐项`);
+
+        const msg = lines.join('\n');
+        adapter.reply(threadId, msg).catch(() => {});
+
+        const targets = new Set([threadId, ...broadcastTo]);
+        for (const tid of targets) {
+            if (tid !== threadId) {
+                adapter.reply(tid, msg).catch(() => {});
+            }
+        }
+
+        const timer = setTimeout(() => {
+            if (pendingDecisions.has(threadId)) {
+                pendingDecisions.delete(threadId);
+                const choice = recommended;
+                const timeoutMsg = `⏰ 超时，自动选择推荐项: ${options[choice - 1]}`;
+                adapter.reply(threadId, timeoutMsg).catch(() => {});
+                for (const tid of targets) {
+                    if (tid !== threadId) {
+                        adapter.reply(tid, timeoutMsg).catch(() => {});
+                    }
+                }
+                resolve(choice);
+            }
+        }, timeoutMs);
+
+        pendingDecisions.set(threadId, { resolve, timer, options, recommended });
+    });
+}
+
+export function cancelDecision(threadId, reason = '') {
+    const pd = pendingDecisions.get(threadId);
+    if (!pd) return;
+    clearTimeout(pd.timer);
+    pendingDecisions.delete(threadId);
+    pd.resolve(0);
+}

package/dist/autonomous/index.js

@@ -0,0 +1,141 @@
+import { createSession, sendMessage } from '../opencode/client.js';
+import { sendDecision, cancelDecision } from './decisions.js';
+
+let autoLoopAbort = null;
+let autoContext = null;
+
+export function isAutoRunning() {
+    return autoLoopAbort !== null && !autoLoopAbort.signal.aborted;
+}
+
+export function stopAutoLoop() {
+    if (autoLoopAbort) {
+        autoLoopAbort.abort();
+        autoLoopAbort = null;
+    }
+    autoContext = null;
+}
+
+export async function startAutoLoop({ adapter, threadId, goal, openCodeSessions, broadcastTo = [] }) {
+    stopAutoLoop();
+    autoLoopAbort = new AbortController();
+    const signal = autoLoopAbort.signal;
+    autoContext = { adapter, threadId, goal, openCodeSessions, broadcastTo };
+
+    const session = await createSession(`auto-${Date.now()}`, `自主研发: ${goal.slice(0, 40)}`);
+    if (!session) {
+        await adapter.reply(threadId, '❌ 无法创建自主研发会话');
+        return;
+    }
+    openCodeSessions.set(threadId, session);
+
+    const sysPrompt = `当前项目: 遥控器 (opencode-remote-control)
+目标: ${goal}
+
+你是自主开发模式，可以读取项目代码、修改文件、运行命令。
+当遇到需要人类决定的选项时，在回复中包含以下格式：
+
+[DECISION]
+问题描述
+1. 选项一
+2. 选项二
+推荐: 1
+[DECISION]
+
+除此之外，请自主推进工作。完成后输出: ✅ 任务完成: 简要总结`;
+
+    const taskRunner = async () => {
+        try {
+            await adapter.reply(threadId, `🤖 开始自主开发: ${goal}`);
+            let fullText = '';
+            await sendMessage(session, sysPrompt, {
+                onResponseMeta: (meta) => {
+                    if (meta.providerID && meta.modelID) {
+                        console.log(`[auto] using ${meta.providerID}/${meta.modelID}`);
+                    }
+                },
+                onText: (text) => {
+                    fullText += text;
+                    const decisionMatch = fullText.match(/\[DECISION\]([\s\S]*?)\[\/DECISION\]/);
+                    if (decisionMatch) {
+                        throw new DecisionRequired(decisionMatch[1].trim());
+                    }
+                },
+            }, threadId);
+
+            await adapter.reply(threadId, `✅ 自主开发完成`);
+        } catch (e) {
+            if (e.name === 'DecisionRequired') {
+                await handleDecision(e.message);
+            } else if (!signal.aborted) {
+                console.error('[auto] error:', e.message);
+                await adapter.reply(threadId, `❌ 自主开发出错: ${e.message}`);
+            }
+        } finally {
+            if (!signal.aborted) {
+                autoLoopAbort = null;
+                autoContext = null;
+            }
+        }
+    };
+
+    taskRunner();
+}
+
+class DecisionRequired extends Error {
+    constructor(text) { super(text); this.name = 'DecisionRequired'; }
+}
+
+async function handleDecision(decisionText) {
+    const ctx = autoContext;
+    if (!ctx || ctx.signal?.aborted) return;
+    const { adapter, threadId, broadcastTo } = ctx;
+
+    const lines = decisionText.split('\n').map(l => l.trim()).filter(Boolean);
+    const question = lines[0] || '请选择';
+    const options = [];
+    let recommended = 1;
+    for (const l of lines) {
+        const optMatch = l.match(/^(\d+)\.\s*(.+)/);
+        if (optMatch) {
+            options.push(optMatch[2]);
+            if (optMatch[1]) recommended = parseInt(optMatch[1], 10);
+        }
+        const recMatch = l.match(/推荐:\s*(\d+)/);
+        if (recMatch) recommended = parseInt(recMatch[1], 10);
+    }
+    if (options.length === 0) {
+        options.push('继续');
+    }
+
+    const choice = await sendDecision({ adapter, threadId, question, options, recommended, timeoutMs: 5 * 60 * 1000, broadcastTo });
+    if (ctx.signal?.aborted) return;
+
+    if (choice === 0) {
+        await adapter.reply(threadId, '⏹ 决策取消，自主开发停止');
+        return;
+    }
+
+    const chosen = options[choice - 1];
+    const userChoice = `选择了: ${choice}. ${chosen}`;
+
+    const { session } = ctx;
+    sendMessage(session, userChoice, {
+        onText: (text) => {
+            const decisionMatch = text.match(/\[DECISION\]([\s\S]*?)\[\/DECISION\]/);
+            if (decisionMatch) {
+                throw new DecisionRequired(decisionMatch[1].trim());
+            }
+        },
+    }, threadId).then(async (result) => {
+        if (result && result.includes('✅')) {
+            await adapter.reply(threadId, `✅ 自主开发完成`);
+        }
+    }).catch(async (e) => {
+        if (e.name === 'DecisionRequired') {
+            await handleDecision(e.message);
+        } else if (!ctx.signal?.aborted) {
+            console.error('[auto] post-decision error:', e.message);
+        }
+    });
+}

package/dist/cli.js

@@ -47,17 +47,9 @@ Multi-Bot Support:
 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
+  /diagnose — System diagnostics
   /model — Switch AI model
 
 Multi-Agent Commands:
@@ -65,7 +57,6 @@ Multi-Agent Commands:
   /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

package/dist/core/config.js

@@ -26,6 +26,7 @@ export function loadConfig() {
 
     const appSecret = content.match(/FEISHU_APP_SECRET=(.+)/)?.[1]?.trim();
     if (appSecret) config.feishuAppSecret = appSecret;
+
   }
 
   // 2. Read ./.env (local project, lower priority)
@@ -56,6 +57,5 @@ export function loadConfig() {
   if (process.env.SESSION_IDLE_TIMEOUT_MS) config.sessionIdleTimeoutMs = parseInt(process.env.SESSION_IDLE_TIMEOUT_MS, 10);
   if (process.env.CLEANUP_INTERVAL_MS) config.cleanupIntervalMs = parseInt(process.env.CLEANUP_INTERVAL_MS, 10);
   if (process.env.APPROVAL_TIMEOUT_MS) config.approvalTimeoutMs = parseInt(process.env.APPROVAL_TIMEOUT_MS, 10);
-
   return config;
 }

package/dist/core/git-push.js

@@ -0,0 +1,120 @@
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DEFAULT_MIRRORS = [
+    'gh-proxy.com',
+    'ghfast.top',
+    'mirror.ghproxy.com',
+    'ghproxy.com',
+    'github.akams.cn',
+    'gh-proxy.ygxz.in',
+    'codeload.github.com',
+    'github.com',
+];
+
+function loadCustomMirrors() {
+    const localMirrors = join(process.cwd(), '.gitmirrors');
+    if (existsSync(localMirrors)) {
+        return readFileSync(localMirrors, 'utf-8').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+    }
+    const globalEnv = join(homedir(), '.opencode-remote', '.env');
+    if (existsSync(globalEnv)) {
+        const m = readFileSync(globalEnv, 'utf-8').match(/GIT_MIRRORS=(.+)/);
+        if (m) return m[1].split(',').map(s => s.trim()).filter(Boolean);
+    }
+    if (process.env.GIT_MIRRORS) return process.env.GIT_MIRRORS.split(',').map(s => s.trim()).filter(Boolean);
+    return DEFAULT_MIRRORS;
+}
+
+function parseOriginUrl(url) {
+    // HTTPS:  https://TOKEN@github.com/user/repo.git
+    //         https://github.com/user/repo.git
+    // SSH:    git@github.com:user/repo.git
+    let auth = '';
+    let host = '';
+    let userRepo = '';
+
+    if (url.includes('://')) {
+        const match = url.match(/^(https?:\/\/)([^@]*@)?([^\/]+)(\/.*)$/);
+        if (!match) return null;
+        const protocol = match[1];
+        const token = match[2] || '';
+        host = match[3];
+        userRepo = match[4];
+        auth = protocol + token;
+    } else {
+        const match = url.match(/^([^@]+@)?([^:]+):(.+)$/);
+        if (!match) return null;
+        auth = match[1] || '';
+        host = match[2];
+        userRepo = '/' + match[3];
+    }
+
+    return { auth, host, userRepo };
+}
+
+export function gitPush({ message, branch } = {}) {
+    const cwd = process.cwd();
+
+    let currentBranch;
+    try {
+        currentBranch = execSync('git branch --show-current', { cwd, encoding: 'utf-8' }).trim();
+    } catch (e) {
+        return { ok: false, error: '不在 git 仓库中' };
+    }
+    const targetBranch = branch || currentBranch;
+
+    const status = execSync('git status --porcelain', { cwd, encoding: 'utf-8' }).trim();
+    if (status) {
+        execSync('git add -A', { cwd });
+        const msg = (message || `auto update ${new Date().toISOString().slice(0, 19)}`).replace(/"/g, '\\"');
+        execSync(`git commit -m "${msg}"`, { cwd, stdio: 'pipe' });
+    }
+
+    let originUrl;
+    try {
+        originUrl = execSync('git remote get-url origin', { cwd, encoding: 'utf-8' }).trim();
+    } catch (e) {
+        return { ok: false, error: '没有找到 remote origin' };
+    }
+
+    const parsed = parseOriginUrl(originUrl);
+    if (!parsed) {
+        return { ok: false, error: `无法解析 remote URL: ${originUrl}` };
+    }
+
+    // 从 gh CLI 提取 token（如果 remote URL 里没有的话）
+    let pushAuth = parsed.auth;
+    if (originUrl.startsWith('https://') && !originUrl.includes('@')) {
+        try {
+            const ghToken = execSync('gh auth token', { encoding: 'utf-8' }).trim();
+            if (ghToken) {
+                pushAuth = `https://${ghToken}@`;
+            }
+        } catch (_) { /* gh not available */ }
+    }
+
+    const mirrors = loadCustomMirrors();
+    const results = [];
+
+    for (const host of mirrors) {
+        const pushUrl = pushAuth + host + parsed.userRepo;
+        const remoteName = `m_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        console.log(`[git-push] trying ${host}...`);
+        try {
+            execSync(`git remote add ${remoteName} "${pushUrl}"`, { cwd, stdio: 'pipe' });
+            execSync(`git push ${remoteName} ${targetBranch} --follow-tags`, { cwd, stdio: 'pipe', timeout: 30000 });
+            execSync(`git remote remove ${remoteName}`, { cwd, stdio: 'pipe' });
+            results.push({ host, ok: true });
+            return { ok: true, results, successUrl: pushUrl };
+        } catch (e) {
+            try { execSync(`git remote remove ${remoteName}`, { cwd, stdio: 'pipe' }); } catch (_) {}
+            const msg = e.stderr?.toString()?.trim() || e.message || '';
+            results.push({ host, ok: false, error: msg.slice(0, 150) });
+        }
+    }
+
+    return { ok: false, results };
+}

package/dist/core/notifications.js

@@ -53,7 +53,7 @@ export const TEMPLATES = {
     botStarted: () => formatNotification({
         type: 'started',
         title: 'OpenCode Remote Control ready',
-        actions: ['💬 Send a prompt to start', '/help — commands', '/status — connection']
+        actions: ['💬 Send a prompt to start', '/help — commands', '/diagnose — diagnostics']
     }),
     sessionExpired: () => formatNotification({
         type: 'expired',
@@ -81,7 +81,7 @@ export const TEMPLATES = {
         type: 'error',
         title: 'OpenCode is offline',
         details: 'Cannot connect to OpenCode server.',
-        actions: ['🔄 /retry — check again', '/status — diagnostics']
+        actions: ['🔄 /retry — check again', '/diagnose — diagnostics']
     }),
     thinking: () => formatNotification({
         type: 'loading',