@yvhitxcel/opencode-remote 0.15.0

package/dist/web/code-viewer.js

@@ -0,0 +1,266 @@
+// Code viewer utilities for Weixin bot
+// Uses OpenCode SDK file.status() API - no git dependency
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { join, extname } from 'path';
+
+function getProjectRoot() {
+    const candidates = [
+        process.env.OPENCODE_PROJECT_ROOT,
+        process.cwd(),
+        process.env.HOME,
+    ];
+    for (const p of candidates) {
+        if (p && existsSync(p)) {
+            return p;
+        }
+    }
+    return process.cwd();
+}
+
+// Get modified files from OpenCode session
+export async function getModifiedFilesFromSession(session) {
+    try {
+        const result = await session.client.file.status({});
+        if (result.error) {
+            return [];
+        }
+        const files = result.data || [];
+        return files.map(f => ({
+            path: f.path,
+            additions: f.additions || 0,
+            deletions: f.deletions || 0,
+            size: f.size || 0,
+        }));
+    }
+    catch (error) {
+        console.error('Failed to get modified files from session:', error.message);
+        return [];
+    }
+}
+
+// Fallback: scan directory for recently modified files
+export function getModifiedFiles() {
+    try {
+        const root = getProjectRoot();
+        const files = [];
+        const now = Date.now();
+        const oneHourAgo = now - 3600000;
+        scanDir(root, root, oneHourAgo, files);
+        files.sort((a, b) => b.mtime - a.mtime);
+        return files.slice(0, 50).map(f => ({
+            path: f.relativePath,
+            additions: 0,
+            deletions: 0,
+            size: f.size,
+            mtime: f.mtime,
+        }));
+    }
+    catch (error) {
+        console.error('Failed to get modified files:', error.message);
+        return [];
+    }
+}
+
+function scanDir(root, dir, cutoff, results, depth = 0) {
+    if (depth > 10) return;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '.git') continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                scanDir(root, fullPath, cutoff, results, depth + 1);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.mtimeMs > cutoff) {
+                        const relativePath = fullPath.substring(root.length + 1);
+                        results.push({
+                            relativePath,
+                            size: stat.size,
+                            mtime: stat.mtimeMs,
+                        });
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+}
+
+export function getFileContent(filePath, maxLines = 500) {
+    try {
+        const root = getProjectRoot();
+        const fullPath = join(root, filePath);
+        if (!existsSync(fullPath)) {
+            return { error: `File not found: ${filePath}` };
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        const lines = content.split('\n');
+        const truncated = lines.length > maxLines;
+        const displayLines = truncated ? lines.slice(0, maxLines) : lines;
+        const numbered = displayLines.map((line, i) => `${String(i + 1).padStart(4)}: ${line}`).join('\n');
+        return {
+            path: filePath,
+            content: numbered,
+            totalLines: lines.length,
+            truncated,
+            extension: extname(filePath).slice(1),
+        };
+    }
+    catch (error) {
+        return { error: `Failed to read file: ${error.message}` };
+    }
+}
+
+export function getFileDiff(filePath) {
+    try {
+        const root = getProjectRoot();
+        const fullPath = join(root, filePath);
+        if (!existsSync(fullPath)) {
+            return { path: filePath, diff: `File not found: ${filePath}` };
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        return { path: filePath, diff: content };
+    }
+    catch {
+        return { path: filePath, diff: '(unable to read file)' };
+    }
+}
+
+export function getAllDiffs() {
+    const files = getModifiedFiles();
+    if (files.length === 0) {
+        return '(no recently modified files found)';
+    }
+    const root = getProjectRoot();
+    let result = '';
+    for (const f of files.slice(0, 10)) {
+        const fullPath = join(root, f.path);
+        if (existsSync(fullPath)) {
+            const content = readFileSync(fullPath, 'utf-8');
+            result += `===== ${f.path} =====\n${content}\n\n`;
+        }
+    }
+    return result || '(unable to read files)';
+}
+
+function parseMdSections(content) {
+    const sections = [];
+    const lines = content.split('\n');
+    let currentSection = { title: 'Introduction', content: [], level: 0 };
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            if (currentSection.content.length > 0) {
+                sections.push({ ...currentSection, content: currentSection.content.join('\n') });
+            }
+            currentSection = {
+                title: headingMatch[2].trim(),
+                content: [],
+                level: headingMatch[1].length,
+            };
+        }
+        else {
+            currentSection.content.push(line);
+        }
+    }
+    if (currentSection.content.length > 0) {
+        sections.push({ ...currentSection, content: currentSection.content.join('\n') });
+    }
+    return sections;
+}
+
+function scoreRelevance(section, keywords) {
+    const text = `${section.title} ${section.content}`.toLowerCase();
+    let score = 0;
+    for (const keyword of keywords) {
+        const lower = keyword.toLowerCase();
+        if (text.includes(lower)) {
+            score += 10;
+            if (section.title.toLowerCase().includes(lower)) {
+                score += 20;
+            }
+        }
+    }
+    return score;
+}
+
+export function getRelevantMdSections(filePath, keywords, maxSections = 5) {
+    try {
+        const root = getProjectRoot();
+        const fullPath = join(root, filePath);
+        if (!existsSync(fullPath)) {
+            return { error: `File not found: ${filePath}` };
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        const sections = parseMdSections(content);
+        if (keywords.length === 0) {
+            const preview = sections.slice(0, maxSections).map((s, i) => ({
+                index: i + 1,
+                title: s.title,
+                content: s.content.length > 300 ? s.content.slice(0, 300) + '...' : s.content,
+            }));
+            return { path: filePath, sections: preview, totalSections: sections.length };
+        }
+        const scored = sections
+            .map((s, i) => ({ ...s, index: i + 1, score: scoreRelevance(s, keywords) }))
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, maxSections);
+        if (scored.length === 0) {
+            const preview = sections.slice(0, maxSections).map((s, i) => ({
+                index: i + 1,
+                title: s.title,
+                content: s.content.length > 300 ? s.content.slice(0, 300) + '...' : s.content,
+            }));
+            return { path: filePath, sections: preview, totalSections: sections.length };
+        }
+        return {
+            path: filePath,
+            sections: scored.map(s => ({
+                index: s.index,
+                title: s.title,
+                content: s.content.length > 500 ? s.content.slice(0, 500) + '...' : s.content,
+                score: s.score,
+            })),
+            totalSections: sections.length,
+        };
+    }
+    catch (error) {
+        return { error: `Failed to read MD file: ${error.message}` };
+    }
+}
+
+export function findMdFiles() {
+    try {
+        const root = getProjectRoot();
+        const files = [];
+        scanMdFiles(root, root, files, 0);
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+
+function scanMdFiles(root, dir, results, depth) {
+    if (depth > 8) return;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '.git') continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                scanMdFiles(root, fullPath, results, depth + 1);
+            }
+            else if (entry.isFile() && /\.(md|MD|markdown)$/i.test(entry.name)) {
+                const relativePath = fullPath.replace(root + '\\', '').replace(root + '/', '');
+                results.push(relativePath);
+            }
+        }
+    }
+    catch { /* ignore */ }
+}

package/dist/weixin/adapter.js

@@ -0,0 +1,135 @@
+import { randomBytes } from 'crypto';
+import { sendMessage as sendWeixinMessage, getConfig, sendTyping } from './api.js';
+
+function createWeixinAdapter(baseUrl, token, botId) {
+    const contextTokens = new Map();
+    const typingTickets = new Map();
+    const processedMessages = new Map();
+    const DEDUP_WINDOW_MS = 30_000;
+
+    function isDuplicate(messageId) {
+        if (!messageId) return false;
+        const seenAt = processedMessages.get(messageId);
+        if (seenAt && Date.now() - seenAt < DEDUP_WINDOW_MS) return true;
+        processedMessages.set(messageId, Date.now());
+        if (processedMessages.size > 1000) {
+            const now = Date.now();
+            for (const [id, ts] of processedMessages.entries()) {
+                if (now - ts > DEDUP_WINDOW_MS) processedMessages.delete(id);
+            }
+        }
+        return false;
+    }
+
+    return {
+        contextTokens,
+        typingTickets,
+        isDuplicate,
+        _baseUrl: baseUrl,
+        _token: token,
+        _botId: botId,
+        async reply(threadId, text) {
+            let contextToken = contextTokens.get(threadId);
+            let retryCount = 0;
+            const maxRetries = 2;
+
+            while (retryCount <= maxRetries) {
+                if (!contextToken) {
+                    try {
+                        console.log(`[Weixin] Fetching contextToken for ${threadId} (attempt ${retryCount + 1})...`);
+                        const r = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
+                        contextToken = r.context_token || r.typing_ticket;
+                        if (contextToken) {
+                            contextTokens.set(threadId, contextToken);
+                            console.log(`[Weixin] Got contextToken: ${contextToken.slice(0, 8)}...`);
+                        } else if (r.errcode === -14) {
+                            console.log(`[Weixin] Session timeout, retrying with fresh token...`);
+                            contextTokens.delete(threadId);
+                            retryCount++;
+                            await new Promise(r => setTimeout(r, 1000));
+                            continue;
+                        } else {
+                            console.error(`[Weixin] getConfig returned no contextToken, errcode: ${r.errcode}`);
+                            break;
+                        }
+                    } catch (e) {
+                        console.error(`[Weixin] getConfig failed:`, e.message);
+                        break;
+                    }
+                }
+
+                if (!contextToken) {
+                    console.error(`[Weixin] reply failed: no contextToken for thread ${threadId} after ${retryCount} retries`);
+                    break;
+                }
+
+                try {
+                    await sendWeixinMessage({
+                        baseUrl, token,
+                        body: { msg: { from_user_id: botId, to_user_id: threadId, client_id: `${Date.now()}-${randomBytes(8).toString('hex')}`, message_type: 2, message_state: 2, context_token: contextToken, item_list: [{ type: 1, text_item: { text } }] } }
+                    });
+                    return;
+                } catch (e) {
+                    const errMsg = e.message || '';
+                    if (errMsg.includes('-14') || errMsg.includes('timeout') || errMsg.includes('session')) {
+                        console.log(`[Weixin] Send failed (timeout), clearing token and retrying...`);
+                        contextTokens.delete(threadId);
+                        contextToken = null;
+                        retryCount++;
+                        await new Promise(r => setTimeout(r, 1000));
+                        continue;
+                    }
+                    console.error(`[Weixin] reply failed:`, e.message);
+                    throw e;
+                }
+            }
+            const err = new Error(`reply failed after ${maxRetries + 1} attempts`);
+            console.error(`[Weixin] ${err.message}`);
+            throw err;
+        },
+        async sendTypingIndicator(threadId) {
+            const cachedTicket = typingTickets.get(threadId);
+            let ticket = cachedTicket;
+            
+            if (!ticket) {
+                try {
+                    const r = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: contextTokens.get(threadId) });
+                    if (r.errcode === -14) {
+                        contextTokens.delete(threadId);
+                        typingTickets.delete(threadId);
+                        const freshConfig = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
+                        ticket = freshConfig.typing_ticket;
+                        if (freshConfig.context_token) {
+                            contextTokens.set(threadId, freshConfig.context_token);
+                        }
+                    } else {
+                        ticket = r.typing_ticket;
+                    }
+                    if (ticket) typingTickets.set(threadId, ticket);
+                } catch { console.debug('[typing] getConfig failed'); }
+            }
+            if (ticket) {
+                try {
+                    await sendTyping({ baseUrl, token, body: { ilink_user_id: threadId, typing_ticket: ticket, status: 1 } });
+                } catch (e) {
+                    if (e.message?.includes('-14') || e.message?.includes('timeout')) {
+                        typingTickets.delete(threadId);
+                        contextTokens.delete(threadId);
+                        try {
+                            const freshConfig = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
+                            if (freshConfig.typing_ticket) {
+                                typingTickets.set(threadId, freshConfig.typing_ticket);
+                                await sendTyping({ baseUrl, token, body: { ilink_user_id: threadId, typing_ticket: freshConfig.typing_ticket, status: 1 } });
+                            }
+                        } catch { console.debug('[typing] retry getConfig failed'); }
+                    }
+                }
+            }
+        },
+        async updateMessage(threadId, messageId, text) { await this.reply(threadId, text); },
+        async deleteMessage() {},
+    };
+}
+
+export { createWeixinAdapter };
+export default createWeixinAdapter;

package/dist/weixin/api.js

@@ -0,0 +1,179 @@
+/**
+ * Weixin API client (based on @tencent-weixin/openclaw-weixin)
+ * Simplified version without OpenClaw framework dependency.
+ */
+import { randomBytes } from 'node:crypto';
+import { DEFAULT_BASE_URL } from './types.js';
+// Build headers
+function buildHeaders(body, token) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'AuthorizationType': 'ilink_bot_token',
+        'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
+        'X-WECHAT-UIN': randomWechatUin(),
+    };
+    if (token?.trim()) {
+        headers['Authorization'] = `Bearer ${token.trim()}`;
+    }
+    return headers;
+}
+// Random X-WECHAT-UIN header
+function randomWechatUin() {
+    const uint32 = randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), 'utf-8').toString('base64');
+}
+// Ensure URL has trailing slash
+function ensureTrailingSlash(url) {
+    return url.endsWith('/') ? url : `${url}/`;
+}
+// Generic fetch wrapper
+async function apiFetch(params) {
+    const base = ensureTrailingSlash(params.baseUrl);
+    const url = new URL(params.endpoint, base);
+    const headers = buildHeaders(params.body, params.token);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const res = await fetch(url.toString(), {
+            method: 'POST',
+            headers,
+            body: params.body,
+            signal: controller.signal,
+        });
+        clearTimeout(t);
+        const rawText = await res.text();
+        if (!res.ok) {
+            console.error(`[apiFetch] ${params.label} failed: ${res.status}`, rawText);
+            throw new Error(`${params.label} ${res.status}: ${rawText}`);
+        }
+        if (rawText.includes('"errcode"') && rawText.includes('-14')) {
+            console.error(`[apiFetch] ${params.label} session timeout:`, rawText);
+        }
+        return rawText;
+    }
+    catch (err) {
+        clearTimeout(t);
+        console.error(`[apiFetch] ${params.label} error:`, err.message);
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Login APIs
+// ---------------------------------------------------------------------------
+/**
+ * Fetch QR code for login
+ */
+export async function fetchQRCode(baseUrl = DEFAULT_BASE_URL, botType = '3') {
+    const base = ensureTrailingSlash(baseUrl);
+    const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, base);
+    const res = await fetch(url.toString());
+    if (!res.ok) {
+        const body = await res.text().catch(() => '(unreadable)');
+        throw new Error(`Failed to fetch QR code: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+}
+/**
+ * Poll QR code status
+ */
+export async function pollQRStatus(baseUrl = DEFAULT_BASE_URL, qrcode) {
+    const base = ensureTrailingSlash(baseUrl);
+    const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+    const headers = {
+        'iLink-App-ClientVersion': '1',
+    };
+    const res = await fetch(url.toString(), { headers });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '(unreadable)');
+        throw new Error(`Failed to poll QR status: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+}
+// ---------------------------------------------------------------------------
+// Message APIs
+// ---------------------------------------------------------------------------
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+/**
+ * Long-poll for new messages
+ */
+export async function getUpdates(params) {
+    const timeout = params.longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+    try {
+        const rawText = await apiFetch({
+            baseUrl: params.baseUrl,
+            endpoint: 'ilink/bot/getupdates',
+            body: JSON.stringify({
+                get_updates_buf: params.get_updates_buf ?? '',
+                base_info: { channel_version: '1.0.0' },
+            }),
+            token: params.token,
+            timeoutMs: timeout,
+            label: 'getUpdates',
+        });
+        return JSON.parse(rawText);
+    }
+    catch (err) {
+        // Long-poll timeout is normal; return empty response
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf };
+        }
+        throw err;
+    }
+}
+/**
+ * Send a message
+ */
+export async function sendMessage(params) {
+    const rawText = await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendmessage',
+        body: JSON.stringify({
+            ...params.body,
+            base_info: { channel_version: '1.0.0' },
+        }),
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: 'sendMessage',
+    });
+    try {
+        JSON.parse(rawText);
+    }
+    catch (e) {
+        console.debug('[api] Non-JSON response:', e.message);
+    }
+}
+/**
+ * Get bot config (includes typing_ticket)
+ */
+export async function getConfig(params) {
+    const rawText = await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/getconfig',
+        body: JSON.stringify({
+            ilink_user_id: params.ilinkUserId,
+            context_token: params.contextToken,
+            base_info: { channel_version: '1.0.0' },
+        }),
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? 10_000,
+        label: 'getConfig',
+    });
+    return JSON.parse(rawText);
+}
+/**
+ * Send typing indicator
+ */
+export async function sendTyping(params) {
+    await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendtyping',
+        body: JSON.stringify({
+            ...params.body,
+            base_info: { channel_version: '1.0.0' },
+        }),
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? 10_000,
+        label: 'sendTyping',
+    });
+}