metame-cli 1.5.13 → 1.5.15

package/scripts/daemon-weixin-bridge.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { createWeixinApiClient, DEFAULT_BASE_URL, DEFAULT_LONG_POLL_TIMEOUT_MS } = require('./daemon-weixin-api');
+const { createWeixinAuthStore } = require('./daemon-weixin-auth');
+
+function extractInboundText(itemList) {
+  if (!Array.isArray(itemList)) return '';
+  for (const item of itemList) {
+    if (item && item.type === 1 && item.text_item && item.text_item.text != null) {
+      return String(item.text_item.text).trim();
+    }
+    if (item && item.type === 3 && item.voice_item && item.voice_item.text) {
+      return String(item.voice_item.text).trim();
+    }
+  }
+  return '';
+}
+
+function createContextTokenStore() {
+  const store = new Map();
+  return {
+    set(accountId, userId, token) {
+      const a = String(accountId || '').trim();
+      const u = String(userId || '').trim();
+      const t = String(token || '').trim();
+      if (!a || !u || !t) return;
+      store.set(`${a}:${u}`, t);
+    },
+    get(accountId, userId) {
+      return store.get(`${String(accountId || '').trim()}:${String(userId || '').trim()}`) || null;
+    },
+    clear(accountId, userId) {
+      store.delete(`${String(accountId || '').trim()}:${String(userId || '').trim()}`);
+    },
+  };
+}
+
+function createPersistentContextTokenStore(deps = {}) {
+  const mem = deps.tokenStore || createContextTokenStore();
+  const HOME = deps.HOME || os.homedir();
+  const fsMod = deps.fs || fs;
+  const pathMod = deps.path || path;
+  const filePath = deps.filePath || pathMod.join(HOME, '.metame', 'weixin', 'context-tokens.json');
+
+  function loadAll() {
+    try {
+      if (!fsMod.existsSync(filePath)) return {};
+      const raw = JSON.parse(fsMod.readFileSync(filePath, 'utf8'));
+      return raw && typeof raw === 'object' ? raw : {};
+    } catch {
+      return {};
+    }
+  }
+
+  function saveAll(data) {
+    try {
+      fsMod.mkdirSync(pathMod.dirname(filePath), { recursive: true });
+      fsMod.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+      try {
+        fsMod.chmodSync(filePath, 0o600);
+      } catch {}
+    } catch {}
+  }
+
+  return {
+    set(accountId, userId, token) {
+      mem.set(accountId, userId, token);
+      const key = `${String(accountId || '').trim()}:${String(userId || '').trim()}`;
+      const all = loadAll();
+      all[key] = {
+        token: String(token || '').trim(),
+        savedAt: new Date().toISOString(),
+      };
+      saveAll(all);
+    },
+    get(accountId, userId) {
+      const hit = mem.get(accountId, userId);
+      if (hit) return hit;
+      const key = `${String(accountId || '').trim()}:${String(userId || '').trim()}`;
+      const all = loadAll();
+      const token = all[key] && all[key].token ? String(all[key].token).trim() : '';
+      if (token) mem.set(accountId, userId, token);
+      return token || null;
+    },
+    clear(accountId, userId) {
+      mem.clear(accountId, userId);
+      const key = `${String(accountId || '').trim()}:${String(userId || '').trim()}`;
+      const all = loadAll();
+      if (Object.prototype.hasOwnProperty.call(all, key)) {
+        delete all[key];
+        saveAll(all);
+      }
+    },
+  };
+}
+
+function createWeixinBridge(deps = {}) {
+  const log = typeof deps.log === 'function' ? deps.log : () => {};
+  const loadConfig = deps.loadConfig;
+  const pipeline = deps.pipeline;
+  const sleep = typeof deps.sleep === 'function' ? deps.sleep : (ms) => new Promise(resolve => setTimeout(resolve, ms));
+  const apiClient = deps.apiClient || createWeixinApiClient({ log });
+  const authStore = deps.authStore || createWeixinAuthStore({
+    apiClient,
+    HOME: deps.HOME,
+    log,
+    sleep,
+  });
+  const tokenStore = deps.tokenStore || createPersistentContextTokenStore({ HOME: deps.HOME });
+
+  if (typeof loadConfig !== 'function') throw new Error('loadConfig is required');
+  if (!pipeline || typeof pipeline.processMessage !== 'function') throw new Error('pipeline.processMessage is required');
+
+  function resolveBridgeConfig(config) {
+    const cfg = (config && config.weixin) || {};
+    return {
+      enabled: !!cfg.enabled,
+      baseUrl: String(cfg.base_url || DEFAULT_BASE_URL).trim(),
+      botType: String(cfg.bot_type || '3').trim(),
+      routeTag: cfg.route_tag === undefined || cfg.route_tag === null ? null : String(cfg.route_tag).trim(),
+      pollTimeoutMs: Number(cfg.poll_timeout_ms || DEFAULT_LONG_POLL_TIMEOUT_MS),
+      allowedChatIds: Array.isArray(cfg.allowed_chat_ids) ? cfg.allowed_chat_ids.map(String) : [],
+      accountId: String(cfg.account_id || '').trim(),
+    };
+  }
+
+  function resolveActiveAccount(config) {
+    const cfg = resolveBridgeConfig(config);
+    const accountId = cfg.accountId || authStore.listAccounts()[0] || '';
+    if (!accountId) return null;
+    const account = authStore.loadAccount(accountId);
+    if (!account || !account.token) return null;
+    return {
+      accountId,
+      token: account.token,
+      baseUrl: String(account.baseUrl || cfg.baseUrl || DEFAULT_BASE_URL).trim(),
+      routeTag: account.routeTag || cfg.routeTag || null,
+    };
+  }
+
+  function createWeixinBot(params) {
+    const accountId = params.accountId;
+    const baseUrl = params.baseUrl;
+    const token = params.token;
+    const routeTag = params.routeTag;
+
+    async function sendPlain(chatId, text) {
+      const contextToken = tokenStore.get(accountId, chatId);
+      if (!contextToken) throw new Error(`weixin context token missing for ${chatId}`);
+      log('DEBUG', `[WEIXIN] send chatId=${chatId} text_len=${String(text || '').length} ctx=${contextToken.slice(0, 8)}`);
+      const result = await apiClient.sendTextMessage({
+        baseUrl,
+        token,
+        routeTag,
+        toUserId: chatId,
+        contextToken,
+        text,
+      });
+      log('DEBUG', `[WEIXIN] send ok chatId=${chatId} ret=${result && result.ret} payload=${JSON.stringify(result || {})}`);
+      return { message_id: Date.now() };
+    }
+
+    return {
+      suppressAck: true,
+      sendMessage: async (_chatId, text) => sendPlain(_chatId, String(text || '').trim()),
+      deleteMessage: async () => false,
+      sendTyping: async () => {},
+    };
+  }
+
+  async function startWeixinBridge(config, executeTaskByName) {
+    const cfg = resolveBridgeConfig(config);
+    if (!cfg.enabled) return null;
+    let running = true;
+    let processing = false;
+    let timer = null;
+    let getUpdatesBuf = '';
+    let currentAccount = null;
+    let currentBot = null;
+    let missingAccountLogged = false;
+
+    function sameAccount(a, b) {
+      if (!a || !b) return false;
+      return a.accountId === b.accountId
+        && a.token === b.token
+        && a.baseUrl === b.baseUrl
+        && a.routeTag === b.routeTag;
+    }
+
+    function setActiveAccount(account) {
+      if (sameAccount(currentAccount, account) && currentBot) return;
+      currentAccount = account;
+      currentBot = account ? createWeixinBot(account) : null;
+      getUpdatesBuf = '';
+      if (account) {
+        log('INFO', `[WEIXIN] bridge active account=${account.accountId}`);
+      }
+    }
+
+    function scheduleNext(delayMs) {
+      if (!running) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => { pump().catch(() => {}); }, delayMs);
+    }
+
+    async function pump() {
+      if (!running || processing) return;
+      processing = true;
+      let nextDelayMs = 250;
+      try {
+        const liveCfg = loadConfig();
+        const liveBridgeCfg = resolveBridgeConfig(liveCfg);
+        if (!liveBridgeCfg.enabled) {
+          setActiveAccount(null);
+          nextDelayMs = 1000;
+          return;
+        }
+        const liveAccount = resolveActiveAccount(liveCfg);
+        if (!liveAccount) {
+          if (!missingAccountLogged) {
+            missingAccountLogged = true;
+            log('WARN', '[WEIXIN] bridge enabled but no linked account found; waiting for account link');
+          }
+          setActiveAccount(null);
+          nextDelayMs = 500;
+          return;
+        }
+        missingAccountLogged = false;
+        setActiveAccount(liveAccount);
+        const resp = await apiClient.getUpdates({
+          baseUrl: currentAccount.baseUrl,
+          token: currentAccount.token,
+          routeTag: currentAccount.routeTag,
+          getUpdatesBuf,
+          timeoutMs: liveBridgeCfg.pollTimeoutMs,
+        });
+        if (resp && typeof resp.get_updates_buf === 'string' && resp.get_updates_buf) {
+          getUpdatesBuf = resp.get_updates_buf;
+        }
+        const messages = Array.isArray(resp && resp.msgs) ? resp.msgs : [];
+        for (const full of messages) {
+          const chatId = String(full && full.from_user_id || '').trim();
+          if (!chatId) continue;
+          if (liveBridgeCfg.allowedChatIds.length && !liveBridgeCfg.allowedChatIds.includes(chatId)) {
+            continue;
+          }
+          const text = extractInboundText(full.item_list);
+          if (!text) continue;
+          if (full && full.context_token) {
+            tokenStore.set(currentAccount.accountId, chatId, full.context_token);
+          }
+          log('DEBUG', `[WEIXIN] inbound chatId=${chatId} text_len=${text.length} has_ctx=${!!(full && full.context_token)} buf=${String(getUpdatesBuf || '').slice(0, 16)}`);
+          await pipeline.processMessage(chatId, text, {
+            bot: currentBot,
+            config: liveCfg,
+            executeTaskByName,
+            senderId: chatId,
+            readOnly: false,
+          });
+        }
+      } catch (err) {
+        log('WARN', `[WEIXIN] poll error: ${err.message}`);
+        nextDelayMs = 1000;
+      } finally {
+        processing = false;
+        scheduleNext(nextDelayMs);
+      }
+    }
+
+    scheduleNext(0);
+    return {
+      stop() {
+        running = false;
+        if (timer) clearTimeout(timer);
+      },
+      reconnect() {
+        getUpdatesBuf = '';
+        scheduleNext(0);
+      },
+      get bot() {
+        return currentBot;
+      },
+      get accountId() {
+        return currentAccount ? currentAccount.accountId : null;
+      },
+    };
+  }
+
+  return {
+    startWeixinBridge,
+    createWeixinBot,
+    createContextTokenStore,
+    createPersistentContextTokenStore,
+    resolveBridgeConfig,
+    resolveActiveAccount,
+  };
+}
+
+module.exports = {
+  createWeixinBridge,
+  createContextTokenStore,
+  createPersistentContextTokenStore,
+  extractInboundText,
+};

package/scripts/daemon.js

@@ -293,7 +293,7 @@ function restoreConfig() {
     try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch { }
     // Secret fields that must NEVER be reverted by a restore
     const SECRET_FIELDS = ['app_id', 'app_secret', 'bot_token', 'operator_ids'];
-    for (const adapter of ['feishu', 'telegram']) {
+    for (const adapter of ['feishu', 'telegram', 'weixin']) {
       if (curCfg[adapter] && bakCfg[adapter]) {
         // Preserve secrets: current config always wins
         for (const field of SECRET_FIELDS) {
@@ -2456,7 +2456,7 @@ _pipelineRef.current = pipeline;
 // ---------------------------------------------------------
 // BOT BRIDGES
 // ---------------------------------------------------------
-const { startTelegramBridge, startFeishuBridge, startImessageBridge, startSiriBridge } = createBridgeStarter({
+const { startTelegramBridge, startFeishuBridge, startWeixinBridge, startImessageBridge, startSiriBridge } = createBridgeStarter({
   fs,
   path,
   HOME,
@@ -2593,7 +2593,7 @@ async function main() {
   }
 
   // Config validation: warn on unknown/suspect fields
-  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge'];
+  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'weixin', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge'];
   const KNOWN_DAEMON = [
     'model',          // legacy (still valid as fallback)
     'models',         // per-engine model map: { claude, codex }
@@ -2684,12 +2684,13 @@ async function main() {
   // Bridges
   let telegramBridge = null;
   let feishuBridge = null;
+  let weixinBridge = null;
   let lastWakeBridgeRecoveryAt = 0;
 
   const notifier = createNotifier({
     log,
     getConfig: () => config,
-    getBridges: () => ({ telegramBridge, feishuBridge }),
+    getBridges: () => ({ telegramBridge, feishuBridge, weixinBridge }),
   });
   const notifyFn = notifier.notify;
   const adminNotifyFn = notifier.notifyAdmin;
@@ -2714,6 +2715,10 @@ async function main() {
       log('INFO', `[WAKE-DETECT] reconnecting Feishu bridge after ${sleepSeconds}s sleep`);
       tasks.push(Promise.resolve().then(() => feishuBridge.reconnect()));
     }
+    if (weixinBridge && typeof weixinBridge.reconnect === 'function') {
+      log('INFO', `[WAKE-DETECT] reconnecting Weixin bridge after ${sleepSeconds}s sleep`);
+      tasks.push(Promise.resolve().then(() => weixinBridge.reconnect()));
+    }
     await Promise.allSettled(tasks);
   };
 
@@ -2781,6 +2786,7 @@ async function main() {
   // Start bridges (both can run simultaneously)
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
   feishuBridge = await startFeishuBridge(config, executeTaskByName);
+  weixinBridge = await startWeixinBridge(config, executeTaskByName);
   await startImessageBridge(config, executeTaskByName);
   await startSiriBridge(config, executeTaskByName);
   if (feishuBridge) _dispatchBridgeRef = feishuBridge; // store bridge, not bot, so .bot stays live after reconnects
@@ -2795,6 +2801,7 @@ async function main() {
     const bots = [];
     if (feishuBridge && feishuBridge.bot) bots.push(feishuBridge.bot);
     if (telegramBridge && telegramBridge.bot) bots.push(telegramBridge.bot);
+    if (weixinBridge && weixinBridge.bot) bots.push(weixinBridge.bot);
     if (bots.length === 0) return;
     const notifs = [];
     for (const [cid] of activeProcesses) {
@@ -2825,6 +2832,7 @@ async function main() {
     try { fs.unlinkSync(SOCK_PATH); } catch { }
     if (telegramBridge) telegramBridge.stop();
     if (feishuBridge) feishuBridge.stop();
+    if (weixinBridge) weixinBridge.stop();
     // Stop QMD semantic search daemon if it was started
     try { require('./qmd-client').stopDaemon(); } catch { /* ignore */ }
     // Release warm pool processes before killing active ones

package/scripts/docs/hook-config.md

@@ -1,6 +1,6 @@
 # MetaMe Hook / Intent Engine 配置手册
 
-> 自动部署到 `~/.metame/docs/hook-config.md`。源文件：`scripts/docs/hook-config.md`。
+> 自动部署到 `~/.metame/docs/hook-config.md`。源文件：`scripts/docs/hook-config.md`。只编辑 `scripts/`，不要直接改 `~/.metame/`。
 
 ---
 
@@ -29,6 +29,7 @@ Stop (每轮结束)
 | `ops_assist` | `intent-ops-assist.js` | 回退/日志/重启/gc/状态 相关语境 | `/undo` `/restart` `/logs` `/gc` `/status` 命令提示 |
 | `task_create` | `intent-task-create.js` | 定时/提醒/每天X点 等调度语境 | `/task-add` 命令用法提示 |
 | `file_transfer` | `intent-file-transfer.js` | "发给我/发过来/导出" 等文件传输语境 | `[[FILE:...]]` 协议 + 收发规则 |
+| `weixin_bridge` | `intent-weixin-bridge.js` | "帮我绑定微信/配置微信桥接/开启微信接入/开始微信扫码登录" 等明确桥接语境 | 开启 `weixin.enabled` + `/weixin` 绑定流程提示 |
 | `memory_recall` | `intent-memory-recall.js` | "上次/之前/还记得" 等跨会话回忆语境 | `memory-search.js` 命令用法 |
 | `doc_router` | `intent-doc-router.js` | "创建/绑定 Agent"、"代码结构/脚本入口"、"hook/intent 配置" 等文档导向语境 | 统一 doc-router 文档指引 |
 ---
@@ -42,6 +43,7 @@ hooks:
   team_dispatch: true   # 改为 false 可禁用
   ops_assist: true
   task_create: false    # 禁用任务调度提示
+  weixin_bridge: false  # 默认关闭；命中明确微信配置语境时再按需开启
 ```
 
 改完立即生效（intent-engine 每次运行时读取）。
@@ -128,7 +130,7 @@ for k, v in s.get('hooks', {}).items():
 |------|------|
 | `scripts/intent-registry.js` | 共享意图注册表（Claude hook / Codex runtime 共用） |
 | `scripts/hooks/intent-engine.js` | Claude hook adapter（源文件） |
-| `~/.metame/hooks/intent-engine.js` | 部署副本（symlink） |
+| `~/.metame/hooks/intent-engine.js` | 部署副本（copy） |
 | `scripts/hooks/intent-*.js` | 各意图模块（源文件） |
 | `~/.metame/daemon.yaml` | 用户配置（包含 `hooks:` 开关） |
 | `~/.claude/settings.json` | Claude Code hook 注册表 |

package/scripts/docs/maintenance-manual.md

@@ -83,6 +83,8 @@ feishu:
 
 ## 6. 运行时文件与状态
 
+- 源码目录：`scripts/`
+- 运行副本目录：`~/.metame/`（由 `node index.js` 部署生成，只读看状态，不直接改）
 - 配置：`~/.metame/daemon.yaml`
 - daemon 状态：`~/.metame/daemon_state.json`
 - 活跃子进程：`~/.metame/active_agent_pids.json`
@@ -91,10 +93,11 @@ feishu:
 - Dispatch 队列：`~/.metame/dispatch/pending.jsonl`（本地 socket 降级）
 - 远端 Dispatch 队列：`~/.metame/dispatch/remote-pending.jsonl`（跨设备中继）
 - Dispatch 签名密钥：`~/.metame/.dispatch_secret`（自动创建）
+- 自动更新策略：发布版 npm 安装默认开启；源码 checkout / `npm link` 默认关闭，可用 `METAME_AUTO_UPDATE=on|off` 覆盖
 
 ## 7. 热重载安全机制（三层防护）
 
-1. **部署前预检**（`index.js`）：`node -c` 语法检查所有 `.js`，不通过则拒绝部署到 `~/.metame/`
+1. **部署前预检**（`index.js`）：`node -c` 语法检查所有 `.js`，不通过则拒绝以 copy 模式部署到 `~/.metame/`
 2. **重启前预检**（`daemon-runtime-lifecycle.js`）：daemon.js 变更触发重启前再次语法校验，不通过则阻止重启并通知 admin
 3. **崩溃循环自愈**：连续 2 次在 30s 内崩溃 → 自动从 `.last-good/` 恢复 → 通知 admin
 

package/scripts/docs/pointer-map.md

@@ -195,5 +195,8 @@
 
 ## 同步提示
 
-- 每次改 `scripts/` 后执行：`npm run sync:plugin`
+- `scripts/` 是唯一源码目录；`~/.metame/` 是运行副本，不直接编辑
+- 每次改 `scripts/` 后先执行：`node index.js`，把最新运行文件 copy 到 `~/.metame/`
+- 只有在需要刷新分发镜像时才执行：`npm run sync:plugin`
 - plugin 镜像路径：`plugin/scripts/*`
+- 本地源码 checkout / `npm link` 默认关闭 auto-update；发布版 npm 安装默认开启，可用 `METAME_AUTO_UPDATE=on|off` 覆盖

package/scripts/hooks/intent-weixin-bridge.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Weixin Bridge Intent Module
+ *
+ * 按需暴露 MetaMe 的微信桥接配置能力，只在用户明确谈到微信接入、
+ * 开启桥接、扫码登录、绑定配置或微信 direct bridge 时注入。
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const POSITIVE_PATTERNS = [
+  /(?:帮我|请|想|要|需要|如何|怎么).{0,10}(?:配置|绑定|接入|接上|开通|启用).{0,10}(?:微信|wechat)(?:.{0,10}(?:bridge|桥接|bot|通道))?/i,
+  /(?:微信|wechat).{0,12}(?:配置|绑定|接入|接上|开通|启用|扫码|二维码|登录|授权|bridge|桥接|bot|通道)/i,
+  /(?:开始|发起).{0,8}(?:微信|wechat).{0,10}(?:扫码|二维码|登录|绑定|授权)/i,
+  /(?:用|通过).{0,6}(?:微信|wechat).{0,10}(?:聊|对话|发消息|收消息|回复)/i,
+];
+const NEGATIVE_PATTERNS = [
+  /企业微信|wecom/i,
+  /微信群|群聊|group/i,
+];
+
+module.exports = function detectWeixinBridge(prompt) {
+  const text = String(prompt || '').trim();
+  if (!text || text.length < 4) return null;
+  if (NEGATIVE_PATTERNS.some(re => re.test(text))) return null;
+  if (!POSITIVE_PATTERNS.some(re => re.test(text))) return null;
+
+  return [
+    '[微信桥接提示]',
+    '- 当前已接入 MetaMe 的是 **微信 direct bridge**，不是企业微信。',
+    '- 如果用户是在让你代为配置，先确保 `~/.metame/daemon.yaml` 里的 `weixin.enabled=true`，`weixin.bot_type=\"3\"`，其余可先保持默认。',
+    '- 开启配置后，执行 `/weixin login start [--bot-type 3] [--session <key>]` 生成二维码/登录链接。',
+    '- 用户扫码确认后，再执行 `/weixin login wait --session <key>` 等待绑定完成。',
+    '- 查看状态：`/weixin` 或 `/weixin status`。',
+    '- 当前最稳的是 **text-only**：收到微信消息后回复文本；媒体、文件、富交互还不是第一优先级。',
+    '- 微信出站依赖最近一条入站消息携带的 `context_token`，所以更适合“用户来一句，系统回一句”的对话模式。',
+  ].join('\n');
+};

package/scripts/intent-registry.js

@@ -12,6 +12,7 @@ const DEFAULTS = Object.freeze({
   ops_assist: true,
   task_create: true,
   file_transfer: true,
+  weixin_bridge: false,
   memory_recall: true,
   doc_router: true,
   perpetual: true,
@@ -23,6 +24,7 @@ const INTENT_MODULES = Object.freeze({
   ops_assist: require('./hooks/intent-ops-assist'),
   task_create: require('./hooks/intent-task-create'),
   file_transfer: require('./hooks/intent-file-transfer'),
+  weixin_bridge: require('./hooks/intent-weixin-bridge'),
   memory_recall: require('./hooks/intent-memory-recall'),
   doc_router: require('./hooks/intent-doc-router'),
   perpetual: require('./hooks/intent-perpetual'),