@bastdewfn/cc-remote 1.0.9

package/dist/renderer.js

@@ -0,0 +1,318 @@
+"use strict";
+if (typeof Terminal === 'undefined') {
+    document.body.innerHTML = '<pre style="color:red;padding:20px;">Error: xterm.js did not load. Check script paths in index.html.</pre>';
+    throw new Error('Terminal is not defined');
+}
+const term = new Terminal({
+    cursorBlink: true,
+    cursorStyle: 'underline',
+    fontSize: 14,
+    fontFamily: '"Cascadia Code", "Fira Code", Consolas, monospace',
+    theme: {
+        background: '#1e1e1e',
+        foreground: '#d4d4d4',
+        cursor: '#ffffff',
+    },
+    allowProposedApi: true,
+});
+const FitAddonClass = FitAddon.FitAddon || FitAddon;
+const fitAddon = new FitAddonClass();
+term.loadAddon(fitAddon);
+// Clipboard addon: auto copy-on-select, Ctrl+C/V
+const ClipboardAddonModule = window.ClipboardAddon;
+if (ClipboardAddonModule) {
+    const ClipboardAddonClass = ClipboardAddonModule.ClipboardAddon || ClipboardAddonModule;
+    const clipboardAddon = new ClipboardAddonClass();
+    term.loadAddon(clipboardAddon);
+}
+const el = document.getElementById('terminal');
+if (el) {
+    term.open(el);
+    fitAddon.fit();
+    term.writeln('Claude Code Terminal\r\n');
+}
+else {
+    document.body.innerHTML = '<pre style="color:red;padding:20px;">Error: #terminal element not found.</pre>';
+    throw new Error('terminal element missing');
+}
+if (typeof window.electronAPI === 'undefined') {
+    term.writeln('[Error: electronAPI not available - preload may have failed]\r\n');
+}
+else {
+    // Intercept all F-keys in capture phase, before xterm.js sees them
+    document.addEventListener('keydown', (e) => {
+        // Shift+Enter → newline (xterm.js doesn't pass this to onData)
+        if (e.key === 'Enter' && e.shiftKey) {
+            e.preventDefault();
+            e.stopPropagation();
+            window.electronAPI.sendInput('\n');
+            return;
+        }
+        // Shift+Tab → unindent (xterm.js doesn't pass this to onData)
+        if (e.key === 'Tab' && e.shiftKey) {
+            e.preventDefault();
+            e.stopPropagation();
+            window.electronAPI.sendInput('\x1b[Z');
+            return;
+        }
+        // Esc → send immediately without waiting for escape sequence timeout
+        if (e.key === 'Escape') {
+            e.preventDefault();
+            e.stopPropagation();
+            window.electronAPI.sendInput('\x1b');
+            return;
+        }
+        if (e.key.startsWith('F') && e.key.length <= 4) {
+            e.preventDefault();
+            e.stopPropagation();
+            if (e.key === 'F1') {
+                dumpTerminalBuffer();
+            }
+            else if (e.key === 'F3') {
+                const bar = document.getElementById('search-bar');
+                if (bar) {
+                    bar.classList.add('visible');
+                    bar.value = '';
+                    bar.focus();
+                }
+            }
+            else if (e.key === 'F11') {
+                window.electronAPI.toggleFullscreen();
+            }
+            else if (e.key === 'F12') {
+                window.electronAPI.openDevTools();
+            }
+        }
+    }, true);
+    term.onData((data) => {
+        window.electronAPI.sendInput(data);
+    });
+    window.electronAPI.onData((data) => {
+        term.write(data);
+    });
+    term.onResize(({ cols, rows }) => {
+        window.electronAPI.resize(cols, rows);
+    });
+    window.electronAPI.onExit((code) => {
+        term.write(`\r\n\n[Claude exited with code ${code}]\r\n`);
+    });
+    window.electronAPI.onStatus((text) => {
+        console.log(text);
+    });
+    // Search addon
+    const SearchAddonModule = window.SearchAddon;
+    let searchAddon = null;
+    if (SearchAddonModule) {
+        const SearchAddonClass = SearchAddonModule.SearchAddon || SearchAddonModule;
+        searchAddon = new SearchAddonClass();
+        term.loadAddon(searchAddon);
+    }
+    // Search bar: Enter to search, Escape/blur to close
+    const searchBar = document.getElementById('search-bar');
+    if (searchBar) {
+        searchBar.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                const query = searchBar.value.trim();
+                searchBar.classList.remove('visible');
+                if (query && searchAddon)
+                    searchAddon.findNext(query);
+                term.focus();
+            }
+            else if (e.key === 'Escape') {
+                searchBar.classList.remove('visible');
+                term.focus();
+            }
+        });
+        searchBar.addEventListener('blur', () => {
+            searchBar.classList.remove('visible');
+        });
+    }
+    // Right-click: copy if selection, paste if no selection
+    el.addEventListener('contextmenu', (e) => {
+        e.preventDefault();
+        const t = term;
+        if (t.hasSelection()) {
+            const selected = t.getSelection();
+            if (selected)
+                window.electronAPI.copyText(selected);
+            t.clearSelection();
+        }
+        else {
+            doPaste();
+        }
+    });
+    // Intercept Ctrl+V / Shift+Insert paste to convert HTML to ANSI
+    el.addEventListener('paste', (e) => {
+        e.preventDefault();
+        const html = e.clipboardData?.getData('text/html');
+        if (html) {
+            const ansi = htmlToAnsi(html);
+            if (ansi.trim()) {
+                window.electronAPI.sendInput(ansi);
+                return;
+            }
+        }
+        const text = e.clipboardData?.getData('text/plain');
+        if (text)
+            window.electronAPI.sendInput(text);
+    });
+    // Clipboard addon handles copy-on-select automatically
+}
+function htmlToAnsi(html) {
+    const div = document.createElement('div');
+    div.innerHTML = html;
+    let result = '';
+    walk(div);
+    return result;
+    function parseRgb(hexOrRgb) {
+        // #rrggbb or #rgb
+        const hexMatch = hexOrRgb.match(/^#([0-9a-f]{3,6})$/i);
+        if (hexMatch) {
+            const h = hexMatch[1];
+            if (h.length === 3)
+                return [parseInt(h[0] + h[0], 16), parseInt(h[1] + h[1], 16), parseInt(h[2] + h[2], 16)];
+            return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+        }
+        // rgb(r, g, b)
+        const rgbMatch = hexOrRgb.match(/rgb\((\d+)\s*,?\s*(\d+)\s*,?\s*(\d+)\)/i);
+        if (rgbMatch)
+            return [parseInt(rgbMatch[1]), parseInt(rgbMatch[2]), parseInt(rgbMatch[3])];
+        return null;
+    }
+    function getStyleVal(style, prop) {
+        const m = style.match(new RegExp(prop + '\\s*:\\s*([^;]+)', 'i'));
+        return m ? m[1].trim() : '';
+    }
+    function walk(node) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            result += node.textContent || '';
+            return;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE)
+            return;
+        const el = node;
+        const tag = el.tagName.toLowerCase();
+        const style = el.getAttribute('style') || '';
+        if (tag === 'br') {
+            result += '\n';
+            return;
+        }
+        let prefix = '';
+        let suffix = '';
+        if (tag === 'b' || tag === 'strong') {
+            prefix += '\x1b[1m';
+            suffix = '\x1b[22m' + suffix;
+        }
+        if (tag === 'i' || tag === 'em') {
+            prefix += '\x1b[3m';
+            suffix = '\x1b[23m' + suffix;
+        }
+        if (tag === 'u') {
+            prefix += '\x1b[4m';
+            suffix = '\x1b[24m' + suffix;
+        }
+        const fw = getStyleVal(style, 'font-weight');
+        if (fw && (fw === 'bold' || parseInt(fw) >= 600)) {
+            prefix += '\x1b[1m';
+            suffix = '\x1b[22m' + suffix;
+        }
+        if (/italic/i.test(getStyleVal(style, 'font-style'))) {
+            prefix += '\x1b[3m';
+            suffix = '\x1b[23m' + suffix;
+        }
+        if (/underline/i.test(getStyleVal(style, 'text-decoration'))) {
+            prefix += '\x1b[4m';
+            suffix = '\x1b[24m' + suffix;
+        }
+        const colorVal = getStyleVal(style, 'color');
+        if (colorVal) {
+            const rgb = parseRgb(colorVal);
+            if (rgb) {
+                prefix += `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+                suffix = '\x1b[39m' + suffix;
+            }
+        }
+        const bgVal = getStyleVal(style, 'background-color');
+        if (bgVal) {
+            const rgb = parseRgb(bgVal);
+            if (rgb) {
+                prefix += `\x1b[48;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+                suffix = '\x1b[49m' + suffix;
+            }
+        }
+        // Block-level elements: add trailing newline
+        const block = /^(div|p|pre|h[1-6]|li|tr)$/.test(tag);
+        result += prefix;
+        for (const child of Array.from(el.childNodes))
+            walk(child);
+        result += suffix;
+        if (block)
+            result += '\n';
+    }
+}
+function doPaste() {
+    const html = window.electronAPI.readClipboardHTML();
+    if (html) {
+        const ansi = htmlToAnsi(html);
+        if (ansi.trim()) {
+            window.electronAPI.sendInput(ansi);
+            return;
+        }
+    }
+    const text = window.electronAPI.readClipboard();
+    if (text)
+        window.electronAPI.sendInput(text);
+}
+function dumpTerminalBuffer() {
+    const buffer = term.buffer;
+    const active = buffer.active;
+    const lines = [];
+    for (let i = 0; i < active.length; i++) {
+        const line = active.getLine(i);
+        if (line) {
+            lines.push(line.translateToString(false));
+        }
+        else {
+            lines.push('');
+        }
+    }
+    console.log('=== Terminal Buffer (F1 dump) ===');
+    console.log(`baseY=${active.baseY}, totalLines=${active.length}, captured=${lines.length}`);
+    console.log(lines.join('\n'));
+    console.log('=== End of Buffer ===');
+    return lines;
+}
+function getLastLines(n) {
+    const buffer = term.buffer;
+    const active = buffer.active;
+    const start = Math.max(0, active.length - n);
+    const result = [];
+    for (let i = start; i < active.length; i++) {
+        const line = active.getLine(i);
+        result.push(line ? line.translateToString(false) : '');
+    }
+    return result.join('\n').trim();
+}
+function getSnapshotContent() {
+    const buffer = term.buffer;
+    const active = buffer.active;
+    let separatorIndex = -1;
+    for (let i = active.length - 1; i >= 0; i--) {
+        const line = active.getLine(i);
+        if (line && /─{30,}/.test(line.translateToString(false))) {
+            separatorIndex = i;
+            break;
+        }
+    }
+    const result = [];
+    for (let i = separatorIndex + 1; i < active.length; i++) {
+        const line = active.getLine(i);
+        result.push(line ? line.translateToString(false) : '');
+    }
+    return result.join('\n').trim();
+}
+window.addEventListener('resize', () => {
+    fitAddon.fit();
+});
+term.focus();

package/dist/weixin/api.js

@@ -0,0 +1,328 @@
+"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.BOT_TYPE = void 0;
+exports.getUpdates = getUpdates;
+exports.sendMessage = sendMessage;
+exports.notifyStart = notifyStart;
+exports.notifyStop = notifyStop;
+exports.fetchQRCode = fetchQRCode;
+exports.pollQRStatus = pollQRStatus;
+exports.listAccountIds = listAccountIds;
+exports.loadAccount = loadAccount;
+exports.saveAccount = saveAccount;
+exports.resolveAccount = resolveAccount;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35000;
+const DEFAULT_API_TIMEOUT_MS = 15000;
+// ---------------------------------------------------------------------------
+// Package info (mirrors the plugin's package.json metadata)
+// ---------------------------------------------------------------------------
+function readPkgVersion() {
+    try {
+        const pkgPath = path.join(__dirname, '..', '..', 'node_modules', '@tencent-weixin', 'openclaw-weixin', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const CHANNEL_VERSION = readPkgVersion();
+exports.BOT_TYPE = '3';
+function buildBaseInfo() {
+    return { channel_version: CHANNEL_VERSION, bot_agent: 'cc-remote' };
+}
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), 'utf-8').toString('base64');
+}
+function buildHeaders(token) {
+    const headers = {
+        'Content-Type': 'application/json',
+        AuthorizationType: 'ilink_bot_token',
+        'X-WECHAT-UIN': randomWechatUin(),
+    };
+    if (token?.trim()) {
+        headers.Authorization = `Bearer ${token.trim()}`;
+    }
+    return headers;
+}
+async function apiPost(params) {
+    const base = params.baseUrl.endsWith('/') ? params.baseUrl : `${params.baseUrl}/`;
+    const url = new URL(params.endpoint, base);
+    const headers = buildHeaders(params.token);
+    const timeoutMs = params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS;
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), 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) {
+            throw new Error(`${params.label} ${res.status}: ${rawText.slice(0, 200)}`);
+        }
+        return rawText;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+async function apiGet(params) {
+    const base = params.baseUrl.endsWith('/') ? params.baseUrl : `${params.baseUrl}/`;
+    const url = new URL(params.endpoint, base);
+    const timeoutMs = params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS;
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url.toString(), {
+            method: 'GET',
+            headers: buildHeaders(),
+            signal: controller.signal,
+        });
+        clearTimeout(t);
+        const rawText = await res.text();
+        if (!res.ok) {
+            throw new Error(`${params.label} ${res.status}: ${rawText.slice(0, 200)}`);
+        }
+        return rawText;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+// ---------------------------------------------------------------------------
+// Core API functions
+// ---------------------------------------------------------------------------
+/** Long-poll for new messages */
+async function getUpdates(params) {
+    const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+    try {
+        const rawText = await apiPost({
+            baseUrl: params.baseUrl,
+            endpoint: 'ilink/bot/getupdates',
+            body: JSON.stringify({
+                get_updates_buf: params.get_updates_buf ?? '',
+                base_info: buildBaseInfo(),
+            }),
+            token: params.token,
+            timeoutMs: timeout,
+            label: 'getUpdates',
+        });
+        return JSON.parse(rawText);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf };
+        }
+        throw err;
+    }
+}
+/** Send a message to a WeChat user */
+async function sendMessage(params) {
+    await apiPost({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendmessage',
+        body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: 'sendMessage',
+    });
+}
+/** Notify server that channel client is starting */
+async function notifyStart(params) {
+    await apiPost({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/msg/notifystart',
+        body: JSON.stringify({ base_info: buildBaseInfo() }),
+        token: params.token,
+        label: 'notifyStart',
+    });
+}
+/** Notify server that channel client is stopping */
+async function notifyStop(params) {
+    await apiPost({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/msg/notifystop',
+        body: JSON.stringify({ base_info: buildBaseInfo() }),
+        token: params.token,
+        label: 'notifyStop',
+    });
+}
+// ---------------------------------------------------------------------------
+// QR Login
+// ---------------------------------------------------------------------------
+const FIXED_BASE_URL = 'https://ilinkai.weixin.qq.com';
+/** Fetch a QR code for WeChat login */
+async function fetchQRCode(botType, localTokens) {
+    const rawText = await apiPost({
+        baseUrl: FIXED_BASE_URL,
+        endpoint: `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`,
+        body: JSON.stringify({ local_token_list: localTokens }),
+        label: 'fetchQRCode',
+    });
+    return JSON.parse(rawText);
+}
+/** Poll QR code scan status */
+async function pollQRStatus(qrcode) {
+    try {
+        const rawText = await apiGet({
+            baseUrl: FIXED_BASE_URL,
+            endpoint: `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
+            timeoutMs: 35000,
+            label: 'pollQRStatus',
+        });
+        return JSON.parse(rawText);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { status: 'wait' };
+        }
+        return { status: 'wait' };
+    }
+}
+// ---------------------------------------------------------------------------
+// Account storage
+// ---------------------------------------------------------------------------
+function resolveAccountsDir() {
+    const dir = path.join(os.homedir(), '.cc-remote', 'weixin', 'accounts');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function listAccountIds() {
+    const indexPath = path.join(os.homedir(), '.cc-remote', 'weixin', 'accounts.json');
+    const fromIndex = [];
+    try {
+        if (fs.existsSync(indexPath)) {
+            const raw = fs.readFileSync(indexPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                fromIndex.push(...parsed.filter((id) => typeof id === 'string' && id.trim() !== ''));
+            }
+        }
+    }
+    catch { /* ignore */ }
+    // Also scan accounts directory for .json files not in the index
+    const accountsDir = path.join(os.homedir(), '.cc-remote', 'weixin', 'accounts');
+    try {
+        if (fs.existsSync(accountsDir)) {
+            for (const entry of fs.readdirSync(accountsDir)) {
+                if (entry.endsWith('.json') && entry !== 'accounts.json') {
+                    const id = entry.slice(0, -5); // strip .json
+                    if (!fromIndex.includes(id))
+                        fromIndex.push(id);
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return fromIndex;
+}
+function registerAccountId(accountId) {
+    const dir = path.join(os.homedir(), '.cc-remote', 'weixin');
+    fs.mkdirSync(dir, { recursive: true });
+    const indexPath = path.join(dir, 'accounts.json');
+    const existing = listAccountIds();
+    if (existing.includes(accountId))
+        return;
+    existing.push(accountId);
+    fs.writeFileSync(indexPath, JSON.stringify(existing, null, 2), 'utf-8');
+}
+function loadAccount(accountId) {
+    const filePath = path.join(resolveAccountsDir(), `${accountId}.json`);
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function saveAccount(accountId, data) {
+    const dir = resolveAccountsDir();
+    // Clean up all existing accounts, keep only the latest one
+    const existingIds = listAccountIds();
+    for (const id of existingIds) {
+        const p = path.join(dir, `${id}.json`);
+        try {
+            fs.unlinkSync(p);
+        }
+        catch { /* ignore */ }
+    }
+    // Clear accounts index
+    const indexPath = path.join(dir, '..', 'accounts.json');
+    try {
+        fs.unlinkSync(indexPath);
+    }
+    catch { /* ignore */ }
+    fs.mkdirSync(dir, { recursive: true });
+    const token = (data.token || '').trim();
+    const baseUrl = (data.baseUrl || '').trim();
+    const userId = (data.userId || '').trim();
+    const accountData = {
+        ...(token ? { token, savedAt: new Date().toISOString() } : {}),
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(userId ? { userId } : {}),
+    };
+    const filePath = path.join(dir, `${accountId}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(accountData, null, 2), 'utf-8');
+    registerAccountId(accountId);
+}
+function resolveAccount(accountId) {
+    const accounts = listAccountIds();
+    const id = accountId?.trim() || accounts[0];
+    if (!id) {
+        throw new Error('weixin: no account configured — run login first');
+    }
+    const data = loadAccount(id);
+    return {
+        accountId: id,
+        baseUrl: data?.baseUrl || DEFAULT_BASE_URL,
+        token: data?.token,
+        configured: Boolean(data?.token),
+    };
+}