@axiom-lattice/cli-a2a 0.1.4 → 0.1.6

package/__tests__/opencode-executor.test.ts

@@ -1,14 +1,35 @@
 /**
- * Tests for OpenCode A2A Executor.
+ * Tests for CLI A2A multi-turn conversation support.
  *
- * These are unit tests that mock the OpenCode SDK.
- * Integration tests require a running opencode server.
+ * Covers SessionBindingStore, client session arguments, and executor
+ * contextId→sessionId mapping.
  */
 
+import { SessionBindingStore, generateContextId } from '../src/session-store';
 import { OpenCodeExecutor } from '../src/executors/opencode/executor';
+import { CodexExecutor } from '../src/executors/codex/executor';
+import { ClaudeExecutor } from '../src/executors/claude/executor';
+import { OpenCodeClient } from '../src/executors/opencode/client';
+import { CodexClient } from '../src/executors/codex/client';
+import { ClaudeClient } from '../src/executors/claude/client';
 import type { AgentConfig } from '../src/config/types';
 import { resolveDefaults } from '../src/config/defaults';
 
+import { mkdirSync, writeFileSync, rmSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function createTestStoreDir(): string {
+  const dir = join(tmpdir(), `cli-a2a-test-${randomUUID()}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+let tmpDir: string;
+
 function createMockConfig(overrides?: Partial<AgentConfig>): Required<AgentConfig> {
   const base: Partial<AgentConfig> = {
     provider: 'opencode',
@@ -22,11 +43,20 @@ function createMockConfig(overrides?: Partial<AgentConfig>): Required<AgentConfi
       model: 'anthropic/claude-sonnet-4',
       agent: 'code-assistant',
     },
+    codex: {
+      cliPath: 'codex',
+      workdir: '/tmp/test-workspace',
+      model: 'gpt-4o',
+    },
+    claude: {
+      cliPath: 'claude',
+      workdir: '/tmp/test-workspace',
+      model: 'claude-sonnet-4',
+    },
     session: {
       ttl: 3_600_000,
       cleanupInterval: 300_000,
       reuseByContext: true,
-      titlePrefix: 'A2A Test',
     },
     features: {
       autoApprovePermissions: true,
@@ -53,49 +83,402 @@ function createMockConfig(overrides?: Partial<AgentConfig>): Required<AgentConfi
   return resolveDefaults(base);
 }
 
+function createStore(opts?: { persist?: boolean }): SessionBindingStore {
+  return new SessionBindingStore({
+    persist: opts?.persist ?? false,
+    cleanupIntervalMs: 100_000, // don't actually run
+  });
+}
+
+// ─── SessionBindingStore ────────────────────────────────────────────────────
+
+describe('SessionBindingStore', () => {
+  let store: SessionBindingStore;
+
+  beforeEach(() => {
+    store = createStore();
+  });
+
+  afterEach(() => {
+    store.shutdown();
+  });
+
+  describe('basic CRUD', () => {
+    it('should return null for unknown contextId', () => {
+      expect(store.get('unknown', 'codex')).toBeNull();
+    });
+
+    it('should set and get a binding', () => {
+      const binding = {
+        provider: 'codex' as const,
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        activeTaskId: 'task-1',
+        activeTaskState: 'working',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+      store.set(binding);
+
+      const found = store.get('ctx-1', 'codex');
+      expect(found).not.toBeNull();
+      expect(found!.sessionId).toBe('ses-1');
+      expect(found!.activeTaskId).toBe('task-1');
+    });
+
+    it('should scope bindings by provider', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+
+      expect(store.get('ctx-1', 'codex')).not.toBeNull();
+      expect(store.get('ctx-1', 'claude')).toBeNull();
+    });
+
+    it('should delete a binding', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+
+      expect(store.delete('ctx-1', 'codex')).toBe(true);
+      expect(store.get('ctx-1', 'codex')).toBeNull();
+    });
+
+    it('should return false when deleting non-existent binding', () => {
+      expect(store.delete('nope', 'codex')).toBe(false);
+    });
+
+    it('should clear active task', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        activeTaskId: 'task-1',
+        activeTaskState: 'input-required',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+
+      store.clearActiveTask('ctx-1', 'codex');
+
+      const found = store.get('ctx-1', 'codex');
+      expect(found!.activeTaskId).toBeUndefined();
+      expect(found!.activeTaskState).toBeUndefined();
+    });
+
+    it('should report correct store size', () => {
+      expect(store.size).toBe(0);
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-a',
+        sessionId: 's1',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-b',
+        sessionId: 's2',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+      expect(store.size).toBe(2);
+    });
+  });
+
+  describe('TTL cleanup', () => {
+    it('should return null for expired bindings', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        createdAt: new Date(Date.now() - 10_000).toISOString(),
+        updatedAt: new Date(Date.now() - 10_000).toISOString(),
+        expiresAt: new Date(Date.now() - 1_000).toISOString(), // expired 1s ago
+      });
+
+      expect(store.get('ctx-1', 'codex')).toBeNull();
+      expect(store.size).toBe(0); // should be removed from cache
+    });
+
+    it('should not expire bindings without expiresAt', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-1',
+        sessionId: 'ses-1',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+
+      expect(store.get('ctx-1', 'codex')).not.toBeNull();
+    });
+
+    it('should clean up expired entries', () => {
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-expired',
+        sessionId: 'ses-expired',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() - 1_000).toISOString(),
+      });
+      store.set({
+        provider: 'codex',
+        contextId: 'ctx-valid',
+        sessionId: 'ses-valid',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+
+      const removed = store.cleanup();
+      expect(removed).toBe(1);
+      expect(store.get('ctx-expired', 'codex')).toBeNull();
+      expect(store.get('ctx-valid', 'codex')).not.toBeNull();
+    });
+  });
+
+  describe('file persistence', () => {
+    let persistDir: string;
+
+    beforeEach(() => {
+      persistDir = createTestStoreDir();
+    });
+
+    afterEach(() => {
+      try { rmSync(persistDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+
+    it('should load bindings from file on startup', () => {
+      const storePath = join(persistDir, 'sessions.json');
+      const data = {
+        version: 1,
+        bindings: [
+          {
+            provider: 'codex',
+            contextId: 'ctx-from-file',
+            sessionId: 'ses-file',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        ],
+      };
+      writeFileSync(storePath, JSON.stringify(data));
+
+      const loadedStore = new SessionBindingStore({ storePath, persist: true, cleanupIntervalMs: 100_000 });
+      expect(loadedStore.get('ctx-from-file', 'codex')).not.toBeNull();
+      expect(loadedStore.get('ctx-from-file', 'codex')!.sessionId).toBe('ses-file');
+      loadedStore.shutdown();
+    });
+
+    it('should recover from corrupted JSON by starting fresh', () => {
+      const storePath = join(persistDir, 'sessions.json');
+      writeFileSync(storePath, '{ not valid json }');
+
+      const store = new SessionBindingStore({ storePath, persist: true });
+      expect(store.size).toBe(0);
+      store.shutdown();
+    });
+
+    it('should survive shutdown and reload', () => {
+      const storePath = join(persistDir, 'sessions.json');
+
+      const store1 = new SessionBindingStore({ storePath, persist: true, cleanupIntervalMs: 100_000 });
+      store1.set({
+        provider: 'codex',
+        contextId: 'ctx-restart',
+        sessionId: 'ses-restart',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      });
+      store1.shutdown();
+
+      // Simulate restart: new store instance loads same file
+      const store2 = new SessionBindingStore({ storePath, persist: true, cleanupIntervalMs: 100_000 });
+      const binding = store2.get('ctx-restart', 'codex');
+      expect(binding).not.toBeNull();
+      expect(binding!.sessionId).toBe('ses-restart');
+      store2.shutdown();
+    });
+
+    it('should skip expired bindings on load', () => {
+      const storePath = join(persistDir, 'sessions.json');
+      const data = {
+        version: 1,
+        bindings: [
+          {
+            provider: 'codex',
+            contextId: 'ctx-expired',
+            sessionId: 'ses-expired',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            expiresAt: new Date(Date.now() - 1_000).toISOString(),
+          },
+          {
+            provider: 'codex',
+            contextId: 'ctx-valid',
+            sessionId: 'ses-valid',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        ],
+      };
+      writeFileSync(storePath, JSON.stringify(data));
+
+      const store = new SessionBindingStore({ storePath, persist: true });
+      expect(store.get('ctx-expired', 'codex')).toBeNull();
+      expect(store.get('ctx-valid', 'codex')).not.toBeNull();
+      store.shutdown();
+    });
+  });
+
+  describe('generateContextId', () => {
+    it('should generate unique UUIDs', () => {
+      const id1 = generateContextId();
+      const id2 = generateContextId();
+      expect(id1).not.toBe(id2);
+      expect(id1.length).toBeGreaterThan(0);
+    });
+  });
+});
+
+// ─── Client Argument Tests ──────────────────────────────────────────────────
+
+describe('CodexClient session args', () => {
+  it('should configure client for new session', () => {
+    const client = new CodexClient({
+      cliPath: 'codex',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+
+  it('should configure client for resume', () => {
+    const client = new CodexClient({
+      cliPath: 'codex',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+
+  it('should reject oversized prompts', async () => {
+    const client = new CodexClient({
+      cliPath: 'codex',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    const bigPrompt = 'x'.repeat(200_000);
+    await expect(client.execute(bigPrompt)).rejects.toThrow('Prompt too large');
+  });
+});
+
+describe('ClaudeClient session args', () => {
+  it('should configure client for new session', () => {
+    const client = new ClaudeClient({
+      cliPath: 'claude',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+
+  it('should configure client for resume', () => {
+    const client = new ClaudeClient({
+      cliPath: 'claude',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+});
+
+describe('OpenCodeClient session args', () => {
+  it('should configure client for new session', () => {
+    const client = new OpenCodeClient({
+      cliPath: 'opencode',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+
+  it('should configure client for resume', () => {
+    const client = new OpenCodeClient({
+      cliPath: 'opencode',
+      workdir: '/tmp/test',
+      timeout: 1000,
+    });
+    expect(client).toBeDefined();
+  });
+});
+
+// ─── Executor Tests ─────────────────────────────────────────────────────────
+
 describe('OpenCodeExecutor', () => {
+  let store: SessionBindingStore;
+
+  beforeEach(() => {
+    store = createStore();
+  });
+
+  afterEach(() => {
+    store.shutdown();
+  });
+
   it('should create an executor with valid config', () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(executor).toBeDefined();
   });
 
   it('should have initialize method', () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(typeof executor.initialize).toBe('function');
   });
 
   it('should have shutdown method', () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(typeof executor.shutdown).toBe('function');
   });
 
   it('should have execute method', () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(typeof executor.execute).toBe('function');
   });
 
   it('should have cancelTask method', () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(typeof executor.cancelTask).toBe('function');
   });
 
-  it('should not be initialized until initialize is called', () => {
+  it('should cleanup on shutdown', async () => {
     const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
+    await executor.shutdown();
     // @ts-expect-error testing private field
     expect(executor.initialized).toBe(false);
+    // @ts-expect-error testing private field
+    expect(executor.client).toBeNull();
   });
 
   it('should handle config with empty model', () => {
     const config = createMockConfig({
       opencode: { model: '' },
     });
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
     expect(executor).toBeDefined();
   });
 
@@ -106,36 +489,79 @@ describe('OpenCodeExecutor', () => {
         systemPromptMode: 'replace',
       },
     });
-    const executor = new OpenCodeExecutor(config);
+    const executor = new OpenCodeExecutor(config, store);
+    expect(executor).toBeDefined();
+  });
+});
+
+describe('CodexExecutor', () => {
+  let store: SessionBindingStore;
+
+  beforeEach(() => {
+    store = createStore();
+  });
+
+  afterEach(() => {
+    store.shutdown();
+  });
+
+  it('should create an executor with valid config', () => {
+    const config = createMockConfig({ provider: 'codex' });
+    const executor = new CodexExecutor(config, store);
     expect(executor).toBeDefined();
   });
 
+  it('should have required methods', () => {
+    const config = createMockConfig({ provider: 'codex' });
+    const executor = new CodexExecutor(config, store);
+    expect(typeof executor.initialize).toBe('function');
+    expect(typeof executor.execute).toBe('function');
+    expect(typeof executor.cancelTask).toBe('function');
+    expect(typeof executor.shutdown).toBe('function');
+  });
+
   it('should cleanup on shutdown', async () => {
-    const config = createMockConfig();
-    const executor = new OpenCodeExecutor(config);
+    const config = createMockConfig({ provider: 'codex' });
+    const executor = new CodexExecutor(config, store);
     await executor.shutdown();
-    // @ts-expect-error testing private field
-    expect(executor.initialized).toBe(false);
-    // @ts-expect-error testing private field
-    expect(executor.client).toBeNull();
   });
+});
 
-  it('should allow double initialization without error', async () => {
-    const config = createMockConfig({
-      features: {
-        autoApprovePermissions: false,
-        autoAnswerQuestions: false,
-      },
-    });
-    const executor = new OpenCodeExecutor(config);
+describe('ClaudeExecutor', () => {
+  let store: SessionBindingStore;
+
+  beforeEach(() => {
+    store = createStore();
+  });
+
+  afterEach(() => {
+    store.shutdown();
+  });
 
-    // First call will fail because no server, but should set initialized=false
-    try { await executor.initialize(); } catch { /* no server */ }
-    // Second call should be safe
-    try { await executor.initialize(); } catch { /* no server */ }
+  it('should create an executor with valid config', () => {
+    const config = createMockConfig({ provider: 'claude' });
+    const executor = new ClaudeExecutor(config, store);
+    expect(executor).toBeDefined();
+  });
+
+  it('should have required methods', () => {
+    const config = createMockConfig({ provider: 'claude' });
+    const executor = new ClaudeExecutor(config, store);
+    expect(typeof executor.initialize).toBe('function');
+    expect(typeof executor.execute).toBe('function');
+    expect(typeof executor.cancelTask).toBe('function');
+    expect(typeof executor.shutdown).toBe('function');
+  });
+
+  it('should cleanup on shutdown', async () => {
+    const config = createMockConfig({ provider: 'claude' });
+    const executor = new ClaudeExecutor(config, store);
+    await executor.shutdown();
   });
 });
 
+// ─── Config Tests ───────────────────────────────────────────────────────────
+
 describe('Config resolution', () => {
   it('should resolve defaults when no config file provided', () => {
     const { resolveConfig } = require('../src/config/loader');
@@ -143,6 +569,8 @@ describe('Config resolution', () => {
     expect(config.provider).toBe('opencode');
     expect(config.agentCard.name).toBeDefined();
     expect(config.server?.port).toBeDefined();
+    expect(config.session?.persist).toBe(true);
+    expect(config.session?.reuseByContext).toBe(true);
   });
 
   it('should merge CLI overrides into defaults', () => {
@@ -157,3 +585,175 @@ describe('Config resolution', () => {
     expect(config.agentCard.name).toBe('Custom Agent');
   });
 });
+
+// ─── Multi-Turn Scenario Tests ──────────────────────────────────────────────
+
+describe('Multi-turn session reuse', () => {
+  let persistDir: string;
+
+  beforeEach(() => {
+    persistDir = createTestStoreDir();
+  });
+
+  afterEach(() => {
+    try { rmSync(persistDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('should reuse session for same contextId across two turns', () => {
+    const storePath = join(persistDir, 'sessions.json');
+    const store = new SessionBindingStore({ storePath, persist: true, cleanupIntervalMs: 100_000 });
+
+    const contextId = 'multi-turn-ctx';
+    const taskId1 = 'task-turn-1';
+    const taskId2 = 'task-turn-2';
+
+    // Turn 1: create binding
+    store.set({
+      provider: 'codex',
+      contextId,
+      sessionId: 'codex-ses-abc',
+      activeTaskId: taskId1,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    // Turn 2: lookup binding
+    const binding = store.get(contextId, 'codex');
+    expect(binding).not.toBeNull();
+    expect(binding!.sessionId).toBe('codex-ses-abc');
+
+    // Update for turn 2
+    store.set({
+      provider: 'codex',
+      contextId,
+      sessionId: 'codex-ses-abc',
+      activeTaskId: taskId2,
+      createdAt: binding!.createdAt,
+      updatedAt: new Date().toISOString(),
+    });
+
+    store.shutdown();
+
+    // Restart: should persist across process restarts
+    const store2 = new SessionBindingStore({ storePath, persist: true, cleanupIntervalMs: 100_000 });
+    const binding2 = store2.get(contextId, 'codex');
+    expect(binding2).not.toBeNull();
+    expect(binding2!.sessionId).toBe('codex-ses-abc');
+    store2.shutdown();
+  });
+
+  it('should create separate sessions for different contextIds', () => {
+    const store = createStore();
+    const ctxA = 'context-a';
+    const ctxB = 'context-b';
+
+    store.set({
+      provider: 'codex',
+      contextId: ctxA,
+      sessionId: 'ses-a',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    store.set({
+      provider: 'codex',
+      contextId: ctxB,
+      sessionId: 'ses-b',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    expect(store.get(ctxA, 'codex')!.sessionId).toBe('ses-a');
+    expect(store.get(ctxB, 'codex')!.sessionId).toBe('ses-b');
+    expect(store.get(ctxA, 'codex')!.sessionId).not.toBe(
+      store.get(ctxB, 'codex')!.sessionId,
+    );
+    store.shutdown();
+  });
+
+  it('should scope sessions by provider', () => {
+    const store = createStore();
+    const ctx = 'shared-ctx';
+
+    store.set({
+      provider: 'codex',
+      contextId: ctx,
+      sessionId: 'ses-codex',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    store.set({
+      provider: 'claude',
+      contextId: ctx,
+      sessionId: 'ses-claude',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    expect(store.get(ctx, 'codex')!.sessionId).toBe('ses-codex');
+    expect(store.get(ctx, 'claude')!.sessionId).toBe('ses-claude');
+    store.shutdown();
+  });
+
+  it('should clear active task without removing session', () => {
+    const store = createStore();
+    const ctx = 'ctx-task-test';
+
+    store.set({
+      provider: 'codex',
+      contextId: ctx,
+      sessionId: 'ses-1',
+      activeTaskId: 'task-1',
+      activeTaskState: 'input-required',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    store.clearActiveTask(ctx, 'codex');
+
+    const binding = store.get(ctx, 'codex');
+    expect(binding).not.toBeNull();
+    expect(binding!.sessionId).toBe('ses-1'); // session preserved
+    expect(binding!.activeTaskId).toBeUndefined(); // task cleared
+
+    store.shutdown();
+  });
+
+  it('should not reuse session when reuseByContext is false', () => {
+    const store = createStore();
+    const ctx = 'ctx-no-reuse';
+
+    // Simulate what a non-reusing server would do:
+    // Set an initial binding, but don't look it up
+    store.set({
+      provider: 'codex',
+      contextId: ctx,
+      sessionId: 'ses-original',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    // When reuseByContext=false, the executor skips the get() call
+    // Verify the original binding still exists (not overwritten)
+    const binding = store.get(ctx, 'codex');
+    expect(binding).not.toBeNull();
+    expect(binding!.sessionId).toBe('ses-original');
+
+    // But executor would call set() with new sessionId without looking up
+    store.set({
+      provider: 'codex',
+      contextId: ctx,
+      sessionId: 'ses-new',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    // The new binding overwrites the old one — but this is fine because
+    // with reuseByContext=false, the executor never reads the old binding
+    const newBinding = store.get(ctx, 'codex');
+    expect(newBinding!.sessionId).toBe('ses-new');
+
+    store.shutdown();
+  });
+});