707 lines
38 KiB
TypeScript
707 lines
38 KiB
TypeScript
import assert from 'node:assert/strict'
|
||
import { testTerminalHostPlugin } from './test-terminal-host-plugin'
|
||
import { createServer } from 'node:http'
|
||
import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises'
|
||
import { tmpdir } from 'node:os'
|
||
import { join } from 'node:path'
|
||
import { pathToFileURL } from 'node:url'
|
||
import { build } from 'esbuild'
|
||
import type { ChatMessage, ToolCallRecord } from '../src/shared/types'
|
||
|
||
interface TimelineEntry {
|
||
kind: 'branch' | 'prompt'
|
||
sessionId: string
|
||
entryId?: string
|
||
text?: string
|
||
}
|
||
|
||
interface TestState {
|
||
userData: string
|
||
home: string
|
||
handlers: Map<string, (...args: unknown[]) => unknown>
|
||
dialogPaths: string[]
|
||
nativeMessages: Map<string, Array<{ entryId: string; text: string }>>
|
||
failBranchIds: Set<string>
|
||
timeline: TimelineEntry[]
|
||
pendingPrompts: Array<{ sessionId: string; complete: () => void }>
|
||
holdSessions: Set<string>
|
||
activePrompts: number
|
||
maxActivePrompts: number
|
||
nextNativeId: number
|
||
speechStatus: number
|
||
speechRequests: Array<{ path: string; authorization: string | undefined; contentType: string | undefined; body: string }>
|
||
events: unknown[]
|
||
}
|
||
|
||
interface TestBundle {
|
||
registerIpc(getWindow: () => unknown): void
|
||
disposeOmpKernels(): Promise<void>
|
||
sessions: {
|
||
appendMessage(sessionId: string, message: ChatMessage): Promise<void>
|
||
getMessages(sessionId: string): Promise<ChatMessage[]>
|
||
getPendingNativeBranch(sessionId: string): Promise<string | undefined>
|
||
setPendingNativeBranch(sessionId: string, entryId: string | undefined): Promise<void>
|
||
}
|
||
attachments: {
|
||
getAttachment(id: string): Promise<{ path?: string; name: string }>
|
||
}
|
||
}
|
||
|
||
const TEST_STATE_KEY = '__YCODE_CONVERSATION_IPC_REGRESSION__'
|
||
|
||
function wait(ms: number): Promise<void> {
|
||
return new Promise((resolve) => setTimeout(resolve, ms))
|
||
}
|
||
|
||
async function waitUntil(predicate: () => boolean | Promise<boolean>, message: string): Promise<void> {
|
||
for (let attempt = 0; attempt < 250; attempt++) {
|
||
if (await predicate()) return
|
||
await wait(10)
|
||
}
|
||
assert.fail(`Timed out: ${message}`)
|
||
}
|
||
|
||
async function waitForAssistant(
|
||
invoke: (channel: string, ...args: unknown[]) => Promise<unknown>,
|
||
sessionId: string,
|
||
predicate: (message: ChatMessage) => boolean = (message) => message.status === 'done'
|
||
): Promise<ChatMessage[]> {
|
||
for (let attempt = 0; attempt < 250; attempt++) {
|
||
const messages = await invoke('session:messages', sessionId) as ChatMessage[]
|
||
const last = messages.findLast((message) => message.role === 'assistant')
|
||
if (last && predicate(last)) return messages
|
||
await wait(10)
|
||
}
|
||
const messages = await invoke('session:messages', sessionId) as ChatMessage[]
|
||
assert.fail(`Timed out waiting for assistant state: ${JSON.stringify(messages.at(-1))}`)
|
||
}
|
||
|
||
function assistant(messages: ChatMessage[]): ChatMessage {
|
||
const found = messages.findLast((message) => message.role === 'assistant')
|
||
assert.ok(found, 'expected an assistant message')
|
||
return found
|
||
}
|
||
|
||
function invokeFor(state: TestState) {
|
||
return (channel: string, ...args: unknown[]): Promise<unknown> => {
|
||
const handler = state.handlers.get(channel)
|
||
if (!handler) throw new Error(`Missing IPC handler: ${channel}`)
|
||
return Promise.resolve().then(() => handler({}, ...args))
|
||
}
|
||
}
|
||
|
||
function message(id: string, role: 'user' | 'assistant', content: string, extras: Partial<ChatMessage> = {}): ChatMessage {
|
||
return { id, role, content, createdAt: Date.now(), status: 'done', ...extras }
|
||
}
|
||
|
||
function seedNativeHistory(state: TestState, sessionId: string, entries: Array<[string, string]>): void {
|
||
state.nativeMessages.set(sessionId, entries.map(([entryId, text]) => ({ entryId, text })))
|
||
}
|
||
|
||
function nativePath(userData: string, sessionId: string): string {
|
||
return join(userData, 'omp-sessions', `session-${encodeURIComponent(sessionId)}.jsonl`)
|
||
}
|
||
|
||
async function buildBundle(tempRoot: string, state: TestState, name: string): Promise<TestBundle> {
|
||
const ipcEntry = join(process.cwd(), 'src', 'main', 'ipc.ts')
|
||
const sessionsEntry = join(process.cwd(), 'src', 'main', 'sessions.ts')
|
||
const attachmentsEntry = join(process.cwd(), 'src', 'main', 'attachments.ts')
|
||
const outfile = join(tempRoot, `${name}.mjs`)
|
||
const stateKey = JSON.stringify(TEST_STATE_KEY)
|
||
await build({
|
||
stdin: {
|
||
contents: [
|
||
`export { registerIpc, disposeOmpKernels } from ${JSON.stringify(ipcEntry)};`,
|
||
`export * as sessions from ${JSON.stringify(sessionsEntry)};`,
|
||
`export * as attachments from ${JSON.stringify(attachmentsEntry)};`
|
||
].join('\n'),
|
||
resolveDir: process.cwd(),
|
||
sourcefile: `${name}.ts`,
|
||
loader: 'ts'
|
||
},
|
||
outfile,
|
||
bundle: true,
|
||
external: ['node-pty'],
|
||
platform: 'node',
|
||
format: 'esm',
|
||
banner: { js: `import { createRequire as createTestRequire } from 'node:module'; const require = createTestRequire(import.meta.url);` },
|
||
logLevel: 'silent',
|
||
plugins: [
|
||
testTerminalHostPlugin,
|
||
{
|
||
name: 'conversation-ipc-electron-and-omp-mocks',
|
||
setup(pluginBuild) {
|
||
pluginBuild.onResolve({ filter: /^electron$/ }, () => ({ path: 'electron', namespace: 'mock-electron' }))
|
||
pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-electron' }, () => ({
|
||
loader: 'js',
|
||
contents: `
|
||
const state = globalThis[${stateKey}];
|
||
export const app = {
|
||
getPath: (name) => name === 'userData' ? state.userData : name === 'home' ? state.home : state.userData,
|
||
getName: () => 'YCode', getVersion: () => '0.1.0'
|
||
};
|
||
export const safeStorage = {
|
||
isEncryptionAvailable: () => false,
|
||
encryptString: (value) => Buffer.from(value),
|
||
decryptString: (value) => value.toString()
|
||
};
|
||
export const ipcMain = { handle: (name, handler) => state.handlers.set(name, handler) };
|
||
export const dialog = {
|
||
showOpenDialog: async (...args) => ({ canceled: false, filePaths: state.dialogPaths.splice(0) }),
|
||
showSaveDialog: async () => ({ canceled: true, filePath: undefined })
|
||
};
|
||
export const shell = { openPath: async () => '' };
|
||
export class BrowserWindow {}
|
||
export class WebContentsView {}
|
||
`
|
||
}))
|
||
pluginBuild.onResolve({ filter: /^\.\/omp$/ }, () => ({ path: 'omp', namespace: 'mock-omp' }))
|
||
pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-omp' }, () => ({
|
||
loader: 'js',
|
||
contents: `
|
||
import { EventEmitter } from 'node:events';
|
||
import { basename } from 'node:path';
|
||
const state = globalThis[${stateKey}];
|
||
export class OmpKernel extends EventEmitter {
|
||
constructor(_exe, _workspace, _profile, sessionPath) {
|
||
super();
|
||
this.sessionId = decodeURIComponent(basename(sessionPath).replace(/^session-/, '').replace(/\\.jsonl$/, ''));
|
||
if (!state.nativeMessages.has(this.sessionId)) state.nativeMessages.set(this.sessionId, []);
|
||
}
|
||
setHostTools() { return Promise.resolve({ type: 'response', success: true, data: { toolNames: [] } }); }
|
||
send(command) {
|
||
if (command.type === 'get_branch_messages') {
|
||
return Promise.resolve({ type: 'response', success: true, data: { messages: [...(state.nativeMessages.get(this.sessionId) || [])] } });
|
||
}
|
||
if (command.type === 'branch') {
|
||
const entryId = String(command.entryId || '');
|
||
state.timeline.push({ kind: 'branch', sessionId: this.sessionId, entryId });
|
||
if (state.failBranchIds.has(entryId)) return Promise.resolve({ type: 'response', success: false, error: 'mock branch failure' });
|
||
const entries = state.nativeMessages.get(this.sessionId) || [];
|
||
const index = entries.findIndex((entry) => entry.entryId === entryId);
|
||
if (index < 0) return Promise.resolve({ type: 'response', success: false, error: 'Invalid entry ID for branching' });
|
||
state.nativeMessages.set(this.sessionId, entries.slice(0, index));
|
||
}
|
||
return Promise.resolve({ type: 'response', success: true, data: {} });
|
||
}
|
||
branch(entryId) { return this.send({ type: 'branch', entryId }); }
|
||
prompt(text) {
|
||
state.timeline.push({ kind: 'prompt', sessionId: this.sessionId, text });
|
||
const entryId = 'native-prompt-' + (++state.nextNativeId);
|
||
const entries = state.nativeMessages.get(this.sessionId) || [];
|
||
entries.push({ entryId, text });
|
||
state.nativeMessages.set(this.sessionId, entries);
|
||
state.activePrompts++;
|
||
state.maxActivePrompts = Math.max(state.maxActivePrompts, state.activePrompts);
|
||
const complete = () => {
|
||
state.activePrompts--;
|
||
this.emit('event', { type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: 'reply:' + text } });
|
||
this.emit('event', { type: 'agent_end', yielded: true });
|
||
};
|
||
if (state.holdSessions.has(this.sessionId)) state.pendingPrompts.push({ sessionId: this.sessionId, complete });
|
||
else setImmediate(complete);
|
||
return Promise.resolve({ type: 'response', success: true });
|
||
}
|
||
abort() {
|
||
setImmediate(() => this.emit('event', { type: 'prompt_result', status: 'aborted' }));
|
||
return Promise.resolve({ type: 'response', success: true });
|
||
}
|
||
respondToHostTool() { return Promise.resolve(); }
|
||
dispose() { return Promise.resolve(); }
|
||
}
|
||
export const detectOmpPath = () => 'mock-omp';
|
||
export const getOmpInfo = () => ({ available: true, exePath: 'mock-omp', profile: 'ycode', model: 'ycode/test' });
|
||
`
|
||
}))
|
||
pluginBuild.onResolve({ filter: /^\.\/agent\/loop$/ }, () => ({ path: 'agent-loop', namespace: 'mock-agent-loop' }))
|
||
pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-agent-loop' }, () => ({
|
||
loader: 'js',
|
||
contents: `export async function runTurn() { throw new Error('unexpected non-OMP fallback'); }`
|
||
}))
|
||
pluginBuild.onResolve({ filter: /^\.\/gateway$/ }, () => ({ path: 'gateway', namespace: 'mock-gateway' }))
|
||
pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-gateway' }, () => ({
|
||
loader: 'js', contents: 'export class Gateway { constructor() {} }'
|
||
}))
|
||
}
|
||
}
|
||
]
|
||
})
|
||
return await import(pathToFileURL(outfile).href) as TestBundle
|
||
}
|
||
|
||
function register(bundle: TestBundle, state: TestState): (channel: string, ...args: unknown[]) => Promise<unknown> {
|
||
state.handlers.clear()
|
||
bundle.registerIpc(() => ({
|
||
isDestroyed: () => false,
|
||
webContents: { isDestroyed: () => false, send: (_channel: string, event: unknown) => state.events.push(event) }
|
||
}))
|
||
return invokeFor(state)
|
||
}
|
||
|
||
async function testConcurrency(bundle: TestBundle, state: TestState, invoke: ReturnType<typeof invokeFor>): Promise<void> {
|
||
const first = await invoke('session:create', 'concurrent one') as { id: string }
|
||
const second = await invoke('session:create', 'concurrent two') as { id: string }
|
||
state.holdSessions.add(first.id)
|
||
state.holdSessions.add(second.id)
|
||
|
||
const firstSend = await invoke('chat:send', { sessionId: first.id, text: 'concurrent-first' }) as {
|
||
modelId?: string
|
||
modelName?: string
|
||
}
|
||
await assert.rejects(invoke('chat:send', { sessionId: first.id, text: 'must-not-append' }), /正在运行/)
|
||
await invoke('chat:send', { sessionId: second.id, text: 'concurrent-second' })
|
||
|
||
await waitUntil(() => state.pendingPrompts.filter((item) => item.sessionId === first.id || item.sessionId === second.id).length === 2,
|
||
'both sessions should reach OMP concurrently')
|
||
const firstMessages = await invoke('session:messages', first.id) as ChatMessage[]
|
||
assert.equal(firstSend.modelId, assistant(firstMessages).modelId,
|
||
'chat:send returns the frozen model ID used by the persisted assistant message')
|
||
assert.equal(firstSend.modelName, assistant(firstMessages).modelName,
|
||
'chat:send returns the frozen model name used by the persisted assistant message')
|
||
assert.deepEqual(firstMessages.filter((item) => item.role === 'user').map((item) => item.content), ['concurrent-first'],
|
||
'a duplicate same-session send must not append a second user message')
|
||
assert.ok(state.maxActivePrompts >= 2, 'different sessions should be able to run in parallel')
|
||
|
||
const held = state.pendingPrompts.splice(0)
|
||
state.holdSessions.clear()
|
||
held.forEach((item) => item.complete())
|
||
const doneFirst = await waitForAssistant(invoke, first.id)
|
||
const doneSecond = await waitForAssistant(invoke, second.id)
|
||
assert.equal(assistant(doneFirst).status, 'done')
|
||
assert.equal(assistant(doneSecond).status, 'done')
|
||
const metadata = (await invoke('session:list')) as Array<{ id: string; title: string }>
|
||
assert.equal(metadata.find((item) => item.id === first.id)?.title, 'concurrent-first', 'first send should set its title')
|
||
}
|
||
|
||
async function seedActionHistory(
|
||
bundle: TestBundle,
|
||
state: TestState,
|
||
action: 'edit' | 'resend' | 'regenerate'
|
||
): Promise<{ sessionId: string; targetUserId: string; targetAssistantId: string }> {
|
||
const invoke = invokeFor(state)
|
||
const session = await invoke('session:create', `action-${action}`) as { id: string }
|
||
const targetUserId = `${action}-user-target`
|
||
const targetAssistantId = `${action}-assistant-target`
|
||
const history = [
|
||
message(`${action}-user-before`, 'user', 'first prompt', { nativeEntryId: `${action}-native-before` }),
|
||
message(`${action}-assistant-before`, 'assistant', 'first reply'),
|
||
message(targetUserId, 'user', 'old prompt', { nativeEntryId: `${action}-native-target` }),
|
||
message(targetAssistantId, 'assistant', 'old reply')
|
||
]
|
||
for (const item of history) await bundle.sessions.appendMessage(session.id, item)
|
||
seedNativeHistory(state, session.id, [
|
||
[`${action}-native-before`, 'first prompt'],
|
||
[`${action}-native-target`, 'old prompt']
|
||
])
|
||
return { sessionId: session.id, targetUserId, targetAssistantId }
|
||
}
|
||
|
||
async function testActionBranch(
|
||
bundle: TestBundle,
|
||
state: TestState,
|
||
action: 'edit' | 'resend' | 'regenerate'
|
||
): Promise<void> {
|
||
const invoke = invokeFor(state)
|
||
const seeded = await seedActionHistory(bundle, state, action)
|
||
const timelineStart = state.timeline.length
|
||
const fromMessageId = action === 'regenerate' ? seeded.targetAssistantId : seeded.targetUserId
|
||
await invoke('chat:send', {
|
||
sessionId: seeded.sessionId,
|
||
text: `${action}-replacement`,
|
||
action,
|
||
fromMessageId
|
||
})
|
||
const messages = await waitForAssistant(invoke, seeded.sessionId)
|
||
const activity = state.timeline.slice(timelineStart).filter((item) => item.sessionId === seeded.sessionId)
|
||
const branchIndex = activity.findIndex((item) => item.kind === 'branch' && item.entryId === `${action}-native-target`)
|
||
const promptIndex = activity.findIndex((item) => item.kind === 'prompt' && item.text?.split(/\r?\n/, 1)[0] === `${action}-replacement`)
|
||
assert.ok(branchIndex >= 0 && promptIndex > branchIndex, `${action} must branch by native entryId before prompting`)
|
||
assert.equal(activity[promptIndex].text, [`${action}-replacement`, messages[2].capabilityContext].filter(Boolean).join('\n\n'),
|
||
'native prompt must include the exact persisted turn context without changing the user text')
|
||
assert.match(activity[promptIndex].text ?? '', /<ycode-agent-mode mode="craft">/, 'native prompt declares the frozen craft mode')
|
||
assert.equal(messages.length, 4, `${action} should keep the old prefix and replace the selected suffix`)
|
||
assert.deepEqual(messages.slice(0, 2).map((item) => item.content), ['first prompt', 'first reply'])
|
||
assert.equal(messages[2].content, `${action}-replacement`)
|
||
assert.ok(messages[2].nativeEntryId?.startsWith('native-prompt-'), 'new user message should receive the returned native entryId')
|
||
assert.equal(await bundle.sessions.getPendingNativeBranch(seeded.sessionId), undefined,
|
||
'successful native entry lookup should clear the pending branch marker')
|
||
|
||
const archiveDirectory = join(state.userData, 'session-branches', encodeURIComponent(seeded.sessionId))
|
||
const archiveFiles = await readdir(archiveDirectory)
|
||
assert.equal(archiveFiles.length, 1, `${action} should archive the replaced branch`)
|
||
const archive = JSON.parse(await readFile(join(archiveDirectory, archiveFiles[0]), 'utf8')) as {
|
||
reason: string
|
||
session: { messages: ChatMessage[] }
|
||
}
|
||
assert.equal(archive.reason, action)
|
||
assert.equal(archive.session.messages.length, 4, 'archive should preserve the full pre-action conversation')
|
||
}
|
||
|
||
async function testActionBranchFailure(bundle: TestBundle, state: TestState): Promise<void> {
|
||
const invoke = invokeFor(state)
|
||
const seeded = await seedActionHistory(bundle, state, 'edit')
|
||
const before = await bundle.sessions.getMessages(seeded.sessionId)
|
||
state.failBranchIds.add('edit-native-target')
|
||
await assert.rejects(invoke('chat:send', {
|
||
sessionId: seeded.sessionId,
|
||
text: 'must-not-append-on-branch-failure',
|
||
action: 'edit',
|
||
fromMessageId: seeded.targetUserId
|
||
}), /branch failure/)
|
||
state.failBranchIds.delete('edit-native-target')
|
||
assert.deepEqual(await bundle.sessions.getMessages(seeded.sessionId), before,
|
||
'failed native branching must not archive or append a replacement user message')
|
||
assert.equal(await bundle.sessions.getPendingNativeBranch(seeded.sessionId), undefined,
|
||
'failed action branch should restore the prior marker')
|
||
}
|
||
|
||
async function testInterruptedResend(bundle: TestBundle, state: TestState): Promise<void> {
|
||
const invoke = invokeFor(state)
|
||
for (const nativeAccepted of [false, true]) {
|
||
const session = await invoke('session:create', 'interrupted-resend') as { id: string }
|
||
await bundle.sessions.appendMessage(session.id, message('prefix-user', 'user', 'earlier', { nativeEntryId: 'prefix-native' }))
|
||
await bundle.sessions.appendMessage(session.id, message('prefix-assistant', 'assistant', 'earlier reply'))
|
||
await bundle.sessions.appendMessage(session.id, message('interrupted-user', 'user', 'interrupted prompt'))
|
||
await bundle.sessions.appendMessage(session.id, message('interrupted-assistant', 'assistant', 'partial', { status: 'cancelled', interrupted: true }))
|
||
seedNativeHistory(state, session.id, [['prefix-native', 'earlier'], ...(nativeAccepted ? [['unbound-native', 'interrupted prompt'] as [string, string]] : [])])
|
||
const start = state.timeline.length
|
||
await invoke('chat:send', { sessionId: session.id, text: 'interrupted prompt', action: 'resend', fromMessageId: 'interrupted-user' })
|
||
const result = await waitForAssistant(invoke, session.id)
|
||
assert.equal(result.length, 4)
|
||
assert.equal(result[2].content, 'interrupted prompt')
|
||
const branches = state.timeline.slice(start).filter((entry) => entry.kind === 'branch')
|
||
assert.equal(branches.length, nativeAccepted ? 1 : 0)
|
||
if (nativeAccepted) assert.equal(branches[0].entryId, 'unbound-native', 'recover the accepted native user without truncating its preceding context')
|
||
assert.ok(result[2].nativeEntryId?.startsWith('native-prompt-'))
|
||
}
|
||
}
|
||
|
||
function writeTool(id: string, path: string, oldContent: string | null, newContent: string): ToolCallRecord {
|
||
return {
|
||
id,
|
||
name: 'write_file',
|
||
args: { path },
|
||
argsRaw: JSON.stringify({ path }),
|
||
status: 'ok',
|
||
output: 'write complete',
|
||
result: { path, oldContent, newContent }
|
||
}
|
||
}
|
||
|
||
async function seedWriteHistory(
|
||
bundle: TestBundle,
|
||
state: TestState,
|
||
title: string,
|
||
path: string,
|
||
targetEntryId: string,
|
||
currentFile: string
|
||
): Promise<string> {
|
||
await writeFile(path, currentFile, 'utf8')
|
||
const session = await invokeFor(state)('session:create', title) as { id: string }
|
||
await bundle.sessions.appendMessage(session.id, message(`${title}-user`, 'user', 'write prompt', { nativeEntryId: targetEntryId }))
|
||
await bundle.sessions.appendMessage(session.id, message(`${title}-assistant`, 'assistant', 'write answer', {
|
||
tools: [writeTool(`${title}-write`, path, 'before', 'after')]
|
||
}))
|
||
seedNativeHistory(state, session.id, [[targetEntryId, 'write prompt']])
|
||
return session.id
|
||
}
|
||
|
||
async function testFeedbackAndRevert(bundle: TestBundle, state: TestState, workspace: string): Promise<{
|
||
markerSessionId: string
|
||
markerEntryId: string
|
||
}> {
|
||
const invoke = invokeFor(state)
|
||
const feedbackSession = await invoke('session:create', 'feedback') as { id: string }
|
||
const feedbackUser = message('feedback-user', 'user', 'feedback request')
|
||
const feedbackAssistant = message('feedback-assistant', 'assistant', 'feedback response')
|
||
await bundle.sessions.appendMessage(feedbackSession.id, feedbackUser)
|
||
await bundle.sessions.appendMessage(feedbackSession.id, feedbackAssistant)
|
||
await invoke('chat:feedback', feedbackSession.id, feedbackAssistant.id, 'like')
|
||
assert.equal((await bundle.sessions.getMessages(feedbackSession.id))[1].feedback, 'like')
|
||
await assert.rejects(invoke('chat:feedback', feedbackSession.id, feedbackUser.id, 'dislike'), /助手消息/)
|
||
await assert.rejects(invoke('chat:feedback', feedbackSession.id, 'missing', 'like'), /助手消息/)
|
||
await assert.rejects(invoke('chat:feedback', feedbackSession.id, feedbackAssistant.id, 'bad'), /反馈值无效/)
|
||
|
||
const conflictPath = join(workspace, 'conflict.txt')
|
||
const conflictId = await seedWriteHistory(bundle, state, 'conflict-revert', conflictPath, 'native-conflict-target', 'external edit')
|
||
const conflictBefore = await bundle.sessions.getMessages(conflictId)
|
||
await assert.rejects(invoke('chat:revert', conflictId, 'conflict-revert-user'), /外部修改/)
|
||
assert.equal(await readFile(conflictPath, 'utf8'), 'external edit', 'revert conflict must preserve the externally edited file')
|
||
assert.deepEqual(await bundle.sessions.getMessages(conflictId), conflictBefore, 'conflict should leave history intact')
|
||
assert.equal(await bundle.sessions.getPendingNativeBranch(conflictId), undefined)
|
||
|
||
const rejectedPath = join(workspace, 'branch-failure.txt')
|
||
const rejectedId = await seedWriteHistory(bundle, state, 'failed-revert', rejectedPath, 'native-failed-revert', 'after')
|
||
state.failBranchIds.add('native-failed-revert')
|
||
await assert.rejects(invoke('chat:revert', rejectedId, 'failed-revert-user'), /恢复失败/)
|
||
state.failBranchIds.delete('native-failed-revert')
|
||
assert.equal(await readFile(rejectedPath, 'utf8'), 'after', 'failed native branch must undo the file restore')
|
||
assert.equal((await bundle.sessions.getMessages(rejectedId)).length, 2, 'failed native branch must preserve history')
|
||
assert.equal(await bundle.sessions.getPendingNativeBranch(rejectedId), undefined)
|
||
|
||
const readOnlyId = await invoke('session:create', 'read-only-revert') as { id: string }
|
||
await bundle.sessions.appendMessage(readOnlyId.id, message('read-only-user', 'user', 'read only'))
|
||
await bundle.sessions.appendMessage(readOnlyId.id, message('read-only-assistant', 'assistant', 'read', {
|
||
tools: [{ id: 'read-tool', name: 'read_file', args: {}, argsRaw: '{}', status: 'ok' }]
|
||
}))
|
||
await assert.rejects(invoke('chat:revert', readOnlyId.id, 'read-only-user'), /没有可恢复/)
|
||
|
||
const unknownPath = join(workspace, 'unknown-write.txt')
|
||
await writeFile(unknownPath, 'after', 'utf8')
|
||
const unknownId = await invoke('session:create', 'unknown-write-revert') as { id: string }
|
||
await bundle.sessions.appendMessage(unknownId.id, message('unknown-write-user', 'user', 'unknown write', {
|
||
nativeEntryId: 'native-unknown-write'
|
||
}))
|
||
await bundle.sessions.appendMessage(unknownId.id, message('unknown-write-assistant', 'assistant', 'unknown', {
|
||
tools: [{
|
||
id: 'unknown-write-tool', name: 'delete_file', args: {}, argsRaw: '{}', status: 'ok',
|
||
result: { path: unknownPath, oldContent: 'before', newContent: 'after' }
|
||
}]
|
||
}))
|
||
await assert.rejects(invoke('chat:revert', unknownId.id, 'unknown-write-user'), /无法完整回滚/)
|
||
assert.equal(await readFile(unknownPath, 'utf8'), 'after', 'unrecognized writes must not be treated as reversible')
|
||
|
||
const markerPath = join(workspace, 'persist-revert.txt')
|
||
const markerSessionId = await seedWriteHistory(bundle, state, 'pending-revert', markerPath, 'native-revert-target', 'after')
|
||
await invoke('chat:revert', markerSessionId, 'pending-revert-user')
|
||
assert.equal(await readFile(markerPath, 'utf8'), 'before', 'known complete host write should be restored')
|
||
assert.deepEqual(await bundle.sessions.getMessages(markerSessionId), [], 'successful revert should truncate the active history prefix')
|
||
const markerEntryId = await bundle.sessions.getPendingNativeBranch(markerSessionId)
|
||
assert.equal(markerEntryId, 'native-revert-target', 'successful revert should persist a replay marker')
|
||
const revertArchiveDirectory = join(state.userData, 'session-branches', encodeURIComponent(markerSessionId))
|
||
const revertArchiveFiles = await readdir(revertArchiveDirectory)
|
||
assert.equal(revertArchiveFiles.length, 1, 'revert should archive its abandoned branch')
|
||
const revertArchive = JSON.parse(await readFile(join(revertArchiveDirectory, revertArchiveFiles[0]), 'utf8')) as {
|
||
reason: string
|
||
session: { messages: ChatMessage[] }
|
||
}
|
||
assert.equal(revertArchive.reason, 'revert')
|
||
assert.equal(revertArchive.session.messages.length, 2, 'revert archive should preserve the messages removed from the active history')
|
||
const stored = JSON.parse(await readFile(join(state.userData, 'sessions.json'), 'utf8')) as {
|
||
sessions: Array<{ id: string; pendingNativeBranchId?: string }>
|
||
}
|
||
assert.equal(stored.sessions.find((item) => item.id === markerSessionId)?.pendingNativeBranchId, markerEntryId,
|
||
'pending native branch marker should be present on disk')
|
||
return { markerSessionId, markerEntryId: markerEntryId! }
|
||
}
|
||
|
||
async function testAttachments(bundle: TestBundle, state: TestState, tempRoot: string): Promise<void> {
|
||
const invoke = invokeFor(state)
|
||
const pickedPath = join(tempRoot, 'picked.txt')
|
||
await writeFile(pickedPath, 'picked file content', 'utf8')
|
||
state.dialogPaths.push(pickedPath)
|
||
const picked = await invoke('attachments:pick') as Array<{ id: string; name: string; path?: string; size: number }>
|
||
assert.equal(picked.length, 1)
|
||
assert.equal(picked[0].name, 'picked.txt')
|
||
assert.equal(picked[0].size, Buffer.byteLength('picked file content'))
|
||
assert.ok(picked[0].path && (await readFile(picked[0].path, 'utf8')) === 'picked file content',
|
||
'picker should stage a real copy in user data')
|
||
|
||
const staged = await invoke('attachments:stage', {
|
||
name: '../safe-note.txt', mimeType: 'text/plain', dataBase64: Buffer.from('attachment body').toString('base64')
|
||
}) as { id: string; name: string; path?: string; size: number }
|
||
assert.equal(staged.name, 'safe-note.txt', 'staging should discard path components from the supplied filename')
|
||
assert.equal(staged.size, Buffer.byteLength('attachment body'))
|
||
assert.equal((await bundle.attachments.getAttachment(staged.id)).name, 'safe-note.txt')
|
||
assert.equal(await readFile(staged.path!, 'utf8'), 'attachment body')
|
||
await assert.rejects(invoke('attachments:stage', {
|
||
name: 'metadata.json', mimeType: 'text/plain', dataBase64: Buffer.from('no').toString('base64')
|
||
}), /文件名无效/)
|
||
|
||
const tamperedMetadata = join(state.userData, 'attachments', staged.id, 'metadata.json')
|
||
await writeFile(tamperedMetadata, JSON.stringify({ ...staged, path: join(tempRoot, 'outside.txt') }), 'utf8')
|
||
const pathChecked = await bundle.attachments.getAttachment(staged.id)
|
||
assert.equal(pathChecked.path, staged.path, 'attachment metadata path must be recomputed inside the staged directory')
|
||
assert.notEqual(pathChecked.path, join(tempRoot, 'outside.txt'))
|
||
await writeFile(tamperedMetadata, JSON.stringify({ ...staged, name: '../outside.txt', path: join(tempRoot, 'outside.txt') }), 'utf8')
|
||
await assert.rejects(bundle.attachments.getAttachment(staged.id), /元数据无效/)
|
||
const sendSession = await invoke('session:create', 'invalid-attachment') as { id: string }
|
||
await assert.rejects(invoke('chat:send', {
|
||
sessionId: sendSession.id, text: 'must not send', attachments: [{ ...staged, id: staged.id }]
|
||
}), /元数据无效/)
|
||
assert.deepEqual(await invoke('session:messages', sendSession.id), [], 'invalid attachment metadata must reject before appending')
|
||
|
||
const sendWithAttachment = await invoke('session:create', 'attachment-send') as { id: string }
|
||
await invoke('chat:send', { sessionId: sendWithAttachment.id, text: 'read attachment', attachments: [picked[0]] })
|
||
await waitForAssistant(invoke, sendWithAttachment.id)
|
||
const prompt = state.timeline.findLast((item) => item.kind === 'prompt' && item.sessionId === sendWithAttachment.id)
|
||
assert.ok(prompt?.text?.includes('附件 picked.txt:\npicked file content'), 'OMP prompt should receive staged file contents')
|
||
|
||
await assert.rejects(invoke('attachments:remove', picked[0].id), /已用于会话/)
|
||
assert.ok(await readFile(join(state.userData, 'attachments', picked[0].id, 'metadata.json'), 'utf8'),
|
||
'removing a committed attachment should leave the session source intact')
|
||
await invoke('attachments:remove', staged.id)
|
||
await assert.rejects(bundle.attachments.getAttachment(staged.id))
|
||
}
|
||
|
||
async function testSpeech(bundle: TestBundle, state: TestState): Promise<void> {
|
||
const server = createServer((request, response) => {
|
||
const chunks: Buffer[] = []
|
||
request.on('data', (chunk: Buffer) => chunks.push(Buffer.from(chunk)))
|
||
request.on('end', () => {
|
||
state.speechRequests.push({
|
||
path: request.url || '',
|
||
authorization: request.headers.authorization,
|
||
contentType: request.headers['content-type'],
|
||
body: Buffer.concat(chunks).toString('utf8')
|
||
})
|
||
response.writeHead(state.speechStatus, { 'content-type': 'application/json' })
|
||
response.end(state.speechStatus === 200 ? JSON.stringify({ text: 'recognized local audio' }) : JSON.stringify({ error: 'mock failure' }))
|
||
})
|
||
})
|
||
await new Promise<void>((resolve, reject) => {
|
||
server.once('error', reject)
|
||
server.listen(0, '127.0.0.1', resolve)
|
||
})
|
||
try {
|
||
const address = server.address()
|
||
assert.ok(address && typeof address === 'object')
|
||
const speechBaseUrl = `http://127.0.0.1:${address.port}`
|
||
const invoke = invokeFor(state)
|
||
await invoke('config:update', { speechBaseUrl, speechModel: 'local-test-model', apiKey: 'regression-only-key' })
|
||
const audioBase64 = Buffer.from('local fake wav bytes').toString('base64')
|
||
const result = await invoke('speech:transcribe', { audioBase64, mimeType: 'audio/wav' }) as { text: string }
|
||
assert.deepEqual(result, { text: 'recognized local audio' })
|
||
const request = state.speechRequests.at(-1)
|
||
assert.ok(request)
|
||
assert.equal(request.path, '/audio/transcriptions')
|
||
assert.equal(request.authorization, 'Bearer regression-only-key')
|
||
assert.ok(request.contentType?.includes('multipart/form-data; boundary='))
|
||
assert.ok(request.body.includes('name="model"') && request.body.includes('local-test-model'))
|
||
assert.ok(request.body.includes('filename="recording.wav"') && request.body.includes('local fake wav bytes'))
|
||
|
||
state.speechStatus = 503
|
||
await assert.rejects(invoke('speech:transcribe', { audioBase64, mimeType: 'audio/wav' }), /转写失败（503）/)
|
||
assert.equal(state.speechRequests.length, 2, 'both transcription requests should stay on the local server')
|
||
assert.ok(state.speechRequests.every((item) => item.path === '/audio/transcriptions'))
|
||
} finally {
|
||
await new Promise<void>((resolve) => server.close(() => resolve()))
|
||
}
|
||
}
|
||
|
||
async function testPendingReplay(
|
||
tempRoot: string,
|
||
bundle: TestBundle,
|
||
state: TestState,
|
||
markerSessionId: string,
|
||
markerEntryId: string
|
||
): Promise<TestBundle> {
|
||
// A real OMP cold start loads the old file leaf; branch alone was not persisted.
|
||
seedNativeHistory(state, markerSessionId, [[markerEntryId, 'write prompt']])
|
||
const restarted = await buildBundle(tempRoot, state, 'conversation-ipc-restarted')
|
||
const invoke = register(restarted, state)
|
||
const before = await restarted.sessions.getMessages(markerSessionId)
|
||
assert.deepEqual(before, [], 'restarted session should load the archived active prefix')
|
||
|
||
state.failBranchIds.add(markerEntryId)
|
||
await assert.rejects(invoke('chat:send', { sessionId: markerSessionId, text: 'blocked until branch succeeds' }), /恢复已保存的原生会话分支/)
|
||
state.failBranchIds.delete(markerEntryId)
|
||
assert.deepEqual(await restarted.sessions.getMessages(markerSessionId), before,
|
||
'failed pending branch replay must not append a user message')
|
||
assert.equal(await restarted.sessions.getPendingNativeBranch(markerSessionId), markerEntryId,
|
||
'failed pending branch replay must retain its marker for a retry')
|
||
|
||
const start = state.timeline.length
|
||
await invoke('chat:send', { sessionId: markerSessionId, text: 'replayed branch prompt' })
|
||
const messages = await waitForAssistant(invoke, markerSessionId)
|
||
const activity = state.timeline.slice(start).filter((item) => item.sessionId === markerSessionId)
|
||
const branch = activity.findIndex((item) => item.kind === 'branch' && item.entryId === markerEntryId)
|
||
const prompt = activity.findIndex((item) => item.kind === 'prompt' && item.text?.split(/\r?\n/, 1)[0] === 'replayed branch prompt')
|
||
assert.ok(branch >= 0 && prompt > branch, 'fresh OMP kernel must replay the saved branch marker before prompt')
|
||
assert.equal(activity[prompt].text, ['replayed branch prompt', messages[0].capabilityContext].filter(Boolean).join('\n\n'),
|
||
'restart prompt retains the exact current turn context')
|
||
assert.match(activity[prompt].text ?? '', /<ycode-agent-mode mode="craft">/, 'restart prompt declares current craft mode')
|
||
assert.equal(messages[0].content, 'replayed branch prompt', 'persisted user content stays exact across restart')
|
||
assert.ok(messages[0].nativeEntryId?.startsWith('native-prompt-'), 'restarted send should map its returned native entryId')
|
||
assert.equal(await restarted.sessions.getPendingNativeBranch(markerSessionId), undefined,
|
||
'new native user entry should clear the marker after successful lookup')
|
||
return restarted
|
||
}
|
||
|
||
async function testColdRecovery(tempRoot: string, state: TestState, bundle: TestBundle): Promise<void> {
|
||
const invoke = invokeFor(state)
|
||
const session = await invoke('session:create', 'cold streaming recovery') as { id: string }
|
||
await bundle.sessions.appendMessage(session.id, message('cold-user', 'user', 'incomplete request', { status: 'done' }))
|
||
await bundle.sessions.appendMessage(session.id, message('cold-assistant', 'assistant', 'partial', {
|
||
requestId: 'cold-run',
|
||
status: 'streaming',
|
||
parts: [{ type: 'text', text: 'partial' }, { type: 'tool', toolId: 'cold-tool' }],
|
||
tools: [{ id: 'cold-tool', name: 'shell', args: {}, argsRaw: '{}', status: 'running', output: 'partial tool output' }]
|
||
}))
|
||
|
||
const cold = await buildBundle(tempRoot, state, 'conversation-ipc-cold-recovery')
|
||
const messages = await cold.sessions.getMessages(session.id)
|
||
const recovered = assistant(messages)
|
||
assert.equal(recovered.status, 'cancelled')
|
||
assert.equal(recovered.interrupted, true)
|
||
assert.equal(recovered.tools?.[0].status, 'cancelled')
|
||
assert.equal(recovered.tools?.[0].output, 'partial tool output', 'cold recovery should retain running tool output')
|
||
const disk = JSON.parse(await readFile(join(state.userData, 'sessions.json'), 'utf8')) as {
|
||
sessions: Array<{ id: string; messages: ChatMessage[] }>
|
||
}
|
||
const diskRecovered = disk.sessions.find((item) => item.id === session.id)?.messages.at(-1)
|
||
assert.equal(diskRecovered?.status, 'cancelled', 'cold recovery should persist its terminal status')
|
||
assert.equal(diskRecovered?.tools?.[0].status, 'cancelled')
|
||
assert.equal(diskRecovered?.tools?.[0].output, 'partial tool output')
|
||
}
|
||
|
||
async function main(): Promise<void> {
|
||
const tempRoot = await mkdtemp(join(tmpdir(), 'ycode-conversation-ipc-'))
|
||
const state: TestState = {
|
||
userData: join(tempRoot, 'userData'),
|
||
home: join(tempRoot, 'home'),
|
||
handlers: new Map(),
|
||
dialogPaths: [],
|
||
nativeMessages: new Map(),
|
||
failBranchIds: new Set(),
|
||
timeline: [],
|
||
pendingPrompts: [],
|
||
holdSessions: new Set(),
|
||
activePrompts: 0,
|
||
maxActivePrompts: 0,
|
||
nextNativeId: 0,
|
||
speechStatus: 200,
|
||
speechRequests: [],
|
||
events: []
|
||
}
|
||
await mkdir(state.userData, { recursive: true })
|
||
await mkdir(state.home, { recursive: true })
|
||
|
||
const globals = globalThis as typeof globalThis & Record<string, unknown>
|
||
const previousState = globals[TEST_STATE_KEY]
|
||
globals[TEST_STATE_KEY] = state
|
||
const bundles: TestBundle[] = []
|
||
try {
|
||
const bundle = await buildBundle(tempRoot, state, 'conversation-ipc-primary')
|
||
bundles.push(bundle)
|
||
const invoke = register(bundle, state)
|
||
|
||
const workspace = join(tempRoot, 'workspace')
|
||
await mkdir(workspace, { recursive: true })
|
||
state.dialogPaths.push(workspace)
|
||
assert.deepEqual(await invoke('workspace:choose'), { root: workspace, changed: true })
|
||
|
||
await testConcurrency(bundle, state, invoke)
|
||
for (const action of ['edit', 'resend', 'regenerate'] as const) await testActionBranch(bundle, state, action)
|
||
await testActionBranchFailure(bundle, state)
|
||
await testInterruptedResend(bundle, state)
|
||
await testAttachments(bundle, state, tempRoot)
|
||
await testSpeech(bundle, state)
|
||
|
||
const { markerSessionId, markerEntryId } = await testFeedbackAndRevert(bundle, state, workspace)
|
||
const restarted = await testPendingReplay(tempRoot, bundle, state, markerSessionId, markerEntryId)
|
||
bundles.push(restarted)
|
||
await testColdRecovery(tempRoot, state, restarted)
|
||
console.log('conversation-ipc-regression: all checks passed')
|
||
} finally {
|
||
await Promise.all(bundles.map((bundle) => bundle.disposeOmpKernels().catch(() => undefined)))
|
||
globals[TEST_STATE_KEY] = previousState
|
||
await rm(tempRoot, { recursive: true, force: true })
|
||
}
|
||
}
|
||
|
||
void main().catch((error: unknown) => {
|
||
console.error('conversation-ipc-regression failed:', error)
|
||
process.exitCode = 1
|
||
})
|