mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-19 09:33:53 +00:00
591 lines
18 KiB
TypeScript
591 lines
18 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Qwen
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import { spawn } from 'node:child_process';
|
|
import { readFileSync, writeFileSync } from 'node:fs';
|
|
import { createInterface } from 'node:readline';
|
|
import { setTimeout as delay } from 'node:timers/promises';
|
|
import { describe, expect, it } from 'vitest';
|
|
import { TestRig } from './test-helper.js';
|
|
|
|
const REQUEST_TIMEOUT_MS = 60_000;
|
|
const INITIAL_PROMPT = 'Create a quick note (smoke test).';
|
|
const RESUME_PROMPT = 'Continue the note after reload.';
|
|
const LIST_SIZE = 5;
|
|
const IS_SANDBOX =
|
|
process.env['GEMINI_SANDBOX'] &&
|
|
process.env['GEMINI_SANDBOX']!.toLowerCase() !== 'false';
|
|
|
|
type PendingRequest = {
|
|
resolve: (value: unknown) => void;
|
|
reject: (reason: Error) => void;
|
|
timeout: NodeJS.Timeout;
|
|
};
|
|
|
|
type SessionUpdateNotification = {
|
|
sessionId?: string;
|
|
update?: {
|
|
sessionUpdate?: string;
|
|
availableCommands?: Array<{
|
|
name: string;
|
|
description: string;
|
|
input?: { hint: string } | null;
|
|
}>;
|
|
content?: {
|
|
type: string;
|
|
text?: string;
|
|
};
|
|
modeId?: string;
|
|
};
|
|
};
|
|
|
|
type PermissionRequest = {
|
|
id: number;
|
|
sessionId?: string;
|
|
toolCall?: {
|
|
toolCallId: string;
|
|
title: string;
|
|
kind: string;
|
|
status: string;
|
|
content?: Array<{
|
|
type: string;
|
|
text?: string;
|
|
path?: string;
|
|
oldText?: string;
|
|
newText?: string;
|
|
}>;
|
|
};
|
|
options?: Array<{
|
|
optionId: string;
|
|
name: string;
|
|
kind: string;
|
|
}>;
|
|
};
|
|
|
|
type PermissionHandler = (
|
|
request: PermissionRequest,
|
|
) => { optionId: string } | { outcome: 'cancelled' };
|
|
|
|
/**
|
|
* Sets up an ACP test environment with all necessary utilities.
|
|
*/
|
|
function setupAcpTest(
|
|
rig: TestRig,
|
|
options?: { permissionHandler?: PermissionHandler },
|
|
) {
|
|
const pending = new Map<number, PendingRequest>();
|
|
let nextRequestId = 1;
|
|
const sessionUpdates: SessionUpdateNotification[] = [];
|
|
const permissionRequests: PermissionRequest[] = [];
|
|
const stderr: string[] = [];
|
|
|
|
// Default permission handler: auto-approve all
|
|
const permissionHandler =
|
|
options?.permissionHandler ?? (() => ({ optionId: 'proceed_once' }));
|
|
|
|
const agent = spawn('node', [rig.bundlePath, '--experimental-acp'], {
|
|
cwd: rig.testDir!,
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
});
|
|
|
|
agent.stderr?.on('data', (chunk) => {
|
|
stderr.push(chunk.toString());
|
|
});
|
|
|
|
const rl = createInterface({ input: agent.stdout });
|
|
|
|
const send = (json: unknown) => {
|
|
agent.stdin.write(`${JSON.stringify(json)}\n`);
|
|
};
|
|
|
|
const sendResponse = (id: number, result: unknown) => {
|
|
send({ jsonrpc: '2.0', id, result });
|
|
};
|
|
|
|
const sendRequest = (method: string, params?: unknown) =>
|
|
new Promise<unknown>((resolve, reject) => {
|
|
const id = nextRequestId++;
|
|
const timeout = setTimeout(() => {
|
|
pending.delete(id);
|
|
reject(new Error(`Request ${id} (${method}) timed out`));
|
|
}, REQUEST_TIMEOUT_MS);
|
|
pending.set(id, { resolve, reject, timeout });
|
|
send({ jsonrpc: '2.0', id, method, params });
|
|
});
|
|
|
|
const handleResponse = (msg: {
|
|
id: number;
|
|
result?: unknown;
|
|
error?: { message?: string };
|
|
}) => {
|
|
const waiter = pending.get(msg.id);
|
|
if (!waiter) {
|
|
return;
|
|
}
|
|
clearTimeout(waiter.timeout);
|
|
pending.delete(msg.id);
|
|
if (msg.error) {
|
|
waiter.reject(new Error(msg.error.message ?? 'Unknown error'));
|
|
} else {
|
|
waiter.resolve(msg.result);
|
|
}
|
|
};
|
|
|
|
const handleMessage = (msg: {
|
|
id?: number;
|
|
method?: string;
|
|
params?: SessionUpdateNotification & {
|
|
path?: string;
|
|
content?: string;
|
|
sessionId?: string;
|
|
toolCall?: PermissionRequest['toolCall'];
|
|
options?: PermissionRequest['options'];
|
|
};
|
|
result?: unknown;
|
|
error?: { message?: string };
|
|
}) => {
|
|
if (typeof msg.id !== 'undefined' && ('result' in msg || 'error' in msg)) {
|
|
handleResponse(
|
|
msg as {
|
|
id: number;
|
|
result?: unknown;
|
|
error?: { message?: string };
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (msg.method === 'session/update') {
|
|
sessionUpdates.push({
|
|
sessionId: msg.params?.sessionId,
|
|
update: msg.params?.update,
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (
|
|
msg.method === 'session/request_permission' &&
|
|
typeof msg.id === 'number'
|
|
) {
|
|
// Track permission request
|
|
const permRequest: PermissionRequest = {
|
|
id: msg.id,
|
|
sessionId: msg.params?.sessionId,
|
|
toolCall: msg.params?.toolCall,
|
|
options: msg.params?.options,
|
|
};
|
|
permissionRequests.push(permRequest);
|
|
|
|
// Use custom handler or default
|
|
const response = permissionHandler(permRequest);
|
|
if ('outcome' in response) {
|
|
sendResponse(msg.id, { outcome: response });
|
|
} else {
|
|
sendResponse(msg.id, {
|
|
outcome: { optionId: response.optionId, outcome: 'selected' },
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (msg.method === 'fs/read_text_file' && typeof msg.id === 'number') {
|
|
try {
|
|
const content = readFileSync(msg.params?.path ?? '', 'utf8');
|
|
sendResponse(msg.id, { content });
|
|
} catch (e) {
|
|
sendResponse(msg.id, { content: `ERROR: ${(e as Error).message}` });
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (msg.method === 'fs/write_text_file' && typeof msg.id === 'number') {
|
|
try {
|
|
writeFileSync(
|
|
msg.params?.path ?? '',
|
|
msg.params?.content ?? '',
|
|
'utf8',
|
|
);
|
|
sendResponse(msg.id, null);
|
|
} catch (e) {
|
|
sendResponse(msg.id, { message: (e as Error).message });
|
|
}
|
|
}
|
|
};
|
|
|
|
rl.on('line', (line) => {
|
|
if (!line.trim()) return;
|
|
try {
|
|
const msg = JSON.parse(line);
|
|
handleMessage(msg);
|
|
} catch {
|
|
// Ignore non-JSON output from the agent.
|
|
}
|
|
});
|
|
|
|
const waitForExit = () =>
|
|
new Promise<void>((resolve) => {
|
|
if (agent.exitCode !== null || agent.signalCode) {
|
|
resolve();
|
|
return;
|
|
}
|
|
agent.once('exit', () => resolve());
|
|
});
|
|
|
|
const cleanup = async () => {
|
|
rl.close();
|
|
agent.kill();
|
|
pending.forEach(({ timeout }) => clearTimeout(timeout));
|
|
pending.clear();
|
|
await waitForExit();
|
|
};
|
|
|
|
return {
|
|
sendRequest,
|
|
sendResponse,
|
|
cleanup,
|
|
stderr,
|
|
sessionUpdates,
|
|
permissionRequests,
|
|
};
|
|
}
|
|
|
|
(IS_SANDBOX ? describe.skip : describe)('acp integration', () => {
|
|
it('creates, lists, loads, and resumes a session', async () => {
|
|
const rig = new TestRig();
|
|
rig.setup('acp load session');
|
|
|
|
const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
|
|
|
|
try {
|
|
const initResult = await sendRequest('initialize', {
|
|
protocolVersion: 1,
|
|
clientCapabilities: {
|
|
fs: { readTextFile: true, writeTextFile: true },
|
|
},
|
|
});
|
|
expect(initResult).toBeDefined();
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
expect((initResult as any).agentInfo.version).toBeDefined();
|
|
|
|
await sendRequest('authenticate', { methodId: 'openai' });
|
|
|
|
const newSession = (await sendRequest('session/new', {
|
|
cwd: rig.testDir!,
|
|
mcpServers: [],
|
|
})) as { sessionId: string };
|
|
expect(newSession.sessionId).toBeTruthy();
|
|
|
|
const promptResult = await sendRequest('session/prompt', {
|
|
sessionId: newSession.sessionId,
|
|
prompt: [{ type: 'text', text: INITIAL_PROMPT }],
|
|
});
|
|
expect(promptResult).toBeDefined();
|
|
|
|
await delay(500);
|
|
|
|
const listResult = (await sendRequest('session/list', {
|
|
cwd: rig.testDir!,
|
|
size: LIST_SIZE,
|
|
})) as { items?: Array<{ sessionId: string }> };
|
|
|
|
expect(Array.isArray(listResult.items)).toBe(true);
|
|
expect(listResult.items?.length ?? 0).toBeGreaterThan(0);
|
|
|
|
const sessionToLoad = listResult.items![0].sessionId;
|
|
await sendRequest('session/load', {
|
|
cwd: rig.testDir!,
|
|
sessionId: sessionToLoad,
|
|
mcpServers: [],
|
|
});
|
|
|
|
const resumeResult = await sendRequest('session/prompt', {
|
|
sessionId: sessionToLoad,
|
|
prompt: [{ type: 'text', text: RESUME_PROMPT }],
|
|
});
|
|
expect(resumeResult).toBeDefined();
|
|
|
|
const sessionsWithUpdates = sessionUpdates
|
|
.map((update) => update.sessionId)
|
|
.filter(Boolean);
|
|
expect(sessionsWithUpdates).toContain(sessionToLoad);
|
|
} catch (e) {
|
|
if (stderr.length) {
|
|
console.error('Agent stderr:', stderr.join(''));
|
|
}
|
|
throw e;
|
|
} finally {
|
|
await cleanup();
|
|
}
|
|
});
|
|
|
|
it('returns modes on initialize and allows setting approval mode', async () => {
|
|
const rig = new TestRig();
|
|
rig.setup('acp approval mode');
|
|
|
|
const { sendRequest, cleanup, stderr } = setupAcpTest(rig);
|
|
|
|
try {
|
|
// Test 1: Initialize and verify modes are returned
|
|
const initResult = (await sendRequest('initialize', {
|
|
protocolVersion: 1,
|
|
clientCapabilities: {
|
|
fs: { readTextFile: true, writeTextFile: true },
|
|
},
|
|
})) as {
|
|
protocolVersion: number;
|
|
modes: {
|
|
currentModeId: string;
|
|
availableModes: Array<{
|
|
id: string;
|
|
name: string;
|
|
description: string;
|
|
}>;
|
|
};
|
|
};
|
|
|
|
expect(initResult).toBeDefined();
|
|
expect(initResult.protocolVersion).toBe(1);
|
|
|
|
// Verify modes data is present
|
|
expect(initResult.modes).toBeDefined();
|
|
expect(initResult.modes.currentModeId).toBeDefined();
|
|
expect(Array.isArray(initResult.modes.availableModes)).toBe(true);
|
|
expect(initResult.modes.availableModes.length).toBeGreaterThan(0);
|
|
|
|
// Verify available modes have expected structure
|
|
const modeIds = initResult.modes.availableModes.map((m) => m.id);
|
|
expect(modeIds).toContain('default');
|
|
expect(modeIds).toContain('yolo');
|
|
expect(modeIds).toContain('auto-edit');
|
|
expect(modeIds).toContain('plan');
|
|
|
|
// Verify each mode has required fields
|
|
for (const mode of initResult.modes.availableModes) {
|
|
expect(mode.id).toBeTruthy();
|
|
expect(mode.name).toBeTruthy();
|
|
expect(mode.description).toBeTruthy();
|
|
}
|
|
|
|
// Test 2: Authenticate
|
|
await sendRequest('authenticate', { methodId: 'openai' });
|
|
|
|
// Test 3: Create a new session
|
|
const newSession = (await sendRequest('session/new', {
|
|
cwd: rig.testDir!,
|
|
mcpServers: [],
|
|
})) as { sessionId: string };
|
|
expect(newSession.sessionId).toBeTruthy();
|
|
|
|
// Test 4: Set approval mode to 'yolo'
|
|
const setModeResult = (await sendRequest('session/set_mode', {
|
|
sessionId: newSession.sessionId,
|
|
modeId: 'yolo',
|
|
})) as { modeId: string };
|
|
expect(setModeResult).toBeDefined();
|
|
expect(setModeResult.modeId).toBe('yolo');
|
|
|
|
// Test 5: Set approval mode to 'auto-edit'
|
|
const setModeResult2 = (await sendRequest('session/set_mode', {
|
|
sessionId: newSession.sessionId,
|
|
modeId: 'auto-edit',
|
|
})) as { modeId: string };
|
|
expect(setModeResult2).toBeDefined();
|
|
expect(setModeResult2.modeId).toBe('auto-edit');
|
|
|
|
// Test 6: Set approval mode back to 'default'
|
|
const setModeResult3 = (await sendRequest('session/set_mode', {
|
|
sessionId: newSession.sessionId,
|
|
modeId: 'default',
|
|
})) as { modeId: string };
|
|
expect(setModeResult3).toBeDefined();
|
|
expect(setModeResult3.modeId).toBe('default');
|
|
} catch (e) {
|
|
if (stderr.length) {
|
|
console.error('Agent stderr:', stderr.join(''));
|
|
}
|
|
throw e;
|
|
} finally {
|
|
await cleanup();
|
|
}
|
|
});
|
|
|
|
it('receives available_commands_update with slash commands after session creation', async () => {
|
|
const rig = new TestRig();
|
|
rig.setup('acp slash commands');
|
|
|
|
const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
|
|
|
|
try {
|
|
// Initialize
|
|
await sendRequest('initialize', {
|
|
protocolVersion: 1,
|
|
clientCapabilities: {
|
|
fs: { readTextFile: true, writeTextFile: true },
|
|
},
|
|
});
|
|
|
|
await sendRequest('authenticate', { methodId: 'openai' });
|
|
|
|
// Create a new session
|
|
const newSession = (await sendRequest('session/new', {
|
|
cwd: rig.testDir!,
|
|
mcpServers: [],
|
|
})) as { sessionId: string };
|
|
expect(newSession.sessionId).toBeTruthy();
|
|
|
|
// Wait for available_commands_update to be received
|
|
await delay(1000);
|
|
|
|
// Verify available_commands_update is received
|
|
const commandsUpdate = sessionUpdates.find(
|
|
(update) =>
|
|
update.update?.sessionUpdate === 'available_commands_update',
|
|
);
|
|
|
|
expect(commandsUpdate).toBeDefined();
|
|
expect(commandsUpdate?.update?.availableCommands).toBeDefined();
|
|
expect(Array.isArray(commandsUpdate?.update?.availableCommands)).toBe(
|
|
true,
|
|
);
|
|
|
|
// Verify that the 'init' command is present (the only allowed built-in command for ACP)
|
|
const initCommand = commandsUpdate?.update?.availableCommands?.find(
|
|
(cmd) => cmd.name === 'init',
|
|
);
|
|
expect(initCommand).toBeDefined();
|
|
expect(initCommand?.description).toBeTruthy();
|
|
|
|
// Note: We don't test /init execution here because it triggers a complex
|
|
// multi-step process (listing files, reading up to 10 files, generating QWEN.md)
|
|
// that can take 30-60+ seconds, exceeding the request timeout.
|
|
// The slash command execution path is tested via simpler prompts in other tests.
|
|
} catch (e) {
|
|
if (stderr.length) {
|
|
console.error('Agent stderr:', stderr.join(''));
|
|
}
|
|
throw e;
|
|
} finally {
|
|
await cleanup();
|
|
}
|
|
});
|
|
|
|
it('handles exit plan mode with permission request and mode update notification', async () => {
|
|
const rig = new TestRig();
|
|
rig.setup('acp exit plan mode');
|
|
|
|
// Track which permission requests we've seen
|
|
const planModeRequests: PermissionRequest[] = [];
|
|
|
|
const { sendRequest, cleanup, stderr, sessionUpdates, permissionRequests } =
|
|
setupAcpTest(rig, {
|
|
permissionHandler: (request) => {
|
|
// Track all permission requests for later verification
|
|
// Auto-approve exit plan mode requests with "proceed_always" to trigger auto-edit mode
|
|
if (request.toolCall?.kind === 'switch_mode') {
|
|
planModeRequests.push(request);
|
|
// Return proceed_always to switch to auto-edit mode
|
|
return { optionId: 'proceed_always' };
|
|
}
|
|
// Auto-approve all other requests
|
|
return { optionId: 'proceed_once' };
|
|
},
|
|
});
|
|
|
|
try {
|
|
// Initialize
|
|
await sendRequest('initialize', {
|
|
protocolVersion: 1,
|
|
clientCapabilities: {
|
|
fs: { readTextFile: true, writeTextFile: true },
|
|
},
|
|
});
|
|
|
|
await sendRequest('authenticate', { methodId: 'openai' });
|
|
|
|
// Create a new session
|
|
const newSession = (await sendRequest('session/new', {
|
|
cwd: rig.testDir!,
|
|
mcpServers: [],
|
|
})) as { sessionId: string };
|
|
expect(newSession.sessionId).toBeTruthy();
|
|
|
|
// Set mode to 'plan' to enable plan mode
|
|
const setModeResult = (await sendRequest('session/set_mode', {
|
|
sessionId: newSession.sessionId,
|
|
modeId: 'plan',
|
|
})) as { modeId: string };
|
|
expect(setModeResult.modeId).toBe('plan');
|
|
|
|
// Send a prompt that should trigger the LLM to call exit_plan_mode
|
|
// The prompt is designed to trigger planning behavior
|
|
const promptResult = await sendRequest('session/prompt', {
|
|
sessionId: newSession.sessionId,
|
|
prompt: [
|
|
{
|
|
type: 'text',
|
|
text: 'Create a simple hello world function in Python. Make a brief plan and when ready, use the exit_plan_mode tool to present it for approval.',
|
|
},
|
|
],
|
|
});
|
|
expect(promptResult).toBeDefined();
|
|
|
|
// Give time for all notifications to be processed
|
|
await delay(1000);
|
|
|
|
// Verify: If exit_plan_mode was called, we should have received:
|
|
// 1. A permission request with kind: "switch_mode"
|
|
// 2. A current_mode_update notification after approval
|
|
|
|
// Check for switch_mode permission requests
|
|
const switchModeRequests = permissionRequests.filter(
|
|
(req) => req.toolCall?.kind === 'switch_mode',
|
|
);
|
|
|
|
// Check for current_mode_update notifications
|
|
const modeUpdateNotifications = sessionUpdates.filter(
|
|
(update) => update.update?.sessionUpdate === 'current_mode_update',
|
|
);
|
|
|
|
// If the LLM called exit_plan_mode, verify the flow
|
|
if (switchModeRequests.length > 0) {
|
|
// Verify permission request structure
|
|
const permReq = switchModeRequests[0];
|
|
expect(permReq.toolCall).toBeDefined();
|
|
expect(permReq.toolCall?.kind).toBe('switch_mode');
|
|
expect(permReq.toolCall?.status).toBe('pending');
|
|
expect(permReq.options).toBeDefined();
|
|
expect(Array.isArray(permReq.options)).toBe(true);
|
|
|
|
// Verify options include appropriate choices
|
|
const optionKinds = permReq.options?.map((opt) => opt.kind) ?? [];
|
|
expect(optionKinds).toContain('allow_once');
|
|
expect(optionKinds).toContain('allow_always');
|
|
|
|
// After approval, should have received current_mode_update
|
|
expect(modeUpdateNotifications.length).toBeGreaterThan(0);
|
|
|
|
// Verify mode update structure
|
|
const modeUpdate = modeUpdateNotifications[0];
|
|
expect(modeUpdate.sessionId).toBe(newSession.sessionId);
|
|
expect(modeUpdate.update?.modeId).toBeDefined();
|
|
// Mode should be auto-edit since we approved with proceed_always
|
|
expect(modeUpdate.update?.modeId).toBe('auto-edit');
|
|
}
|
|
|
|
// Note: If the LLM didn't call exit_plan_mode, that's acceptable
|
|
// since LLM behavior is non-deterministic. The test setup and structure
|
|
// is verified regardless.
|
|
} catch (e) {
|
|
if (stderr.length) {
|
|
console.error('Agent stderr:', stderr.join(''));
|
|
}
|
|
throw e;
|
|
} finally {
|
|
await cleanup();
|
|
}
|
|
});
|
|
});
|