botmux 2.85.1 → 2.86.0

package/dist/dashboard.js

@@ -37,8 +37,13 @@ import { loadBotConfigs } from './bot-registry.js';
 import { analyzeSkillReferences } from './core/skills/references.js';
 import { installDashboardSkill, parseDashboardSkillInstallRequest } from './dashboard/skill-install-request.js';
 import { botDefaultsPayload, botSummaryPayload } from './dashboard/bot-payload.js';
+import { isValidRoleProfileId } from './services/role-profile-store.js';
+import { mergeSafeInsightOverviews } from './services/insight/report.js';
 const SECRET_PATH = join(homedir(), '.botmux', '.dashboard-secret');
 const TOKEN_PATH = join(homedir(), '.botmux', '.dashboard-token');
+/** Per-daemon budget for the cross-daemon insight overview fan-out — bounds
+ *  aggregate latency when one daemon's insight parse is slow or hung. */
+const INSIGHT_FANOUT_TIMEOUT_MS = 10_000;
 const BOTS_JSON_PATH = join(homedir(), '.botmux', 'bots.json');
 const REGISTRY_DIR = join(homedir(), '.botmux', 'data', 'dashboard-daemons');
 // The dashboard probes upward if its configured port is busy (e.g. a second
@@ -219,7 +224,7 @@ function serveFileAbs(res, fp) {
     createReadStream(fp).pipe(res);
     return true;
 }
-function serveStatic(_req, res, pathname) {
+function serveStatic(req, res, pathname) {
     const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
     const fp = resolve(WEB_DIR, rel);
     const webRoot = resolve(WEB_DIR);
@@ -231,7 +236,23 @@ function serveStatic(_req, res, pathname) {
         const st = statSync(fp);
         if (!st.isFile())
             return false;
-        res.writeHead(200, { 'content-type': MIME[extname(fp)] ?? 'application/octet-stream' });
+        // Bundle filenames are fixed (app.js/style.css), so without revalidation
+        // browsers heuristic-cache them and serve a stale build after a deploy
+        // (new JS + old CSS → broken layout). `no-cache` + an mtime/size ETag makes
+        // the browser revalidate every load: 304 when unchanged (cheap), fresh 200
+        // when the build changed. No manual hard-refresh needed after deploy.
+        const etag = `W/"${st.size.toString(16)}-${Math.floor(st.mtimeMs).toString(16)}"`;
+        const headers = {
+            'content-type': MIME[extname(fp)] ?? 'application/octet-stream',
+            'cache-control': 'no-cache',
+            etag,
+        };
+        if (req.headers['if-none-match'] === etag) {
+            res.writeHead(304, headers);
+            res.end();
+            return true;
+        }
+        res.writeHead(200, headers);
         res.end(readFileSync(fp));
         return true;
     }
@@ -302,7 +323,13 @@ async function createTeamGroup(args) {
         const upstream = await proxyToDaemon(plan.creatorLarkAppId, '/api/groups/create', {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ name: args.name, larkAppIds: selectedIds, userOpenIds, ownerUnionIds: args.ownerUnionIds ?? [] }),
+            body: JSON.stringify({
+                name: args.name,
+                larkAppIds: selectedIds,
+                userOpenIds,
+                ownerUnionIds: args.ownerUnionIds ?? [],
+                ...(args.roleProfileId ? { roleProfileId: args.roleProfileId } : {}),
+            }),
         });
         const text = await upstream.text();
         let parsed = null;
@@ -673,6 +700,29 @@ const server = createServer(async (req, res) => {
             });
             return jsonRes(res, 200, { sessions });
         }
+        if (req.method === 'GET' && url.pathname === '/api/insights/summary') {
+            const limit = Math.min(Math.max(parseInt(url.searchParams.get('limit') ?? '200', 10) || 200, 1), 500);
+            // Per-daemon timeout + isolate failures: an upstream insight parse can be
+            // heavy, so a slow/hung daemon must not stall the aggregated summary. A
+            // timed-out / errored chunk drops to null and is filtered out below.
+            const chunks = await Promise.all(registry.list().map(async (d) => {
+                try {
+                    const upstream = await proxyToDaemon(d.larkAppId, `/api/insights/summary?limit=${limit}`, {
+                        method: 'GET',
+                        signal: AbortSignal.timeout(INSIGHT_FANOUT_TIMEOUT_MS),
+                    });
+                    if (!upstream.ok)
+                        return null;
+                    const body = await upstream.json().catch(() => null);
+                    return body?.overview ?? null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            const overview = mergeSafeInsightOverviews(chunks.filter((x) => !!x), { limit });
+            return jsonRes(res, 200, { ok: true, overview });
+        }
         if (req.method === 'GET' && url.pathname === '/api/schedules') {
             // Public-read carve-out: the row carries CONTENT (prompt = business
             // instructions) and a bound `workingDir` (repo/customer path) — strip
@@ -1032,6 +1082,30 @@ const server = createServer(async (req, res) => {
             res.end(await upstream.text());
             return;
         }
+        // 会话 insight（只读 trace 分析：动作 span / 失败聚合 / 规则建议）。
+        // owner-only：不在公开读白名单 → decideDashboardAuth 已对只读访客 401，
+        // 公开/联邦访客看不到 tab 也拿不到 span。代理到 owner daemon 的同名 IPC。
+        if (req.method === 'GET' && (m = url.pathname.match(/^\/api\/sessions\/([^/]+)\/insight$/))) {
+            const sid = decodeURIComponent(m[1]);
+            const owner = aggregator.ownerOf(sid);
+            if (!owner)
+                return jsonRes(res, 404, { ok: false, error: 'unknown_session' });
+            const upstream = await proxyToDaemon(owner, `/api/sessions/${sid}/insight${url.search ?? ''}`, { method: 'GET' });
+            res.writeHead(upstream.status, { 'content-type': 'application/json' });
+            res.end(await upstream.text());
+            return;
+        }
+        if (req.method === 'GET' && (m = url.pathname.match(/^\/api\/sessions\/([^/]+)\/insight\/turn\/([^/]+)$/))) {
+            const sid = decodeURIComponent(m[1]);
+            const turnIndex = decodeURIComponent(m[2]);
+            const owner = aggregator.ownerOf(sid);
+            if (!owner)
+                return jsonRes(res, 404, { ok: false, error: 'unknown_session' });
+            const upstream = await proxyToDaemon(owner, `/api/sessions/${sid}/insight/turn/${turnIndex}${url.search ?? ''}`, { method: 'GET' });
+            res.writeHead(upstream.status, { 'content-type': 'application/json' });
+            res.end(await upstream.text());
+            return;
+        }
         // Writable web-terminal link (token-bearing). Not in any public allow-list,
         // so decideDashboardAuth has already 401'd unauthenticated callers before we
         // get here — the token only reaches authenticated dashboard sessions.
@@ -1202,6 +1276,135 @@ const server = createServer(async (req, res) => {
                 return;
             }
         }
+        // ─── Profiles (aggregate/proxy to daemon) ─────────────────────────────
+        if (req.method === 'GET' && url.pathname === '/api/role-profiles') {
+            const merged = new Map();
+            await Promise.all(registry.list().map(async (d) => {
+                try {
+                    const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/role-profiles`);
+                    if (!r.ok)
+                        return;
+                    const j = await r.json();
+                    for (const p of j.profiles ?? []) {
+                        if (typeof p.profileId !== 'string')
+                            continue;
+                        const cur = merged.get(p.profileId) ?? { profileId: p.profileId, entryCount: 0, updatedAt: null, botEntries: [] };
+                        cur.entryCount = Math.max(cur.entryCount, typeof p.entryCount === 'number' ? p.entryCount : 0);
+                        if (typeof p.updatedAt === 'number')
+                            cur.updatedAt = cur.updatedAt === null ? p.updatedAt : Math.max(cur.updatedAt, p.updatedAt);
+                        const larkAppId = j.larkAppId ?? d.larkAppId;
+                        if (!cur.botEntries.some(entry => entry.larkAppId === larkAppId)) {
+                            cur.botEntries.push({ larkAppId, hasEntry: p.hasCurrentBotEntry === true });
+                        }
+                        merged.set(p.profileId, cur);
+                    }
+                }
+                catch { /* skip offline/bad daemon */ }
+            }));
+            return jsonRes(res, 200, {
+                profiles: [...merged.values()]
+                    .map(p => ({
+                    ...p,
+                    entryCount: Math.max(p.entryCount, p.botEntries.filter(entry => entry.hasEntry).length),
+                }))
+                    .sort((a, b) => a.profileId.localeCompare(b.profileId)),
+            });
+        }
+        let mRoleProfileApply;
+        if (req.method === 'POST' && (mRoleProfileApply = url.pathname.match(/^\/api\/role-profiles\/([^/]+)\/apply$/))) {
+            const profileId = decodeURIComponent(mRoleProfileApply[1]);
+            if (!isValidRoleProfileId(profileId))
+                return jsonRes(res, 400, { ok: false, error: 'invalid_role_profile_id' });
+            let raw = '{}';
+            let parsed;
+            try {
+                const chunks = [];
+                for await (const c of req)
+                    chunks.push(c);
+                raw = Buffer.concat(chunks).toString('utf8') || '{}';
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                return jsonRes(res, 400, { ok: false, error: 'bad_json' });
+            }
+            const larkAppId = typeof parsed.larkAppId === 'string' ? parsed.larkAppId : '';
+            if (!larkAppId)
+                return jsonRes(res, 400, { ok: false, error: 'larkAppId_required' });
+            const upstream = await proxyToDaemon(larkAppId, `/api/role-profiles/${encodeURIComponent(profileId)}/apply`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: raw,
+            });
+            res.writeHead(upstream.status, { 'content-type': 'application/json' });
+            res.end(await upstream.text());
+            return;
+        }
+        let mRoleProfileEntry;
+        if ((mRoleProfileEntry = url.pathname.match(/^\/api\/role-profiles\/([^/]+)\/([^/]+)$/))) {
+            const profileId = decodeURIComponent(mRoleProfileEntry[1]);
+            const larkAppId = decodeURIComponent(mRoleProfileEntry[2]);
+            if (!isValidRoleProfileId(profileId))
+                return jsonRes(res, 400, { ok: false, error: 'invalid_role_profile_id' });
+            if (req.method === 'GET') {
+                const upstream = await proxyToDaemon(larkAppId, `/api/role-profiles/${encodeURIComponent(profileId)}/${encodeURIComponent(larkAppId)}`, { method: 'GET' });
+                res.writeHead(upstream.status, { 'content-type': 'application/json' });
+                res.end(await upstream.text());
+                return;
+            }
+            if (req.method === 'PUT') {
+                const chunks = [];
+                for await (const c of req)
+                    chunks.push(c);
+                const raw = Buffer.concat(chunks).toString('utf8') || '{}';
+                const upstream = await proxyToDaemon(larkAppId, `/api/role-profiles/${encodeURIComponent(profileId)}/${encodeURIComponent(larkAppId)}`, {
+                    method: 'PUT',
+                    headers: { 'content-type': 'application/json' },
+                    body: raw,
+                });
+                res.writeHead(upstream.status, { 'content-type': 'application/json' });
+                res.end(await upstream.text());
+                return;
+            }
+            if (req.method === 'DELETE') {
+                const upstream = await proxyToDaemon(larkAppId, `/api/role-profiles/${encodeURIComponent(profileId)}/${encodeURIComponent(larkAppId)}`, { method: 'DELETE' });
+                res.writeHead(upstream.status, { 'content-type': 'application/json' });
+                res.end(await upstream.text());
+                return;
+            }
+        }
+        let mRoleProfile;
+        if (req.method === 'GET' && (mRoleProfile = url.pathname.match(/^\/api\/role-profiles\/([^/]+)$/))) {
+            const profileId = decodeURIComponent(mRoleProfile[1]);
+            if (!isValidRoleProfileId(profileId))
+                return jsonRes(res, 400, { ok: false, error: 'invalid_role_profile_id' });
+            const byBot = new Map();
+            await Promise.all(registry.list().map(async (d) => {
+                try {
+                    const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/role-profiles/${encodeURIComponent(profileId)}`);
+                    if (!r.ok)
+                        return;
+                    const j = await r.json();
+                    for (const entry of j.entries ?? []) {
+                        if (typeof entry.larkAppId !== 'string' || typeof entry.content !== 'string')
+                            continue;
+                        const updatedAt = typeof entry.updatedAt === 'number' ? entry.updatedAt : null;
+                        const current = byBot.get(entry.larkAppId);
+                        if (current && (current.updatedAt ?? 0) > (updatedAt ?? 0))
+                            continue;
+                        byBot.set(entry.larkAppId, {
+                            profileId,
+                            larkAppId: entry.larkAppId,
+                            content: entry.content,
+                            byteLength: typeof entry.byteLength === 'number' ? entry.byteLength : Buffer.byteLength(entry.content, 'utf-8'),
+                            updatedAt,
+                        });
+                    }
+                }
+                catch { /* skip */ }
+            }));
+            const entries = [...byBot.values()].sort((a, b) => a.larkAppId.localeCompare(b.larkAppId));
+            return jsonRes(res, 200, { profileId, entries });
+        }
         let m2;
         if (req.method === 'POST' && (m2 = url.pathname.match(/^\/api\/groups\/([^/]+)\/add-bots$/))) {
             const chatId = decodeURIComponent(m2[1]);
@@ -1570,6 +1773,12 @@ const server = createServer(async (req, res) => {
             if (selectedIds.length === 0) {
                 return jsonRes(res, 400, { ok: false, error: 'larkAppIds_required' });
             }
+            const roleProfileId = typeof parsed.roleProfileId === 'string' && parsed.roleProfileId.trim()
+                ? parsed.roleProfileId.trim()
+                : null;
+            if (roleProfileId && !isValidRoleProfileId(roleProfileId)) {
+                return jsonRes(res, 400, { ok: false, error: 'invalid_role_profile_id' });
+            }
             const explicit = Array.isArray(parsed.userOpenIds)
                 ? parsed.userOpenIds.filter((x) => typeof x === 'string')
                 : [];
@@ -1600,6 +1809,7 @@ const server = createServer(async (req, res) => {
                 bindWorkingDir: typeof parsed.bindWorkingDir === 'string' && parsed.bindWorkingDir.trim()
                     ? parsed.bindWorkingDir.trim()
                     : undefined,
+                roleProfileId: roleProfileId ?? undefined,
             };
             const upstream = await fetch(`http://127.0.0.1:${creator.ipcPort}/api/groups/create`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(forwardBody) });
             const upstreamText = await upstream.text();
@@ -1609,6 +1819,8 @@ const server = createServer(async (req, res) => {
             }
             catch { /* leave null */ }
             if (upstreamJson && typeof upstreamJson === 'object') {
+                if (roleProfileId)
+                    upstreamJson.roleProfileId = roleProfileId;
                 // If Lark rejected the invite (open_id wrong scope, banned user, etc.)
                 // null out autoInvitedOpenId so the frontend doesn't falsely claim
                 // success — the user actually isn't a member of the new chat.