botmux 2.101.1 → 2.103.0

package/dist/dashboard.js

@@ -26,12 +26,13 @@ import { handleFederationApi } from './dashboard/federation-api.js';
 import { handleFederationSpokeApi, syncAllMemberships, autoBindOwnerIfUnambiguous } from './dashboard/federation-spoke-api.js';
 import { getRunsDir } from './workflows/runs-dir.js';
 import { BotOnboardingManager } from './dashboard/bot-onboarding.js';
+import { FeishuLoginManager } from './dashboard/feishu-login.js';
 import { CLI_SELECT_OPTIONS, resolveCliSelection, isTtadkWrapper, ttadkAcceptsModel, TTADK_DEFAULT_MODEL, TTADK_MODEL_SUGGESTIONS, } from './setup/cli-selection.js';
 import { invalidWorkingDirs } from './utils/working-dir.js';
 import { invalidateGlobalConfigCache, mergeGlobalConfig, readGlobalConfig } from './global-config.js';
 import { buildDashboardUrl } from './core/dashboard-url.js';
 import { deleteWhiteboard, listWhiteboards, readWhiteboard, whiteboardEnabled } from './services/whiteboard-store.js';
-import { isLocalDevInstall, botmuxVersion } from './utils/install-info.js';
+import { isLocalDevInstall, botmuxVersion, botmuxCliEntry } from './utils/install-info.js';
 import { checkNode, detectBotmuxInstalls, resolveCurrentVersion } from './utils/install-diagnostics.js';
 import { fetchLatestVersion, fetchReleasesSince, isNewerVersion } from './core/update-check.js';
 import { GITHUB_REPO } from './core/restart-report.js';
@@ -168,7 +169,73 @@ function signDaemonTokenHeaders() {
 mkdirSync(REGISTRY_DIR, { recursive: true });
 const registry = new DaemonRegistry(REGISTRY_DIR);
 const aggregator = new Aggregator();
-const botOnboarding = new BotOnboardingManager({ botsJsonPath: BOTS_JSON_PATH });
+/**
+ * Bring a freshly-onboarded bot online without a fleet-wide restart by spawning
+ * `botmux start-bot <appId> --json` (see cli.ts:ensureBotDaemonStarted). The new
+ * daemon is forked+supervised by pm2 (reparented off this process), self-registers
+ * and opens its Feishu WSClient, then publishes a descriptor the DaemonRegistry
+ * auto-discovers — so no dashboard reload is needed either. Runs `botmux` on the
+ * SAME host as the dashboard (shared pm2 home / bots.json — the documented
+ * dashboard↔daemon co-location assumption). Resolves best-effort; the caller
+ * falls back to the restart hint on failure.
+ */
+function spawnStartBotLive(appId) {
+    return new Promise((resolve) => {
+        let out = '';
+        let err = '';
+        let settled = false;
+        const done = (r) => { if (!settled) {
+            settled = true;
+            resolve(r);
+        } };
+        try {
+            const child = spawn(process.execPath, [botmuxCliEntry(), 'start-bot', appId, '--json'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: process.env,
+            });
+            const timer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* already gone */ }
+                done({ ok: false, message: 'start-bot 超时（30s）' });
+            }, 30_000);
+            timer.unref?.();
+            child.stdout?.on('data', (d) => { out += String(d); });
+            child.stderr?.on('data', (d) => { err += String(d); });
+            child.on('error', (e) => {
+                clearTimeout(timer);
+                done({ ok: false, message: e instanceof Error ? e.message : String(e) });
+            });
+            child.on('exit', (code) => {
+                clearTimeout(timer);
+                // `start-bot --json` prints a single StartBotLiveResult object; prefer its
+                // own message/processName over the raw exit code.
+                let parsed;
+                try {
+                    parsed = JSON.parse(out.trim());
+                }
+                catch { /* non-JSON → fall through */ }
+                if (code === 0) {
+                    done({ ok: true, message: parsed?.processName ? `${parsed.processName} 已上线` : undefined });
+                }
+                else {
+                    done({ ok: false, message: parsed?.message || err.trim() || `start-bot 退出码 ${code}` });
+                }
+            });
+        }
+        catch (e) {
+            done({ ok: false, message: e instanceof Error ? e.message : String(e) });
+        }
+    });
+}
+const botOnboarding = new BotOnboardingManager({
+    botsJsonPath: BOTS_JSON_PATH,
+    startBotLive: spawnStartBotLive,
+});
+// 飞书 Web 登录态刷新（机器人改名缺登录态时的 dashboard 扫码入口）。机器级单例，
+// 写 ~/.botmux/feishu-session.json，与 setup / onboarding 复用同一份登录态。
+const feishuLogin = new FeishuLoginManager();
 const subs = new Map();
 const attaching = new Set(); // dedup concurrent attaches per appId
 function resolveDashboardSettings() {
@@ -1521,6 +1588,15 @@ const server = createServer(async (req, res) => {
                 return jsonRes(res, 404, { ok: false, error: 'unknown_onboarding_job' });
             return jsonRes(res, 200, { job });
         }
+        // 飞书 Web 登录态刷新（改名缺登录态 → dashboard 扫码）。POST 受 dashboard 的
+        // 写操作 auth 闸保护（非 GET 需 owner cookie）；GET 仅暴露二维码+状态，扫码
+        // 授权的是扫码人自己的账号，风险模型与 onboarding 第二个二维码一致。
+        if (req.method === 'POST' && url.pathname === '/api/feishu-login/start') {
+            return jsonRes(res, 202, { login: feishuLogin.start() });
+        }
+        if (req.method === 'GET' && url.pathname === '/api/feishu-login/status') {
+            return jsonRes(res, 200, { login: feishuLogin.get() });
+        }
         let m;
         if (req.method === 'POST' && (m = url.pathname.match(/^\/api\/sessions\/([^/]+)\/(close|locate|resume|restart|start)$/))) {
             const sid = decodeURIComponent(m[1]);
@@ -2204,6 +2280,26 @@ const server = createServer(async (req, res) => {
             res.end(await upstream.text());
             return;
         }
+        // PUT /api/bots/:appId/rename — proxy to that bot's daemon. Body
+        // `{ name: string }`. Daemon tries the Open Platform automation first
+        // (really renames the Feishu app + publishes a version); on failure it
+        // falls back to the botmux-side display name and reports `warning`.
+        let mBotRename;
+        if (req.method === 'PUT' && (mBotRename = url.pathname.match(/^\/api\/bots\/([^/]+)\/rename$/))) {
+            const appId = decodeURIComponent(mBotRename[1]);
+            const chunks = [];
+            for await (const c of req)
+                chunks.push(c);
+            const raw = Buffer.concat(chunks).toString('utf8') || '{}';
+            const upstream = await proxyToDaemon(appId, `/api/bot-rename`, {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: raw,
+            });
+            res.writeHead(upstream.status, { 'content-type': 'application/json' });
+            res.end(await upstream.text());
+            return;
+        }
         // PUT /api/bots/:appId/max-live-workers — proxy to that bot's daemon. Body
         // `{ maxLiveWorkers: number | null }` (null = clear → fall back to the
         // built-in default of 30; a positive integer overrides it).
@@ -2703,17 +2799,52 @@ function handlePlatformTeamSync(payload) {
     logger.info(`[platform-tunnel] team-sync 已应用 rev=${applied.rev} teams=${applied.teams.length}`);
     void maybeAnnounceHallPresence();
 }
-// 大厅打卡（union_id 自学触发）节流：per-bot 最小间隔 + 每进程尝试上限。打卡消息
-// 本身只有 bot 可见（大厅是 bot-only 群），上限只是防御发送持续失败时的无谓重试。
-const hallAnnounceState = new Map();
+// 大厅打卡节流：按「发送 bot ×大厅」记最小间隔与尝试上限——按 bot 记会让多团队
+// bot 在第一个大厅烧光预算后，新加入的大厅永远轮空（实测踩过）。只有真正发出
+// 消息才消耗次数；状态落盘，重启不重发（否则每次重启都往大厅刷一轮）。
 const HALL_ANNOUNCE_MIN_INTERVAL_MS = 10 * 60 * 1000;
 const HALL_ANNOUNCE_MAX_TRIES = 6;
+const hallAnnounceStatePath = () => join(config.session.dataDir, 'hall-announce-state.json');
+function readHallAnnounceState() {
+    try {
+        return JSON.parse(readFileSync(hallAnnounceStatePath(), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** 记录一次打卡尝试。consumeTry=false 只刷新 lastAt（发送失败：保住 10 分钟退避
+ *  但不烧预算——否则 daemon 掉线期间就把 6 次上限烧光、恢复后永久跳过，Codex review）。 */
+function bumpHallAnnounceState(key, consumeTry) {
+    const all = readHallAnnounceState();
+    const cur = all[key];
+    all[key] = { lastAt: Date.now(), tries: (cur?.tries ?? 0) + (consumeTry ? 1 : 0) };
+    try {
+        atomicWriteFileSync(hallAnnounceStatePath(), JSON.stringify(all, null, 2) + '\n');
+    }
+    catch { /* 尽力而为 */ }
+}
+/** 发送方 daemon 的 mention cross-ref（name → 本 app 视角 open_id）。 */
+function readBotCrossRef(appId) {
+    try {
+        return JSON.parse(readFileSync(join(config.session.dataDir, `bot-openids-${appId}.json`), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
 /**
- * 让还没学到自己 union_id 的本地 bot 去团队大厅发一条打卡消息：自家消息回声
- * （event-dispatcher isSelfMessage 分支）带回 sender.sender_id.union_id → 落盘
- * bot-union-ids → 下个心跳上报平台进 roster。一辈子一次；学到即永久跳过。
- * 顺带的副作用：大厅在各成员机器的 team-groups 里（team-sync 镜像），其他
- * daemon 收到这条消息会直接 recordTeamBot 学到该 bot——roster 之外的即时互学。
+ * 大厅打卡编排（union_id 自学）。实测大厅（bot-only 群）只有「直接点名 @」会
+ * 投递事件——普通消息、自 @、@all 全部静默，自家回声在大多数应用上永远等不来。
+ * 机制（与 event-dispatcher 的 hall 分支对偶）：
+ * - 有未入册成员的大厅里，每个本机 bot 点名 @ 自己 cross-ref 能解析到的未入册
+ *   成员（含别的机器的——mention 跨机器投递，对方跑新版即可学）；被点到的直接
+ *   从 mentions[] 学到自己的 union_id。已入册 bot 也参与——纯教学。
+ * - 自己未入册时消息带 #hall-echo，被点到的 bot 回 @ 一次（open_id 取事件
+ *   sender_id，无需 cross-ref）→ 打卡者从回执学到自己。任一方向可解析即收敛。
+ * 消息只在有意义时才发：解析不到任何目标时不发不计次（唯一例外：未入册 bot 的
+ * 首次尝试发一条裸打卡，给有 receive-all scope 的应用留回声机会）。状态落盘，
+ * 重启不重发——解析不到目标反复裸发刷屏这个坑踩过了（自动review 实测）。
  */
 async function maybeAnnounceHallPresence() {
     try {
@@ -2723,36 +2854,58 @@ async function maybeAnnounceHallPresence() {
             return;
         const localBotIds = new Set(readPlatformBotsInfo().map(b => b.appId));
         const now = Date.now();
+        const state = readHallAnnounceState();
         for (const team of teams) {
             const hallChatId = team.groupChatIds[0];
             if (!hallChatId)
                 continue;
+            // 未入册成员（全大厅，含别的机器）：本机的以本地 store 为准（比 roster 新鲜），
+            // 远端的以 roster 的 unionId 为准。
+            const isLearned = (b) => localBotIds.has(b.appId) ? !!getBotUnionId(dataDir, b.appId) : !!b.unionId;
+            const unlearned = team.bots.filter(b => !isLearned(b));
+            if (unlearned.length === 0)
+                continue;
+            const unlearnedNames = new Set(unlearned.map(b => b.name).filter(Boolean));
             for (const bot of team.bots) {
                 if (!localBotIds.has(bot.appId))
-                    continue; // 别的机器的 bot
-                if (getBotUnionId(dataDir, bot.appId))
-                    continue; // 已学到 → 永久跳过
-                const st = hallAnnounceState.get(bot.appId);
+                    continue; // 只编排本机 bot
+                const selfLearned = isLearned(bot);
+                const throttleKey = `${bot.appId}::${hallChatId}`;
+                const st = state[throttleKey];
                 if (st && (now - st.lastAt < HALL_ANNOUNCE_MIN_INTERVAL_MS || st.tries >= HALL_ANNOUNCE_MAX_TRIES))
                     continue;
-                hallAnnounceState.set(bot.appId, { lastAt: now, tries: (st?.tries ?? 0) + 1 });
+                // 点名目标 = 自己 cross-ref 能解析到的未入册成员（发不出 @ 的目标点了也白点）。
+                const crossRef = readBotCrossRef(bot.appId);
+                const targets = [...unlearnedNames].filter(n => n !== bot.name && typeof crossRef[n] === 'string').slice(0, 4);
+                // 没有可教的目标：已入册 → 无事可做；未入册 → 仅首次发裸打卡碰回声运气，
+                // 之后静默等别人教（不发不计次，cross-ref 或 roster 变化后自然恢复）。
+                if (targets.length === 0 && (selfLearned || (st?.tries ?? 0) > 0))
+                    continue;
+                // 成功发出才消耗预算；失败只刷新 lastAt 保住退避间隔（见 bumpHallAnnounceState）。
+                let sent = false;
                 try {
                     const r = await proxyToDaemon(bot.appId, '/api/platform/hall-announce', {
                         method: 'POST',
                         headers: { 'content-type': 'application/json' },
-                        body: JSON.stringify({ chatId: hallChatId }),
+                        body: JSON.stringify({ chatId: hallChatId, mentionNames: targets }),
                     });
                     const j = await r.json().catch(() => ({}));
                     if (!r.ok || !j.ok) {
                         logger.warn(`[platform-tunnel] 大厅打卡失败 bot=${bot.appId} chat=${hallChatId.substring(0, 12)}: ${j.error ?? r.status}`);
                     }
                     else {
-                        logger.info(`[platform-tunnel] 大厅打卡已发 bot=${bot.appId} chat=${hallChatId.substring(0, 12)}（等待回声学 union_id）`);
+                        sent = !j.skipped;
+                        const mentioned = j.mentioned ?? [];
+                        const unresolved = j.unresolved ?? [];
+                        if (sent)
+                            logger.info(`[platform-tunnel] 大厅打卡已发 bot=${bot.appId} chat=${hallChatId.substring(0, 12)}${mentioned.length ? ` 点名=[${mentioned.join(',')}]` : ''}${unresolved.length ? ` 未解析=[${unresolved.join(',')}]` : ''}`);
                     }
                 }
                 catch (e) {
                     logger.warn(`[platform-tunnel] 大厅打卡请求异常 bot=${bot.appId}: ${e.message}`);
                 }
+                bumpHallAnnounceState(throttleKey, sent);
+                state[throttleKey] = { lastAt: now, tries: (st?.tries ?? 0) + (sent ? 1 : 0) };
             }
         }
     }