@inspectr/mcplab 1.16.0 → 1.18.0

package/dist/app-server/runs-routes.js

@@ -32,6 +32,53 @@ export function mergeLibraryAgentsIntoConfig(config, libraryAgents) {
 export function applyLibraryAgents(loaded, libraryAgents) {
     applyLibraryEntries(loaded, libraryAgents, {});
 }
+function toQueueEntry(job) {
+    return {
+        jobId: job.id,
+        status: job.status,
+        blockedReason: job.status === 'blocked_auth' ? 'oauth_required' : undefined,
+        requiredServers: job.status === 'blocked_auth' ? job.blockedAuthServers ?? [] : undefined,
+        runParams: {
+            configPath: job.runParams.configPath,
+            runsPerScenario: job.runParams.runsPerScenario,
+            scenarioIds: job.runParams.scenarioIds ?? null,
+            agents: job.runParams.requestedAgents ?? null,
+            runNote: job.runParams.runNote ?? null,
+            serverOverrideAll: job.runParams.serverOverrideAll ?? null,
+            scenarioServerOverrides: job.runParams.scenarioServerOverrides ?? null
+        }
+    };
+}
+function buildQueueState(jobs, runQueueState) {
+    const activeJob = runQueueState.activeJobId ? jobs.get(runQueueState.activeJobId) : null;
+    const queuedEntries = runQueueState.queue
+        .map((id) => jobs.get(id))
+        .filter((j) => !!j && (j.status === 'queued' || j.status === 'blocked_auth'))
+        .map((job) => toQueueEntry(job));
+    return {
+        active: activeJob ? toQueueEntry(activeJob) : null,
+        queued: queuedEntries
+    };
+}
+function emitQueueEvent(jobs, runQueueState, deps) {
+    const event = {
+        type: 'queue_event',
+        ts: new Date().toISOString(),
+        payload: { event: buildQueueState(jobs, runQueueState) }
+    };
+    for (const client of Array.from(runQueueState.clients)) {
+        if (client.destroyed || client.writableEnded) {
+            runQueueState.clients.delete(client);
+            continue;
+        }
+        try {
+            deps.sendSseEvent(client, event);
+        }
+        catch {
+            runQueueState.clients.delete(client);
+        }
+    }
+}
 export async function handleRunsRoutes(params) {
     const { req, res, pathname, method, settings, jobs, runQueueState, oauthSessionManager, deps } = params;
     const { parseBody, asJson, addJobEvent, sendSseEvent, ensureInsideRoot, listRuns, getRunResults, getScenarioRunTraceRecords, selectScenarioIds, expandConfigForAgents, resolveRunSelectedAgents, readLibraries, pickDefaultAssistantAgentName, pkgVersion } = deps;
@@ -39,16 +86,71 @@ export async function handleRunsRoutes(params) {
         const requestUrl = new URL(req.url ?? '/api/runs', 'http://localhost');
         const since = requestUrl.searchParams.get('since') ?? undefined;
         const until = requestUrl.searchParams.get('until') ?? undefined;
+        const scenario = requestUrl.searchParams.get('scenario') ?? undefined;
         const lastDaysRaw = requestUrl.searchParams.get('last_days');
         const lastDaysParsed = lastDaysRaw === null ? NaN : Number(lastDaysRaw);
         const lastDays = Number.isFinite(lastDaysParsed) && lastDaysParsed > 0
             ? Math.floor(lastDaysParsed)
             : undefined;
-        asJson(res, 200, listRuns(settings.runsDir, {
+        const limitRaw = Number(requestUrl.searchParams.get('limit'));
+        const offsetRaw = Number(requestUrl.searchParams.get('offset'));
+        const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(100, Math.floor(limitRaw))) : 25;
+        const offset = Number.isFinite(offsetRaw) ? Math.max(0, Math.floor(offsetRaw)) : 0;
+        const all = listRuns(settings.runsDir, {
             since,
             until,
-            lastDays
-        }));
+            lastDays,
+            scenario
+        });
+        const data = all.slice(offset, offset + limit);
+        const totalCount = all.length;
+        const hasMore = offset + data.length < totalCount;
+        const nextOffset = hasMore ? offset + data.length : null;
+        const prevOffset = offset > 0 ? Math.max(0, offset - limit) : null;
+        asJson(res, 200, {
+            object: 'list',
+            url: `${pathname}${requestUrl.search}`,
+            data,
+            has_more: hasMore,
+            total_count: totalCount,
+            next_offset: nextOffset,
+            prev_offset: prevOffset
+        });
+        return true;
+    }
+    if (pathname === '/api/runs/latest-pass-rates' && method === 'POST') {
+        const body = (await parseBody(req));
+        const requestedConfigs = Array.isArray(body.configs) ? body.configs : [];
+        const normalizedConfigs = requestedConfigs
+            .map((entry) => ({
+            id: String(entry?.id ?? '').trim(),
+            sourcePath: String(entry?.sourcePath ?? '').trim(),
+            relativePath: String(entry?.relativePath ?? '').trim(),
+            configHash: String(entry?.configHash ?? '').trim()
+        }))
+            .filter((entry) => entry.id);
+        const lastDaysRaw = Number(body.lastDays);
+        const lastDays = Number.isFinite(lastDaysRaw) && lastDaysRaw > 0 ? Math.floor(lastDaysRaw) : undefined;
+        const summaries = listRuns(settings.runsDir, { lastDays });
+        const pending = new Set(normalizedConfigs.map((entry) => entry.id));
+        const byConfigId = {};
+        for (const summary of summaries) {
+            if (pending.size === 0)
+                break;
+            const summaryPath = String(summary.configPath ?? '').trim();
+            const summaryHash = String(summary.configHash ?? '').trim();
+            for (const cfg of normalizedConfigs) {
+                if (!pending.has(cfg.id))
+                    continue;
+                if ((cfg.sourcePath && cfg.sourcePath === summaryPath) ||
+                    (cfg.relativePath && cfg.relativePath === summaryPath) ||
+                    (cfg.configHash && cfg.configHash === summaryHash)) {
+                    byConfigId[cfg.id] = summary.passRate;
+                    pending.delete(cfg.id);
+                }
+            }
+        }
+        asJson(res, 200, { byConfigId });
         return true;
     }
     if (pathname.startsWith('/api/runs/') && pathname.endsWith('/trace') && method === 'GET') {
@@ -102,6 +204,10 @@ export async function handleRunsRoutes(params) {
             for (const client of job.clients)
                 client.end();
             job.clients.clear();
+            void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, {
+                emitWhenIdle: true,
+                hostHeader: req.headers.host
+            });
             asJson(res, 200, { ok: true, status: 'stopped' });
             return true;
         }
@@ -115,42 +221,25 @@ export async function handleRunsRoutes(params) {
         return true;
     }
     if (pathname === '/api/runs/queue' && method === 'GET') {
-        const activeJob = runQueueState.activeJobId ? jobs.get(runQueueState.activeJobId) : null;
-        const queuedEntries = runQueueState.queue
-            .map((id) => jobs.get(id))
-            .filter((j) => !!j && (j.status === 'queued' || j.status === 'blocked_auth'))
-            .map((j) => ({
-            jobId: j.id,
-            status: j.status,
-            blockedReason: j.status === 'blocked_auth' ? 'oauth_required' : undefined,
-            requiredServers: j.status === 'blocked_auth' ? j.blockedAuthServers ?? [] : undefined,
-            runParams: {
-                configPath: j.runParams.configPath,
-                runsPerScenario: j.runParams.runsPerScenario,
-                scenarioIds: j.runParams.scenarioIds ?? null,
-                agents: j.runParams.requestedAgents ?? null,
-                runNote: j.runParams.runNote ?? null,
-                serverOverrideAll: j.runParams.serverOverrideAll ?? null,
-                scenarioServerOverrides: j.runParams.scenarioServerOverrides ?? null
-            }
-        }));
-        asJson(res, 200, {
-            active: activeJob
-                ? {
-                    jobId: activeJob.id,
-                    status: activeJob.status,
-                    runParams: {
-                        configPath: activeJob.runParams.configPath,
-                        runsPerScenario: activeJob.runParams.runsPerScenario,
-                        scenarioIds: activeJob.runParams.scenarioIds ?? null,
-                        agents: activeJob.runParams.requestedAgents ?? null,
-                        runNote: activeJob.runParams.runNote ?? null,
-                        serverOverrideAll: activeJob.runParams.serverOverrideAll ?? null,
-                        scenarioServerOverrides: activeJob.runParams.scenarioServerOverrides ?? null
-                    }
-                }
-                : null,
-            queued: queuedEntries
+        asJson(res, 200, buildQueueState(jobs, runQueueState));
+        return true;
+    }
+    if (pathname === '/api/runs/queue/events' && method === 'GET') {
+        res.statusCode = 200;
+        res.setHeader('content-type', 'text/event-stream');
+        res.setHeader('cache-control', 'no-cache');
+        res.setHeader('connection', 'keep-alive');
+        if ('flushHeaders' in res && typeof res.flushHeaders === 'function') {
+            res.flushHeaders();
+        }
+        sendSseEvent(res, {
+            type: 'queue_event',
+            ts: new Date().toISOString(),
+            payload: { event: buildQueueState(jobs, runQueueState) }
+        });
+        runQueueState.clients.add(res);
+        req.on('close', () => {
+            runQueueState.clients.delete(res);
         });
         return true;
     }
@@ -171,7 +260,6 @@ export async function handleRunsRoutes(params) {
             asJson(res, 404, { error: 'Job is not queued' });
             return true;
         }
-        const wasBlocked = job.status === 'blocked_auth';
         const idx = runQueueState.queue.indexOf(jobId);
         if (idx !== -1)
             runQueueState.queue.splice(idx, 1);
@@ -184,14 +272,18 @@ export async function handleRunsRoutes(params) {
         for (const client of job.clients)
             client.end();
         job.clients.clear();
-        if (wasBlocked) {
-            void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps);
-        }
+        void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, {
+            emitWhenIdle: true,
+            hostHeader: req.headers.host
+        });
         asJson(res, 200, { ok: true, jobId, status: 'stopped' });
         return true;
     }
     if (pathname === '/api/runs/queue/resume' && method === 'POST') {
-        void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps);
+        void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, {
+            emitWhenIdle: true,
+            hostHeader: req.headers.host
+        });
         asJson(res, 200, { ok: true });
         return true;
     }
@@ -320,13 +412,16 @@ export async function handleRunsRoutes(params) {
                     position: runQueueState.queue.length
                 }
             });
+            emitQueueEvent(jobs, runQueueState, deps);
             asJson(res, 202, { jobId, queued: true, position: runQueueState.queue.length });
         }
         else {
             // No active job — add to queue and let advanceQueue handle start (with OAuth pre-check)
             runQueueState.queue.push(jobId);
             asJson(res, 202, { jobId });
-            void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps);
+            void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, {
+                hostHeader: req.headers.host
+            });
         }
         return true;
     }
@@ -677,18 +772,26 @@ function resolveOAuthServersForJob(job, librariesDir) {
         return [];
     }
 }
-async function advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps) {
-    if (runQueueState.activeJobId)
+async function advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, options) {
+    if (runQueueState.activeJobId) {
+        if (options?.emitWhenIdle)
+            emitQueueEvent(jobs, runQueueState, deps);
         return;
-    if (runQueueState.isAdvancingQueue)
+    }
+    if (runQueueState.isAdvancingQueue) {
+        if (options?.emitWhenIdle)
+            emitQueueEvent(jobs, runQueueState, deps);
         return;
+    }
     runQueueState.isAdvancingQueue = true;
+    let queueMutated = false;
     try {
         while (runQueueState.queue.length > 0) {
             const nextId = runQueueState.queue[0]; // peek — do not shift yet
             const nextJob = jobs.get(nextId);
             if (!nextJob || (nextJob.status !== 'queued' && nextJob.status !== 'blocked_auth')) {
                 runQueueState.queue.shift();
+                queueMutated = true;
                 continue;
             }
             // Pre-check OAuth before starting
@@ -709,27 +812,52 @@ async function advanceQueue(jobs, runQueueState, settings, oauthSessionManager,
                 for (const client of nextJob.clients)
                     client.end();
                 nextJob.clients.clear();
+                queueMutated = true;
                 continue;
             }
             if (oauthServers.length > 0) {
-                const authStatus = oauthSessionManager.checkServersAuthStatus(oauthServers);
-                const needsAuth = authStatus.filter((s) => s.status === 'auth_required');
+                const ensureResult = await oauthSessionManager.ensureServersAuthorized(oauthServers, options?.hostHeader);
+                const needsAuth = ensureResult.servers.filter((s) => s.status === 'auth_required');
                 if (needsAuth.length > 0) {
-                    const needsAuthNames = needsAuth.map((s) => s.name);
+                    const needsAuthNames = needsAuth.map((s) => s.serverName);
+                    const wasBlocked = nextJob.status === 'blocked_auth';
+                    const prevBlockedServers = nextJob.blockedAuthServers ?? [];
+                    const prevKey = [...prevBlockedServers].sort().join('|');
+                    const nextKey = [...needsAuthNames].sort().join('|');
+                    const blockedSetChanged = prevKey !== nextKey;
                     nextJob.blockedAuthServers = needsAuthNames; // always refresh to current missing subset
-                    if (nextJob.status !== 'blocked_auth') {
+                    if (!wasBlocked) {
                         nextJob.status = 'blocked_auth';
                     }
+                    if (!wasBlocked || blockedSetChanged) {
+                        deps.addJobEvent(nextJob, {
+                            type: 'oauth_required',
+                            ts: new Date().toISOString(),
+                            payload: {
+                                jobId: nextJob.id,
+                                servers: needsAuthNames,
+                                message: `OAuth login required for server(s): ${needsAuthNames.join(', ')}.`
+                            }
+                        });
+                    }
+                    queueMutated = true;
+                    emitQueueEvent(jobs, runQueueState, deps);
+                    return; // pause — frontend must call /api/runs/queue/resume after auth
+                }
+                const readyServers = ensureResult.servers
+                    .filter((s) => s.status === 'ready')
+                    .map((s) => {
+                    const mode = s.debugState ?? 'unknown';
+                    return `${s.serverName} (${mode})`;
+                });
+                if (readyServers.length > 0) {
                     deps.addJobEvent(nextJob, {
-                        type: 'oauth_required',
+                        type: 'log',
                         ts: new Date().toISOString(),
                         payload: {
-                            jobId: nextJob.id,
-                            servers: needsAuthNames,
-                            message: `OAuth login required for server(s): ${needsAuthNames.join(', ')}.`
+                            message: `OAuth credentials ready for queued run: ${readyServers.join(', ')}`
                         }
                     });
-                    return; // pause — frontend must call /api/runs/queue/resume after auth
                 }
             }
             // OAuth ready (or not required) — start the job
@@ -750,16 +878,21 @@ async function advanceQueue(jobs, runQueueState, settings, oauthSessionManager,
                     scenarioServerOverrides: nextJob.runParams.scenarioServerOverrides ?? null
                 }
             });
+            queueMutated = true;
+            emitQueueEvent(jobs, runQueueState, deps);
             void executeRunJob(nextJob, settings, jobs, runQueueState, oauthSessionManager, deps);
             return;
         }
+        if (queueMutated || options?.emitWhenIdle) {
+            emitQueueEvent(jobs, runQueueState, deps);
+        }
     }
     finally {
         runQueueState.isAdvancingQueue = false;
     }
 }
 async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionManager, deps) {
-    const { addJobEvent, selectScenarioIds, expandConfigForAgents, resolveRunSelectedAgents, readLibraries, pkgVersion } = deps;
+    const { addJobEvent, getScenarioRunTraceRecords, selectScenarioIds, expandConfigForAgents, resolveRunSelectedAgents, readLibraries, pkgVersion } = deps;
     const { configPath, runsPerScenario, scenarioId, scenarioIds, requestedAgents, runNote, serverOverrideAll, scenarioServerOverrides } = job.runParams;
     try {
         addJobEvent(job, {
@@ -847,8 +980,9 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
         });
         const usedServerNames = new Set(expandedConfig.scenarios.flatMap((scenario) => scenario.servers));
         const oauthServers = Array.from(usedServerNames).filter((serverName) => expandedConfig.servers[serverName]?.auth?.type === 'oauth_authorization_code');
+        const oauthServerSet = new Set(oauthServers);
         const mcpServerAuthHeaders = oauthServers.length > 0
-            ? await oauthSessionManager.getAuthHeadersForServers(oauthServers)
+            ? await oauthSessionManager.getAuthHeadersForServers(oauthServers, undefined)
             : undefined;
         if (oauthServers.length > 0) {
             addJobEvent(job, {
@@ -884,6 +1018,16 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
                 cliVersion: pkgVersion,
                 runsDir: settings.runsDir,
                 mcpServerAuthHeaders,
+                resolveMcpServerAuthHeaders: oauthServers.length > 0
+                    ? async (serverNames, options) => {
+                        if (options?.signal?.aborted)
+                            return {};
+                        const namesToRefresh = serverNames.filter((name) => oauthServerSet.has(name));
+                        if (namesToRefresh.length === 0)
+                            return {};
+                        return oauthSessionManager.getAuthHeadersForServers(namesToRefresh);
+                    }
+                    : undefined,
                 signal: job.abortController.signal,
                 onProgress: async (event) => {
                     const message = formatRunProgressMessage(event);
@@ -902,6 +1046,23 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
             if (loaded.config.name && loaded.config.name.trim().length > 0) {
                 results.metadata.config_name = loaded.config.name.trim();
             }
+            results.metadata.rerun_agents = [...resolvedAgentList];
+            results.metadata.rerun_scenario_ids = selectedBaseScenarios.scenarios.map((scenario) => scenario.id);
+            if (serverOverrideAll && serverOverrideAll.length > 0) {
+                results.metadata.rerun_server_override_all = [...serverOverrideAll];
+            }
+            else {
+                delete results.metadata.rerun_server_override_all;
+            }
+            if (filteredScenarioOverrides && Object.keys(filteredScenarioOverrides).length > 0) {
+                results.metadata.rerun_scenario_server_overrides = Object.fromEntries(Object.entries(filteredScenarioOverrides).map(([scenarioKey, serverIds]) => [
+                    scenarioKey,
+                    [...serverIds]
+                ]));
+            }
+            else {
+                delete results.metadata.rerun_scenario_server_overrides;
+            }
             addJobEvent(job, {
                 type: 'log',
                 ts: new Date().toISOString(),
@@ -914,6 +1075,8 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
                 ts: new Date().toISOString(),
                 payload: { message: `Writing results to ${runDir}` }
             });
+            const traceRecords = getScenarioRunTraceRecords(results.metadata.run_id, settings.runsDir);
+            results.metadata.tool_tokens_total = estimateRunToolTokensTotal(traceRecords);
             writeFileSync(join(runDir, 'results.json'), `${JSON.stringify(results, null, 2)}\n`, 'utf8');
             writeFileSync(join(runDir, 'report.html'), renderReport(results), 'utf8');
             writeFileSync(join(runDir, 'summary.md'), renderSummaryMarkdown(results), 'utf8');
@@ -940,6 +1103,27 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
         }
     }
     catch (error) {
+        if (error instanceof OAuthAuthorizationRequiredError) {
+            const blockedServers = Array.from(new Set(error.details.map((detail) => detail.serverName).filter(Boolean)));
+            const aborted = job.abortController.signal.aborted || job.status === 'stopped';
+            if (!aborted && blockedServers.length > 0) {
+                job.blockedAuthServers = blockedServers;
+                job.status = 'blocked_auth';
+                if (!runQueueState.queue.includes(job.id)) {
+                    runQueueState.queue.unshift(job.id);
+                }
+                addJobEvent(job, {
+                    type: 'oauth_required',
+                    ts: new Date().toISOString(),
+                    payload: {
+                        jobId: job.id,
+                        servers: blockedServers,
+                        message: `OAuth login required for server(s): ${blockedServers.join(', ')}.`
+                    }
+                });
+                return;
+            }
+        }
         const normalizedError = error instanceof OAuthAuthorizationRequiredError
             ? new Error(error.details[0]?.message || error.message)
             : error;
@@ -959,13 +1143,90 @@ async function executeRunJob(job, settings, jobs, runQueueState, oauthSessionMan
     }
     finally {
         runQueueState.activeJobId = null;
-        for (const client of job.clients)
-            client.end();
-        job.clients.clear();
-        advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps);
+        if (job.status !== 'blocked_auth') {
+            for (const client of job.clients)
+                client.end();
+            job.clients.clear();
+        }
+        void advanceQueue(jobs, runQueueState, settings, oauthSessionManager, deps, {
+            emitWhenIdle: true
+        }).catch((error) => {
+            console.warn(`[mcplab] Failed to advance run queue after job '${job.id}': ${error instanceof Error ? error.message : String(error)}`);
+        });
         pruneOldJobs(jobs, runQueueState);
     }
 }
+function splitInteger(total, parts) {
+    if (!Number.isFinite(total) || !parts || parts <= 0)
+        return Array(parts).fill(0);
+    const safeTotal = Math.max(0, Math.round(total ?? 0));
+    const base = Math.floor(safeTotal / parts);
+    let remainder = safeTotal % parts;
+    return Array.from({ length: parts }, () => {
+        const value = base + (remainder > 0 ? 1 : 0);
+        if (remainder > 0)
+            remainder -= 1;
+        return value;
+    });
+}
+function estimateRunToolTokensTotal(records) {
+    let total = 0;
+    let hasAny = false;
+    for (const record of records) {
+        const toolUsesById = new Map();
+        for (const message of record.messages ?? []) {
+            const toolUses = message.content.filter((block) => block.type === 'tool_use');
+            if (toolUses.length > 0) {
+                for (const toolUse of toolUses)
+                    toolUsesById.set(toolUse.id, toolUse.name);
+                const allEstimated = toolUses.every((toolUse) => Boolean(toolUse.estimated_tokens));
+                if (allEstimated) {
+                    for (const toolUse of toolUses)
+                        total += toolUse.estimated_tokens?.total ?? 0;
+                    hasAny = true;
+                }
+                else if (toolUses.length === 1 && typeof message.usage?.total_tokens === 'number') {
+                    total += message.usage.total_tokens;
+                    hasAny = true;
+                }
+                else {
+                    const shares = splitInteger(message.usage?.total_tokens, toolUses.length);
+                    total += shares.reduce((sum, value) => sum + value, 0);
+                    if (typeof message.usage?.total_tokens === 'number')
+                        hasAny = true;
+                }
+            }
+            const toolResults = message.content.filter((block) => block.type === 'tool_result');
+            if (toolResults.length === 0)
+                continue;
+            const allEstimated = toolResults.every((result) => Boolean(result.estimated_tokens));
+            if (allEstimated) {
+                for (const result of toolResults)
+                    total += result.estimated_tokens?.total ?? 0;
+                hasAny = true;
+                continue;
+            }
+            if (toolResults.length === 1) {
+                const [result] = toolResults;
+                if (result &&
+                    toolUsesById.has(result.tool_use_id) &&
+                    typeof message.usage?.total_tokens === 'number') {
+                    total += message.usage.total_tokens;
+                    hasAny = true;
+                    continue;
+                }
+            }
+            const knownResults = toolResults.filter((result) => toolUsesById.has(result.tool_use_id));
+            if (knownResults.length === 0)
+                continue;
+            const shares = splitInteger(message.usage?.total_tokens, knownResults.length);
+            total += shares.reduce((sum, value) => sum + value, 0);
+            if (typeof message.usage?.total_tokens === 'number')
+                hasAny = true;
+        }
+    }
+    return hasAny ? total : null;
+}
 function pruneOldJobs(jobs, runQueueState) {
     const maxAgeMs = 30 * 60_000;
     const now = Date.now();