@0xmaxma/claude-gateway 2.0.4 → 2.0.6

package/dist/api/gateway-router.js

@@ -38,6 +38,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayRouter = void 0;
 exports.resolveBindHost = resolveBindHost;
+const memory_activity_1 = require("./memory-activity");
+const dashboard_range_1 = require("../ui/dashboard-range");
+const dashboard_reader_1 = require("../orchestration/dashboard-reader");
 const express_1 = __importDefault(require("express"));
 const http = __importStar(require("node:http"));
 const child_process_1 = require("child_process");
@@ -51,6 +54,7 @@ const pty_stream_registry_1 = require("../shell/pty-stream-registry");
 const control_channel_1 = require("../shell/control-channel");
 const factory_1 = require("../watch/factory");
 const web_ui_1 = require("../ui/web-ui");
+const token_report_1 = require("../ui/token-report");
 const knowledge_1 = require("../agent/knowledge");
 const logger_1 = require("../logger");
 const report_1 = require("../agent/dreaming/report");
@@ -228,6 +232,8 @@ class RateLimiter {
 }
 class GatewayRouter {
     constructor(agents, configs, schedulers, gatewayConfig, cronManager, configPath, appsRegistry, appInstaller, appRegistryClient) {
+        this.dashboardReader = new dashboard_reader_1.DashboardReader();
+        this.dashboardStreams = new Set();
         // ─── App proxy ──────────────────────────────────────────────────────────
         /** "appName:portName" → ProxyRoute */
         this.routeMap = new Map();
@@ -774,6 +780,19 @@ class GatewayRouter {
         this.app.get('/health', (_req, res) => {
             res.json({ status: 'ok' });
         });
+        // Public static typeface assets contain no gateway data.
+        this.app.get('/dashboard/fonts.css', (_req, res) => {
+            res.setHeader('Cache-Control', 'public, max-age=86400');
+            res.type('css').send([300, 400, 500, 600].map(weight => `@font-face{font-family:Poppins;font-style:normal;font-weight:${weight};font-display:swap;src:url(fonts/poppins-${weight}.woff2) format('woff2')}`).join('\n'));
+        });
+        this.app.get('/dashboard/fonts/:font', (req, res) => {
+            if (!/^poppins-(300|400|500|600)\.woff2$/.test(req.params.font)) {
+                res.sendStatus(404);
+                return;
+            }
+            res.setHeader('Cache-Control', 'public, max-age=86400');
+            res.sendFile(path.resolve(__dirname, '../../resource/dashboard', req.params.font));
+        });
         // Web dashboard. When API keys are configured, require a live dashboard
         // session cookie; otherwise serve the login page (API-key form). Keyless
         // installs have no credential to check, so the dashboard stays open there —
@@ -797,10 +816,123 @@ class GatewayRouter {
                 delete require.cache[webUiPath];
                 // eslint-disable-next-line @typescript-eslint/no-require-imports
                 const { generateDashboardHtml: fresh } = require('../ui/web-ui');
-                res.send(fresh());
+                res.send(fresh(this.gatewayConfig?.gateway?.timezone));
             }
             else {
-                res.send((0, web_ui_1.generateDashboardHtml)());
+                res.send((0, web_ui_1.generateDashboardHtml)(this.gatewayConfig?.gateway?.timezone));
+            }
+        });
+        // Reports expose cross-agent usage/tool inventories: the same admin gate as status.
+        for (const reportPath of ['/dashboard/token-report', '/token-report']) {
+            this.app.get(reportPath, async (req, res) => {
+                res.setHeader('Cache-Control', 'no-store');
+                // The HTML page requires an explicit dashboard login, just like /dashboard.
+                // Reverse proxies may inject an admin API key: that must not log a browser in.
+                // The JSON /token-report endpoint retains API-key access for API clients.
+                if (reportPath === '/dashboard/token-report' && this.apiKeys.length > 0 && !this.hasValidDashSession(req)) {
+                    // Relative redirect preserves deployment prefixes (e.g. /gateway) without
+                    // trusting forwarded headers. Also handle Express's optional trailing slash.
+                    const query = new URLSearchParams();
+                    for (const key of ['agentId', 'sessionId', 'scope', 'offset'])
+                        if (typeof req.query[key] === 'string')
+                            query.set(key, req.query[key]);
+                    res.redirect(303, (req.path.endsWith('/') ? '../' : './') + '?returnTo=' + encodeURIComponent('token-report?' + query.toString()));
+                    return;
+                }
+                if (!this.requireDashOrApiKey(req, res))
+                    return;
+                const { agentId, sessionId } = req.query;
+                const offset = Number(req.query.offset ?? 0);
+                if (!Number.isSafeInteger(offset) || offset < 0 || offset > 1000000) {
+                    res.status(400).json({ error: 'Invalid offset' });
+                    return;
+                }
+                if (typeof agentId !== 'string' || typeof sessionId !== 'string' || !sessionId || sessionId.length > 256) {
+                    res.status(400).json({ error: 'agentId and sessionId are required' });
+                    return;
+                }
+                const runner = this.agents.get(agentId);
+                if (!runner) {
+                    res.status(404).json({ error: 'Unknown agent' });
+                    return;
+                }
+                try {
+                    const source = runner.getDashboardSource?.();
+                    let report = source ? await this.dashboardReader.read('report', source.filename, { workspace: source.workspace, sessionId, offset, since: (0, dashboard_range_1.dashboardSince)(req.query.scope ?? (reportPath === '/token-report' ? 'all' : '24h'), Date.now(), this.gatewayConfig?.gateway?.timezone), historyFilename: source.historyFilename }) : await runner.getTokenReport(sessionId);
+                    if (!report) {
+                        res.status(404).json({ error: 'No recorded session token report' });
+                        return;
+                    }
+                    if (runner.isSessionCompacting?.(sessionId))
+                        report = { ...report, activityStatus: 'compacting' };
+                    if (report.contextWindow)
+                        report.contextWindow.total = report.contextWindow.model ? await runner.dashboardContextWindow?.(report.contextWindow.model) ?? null : null;
+                    if (reportPath === '/token-report')
+                        res.json(report);
+                    else
+                        res.type('html').send((0, token_report_1.generateTokenReportHtml)(agentId, { ...report, timezone: this.gatewayConfig?.gateway?.timezone, scope: (0, dashboard_range_1.dashboardRange)(req.query.scope), sessionStatus: runner.agentSessionLiveStatus?.(sessionId) ?? 'stopped' }));
+                }
+                catch {
+                    res.status(500).json({ error: 'Unable to load session token report' });
+                }
+            });
+        }
+        this.app.get('/dashboard/session', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            res.setHeader('Cache-Control', 'no-store');
+            const { agentId, sessionId } = req.query, offset = Number(req.query.offset ?? 0);
+            if ([agentId, sessionId].some(v => typeof v !== 'string' || !v || v.length > 256) || !Number.isSafeInteger(offset) || offset < 0 || offset > 1000000) {
+                res.status(400).json({ error: 'Invalid session query' });
+                return;
+            }
+            const detailRunner = this.agents.get(String(agentId));
+            const source = detailRunner?.getDashboardSource?.();
+            if (!source) {
+                res.status(404).json({ error: 'Unknown agent' });
+                return;
+            }
+            try {
+                const detail = await this.dashboardReader.read('session', source.filename, { sessionId, offset, since: (0, dashboard_range_1.dashboardSince)(req.query.scope, Date.now(), this.gatewayConfig?.gateway?.timezone), historyFilename: source.historyFilename });
+                if (!detail) {
+                    res.status(404).json({ error: 'Session not found' });
+                    return;
+                }
+                if (detailRunner?.isSessionCompacting?.(String(sessionId)))
+                    detail.activityStatus = 'compacting';
+                if (detail.contextWindow)
+                    detail.contextWindow.total = detail.contextWindow.model ? await detailRunner?.dashboardContextWindow?.(detail.contextWindow.model) ?? null : null;
+                res.json({ ...detail, sessionStatus: detailRunner?.agentSessionLiveStatus?.(String(sessionId)) ?? 'stopped' });
+            }
+            catch {
+                res.status(503).json({ error: 'Dashboard data temporarily unavailable' });
+            }
+        });
+        this.app.get('/dashboard/task', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            res.setHeader('Cache-Control', 'no-store');
+            const { agentId, sessionId, taskId } = req.query;
+            const offset = Number(req.query.offset ?? 0);
+            if ([agentId, sessionId, taskId].some(v => typeof v !== 'string' || !v || v.length > 256) || !Number.isSafeInteger(offset) || offset < 0 || offset > 1000000) {
+                res.status(400).json({ error: 'Valid agentId, sessionId, taskId and offset are required' });
+                return;
+            }
+            const source = this.agents.get(String(agentId))?.getDashboardSource?.();
+            if (!source) {
+                res.status(404).json({ error: 'Unknown agent' });
+                return;
+            }
+            try {
+                const task = await this.dashboardReader.read('task', source.filename, { sessionId, taskId, offset, since: (0, dashboard_range_1.dashboardSince)(req.query.scope, Date.now(), this.gatewayConfig?.gateway?.timezone) });
+                if (!task) {
+                    res.status(404).json({ error: 'Task not found in this session' });
+                    return;
+                }
+                res.json(task);
+            }
+            catch {
+                res.status(503).json({ error: 'Dashboard data temporarily unavailable' });
             }
         });
         // Dashboard login — exchange a configured API key for an HttpOnly session
@@ -1030,6 +1162,66 @@ class GatewayRouter {
                 res.status(500).json({ error: 'Failed to list knowledge sources' });
             }
         });
+        let memorySnapshot;
+        let memorySnapshotUntil = 0;
+        this.app.get('/dashboard/memory-activity', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            res.setHeader('Cache-Control', 'no-store');
+            const { agentId, kind, status, id, scope, completedOnly } = req.query, page = Number(req.query.page ?? 0);
+            if (!Number.isSafeInteger(page) || page < 0 || page > 1000000 ||
+                [agentId, kind, status, id, scope].some(v => v !== undefined && (typeof v !== 'string' || v.length > 256)) ||
+                (completedOnly !== undefined && completedOnly !== 'true' && completedOnly !== 'false') ||
+                (kind !== undefined && !['all', 'memory_dream', 'session_compaction'].includes(String(kind))) ||
+                (status !== undefined && !String(status).split(',').every(s => ['all', 'none', 'pending', 'running', 'completed', 'failed', 'partial_failure', 'interrupted', 'skipped'].includes(s))) ||
+                (scope !== undefined && !['24h', '7d', '30d', '90d', 'all'].includes(String(scope)))) {
+                res.status(400).json({ error: 'Invalid activity filters' });
+                return;
+            }
+            if (agentId && !this.agents.has(String(agentId))) {
+                res.status(404).json({ error: 'Unknown agent' });
+                return;
+            }
+            try {
+                if (!memorySnapshot || Date.now() >= memorySnapshotUntil) {
+                    memorySnapshotUntil = Infinity;
+                    const snapshot = (0, memory_activity_1.readMemoryActivity)(this.agents, this.agentsRoot(), (filename, agentId) => this.dashboardReader.read('compaction', filename, { agentId })).then(data => { if (memorySnapshot === snapshot)
+                        memorySnapshotUntil = Date.now() + 5000; return data; }, error => { if (memorySnapshot === snapshot)
+                        memorySnapshot = undefined; throw error; });
+                    memorySnapshot = snapshot;
+                }
+                const data = await memorySnapshot;
+                if (id) {
+                    let run = data.runs.find(r => r.id === id && r.agent === agentId);
+                    if (!run) {
+                        res.status(404).json({ error: 'Activity not found' });
+                        return;
+                    }
+                    const source = this.agents.get(String(agentId))?.getDashboardSource?.();
+                    if (run.kind === 'session_compaction' && source)
+                        run = await this.dashboardReader.read('compaction', source.filename, { agentId, runId: id });
+                    if (!run) {
+                        res.status(404).json({ error: 'Activity not found' });
+                        return;
+                    }
+                    if (completedOnly === 'true' && run.kind === 'session_compaction') {
+                        run = { ...run, items: (run.items ?? []).filter((item) => item.status === 'completed'), itemCount: run.completedSessions };
+                    }
+                    res.json({ run });
+                    return;
+                }
+                const timezone = this.gatewayConfig?.gateway?.timezone || 'UTC';
+                const since = (0, dashboard_range_1.dashboardSince)(scope, Date.now(), timezone);
+                const runs = data.runs.filter(r => (completedOnly !== 'true' || r.kind !== 'session_compaction' || r.completedSessions > 0 || (r.items ?? []).some((i) => i.status === 'completed')) && (!agentId || r.agent === agentId) && (!kind || kind === 'all' || r.kind === kind) && (!status || status === 'all' || String(status).split(',').includes(r.status)) && r.startedAt >= since);
+                res.json({ timezone, since, runs: runs.slice(page * 25, page * 25 + 25).map(memory_activity_1.activitySummary), total: runs.length, page, pageSize: 25,
+                    agents: data.agents, schedules: data.schedules.filter(s => !agentId || s.agent === agentId), unavailable: data.unavailable,
+                    counts: { compactedSessions: runs.reduce((n, r) => n + (r.completedSessions ?? r.items?.filter((i) => i.status === 'completed').length ?? 0), 0), measuredReduction: runs.reduce((n, r) => n + ((0, memory_activity_1.activitySummary)(r).measuredReduction ?? 0), 0), measuredSessions: runs.reduce((n, r) => n + ((0, memory_activity_1.activitySummary)(r).measuredSessions ?? 0), 0), runs: runs.length, pendingProposals: runs.reduce((n, r) => n + (r.pendingProposals ?? 0), 0), failed: runs.filter(r => ['failed', 'partial_failure', 'interrupted'].includes(r.status)).length },
+                    historyLimit: 100 });
+            }
+            catch {
+                res.status(503).json({ error: 'Memory activity temporarily unavailable' });
+            }
+        });
         // Nightly dreaming report — parses every agent's `.dreaming/` audit trail
         // (DREAMS.md + promotions.jsonl) into newest-first runs for the dashboard's
         // "Nightly dreaming" tab. Auth: dashboard session cookie OR API key. Payload is
@@ -1044,7 +1236,7 @@ class GatewayRouter {
                 const runs = [];
                 const agents = [];
                 for (const id of this.agents.keys()) {
-                    const dir = path.join(root, id, 'workspace', audit_1.DREAMING_DIR);
+                    const dir = path.join(this.agents.get(id)?.workspacePath ?? path.join(root, id, 'workspace'), audit_1.DREAMING_DIR);
                     let dreams;
                     try {
                         dreams = fs.readFileSync(path.join(dir, 'DREAMS.md'), 'utf8');
@@ -1100,6 +1292,7 @@ class GatewayRouter {
         this.app.post('/knowledge/dreams/apply', (req, res) => {
             if (!this.requireDashOrApiKey(req, res))
                 return;
+            memorySnapshot = undefined;
             try {
                 const body = (req.body ?? {});
                 const agentId = typeof body.agentId === 'string' ? body.agentId : '';
@@ -1123,7 +1316,7 @@ class GatewayRouter {
                     }
                     indexes = body.indexes;
                 }
-                const workspaceDir = path.join(this.agentsRoot(), agentId, 'workspace');
+                const workspaceDir = this.agents.get(agentId)?.workspacePath ?? path.join(this.agentsRoot(), agentId, 'workspace');
                 const budget = (0, workspace_loader_1.resolveMemoryBudget)({
                     ...this.gatewayConfig?.gateway?.memory,
                     ...this.configs.get(agentId)?.memory,
@@ -1177,12 +1370,9 @@ class GatewayRouter {
                 res.status(500).json({ error: 'Failed to read screen state' });
             });
         });
-        // Status endpoint — per-agent stats + heartbeat history
-        this.app.get('/status', (req, res) => {
-            if (!this.requireDashOrApiKey(req, res))
-                return;
+        const dashboardSnapshot = async (offset, scope = 'all') => {
             const uptimeMs = Date.now() - this.startedAt.getTime();
-            const agentsStatus = [...this.agents.entries()].map(([id, runner]) => {
+            const agentsStatus = await Promise.all([...this.agents.entries()].map(async ([id, runner]) => {
                 const scheduler = this.schedulers.get(id);
                 const history = scheduler?.getHistory();
                 const agentConfig = this.configs.get(id);
@@ -1206,10 +1396,20 @@ class GatewayRouter {
                 }).filter(Boolean);
                 const lastActivity = this.lastActivityAt.get(id);
                 // PTY streams are keyed per session, so liveness is per session too.
-                const orchestration = runner.getOrchestrationSummary?.();
-                const managedSessions = orchestration?.sessions ?? [];
-                const managedIds = new Set(managedSessions.map(s => s.sessionId));
-                const sessions = [...runner.getSessionsSummary().filter(s => !managedIds.has(s.sessionId)), ...managedSessions].map((s) => ({
+                const source = runner.getDashboardSource?.();
+                const legacySessions = runner.getSessionsSummary();
+                const liveSessionIds = new Set(runner.liveSessionIds?.() ?? []);
+                const orchestration = source ? (source.enabled ? await this.dashboardReader.read('summary', source.filename, { ...source, timezone: this.gatewayConfig?.gateway?.timezone, offset, since: (0, dashboard_range_1.dashboardSince)(scope, Date.now(), this.gatewayConfig?.gateway?.timezone), legacyIds: legacySessions.map(s => s.sessionId) }) : undefined) : runner.getOrchestrationSummary?.();
+                const managedSessions = (orchestration?.sessions ?? []).map((s) => ({
+                    ...s,
+                    // Live liveness from the runner's in-memory map: the DB-derived status
+                    // reports 'idle' for both a kept-alive session and one already killed by
+                    // the idle cleaner; sessionAlive disambiguates them for the dashboard.
+                    sessionAlive: liveSessionIds.has(s.sessionId),
+                    ...(runner.isSessionCompacting?.(s.sessionId) ? { status: 'compacting', isRunning: true } : {}),
+                }));
+                const managedIds = new Set([...managedSessions.map((s) => s.sessionId), ...(orchestration?.managedLegacyIds ?? [])]);
+                const sessions = [...legacySessions.filter(s => !managedIds.has(s.sessionId) && (!(0, dashboard_range_1.dashboardSince)(scope, Date.now(), this.gatewayConfig?.gateway?.timezone) || Number(s.updatedAt || s.spawnedAt || 0) >= (0, dashboard_range_1.dashboardSince)(scope, Date.now(), this.gatewayConfig?.gateway?.timezone))), ...managedSessions].map((s) => ({
                     ...s,
                     hasPtyStream: pty_stream_registry_1.ptyStreamRegistry.hasSockets(s.sessionId),
                 }));
@@ -1235,15 +1435,118 @@ class GatewayRouter {
                     },
                     sessions,
                 };
-            });
-            res.json({
+            }));
+            return {
                 agents: agentsStatus,
                 uptime: Math.floor(uptimeMs / 1000),
                 startedAt: this.startedAt.toISOString(),
                 version: GATEWAY_VERSION,
                 // Degraded file watchers (e.g. inotify ENOSPC). Empty array when healthy.
                 watchers: (0, factory_1.getWatcherHealth)(),
-            });
+            };
+        };
+        this.app.get('/dashboard/charts', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            res.setHeader('Cache-Control', 'no-store');
+            const scope = req.query.scope ?? '24h';
+            if (typeof scope !== 'string' || !['24h', '7d', '30d', '90d'].includes(scope)) {
+                res.status(400).json({ error: 'Invalid chart range' });
+                return;
+            }
+            const timezone = this.gatewayConfig?.gateway?.timezone || 'UTC';
+            // Stable snapshot timestamp coalesces all four cards and concurrent browsers.
+            const now = Math.floor(Date.now() / 10000) * 10000;
+            try {
+                const agents = [];
+                for (const [id, runner] of this.agents) {
+                    const source = runner.getDashboardSource?.();
+                    if (!source?.enabled)
+                        continue;
+                    const usage = await this.dashboardReader.read('charts', source.filename, { scope, timezone, now });
+                    if (usage)
+                        agents.push({ id, ...usage });
+                }
+                res.json({ scope, timezone, asOf: now, since: (0, dashboard_range_1.dashboardSince)(scope, now, timezone), agents });
+            }
+            catch {
+                res.status(503).json({ error: 'Chart data temporarily unavailable' });
+            }
+        });
+        this.app.get('/status', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            res.setHeader('Cache-Control', 'no-store');
+            const offset = Number(req.query.offset ?? 0);
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset > 1000000) {
+                res.status(400).json({ error: 'Invalid offset' });
+                return;
+            }
+            try {
+                res.json(await dashboardSnapshot(offset, req.query.scope ?? 'all'));
+            }
+            catch {
+                res.status(503).json({ error: 'Dashboard data temporarily unavailable' });
+            }
+        });
+        this.app.get('/dashboard/events', async (req, res) => {
+            if (!this.requireDashOrApiKey(req, res))
+                return;
+            const offset = Number(req.query.offset ?? 0);
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset > 1000000) {
+                res.status(400).json({ error: 'Invalid offset' });
+                return;
+            }
+            if (this.dashboardStreams.size >= 32) {
+                res.status(503).json({ error: 'Too many dashboard streams' });
+                return;
+            }
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-store');
+            res.setHeader('X-Accel-Buffering', 'no');
+            res.flushHeaders();
+            this.dashboardStreams.add(res);
+            let closed = false, busy = false, last = String(req.headers['last-event-id'] ?? '');
+            const stop = () => { closed = true; clearInterval(timer); this.dashboardStreams.delete(res); res.end(); };
+            const tick = async () => {
+                if (closed || busy)
+                    return;
+                // Recheck cookie expiration/revocation without writing HTTP errors into SSE.
+                if (this.apiKeys.length && !this.hasValidDashSession(req) && !timingSafeAdminKeyMatch(this.apiKeys, this.extractApiToken(req))) {
+                    res.write('event: unauthorized\ndata: {}\n\n');
+                    stop();
+                    return;
+                }
+                // Never queue snapshots behind a slow browser.
+                if (res.writableLength > 256 * 1024) {
+                    stop();
+                    return;
+                }
+                busy = true;
+                try {
+                    const data = await dashboardSnapshot(offset, req.query.scope ?? 'all');
+                    if (closed)
+                        return;
+                    const payload = JSON.stringify(data), id = crypto.createHash('sha256').update(JSON.stringify({ agents: data.agents, watchers: data.watchers, version: data.version })).digest('hex').slice(0, 24);
+                    if (id !== last) {
+                        res.write('id: ' + id + '\nevent: snapshot\ndata: ' + payload + '\n\n');
+                        last = id;
+                    }
+                    else
+                        res.write(': heartbeat\n\n');
+                }
+                catch {
+                    if (!closed)
+                        res.write('event: unavailable\ndata: {}\n\n');
+                }
+                finally {
+                    busy = false;
+                }
+            };
+            const timer = setInterval(() => void tick(), 5000);
+            timer.unref();
+            req.on('close', stop);
+            void tick();
         });
     }
     /** The port the HTTP server is actually listening on, or null when it is not
@@ -1435,6 +1738,10 @@ class GatewayRouter {
         }
     }
     async stop() {
+        for (const response of this.dashboardStreams)
+            response.end();
+        this.dashboardStreams.clear();
+        await this.dashboardReader.close();
         await this.voiceApi?.close();
         if (this.ticketPruner)
             clearInterval(this.ticketPruner);