ec-web 0.0.4 → 0.0.6

package/dist/server.js

@@ -20,7 +20,7 @@ import { ipcQuery } from './ipc-client.js';
 import { setDebugLog, dlog } from './debug-log.js';
 import { aidSource } from './sources/aid.js';
 import { msgSource } from './sources/msg.js';
-import { sessionSource, buildBindMap } from './sources/session.js';
+import { sessionSource, buildBindMap, readClaudeSessionResult } from './sources/session.js';
 import { cacheSource } from './sources/cache.js';
 import { systemSource } from './sources/system.js';
 import { triggersSource } from './sources/triggers.js';
@@ -34,6 +34,7 @@ import { relationRolesSource, handleRelationRolesApi, handlePeerRoleApi } from '
 import { roleDefinitionsSource, handleRoleDefinitionsApi } from './sources/role-definitions.js';
 import { handleModelsApi } from './sources/models.js';
 import { detectBaseAgents } from './sources/baseagent-detector.js';
+import { readCodexSessionResult } from './sources/session-codex.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const STATIC_DIR = path.join(__dirname, 'static');
 const TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30天（滑动窗口：每次有效访问刷新 lastActive 自动续期）
@@ -66,10 +67,26 @@ const ECWEB_VERSION = readEcwebVersion();
 const MIME = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
     '.css': 'text/css; charset=utf-8',
     '.json': 'application/json; charset=utf-8',
+    '.webmanifest': 'application/manifest+json; charset=utf-8',
     '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.wasm': 'application/wasm',
 };
+const HTML_CACHE_CONTROL = 'no-cache';
+const STATIC_CACHE_CONTROL = 'public, max-age=0, must-revalidate';
 function tokenStorePath() {
     const dir = resolvePaths().instanceDir;
     const current = path.join(dir, 'ecweb-tokens.json');
@@ -141,7 +158,32 @@ function injectBaseHref(html, prefix) {
         return html.replace(/<base\b[^>]*>/i, tag);
     return html.replace(/<head[^>]*>/i, (m) => `${m}\n  ${tag}`);
 }
-function serveStatic(req, res) {
+function createEtag(content) {
+    return `"${crypto.createHash('sha256').update(content).digest('hex')}"`;
+}
+function matchesIfNoneMatch(req, etag) {
+    const header = req.headers['if-none-match'];
+    const value = Array.isArray(header) ? header.join(',') : header;
+    if (!value)
+        return false;
+    // GET uses weak comparison, so a client may send the validator with W/.
+    return value.split(',').some((candidate) => {
+        const normalized = candidate.trim().replace(/^W\//, '');
+        return normalized === '*' || normalized === etag;
+    });
+}
+function respondWithValidator(req, res, body, contentType, cacheControl, extraHeaders = {}) {
+    const etag = createEtag(body);
+    const headers = { 'Content-Type': contentType, 'Cache-Control': cacheControl, ETag: etag, ...extraHeaders };
+    if (matchesIfNoneMatch(req, etag)) {
+        res.writeHead(304, headers);
+        res.end();
+        return;
+    }
+    res.writeHead(200, headers);
+    res.end(body);
+}
+export function serveStatic(req, res) {
     let urlPath = (req.url || '/').split('?')[0];
     if (urlPath === '/')
         urlPath = '/index.html';
@@ -161,12 +203,13 @@ function serveStatic(req, res) {
         if (ext === '.html') {
             const prefix = forwardedPrefix(req);
             const html = injectBaseHref(data.toString('utf-8'), prefix);
-            res.writeHead(200, { 'Content-Type': MIME[ext] });
-            res.end(html);
+            // The proxy prefix changes the representation, so shared caches must key on it.
+            respondWithValidator(req, res, html, MIME[ext], HTML_CACHE_CONTROL, { Vary: 'X-Forwarded-Prefix' });
             return;
         }
-        res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
-        res.end(data);
+        // Static files have stable ETags, including fonts, images, manifests, and vendored libraries.
+        // Their fixed URLs must revalidate so deployments never leave clients on an old asset.
+        respondWithValidator(req, res, data, MIME[ext] || 'application/octet-stream', STATIC_CACHE_CONTROL);
     });
 }
 // ── Helpers ──
@@ -511,8 +554,14 @@ function handleConnection(ws, req, log) {
                 params.aid = msg.aid;
             if (msg.peer)
                 params.peer = msg.peer;
+            if (msg.before != null)
+                params.before = msg.before;
             if (msg.sessionId)
                 params.sessionId = msg.sessionId;
+            if (msg.turnBefore != null)
+                params.turnBefore = msg.turnBefore;
+            if (msg.turnLimit != null)
+                params.turnLimit = msg.turnLimit;
             if (msg.project)
                 params.project = msg.project;
             if (msg.agent)
@@ -527,6 +576,14 @@ function handleConnection(ws, req, log) {
             await switchSubscription(msg.view, params);
             return;
         }
+        if (msg.type === 'session.result') {
+            const params = msg.params && typeof msg.params === 'object' ? msg.params : {};
+            const result = params.baseagent === 'codex'
+                ? readCodexSessionResult(params)
+                : readClaudeSessionResult(params);
+            send({ type: 'session.result', requestId: msg.requestId, data: result == null ? null : { text: result } });
+            return;
+        }
         if (msg.type === 'menu' && msg.payload) {
             const p = resolvePaths();
             const timeoutMs = Number.isFinite(Number(msg.timeoutMs)) && Number(msg.timeoutMs) > 0

package/dist/sources/msg.js

@@ -6,11 +6,17 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { ipcQuery } from '../ipc-client.js';
 import { resolvePaths } from '../paths.js';
 import { resolveParentDistModule, toFileUrl } from './parent-package.js';
 import { isTransientProtocolMessage, readAllJsonlLines, readJsonFile, } from '../fs-utils.js';
 let contextModulesPromise = null;
 const sessionAdapterPromises = new Map();
+let peerDisplayResolverPromise = null;
+const aunGroupNameCache = new Map();
+const aunGroupNameRequests = new Map();
+let agentDisplayNamesCache = null;
+const messageFileCache = new Map();
 function getContextModules() {
     if (!contextModulesPromise) {
         contextModulesPromise = Promise.all([
@@ -21,6 +27,159 @@ function getContextModules() {
     }
     return contextModulesPromise;
 }
+function getPeerDisplayResolver() {
+    if (!peerDisplayResolverPromise) {
+        peerDisplayResolverPromise = Promise.resolve()
+            .then(() => import(toFileUrl(resolveParentDistModule('config', 'contact-book.js'))))
+            .then(mod => typeof mod.resolvePeerDisplayLabel === 'function' ? mod.resolvePeerDisplayLabel : null)
+            .catch(() => null);
+    }
+    return peerDisplayResolverPromise;
+}
+export function resolveContactPeerName(resolver, identity, peerId, fallback) {
+    if (!resolver)
+        return fallback;
+    try {
+        return resolver(identity.selfAID, identity.channelType, peerId, identity.channel) || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function aunGroupIdVariants(groupId) {
+    const id = String(groupId || '').trim();
+    if (!id)
+        return [];
+    const variants = new Set([id]);
+    const legacy = /^group\.agentid\.pub\/([^/]+)$/i.exec(id);
+    if (legacy)
+        variants.add(`${legacy[1]}.agentid.pub`);
+    const current = /^([^.]+)\.agentid\.pub$/i.exec(id);
+    if (current)
+        variants.add(`group.agentid.pub/${current[1]}`);
+    return [...variants];
+}
+export function resolveAunGroupName(names, groupId, fallback) {
+    for (const id of aunGroupIdVariants(groupId || '')) {
+        const name = names.get(id);
+        if (name)
+            return name;
+    }
+    return fallback;
+}
+async function fetchAunGroupNames(aid) {
+    const names = new Map();
+    let cursor = null;
+    let page = 0;
+    do {
+        page += 1;
+        const response = await ipcQuery(resolvePaths().socket, {
+            type: 'menu.exec',
+            payload: {
+                type: 'menu.query',
+                name: 'connect',
+                cmd: '/connect',
+                agent: aid,
+                id: `ecweb-msg-groups-${Date.now()}-${page}`,
+                args: { self: aid, view: 'groups', limit: 200, ...(cursor ? { cursor } : {}) },
+            },
+            auth: { source: 'ecweb', localDirect: true },
+        }, 10_000);
+        const data = response?.ok && !response.response?.error ? response.response?.data : null;
+        if (!data || !Array.isArray(data.items))
+            break;
+        for (const item of data.items) {
+            const groupId = String(item?.groupId || '').trim();
+            const displayName = String(item?.displayName || '').trim();
+            if (!groupId || !displayName)
+                continue;
+            for (const variant of aunGroupIdVariants(groupId))
+                names.set(variant, displayName);
+        }
+        cursor = typeof data.nextCursor === 'string' && data.nextCursor ? data.nextCursor : null;
+    } while (cursor && page < 20);
+    return names;
+}
+function getAunGroupNames(aid) {
+    const cached = aunGroupNameCache.get(aid);
+    if (cached && cached.expiresAt > Date.now())
+        return Promise.resolve(cached.names);
+    const pending = aunGroupNameRequests.get(aid);
+    if (pending)
+        return pending;
+    const request = fetchAunGroupNames(aid)
+        .then(names => {
+        aunGroupNameCache.set(aid, {
+            names,
+            expiresAt: Date.now() + (names.size ? 5 * 60_000 : 15_000),
+        });
+        return names;
+    })
+        .catch(() => new Map())
+        .finally(() => aunGroupNameRequests.delete(aid));
+    aunGroupNameRequests.set(aid, request);
+    return request;
+}
+async function hydrateAunGroupNames(chats, waitForRefresh = false) {
+    const aids = [...new Set(chats
+            .filter(chat => chat.channelType === 'aun' && chat.chatType === 'group')
+            .map(chat => chat.selfAID))];
+    if (!aids.length)
+        return;
+    const directories = new Map();
+    if (waitForRefresh) {
+        for (const [aid, names] of await Promise.all(aids.map(async (aid) => [aid, await getAunGroupNames(aid)]))) {
+            directories.set(aid, names);
+        }
+    }
+    else {
+        for (const aid of aids) {
+            const cached = aunGroupNameCache.get(aid);
+            if (cached)
+                directories.set(aid, cached.names);
+            if (!cached || cached.expiresAt <= Date.now())
+                void getAunGroupNames(aid);
+        }
+    }
+    for (const chat of chats) {
+        if (chat.channelType !== 'aun' || chat.chatType !== 'group')
+            continue;
+        const groupName = resolveAunGroupName(directories.get(chat.selfAID) || new Map(), chat.groupId, chat.groupName);
+        if (!groupName)
+            continue;
+        chat.groupName = groupName;
+        chat.peerName = groupName;
+    }
+}
+export function resolveSessionBindDisplayName(bind, resolver, aunGroupNames = new Map()) {
+    const isGroup = bind.chatType === 'group' || !!bind.groupId;
+    if (bind.channelType === 'aun' && isGroup) {
+        return resolveAunGroupName(aunGroupNames, bind.groupId || bind.channelId, bind.groupName || null);
+    }
+    if (isGroup)
+        return bind.groupName || null;
+    return resolveContactPeerName(resolver, {
+        selfAID: bind.selfAID,
+        channelType: bind.channelType,
+        channel: bind.channelKey || bind.channelType,
+        channelId: bind.channelId,
+    }, bind.peerId || bind.channelId, bind.peerName);
+}
+/** 为会话页绑定标签补齐联系人名或 AUN 群名，不改变原始 channelId。 */
+export async function hydrateSessionBindDisplayNames(binds) {
+    const items = [...binds];
+    if (!items.length)
+        return;
+    const resolver = await getPeerDisplayResolver();
+    const groupAids = [...new Set(items
+            .filter(bind => bind.channelType === 'aun' && (bind.chatType === 'group' || !!bind.groupId))
+            .map(bind => bind.selfAID)
+            .filter(Boolean))];
+    const groupDirectories = new Map(await Promise.all(groupAids.map(async (aid) => [aid, await getAunGroupNames(aid)])));
+    for (const bind of items) {
+        bind.displayName = resolveSessionBindDisplayName(bind, resolver, groupDirectories.get(bind.selfAID) || new Map());
+    }
+}
 function getSessionAdapter(baseagent) {
     if (!sessionAdapterPromises.has(baseagent)) {
         const classNames = {
@@ -63,6 +222,131 @@ function findMessageFiles(root) {
     visit(root);
     return out;
 }
+function fileSignature(file) {
+    try {
+        const stat = fs.statSync(file);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    catch {
+        return '';
+    }
+}
+function chatMetadataSignature(dirPath) {
+    const parts = [
+        `active:${fileSignature(path.join(dirPath, 'active.json'))}`,
+    ];
+    let rootEntries = [];
+    try {
+        rootEntries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch { }
+    for (const entry of rootEntries) {
+        if (entry.isFile() && entry.name.startsWith('meta_') && entry.name.endsWith('.jsonl')) {
+            parts.push(`${entry.name}:${fileSignature(path.join(dirPath, entry.name))}`);
+        }
+    }
+    const threadsDir = path.join(dirPath, '_threads');
+    let threadEntries = [];
+    try {
+        threadEntries = fs.readdirSync(threadsDir, { withFileTypes: true });
+    }
+    catch { }
+    for (const entry of threadEntries) {
+        if (entry.isFile() && (entry.name === 'thread-index.json' || entry.name.endsWith('.jsonl'))) {
+            parts.push(`threads/${entry.name}:${fileSignature(path.join(threadsDir, entry.name))}`);
+        }
+    }
+    return parts.sort().join('|');
+}
+function appendMessageRows(file, cached, metrics) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        return false;
+    }
+    if (stat.size < cached.offset || (stat.size === cached.offset && cached.mtimeMs && stat.mtimeMs !== cached.mtimeMs)) {
+        cached.offset = 0;
+        cached.messages = [];
+    }
+    if (stat.size === cached.offset)
+        return false;
+    const bytes = stat.size - cached.offset;
+    const buffer = Buffer.allocUnsafe(bytes);
+    let fd = null;
+    try {
+        fd = fs.openSync(file, 'r');
+        fs.readSync(fd, buffer, 0, bytes, cached.offset);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd != null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    let completeBytes = buffer.length;
+    const lastBreak = buffer.lastIndexOf(0x0a);
+    if (lastBreak !== buffer.length - 1) {
+        const trailing = buffer.subarray(lastBreak + 1).toString('utf8').trim();
+        try {
+            JSON.parse(trailing);
+        }
+        catch {
+            completeBytes = lastBreak + 1;
+        }
+    }
+    if (completeBytes <= 0)
+        return false;
+    let parsedLines = 0;
+    for (const line of buffer.subarray(0, completeBytes).toString('utf8').split(/\r?\n/)) {
+        if (!line)
+            continue;
+        try {
+            const message = JSON.parse(line);
+            parsedLines++;
+            if (!isTransientProtocolMessage(message))
+                cached.messages.push(message);
+        }
+        catch { }
+    }
+    cached.offset += completeBytes;
+    cached.mtimeMs = stat.mtimeMs;
+    metrics.changedFiles++;
+    metrics.parsedLines += parsedLines;
+    metrics.parsedBytes += completeBytes;
+    return true;
+}
+function cachedMessageFile(file, metrics) {
+    let cached = messageFileCache.get(file);
+    if (!cached) {
+        cached = {
+            offset: 0,
+            mtimeMs: 0,
+            messages: [],
+            active: {},
+            threadSessions: [],
+            mainSessionIds: new Set(),
+            metadataSignature: '',
+        };
+        messageFileCache.set(file, cached);
+    }
+    appendMessageRows(file, cached, metrics);
+    const dirPath = path.dirname(file);
+    const metadataSignature = chatMetadataSignature(dirPath);
+    if (metadataSignature !== cached.metadataSignature) {
+        cached.active = readJsonFile(path.join(dirPath, 'active.json')) ?? {};
+        cached.threadSessions = loadThreadSessions(dirPath);
+        cached.mainSessionIds = loadMainSessionIds(dirPath, cached.active);
+        cached.metadataSignature = metadataSignature;
+        metrics.metadataRefreshes++;
+    }
+    return cached;
+}
 function readLastJsonlObject(file) {
     const rows = readAllJsonlLines(file);
     return rows.length ? rows[rows.length - 1] : null;
@@ -173,6 +457,37 @@ function listConfiguredAgentAids(root) {
     }
     return aids;
 }
+function shortAid(value) {
+    return String(value || '').split('.')[0] || String(value || '');
+}
+/** Returns local Agent display names, preferring the runtime selfName. */
+export async function getAgentSelfNames() {
+    if (agentDisplayNamesCache && agentDisplayNamesCache.expiresAt > Date.now()) {
+        return agentDisplayNamesCache.names;
+    }
+    const names = new Map();
+    try {
+        const [agentsResp, statsResp] = await Promise.all([
+            ipcQuery(resolvePaths().socket, { type: 'evolagent.list' }, 4000),
+            ipcQuery(resolvePaths().socket, { type: 'aun-aid-stats' }, 4000),
+        ]);
+        const statsByAid = new Map((statsResp?.stats || []).map(item => [String(item?.aid || ''), item]));
+        for (const agent of agentsResp?.agents || []) {
+            const aid = String(agent?.aid || '').trim();
+            if (!aid)
+                continue;
+            const stats = statsByAid.get(aid);
+            const displayName = String(stats?.selfName || agent?.displayName || shortAid(aid)).trim();
+            if (displayName)
+                names.set(aid, displayName);
+        }
+    }
+    catch {
+        // daemon unavailable: leave the map empty and use the AID fallback below
+    }
+    agentDisplayNamesCache = { expiresAt: Date.now() + 5000, names };
+    return names;
+}
 function decodeDirSegment(seg) {
     return seg.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
@@ -292,17 +607,22 @@ function chatDisplayId(active, messages) {
         groupName: null,
     };
 }
-function loadChats() {
+function loadChats(peerDisplayResolver, metrics) {
     const paths = resolvePaths();
     const sessionsDir = paths.sessionsDir;
     const configuredAids = listConfiguredAgentAids(paths.root);
     const files = findMessageFiles(sessionsDir);
+    const liveFiles = new Set(files);
+    for (const file of messageFileCache.keys()) {
+        if (!liveFiles.has(file))
+            messageFileCache.delete(file);
+    }
+    metrics.files = files.length;
     const chats = [];
     for (const file of files) {
         const dirPath = path.dirname(file);
-        const active = readJsonFile(path.join(dirPath, 'active.json')) ?? {};
-        const messages = readAllJsonlLines(file)
-            .filter(m => !isTransientProtocolMessage(m));
+        const cached = cachedMessageFile(file, metrics);
+        const { active, messages } = cached;
         if (!messages.length)
             continue;
         const identity = normalizeChatIdentity(sessionsDir, dirPath, active, messages);
@@ -311,9 +631,12 @@ function loadChats() {
             continue;
         const chatType = String(active.chatType || messages.find(m => m.chatType)?.chatType || 'private');
         const display = chatDisplayId({ ...active, chatType, channelId }, messages);
-        const threadSessions = loadThreadSessions(dirPath);
+        const peerName = chatType === 'group'
+            ? display.peerName
+            : resolveContactPeerName(peerDisplayResolver, identity, display.peerId, display.peerName);
+        const threadSessions = cached.threadSessions;
         const threadById = new Map(threadSessions.map(item => [item.threadId, item]));
-        const mainSessionIds = loadMainSessionIds(dirPath, active);
+        const mainSessionIds = cached.mainSessionIds;
         for (const item of partitionMessages(messages, threadSessions, mainSessionIds)) {
             if (!item.messages.length)
                 continue;
@@ -331,7 +654,7 @@ function loadChats() {
                 selfAID,
                 chatType,
                 peerId: display.peerId,
-                peerName: display.peerName,
+                peerName,
                 groupId: display.groupId,
                 groupName: display.groupName,
                 partition: item.partition,
@@ -353,7 +676,7 @@ function scopeId(chat) {
 function legacyChannelScopeId(chat) {
     return safeId(`${chat.selfAID}\n${chat.channelType}\n${chat.channel}`);
 }
-function buildScopes(chats) {
+function buildScopes(chats, agentDisplayNames = new Map()) {
     const map = new Map();
     const seenChats = new Map();
     const seenChannels = new Map();
@@ -366,6 +689,7 @@ function buildScopes(chats) {
                 id,
                 aid: id,
                 selfAID: chat.selfAID,
+                displayName: agentDisplayNames.get(chat.selfAID) || shortAid(chat.selfAID),
                 totalIn: 0,
                 totalOut: 0,
                 peerCount: 0,
@@ -471,7 +795,7 @@ function selectedChats(chats, scope) {
         return [];
     return chats.filter(chat => scopeId(chat) === scope);
 }
-function messagesFor(chats, peer) {
+function messagesFor(chats, peer, before, limit) {
     const selected = peer
         ? chats.filter(chat => chatKey(chat) === peer)
         : chats;
@@ -486,7 +810,13 @@ function messagesFor(chats, peer) {
         threadName: chat.threadName,
     })));
     messages.sort((a, b) => (a.ts || 0) - (b.ts || 0));
-    return messages.length > 1000 ? messages.slice(-1000) : messages;
+    const end = before == null ? messages.length : Math.min(Math.max(before, 0), messages.length);
+    const start = Math.max(0, end - limit);
+    return {
+        messages: messages.slice(start, end),
+        nextBefore: start > 0 ? start : null,
+        hasMore: start > 0,
+    };
 }
 function latestInbound(chat) {
     for (let i = chat.messages.length - 1; i >= 0; i--) {
@@ -566,8 +896,21 @@ async function buildSessionContext(chat) {
     };
 }
 async function buildSnapshot(params) {
-    const chats = loadChats();
-    const scopes = buildScopes(chats);
+    const startedAt = Date.now();
+    const metrics = {
+        files: 0,
+        changedFiles: 0,
+        parsedLines: 0,
+        parsedBytes: 0,
+        metadataRefreshes: 0,
+        scanMs: 0,
+        totalMs: 0,
+    };
+    const peerDisplayResolver = await getPeerDisplayResolver();
+    const scanStartedAt = Date.now();
+    const chats = loadChats(peerDisplayResolver, metrics);
+    metrics.scanMs = Date.now() - scanStartedAt;
+    const scopes = buildScopes(chats, await getAgentSelfNames());
     const requestedScope = params.scope || params.aid || null;
     const scope = requestedScope && !scopes.some(s => s.id === requestedScope)
         ? (chats.find(chat => legacyChannelScopeId(chat) === requestedScope)
@@ -576,19 +919,33 @@ async function buildSnapshot(params) {
         : requestedScope;
     const peer = params.peer || null;
     const inScope = selectedChats(chats, scope);
+    if (scope)
+        await hydrateAunGroupNames(inScope);
     const peers = scope ? mergePeerInfo(inScope) : [];
-    const messages = scope ? messagesFor(inScope, peer) : [];
+    const requestedLimit = Number(params.limit);
+    const limit = Number.isFinite(requestedLimit) ? Math.min(Math.max(Math.trunc(requestedLimit), 20), 200) : 100;
+    const requestedBefore = params.before == null ? Number.NaN : Number(params.before);
+    const before = Number.isFinite(requestedBefore) && requestedBefore >= 0 ? Math.trunc(requestedBefore) : null;
+    const page = scope && peer ? messagesFor(inScope, peer, before, limit) : { messages: [], nextBefore: null, hasMore: false };
     const currentChat = peer ? inScope.find(chat => chatKey(chat) === peer) : undefined;
     const sessionContext = await buildSessionContext(currentChat);
+    metrics.totalMs = Date.now() - startedAt;
     return {
         scopes,
         aids: scopes,
         peers,
-        messages,
+        messages: page.messages,
+        messagePage: {
+            limit,
+            before,
+            nextBefore: page.nextBefore,
+            hasMore: page.hasMore,
+        },
         scope,
         aid: scope,
         peer,
         sessionContext,
+        metrics,
     };
 }
 export const msgSource = {