agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/providers.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { NullWorkerProvider, resolveProviderSelection } from '../src/index.js';
 
@@ -165,6 +165,46 @@ describe('provider selection', () => {
       })
     ).toThrow(ERROR_CODES.INVALID_CLI_ARGS);
   });
+
+  it('GIVEN_env_AOP_AGENT_CONFIG_WHEN_resolving_THEN_uses_env_agent_config', () => {
+    const agentConfig = { model_params: { temperature: 0.7 } };
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'kiro-cli' },
+      env: { AOP_AGENT_CONFIG: JSON.stringify(agentConfig) },
+      agentsConfig: {}
+    });
+    expect(selection.agent_config).toEqual(agentConfig);
+  });
+
+  it('GIVEN_env_AOP_AGENT_CONFIG_JSON_WHEN_resolving_THEN_uses_env_json_agent_config', () => {
+    const agentConfig = { temperature: 0.5 };
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'kiro-cli' },
+      env: { AOP_AGENT_CONFIG_JSON: JSON.stringify(agentConfig) },
+      agentsConfig: {}
+    });
+    expect(selection.agent_config).toEqual(agentConfig);
+  });
+
+  it('GIVEN_env_agent_config_not_plain_object_WHEN_resolving_THEN_throws_invalid_cli_args', () => {
+    expect(() =>
+      resolveProviderSelection({
+        cli: { agent_provider: 'kiro-cli' },
+        env: { AOP_AGENT_CONFIG: JSON.stringify([1, 2, 3]) },
+        agentsConfig: {}
+      })
+    ).toThrow(ERROR_CODES.INVALID_CLI_ARGS);
+  });
+
+  it('GIVEN_runtime_without_provider_configs_WHEN_resolving_with_default_agent_config_THEN_uses_default', () => {
+    const defaultConfig = { max_tokens: 8000 };
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'kiro-cli' },
+      env: {},
+      agentsConfig: { runtime: { default_agent_config: defaultConfig } }
+    });
+    expect(selection.agent_config).toEqual(defaultConfig);
+  });
 });
 
 describe('NullWorkerProvider', () => {
@@ -243,4 +283,307 @@ describe('NullWorkerProvider', () => {
     const provider = new NullWorkerProvider(selection);
     await expect(provider.closeSession('session:1')).resolves.toEqual({ closed: true });
   });
+
+  it('GIVEN_codex_provider_WHEN_attachToSession_called_THEN_executes_interactive_attach_command', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+    };
+    const provider = new NullWorkerProvider(
+      {
+        provider: 'codex',
+        model: 'codex-default',
+        provider_config_env: null,
+        provider_config_ref: null
+      },
+      { commandRunner: runner }
+    );
+
+    expect(provider.attachToSession).toBeTypeOf('function');
+    await provider.attachToSession?.('session-codex-1');
+
+    expect(runner.run).toHaveBeenCalledWith(
+      'codex',
+      ['chat', '--session', 'session-codex-1'],
+      expect.objectContaining({ interactive: true })
+    );
+  });
+
+  it('GIVEN_claude_provider_WHEN_sendMessage_called_THEN_executes_send_command_with_message_argument', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+    };
+    const provider = new NullWorkerProvider(
+      {
+        provider: 'claude',
+        model: 'claude-default',
+        provider_config_env: null,
+        provider_config_ref: null
+      },
+      { commandRunner: runner }
+    );
+
+    expect(provider.sendMessage).toBeTypeOf('function');
+    await provider.sendMessage?.('session-claude-1', 'Please rerun the QA gate');
+
+    expect(runner.run).toHaveBeenCalledWith(
+      'claude-code',
+      ['chat', '--session', 'session-claude-1', '--message', 'Please rerun the QA gate'],
+      expect.objectContaining({ interactive: false })
+    );
+  });
+
+  it('GIVEN_custom_provider_without_command_overrides_WHEN_constructed_THEN_attach_and_send_are_unsupported', () => {
+    const provider = new NullWorkerProvider({
+      provider: 'custom',
+      model: 'custom-default',
+      provider_config_env: null,
+      provider_config_ref: null
+    });
+
+    expect(provider.attachToSession).toBeUndefined();
+    expect(provider.sendMessage).toBeUndefined();
+  });
+
+  it('GIVEN_custom_provider_with_agent_config_overrides_WHEN_attach_called_THEN_uses_overridden_command_template', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 0, signal: null }))
+    };
+    const provider = new NullWorkerProvider(
+      {
+        provider: 'custom',
+        model: 'custom-default',
+        provider_config_env: null,
+        provider_config_ref: null,
+        agent_config: {
+          attach_command: 'my-agent-cli',
+          attach_args: ['open', '--session-id', '{session_id}']
+        }
+      },
+      { commandRunner: runner }
+    );
+
+    await provider.attachToSession?.('session-custom-1');
+    expect(runner.run).toHaveBeenCalledWith(
+      'my-agent-cli',
+      ['open', '--session-id', 'session-custom-1'],
+      expect.objectContaining({ interactive: true })
+    );
+  });
+});
+
+describe('NullWorkerProvider executeCommand error branches', () => {
+  it('GIVEN_command_exits_with_127_WHEN_executeCommand_called_THEN_throws_unsupported_agent_provider', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 127, signal: null, errorCode: undefined }))
+    };
+    const provider = new NullWorkerProvider(
+      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
+      { commandRunner: runner }
+    );
+    await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
+      code: 'unsupported_agent_provider'
+    });
+  });
+
+  it('GIVEN_command_exits_with_ENOENT_error_code_WHEN_executeCommand_called_THEN_throws_unsupported_agent_provider', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: 'ENOENT' }))
+    };
+    const provider = new NullWorkerProvider(
+      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
+      { commandRunner: runner }
+    );
+    await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
+      code: 'unsupported_agent_provider'
+    });
+  });
+
+  it('GIVEN_command_exits_with_generic_nonzero_code_WHEN_executeCommand_called_THEN_throws_internal_error', async () => {
+    const runner = {
+      run: vi.fn(async () => ({ exitCode: 1, signal: null, errorCode: undefined }))
+    };
+    const provider = new NullWorkerProvider(
+      { provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null },
+      { commandRunner: runner }
+    );
+    await expect(provider.sendMessage?.('session-1', 'hello')).rejects.toMatchObject({
+      code: 'internal_error'
+    });
+  });
+
+  it('GIVEN_provider_without_send_command_WHEN_executeCommand_invoked_THEN_would_throw_if_called', () => {
+    const provider = new NullWorkerProvider(
+      { provider: 'custom', model: 'custom-default', provider_config_env: null, provider_config_ref: null }
+    );
+    // sendMessage should be undefined for custom provider without agent_config
+    expect(provider.sendMessage).toBeUndefined();
+  });
+});
+
+describe('NullWorkerProvider additional coverage', () => {
+  it('GIVEN_empty_sessionId_WHEN_reattachSession_called_THEN_returns_null', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+    });
+    const result = await provider.reattachSession('');
+    expect(result).toBeNull();
+  });
+
+  it('GIVEN_unknown_sessionId_WHEN_reattachSession_called_THEN_returns_null', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+    });
+    const result = await provider.reattachSession('unknown');
+    expect(result).toBeNull();
+  });
+
+  it('GIVEN_valid_sessionId_WHEN_reattachSession_called_THEN_returns_worker_session', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'claude', model: 'claude-default', provider_config_env: null, provider_config_ref: null
+    });
+    const result = await provider.reattachSession('session-abc-1');
+    expect(result).toMatchObject({ session_id: 'session-abc-1', role: 'orchestrator' });
+  });
+
+  it('GIVEN_custom_provider_without_attach_command_WHEN_executeCommand_called_THEN_throws_unsupported', async () => {
+    // Custom provider with send command only (no attach)
+    const runner = { run: vi.fn() };
+    const provider = new NullWorkerProvider(
+      {
+        provider: 'custom', model: 'custom', provider_config_env: null, provider_config_ref: null,
+        agent_config: {
+          send_command: 'my-cli',
+          send_args: ['send', '--session', '{session_id}', '--msg', '{message}']
+        }
+      },
+      { commandRunner: runner }
+    );
+    // attachToSession should be undefined (no attach_command in config)
+    expect(provider.attachToSession).toBeUndefined();
+  });
+});
+
+describe('resolveConfiguredAgentConfig branches', () => {
+  it('GIVEN_provider_configs_has_plain_object_for_provider_WHEN_resolving_THEN_uses_provider_specific_config', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'custom' },
+      env: {},
+      agentsConfig: {
+        runtime: {
+          provider_configs: {
+            custom: { command: 'my-cli', args: ['--agent'] }
+          }
+        }
+      }
+    });
+    expect(selection.agent_config).toMatchObject({ command: 'my-cli' });
+  });
+
+  it('GIVEN_no_matching_provider_configs_but_default_agent_config_exists_WHEN_resolving_THEN_uses_default', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'custom' },
+      env: {},
+      agentsConfig: {
+        runtime: {
+          provider_configs: {},
+          default_agent_config: { command: 'default-cli', args: [] }
+        }
+      }
+    });
+    expect(selection.agent_config).toMatchObject({ command: 'default-cli' });
+  });
+
+  it('GIVEN_no_provider_configs_and_no_default_WHEN_resolving_THEN_agent_config_is_null', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'custom' },
+      env: {},
+      agentsConfig: {
+        runtime: {}
+      }
+    });
+    expect(selection.agent_config).toBeNull();
+  });
+});
+
+describe('NullWorkerProvider getSessionInfo branch', () => {
+  it('GIVEN_provider_with_attach_command_WHEN_getSessionInfo_called_THEN_returns_active_status', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'claude',
+      model: 'claude-3',
+      provider_config_env: null,
+      provider_config_ref: null,
+      agent_config: {
+        attach_command: 'claude-code',
+        attach_args: ['chat', '--session', '{session_id}']
+      }
+    });
+
+    expect(provider.getSessionInfo).toBeDefined();
+    const info = await provider.getSessionInfo('valid-session-id');
+    expect(info.active).toBe(true);
+    expect(info.provider).toBe('claude');
+  });
+
+  it('GIVEN_provider_with_attach_command_WHEN_getSessionInfo_called_with_unknown_id_THEN_inactive', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'claude',
+      model: 'claude-3',
+      provider_config_env: null,
+      provider_config_ref: null,
+      agent_config: {
+        attach_command: 'claude-code',
+        attach_args: ['chat', '--session', '{session_id}']
+      }
+    });
+
+    const info = await provider.getSessionInfo('unknown');
+    expect(info.active).toBe(false);
+  });
+
+  it('GIVEN_provider_with_attach_command_WHEN_executeCommand_called_with_missing_template_THEN_throws', async () => {
+    const provider = new NullWorkerProvider({
+      provider: 'null',
+      model: 'none',
+      provider_config_env: null,
+      provider_config_ref: null
+    });
+
+    // Access executeCommand directly to cover the !template guard
+    await expect(
+      (provider as never as { executeCommand: (kind: string, sessionId: string) => Promise<void> })
+        .executeCommand('attach', 'session-123')
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER
+    });
+  });
+});
+
+import { NodeProviderCommandRunner } from '../src/providers/providers.js';
+
+describe('NodeProviderCommandRunner', () => {
+  it('GIVEN_command_emits_ENOENT_error_WHEN_run_THEN_returns_exitCode_127_or_minus2', async () => {
+    const runner = new NodeProviderCommandRunner();
+    // /nonexistent-command-xyz fires an 'error' event with code ENOENT on Linux
+    const result = await runner.run('/nonexistent-command-xyz', []);
+    expect([127, -2]).toContain(result.exitCode);
+  });
+
+  it('GIVEN_valid_command_WHEN_run_THEN_returns_exit_code', async () => {
+    const runner = new NodeProviderCommandRunner();
+    const result = await runner.run('true', []);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('GIVEN_stdin_string_WHEN_run_THEN_writes_stdin_to_process', async () => {
+    const runner = new NodeProviderCommandRunner();
+    const result = await runner.run('cat', [], { stdin: 'hello' });
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('GIVEN_timeout_WHEN_command_exceeds_it_THEN_kills_process', async () => {
+    const runner = new NodeProviderCommandRunner();
+    const result = await runner.run('sleep', ['10'], { timeoutMs: 50 });
+    // Killed by SIGKILL → exitCode should be non-zero or null
+    expect(result.signal).toBe('SIGKILL');
+  });
 });