session-runner.test.js

const { describe, it } = require('node:test');
const assert = require('node:assert');
const { EventEmitter } = require('events');
const { createSessionRunner } = require('./session-runner');

function createMockChild() {
  const stdout = new EventEmitter();
  stdout.removeAllListeners = function(...args) {
    EventEmitter.prototype.removeAllListeners.apply(this, args);
  };
  const child = new EventEmitter();
  child.stdout = stdout;
  child.kill = () => {};
  return child;
}

describe('session-runner boundary', () => {
  it('resolves with sessionId from step_start event', async () => {
    let emittedChild = null;
    const mockSpawn = () => {
      emittedChild = createMockChild();
      return emittedChild;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    const promise = runner.createSession({ prompt: 'Hello world' });

    // Emit a step_start event with session_id
    emittedChild.stdout.emit('data', JSON.stringify({ type: 'step_start', session_id: 'ses_abc123' }) + '\n');

    const result = await promise;
    assert.strictEqual(result.sessionId, 'ses_abc123');
    assert.strictEqual(result.processing, true);
  });

  it('resolves with sessionId from camelCase sessionId field', async () => {
    let emittedChild = null;
    const mockSpawn = () => {
      emittedChild = createMockChild();
      return emittedChild;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    const promise = runner.createSession({ prompt: 'Test prompt' });

    emittedChild.stdout.emit('data', JSON.stringify({ type: 'step_start', sessionId: 'ses_xyz789' }) + '\n');

    const result = await promise;
    assert.strictEqual(result.sessionId, 'ses_xyz789');
  });

  it('ignores non-step_start events until step_start appears', async () => {
    let emittedChild = null;
    const mockSpawn = () => {
      emittedChild = createMockChild();
      return emittedChild;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    const promise = runner.createSession({ prompt: 'Hello' });

    emittedChild.stdout.emit('data', JSON.stringify({ type: 'log', message: 'starting' }) + '\n');
    emittedChild.stdout.emit('data', JSON.stringify({ type: 'step_start', session_id: 'ses_delayed' }) + '\n');

    const result = await promise;
    assert.strictEqual(result.sessionId, 'ses_delayed');
  });

  it('ignores non-JSON lines', async () => {
    let emittedChild = null;
    const mockSpawn = () => {
      emittedChild = createMockChild();
      return emittedChild;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    const promise = runner.createSession({ prompt: 'Hello' });

    emittedChild.stdout.emit('data', 'some log output\n');
    emittedChild.stdout.emit('data', JSON.stringify({ type: 'step_start', session_id: 'ses_after_log' }) + '\n');

    const result = await promise;
    assert.strictEqual(result.sessionId, 'ses_after_log');
  });

  it('handles split NDJSON lines across data chunks', async () => {
    let emittedChild = null;
    const mockSpawn = () => {
      emittedChild = createMockChild();
      return emittedChild;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    const promise = runner.createSession({ prompt: 'Hello' });

    const event = JSON.stringify({ type: 'step_start', session_id: 'ses_split' });
    emittedChild.stdout.emit('data', event.substring(0, 10));
    emittedChild.stdout.emit('data', event.substring(10) + '\n');

    const result = await promise;
    assert.strictEqual(result.sessionId, 'ses_split');
  });

  it('rejects when prompt is missing', async () => {
    const runner = createSessionRunner({ spawn: () => createMockChild() });
    await assert.rejects(
      () => runner.createSession({}),
      /Prompt is required/
    );
  });

  it('rejects when prompt is empty string', async () => {
    const runner = createSessionRunner({ spawn: () => createMockChild() });
    await assert.rejects(
      () => runner.createSession({ prompt: '   ' }),
      /Prompt is required/
    );
  });

  it('rejects when spawn errors', async () => {
    const mockSpawn = () => {
      const child = createMockChild();
      setTimeout(() => child.emit('error', new Error('spawn opencode ENOENT')), 0);
      return child;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    await assert.rejects(
      () => runner.createSession({ prompt: 'Hello' }),
      /spawn opencode ENOENT/
    );
  });

  it('rejects when process exits without session ID', async () => {
    const mockSpawn = () => {
      const child = createMockChild();
      setTimeout(() => child.emit('close', 1), 0);
      return child;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    await assert.rejects(
      () => runner.createSession({ prompt: 'Hello' }),
      /Process exited with code 1 without producing a session ID/
    );
  });

  it('rejects on timeout when no session ID is produced', async () => {
    const mockSpawn = () => createMockChild();

    const runner = createSessionRunner({ spawn: mockSpawn, timeoutMs: 50 });
    await assert.rejects(
      () => runner.createSession({ prompt: 'Hello' }),
      /Timeout waiting for session ID/
    );
  });

  it('passes directory to spawn args when provided', async () => {
    let capturedArgs = null;
    const mockSpawn = (_cmd, args) => {
      capturedArgs = args;
      const child = createMockChild();
      setTimeout(() => {
        child.stdout.emit('data', JSON.stringify({ type: 'step_start', session_id: 'ses_dir' }) + '\n');
      }, 0);
      return child;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    await runner.createSession({ prompt: 'Hello', directory: '/home/dsp/project' });

    assert.ok(capturedArgs.includes('--dir'));
    assert.ok(capturedArgs.includes('/home/dsp/project'));
  });

  it('does not pass directory arg when not provided', async () => {
    let capturedArgs = null;
    const mockSpawn = (_cmd, args) => {
      capturedArgs = args;
      const child = createMockChild();
      setTimeout(() => {
        child.stdout.emit('data', JSON.stringify({ type: 'step_start', session_id: 'ses_nodir' }) + '\n');
      }, 0);
      return child;
    };

    const runner = createSessionRunner({ spawn: mockSpawn });
    await runner.createSession({ prompt: 'Hello' });

    assert.ok(!capturedArgs.includes('--dir'));
  });
});