botmux 2.91.0 → 2.92.0

package/dist/dashboard.js

@@ -1,5 +1,5 @@
 // src/dashboard.ts
-import { createServer } from 'node:http';
+import { createServer, get as httpGet } from 'node:http';
 import { createServer as createTcpServer } from 'node:net';
 import { readFileSync, existsSync, mkdirSync, statSync, createReadStream, } from 'node:fs';
 import { atomicWriteFileSync } from './utils/atomic-write.js';
@@ -52,7 +52,8 @@ import { installDashboardSkill, parseDashboardSkillInstallRequest, parseInstallL
 import { botDefaultsPayload, botSummaryPayload } from './dashboard/bot-payload.js';
 import { isValidRoleProfileId } from './services/role-profile-store.js';
 import { mergeSafeInsightOverviews } from './services/insight/report.js';
-import { readPlatformBinding } from './platform/binding.js';
+import { watch as fsWatch } from 'node:fs';
+import { readPlatformBinding, PLATFORM_BINDING_PATH } from './platform/binding.js';
 import { startPlatformTunnelClient } from './platform/tunnel-client.js';
 import { cleanupIdleSessions, parseIdleCleanupHours } from './dashboard/session-cleanup.js';
 const SECRET_PATH = join(homedir(), '.botmux', '.dashboard-secret');
@@ -118,6 +119,37 @@ function dashboardPortAvailable(port) {
     // wildcard bind still succeeds, causing CLI HMAC calls to hit that process.
     return tcpPortAvailable('127.0.0.1', port);
 }
+// Per-process random marker served at /__selfcheck. Lets verifyDashboardBinding
+// confirm a loopback request to our just-bound wildcard port reaches THIS
+// process and not a shadow holding 127.0.0.1:port. The value is meaningless to
+// anyone else, so exposing it is safe.
+const DASHBOARD_SELF_NONCE = randomBytes(16).toString('hex');
+/**
+ * Post-bind loopback identity check handed to listenWithProbe (verifyBound).
+ * dashboardPortAvailable is a PRE-bind gate, but on macOS a loopback occupant
+ * can appear in the race window between that check and the wildcard listen, and
+ * a 0.0.0.0 bind succeeds anyway while loopback routing favours the occupant —
+ * so the dashboard would advertise a port it doesn't actually own on loopback.
+ * This runs AFTER listen: dial 127.0.0.1:port/__selfcheck and require OUR nonce
+ * back. A shadow answers with its own body/404 → reject → listenWithProbe steps
+ * up. Number-independent: it works no matter which port or who is shadowing.
+ * Loopback-host binds can't be shadowed, so they short-circuit to true.
+ */
+function verifyDashboardBinding(port) {
+    if (!isWildcardBindHost(config.dashboard.host))
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const req = httpGet({ host: '127.0.0.1', port, path: '/__selfcheck', agent: false }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (c) => { body += c; if (body.length > 128)
+                req.destroy(); });
+            res.on('end', () => resolve(res.statusCode === 200 && body === DASHBOARD_SELF_NONCE));
+        });
+        req.setTimeout(2000, () => { req.destroy(); resolve(false); });
+        req.on('error', () => resolve(false));
+    });
+}
 /** Sign a loopback request to a daemon's write-link route. The daemon verifies
  *  with the same .dashboard-secret, so only a caller that can read the secret —
  *  the dashboard — can mint write tokens; a bare local process that only knows
@@ -807,6 +839,13 @@ const server = createServer(async (req, res) => {
         if (url.pathname === '/__health') {
             return jsonRes(res, 200, { ok: true });
         }
+        // Loopback self-identification (no auth): echoes this process's nonce so the
+        // post-bind shadow check (listen-with-probe verifyBound) can distinguish our
+        // server from a process shadowing 127.0.0.1:port. Returns only the nonce.
+        if (url.pathname === '/__selfcheck') {
+            res.writeHead(200, { 'content-type': 'text/plain' });
+            return res.end(DASHBOARD_SELF_NONCE);
+        }
         if (await handleWebhookRoute(req, res, url, {
             proxyToDaemon,
             createLifecycleGroup: createLifecycleGroupForWebhook,
@@ -2026,6 +2065,11 @@ const server = createServer(async (req, res) => {
             }
             const creator = registry.getByAppId(pick.creatorLarkAppId);
             const merged = new Set([...explicit, ...pick.userOpenIds]);
+            // 跨 app 邀请通道：按 union_id 加人（open_id 是 app 作用域的，union_id 稳定，
+            // 由 creator daemon 解析成本 app 的 open_id 再加）。平台「拉群」即走这条。
+            const ownerUnionIds = Array.isArray(parsed.ownerUnionIds)
+                ? parsed.ownerUnionIds.filter((x) => typeof x === 'string')
+                : [];
             // Auto-invite/transfer/notify target: prefer the explicit open_id passed
             // by the caller (rare API consumer use), else the creator bot's first
             // resolved allowlist entry.
@@ -2034,6 +2078,7 @@ const server = createServer(async (req, res) => {
                 name: typeof parsed.name === 'string' ? parsed.name : undefined,
                 larkAppIds: selectedIds,
                 userOpenIds: [...merged],
+                ownerUnionIds,
                 // Auto-transfer ownership to the auto-invited operator. Scope-safe
                 // because the open_id was sourced from the creator bot's own allowlist.
                 transferOwnerTo: autoInvited ?? undefined,
@@ -2249,6 +2294,7 @@ listenWithProbe({
     port: config.dashboard.port,
     host: config.dashboard.host,
     portAvailable: dashboardPortAvailable,
+    verifyBound: verifyDashboardBinding,
     log: (m) => logger.warn(`[dashboard] ${m}`),
 }).then((port) => {
     boundDashboardPort = port;
@@ -2260,6 +2306,7 @@ listenWithProbe({
     }
     logger.info(`[dashboard] listening on ${config.dashboard.host}:${port}`);
     startPlatformTunnelIfBound();
+    watchPlatformBinding(); // bind 后无需重启 daemon，自动连接平台
 }).catch((err) => {
     logger.error(`[dashboard] could not bind near ${config.dashboard.host}:${config.dashboard.port} after probing — set BOTMUX_DASHBOARD_PORT to a free port. ${err.message}`);
     process.exit(1);
@@ -2276,6 +2323,8 @@ const federationSync = setInterval(() => {
 federationSync.unref();
 // 中心化平台隧道（已绑定才启动；每台机器一个，跑在 dashboard 进程里）
 let platformTunnel = null;
+// 当前隧道对应的绑定身份（platformUrl|machineId|machineToken）；用于判断 bind 变化是否需要重连
+let platformBindingKey = null;
 function readBotmuxVersion() {
     try {
         const pkg = JSON.parse(readFileSync(join(dirname(__dirname), 'package.json'), 'utf8'));
@@ -2285,25 +2334,91 @@ function readBotmuxVersion() {
         return 'unknown';
     }
 }
+/** 读本机 bots-info.json，转成上报给平台的 bot 概要（人→机器→bot + 拉群用）。 */
+function readPlatformBotsInfo() {
+    try {
+        const fp = join(config.session.dataDir, 'bots-info.json');
+        if (!existsSync(fp))
+            return [];
+        const entries = JSON.parse(readFileSync(fp, 'utf8'));
+        if (!Array.isArray(entries))
+            return [];
+        return entries
+            .map((e) => ({
+            appId: e.larkAppId || '',
+            openId: e.botOpenId ?? null,
+            name: e.botName || e.larkAppId || 'bot',
+            avatar: e.botAvatarUrl || undefined,
+            cli: e.cliId,
+        }))
+            .filter((b) => b.appId);
+    }
+    catch {
+        return [];
+    }
+}
 function startPlatformTunnelIfBound() {
     try {
         const binding = readPlatformBinding();
-        if (!binding)
+        if (!binding) {
+            platformBindingKey = null;
             return;
+        }
         const version = readBotmuxVersion();
         platformTunnel = startPlatformTunnelClient({
             binding,
             getDashboardPort: () => boundDashboardPort,
             getDashboardToken: () => activeToken,
             getVersion: () => version,
+            getBots: () => readPlatformBotsInfo(),
             log: (msg, extra) => logger.info(`[platform-tunnel] ${msg}${extra ? ' ' + JSON.stringify(extra) : ''}`),
         });
+        platformBindingKey = `${binding.platformUrl}|${binding.machineId}|${binding.machineToken}`;
         logger.info(`[platform-tunnel] 绑定到 ${binding.platformUrl}，启动隧道`);
     }
     catch (e) {
         logger.warn(`[platform-tunnel] 启动失败: ${e.message}`);
     }
 }
+/**
+ * 监听绑定文件变化：`botmux bind` 写入后无需重启 daemon，自动连接平台。
+ * 只在绑定「身份」(platformUrl/machineId/machineToken) 变化时重连——团队成员变化也会改写该文件
+ * （tunnel-client 自己写的），那种不重连，避免反复重启。
+ */
+function watchPlatformBinding() {
+    let timer = null;
+    const onChange = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            const b = readPlatformBinding();
+            const key = b ? `${b.platformUrl}|${b.machineId}|${b.machineToken}` : null;
+            if (key === platformBindingKey)
+                return; // 没变（或仅团队变化）→ 不重连
+            logger.info('[platform-tunnel] 检测到绑定变化，重连平台');
+            try {
+                platformTunnel?.stop();
+            }
+            catch {
+                /* ignore */
+            }
+            platformTunnel = null;
+            startPlatformTunnelIfBound();
+        }, 800);
+    };
+    try {
+        // 监听所在目录而非文件本身——绑定走原子写（临时文件 + rename），直接 watch 文件会在 rename 后失效
+        const dir = dirname(PLATFORM_BINDING_PATH);
+        const base = PLATFORM_BINDING_PATH.slice(dir.length + 1);
+        fsWatch(dir, (_event, filename) => {
+            if (!filename || filename === base)
+                onChange();
+        });
+    }
+    catch (e) {
+        logger.warn(`[platform-tunnel] 绑定文件监听启动失败: ${e.message}`);
+    }
+}
 // Graceful shutdown
 function shutdown() {
     for (const off of subs.values())