botmux 2.107.0 → 2.108.0

package/dist/dashboard.js

@@ -33,11 +33,12 @@ import { invalidateGlobalConfigCache, mergeGlobalConfig, readGlobalConfig } from
 import { hostLocalTimeZone, scheduleTimeZone } from './utils/timezone.js';
 import { buildDashboardUrls } from './core/dashboard-url.js';
 import { deleteWhiteboard, listWhiteboards, readWhiteboard, whiteboardEnabled } from './services/whiteboard-store.js';
-import { isLocalDevInstall, botmuxVersion, botmuxCliEntry } from './utils/install-info.js';
+import { isLocalDevInstall, botmuxVersionAt, botmuxCliEntry, botmuxInstallRoot } 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, npmGlobalUpdateCwd } from './core/maintenance.js';
+import { spawnDetachedRestart, globalInstallUpdateLockTarget, globalInstallUpdateCwd } from './core/maintenance.js';
+import { detectGlobalInstallManager, formatGlobalInstallCommand, resolveGlobalInstallPlan, tryResolveGlobalInstallPlan, UnsupportedGlobalInstallError, } from './utils/global-install.js';
 import { writeRestartIntent } from './services/restart-intent-store.js';
 import { withFileLock } from './utils/file-lock.js';
 import { spawn } from 'node:child_process';
@@ -63,6 +64,7 @@ import { startPlatformTunnelClient } from './platform/tunnel-client.js';
 import { applyPlatformTeamSync, getPlatformTeamSyncRev, listPlatformTeams } from './services/platform-team-store.js';
 import { getBotUnionId } from './services/bot-union-ids-store.js';
 import { cleanupIdleSessions, parseIdleCleanupHours } from './dashboard/session-cleanup.js';
+import { aggregateRoleBatch, parseRoleBatchTargets } from './dashboard/roles-batch.js';
 import { automateOpenPlatformSetup } from './setup/open-platform-automation.js';
 import { VC_MEETING_FEATURE_SCOPES, VC_MEETING_REALTIME_VOICE_SCOPES } from './setup/verify-permissions.js';
 import { checkLarkCliVersion, MIN_LARK_CLI_VERSION_FOR_VC_BOT } from './vc-agent/polling-source.js';
@@ -200,9 +202,9 @@ function spawnStartBotLive(appId) {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 env: process.env,
                 // Run from HOME, not the dashboard's cwd (pm2 `cwd: PKG_ROOT`): a global
-                // npm update replaces that dir, so a still-running dashboard would spawn
-                // start-bot in a deleted directory (uv_cwd/ENOENT). See npmGlobalUpdateCwd.
-                cwd: npmGlobalUpdateCwd(),
+                // package update replaces that dir, so a still-running dashboard would spawn
+                // start-bot in a deleted directory (uv_cwd/ENOENT). See globalInstallUpdateCwd.
+                cwd: globalInstallUpdateCwd(),
             });
             const timer = setTimeout(() => {
                 try {
@@ -612,6 +614,7 @@ function resolveDashboardSettings() {
         repoPickerMode: global.repoPickerMode ?? 'all',
         maintenance: global.maintenance ?? {},
         localDevInstall: isLocalDevInstall(),
+        autoUpdateSupported: lastSuccessfulUpdatePlan !== undefined || tryResolveGlobalInstallPlan() !== null,
         whiteboard: { enabled: global.whiteboard?.enabled === true },
         remoteAccess: global.remoteAccess === true,
         scheduleTimeZone: global.scheduleTimeZone ?? null,
@@ -691,6 +694,10 @@ async function readJsonBody(req) {
  *  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;
+// The dashboard process survives while pnpm swaps its versioned realpath. Keep
+// the successful plan (including its stable package root) so follow-up status,
+// update, and restart requests do not reuse the removed old runtime realpath.
+let lastSuccessfulUpdatePlan;
 // 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
@@ -717,19 +724,19 @@ async function cachedChangelog(current, now = Date.now()) {
     return value;
 }
 /**
- * Run `npm install -g botmux@latest` for the manual-update flow WITHOUT blocking
+ * Run the ownership-aware npm/pnpm update 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() {
+function runGlobalInstallLatest(plan) {
     return new Promise((resolve, reject) => {
-        const child = spawn('npm', ['install', '-g', 'botmux@latest'], {
-            cwd: npmGlobalUpdateCwd(),
+        const child = spawn(plan.command, plan.args, {
+            cwd: globalInstallUpdateCwd(),
             env: process.env,
             stdio: ['ignore', 'pipe', 'pipe'],
-            shell: process.platform === 'win32', // resolve npm.cmd on Windows
+            shell: process.platform === 'win32', // resolve npm.cmd / pnpm.cmd
         });
         let tail = '';
         const capture = (d) => { tail = (tail + d.toString()).slice(-2000); };
@@ -737,7 +744,7 @@ function runNpmInstallLatest() {
         child.stderr?.on('data', capture);
         const timer = setTimeout(() => {
             child.kill('SIGKILL');
-            reject(new Error('npm install timed out after 180s'));
+            reject(new Error(`${plan.manager} install timed out after 180s`));
         }, 180_000);
         child.on('error', (e) => { clearTimeout(timer); reject(e); });
         child.on('exit', (code) => {
@@ -745,7 +752,7 @@ function runNpmInstallLatest() {
             if (code === 0)
                 resolve();
             else
-                reject(new Error(`npm exited ${code}: ${tail.trim().slice(-500)}`));
+                reject(new Error(`${plan.manager} exited ${code}: ${tail.trim().slice(-500)}`));
         });
     });
 }
@@ -830,6 +837,8 @@ resourceMonitor.start();
 // Path to the bundled frontend (sibling of dist/dashboard.js)
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const WEB_DIR = join(__dirname, 'dashboard-web');
+const DEV_RELOAD_MARKER = join(WEB_DIR, '.botmux-dashboard-dev');
+const DEV_RELOAD_VERSION = join(WEB_DIR, '.botmux-dashboard-reload');
 const MIME = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript',
@@ -862,6 +871,36 @@ function serveFileAbs(res, fp) {
     createReadStream(fp).pipe(res);
     return true;
 }
+function dashboardDevReloadEnabled() {
+    return process.env.BOTMUX_DASHBOARD_DEV_RELOAD === '1' || existsSync(DEV_RELOAD_MARKER);
+}
+function dashboardDevReloadVersion() {
+    try {
+        const st = statSync(DEV_RELOAD_VERSION);
+        if (!st.isFile())
+            return null;
+        return `${st.size}:${Math.floor(st.mtimeMs)}`;
+    }
+    catch {
+        return null;
+    }
+}
+function devReloadSnippet() {
+    return `
+<script type="module">
+(() => {
+  if (!('__BOTMUX_DASHBOARD_DEV_RELOAD__' in window)) {
+    Object.defineProperty(window, '__BOTMUX_DASHBOARD_DEV_RELOAD__', { value: true });
+    const source = new EventSource('/__dev/reload');
+    source.addEventListener('reload', () => location.reload());
+  }
+})();
+</script>`;
+}
+function injectDevReload(html) {
+    const snippet = devReloadSnippet();
+    return html.includes('</body>') ? html.replace('</body>', `${snippet}\n</body>`) : `${html}\n${snippet}`;
+}
 function serveStatic(req, res, pathname) {
     const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
     const fp = resolve(WEB_DIR, rel);
@@ -879,18 +918,28 @@ function serveStatic(req, res, pathname) {
         // and can be cached immutably once the current app.js points at them.
         const immutableChunk = relToRoot.startsWith('chunks/') || relToRoot.startsWith('chunks\\');
         const etag = `W/"${st.size.toString(16)}-${Math.floor(st.mtimeMs).toString(16)}"`;
+        const devIndex = relToRoot === 'index.html' && dashboardDevReloadEnabled();
         const headers = {
             'content-type': MIME[extname(fp)] ?? 'application/octet-stream',
-            'cache-control': immutableChunk ? 'public, max-age=31536000, immutable' : 'no-cache',
+            'cache-control': devIndex ? 'no-store' : immutableChunk ? 'public, max-age=31536000, immutable' : 'no-cache',
             etag,
         };
-        if (req.headers['if-none-match'] === etag) {
+        if (!devIndex && req.headers['if-none-match'] === etag) {
             res.writeHead(304, headers);
             res.end();
             return true;
         }
         res.writeHead(200, headers);
-        res.end(readFileSync(fp));
+        if (req.method === 'HEAD') {
+            res.end();
+            return true;
+        }
+        if (devIndex) {
+            res.end(injectDevReload(readFileSync(fp, 'utf8')));
+        }
+        else {
+            res.end(readFileSync(fp));
+        }
         return true;
     }
     catch {
@@ -1473,9 +1522,34 @@ const server = createServer(async (req, res) => {
             res.end();
             return;
         }
-        // ─── Static frontend (index.html + /assets/* + /game/*) ────────────────
-        if (req.method === 'GET' &&
-            (url.pathname === '/' || url.pathname.startsWith('/assets/') || url.pathname.startsWith('/game/'))) {
+        if (req.method === 'GET' && url.pathname === '/__dev/reload') {
+            if (!dashboardDevReloadEnabled())
+                return jsonRes(res, 404, { error: 'dev_reload_disabled' });
+            res.writeHead(200, {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-cache, no-transform',
+                connection: 'keep-alive',
+            });
+            let last = dashboardDevReloadVersion();
+            res.write(`event: ready\ndata: ${JSON.stringify({ version: last })}\n\n`);
+            const timer = setInterval(() => {
+                const next = dashboardDevReloadVersion();
+                if (!next || next === last)
+                    return;
+                last = next;
+                res.write(`event: reload\ndata: ${JSON.stringify({ version: next })}\n\n`);
+            }, 500);
+            req.on('close', () => clearInterval(timer));
+            return;
+        }
+        // ─── Static frontend (index.html + /assets/* + /game/* + root icons) ───
+        if ((req.method === 'GET' || req.method === 'HEAD') &&
+            (url.pathname === '/' ||
+                url.pathname === '/favicon.ico' ||
+                url.pathname === '/favicon.png' ||
+                url.pathname === '/apple-touch-icon.png' ||
+                url.pathname.startsWith('/assets/') ||
+                url.pathname.startsWith('/game/'))) {
             // HD2D runtime binaries (index.wasm / index.pck) are NOT shipped — they
             // are downloaded on demand into the cache dir and served from there.
             // Everything else under /game/ is the small shell shipped in dist.
@@ -1487,10 +1561,12 @@ const server = createServer(async (req, res) => {
                 res.end();
                 return;
             }
-            // Map /assets/foo.js → WEB_DIR/foo.js; /game/* is served as-is.
+            // Map /assets/foo.js → WEB_DIR/foo.js; /favicon.ico is an alias for the PNG favicon.
             const lookupPath = url.pathname.startsWith('/assets/')
                 ? '/' + url.pathname.slice(8)
-                : url.pathname;
+                : url.pathname === '/favicon.ico'
+                    ? '/favicon.png'
+                    : url.pathname;
             if (serveStatic(req, res, lookupPath))
                 return;
         }
@@ -1653,12 +1729,15 @@ const server = createServer(async (req, res) => {
             return jsonRes(res, 200, { ok: true, settings: result.settings });
         }
         // ─── Version & manual update ─────────────────────────────────────────────
-        // `npm install -g` and a host restart are privileged: none of these paths
+        // Global package updates 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();
+            const packageRoot = botmuxInstallRoot();
+            const installManager = detectGlobalInstallManager(packageRoot);
+            const installPlan = lastSuccessfulUpdatePlan ?? tryResolveGlobalInstallPlan(packageRoot);
             // 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
@@ -1669,6 +1748,9 @@ const server = createServer(async (req, res) => {
                 latest,
                 behind: !!latest && isNewerVersion(latest, current),
                 localDevInstall: isLocalDevInstall(),
+                updateSupported: installPlan !== null,
+                updateManager: installPlan?.manager ?? installManager,
+                updateCommand: installPlan ? formatGlobalInstallCommand(installPlan) : null,
                 node: checkNode(),
                 installs: detectBotmuxInstalls(),
             });
@@ -1689,35 +1771,56 @@ const server = createServer(async (req, res) => {
                 return jsonRes(res, 401, { ok: false, error: 'unauthorized' });
             if (isLocalDevInstall())
                 return jsonRes(res, 400, { ok: false, error: 'local_dev_no_update' });
+            let installPlan;
+            try {
+                installPlan = lastSuccessfulUpdatePlan ?? resolveGlobalInstallPlan();
+            }
+            catch (error) {
+                if (error instanceof UnsupportedGlobalInstallError) {
+                    return jsonRes(res, 400, {
+                        ok: false,
+                        error: 'unsupported_install_method',
+                        manager: error.manager,
+                    });
+                }
+                throw error;
+            }
             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();
+            const oldVersion = botmuxVersionAt(installPlan.activePackageRoot);
             // 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.
+            // auto-update (running in the bot-0 daemon) can't update the same global
+            // install concurrently. `acquired` distinguishes "lock held by
+            // maintenance" (409) from "the package manager 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 () => {
+                await withFileLock(globalInstallUpdateLockTarget(), async () => {
                     acquired = true;
-                    await runNpmInstallLatest();
+                    await runGlobalInstallLatest(installPlan);
                 }, { 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) });
+                return jsonRes(res, 500, { ok: false, error: 'install_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 });
+            const newVersion = botmuxVersionAt(installPlan.activePackageRoot);
+            lastSuccessfulUpdatePlan = installPlan;
+            return jsonRes(res, 200, {
+                ok: true,
+                oldVersion,
+                newVersion,
+                changed: newVersion !== oldVersion,
+                manager: installPlan.manager,
+            });
         }
         if (req.method === 'POST' && url.pathname === '/api/update/restart') {
             if (!authed)
@@ -1739,7 +1842,7 @@ const server = createServer(async (req, res) => {
                 }
                 catch { /* breadcrumb is best-effort */ }
             }
-            spawnDetachedRestart('dashboard');
+            spawnDetachedRestart('dashboard', lastSuccessfulUpdatePlan?.activePackageRoot);
             return jsonRes(res, 200, { ok: true });
         }
         if (req.method === 'GET' && url.pathname === '/api/skills') {
@@ -2193,9 +2296,24 @@ const server = createServer(async (req, res) => {
             });
         }
         // ─── Roles (proxy to daemon) ────────────────────────────────────────────
+        // POST   /api/roles/batch → collapse role reads to one request per daemon
         // GET    /api/roles/:larkAppId/:chatId → read role file
         // PUT    /api/roles/:larkAppId/:chatId → write role file
         // DELETE /api/roles/:larkAppId/:chatId → delete role file
+        if (req.method === 'POST' && url.pathname === '/api/roles/batch') {
+            let body;
+            try {
+                body = await readJsonBody(req);
+            }
+            catch {
+                return jsonRes(res, 400, { ok: false, error: 'bad_json' });
+            }
+            const parsed = parseRoleBatchTargets(body);
+            if (!parsed.ok)
+                return jsonRes(res, 400, { ok: false, error: parsed.error });
+            const result = await aggregateRoleBatch(parsed.targets, proxyToDaemon);
+            return jsonRes(res, 200, result);
+        }
         let mRole;
         if ((mRole = url.pathname.match(/^\/api\/roles\/([^/]+)\/([^/]+)$/))) {
             const larkAppId = decodeURIComponent(mRole[1]);