340 lines
13 KiB
TypeScript
340 lines
13 KiB
TypeScript
import type { Page } from '@playwright/test';
|
|
import type { ElectronApplication } from 'playwright-core';
|
|
import { expect, getStableWindow, test } from './fixtures/electron';
|
|
|
|
type CapturedRequest = {
|
|
path: string;
|
|
method: string;
|
|
body?: Record<string, unknown>;
|
|
};
|
|
|
|
const SESSION_A_ID = 'ses_multichat_a';
|
|
const SESSION_B_ID = 'ses_multichat_b';
|
|
const REGISTRY_PENDING_ERROR = '项目 Agent 配置正在等待运行时重新加载，请在当前回复完成后手动重启运行时再试。';
|
|
|
|
async function disableRendererEventSource(page: Page): Promise<void> {
|
|
await page.addInitScript(() => {
|
|
class DisabledEventSource extends EventTarget {
|
|
static readonly CONNECTING = 0;
|
|
static readonly OPEN = 1;
|
|
static readonly CLOSED = 2;
|
|
readonly CONNECTING = DisabledEventSource.CONNECTING;
|
|
readonly OPEN = DisabledEventSource.OPEN;
|
|
readonly CLOSED = DisabledEventSource.CLOSED;
|
|
readonly url: string;
|
|
readonly withCredentials = false;
|
|
readyState = DisabledEventSource.OPEN;
|
|
onopen: ((event: Event) => void) | null = null;
|
|
onmessage: ((event: MessageEvent) => void) | null = null;
|
|
onerror: ((event: Event) => void) | null = null;
|
|
|
|
constructor(url: string) {
|
|
super();
|
|
this.url = url;
|
|
}
|
|
|
|
close(): void {
|
|
this.readyState = DisabledEventSource.CLOSED;
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(window, 'EventSource', {
|
|
configurable: true,
|
|
writable: true,
|
|
value: DisabledEventSource,
|
|
});
|
|
});
|
|
}
|
|
|
|
async function installMultichatHost(electronApp: ElectronApplication): Promise<void> {
|
|
await electronApp.evaluate(async () => {
|
|
const { ipcMain } = process.mainModule!.require('electron') as typeof import('electron');
|
|
const sessionAId = 'ses_multichat_a';
|
|
const sessionBId = 'ses_multichat_b';
|
|
const registryPendingError = '项目 Agent 配置正在等待运行时重新加载，请在当前回复完成后手动重启运行时再试。';
|
|
type MainState = {
|
|
captured: CapturedRequest[];
|
|
sessionABusy: boolean;
|
|
};
|
|
const mainGlobal = globalThis as typeof globalThis & {
|
|
__makeloreMultichatE2EState?: MainState;
|
|
};
|
|
const state: MainState = {
|
|
captured: [],
|
|
sessionABusy: false,
|
|
};
|
|
mainGlobal.__makeloreMultichatE2EState = state;
|
|
|
|
const now = '2026-08-17T10:00:00.000Z';
|
|
const project = {
|
|
id: 'prj_multichat_e2e',
|
|
path: 'D:/e2e/multichat',
|
|
name: 'multichat',
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
lastOpenedAt: now,
|
|
};
|
|
const agent = {
|
|
id: 'game-development',
|
|
avatarId: 'avatar-01',
|
|
roleName: '游戏开发',
|
|
name: '游戏开发',
|
|
builtIn: false,
|
|
enabled: true,
|
|
model: 'niancode-user-models/qwen3.7-plus',
|
|
skillIds: [],
|
|
responsibility: {
|
|
mission: '实现并验证项目功能。',
|
|
owns: [],
|
|
boundaries: [],
|
|
collaborators: [],
|
|
principles: [],
|
|
},
|
|
prompt: '',
|
|
archivedAt: null,
|
|
pinned: false,
|
|
};
|
|
const config = {
|
|
schemaVersion: 1,
|
|
projectType: 'custom',
|
|
initialized: true,
|
|
defaultModel: 'niancode-user-models/qwen3.7-plus',
|
|
agents: [agent],
|
|
knowledgeDirectory: 'knowledge',
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
};
|
|
const sessions = [
|
|
{ id: sessionAId, title: 'Session A', agent: agent.id, time: { updated: 2 } },
|
|
{ id: sessionBId, title: 'Session B', agent: agent.id, time: { updated: 1 } },
|
|
];
|
|
const conversationState = {
|
|
schemaVersion: 1,
|
|
sessions: [
|
|
{
|
|
sessionId: sessionAId,
|
|
agentId: agent.id,
|
|
archivedAt: null,
|
|
unreadCount: 0,
|
|
createdAt: now,
|
|
updatedAt: '2026-08-17T10:00:02.000Z',
|
|
},
|
|
{
|
|
sessionId: sessionBId,
|
|
agentId: agent.id,
|
|
archivedAt: null,
|
|
unreadCount: 0,
|
|
createdAt: now,
|
|
updatedAt: '2026-08-17T10:00:01.000Z',
|
|
},
|
|
],
|
|
updatedAt: '2026-08-17T10:00:02.000Z',
|
|
};
|
|
const runtimeStatus = {
|
|
state: 'running',
|
|
port: 4096,
|
|
url: 'http://127.0.0.1:4096',
|
|
};
|
|
const respond = (json: unknown, responseStatus = 200) => ({
|
|
ok: true,
|
|
data: {
|
|
status: responseStatus,
|
|
ok: responseStatus >= 200 && responseStatus < 300,
|
|
json,
|
|
},
|
|
});
|
|
|
|
ipcMain.removeHandler('hostapi:fetch');
|
|
ipcMain.handle('hostapi:fetch', async (
|
|
_event,
|
|
request: { path?: string; method?: string; body?: string | null },
|
|
) => {
|
|
const path = request.path ?? '';
|
|
const method = request.method ?? 'GET';
|
|
const body = request.body
|
|
? JSON.parse(request.body) as Record<string, unknown>
|
|
: undefined;
|
|
state.captured.push({ path, method, ...(body ? { body } : {}) });
|
|
|
|
if (path === '/api/opencode/status') return respond(runtimeStatus);
|
|
if (path === '/api/opencode/health') {
|
|
return respond({ ok: true, status: runtimeStatus });
|
|
}
|
|
if (path === '/api/opencode/projects' || path.startsWith('/api/opencode/projects?')) {
|
|
return respond({ projects: [project], activeProject: project });
|
|
}
|
|
if (path === '/api/opencode/projects/active' && method === 'GET') {
|
|
return respond({ projects: [project], activeProject: project });
|
|
}
|
|
if (path.startsWith('/api/opencode/projects/config?')) {
|
|
return respond({ status: 'valid', config, knowledgeFiles: [] });
|
|
}
|
|
if (path.startsWith('/api/opencode/projects/template?')) {
|
|
return respond({ status: 'missing' });
|
|
}
|
|
if (path.startsWith('/api/opencode/projects/conversations?')) {
|
|
return respond({ state: conversationState });
|
|
}
|
|
if (path === '/api/opencode/projects/conversations' && method === 'POST') {
|
|
return respond({ success: true, state: conversationState });
|
|
}
|
|
if (path === '/api/opencode/config-summary') {
|
|
return respond({
|
|
model: 'niancode-user-models/qwen3.7-plus',
|
|
smallModel: null,
|
|
providerIds: ['niancode-user-models'],
|
|
enabledProviderIds: ['niancode-user-models'],
|
|
providerCount: 1,
|
|
});
|
|
}
|
|
if (path === '/api/provider-accounts') {
|
|
return respond([{
|
|
id: 'niancode-user-models',
|
|
vendorId: 'custom',
|
|
label: 'Makelore Models',
|
|
authMode: 'api_key',
|
|
model: 'qwen3.7-plus',
|
|
enabled: true,
|
|
isDefault: true,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
}]);
|
|
}
|
|
if (path === '/api/provider-accounts/key-info') {
|
|
return respond([{ accountId: 'niancode-user-models', hasKey: true, keyMasked: 'sk-***' }]);
|
|
}
|
|
if (path === '/api/provider-vendors') return respond([]);
|
|
if (path === '/api/provider-accounts/default') {
|
|
return respond({ accountId: 'niancode-user-models' });
|
|
}
|
|
if (path === '/api/opencode/sessions') return respond({ sessions });
|
|
if (path === '/api/opencode/sessions/status') {
|
|
return respond({
|
|
statuses: {
|
|
[sessionAId]: { type: state.sessionABusy ? 'busy' : 'idle' },
|
|
[sessionBId]: { type: 'idle' },
|
|
},
|
|
});
|
|
}
|
|
if (
|
|
(path === `/api/opencode/sessions/${sessionAId}/messages`
|
|
|| path === `/api/opencode/sessions/${sessionBId}/messages`)
|
|
&& method === 'GET'
|
|
) {
|
|
return respond({ messages: [] });
|
|
}
|
|
if (path === `/api/opencode/sessions/${sessionAId}/messages` && method === 'POST') {
|
|
state.sessionABusy = true;
|
|
return respond({ success: true }, 202);
|
|
}
|
|
if (path === `/api/opencode/sessions/${sessionBId}/messages` && method === 'POST') {
|
|
return respond({
|
|
success: false,
|
|
error: registryPendingError,
|
|
code: 'OPENCODE_AGENT_REGISTRY_PENDING',
|
|
promptSent: false,
|
|
terminal: true,
|
|
retryable: false,
|
|
runtimeGeneration: 1,
|
|
}, 409);
|
|
}
|
|
if (path.endsWith('/todos')) return respond({ todos: [] });
|
|
if (path.endsWith('/diff')) return respond({ diffs: [] });
|
|
if (path === '/api/opencode/questions') return respond({ questions: [] });
|
|
if (path === '/api/opencode/permissions') return respond({ permissions: [] });
|
|
if (path === '/api/opencode/files/status') return respond({ files: [] });
|
|
if (path === '/api/opencode/commands') {
|
|
return respond({ commands: [], shareEnabled: true });
|
|
}
|
|
if (path === '/api/opencode/skills') return respond({ skills: [] });
|
|
throw new Error(`Unexpected hostapi request: ${method} ${path}`);
|
|
});
|
|
});
|
|
}
|
|
|
|
async function capturedRequests(electronApp: ElectronApplication): Promise<CapturedRequest[]> {
|
|
return await electronApp.evaluate(() => {
|
|
const mainGlobal = globalThis as typeof globalThis & {
|
|
__makeloreMultichatE2EState?: { captured: CapturedRequest[] };
|
|
};
|
|
return structuredClone(mainGlobal.__makeloreMultichatE2EState?.captured ?? []);
|
|
});
|
|
}
|
|
|
|
function sessionSelectionButton(page: Page, title: string) {
|
|
return page.getByRole('button', { name: `归档会话 ${title}`, exact: true })
|
|
.locator('..')
|
|
.getByRole('button')
|
|
.first();
|
|
}
|
|
|
|
async function submitComposer(page: Page, text: string): Promise<void> {
|
|
const composer = page.getByRole('textbox');
|
|
await composer.fill(text);
|
|
const sendButton = page.getByRole('button', { name: '发送', exact: true });
|
|
await expect(sendButton).toBeEnabled();
|
|
await sendButton.click();
|
|
}
|
|
|
|
test('keeps Session A running when Session B is terminally rejected by Agent preflight', async ({
|
|
launchElectronApp,
|
|
}) => {
|
|
const electronApp = await launchElectronApp({ skipSetup: true });
|
|
await installMultichatHost(electronApp);
|
|
|
|
let page = await getStableWindow(electronApp);
|
|
await disableRendererEventSource(page);
|
|
await page.reload();
|
|
page = await getStableWindow(electronApp);
|
|
await expect(page.getByTestId('ai-module-selection-page')).toBeVisible();
|
|
await page.getByTestId('ai-module-option-programming').click();
|
|
await page.getByTestId('project-agent-chat-game-development').click();
|
|
|
|
const sessionA = sessionSelectionButton(page, 'Session A');
|
|
const sessionB = sessionSelectionButton(page, 'Session B');
|
|
await expect(sessionA).toBeVisible();
|
|
await expect(sessionB).toBeVisible();
|
|
|
|
await sessionA.click();
|
|
await expect(sessionA).toHaveAttribute('aria-current', 'page');
|
|
await submitComposer(page, 'Keep Session A running');
|
|
await expect.poll(async () => [...new Set((await capturedRequests(electronApp))
|
|
.filter((request) => request.path.includes('/messages'))
|
|
.map((request) => `${request.method} ${request.path}`))])
|
|
.toContain(`POST /api/opencode/sessions/${SESSION_A_ID}/messages`);
|
|
const stopButton = page.getByRole('button', { name: '停止当前对话' });
|
|
await expect(stopButton).toBeEnabled();
|
|
await expect(stopButton.getByTestId('opencode-agent-response-loader')).toBeVisible();
|
|
|
|
await sessionB.click();
|
|
await submitComposer(page, 'Try Session B while A is busy');
|
|
const errorBanner = page.getByTestId('opencode-error-banner');
|
|
await expect(errorBanner).toContainText(REGISTRY_PENDING_ERROR);
|
|
await expect(page.getByRole('textbox')).toHaveValue('Try Session B while A is busy');
|
|
await expect(page.getByRole('button', { name: '停止当前对话' })).toHaveCount(0);
|
|
await expect(page.getByTestId('opencode-chat-layout')).toHaveAttribute('data-session-status', 'idle');
|
|
|
|
await expect.poll(async () => (await capturedRequests(electronApp)).map(
|
|
(request) => `${request.method} ${request.path}`,
|
|
)).toContain(`POST /api/opencode/sessions/${SESSION_B_ID}/messages`);
|
|
|
|
// A rejected preflight deliberately keeps B's draft. Clear it so A's busy
|
|
// composer projects the stop control and its response loader.
|
|
await page.getByRole('textbox').fill('');
|
|
await sessionA.click();
|
|
await expect(errorBanner).toHaveCount(0);
|
|
await expect(page.getByTestId('opencode-chat-layout')).toHaveAttribute('data-session-status', 'busy');
|
|
await expect(page.getByRole('button', { name: '停止当前对话' })).toBeEnabled();
|
|
await expect(page.getByTestId('opencode-agent-response-loader')).toBeVisible();
|
|
|
|
await sessionB.click();
|
|
await expect(errorBanner).toContainText(REGISTRY_PENDING_ERROR);
|
|
await expect(page.getByTestId('opencode-chat-layout')).toHaveAttribute('data-session-status', 'idle');
|
|
|
|
const promptPosts = (await capturedRequests(electronApp)).filter((request) => (
|
|
request.method === 'POST' && request.path.endsWith('/messages')
|
|
));
|
|
expect(promptPosts.filter((request) => request.path.includes(SESSION_A_ID))).toHaveLength(1);
|
|
expect(promptPosts.filter((request) => request.path.includes(SESSION_B_ID))).toHaveLength(1);
|
|
});
|