tlc-claude-code 2.4.2 → 2.4.4

package/server/lib/orchestration/cli-dispatch.js

@@ -0,0 +1,200 @@
+let parseCodexEvents = null;
+
+try {
+  ({ parseCodexEvents } = require('../capture/codex-event-parser.js'));
+} catch (_) {
+  parseCodexEvents = null;
+}
+
+function fallbackParseCodexEvents(jsonStream) {
+  const lines = typeof jsonStream === 'string' ? jsonStream.split('\n') : [];
+  let threadId = null;
+
+  for (const line of lines) {
+    if (typeof line !== 'string' || line.trim() === '') {
+      continue;
+    }
+
+    try {
+      const event = JSON.parse(line);
+      if (
+        event &&
+        event.type === 'thread.started' &&
+        typeof event.thread_id === 'string' &&
+        event.thread_id.trim() !== ''
+      ) {
+        threadId = event.thread_id;
+      }
+    } catch (_) {
+      // Ignore non-JSON lines in mixed stdout streams.
+    }
+  }
+
+  return { threadId };
+}
+
+function extractCodexThreadId(stdout) {
+  const parsed = parseCodexEvents
+    ? parseCodexEvents(stdout)
+    : fallbackParseCodexEvents(stdout);
+
+  return parsed && typeof parsed.threadId === 'string' ? parsed.threadId : null;
+}
+
+function buildCommand(provider, prompt, worktreePath, flags) {
+  const normalizedProvider = String(provider || '').trim();
+  const baseFlags = Array.isArray(flags) ? [...flags] : [];
+  const spawnOptions = {};
+  let usesStdin = true;
+  let args;
+
+  if (normalizedProvider === 'codex') {
+    args = ['exec', '--json', '--full-auto'];
+    if (worktreePath) {
+      args.push('-C', worktreePath);
+    }
+  } else if (normalizedProvider === 'gemini') {
+    usesStdin = false;
+    args = [...baseFlags, '-p', prompt];
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else if (normalizedProvider === 'claude') {
+    usesStdin = false;
+    args = ['--agent', 'builder'];
+    if (worktreePath) {
+      args.push('--worktree', worktreePath);
+      spawnOptions.cwd = worktreePath;
+    }
+    args.push(...baseFlags, '-p', prompt);
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else if (normalizedProvider === 'ollama') {
+    args = ['run', ...baseFlags];
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else {
+    args = baseFlags;
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  }
+
+  args.push(...baseFlags);
+  return { command: normalizedProvider, args, spawnOptions, usesStdin };
+}
+
+function buildSpawnError(provider, err) {
+  const message = err && err.message ? err.message : `Failed to spawn ${provider}`;
+
+  if (err && err.code === 'ENOENT') {
+    return {
+      code: 'CLI_NOT_FOUND',
+      message: `CLI "${provider}" was not found: ${message}`,
+    };
+  }
+
+  return {
+    code: 'SPAWN_ERROR',
+    message,
+  };
+}
+
+async function dispatch({
+  provider,
+  prompt = '',
+  worktreePath,
+  flags = [],
+  timeout = 120000,
+  spawn = require('child_process').spawn,
+  binaryOverride,
+}) {
+  const start = Date.now();
+  const built = buildCommand(provider, prompt, worktreePath, flags);
+  // Allow standalone to preserve custom/absolute binary paths
+  const command = binaryOverride || built.command;
+  const { args, spawnOptions, usesStdin } = built;
+
+  return new Promise((resolve) => {
+    let proc;
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let timer = null;
+
+    function finish(exitCode, error) {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+
+      resolve({
+        stdout,
+        stderr,
+        exitCode,
+        duration: Date.now() - start,
+        threadId: command === 'codex' ? extractCodexThreadId(stdout) : null,
+        error: error || null,
+      });
+    }
+
+    try {
+      proc = spawn(command, args, spawnOptions);
+    } catch (err) {
+      finish(-1, buildSpawnError(command, err));
+      return;
+    }
+
+    proc.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      finish(-1, buildSpawnError(command, err));
+    });
+
+    proc.on('close', (code) => {
+      finish(typeof code === 'number' ? code : -1, null);
+    });
+
+    timer = setTimeout(() => {
+      if (typeof proc.kill === 'function') {
+        proc.kill();
+      }
+
+      finish(-1, {
+        code: 'TIMEOUT',
+        message: `CLI "${command}" timed out after ${timeout}ms`,
+      });
+    }, timeout);
+
+    if (proc.stdin && typeof proc.stdin.on === 'function') {
+      proc.stdin.on('error', () => {});
+    }
+
+    if (proc.stdin) {
+      if (usesStdin && typeof proc.stdin.write === 'function' && prompt) {
+        proc.stdin.write(prompt);
+      }
+
+      if (typeof proc.stdin.end === 'function') {
+        proc.stdin.end();
+      }
+    }
+  });
+}
+
+module.exports = {
+  dispatch,
+};

package/server/lib/orchestration/cli-dispatch.test.js

@@ -0,0 +1,242 @@
+import { describe, it, expect, vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+const { dispatch } = require('./cli-dispatch.js');
+
+function createMockProcess({ stdout = '', stderr = '', exitCode = 0, delay = 0 } = {}) {
+  const proc = new EventEmitter();
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.stdin = {
+    write: vi.fn(),
+    end: vi.fn(),
+    on: vi.fn(),
+  };
+  proc.kill = vi.fn();
+
+  setTimeout(() => {
+    if (stdout) {
+      proc.stdout.emit('data', Buffer.from(stdout));
+    }
+
+    if (stderr) {
+      proc.stderr.emit('data', Buffer.from(stderr));
+    }
+
+    proc.emit('close', exitCode);
+  }, delay);
+
+  return proc;
+}
+
+describe('cli-dispatch', () => {
+  it('builds codex args with -C, writes prompt to stdin, and extracts threadId', async () => {
+    const stdout = [
+      '{"type":"thread.started","thread_id":"thread-123"}',
+      '{"type":"agent_message","message":{"items":[{"type":"text","text":"done"}]}}',
+    ].join('\n');
+    const proc = createMockProcess({ stdout });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'Review this change',
+      worktreePath: '/tmp/worktree',
+      flags: ['--model', 'gpt-5.4'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'codex',
+      ['exec', '--json', '--full-auto', '-C', '/tmp/worktree', '--model', 'gpt-5.4'],
+      {}
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Review this change');
+    expect(proc.stdin.end).toHaveBeenCalled();
+    expect(result.threadId).toBe('thread-123');
+    expect(result.exitCode).toBe(0);
+    expect(result.error).toBeNull();
+  });
+
+  it('passes gemini prompt as -p argument and sets cwd from worktreePath', async () => {
+    const proc = createMockProcess({ stdout: 'gemini output' });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'gemini',
+      prompt: 'Explain this diff',
+      worktreePath: '/tmp/gemini-worktree',
+      flags: ['--model', 'gemini-2.5-pro'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'gemini',
+      ['--model', 'gemini-2.5-pro', '-p', 'Explain this diff'],
+      { cwd: '/tmp/gemini-worktree' }
+    );
+    expect(proc.stdin.write).not.toHaveBeenCalled();
+    expect(proc.stdin.end).toHaveBeenCalled();
+    expect(result.stdout).toBe('gemini output');
+  });
+
+  it('builds claude args with worktree and prompt flag and sets cwd', async () => {
+    const proc = createMockProcess({ stdout: 'claude output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'claude',
+      prompt: 'Implement the feature',
+      worktreePath: '/tmp/claude-worktree',
+      flags: ['--permission-mode', 'auto'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'claude',
+      ['--agent', 'builder', '--worktree', '/tmp/claude-worktree', '--permission-mode', 'auto', '-p', 'Implement the feature'],
+      { cwd: '/tmp/claude-worktree' }
+    );
+  });
+
+  it('uses stdin prompt for ollama and sets cwd when worktreePath is provided', async () => {
+    const proc = createMockProcess({ stdout: 'ollama output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'ollama',
+      prompt: 'Summarize the logs',
+      worktreePath: '/tmp/ollama-worktree',
+      flags: ['llama3.2'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'ollama',
+      ['run', 'llama3.2'],
+      { cwd: '/tmp/ollama-worktree' }
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Summarize the logs');
+  });
+
+  it('uses generic flags and stdin for unknown providers', async () => {
+    const proc = createMockProcess({ stdout: 'custom output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'custom-cli',
+      prompt: 'Do the custom thing',
+      worktreePath: '/tmp/custom-worktree',
+      flags: ['--mode', 'fast'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'custom-cli',
+      ['--mode', 'fast'],
+      { cwd: '/tmp/custom-worktree' }
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Do the custom thing');
+  });
+
+  it('returns CLI_NOT_FOUND when spawn emits ENOENT', async () => {
+    const proc = new EventEmitter();
+    proc.stdout = new EventEmitter();
+    proc.stderr = new EventEmitter();
+    proc.stdin = {
+      write: vi.fn(),
+      end: vi.fn(),
+      on: vi.fn(),
+    };
+    proc.kill = vi.fn();
+
+    const spawn = vi.fn(() => {
+      setTimeout(() => {
+        proc.emit('error', Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }));
+      }, 0);
+      return proc;
+    });
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      spawn,
+    });
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.error).toEqual(
+      expect.objectContaining({
+        code: 'CLI_NOT_FOUND',
+      })
+    );
+    expect(result.error.message).toContain('codex');
+  });
+
+  it('returns TIMEOUT on hung processes', async () => {
+    const proc = createMockProcess({ stdout: 'late output', delay: 5000 });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'ollama',
+      prompt: 'slow task',
+      timeout: 20,
+      spawn,
+    });
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.error).toEqual(
+      expect.objectContaining({
+        code: 'TIMEOUT',
+      })
+    );
+    expect(proc.kill).toHaveBeenCalled();
+  });
+
+  it('captures non-zero exits without throwing', async () => {
+    const proc = createMockProcess({ stdout: 'partial', stderr: 'failed', exitCode: 2 });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'custom-cli',
+      prompt: 'run',
+      spawn,
+    });
+
+    expect(result.stdout).toBe('partial');
+    expect(result.stderr).toBe('failed');
+    expect(result.exitCode).toBe(2);
+    expect(result.error).toBeNull();
+  });
+
+  it('does not set cwd when codex already uses -C', async () => {
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      worktreePath: '/tmp/codex-worktree',
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'codex',
+      ['exec', '--json', '--full-auto', '-C', '/tmp/codex-worktree'],
+      {}
+    );
+  });
+
+  it('returns null threadId when codex output does not contain one', async () => {
+    const proc = createMockProcess({ stdout: '{"type":"agent_message"}' });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      spawn,
+    });
+
+    expect(result.threadId).toBeNull();
+    expect(result.exitCode).toBe(0);
+  });
+});

package/server/lib/orchestration/codex-orchestrator.js

@@ -0,0 +1,185 @@
+/**
+ * Codex Orchestrator
+ *
+ * Dispatches tasks to Codex CLI and captures thread IDs for resume flows.
+ */
+
+function createCliNotFoundError() {
+  return {
+    code: 'CODEX_CLI_NOT_FOUND',
+    message: 'Codex CLI is not installed or not available on PATH',
+  };
+}
+
+function createTimeoutError(timeout) {
+  return {
+    code: 'PROCESS_TIMEOUT',
+    message: `Process timed out after ${timeout}ms`,
+  };
+}
+
+function runCodex({
+  args,
+  prompt = '',
+  timeout = 120000,
+  cwd,
+  spawn = require('child_process').spawn,
+  onStdoutLine,
+}) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const spawnOpts = {};
+    if (cwd) spawnOpts.cwd = cwd;
+
+    let proc;
+    try {
+      proc = spawn('codex', args, spawnOpts);
+    } catch (err) {
+      const error = err && err.code === 'ENOENT'
+        ? createCliNotFoundError()
+        : {
+            code: 'SPAWN_FAILED',
+            message: err && err.message ? err.message : 'Failed to spawn Codex CLI',
+          };
+
+      resolve({
+        stdout: '',
+        stderr: err && err.message ? err.message : error.message,
+        exitCode: -1,
+        duration: Date.now() - start,
+        error,
+      });
+      return;
+    }
+
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let stdoutBuffer = '';
+
+    const finish = (exitCode, error = null, stderrOverride) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr: stderrOverride !== undefined ? stderrOverride : stderr,
+        exitCode,
+        duration: Date.now() - start,
+        error,
+      });
+    };
+
+    const timer = setTimeout(() => {
+      proc.kill();
+      const error = createTimeoutError(timeout);
+      const nextStderr = stderr ? `${stderr}\n${error.message}` : error.message;
+      finish(-1, error, nextStderr);
+    }, timeout);
+
+    proc.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+
+      if (!onStdoutLine) {
+        return;
+      }
+
+      stdoutBuffer += chunk;
+
+      while (stdoutBuffer.includes('\n')) {
+        const newlineIndex = stdoutBuffer.indexOf('\n');
+        const line = stdoutBuffer.slice(0, newlineIndex);
+        stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+        onStdoutLine(line);
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (onStdoutLine && stdoutBuffer) {
+        onStdoutLine(stdoutBuffer);
+        stdoutBuffer = '';
+      }
+
+      finish(code, null);
+    });
+
+    proc.on('error', (err) => {
+      const error = err && err.code === 'ENOENT'
+        ? createCliNotFoundError()
+        : {
+            code: 'SPAWN_FAILED',
+            message: err && err.message ? err.message : 'Failed to spawn Codex CLI',
+          };
+
+      const nextStderr = stderr || (err && err.message) || error.message;
+      finish(-1, error, nextStderr);
+    });
+
+    proc.stdin.on('error', () => {});
+
+    if (prompt) {
+      proc.stdin.write(prompt);
+    }
+    proc.stdin.end();
+  });
+}
+
+async function dispatchToCodex({
+  worktreePath,
+  prompt,
+  timeout = 120000,
+  spawn = require('child_process').spawn,
+}) {
+  let threadId = null;
+
+  const result = await runCodex({
+    args: ['exec', '--json', '--full-auto', '-C', worktreePath],
+    prompt,
+    timeout,
+    spawn,
+    onStdoutLine(line) {
+      if (!line) return;
+
+      try {
+        const event = JSON.parse(line);
+        if (event.type === 'thread.started' && typeof event.thread_id === 'string') {
+          threadId = event.thread_id;
+        }
+      } catch (_) {
+        // Ignore non-JSON lines in mixed stdout streams.
+      }
+    },
+  });
+
+  return {
+    threadId,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode,
+    duration: result.duration,
+    error: result.error,
+  };
+}
+
+function resumeSession({
+  threadId,
+  prompt,
+  timeout = 120000,
+  spawn = require('child_process').spawn,
+}) {
+  return runCodex({
+    args: ['exec', 'resume', threadId, prompt],
+    timeout,
+    spawn,
+  });
+}
+
+module.exports = {
+  dispatchToCodex,
+  resumeSession,
+};