594 lines
30 KiB
JavaScript
594 lines
30 KiB
JavaScript
#!/usr/bin/env node
|
||
'use strict';
|
||
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
|
||
const source = fs.readFileSync(path.join(__dirname, '..', 'public', 'app.js'), 'utf8');
|
||
|
||
function extractFunction(name) {
|
||
const start = source.indexOf(`function ${name}(`);
|
||
assert(start >= 0, `缺少前端函数 ${name}`);
|
||
let signatureEnd = start;
|
||
let parentheses = 0;
|
||
for (let i = source.indexOf('(', start); i < source.length; i += 1) {
|
||
if (source[i] === '(') parentheses += 1;
|
||
if (source[i] === ')' && --parentheses === 0) { signatureEnd = i; break; }
|
||
}
|
||
let depth = 0;
|
||
for (let i = source.indexOf('{', signatureEnd); i < source.length; i += 1) {
|
||
if (source[i] === '{') depth += 1;
|
||
if (source[i] === '}' && --depth === 0) return source.slice(start, i + 1);
|
||
}
|
||
throw new Error(`无法提取 ${name}`);
|
||
}
|
||
|
||
// 仅模拟浏览器节点操作，消息身份、对账、缓存合并及重连分支均执行 app.js 原函数。
|
||
class Element {
|
||
constructor(tagName = '') {
|
||
this.tagName = tagName;
|
||
this.dataset = {};
|
||
this.children = [];
|
||
this.parentNode = null;
|
||
this.scrollTop = 0;
|
||
this.id = '';
|
||
this.classes = new Set();
|
||
this.listeners = new Map();
|
||
this.classList = {
|
||
contains: (name) => this.classes.has(name) || this.message?.role === name,
|
||
add: (name) => this.classes.add(name),
|
||
remove: (name) => this.classes.delete(name),
|
||
};
|
||
}
|
||
get scrollHeight() { return this.children.length * 50; }
|
||
get nextSibling() {
|
||
if (!this.parentNode) return null;
|
||
return this.parentNode.children[this.parentNode.children.indexOf(this) + 1] || null;
|
||
}
|
||
set innerHTML(value) {
|
||
this.html = value;
|
||
this.children.forEach((child) => { child.parentNode = null; });
|
||
this.children = [];
|
||
}
|
||
get innerHTML() { return this.html || ''; }
|
||
insertBefore(node, anchor) {
|
||
if (node.fragment) {
|
||
[...node.children].forEach((child) => this.insertBefore(child, anchor));
|
||
return node;
|
||
}
|
||
if (node === anchor) return node;
|
||
node.remove();
|
||
const index = anchor ? this.children.indexOf(anchor) : this.children.length;
|
||
assert(index >= 0, '插入锚点必须仍在消息容器中');
|
||
this.children.splice(index, 0, node);
|
||
node.parentNode = this;
|
||
return node;
|
||
}
|
||
appendChild(node) { return this.insertBefore(node, null); }
|
||
addEventListener(type, listener) { this.listeners.set(type, listener); }
|
||
click() { if (!this.disabled) this.listeners.get('click')?.(); }
|
||
removeAttribute(name) { if (name === 'id') this.id = ''; }
|
||
remove() {
|
||
if (!this.parentNode) return;
|
||
const nodes = this.parentNode.children;
|
||
nodes.splice(nodes.indexOf(this), 1);
|
||
this.parentNode = null;
|
||
}
|
||
replaceWith(node) {
|
||
if (!this.parentNode) return;
|
||
this.parentNode.insertBefore(node, this);
|
||
this.remove();
|
||
}
|
||
querySelectorAll(selector) {
|
||
return this.children.filter((child) => {
|
||
if (selector.includes('.user') && child.message?.role !== 'user') return false;
|
||
if (selector.includes('[data-session-message="true"]') && child.dataset.sessionMessage !== 'true') return false;
|
||
if (selector.includes('[data-message-key]') && !child.dataset.messageKey) return false;
|
||
return true;
|
||
});
|
||
}
|
||
querySelector() { return null; }
|
||
}
|
||
|
||
function createHarness() {
|
||
const names = [
|
||
'stableMessageHash', 'getStableMessageKey', 'getMessageRenderFingerprint',
|
||
'mergeIndexedSessionMessages', 'dedupeSessionMessages', 'markSessionMessageElement',
|
||
'mergeHistoryChunkIntoCachedSnapshot', 'mergeHistoryChunkIntoSessionLoadSnapshot',
|
||
'findRenderedSessionMessageByKey', 'renderMessages', 'reconcileRenderedSessionMessages',
|
||
'prependHistoryMessages', 'bindStreamingAssistantMessage', 'commitCompletedAssistantMessage',
|
||
'finishGenerating',
|
||
];
|
||
const resumeStart = source.indexOf("case 'resume_session_result':");
|
||
const resumeEnd = source.indexOf("case 'error':", resumeStart);
|
||
const doneStart = source.indexOf("case 'done':");
|
||
const doneEnd = source.indexOf("case 'system_message':", doneStart);
|
||
const generatingStart = source.indexOf("case 'resume_generating':");
|
||
const messagesDiv = new Element();
|
||
const api = new Function('Element', 'messagesDiv', `
|
||
let renderEpoch = 0;
|
||
let closedCollabAgentIds = new Set();
|
||
let collabAgentStateCache = new Map();
|
||
let collabAgentIdsByToolUseId = new Map();
|
||
let closedCollabAgentIdsByToolUseId = new Map();
|
||
let currentSessionId = 'running-session';
|
||
let currentSessionMessageCount = 0;
|
||
let isGenerating = false;
|
||
let generatingSessionId = null;
|
||
let pendingText = '';
|
||
let toolGroupCount = 0;
|
||
let hasGrouped = false;
|
||
const currentAgent = 'codexapp';
|
||
const activeToolCalls = new Map();
|
||
const activeTodoCallTargets = new Map();
|
||
const window = { pendingContentBlocks: [] };
|
||
const msgInput = { focus() {} };
|
||
let loadedHistorySessionId = '';
|
||
let currentCwd = '/tmp/history-test';
|
||
const historyLoadMore = null;
|
||
const sessionCache = new Map();
|
||
const buffers = new Map();
|
||
const timers = [];
|
||
let outlineUpdates = 0;
|
||
let scrollbarUpdates = 0;
|
||
const document = {
|
||
getElementById(id) { return messagesDiv.children.find((node) => node.id === id) || null; },
|
||
querySelector() { return null; },
|
||
createDocumentFragment() { const node = new Element(); node.fragment = true; return node; },
|
||
};
|
||
function setTimeout(callback) { timers.push(callback); }
|
||
function collectClosedCollabAgentIds() { return new Set(); }
|
||
function clearUserMessageIndex() {}
|
||
function updateUserOutlinePanel() { outlineUpdates += 1; }
|
||
function updateScrollbar() { scrollbarUpdates += 1; }
|
||
function renderPendingNotes() {}
|
||
function scrollToBottom() {}
|
||
function syncAssistantBranchButton() {}
|
||
function isCurrentSessionEvent(msg) { return msg.sessionId === currentSessionId; }
|
||
function clearPendingSessionResumeRequest() {}
|
||
function setCurrentSessionRunningState() {}
|
||
function updateNoteModeUI() {}
|
||
function migratePendingNotesToSession() {}
|
||
function migrateQueuedMessagesToSession() {}
|
||
function scheduleQueuedMessageDrain() {}
|
||
function syncAssistantLastSectionButton() {}
|
||
function updateGenerationControls() {}
|
||
function isNearBottom() { return true; }
|
||
function flushRender() {
|
||
const stream = document.getElementById('streaming-msg');
|
||
if (stream) stream.pendingText = pendingText;
|
||
}
|
||
function startGenerating() {
|
||
isGenerating = true;
|
||
const stream = new Element();
|
||
stream.id = 'streaming-msg';
|
||
stream.dataset.messageKey = 'local-stream';
|
||
messagesDiv.appendChild(stream);
|
||
}
|
||
function getSessionHistoryBuffer(id) { return buffers.get(id) || null; }
|
||
function isCompleteSessionSnapshot(snapshot) { return snapshot.complete; }
|
||
function cacheSessionSnapshot(snapshot) { sessionCache.set(snapshot.sessionId, { snapshot }); }
|
||
function bufferSessionSnapshot(snapshot) { buffers.set(snapshot.sessionId, snapshot); }
|
||
${names.map(extractFunction).join('\n')}
|
||
function buildMsgElement(message, index) {
|
||
const element = new Element();
|
||
element.message = JSON.parse(JSON.stringify(message));
|
||
markSessionMessageElement(element, index, message);
|
||
return element;
|
||
}
|
||
function resume(msg) {
|
||
switch (msg.type) { ${source.slice(resumeStart, resumeEnd)} }
|
||
}
|
||
function done(msg) {
|
||
switch (msg.type) { ${source.slice(doneStart, doneEnd)} }
|
||
}
|
||
function resumeGenerating(msg) {
|
||
switch (msg.type) { ${source.slice(generatingStart, resumeStart)} }
|
||
}
|
||
return {
|
||
${names.join(',')}, resume, done, resumeGenerating, messagesDiv, sessionCache, buffers,
|
||
setCount(value) { currentSessionMessageCount = value; },
|
||
count() { return currentSessionMessageCount; },
|
||
flushTimers() { while (timers.length) timers.shift()(); },
|
||
updates() { return { outlineUpdates, scrollbarUpdates }; },
|
||
};
|
||
`)(Element, messagesDiv);
|
||
api.ids = () => messagesDiv.children.map((node) => node.message?.id || node.id);
|
||
return api;
|
||
}
|
||
|
||
function message(id, role = 'assistant', content = id) {
|
||
return { id, role, content, timestamp: '2026-09-21T00:00:00.000Z' };
|
||
}
|
||
|
||
function createPaginationHarness() {
|
||
const rendering = createHarness();
|
||
const names = [
|
||
'createOutlineHistoryState', 'resetOutlineHistoryState', 'buildOutlineHistoryEntry',
|
||
'mergeOutlineHistoryMessages', 'syncOutlineHistoryIndex', 'normalizeOutlineTitleHistory',
|
||
'formatUserOutlineDate', 'buildUserOutlineItems', 'buildUserOutlineTimelineItems',
|
||
'updateUserOutlinePanel', 'resetHistoryLoadState', 'renderHistoryLoadControl',
|
||
'syncHistoryLoadControl', 'requestOlderHistory', 'requestOutlineHistoryPage',
|
||
];
|
||
const historyStart = source.indexOf("case 'session_history_chunk':");
|
||
const historyEnd = source.indexOf("case 'session_message':", historyStart);
|
||
const errorStart = source.indexOf("case 'error':", historyStart);
|
||
const errorEnd = source.indexOf('const matchesActiveLoadError =', errorStart);
|
||
assert(historyStart >= 0 && historyEnd > historyStart && errorStart >= 0 && errorEnd > errorStart);
|
||
return new Function('Element', 'rendering', `
|
||
let currentSessionId = 'running-session';
|
||
const loadedHistorySessionId = currentSessionId;
|
||
let currentHistoryState = {};
|
||
let currentOutlineHistoryState = createOutlineHistoryState(currentSessionId);
|
||
let activeHistoryPageRequest = null;
|
||
let activeOutlineHistoryRequest = null;
|
||
let activeOutlineTargetRequest = null;
|
||
let historyPageRequestSeq = 0;
|
||
let outlineHistoryRequestSeq = 0;
|
||
const activeSessionLoad = null;
|
||
let ws = { readyState: 1 };
|
||
let wsAuthenticated = true;
|
||
const historyLoadMore = new Element();
|
||
const userOutlinePanel = new Element();
|
||
const userOutlineBtn = new Element();
|
||
const messagesDiv = rendering.messagesDiv;
|
||
const userMessageIndex = new Map();
|
||
const currentOutlineTitleHistory = [];
|
||
const requests = [];
|
||
const document = { createElement(tagName) { return new Element(tagName); } };
|
||
function send(request) { requests.push(request); }
|
||
function shortMessagePreview(value, length) { return String(value).slice(0, length); }
|
||
function escapeHtml(value) { return String(value); }
|
||
function isBlockingSessionLoad() { return false; }
|
||
function scheduleAdvancedSearchJump() {}
|
||
function prependHistoryMessages(...args) { rendering.prependHistoryMessages(...args); }
|
||
function mergeHistoryChunkIntoCachedSnapshot(...args) { rendering.mergeHistoryChunkIntoCachedSnapshot(...args); }
|
||
${names.map(extractFunction).join('\n')}
|
||
return {
|
||
requests, historyLoadMore, userOutlinePanel, userOutlineBtn,
|
||
requestOlderHistory, requestOutlineHistoryPage,
|
||
reset() {
|
||
resetHistoryLoadState(currentSessionId);
|
||
resetOutlineHistoryState(currentSessionId);
|
||
updateUserOutlinePanel();
|
||
},
|
||
ids: rendering.ids,
|
||
outlineItems: buildUserOutlineItems,
|
||
state() { return { history: currentHistoryState, outline: currentOutlineHistoryState,
|
||
pageRequest: activeHistoryPageRequest, outlineRequest: activeOutlineHistoryRequest }; },
|
||
connect(authenticated = true, readyState = 1, connected = true) {
|
||
wsAuthenticated = authenticated;
|
||
ws = connected ? { readyState } : null;
|
||
},
|
||
select(sessionId) { currentSessionId = sessionId; },
|
||
init(snapshot) {
|
||
resetHistoryLoadState();
|
||
resetOutlineHistoryState();
|
||
rendering.buffers.set(snapshot.sessionId, { ...snapshot, messages: [...snapshot.messages] });
|
||
rendering.renderMessages(snapshot.messages, { immediate: true, baseIndex: snapshot.historyBaseIndex });
|
||
syncHistoryLoadControl(snapshot);
|
||
syncOutlineHistoryIndex(snapshot);
|
||
updateUserOutlinePanel();
|
||
},
|
||
receive(msg) {
|
||
switch (msg.type) {
|
||
${source.slice(historyStart, historyEnd)}
|
||
${source.slice(errorStart, errorEnd)}
|
||
break;
|
||
}
|
||
},
|
||
};
|
||
`)(Element, rendering);
|
||
}
|
||
|
||
const savedMessages = Array.from({ length: 57 }, (_, index) =>
|
||
message(`saved-${index}`, index < 45 && index % 2 === 0 ? 'user' : 'assistant'));
|
||
function savedSnapshot(available = false, cursor = 45) {
|
||
return {
|
||
sessionId: 'running-session', messages: savedMessages.slice(cursor),
|
||
historyBaseIndex: cursor, historyCursor: cursor, historyTotal: savedMessages.length,
|
||
historyAvailable: available,
|
||
};
|
||
}
|
||
function historyChunk(request, cursor) {
|
||
return {
|
||
type: 'session_history_chunk', sessionId: request.sessionId, requestId: request.requestId,
|
||
messages: savedMessages.slice(cursor, request.before), historyBaseIndex: cursor,
|
||
historyCursor: cursor, historyTotal: savedMessages.length, historyAvailable: false, remaining: 0,
|
||
};
|
||
}
|
||
function historyButtons(api) {
|
||
return api.historyLoadMore.children.filter((node) => node.tagName === 'button');
|
||
}
|
||
function historyCopy(api) {
|
||
return api.historyLoadMore.children.filter((node) => node.tagName === 'span')
|
||
.map((node) => node.textContent).join(' ');
|
||
}
|
||
|
||
{
|
||
const api = createPaginationHarness();
|
||
api.init(savedSnapshot());
|
||
api.requestOlderHistory();
|
||
assert.equal(api.requests.length, 1, '原始来源不可用时仍须请求已保存的45条正文');
|
||
assert.match(historyCopy(api), /45 条已保存的更早消息/);
|
||
assert.equal(historyButtons(api)[0].disabled, true, '请求期间保留 loading 和按钮禁用');
|
||
assert.equal(historyButtons(api)[0].textContent, '正在加载…');
|
||
api.requestOlderHistory();
|
||
assert.equal(api.requests.length, 1, '重复点击不能重复请求');
|
||
const first = api.requests[0];
|
||
api.receive({ ...historyChunk(first, 33), requestId: '过期请求' });
|
||
api.receive({ ...historyChunk(first, 33), sessionId: '其他会话' });
|
||
assert.equal(api.ids().length, 12, '错误会话和过期请求不能插入正文');
|
||
while (api.state().pageRequest) {
|
||
const request = api.state().pageRequest;
|
||
const response = historyChunk(request, Math.max(0, request.before - 12));
|
||
api.receive(response);
|
||
api.receive(response);
|
||
if (api.state().history.cursor > 0) historyButtons(api)[0].click();
|
||
}
|
||
assert.deepEqual(api.requests.map((request) => request.before), [45, 33, 21, 9]);
|
||
assert.deepEqual(api.ids(), savedMessages.map((item) => item.id), '57条已保存正文保持顺序且不重复');
|
||
assert.equal(api.state().history.available, false, '来源状态不能伪装成完整恢复');
|
||
assert.equal(api.historyLoadMore.hidden, false, '读完已保存消息仍须保留更早记录待核实提示');
|
||
assert.equal(historyButtons(api).length, 0, 'cursor=0时不能保留加载按钮');
|
||
assert.doesNotMatch(historyCopy(api), /无法恢复/);
|
||
}
|
||
|
||
{
|
||
const api = createPaginationHarness();
|
||
api.init(savedSnapshot());
|
||
assert.equal(api.outlineItems().length, 0, '首屏没有用户提问，用于验证目录入口');
|
||
assert.equal(api.userOutlineBtn.disabled, false, '有已保存旧消息时目录按钮不能因来源状态而禁用');
|
||
api.requestOutlineHistoryPage();
|
||
assert.equal(api.requests.length, 1, '原始来源不可用时仍须索引已保存的45条');
|
||
assert.match(api.userOutlinePanel.innerHTML, /正在加载/);
|
||
api.requestOutlineHistoryPage();
|
||
assert.equal(api.requests.length, 1, '目录索引请求必须去重');
|
||
const first = api.requests[0];
|
||
api.receive({ ...historyChunk(first, 33), requestId: '过期目录请求' });
|
||
api.receive({ ...historyChunk(first, 33), sessionId: '其他会话' });
|
||
assert.equal(api.outlineItems().length, 0, '错误会话和过期响应不能污染目录');
|
||
while (api.state().outlineRequest) {
|
||
const request = api.state().outlineRequest;
|
||
const response = historyChunk(request, Math.max(0, request.before - 12));
|
||
api.receive(response);
|
||
api.receive(response);
|
||
}
|
||
assert.deepEqual(api.requests.map((request) => request.before), [45, 33, 21, 9]);
|
||
assert(api.requests.every((request) => request.purpose === 'outline'));
|
||
assert.deepEqual(api.outlineItems().map((item) => item.id),
|
||
savedMessages.filter((item) => item.role === 'user').map((item) => item.id),
|
||
'目录自动完成全部用户提问索引，顺序正确且无重复');
|
||
assert.equal(api.state().outline.complete, true);
|
||
assert.equal(api.state().outline.available, false);
|
||
assert.match(api.userOutlinePanel.innerHTML, /更早的记录尚待核实/);
|
||
assert.doesNotMatch(api.userOutlinePanel.innerHTML, /无法恢复/);
|
||
}
|
||
|
||
for (const outline of [false, true]) {
|
||
const api = createPaginationHarness();
|
||
api.init(savedSnapshot());
|
||
const requestPage = () => outline ? api.requestOutlineHistoryPage() : api.requestOlderHistory();
|
||
const state = () => outline ? api.state().outline : api.state().history;
|
||
const active = () => outline ? api.state().outlineRequest : api.state().pageRequest;
|
||
api.connect(false);
|
||
requestPage();
|
||
api.connect(true, 0);
|
||
requestPage();
|
||
api.connect(true, 1, false);
|
||
requestPage();
|
||
api.connect();
|
||
api.select('其他会话');
|
||
requestPage();
|
||
assert.equal(api.requests.length, 0, '保留认证、连接状态和会话隔离门禁');
|
||
api.select('running-session');
|
||
requestPage();
|
||
assert.equal(api.requests.length, 1);
|
||
const failedRequest = active();
|
||
api.receive({ type: 'error', sessionId: '其他会话', requestId: failedRequest.requestId, message: '不得生效' });
|
||
assert.equal(state().loading, true, '其他会话错误不能取消本次加载');
|
||
api.receive({ type: 'error', sessionId: failedRequest.sessionId, requestId: failedRequest.requestId, message: '读取失败，请重试' });
|
||
assert.equal(active(), null);
|
||
assert.equal(state().loading, false);
|
||
assert.equal(state().cursor, 45, '失败后保留游标供重试');
|
||
if (outline) {
|
||
assert.match(api.userOutlinePanel.innerHTML, /data-outline-retry/);
|
||
assert.equal(api.userOutlineBtn.disabled, false);
|
||
requestPage();
|
||
} else {
|
||
assert.equal(historyButtons(api)[0].disabled, false);
|
||
assert.equal(historyButtons(api)[0].textContent, '重试');
|
||
historyButtons(api)[0].click();
|
||
}
|
||
assert.equal(api.requests.length, 2, '失败后能够重试已有记录');
|
||
assert.notEqual(active().requestId, failedRequest.requestId);
|
||
assert.equal(state().error, '');
|
||
assert.equal(state().loading, true);
|
||
}
|
||
|
||
for (const available of [false, true]) {
|
||
const api = createPaginationHarness();
|
||
api.init(savedSnapshot(available, 0));
|
||
api.requestOlderHistory();
|
||
api.requestOutlineHistoryPage();
|
||
assert.equal(api.requests.length, 0, 'cursor=0时两类请求都必须停止');
|
||
assert.equal(historyButtons(api).length, 0);
|
||
assert.equal(api.historyLoadMore.hidden, available, '完整历史读完隐藏控件；来源待核实则保留提示');
|
||
if (available) {
|
||
assert.doesNotMatch(api.userOutlinePanel.innerHTML, /待核实/);
|
||
} else {
|
||
assert.match(historyCopy(api), /更早的记录尚待核实/);
|
||
assert.match(api.userOutlinePanel.innerHTML, /更早的记录尚待核实/);
|
||
assert.doesNotMatch(historyCopy(api), /不完整|未保存|无法恢复/);
|
||
assert.doesNotMatch(api.userOutlinePanel.innerHTML, /不完整|未保存|无法恢复/);
|
||
}
|
||
}
|
||
|
||
{
|
||
const api = createPaginationHarness();
|
||
api.reset();
|
||
assert.equal(api.historyLoadMore.hidden, true, '收到历史元数据前不能误报更早记录待核实');
|
||
assert.doesNotMatch(api.userOutlinePanel.innerHTML, /待核实/);
|
||
assert.equal(api.userOutlineBtn.disabled, true, '没有已保存消息或待加载记录时保持空目录禁用');
|
||
api.init(savedSnapshot(true));
|
||
assert.equal(historyButtons(api)[0].disabled, false);
|
||
assert.doesNotMatch(historyCopy(api), /待核实/);
|
||
assert.doesNotMatch(api.userOutlinePanel.innerHTML, /待核实/);
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
assert.equal(api.getStableMessageKey({ role: 'assistant', turnId: 'turn-1', content: '初稿' }),
|
||
api.getStableMessageKey({ role: 'assistant', turnId: 'turn-1', content: '完成' }));
|
||
assert.notEqual(api.getStableMessageKey({ role: 'user', turnId: 'turn-1' }),
|
||
api.getStableMessageKey({ role: 'assistant', turnId: 'turn-1' }));
|
||
assert.equal(api.getStableMessageKey({ id: '已保存', turnId: 'turn-1' }), '已保存');
|
||
const before = message('reply');
|
||
assert.notEqual(api.getMessageRenderFingerprint(before), api.getMessageRenderFingerprint({ ...before, toolCalls: [{ result: '完成' }] }));
|
||
assert.notEqual(api.getMessageRenderFingerprint(before), api.getMessageRenderFingerprint({ ...before, crossConversation: { sourceTitle: '子对话' } }));
|
||
}
|
||
|
||
for (const cached of [false, true]) {
|
||
const api = createHarness();
|
||
const snapshot = { sessionId: 'history', messages: [message('user', 'user'), message('assistant')], historyBaseIndex: 7, historyTotal: 10 };
|
||
api.buffers.set('history', snapshot);
|
||
const merge = (messages, baseIndex) => cached
|
||
? api.mergeHistoryChunkIntoCachedSnapshot('history', messages, { baseIndex, total: 10, cursor: 3 })
|
||
: api.mergeHistoryChunkIntoSessionLoadSnapshot(snapshot, messages, { baseIndex, total: 10 });
|
||
merge([message('older')], 7);
|
||
assert.deepEqual(snapshot.messages.map((item) => item.id), ['user', 'older', 'assistant'], '相同下标不能吞掉不同 ID');
|
||
merge([message('older')], 7);
|
||
assert.equal(snapshot.messages.length, 3, '重复分页不能重复插入');
|
||
assert.equal(snapshot.historyMessagePositions.assistant, 8, '碰撞后的再次分页不能挤动原下标');
|
||
const updated = { ...message('assistant', 'assistant', '新正文'), toolCalls: [{ result: '工具结果' }], crossConversation: { reply: true, sourceTitle: '负责人' } };
|
||
merge([updated], 3);
|
||
assert.deepEqual(snapshot.messages.map((item) => item.id), ['assistant', 'user', 'older'], '同 ID 的新位置必须生效');
|
||
assert.deepEqual(snapshot.messages[0], updated, '同 ID 的正文、工具和来源必须更新');
|
||
assert.equal(snapshot.historyBaseIndex, 3);
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
api.renderMessages([message('user', 'user'), message('assistant'), message('assistant', 'assistant', '最终回复')], { immediate: true, baseIndex: 7 });
|
||
assert.deepEqual(api.ids(), ['user', 'assistant'], '初始渲染按稳定 ID 去重');
|
||
assert.equal(api.messagesDiv.children[1].message.content, '最终回复');
|
||
api.prependHistoryMessages([message('older')], { baseIndex: 7 });
|
||
assert.deepEqual(api.ids(), ['user', 'older', 'assistant'], '同下标的分页消息不得丢失');
|
||
api.prependHistoryMessages([message('older')], { baseIndex: 7 });
|
||
assert.equal(api.messagesDiv.children.length, 3);
|
||
const updated = { ...message('assistant', 'assistant', '最终回复'), toolCalls: [{ id: 'tool', result: '已更新' }], crossConversation: { reply: true, sourceTitle: '负责人' } };
|
||
const counts = api.updates();
|
||
api.prependHistoryMessages([updated], { baseIndex: 3 });
|
||
assert.deepEqual(api.ids(), ['assistant', 'user', 'older'], '同 ID 跨下标移动必须重排 DOM');
|
||
assert.deepEqual(api.messagesDiv.children[0].message, updated, '正文相同时也更新工具和来源');
|
||
assert.equal(api.messagesDiv.children[0].dataset.messageIndex, '3');
|
||
assert(api.updates().outlineUpdates > counts.outlineUpdates, '只更新消息也需要刷新目录');
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const initial = Array.from({ length: 35 }, (_, index) => message(`batch-${index}`));
|
||
api.renderMessages(initial);
|
||
const latest = { ...initial[3], content: '重连期间更新的内容', toolCalls: [{ result: '新结果' }] };
|
||
api.reconcileRenderedSessionMessages([latest], { baseIndex: 3 });
|
||
api.flushTimers();
|
||
assert.deepEqual(api.ids(), initial.map((item) => item.id), '延迟渲染与重连对账交错不能重复插入');
|
||
assert.equal(api.messagesDiv.children[3].message.content, latest.content, '延迟批次不能把更新恢复成旧内容');
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const user = message('question', 'user', '没参考其他的页面么，WMSA51 是你这么写的么？');
|
||
const architecture = message('architecture', 'assistant', '页面职责和流程边界需要返工');
|
||
const reply = { ...message('reply'), crossConversation: { reply: true, sourceTitle: '旧来源' } };
|
||
api.renderMessages([architecture, reply], { immediate: true, baseIndex: 20 });
|
||
const stream = new Element();
|
||
stream.id = 'streaming-msg';
|
||
stream.pendingText = '当前正在生成的消息';
|
||
api.messagesDiv.appendChild(stream);
|
||
const refreshedReply = { ...reply, crossConversation: { reply: true, sourceTitle: '子对话负责人' }, toolCalls: [{ result: '验收完成' }] };
|
||
const snapshot = { sessionId: 'running-session', messages: [architecture, reply], historyBaseIndex: 20, historyTotal: 23 };
|
||
api.buffers.set('running-session', snapshot);
|
||
const resume = {
|
||
type: 'resume_session_result', sessionId: 'running-session', isRunning: true,
|
||
historyBaseIndex: 20, historyTotal: 23, messages: [user, architecture, refreshedReply],
|
||
};
|
||
api.resume(resume);
|
||
api.resume(resume);
|
||
assert.deepEqual(api.ids(), ['question', 'architecture', 'reply', 'streaming-msg']);
|
||
assert.strictEqual(api.messagesDiv.children.at(-1), stream, '运行中重连必须保留原流式节点');
|
||
assert.equal(stream.pendingText, '当前正在生成的消息');
|
||
assert.equal(api.messagesDiv.children[2].message.crossConversation.sourceTitle, '子对话负责人');
|
||
const changed = { ...refreshedReply, content: '回传内容更新', toolCalls: [{ result: '新结果' }] };
|
||
api.resume({ ...resume, messages: [user, architecture, changed] });
|
||
assert.equal(api.messagesDiv.children[2].message.content, '回传内容更新', '同数量同 ID 的重连也必须更新');
|
||
assert.equal(snapshot.messages.find((item) => item.id === 'reply').toolCalls[0].result, '新结果');
|
||
assert.equal(api.messagesDiv.children[0].message.role, 'user');
|
||
assert.equal(api.messagesDiv.children[2].message.role, 'assistant');
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const question = message('question', 'user');
|
||
const completed = { ...message('turn-reply'), toolCalls: [{ id: 'tool', result: '最终结果' }] };
|
||
api.renderMessages([question], { immediate: true });
|
||
api.setCount(1);
|
||
api.resumeGenerating({ type: 'resume_generating', sessionId: 'running-session', assistantMessageId: completed.id, turnId: 'turn-1', text: '生成中的回复' });
|
||
const stream = api.messagesDiv.children.at(-1);
|
||
assert.equal(stream.dataset.messageKey, completed.id, '恢复流式状态必须绑定持久化助手 ID');
|
||
assert.equal(stream.dataset.turnId, 'turn-1');
|
||
api.done({ type: 'done', sessionId: 'running-session', assistantMessage: completed, assistantMessageIndex: 1 });
|
||
assert.deepEqual(api.ids(), ['question', 'turn-reply']);
|
||
assert.deepEqual(api.messagesDiv.children[1].message, completed, '完成事件必须采用规范化助手消息');
|
||
assert.equal(api.count(), 2);
|
||
api.done({ type: 'done', sessionId: 'running-session', assistantMessage: completed, assistantMessageIndex: 1 });
|
||
assert.deepEqual(api.ids(), ['question', 'turn-reply'], '重复完成事件不能重复增加助手');
|
||
assert.equal(api.count(), 2, '重复完成事件不能增加消息计数');
|
||
api.resume({ type: 'resume_session_result', sessionId: 'running-session', isRunning: false, messages: [question, completed], historyBaseIndex: 0, historyTotal: 2 });
|
||
assert.deepEqual(api.ids(), ['question', 'turn-reply'], '完成后的重连不得再次插入助手');
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const question = message('question', 'user');
|
||
const completed = message('turn-reply', 'assistant', '快照中的最终回复');
|
||
api.renderMessages([question, completed], { immediate: true });
|
||
api.setCount(2);
|
||
api.resumeGenerating({ type: 'resume_generating', sessionId: 'running-session', assistantMessageId: completed.id, turnId: 'turn-2', text: '仍在生成' });
|
||
const stream = api.messagesDiv.children.at(-1);
|
||
assert.deepEqual(api.ids(), ['question', 'streaming-msg'], '相同助手 ID 的历史气泡与 stream 只能显示一份');
|
||
api.resume({ type: 'resume_session_result', sessionId: 'running-session', isRunning: true, messages: [question, completed], historyBaseIndex: 0, historyTotal: 2 });
|
||
assert.deepEqual(api.ids(), ['question', 'streaming-msg'], '流式过程中重复快照不能再建立同 ID 历史气泡');
|
||
assert.strictEqual(api.messagesDiv.children.at(-1), stream, '对账仍须保留运行中的原节点');
|
||
api.resume({ type: 'resume_session_result', sessionId: 'running-session', isRunning: false, messages: [question, completed], historyBaseIndex: 0, historyTotal: 2 });
|
||
assert.deepEqual(api.ids(), ['question', 'turn-reply'], '停止运行的恢复结果须把 stream 转成同 ID 最终助手');
|
||
assert.equal(api.count(), 2);
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const completed = message('already-saved');
|
||
api.renderMessages([completed], { immediate: true });
|
||
api.setCount(1);
|
||
api.resumeGenerating({ type: 'resume_generating', sessionId: 'running-session', text: '尚未绑定 ID 的流式输出' });
|
||
assert.equal(api.messagesDiv.children.length, 2);
|
||
api.done({ type: 'done', sessionId: 'running-session', assistantMessage: { ...completed, content: '规范化最终回复' }, assistantMessageIndex: 0 });
|
||
assert.deepEqual(api.ids(), ['already-saved'], '完成事件需移除与已保存消息重复的 stream');
|
||
assert.equal(api.messagesDiv.children[0].message.content, '规范化最终回复');
|
||
assert.equal(api.count(), 1);
|
||
}
|
||
|
||
{
|
||
const api = createHarness();
|
||
const completed = message('without-stream');
|
||
api.done({ type: 'done', sessionId: 'running-session', assistantMessage: completed, assistantMessageIndex: 3 });
|
||
assert.deepEqual(api.ids(), ['without-stream'], '丢失流式节点时完成事件仍可补回最终消息');
|
||
assert.equal(api.count(), 4);
|
||
api.done({ type: 'done', sessionId: 'running-session', assistantMessage: { ...completed, content: '最终内容更新' }, assistantMessageIndex: 3 });
|
||
assert.equal(api.messagesDiv.children[0].message.content, '最终内容更新');
|
||
assert.equal(api.count(), 4);
|
||
}
|
||
|
||
console.log('前端历史单测通过：已保存历史分页、目录索引、来源提示、认证隔离与重试、稳定 ID、重连和流式去重');
|