botmux 2.85.1 → 2.87.0

package/dist/dashboard.js

@@ -27,18 +27,32 @@ import { BotOnboardingManager } from './dashboard/bot-onboarding.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 { mergeDashboardConfig, mergeGlobalConfig, mergeMaintenanceConfig, parseMaintenancePatch, readGlobalConfig, setGlobalLocale } from './global-config.js';
+import { deleteWhiteboard, listWhiteboards, readWhiteboard, whiteboardEnabled } from './services/whiteboard-store.js';
 import { isLocale } from './i18n/types.js';
-import { isLocalDevInstall } from './utils/install-info.js';
+import { isLocalDevInstall, botmuxVersion } 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';
+import { spawnDetachedRestart, npmGlobalUpdateLockTarget } from './core/maintenance.js';
+import { writeRestartIntent } from './services/restart-intent-store.js';
+import { withFileLock } from './utils/file-lock.js';
+import { spawn } from 'node:child_process';
 import { listTeamReports, readTeamBoard, setTeamBoardEntry } from './services/team-board-store.js';
 import { hd2dAssetPath, hd2dStatus, startHd2dDownload } from './dashboard/hd2d-assets.js';
-import { readSkillRegistry, removeInstalledSkill, updateInstalledSkillAsync, } from './services/skill-registry-store.js';
+import { installLocalSkillLinks, readSkillRegistry, removeInstalledSkill, updateInstalledSkillAsync, } from './services/skill-registry-store.js';
 import { redactGitUrlCredentials } from './core/skills/sources.js';
 import { loadBotConfigs } from './bot-registry.js';
+import { discoverNativeCliSkillGroups } from './core/skills/discovery.js';
 import { analyzeSkillReferences } from './core/skills/references.js';
-import { installDashboardSkill, parseDashboardSkillInstallRequest } from './dashboard/skill-install-request.js';
+import { installDashboardSkill, parseDashboardSkillInstallRequest, parseInstallLocalLinksSources, MAX_LOCAL_LINK_SOURCES } 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
@@ -111,6 +125,7 @@ function resolveDashboardSettings() {
         repoPickerMode: global.repoPickerMode ?? 'all',
         maintenance: global.maintenance ?? {},
         localDevInstall: isLocalDevInstall(),
+        whiteboard: { enabled: global.whiteboard?.enabled === true },
     };
 }
 async function readJsonBody(req) {
@@ -120,6 +135,67 @@ async function readJsonBody(req) {
     const raw = Buffer.concat(chunks).toString('utf8').trim();
     return raw ? JSON.parse(raw) : {};
 }
+/** Fast in-process guard against double-clicks within this dashboard process.
+ *  Cross-process serialization against the maintenance auto-update (a different
+ *  process) is handled separately by the shared file lock in the run route. */
+let updateInFlight = false;
+// Cache the upstream version/changelog lookups so the nav-badge check + the
+// Settings card don't hammer the npm registry / GitHub on every page load.
+// GitHub's unauthenticated API is only 60 req/h per IP, so caching the changelog
+// also keeps us from exhausting it. Failures cache briefly so they self-heal.
+const LATEST_TTL_MS = 30 * 60_000;
+const CHANGELOG_TTL_MS = 15 * 60_000;
+const FAILURE_TTL_MS = 60_000;
+let latestVersionCache = null;
+let changelogCache = null;
+async function cachedLatestVersion(now = Date.now()) {
+    const ttl = latestVersionCache?.value ? LATEST_TTL_MS : FAILURE_TTL_MS;
+    if (latestVersionCache && now - latestVersionCache.at < ttl)
+        return latestVersionCache.value;
+    const value = await fetchLatestVersion();
+    latestVersionCache = { value, at: now };
+    return value;
+}
+async function cachedChangelog(current, now = Date.now()) {
+    const ttl = changelogCache?.value.ok ? CHANGELOG_TTL_MS : FAILURE_TTL_MS;
+    if (changelogCache && changelogCache.key === current && now - changelogCache.at < ttl)
+        return changelogCache.value;
+    const value = await fetchReleasesSince(current);
+    changelogCache = { key: current, value, at: now };
+    return value;
+}
+/**
+ * Run `npm install -g botmux@latest` for the manual-update flow WITHOUT blocking
+ * the event loop (async spawn, not execSync — the dashboard must keep serving
+ * during the ~10-30s install). Resolves on exit 0; rejects with the tail of
+ * stdout/stderr on a non-zero exit, spawn error, or 3-minute timeout. Args are
+ * a fixed literal — no shell interpolation of untrusted input.
+ */
+function runNpmInstallLatest() {
+    return new Promise((resolve, reject) => {
+        const child = spawn('npm', ['install', '-g', 'botmux@latest'], {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: process.platform === 'win32', // resolve npm.cmd on Windows
+        });
+        let tail = '';
+        const capture = (d) => { tail = (tail + d.toString()).slice(-2000); };
+        child.stdout?.on('data', capture);
+        child.stderr?.on('data', capture);
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            reject(new Error('npm install timed out after 180s'));
+        }, 180_000);
+        child.on('error', (e) => { clearTimeout(timer); reject(e); });
+        child.on('exit', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`npm exited ${code}: ${tail.trim().slice(-500)}`));
+        });
+    });
+}
 /**
  * Attach to one daemon: hydrate its sessions/schedules into the aggregator,
  * THEN open the SSE subscription. Order matters — hydrating after subscribe
@@ -219,7 +295,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 +307,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 +394,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;
@@ -480,12 +578,33 @@ function sanitizeSkillForDashboard(skill) {
         source: { ...skill.source, url: redactGitUrlCredentials(skill.source.url) },
     };
 }
+function dashboardSkillCliIds() {
+    const ids = new Set();
+    try {
+        for (const cliId of configuredCliIds().values())
+            ids.add(cliId);
+    }
+    catch {
+        // Fall back to daemon descriptors below when persistent config is unavailable.
+    }
+    for (const bot of registry.list()) {
+        if (bot.cliId)
+            ids.add(bot.cliId);
+    }
+    return [...ids];
+}
 function dashboardSkillsPayload() {
     const globalSkills = readGlobalConfig().skills ?? {};
+    const nativeSkillGroups = discoverNativeCliSkillGroups(dashboardSkillCliIds())
+        .map(group => ({
+        ...group,
+        skills: group.skills.map(sanitizeSkillForDashboard),
+    }));
     return {
         skills: Object.values(readSkillRegistry().skills)
             .sort((a, b) => a.name.localeCompare(b.name))
             .map(sanitizeSkillForDashboard),
+        nativeSkillGroups,
         trustProjectSkills: globalSkills.trustProjectSkills ?? 'off',
         delivery: globalSkills.delivery ?? 'auto',
     };
@@ -673,6 +792,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
@@ -724,6 +866,16 @@ const server = createServer(async (req, res) => {
                 mergeGlobalConfig({ repoPickerMode: v });
                 touched = true;
             }
+            if ('whiteboard' in body) {
+                const raw = body.whiteboard;
+                if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                    return jsonRes(res, 400, { ok: false, error: 'invalid_whiteboard' });
+                const wb = raw;
+                if (typeof wb.enabled !== 'boolean')
+                    return jsonRes(res, 400, { ok: false, error: 'invalid_whiteboard_enabled' });
+                mergeGlobalConfig({ whiteboard: { enabled: wb.enabled } });
+                touched = true;
+            }
             if ('maintenance' in body) {
                 const r = parseMaintenancePatch(body.maintenance);
                 if (!r.ok)
@@ -763,6 +915,96 @@ const server = createServer(async (req, res) => {
                 return jsonRes(res, 400, { ok: false, error: 'empty_patch' });
             return jsonRes(res, 200, { ok: true, settings: resolveDashboardSettings() });
         }
+        // ─── Version & manual update ─────────────────────────────────────────────
+        // `npm install -g` and a host restart are privileged: none of these paths
+        // are on PUBLIC_READ_PATHS, so decideDashboardAuth already 401s an
+        // unauthenticated caller (in both normal and public-read mode). The explicit
+        // `authed` guards on the two mutations are defense-in-depth for host actions.
+        if (req.method === 'GET' && url.pathname === '/api/update/status') {
+            const current = resolveCurrentVersion();
+            // Compare against the npm `latest` dist-tag (always stable; the update
+            // button installs `@latest`). isNewerVersion uses semver precedence, so a
+            // canary running AHEAD of the latest stable (e.g. 2.87.0-canary.0 vs
+            // 2.86.0) is NOT flagged behind — exactly the canary case we want.
+            const latest = await cachedLatestVersion();
+            return jsonRes(res, 200, {
+                current,
+                latest,
+                behind: !!latest && isNewerVersion(latest, current),
+                localDevInstall: isLocalDevInstall(),
+                node: checkNode(),
+                installs: detectBotmuxInstalls(),
+            });
+        }
+        if (req.method === 'GET' && url.pathname === '/api/update/changelog') {
+            const current = resolveCurrentVersion();
+            const result = await cachedChangelog(current);
+            return jsonRes(res, 200, {
+                current,
+                ok: result.ok,
+                rateLimited: result.rateLimited === true,
+                releases: result.releases,
+                releasesUrl: `https://github.com/${GITHUB_REPO}/releases`,
+            });
+        }
+        if (req.method === 'POST' && url.pathname === '/api/update/run') {
+            if (!authed)
+                return jsonRes(res, 401, { ok: false, error: 'unauthorized' });
+            if (isLocalDevInstall())
+                return jsonRes(res, 400, { ok: false, error: 'local_dev_no_update' });
+            const node = checkNode();
+            if (!node.ok)
+                return jsonRes(res, 400, { ok: false, error: 'node_too_old', node });
+            if (updateInFlight)
+                return jsonRes(res, 409, { ok: false, error: 'update_in_flight' });
+            updateInFlight = true;
+            const oldVersion = botmuxVersion();
+            // Acquire the shared cross-process lock so a scheduled maintenance
+            // auto-update (running in the bot-0 daemon) can't `npm install -g` at the
+            // same time. `acquired` distinguishes "lock held by maintenance" (409)
+            // from "npm itself failed" (500). Short wait: don't block the request on a
+            // full in-progress install — report busy fast.
+            let acquired = false;
+            try {
+                await withFileLock(npmGlobalUpdateLockTarget(), async () => {
+                    acquired = true;
+                    await runNpmInstallLatest();
+                }, { maxWaitMs: 2_000 });
+            }
+            catch (e) {
+                if (!acquired)
+                    return jsonRes(res, 409, { ok: false, error: 'update_in_flight' });
+                return jsonRes(res, 500, { ok: false, error: 'npm_failed', detail: e instanceof Error ? e.message : String(e) });
+            }
+            finally {
+                updateInFlight = false;
+            }
+            const newVersion = botmuxVersion();
+            return jsonRes(res, 200, { ok: true, oldVersion, newVersion, changed: newVersion !== oldVersion });
+        }
+        if (req.method === 'POST' && url.pathname === '/api/update/restart') {
+            if (!authed)
+                return jsonRes(res, 401, { ok: false, error: 'unauthorized' });
+            let body = {};
+            try {
+                const parsed = await readJsonBody(req);
+                if (parsed && typeof parsed === 'object')
+                    body = parsed;
+            }
+            catch { /* empty / bad body → plain restart */ }
+            const upd = body.update && typeof body.update === 'object' ? body.update : null;
+            // After a manual update, leave an `update` breadcrumb so the fresh daemon
+            // DMs the owner the changelog (reuses the restart-report pipeline). A plain
+            // restart leaves none here; cmdRestart writes a `manual` breadcrumb itself.
+            if (upd && typeof upd.oldVersion === 'string' && typeof upd.newVersion === 'string' && upd.oldVersion !== upd.newVersion) {
+                try {
+                    writeRestartIntent({ kind: 'update', oldVersion: upd.oldVersion, newVersion: upd.newVersion, at: new Date().toISOString() });
+                }
+                catch { /* breadcrumb is best-effort */ }
+            }
+            spawnDetachedRestart('dashboard');
+            return jsonRes(res, 200, { ok: true });
+        }
         if (req.method === 'GET' && url.pathname === '/api/skills') {
             return jsonRes(res, 200, dashboardSkillsPayload());
         }
@@ -815,6 +1057,30 @@ const server = createServer(async (req, res) => {
                 return jsonRes(res, 400, { ok: false, error: redactGitUrlCredentials(err?.message ?? String(err)) });
             }
         }
+        if (req.method === 'POST' && url.pathname === '/api/skills/install-local-links') {
+            let parsed;
+            try {
+                parsed = await readJsonBody(req);
+            }
+            catch {
+                return jsonRes(res, 400, { ok: false, error: 'bad_json' });
+            }
+            const sources = parseInstallLocalLinksSources(parsed);
+            if (sources.length === 0)
+                return jsonRes(res, 400, { ok: false, error: 'sources_required' });
+            if (sources.length > MAX_LOCAL_LINK_SOURCES)
+                return jsonRes(res, 400, { ok: false, error: 'too_many_sources' });
+            try {
+                const skills = installLocalSkillLinks(sources);
+                // Frontend re-fetches /api/skills (refresh()) after success, so we keep
+                // the response lean — no need to spread a full dashboardSkillsPayload()
+                // (which would re-run the native-skill discovery scan a second time).
+                return jsonRes(res, 200, { ok: true, installed: skills.map(sanitizeSkillForDashboard) });
+            }
+            catch (err) {
+                return jsonRes(res, 400, { ok: false, error: redactGitUrlCredentials(err?.message ?? String(err)) });
+            }
+        }
         let mSkillJob;
         if (req.method === 'GET' && (mSkillJob = url.pathname.match(/^\/api\/skills\/jobs\/([^/]+)$/))) {
             const job = skillJobs.get(decodeURIComponent(mSkillJob[1]));
@@ -858,6 +1124,28 @@ const server = createServer(async (req, res) => {
                 ...dashboardSkillsPayload(),
             });
         }
+        if (req.method === 'GET' && url.pathname === '/api/whiteboards') {
+            return jsonRes(res, 200, { enabled: whiteboardEnabled(), whiteboards: listWhiteboards() });
+        }
+        const mWhiteboard = url.pathname.match(/^\/api\/whiteboards\/([^/]+)$/);
+        if (req.method === 'GET' && mWhiteboard) {
+            try {
+                const id = decodeURIComponent(mWhiteboard[1]);
+                return jsonRes(res, 200, { enabled: whiteboardEnabled(), id, content: readWhiteboard(id, { allowDisabled: true }) });
+            }
+            catch (err) {
+                return jsonRes(res, 404, { ok: false, error: err?.message ?? 'whiteboard_not_found' });
+            }
+        }
+        if (req.method === 'DELETE' && mWhiteboard) {
+            try {
+                const id = decodeURIComponent(mWhiteboard[1]);
+                return jsonRes(res, 200, deleteWhiteboard(id));
+            }
+            catch (err) {
+                return jsonRes(res, 400, { ok: false, error: err?.message ?? 'whiteboard_delete_failed' });
+            }
+        }
         if (await handleConnectorApi(req, res, url)) {
             return;
         }
@@ -1032,6 +1320,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 +1514,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]);
@@ -1455,6 +1896,24 @@ const server = createServer(async (req, res) => {
             res.end(await upstream.text());
             return;
         }
+        // PUT /api/bots/:appId/env — proxy to that bot's daemon. Body
+        // `{ env: string }` (raw JSON text; '' = clear).
+        let mBotEnv;
+        if (req.method === 'PUT' && (mBotEnv = url.pathname.match(/^\/api\/bots\/([^/]+)\/env$/))) {
+            const appId = decodeURIComponent(mBotEnv[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-env`, {
+                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/sandbox — proxy to that bot's daemon. Body `{ enabled: boolean }`.
         let mBotSandbox;
         if (req.method === 'PUT' && (mBotSandbox = url.pathname.match(/^\/api\/bots\/([^/]+)\/sandbox$/))) {
@@ -1570,6 +2029,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 +2065,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 +2075,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.