@bastdewfn/cc-remote 1.0.9

package/README.md

@@ -0,0 +1,150 @@
+# cc-remote
+![](https://img.shields.io/badge/Node.js-18%2B-brightgreen?style=flat-square) [![npm]](https://www.npmjs.com/package/@bastdewfn/cc-remote)
+
+远程控制 Claude Code 的桌面终端，支持飞书和微信双频道接入。
+有问题可联系邮箱else-love@qq.com
+
+## 系统
+windows  
+mac
+
+## 功能
+
+- **飞书频道** — WebSocket 接收消息，卡片式工具审批，回复自动推送
+- **微信频道** — 长轮询接收消息，文字式工具审批，扫码登录
+- **工具审批** — Claude 执行高风险工具前需用户确认，支持始终允许
+- 同一时间暂只支持一个项目会话，期待下个版本
+
+
+
+## 安装
+npm i @bastdewfn/cc-remote
+
+# 全局安装
+npm install -g @bastdewfn/cc-remote
+
+
+## 快速开始
+
+
+配置频道 命令
+```bash
+cc-remote config  
+```
+### 首次启动可能会下载 Electron  如果失败，请切换海外网络
+
+#### 选择飞书或微信，按提示录入凭据
+#### 飞书：App ID / App Secret / Relay Port / claudePath
+#### 微信：扫码登录 / Relay Port / claudePath /会出现二维码
+
+
+| 字段 | 说明 |
+|------|------|
+| `claudePath` | Claude 可执行文件路径，留空则用 PATH 中的 `claude`（macOS）或 `claude.exe`（Windows） |
+| `Relay Port ` | 本机服务端口默认19200 |
+
+
+#### *飞书需申请机器人，配置事件回调，较麻烦，但交互体验好*  配置 https://open.feishu.cn/document/develop-an-echo-bot/faq
+### 微信在入门快，但体验一般。 在我的微信里 ，设置->插件->微信ClawBot->详情->扫码 
+
+## 启动 
+在项目目录下 运行命令
+```base
+cc-remote
+```
+
+配置保存在 `~/.cc-remote/config.json`。微信凭据保存在 `~/.cc-remote/weixin/accounts/`。
+
+## 命令
+
+| 命令 | 说明 |
+|------|------|
+| `cc-remote config` | 频道配置向导 |
+| `cc-remote` | 在当前目录启动  |
+| `cc-remote --project <path>` | 指定目录启动 |
+| `cc-remote cli` | 纯终端启动(备用) |
+
+Claude ，开启远程接管，会话内命令（需先进入 remote 模式）：
+
+| 命令 | 说明 |
+|------|------|
+| `/cc-remote-open` | 进入远程模式，消息通过频道收发 |
+| `/cc-remote-close` | 退出远程模式，恢复本地交互 |
+| `/cc-remote-doctor` | 运行诊断，检查连接状态 |
+
+飞书/微信快捷命令（手机键盘无法直接输入方向键等控制键时使用）：
+
+| 命令 | 说明 |
+|------|------|
+| `/up` `/上` | 上箭头 ↑ |
+| `/down` `/下` | 下箭头 ↓ |
+| `/left` `/左` | 左箭头 ← |
+| `/right` `/右` | 右箭头 → |
+| `/enter` `/回车` | 回车 |
+| `/esc` `/取消` | Esc |
+| `/切换` | Shift+Tab（切换焦点） |
+| `/space` `/空格` | 空格 |
+| `/snapshot` `/快照` | 截取终端内容（分隔符之后）发送到频道 |
+| `/快照15` | 截取最后 15 行发送到频道 |
+
+## 配置
+
+`~/.cc-remote/config.json`：
+
+```json
+{
+  "appId": "飞书应用 App ID",
+  "appSecret": "飞书应用 App Secret",
+  "openId": "机器人 open_id（可选）",
+  "relayPort": 19200,
+  "approvalTimeoutS": 1800,
+  "claudePath": "",
+  "enableFeishu": true,
+  "enableWeixin": false
+}
+```
+
+
+## 工具审批
+
+remote 模式下，Claude 调用工具时会触发审批：
+
+**飞书** — 卡片按钮：
+- ✅ 允许 — 本次放行
+- ❌ 拒绝 — 阻止执行
+- 🟢 始终允许 — 记住规则，永久放行
+
+**微信** — 文字回复：
+- `go` — 允许
+- `no` — 拒绝
+- `ok` — 始终允许
+
+只读工具（Read / Glob / Grep / WebSearch）自动放行，无需审批。
+
+![](./1.jpg)
+
+![](./2.jpg)
+
+## 项目结构
+
+```
+├── bin/cc-remote.js         # CJS 启动器 (config 向导 + Electron spawn)
+├── src/
+│   ├── main.ts              # Electron 主进程: 窗口、PTY、Relay、Hook
+│   ├── cli.ts               # 无头 CLI 模式
+│   ├── renderer.ts          # xterm.js 终端 UI
+│   ├── config-setup.ts      # 频道配置向导
+│   ├── feishu/              # 飞书: WebSocket 客户端、消息发送、卡片
+│   ├── weixin/              # 微信: 长轮询客户端、API、QR 登录
+│   └── hooks/               # PreToolUse / Stop Hook 脚本
+├── commands/                # Claude 命令定义
+└── dist/                    # 编译输出
+```
+
+## 依赖
+
+- Electron — 桌面窗口
+- xterm.js + node-pty — 终端模拟
+- @larksuiteoapi/node-sdk — 飞书 API
+- @tencent-weixin/openclaw-weixin — 微信协议
+- qrcode-terminal — 终端二维码

package/bin/cc-remote.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// cc-remote launcher — handles subcommands, then spawns Electron
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const http = require('http');
+const { spawn } = require('child_process');
+
+const args = process.argv.slice(2);
+const sub = args[0];
+
+// ---- Helpers ----
+function getRelayPort() {
+  let port = 19200;
+  try {
+    const cfgPath = path.join(os.homedir(), '.cc-remote', 'config.json');
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+    if (cfg.relayPort > 0) port = cfg.relayPort;
+  } catch {}
+  return port;
+}
+
+function injectProject(stdinData) {
+  try {
+    const obj = JSON.parse(stdinData || '{}');
+    obj.project = process.cwd();
+    return JSON.stringify(obj);
+  } catch {
+    return JSON.stringify({ project: process.cwd() });
+  }
+}
+
+// ---- pre-tool-use: forward hook stdin to relay ----
+if (sub === 'pre-tool-use') {
+  let stdinData = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', (chunk) => { stdinData += chunk; });
+  process.stdin.on('end', () => {
+    const body = injectProject(stdinData);
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: getRelayPort(),
+      path: '/hooks/pre-tool-use',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 600000,
+    });
+
+    req.on('error', () => { process.exit(0); });
+    req.on('response', (res) => {
+      let respBody = '';
+      res.on('data', (chunk) => { respBody += chunk; });
+      res.on('end', () => {
+        if (respBody) process.stdout.write(respBody);
+        process.exit(0);
+      });
+    });
+    req.write(body);
+    req.end();
+  });
+  return;
+}
+
+// ---- stop-notify: forward hook stdin to relay ----
+if (sub === 'stop-notify') {
+  let stdinData = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', (chunk) => { stdinData += chunk; });
+  process.stdin.on('end', () => {
+    const body = injectProject(stdinData);
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: getRelayPort(),
+      path: '/hooks/stop-notify',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 5000,
+    });
+
+    req.on('error', () => { process.exit(0); });
+    req.on('response', () => { process.exit(0); });
+    req.write(body);
+    req.end();
+  });
+  return;
+}
+
+// ---- mode: switch feishu remote/close mode ----
+if (sub === 'mode') {
+  const modeIdx = args.indexOf('--remote');
+  const isRemote = modeIdx >= 0;
+  const isClose = args.indexOf('--close') >= 0;
+  if (!isRemote && !isClose) {
+    console.error('用法: cc-remote mode --remote | --close');
+    process.exit(1);
+  }
+  const body = JSON.stringify({ mode: isRemote ? 'remote' : 'close', project: process.cwd() });
+  const req = http.request({
+    hostname: '127.0.0.1',
+    port: getRelayPort(),
+    path: '/feishu-mode',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
+    },
+    timeout: 5000,
+  });
+  req.on('error', () => { process.exit(1); });
+  req.on('response', (res) => {
+    let respBody = '';
+    res.on('data', (chunk) => { respBody += chunk; });
+    res.on('end', () => {
+      if (respBody) process.stdout.write(respBody);
+      process.exit(res.statusCode >= 400 ? 1 : 0);
+    });
+  });
+  req.write(body);
+  req.end();
+  return;
+}
+
+// ---- cli: headless CLI mode (no Electron) ----
+if (sub === 'cli') {
+  const cliPath = path.join(__dirname, '..', 'dist', 'cli.js');
+  if (!fs.existsSync(cliPath)) {
+    console.error('错误: 未找到 dist/cli.js，请先运行 npm run build');
+    process.exit(1);
+  }
+  // Strip 'cli' from argv so the cli module sees the remaining args
+  process.argv.splice(2, 1);
+  require(cliPath);
+  return;
+}
+
+// ---- config: interactive setup wizard ----
+const isConfigCmd = sub === 'config';
+
+// Remove subcommand from args passed to Electron
+const electronArgs = isConfigCmd ? args.slice(1) : args;
+
+const appDir = path.join(__dirname, '..');
+const mainFile = path.join(appDir, 'dist', 'main.js');
+
+let electronPath;
+try {
+  electronPath = require('electron');
+} catch {
+  console.error('错误: 未找到 Electron。');
+  console.error('请运行: npm install -g electron');
+  console.error('或使用 electron-builder 打包的安装版。');
+  process.exit(1);
+}
+
+(async () => {
+  if (isConfigCmd) {
+    try {
+      const { runConfigSetup } = require('../dist/config-setup');
+      await runConfigSetup();
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND') {
+        console.error('错误: 未找到配置向导模块。');
+        console.error('请先运行: npm run build');
+        process.exit(1);
+      }
+      throw err;
+    }
+    process.exit(0);
+  }
+
+  const child = spawn(electronPath, [mainFile, ...electronArgs], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+  child.on('close', (code) => { process.exit(code); });
+})();

package/commands/cc-remote-close.md

@@ -0,0 +1,5 @@
+Run the following command immediately without asking questions. Do not speak. Just run it.
+
+```
+cc-remote mode --close
+```

package/commands/cc-remote-doctor.md

@@ -0,0 +1,20 @@
+Run the following command immediately without asking questions. Do not speak. Just run it.
+
+```
+curl -s http://127.0.0.1:{{PORT}}/doctor
+```
+
+Then analyze the JSON output and present a diagnostic report to the user in Chinese with these sections:
+
+1. **配置检查**: config.json 是否完整（appId/appSecret）、字段列表
+2. **Hook 配置**: preToolUse/stop 是否配置，列出 hookCommands 里的命令详情
+3. **权限检查**: permissions.allow 列表，是否包含 cc-remote 规则（hasCcRemote）
+4. **连接检查**: WebSocket 是否已连接、运行时间、Relay 是否运行
+5. **Relay 端口**: 绑定端口号、是否在监听
+6. **PTY 状态**: PID、是否存活
+7. **微信检查**: 是否启用、客户端是否启动、accountId
+8. **收发检查**: 最近消息时间、待审批数量、发送错误
+9. **API 检查**: 飞书 API 是否可达，认证是否有效
+10. **当前模式**: remote/close，chatId
+
+对每个检查项，如果失败则给出修复建议（如检查 config.json、飞书后台事件订阅、机器人是否上线等）。

package/commands/cc-remote-open.md

@@ -0,0 +1,5 @@
+Run the following command immediately without asking questions. Do not speak. Just run it.
+
+```
+cc-remote mode --remote
+```

package/config.example.json

@@ -0,0 +1,10 @@
+{
+  "appId": "你的飞书应用 App ID",
+  "appSecret": "你的飞书应用 App Secret",
+  "openId": "你的机器人 open_id (可选)",
+  "relayPort": 19200,
+  "approvalTimeoutS": 1800,
+  "claudePath": "",
+  "enableFeishu": true,
+  "enableWeixin": false
+}

package/dist/cli.js

@@ -0,0 +1,313 @@
+"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 });
+const pty_1 = require("./pty");
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const core_1 = require("./core");
+const relay_1 = require("./relay");
+const commands_1 = require("./commands");
+const client_1 = require("./feishu/client");
+const replier_1 = require("./feishu/replier");
+const client_2 = require("./weixin/client");
+const replier_2 = require("./weixin/replier");
+const port_1 = require("./port");
+// ---- Keep-Alive agent ----
+try {
+    https.globalAgent = new https.Agent({ keepAlive: true, maxSockets: 20, keepAliveMsecs: 30000 });
+    http.globalAgent = new http.Agent({ keepAlive: true, maxSockets: 20, keepAliveMsecs: 30000 });
+}
+catch { /* read-only in some environments */ }
+// ---- Parse args ----
+const rawArgs = process.argv.slice(2);
+let targetDir = process.cwd();
+const claudeArgs = [];
+for (let i = 0; i < rawArgs.length; i++) {
+    if (rawArgs[i] === '--project' && i + 1 < rawArgs.length) {
+        targetDir = rawArgs[i + 1];
+        i++;
+    }
+    else {
+        claudeArgs.push(rawArgs[i]);
+    }
+}
+// ---- Load config ----
+const cfg = (0, core_1.loadConfig)();
+// ---- Port conflict check (before PTY spawn) ----
+async function ensurePortFree(port) {
+    const free = await (0, port_1.checkPortFree)(port);
+    if (!free) {
+        if (process.stdin.isTTY) {
+            console.log(`\n⚠️ 端口 ${port} 已被占用`);
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                const timer = setTimeout(() => resolve('1'), 30000);
+                rl.question('1. 关闭占用进程并继续启动 (默认)\n2. 退出\n请输入: ', (ans) => {
+                    clearTimeout(timer);
+                    resolve(ans.trim() || '1');
+                });
+            });
+            rl.close();
+            if (answer === '2') {
+                console.log('已退出');
+                process.exit(0);
+            }
+        }
+        const killedPid = (0, port_1.killPortProcess)(port);
+        if (killedPid) {
+            console.log(`✅ 已关闭占用进程 PID:${killedPid}，继续启动...\n`);
+        }
+        else {
+            console.log(`❌ 无法关闭占用端口 ${port} 的进程，请手动处理`);
+            process.exit(1);
+        }
+    }
+}
+// ---- onStatus: log file only, no terminal output ----
+function onStatus(_text) {
+    const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const logFile = (0, core_1.dataPath)(targetDir, `status-${date}.log`);
+    try {
+        fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${stripControl(_text)}\n`);
+    }
+    catch { /* ignore */ }
+}
+function stripControl(s) {
+    return s.replace(/[\x00-\x1F\x7F]/g, '').replace(/\[[0-9;]*m/g, '');
+}
+// ---- Message log (dedicated) ----
+function messageLog(msg) {
+    const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const logFile = (0, core_1.dataPath)(targetDir, `messages-${date}.log`);
+    try {
+        fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch { /* ignore */ }
+}
+function logAll(msg) {
+    onStatus(msg);
+    if (msg.includes('[飞书→]') || msg.includes('[微信→]') || msg.includes('[飞书↻]') || msg.includes('[微信↻]')) {
+        messageLog(msg);
+    }
+}
+// ---- Feishu ----
+const feishuEnabled = cfg.enableFeishu !== false;
+let feishuReplier = null;
+let feishuStop = null;
+if (feishuEnabled) {
+    const feishuClient = (0, client_1.createFeishuClient)(cfg);
+    feishuReplier = new replier_1.Replier(feishuClient, logAll);
+}
+// ---- WeChat ----
+const weixinEnabled = cfg.enableWeixin === true;
+let weixinClient = null;
+let weixinReplier = null;
+if (weixinEnabled) {
+    weixinClient = new client_2.WeixinClient({
+        onMessage: () => { }, // wired after relay creation
+        onStatus,
+    });
+    weixinReplier = new replier_2.WeixinReplier(weixinClient.getAccountId(), logAll);
+}
+// ---- PTY ----
+const claudeExe = cfg.claudePath?.trim() || (process.platform === 'darwin' ? 'claude' : 'claude.exe');
+console.log(`[cc-remote] 启动: ${claudeExe} ${claudeArgs.join(' ')}`);
+console.log(`[cc-remote] 目录: ${targetDir}`);
+console.log(`[cc-remote] ENV PATH: ${process.env.PATH || '(空)'}`);
+const proc = (0, pty_1.spawnPty)(claudeExe, claudeArgs, {
+    name: 'xterm-256color',
+    cols: 120,
+    rows: 30,
+    cwd: targetDir,
+    encoding: 'utf-8',
+    env: {
+        LANG: 'zh_CN.UTF-8',
+        LC_ALL: 'zh_CN.UTF-8',
+        LC_CTYPE: 'zh_CN.UTF-8',
+    },
+});
+// ---- Relay ----
+const relay = new relay_1.CoreRelay({
+    config: cfg,
+    configPath: getConfigPath(),
+    targetDir,
+    feishuReplier: feishuReplier,
+    weixinReplier,
+    onStatus,
+});
+// Update relay diagnostics periodically
+function updateDiag() {
+    relay.diag.wsConnected = wsConnected;
+    relay.diag.wsConnectTime = wsConnectTime;
+    relay.diag.lastMessageTime = lastMessageTime;
+    relay.diag.lastMessageText = lastMessageText;
+    relay.diag.lastSendError = lastSendError;
+    relay.diag.lastSendErrorTime = lastSendErrorTime;
+    relay.diag.ptyPid = proc?.pid;
+    relay.diag.ptyAlive = proc !== null && proc.pid > 0;
+    relay.diag.weixinEnabled = weixinEnabled;
+    relay.diag.weixinClientStarted = weixinClient !== null;
+    relay.diag.weixinAccountId = weixinClient ? weixinClient.accountId || null : null;
+}
+// ---- Message handlers ----
+const dataFile = (filename) => (0, core_1.dataPath)(targetDir, filename);
+const handleFeishu = feishuReplier ? (0, core_1.createFeishuHandler)({
+    getPty: () => proc,
+    feishuReplier,
+    onStatus,
+    dataFile,
+    openId: cfg.openId,
+    onSnapshot: handleSnapshot,
+    messageLog,
+}) : null;
+const handleWeixin = weixinReplier ? (0, core_1.createWeixinHandler)({
+    getPty: () => proc,
+    weixinReplier,
+    onStatus,
+    dataFile,
+    wxPendingApprovals: relay.wxPendingApprovals,
+    onSnapshot: handleSnapshot,
+    messageLog,
+}) : null;
+// Wire WeChat message handler
+if (weixinClient && handleWeixin) {
+    weixinClient.onMessage = handleWeixin;
+}
+// ---- Snapshot ----
+async function handleSnapshot(mode, _channel, _meta) {
+    const label = mode.type === 'last' ? `快照${mode.count}` : '快照';
+    onStatus(`\r\n[${label}] CLI 模式下终端快照不可用\r\n`);
+}
+// ---- Feishu diagnostics state ----
+let wsConnected = false;
+let wsConnectTime = 0;
+let lastMessageTime = 0;
+let lastMessageText = '';
+let lastSendError = '';
+let lastSendErrorTime = 0;
+// ---- PTY I/O ----
+proc.onData((data) => {
+    process.stdout.write(data);
+});
+process.stdin.setRawMode?.(true);
+process.stdin.on('data', (key) => {
+    proc.write(key.toString());
+});
+let isShuttingDown = false;
+function forceShutdown(exitCode = 0) {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    relay.stop();
+    feishuStop?.();
+    weixinClient?.stop().catch(() => { });
+    process.exit(exitCode);
+}
+// Crash handlers: ensure relay is stopped on abnormal exit
+process.on('uncaughtException', (err) => {
+    console.error('[cc-remote] 未捕获异常:', err.message || err);
+    forceShutdown(1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[cc-remote] 未处理的 Promise 拒绝:', reason);
+    forceShutdown(1);
+});
+proc.onExit(({ exitCode }) => {
+    if (!isShuttingDown) {
+        forceShutdown(exitCode ?? 0);
+    }
+});
+// ---- Signal handling ----
+let lastSigint = 0;
+process.on('SIGINT', () => {
+    const now = Date.now();
+    if (lastSigint && (now - lastSigint) < 2000) {
+        // Double Ctrl+C within 2s → force quit
+        forceShutdown(0);
+    }
+    else {
+        // First Ctrl+C → forward to PTY
+        lastSigint = now;
+        proc.write('\x03');
+    }
+});
+// ---- Startup ----
+function getConfigPath() {
+    const os = require('os');
+    const userPath = path.join(os.homedir(), '.cc-remote', 'config.json');
+    if (fs.existsSync(userPath))
+        return userPath;
+    return path.join(__dirname, '../config.json');
+}
+const relayPort = cfg.relayPort || 19200;
+ensurePortFree(relayPort).then(() => {
+    try {
+        relay.start(relayPort);
+    }
+    catch (err) {
+        process.stderr.write(`[cc-remote] Relay 启动失败: ${err}\n`);
+        process.exit(1);
+    }
+});
+if (feishuEnabled) {
+    const feishuClient = (0, client_1.createFeishuClient)(cfg);
+    const feishuWs = (0, client_1.createWsClient)(cfg);
+    feishuStop = (0, client_1.startFeishuBot)(feishuClient, feishuWs, {
+        onMessage: handleFeishu,
+        onStatus: (text) => {
+            if (text.includes('已连接')) {
+                wsConnected = true;
+                wsConnectTime = Date.now();
+            }
+            if (text.includes('连接断开')) {
+                wsConnected = false;
+            }
+            onStatus(text);
+        },
+        cardAction: (raw) => relay.handleCardAction(raw),
+    }).stop;
+}
+if (weixinEnabled && weixinClient) {
+    weixinClient.start().catch((err) => {
+        onStatus(`[微信] 启动失败: ${err}`);
+    });
+}
+(0, commands_1.registerFeishuCommands)(targetDir, cfg.relayPort || 19200);
+// Periodic diagnostics update
+setInterval(updateDiag, 5000);
+updateDiag();