@axhub/genie 0.2.5 → 0.2.7

package/server/acp-runtime/client.test.js

@@ -0,0 +1,688 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { AcpClient, normalizeTerminalCommandForSpawn, splitCommandLine } from './client.js';
+
+function createWriter() {
+  const messages = [];
+  return {
+    messages,
+    send(payload) {
+      messages.push(payload);
+    },
+    setSessionId() {},
+    getSessionId() {
+      return null;
+    }
+  };
+}
+
+function getConversationEvents(writer) {
+  return writer.messages
+    .filter((payload) => payload.type === 'conversation-event')
+    .map((payload) => payload.event);
+}
+
+test('splitCommandLine keeps quoted arguments together', () => {
+  const parsed = splitCommandLine('npx -y "pkg with spaces" --flag=\'value one\'');
+  assert.equal(parsed.command, 'npx');
+  assert.deepEqual(parsed.args, ['-y', 'pkg with spaces', '--flag=value one']);
+});
+
+test('normalizeTerminalCommandForSpawn disables zsh nomatch for inline commands', () => {
+  const normalized = normalizeTerminalCommandForSpawn('/bin/zsh', ['-lc', 'curl -sS https://wttr.in/Guangzhou?format=3']);
+  assert.equal(normalized.command, '/bin/zsh');
+  assert.deepEqual(normalized.args, ['-lc', 'setopt no_nomatch; curl -sS https://wttr.in/Guangzhou?format=3']);
+});
+
+test('normalizeTerminalCommandForSpawn leaves non-zsh commands unchanged', () => {
+  const normalized = normalizeTerminalCommandForSpawn('/bin/bash', ['-lc', 'echo hello']);
+  assert.equal(normalized.command, '/bin/bash');
+  assert.deepEqual(normalized.args, ['-lc', 'echo hello']);
+});
+
+test('AcpClient streams assistant chunks into conversation events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-5';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-5',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'text',
+        text: 'Hello ACP'
+      }
+    }
+  });
+
+  client.flushOpenTextStreams('2026-03-30T12:00:00.000Z');
+  client.resetTurnState();
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-5',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'text',
+        text: 'Second turn'
+      }
+    }
+  });
+
+  client.flushOpenTextStreams('2026-03-30T12:00:01.000Z');
+
+  const events = getConversationEvents(writer);
+  const kinds = events.map((event) => event.kind);
+  const assistantStartEvents = events.filter((event) => event.kind === 'assistant_text_start');
+
+  assert.deepEqual(kinds, [
+    'assistant_text_start',
+    'assistant_text_delta',
+    'assistant_text_end',
+    'assistant_text_start',
+    'assistant_text_delta',
+    'assistant_text_end'
+  ]);
+  assert.equal(assistantStartEvents.length, 2);
+  assert.notEqual(assistantStartEvents[0].payload.messageId, assistantStartEvents[1].payload.messageId);
+});
+
+test('AcpClient maps reasoning chunks and end_turn into reasoning events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-reasoning';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-reasoning',
+    update: {
+      sessionUpdate: 'agent_thought_chunk',
+      content: {
+        type: 'text',
+        text: 'Thinking...'
+      }
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-reasoning',
+    update: {
+      sessionUpdate: 'end_turn'
+    }
+  });
+
+  const events = getConversationEvents(writer);
+  assert.deepEqual(
+    events.map((event) => event.kind),
+    ['reasoning_start', 'reasoning_delta', 'reasoning_end']
+  );
+});
+
+test('AcpClient maps tool_call updates into tool lifecycle events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-tool';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool',
+    update: {
+      sessionUpdate: 'tool_call',
+      toolCallId: 'tool-123',
+      title: 'Read file',
+      kind: 'read',
+      status: 'in_progress',
+      rawInput: { path: 'README.md' },
+      locations: [{ path: 'README.md', line: 1 }]
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool',
+    update: {
+      sessionUpdate: 'tool_call_update',
+      toolCallId: 'tool-123',
+      title: 'Read file',
+      kind: 'read',
+      status: 'completed',
+      rawInput: { path: 'README.md' },
+      rawOutput: 'file contents',
+      content: [
+        {
+          type: 'content',
+          content: {
+            type: 'text',
+            text: 'Opened README.md'
+          }
+        }
+      ]
+    }
+  });
+
+  const events = getConversationEvents(writer);
+  assert.deepEqual(
+    events.map((event) => event.kind),
+    ['tool_call_start', 'tool_call_input', 'tool_call_input', 'tool_call_end', 'tool_result']
+  );
+  assert.equal(events[4].payload.content, 'file contents');
+  assert.equal(events[0].payload.kind, 'read');
+  assert.equal(events[1].payload.locations[0].path, 'README.md');
+  assert.equal(events[4].payload.contentBlocks[0].type, 'content');
+});
+
+test('AcpClient splits assistant text around tool calls within the same turn', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-tool-boundary';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool-boundary',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'text',
+        text: 'First, I will inspect the file.'
+      }
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool-boundary',
+    update: {
+      sessionUpdate: 'tool_call',
+      toolCallId: 'tool-boundary-1',
+      title: 'Read file',
+      kind: 'read',
+      status: 'in_progress',
+      rawInput: { path: 'README.md' }
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool-boundary',
+    update: {
+      sessionUpdate: 'tool_call_update',
+      toolCallId: 'tool-boundary-1',
+      title: 'Read file',
+      kind: 'read',
+      status: 'completed',
+      rawInput: { path: 'README.md' },
+      rawOutput: 'done'
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-tool-boundary',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'text',
+        text: 'Here is what I found.'
+      }
+    }
+  });
+
+  client.flushOpenTextStreams('2026-03-30T12:00:03.000Z');
+
+  const events = getConversationEvents(writer);
+  const assistantStarts = events.filter((event) => event.kind === 'assistant_text_start');
+  const assistantEnds = events.filter((event) => event.kind === 'assistant_text_end');
+
+  assert.deepEqual(
+    events.map((event) => event.kind),
+    [
+      'assistant_text_start',
+      'assistant_text_delta',
+      'assistant_text_end',
+      'tool_call_start',
+      'tool_call_input',
+      'tool_call_input',
+      'tool_call_end',
+      'tool_result',
+      'assistant_text_start',
+      'assistant_text_delta',
+      'assistant_text_end'
+    ]
+  );
+  assert.equal(assistantStarts.length, 2);
+  assert.equal(assistantEnds.length, 2);
+  assert.notEqual(assistantStarts[0].payload.messageId, assistantStarts[1].payload.messageId);
+});
+
+test('AcpClient waits for explicit permission decisions in default mode', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd(),
+    permissionMode: 'default'
+  });
+
+  client.sessionId = 'session-6';
+
+  const permissionPromise = client.handleRequestPermission({
+    sessionId: 'session-6',
+    toolCall: {
+      toolCallId: 'tool-1',
+      title: 'Write file',
+      kind: 'edit',
+      rawInput: {
+        path: 'README.md'
+      }
+    },
+    options: [
+      {
+        optionId: 'allow-once',
+        kind: 'allow_once',
+        name: 'Allow once'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  const requestPayload = writer.messages.find((payload) => payload.type === 'conversation-event' && payload.event.kind === 'approval_request');
+  assert.ok(requestPayload);
+
+  const requestId = requestPayload.event.payload.requestId;
+  assert.ok(AcpClient.resolvePermissionRequest(requestId, { allow: true }));
+
+  const response = await permissionPromise;
+  assert.equal(response.outcome.outcome, 'selected');
+  assert.equal(response.outcome.optionId, 'allow-once');
+
+  const resolutionPayload = writer.messages.find((payload) => payload.type === 'conversation-event' && payload.event.kind === 'approval_resolved');
+  assert.ok(resolutionPayload);
+  assert.equal(resolutionPayload.event.payload.status, 'approved');
+});
+
+test('AcpClient accepts explicit ACP option selections and emits rich permission payload', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd(),
+    permissionMode: 'default'
+  });
+
+  client.sessionId = 'session-6b';
+
+  const permissionPromise = client.handleRequestPermission({
+    sessionId: 'session-6b',
+    toolCall: {
+      toolCallId: 'tool-3',
+      title: 'Edit file',
+      kind: 'edit',
+      rawInput: {
+        path: 'README.md'
+      },
+      locations: [{ path: 'README.md', line: 9 }]
+    },
+    options: [
+      {
+        optionId: 'allow-always',
+        kind: 'allow_always',
+        name: 'Always allow'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  const requestPayload = writer.messages.find((payload) => payload.type === 'conversation-event' && payload.event.kind === 'approval_request');
+  assert.ok(requestPayload);
+  assert.equal(requestPayload.event.payload.toolCall.kind, 'edit');
+  assert.equal(requestPayload.event.payload.options[0].optionId, 'allow-always');
+
+  assert.ok(AcpClient.resolvePermissionRequest(requestPayload.event.payload.requestId, {
+    outcome: {
+      outcome: 'selected',
+      optionId: 'allow-always'
+    }
+  }));
+
+  const response = await permissionPromise;
+  assert.equal(response.outcome.outcome, 'selected');
+  assert.equal(response.outcome.optionId, 'allow-always');
+});
+
+test('AcpClient maps plan updates into conversation events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-plan';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-plan',
+    update: {
+      sessionUpdate: 'plan',
+      entries: [
+        { content: 'Inspect adapter', status: 'completed', priority: 'medium' },
+        { content: 'Render plan UI', status: 'in_progress', priority: 'high' }
+      ]
+    }
+  });
+
+  const events = getConversationEvents(writer);
+  assert.equal(events.length, 1);
+  assert.equal(events[0].kind, 'plan_update');
+  assert.equal(events[0].payload.entries.length, 2);
+  assert.equal(events[0].payload.entries[1].priority, 'high');
+});
+
+test('AcpClient maps mode and available commands updates into conversation events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-mode';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-mode',
+    update: {
+      sessionUpdate: 'current_mode_update',
+      currentModeId: 'code'
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-mode',
+    update: {
+      sessionUpdate: 'available_commands_update',
+      availableCommands: [
+        {
+          name: 'create_plan',
+          description: 'Create a plan'
+        }
+      ]
+    }
+  });
+
+  const events = getConversationEvents(writer);
+  assert.equal(events[0].kind, 'mode_update');
+  assert.equal(events[0].payload.currentModeId, 'code');
+  assert.equal(events[1].kind, 'available_commands_update');
+  assert.equal(events[1].payload.availableCommands[0].name, 'create_plan');
+});
+
+test('AcpClient maps non-text assistant chunks into content block events', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-content-blocks';
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-content-blocks',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'resource_link',
+        uri: '/tmp/spec.md',
+        name: 'spec.md'
+      }
+    }
+  });
+
+  await client.handleSessionUpdate({
+    sessionId: 'session-content-blocks',
+    update: {
+      sessionUpdate: 'agent_message_chunk',
+      content: {
+        type: 'text',
+        text: 'See the attached spec.'
+      }
+    }
+  });
+
+  client.flushOpenTextStreams('2026-03-30T12:00:02.000Z');
+
+  const events = getConversationEvents(writer);
+  assert.equal(events[0].kind, 'assistant_content_block');
+  assert.equal(events[0].payload.contentBlock.type, 'resource_link');
+  assert.equal(events[1].kind, 'assistant_text_start');
+  assert.equal(events[1].payload.messageId, events[0].payload.messageId);
+  assert.equal(events[2].kind, 'assistant_text_delta');
+});
+
+test('AcpClient auto-approves editable tools in acceptEdits mode', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd(),
+    permissionMode: 'acceptEdits'
+  });
+
+  client.sessionId = 'session-7';
+
+  const response = await client.handleRequestPermission({
+    sessionId: 'session-7',
+    toolCall: {
+      toolCallId: 'tool-2',
+      title: 'Edit file',
+      kind: 'edit'
+    },
+    options: [
+      {
+        optionId: 'allow-once',
+        kind: 'allow_once',
+        name: 'Allow once'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  assert.equal(response.outcome.outcome, 'selected');
+  assert.equal(response.outcome.optionId, 'allow-once');
+  assert.equal(writer.messages.length, 0);
+});
+
+test('AcpClient auto-approves all tools in bypassPermissions mode', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd(),
+    permissionMode: 'bypassPermissions'
+  });
+
+  client.sessionId = 'session-8';
+
+  const response = await client.handleRequestPermission({
+    sessionId: 'session-8',
+    toolCall: {
+      toolCallId: 'tool-3',
+      title: 'Run shell command',
+      kind: 'execute'
+    },
+    options: [
+      {
+        optionId: 'allow-once',
+        kind: 'allow_once',
+        name: 'Allow once'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  assert.equal(response.outcome.outcome, 'selected');
+  assert.equal(response.outcome.optionId, 'allow-once');
+  assert.equal(writer.messages.length, 0);
+});
+
+test('AcpClient plan mode rejects non-read tools and allows read-like tools', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd(),
+    permissionMode: 'plan'
+  });
+
+  client.sessionId = 'session-9';
+
+  const denied = await client.handleRequestPermission({
+    sessionId: 'session-9',
+    toolCall: {
+      toolCallId: 'tool-4',
+      title: 'Edit file',
+      kind: 'edit'
+    },
+    options: [
+      {
+        optionId: 'allow-once',
+        kind: 'allow_once',
+        name: 'Allow once'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  const allowed = await client.handleRequestPermission({
+    sessionId: 'session-9',
+    toolCall: {
+      toolCallId: 'tool-5',
+      title: 'Read file',
+      kind: 'read'
+    },
+    options: [
+      {
+        optionId: 'allow-once',
+        kind: 'allow_once',
+        name: 'Allow once'
+      },
+      {
+        optionId: 'reject-once',
+        kind: 'reject_once',
+        name: 'Reject once'
+      }
+    ]
+  });
+
+  assert.equal(denied.outcome.outcome, 'selected');
+  assert.equal(denied.outcome.optionId, 'reject-once');
+  assert.equal(allowed.outcome.outcome, 'selected');
+  assert.equal(allowed.outcome.optionId, 'allow-once');
+  assert.equal(writer.messages.length, 0);
+});
+
+test('AcpClient fails Gemini prompts quickly when stderr reports rate limiting', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'gemini',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-gemini-rate-limit';
+  client.connection = {
+    prompt: () => new Promise(() => {})
+  };
+
+  const promptPromise = client.sendPrompt('Reply with exactly GEMINI_OK.');
+  client.handleAgentDiagnostic('Attempt 1 failed with status 429. reason: rateLimitExceeded. status: RESOURCE_EXHAUSTED');
+
+  await assert.rejects(
+    promptPromise,
+    /rate limited \(429 RESOURCE_EXHAUSTED\)/i
+  );
+
+  const conversationEvents = getConversationEvents(writer);
+  const stateChange = conversationEvents.find((event) => event.kind === 'session_state_changed' && event.payload?.state === 'errored');
+  const statusPayloads = writer.messages.filter((payload) => payload.type === 'session-status');
+  const rawErrorPayload = writer.messages.find((payload) => payload.type === 'error');
+
+  assert.ok(stateChange);
+  assert.equal(
+    rawErrorPayload?.error,
+    'Gemini request failed because the logged-in account is currently rate limited (429 RESOURCE_EXHAUSTED). Please wait and try again later.'
+  );
+  assert.deepEqual(
+    statusPayloads.map((payload) => payload.isProcessing),
+    [true, false]
+  );
+});
+
+test('AcpClient sends prompt resource links as ACP prompt blocks and user content blocks', async () => {
+  const writer = createWriter();
+  const client = new AcpClient({
+    agentKey: 'claude',
+    writer,
+    projectPath: process.cwd()
+  });
+
+  client.sessionId = 'session-prompt-blocks';
+  let promptParams = null;
+  client.connection = {
+    prompt: async (params) => {
+      promptParams = params;
+      return { stopReason: 'end_turn' };
+    }
+  };
+
+  await client.sendPrompt('Review this file.', {
+    resourceLinks: [
+      {
+        uri: '/tmp/spec.md',
+        name: 'spec.md'
+      }
+    ]
+  });
+
+  assert.equal(promptParams.prompt[1].type, 'resource_link');
+  assert.equal(promptParams.prompt[1].uri, '/tmp/spec.md');
+
+  const userEvent = getConversationEvents(writer).find((event) => event.kind === 'user_message');
+  assert.ok(userEvent);
+  assert.equal(userEvent.payload.contentBlocks[0].type, 'resource_link');
+  assert.equal(userEvent.payload.contentBlocks[0].uri, '/tmp/spec.md');
+});