ec-web 0.0.5 → 0.0.7

package/dist/fs-utils.js

@@ -14,72 +14,104 @@ export function encodeSegment(s) {
 export function decodeDirSegment(seg) {
     return seg.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
+function encodeChannelSessionComponent(value) {
+    const encoded = encodeURIComponent(value).replace(/\*/g, '%2A');
+    return encoded.endsWith('.') ? `${encoded.slice(0, -1)}%2E` : encoded;
+}
+function formatChannelSessionKeyParts(channelType, channelName, channelId) {
+    if (!channelType || !channelName || !channelId)
+        throw new Error('channel session key components must not be empty');
+    const key = [channelType, channelName, channelId].map(encodeChannelSessionComponent).join('#');
+    if (Buffer.byteLength(key, 'utf8') > 255)
+        throw new Error('channel session key exceeds the 255-byte filesystem limit');
+    return key;
+}
+export function formatChannelSessionKey(channelType, channelId, channelKey) {
+    const parts = channelKey?.split('#');
+    const channelName = parts?.length === 3 && parts[0] === channelType && parts[2]?.trim()
+        ? parts[2].trim()
+        : 'main';
+    return formatChannelSessionKeyParts(channelType, channelName, channelId);
+}
+export function tryParseChannelSessionKey(key) {
+    const parts = key.split('#');
+    if (parts.length !== 3 || parts.some(part => !part))
+        return undefined;
+    try {
+        const parsed = {
+            channelType: decodeURIComponent(parts[0]),
+            channelName: decodeURIComponent(parts[1]),
+            channelId: decodeURIComponent(parts[2]),
+        };
+        if (!parsed.channelType || !parsed.channelName || !parsed.channelId)
+            return undefined;
+        return formatChannelSessionKeyParts(parsed.channelType, parsed.channelName, parsed.channelId) === key
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** 与 evolcore cross-platform.ts encodePath 一致（CC transcript 目录名） */
 export function encodePath(p) {
     const isWindows = process.platform === 'win32';
     const norm = isWindows ? p.replace(/\\/g, '/') : p;
     return encodeURIComponent(norm).replace(/%2F/gi, '-').replace(/%3A/gi, '-').replace(/^-/, '');
 }
+function hasSessionPayload(dirPath) {
+    try {
+        return fs.readdirSync(dirPath, { withFileTypes: true }).some(entry => (entry.isFile() && (entry.name === 'active.json'
+            || entry.name === 'messages.jsonl'
+            || (entry.name.startsWith('meta_') && entry.name.endsWith('.jsonl')))) || (entry.isDirectory() && entry.name === '_threads'));
+    }
+    catch {
+        return false;
+    }
+}
 export function scanChatDirs(sessionsDir) {
     const results = [];
-    let channelTypes;
+    let agents;
     try {
-        channelTypes = fs.readdirSync(sessionsDir, { withFileTypes: true });
+        agents = fs.readdirSync(sessionsDir, { withFileTypes: true });
     }
     catch {
         return results;
     }
-    for (const ct of channelTypes) {
-        if (!ct.isDirectory())
+    for (const agent of agents) {
+        if (!agent.isDirectory())
             continue;
-        const channelType = ct.name;
-        const ctDir = path.join(sessionsDir, channelType);
-        let level2;
+        const selfAID = decodeDirSegment(agent.name);
+        const agentSessions = path.join(sessionsDir, agent.name, 'sessions');
+        let sessions;
         try {
-            level2 = fs.readdirSync(ctDir, { withFileTypes: true });
+            sessions = fs.readdirSync(agentSessions, { withFileTypes: true });
         }
         catch {
             continue;
         }
-        if (channelType === 'aun') {
-            for (const selfEnc of level2) {
-                if (!selfEnc.isDirectory())
-                    continue;
-                const selfAID = decodeDirSegment(selfEnc.name);
-                const selfDir = path.join(ctDir, selfEnc.name);
-                let peers;
-                try {
-                    peers = fs.readdirSync(selfDir, { withFileTypes: true });
-                }
-                catch {
-                    continue;
-                }
-                for (const peerEnc of peers) {
-                    if (!peerEnc.isDirectory() || peerEnc.name.startsWith('_'))
-                        continue;
-                    results.push({
-                        dirPath: path.join(selfDir, peerEnc.name),
-                        channelType,
-                        channelId: decodeDirSegment(peerEnc.name),
-                        selfAID,
-                    });
-                }
-            }
-        }
-        else {
-            for (const chanEnc of level2) {
-                if (!chanEnc.isDirectory())
-                    continue;
-                results.push({
-                    dirPath: path.join(ctDir, chanEnc.name),
-                    channelType,
-                    channelId: decodeDirSegment(chanEnc.name),
-                    selfAID: '',
-                });
-            }
+        for (const session of sessions) {
+            if (!session.isDirectory())
+                continue;
+            const parsed = tryParseChannelSessionKey(session.name);
+            if (!parsed)
+                continue;
+            const dirPath = path.join(agentSessions, session.name);
+            if (!hasSessionPayload(dirPath))
+                continue;
+            results.push({
+                dirPath,
+                channelType: parsed.channelType,
+                channelKey: parsed.channelType === 'daemon'
+                    ? 'daemon'
+                    : `${parsed.channelType}#${selfAID}#${parsed.channelName}`,
+                channelId: parsed.channelId,
+                channelSessionKey: session.name,
+                selfAID,
+            });
         }
     }
-    return results;
+    return results.sort((left, right) => left.dirPath < right.dirPath ? -1 : left.dirPath > right.dirPath ? 1 : 0);
 }
 export function readJsonFile(filePath) {
     try {
@@ -123,34 +155,26 @@ export function isTransientProtocolMessage(entry) {
     return transient(entry.payloadType) || transient(entry.msgType);
 }
 export function getSessionsAunDir() {
-    return path.join(resolvePaths().sessionsDir, 'aun');
+    return resolvePaths().sessionsDir;
 }
 export function listLocalAids(aunDir) {
-    try {
-        return fs.readdirSync(aunDir, { withFileTypes: true })
-            .filter(e => e.isDirectory())
-            .map(e => decodeDirSegment(e.name));
-    }
-    catch {
-        return [];
-    }
+    return [...new Set(scanChatDirs(aunDir)
+            .filter(chat => chat.channelType === 'aun')
+            .map(chat => chat.selfAID))].sort();
 }
 export function listPeers(aunDir, localAid) {
-    const aidDir = path.join(aunDir, encodeSegment(localAid));
-    try {
-        return fs.readdirSync(aidDir, { withFileTypes: true })
-            .filter(e => e.isDirectory() && !e.name.startsWith('_'))
-            .map(e => decodeDirSegment(e.name));
-    }
-    catch {
-        return [];
-    }
+    return [...new Set(scanChatDirs(aunDir)
+            .filter(chat => chat.channelType === 'aun' && chat.selfAID === localAid)
+            .map(chat => chat.channelId))].sort();
+}
+function aunChatDir(aunDir, localAid, peerId) {
+    return path.join(aunDir, encodeSegment(localAid), 'sessions', formatChannelSessionKey('aun', peerId, `aun#${localAid}#main`));
 }
 export function readMessages(aunDir, localAid, peerId) {
-    return readAllJsonlLines(path.join(aunDir, encodeSegment(localAid), encodeSegment(peerId), 'messages.jsonl')).filter(m => !isTransientProtocolMessage(m));
+    return readAllJsonlLines(path.join(aunChatDir(aunDir, localAid, peerId), 'messages.jsonl')).filter(m => !isTransientProtocolMessage(m));
 }
 function readPeerName(aunDir, localAid, peerId) {
-    return readJsonFile(path.join(aunDir, encodeSegment(localAid), encodeSegment(peerId), 'active.json'))?.metadata?.peerName ?? null;
+    return readJsonFile(path.join(aunChatDir(aunDir, localAid, peerId), 'active.json'))?.metadata?.peerName ?? null;
 }
 export function loadAidInfo(aunDir, aid) {
     const peers = listPeers(aunDir, aid);

package/dist/paths.js

@@ -42,7 +42,7 @@ export function resolvePaths() {
     const root = resolveRoot();
     return {
         root,
-        sessionsDir: path.join(root, 'data', 'sessions'),
+        sessionsDir: path.join(root, 'agents'),
         instanceDir: path.join(root, 'data', 'instance'),
         dataDir: path.join(root, 'data'),
         logs: path.join(root, 'logs'),

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 自动续期）
@@ -553,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)
@@ -569,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

@@ -1,5 +1,5 @@
 /**
- * 消息数据源：扫描 data/sessions 下所有渠道的 messages.jsonl。
+ * 消息数据源：扫描 agents/<aid>/sessions 下所有渠道的 messages.jsonl。
  *
  * 左列按 agent 聚合；中列列出该 agent 下所有渠道的私聊/群聊会话。
  * 兼容旧参数名 aid/peer：前端的 aid 实际上传 scope id。
@@ -9,13 +9,14 @@ 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';
+import { decodeDirSegment, isTransientProtocolMessage, readAllJsonlLines, readJsonFile, scanChatDirs, tryParseChannelSessionKey, } 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([
@@ -119,13 +120,27 @@ function getAunGroupNames(aid) {
     aunGroupNameRequests.set(aid, request);
     return request;
 }
-async function hydrateAunGroupNames(chats) {
+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(await Promise.all(aids.map(async (aid) => [aid, await getAunGroupNames(aid)])));
+    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;
@@ -186,26 +201,135 @@ function getSessionAdapter(baseagent) {
 function safeId(value) {
     return Buffer.from(value, 'utf8').toString('base64url');
 }
-function findMessageFiles(root) {
-    const out = [];
-    const visit = (dir) => {
-        let entries;
+export function findMessageFiles(root) {
+    return scanChatDirs(root)
+        .map(chat => path.join(chat.dirPath, 'messages.jsonl'))
+        .filter(file => fs.existsSync(file));
+}
+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 {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+            JSON.parse(trailing);
         }
         catch {
-            return;
+            completeBytes = lastBreak + 1;
         }
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory())
-                visit(full);
-            else if (entry.isFile() && entry.name === 'messages.jsonl')
-                out.push(full);
+    }
+    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);
         }
-    };
-    visit(root);
-    return out;
+        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);
@@ -348,9 +472,6 @@ export async function getAgentSelfNames() {
     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)));
-}
 function parseChannelKey(value) {
     if (typeof value !== 'string')
         return null;
@@ -375,10 +496,38 @@ function parseLegacySessionKey(value, channelType) {
         return null;
     return { type: parts[0], selfAID: parts[1], name: parts[2] || 'main' };
 }
-function pathIdentity(sessionsDir, dirPath) {
+export function pathIdentity(sessionsDir, dirPath) {
     const relParts = path.relative(sessionsDir, dirPath).split(path.sep).filter(Boolean);
     if (!relParts.length)
         return {};
+    // Current layout: agents/<aid>/sessions/<channelSessionKey>/
+    if (relParts.length === 3 && relParts[1] === 'sessions') {
+        const selfAID = decodeDirSegment(relParts[0]);
+        const parsed = tryParseChannelSessionKey(relParts[2]);
+        if (parsed) {
+            return {
+                channelType: parsed.channelType,
+                channel: parsed.channelType === 'daemon'
+                    ? 'daemon'
+                    : `${parsed.channelType}#${selfAID}#${parsed.channelName}`,
+                channelId: parsed.channelId,
+                selfAID,
+            };
+        }
+    }
+    // Immediately preceding Agent layout, retained for inspecting backups.
+    if (relParts.length >= 4 && relParts[1] === 'sessions') {
+        const selfAID = decodeDirSegment(relParts[0]);
+        const channelKey = decodeDirSegment(relParts[2]);
+        const parsed = parseChannelKey(channelKey);
+        return {
+            channelType: parsed?.type || channelKey,
+            channel: channelKey,
+            channelId: decodeDirSegment(relParts[3]),
+            selfAID: parsed?.selfAID || selfAID,
+        };
+    }
+    // Pre-migration path fallback for viewing a backup directory only.
     const firstKey = parseChannelKey(decodeDirSegment(relParts[0]));
     if (firstKey) {
         return {
@@ -467,17 +616,22 @@ function chatDisplayId(active, messages) {
         groupName: null,
     };
 }
-function loadChats(peerDisplayResolver) {
+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);
@@ -489,9 +643,9 @@ function loadChats(peerDisplayResolver) {
         const peerName = chatType === 'group'
             ? display.peerName
             : resolveContactPeerName(peerDisplayResolver, identity, display.peerId, display.peerName);
-        const threadSessions = loadThreadSessions(dirPath);
+        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;
@@ -650,7 +804,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;
@@ -665,7 +819,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--) {
@@ -745,8 +905,20 @@ async function buildSessionContext(chat) {
     };
 }
 async function buildSnapshot(params) {
+    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 chats = loadChats(peerDisplayResolver);
+    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)
@@ -759,18 +931,30 @@ async function buildSnapshot(params) {
     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 = {