tlc-claude-code 2.4.2 → 2.4.3

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

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi } from 'vitest';
+import { dispatchToCodex, resumeSession } from './codex-orchestrator.js';
+
+function createMockSpawn({
+  stdoutChunks = [],
+  stderrChunks = [],
+  exitCode = 0,
+  delay = 0,
+  error = null,
+} = {}) {
+  return vi.fn(() => {
+    const listeners = {};
+    const stdinChunks = [];
+
+    const proc = {
+      stdin: {
+        write(data) { stdinChunks.push(data); },
+        end() { stdinChunks.push(null); },
+        on(event, cb) { listeners[`stdin:${event}`] = cb; },
+      },
+      stdout: {
+        on(event, cb) { listeners[`stdout:${event}`] = cb; },
+      },
+      stderr: {
+        on(event, cb) { listeners[`stderr:${event}`] = cb; },
+      },
+      on(event, cb) { listeners[event] = cb; },
+      kill: vi.fn(() => {
+        listeners._killed = true;
+      }),
+      _stdinChunks: stdinChunks,
+      _listeners: listeners,
+    };
+
+    setTimeout(() => {
+      if (error) {
+        listeners.error?.(error);
+        return;
+      }
+
+      stdoutChunks.forEach((chunk) => {
+        listeners['stdout:data']?.(Buffer.from(chunk));
+      });
+
+      stderrChunks.forEach((chunk) => {
+        listeners['stderr:data']?.(Buffer.from(chunk));
+      });
+
+      if (!listeners._killed) {
+        listeners.close?.(exitCode);
+      }
+    }, delay);
+
+    return proc;
+  });
+}
+
+describe('codex-orchestrator', () => {
+  describe('dispatchToCodex', () => {
+    it('builds correct command args', async () => {
+      const spawn = createMockSpawn();
+
+      await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Implement the task',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', '--json', '--full-auto', '-C', '/tmp/worktree'],
+        {}
+      );
+    });
+
+    it('pipes prompt via stdin', async () => {
+      const spawn = createMockSpawn();
+
+      await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Review this change',
+        spawn,
+      });
+
+      const proc = spawn.mock.results[0].value;
+      expect(proc._stdinChunks).toContain('Review this change');
+      expect(proc._stdinChunks).toContain(null);
+    });
+
+    it('extracts thread_id from JSON stream', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: [
+          '{"type":"status","message":"booting"}\n',
+          '{"type":"thread.started","thread_id":"thread_123"}\n',
+          '{"type":"message.delta","delta":"done"}\n',
+        ],
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Do work',
+        spawn,
+      });
+
+      expect(result.threadId).toBe('thread_123');
+      expect(result.stdout).toContain('"thread_id":"thread_123"');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('ignores invalid JSON lines and still extracts thread_id', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: [
+          'not-json\n',
+          '{"type":"thread.started","thread_id":"thread_abc"}\n',
+        ],
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Do work',
+        spawn,
+      });
+
+      expect(result.threadId).toBe('thread_abc');
+    });
+
+    it('timeout kills process and returns error', async () => {
+      const spawn = createMockSpawn({ delay: 1000 });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Slow task',
+        timeout: 25,
+        spawn,
+      });
+
+      const proc = spawn.mock.results[0].value;
+      expect(proc.kill).toHaveBeenCalledTimes(1);
+      expect(result.exitCode).toBe(-1);
+      expect(result.error).toEqual(
+        expect.objectContaining({ code: 'PROCESS_TIMEOUT' })
+      );
+      expect(result.stderr).toContain('timed out');
+    });
+
+    it('missing codex CLI returns structured error', async () => {
+      const spawn = createMockSpawn({
+        error: Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }),
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Task',
+        spawn,
+      });
+
+      expect(result.exitCode).toBe(-1);
+      expect(result.threadId).toBeNull();
+      expect(result.error).toEqual({
+        code: 'CODEX_CLI_NOT_FOUND',
+        message: 'Codex CLI is not installed or not available on PATH',
+      });
+      expect(result.stderr).toContain('ENOENT');
+    });
+
+    it('captures non-zero exit without throwing', async () => {
+      const spawn = createMockSpawn({
+        stderrChunks: ['process failed'],
+        exitCode: 17,
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Task',
+        spawn,
+      });
+
+      expect(result.exitCode).toBe(17);
+      expect(result.stderr).toBe('process failed');
+      expect(result.error).toBeNull();
+    });
+  });
+
+  describe('resumeSession', () => {
+    it('builds correct resume command', async () => {
+      const spawn = createMockSpawn();
+
+      await resumeSession({
+        threadId: 'thread_123',
+        prompt: 'Continue',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', 'resume', 'thread_123', 'Continue'],
+        {}
+      );
+    });
+
+    it('passes prompt correctly', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: ['resumed'],
+      });
+
+      const result = await resumeSession({
+        threadId: 'thread_123',
+        prompt: 'Follow up task',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', 'resume', 'thread_123', 'Follow up task'],
+        {}
+      );
+      expect(result.stdout).toBe('resumed');
+      expect(result.exitCode).toBe(0);
+    });
+  });
+});

package/server/lib/orchestration/dep-linker.js

@@ -0,0 +1,61 @@
+const path = require('path');
+
+const DEP_DIRS = ['node_modules', 'vendor', '.venv'];
+
+function pathExists(fs, targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function readExistingLinkTarget(fs, linkPath) {
+  try {
+    return path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+  } catch {
+    return null;
+  }
+}
+
+function symlinkDeps({ worktreePath, mainRepoPath, fs = require('fs') }) {
+  const linked = [];
+  const skipped = [];
+  const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+  for (const depDir of DEP_DIRS) {
+    const sourcePath = path.join(mainRepoPath, depDir);
+    const targetPath = path.join(worktreePath, depDir);
+
+    if (!pathExists(fs, sourcePath)) {
+      skipped.push(depDir);
+      continue;
+    }
+
+    let targetStats = null;
+    try {
+      targetStats = fs.lstatSync(targetPath);
+    } catch {
+      targetStats = null;
+    }
+
+    if (targetStats) {
+      if (targetStats.isSymbolicLink()) {
+        if (readExistingLinkTarget(fs, targetPath) === sourcePath) {
+          skipped.push(depDir);
+          continue;
+        }
+
+        fs.rmSync(targetPath, { recursive: true, force: true });
+      } else {
+        skipped.push(depDir);
+        continue;
+      }
+    }
+
+    fs.symlinkSync(sourcePath, targetPath, symlinkType);
+    linked.push(depDir);
+  }
+
+  return { linked, skipped };
+}
+
+module.exports = {
+  symlinkDeps,
+};

package/server/lib/orchestration/dep-linker.test.js

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, it } from 'vitest';
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { symlinkDeps } = require('./dep-linker.js');
+
+const tempPaths = [];
+
+function makeTempDir() {
+  const dirPath = path.join(os.tmpdir(), `dep-linker-${crypto.randomUUID()}`);
+  fs.mkdirSync(dirPath, { recursive: true });
+  tempPaths.push(dirPath);
+  return dirPath;
+}
+
+function createRepoPair() {
+  const rootPath = makeTempDir();
+  const mainRepoPath = path.join(rootPath, 'main');
+  const worktreePath = path.join(rootPath, 'worktree');
+
+  fs.mkdirSync(mainRepoPath, { recursive: true });
+  fs.mkdirSync(worktreePath, { recursive: true });
+
+  return { mainRepoPath, worktreePath };
+}
+
+function makeDir(targetPath) {
+  fs.mkdirSync(targetPath, { recursive: true });
+}
+
+function readLinkTarget(linkPath) {
+  return path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+}
+
+afterEach(() => {
+  while (tempPaths.length > 0) {
+    fs.rmSync(tempPaths.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('dep-linker', () => {
+  it('symlinks node_modules when exists in main', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'node_modules');
+    const linkPath = path.join(worktreePath, 'node_modules');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['node_modules']);
+    expect(result.skipped).toEqual(['vendor', '.venv']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('skips node_modules when missing from main', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(fs.existsSync(path.join(worktreePath, 'node_modules'))).toBe(false);
+  });
+
+  it('symlinks vendor when exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'vendor');
+    const linkPath = path.join(worktreePath, 'vendor');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['vendor']);
+    expect(result.skipped).toEqual(['node_modules', '.venv']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('symlinks .venv when exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, '.venv');
+    const linkPath = path.join(worktreePath, '.venv');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['.venv']);
+    expect(result.skipped).toEqual(['node_modules', 'vendor']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('returns correct linked and skipped arrays', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(path.join(mainRepoPath, 'vendor'));
+
+    expect(symlinkDeps({ worktreePath, mainRepoPath, fs })).toEqual({
+      linked: ['node_modules', 'vendor'],
+      skipped: ['.venv'],
+    });
+  });
+
+  it('skips when worktree already has real directory', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const existingPath = path.join(worktreePath, 'node_modules');
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(existingPath);
+    fs.writeFileSync(path.join(existingPath, 'keep.txt'), 'present');
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(fs.lstatSync(existingPath).isDirectory()).toBe(true);
+    expect(fs.lstatSync(existingPath).isSymbolicLink()).toBe(false);
+    expect(fs.readFileSync(path.join(existingPath, 'keep.txt'), 'utf8')).toBe('present');
+  });
+
+  it('skips when correct symlink already exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'node_modules');
+    const linkPath = path.join(worktreePath, 'node_modules');
+    const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+    makeDir(sourcePath);
+    fs.symlinkSync(sourcePath, linkPath, symlinkType);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('handles all three dirs in one call', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(path.join(mainRepoPath, 'vendor'));
+    makeDir(path.join(mainRepoPath, '.venv'));
+
+    expect(symlinkDeps({ worktreePath, mainRepoPath, fs })).toEqual({
+      linked: ['node_modules', 'vendor', '.venv'],
+      skipped: [],
+    });
+
+    expect(fs.lstatSync(path.join(worktreePath, 'node_modules')).isSymbolicLink()).toBe(true);
+    expect(fs.lstatSync(path.join(worktreePath, 'vendor')).isSymbolicLink()).toBe(true);
+    expect(fs.lstatSync(path.join(worktreePath, '.venv')).isSymbolicLink()).toBe(true);
+  });
+
+  it('works with empty worktree dir', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+
+    expect(fs.readdirSync(worktreePath)).toEqual([]);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['node_modules']);
+    expect(result.skipped).toEqual(['vendor', '.venv']);
+    expect(fs.lstatSync(path.join(worktreePath, 'node_modules')).isSymbolicLink()).toBe(true);
+  });
+});

package/server/lib/router-config.js

@@ -20,6 +20,10 @@ export const defaultConfig = {
   devserver: { url: null, queue: { maxConcurrent: 3, timeout: 120000 } },
 };
 
+function isMissingConfigError(error) {
+  return error?.code === 'ENOENT' || error?.message?.includes('ENOENT');
+}
+
 export async function loadRouterConfig(options = {}) {
   try {
     let content;
@@ -38,7 +42,13 @@ export async function loadRouterConfig(options = {}) {
       capabilities: { ...defaultConfig.capabilities, ...routerConfig.capabilities },
       devserver: { ...defaultConfig.devserver, ...routerConfig.devserver },
     };
-  } catch {
+  } catch (error) {
+    if (!isMissingConfigError(error)) {
+      const message = error instanceof SyntaxError
+        ? 'Failed to parse .tlc.json router config; using defaults'
+        : `Failed to load .tlc.json router config; using defaults (${error?.message || 'unknown error'})`;
+      console.warn(`[TLC WARNING] ${message}`);
+    }
     return { ...defaultConfig };
   }
 }
@@ -75,8 +85,13 @@ export async function saveRouterConfig(config, options = {}) {
   try {
     const content = await readFile(configPath, 'utf-8');
     existing = JSON.parse(content);
-  } catch {
-    // New file
+  } catch (error) {
+    if (!isMissingConfigError(error)) {
+      const message = error instanceof SyntaxError
+        ? 'Failed to parse existing .tlc.json router config; overwriting router section'
+        : `Failed to load existing .tlc.json router config; overwriting router section (${error?.message || 'unknown error'})`;
+      console.warn(`[TLC WARNING] ${message}`);
+    }
   }
 
   existing.router = config;

package/server/lib/router-config.test.js

@@ -1,4 +1,7 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import {
   loadRouterConfig,
   validateConfig,
@@ -9,6 +12,13 @@ import {
 } from './router-config.js';
 
 describe('Router Config', () => {
+  const originalCwd = process.cwd();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.chdir(originalCwd);
+  });
+
   describe('loadRouterConfig', () => {
     it('reads from .tlc.json', async () => {
       const config = await loadRouterConfig({ _readFile: vi.fn().mockResolvedValue(JSON.stringify({
@@ -28,6 +38,32 @@ describe('Router Config', () => {
       const config = await loadRouterConfig({ _readFile: vi.fn().mockResolvedValue('{}') });
       expect(config.providers).toBeDefined();
     });
+
+    it('warns when router config JSON is invalid', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const config = await loadRouterConfig({
+        _readFile: vi.fn().mockResolvedValue('{invalid json'),
+      });
+
+      expect(config).toEqual({ ...defaultConfig });
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[TLC WARNING] Failed to parse .tlc.json router config; using defaults'
+      );
+    });
+
+    it('stays silent when router config file is missing', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const error = new Error('ENOENT');
+      error.code = 'ENOENT';
+
+      const config = await loadRouterConfig({
+        _readFile: vi.fn().mockRejectedValue(error),
+      });
+
+      expect(config).toEqual({ ...defaultConfig });
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
   });
 
   describe('validateConfig', () => {
@@ -79,5 +115,25 @@ describe('Router Config', () => {
       await saveRouterConfig({ providers: {} }, { _writeFile: writeFile });
       expect(writeFile).toHaveBeenCalled();
     });
+
+    it('warns when existing router config JSON is invalid', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const tempDir = await mkdtemp(join(tmpdir(), 'router-config-test-'));
+      await writeFile(join(tempDir, '.tlc.json'), '{invalid json');
+      process.chdir(tempDir);
+
+      await saveRouterConfig(
+        { providers: {} },
+        {
+          _writeFile: vi.fn().mockResolvedValue(undefined),
+        },
+      );
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[TLC WARNING] Failed to parse existing .tlc.json router config; overwriting router section'
+      );
+
+      await rm(tempDir, { recursive: true, force: true });
+    });
   });
 });

package/server/lib/routing/index.js

@@ -0,0 +1,34 @@
+const {
+  resolveRouting,
+  loadPersonalConfig,
+  loadProjectOverride,
+  SHIPPED_DEFAULTS,
+  ROUTABLE_COMMANDS,
+} = require('../task-router-config.js');
+const { dispatch, buildProviderCommand } = require('../cli-dispatcher.js');
+const { routeCommand } = require('../command-router.js');
+const {
+  showRouting,
+  showProviders,
+  savePersonalRouting,
+  formatRoutingTable,
+  formatProviderList,
+} = require('../routing-command.js');
+const { generatePreamble } = require('../routing-preamble.js');
+
+module.exports = {
+  resolveRouting,
+  loadPersonalConfig,
+  loadProjectOverride,
+  SHIPPED_DEFAULTS,
+  ROUTABLE_COMMANDS,
+  dispatch,
+  buildProviderCommand,
+  routeCommand,
+  showRouting,
+  showProviders,
+  savePersonalRouting,
+  formatRoutingTable,
+  formatProviderList,
+  generatePreamble,
+};

package/server/lib/routing/index.test.js

@@ -0,0 +1,33 @@
+import { createRequire } from 'module';
+import { describe, it, expect } from 'vitest';
+
+const require = createRequire(import.meta.url);
+const routing = require('./index.js');
+const taskRouterConfig = require('../task-router-config.js');
+const cliDispatcher = require('../cli-dispatcher.js');
+const commandRouter = require('../command-router.js');
+const routingCommand = require('../routing-command.js');
+const routingPreamble = require('../routing-preamble.js');
+
+describe('routing barrel exports', () => {
+  it('re-exports the full routing surface from the flat modules', () => {
+    expect(routing.resolveRouting).toBe(taskRouterConfig.resolveRouting);
+    expect(routing.loadPersonalConfig).toBe(taskRouterConfig.loadPersonalConfig);
+    expect(routing.loadProjectOverride).toBe(taskRouterConfig.loadProjectOverride);
+    expect(routing.SHIPPED_DEFAULTS).toBe(taskRouterConfig.SHIPPED_DEFAULTS);
+    expect(routing.ROUTABLE_COMMANDS).toBe(taskRouterConfig.ROUTABLE_COMMANDS);
+
+    expect(routing.dispatch).toBe(cliDispatcher.dispatch);
+    expect(routing.buildProviderCommand).toBe(cliDispatcher.buildProviderCommand);
+
+    expect(routing.routeCommand).toBe(commandRouter.routeCommand);
+
+    expect(routing.showRouting).toBe(routingCommand.showRouting);
+    expect(routing.showProviders).toBe(routingCommand.showProviders);
+    expect(routing.savePersonalRouting).toBe(routingCommand.savePersonalRouting);
+    expect(routing.formatRoutingTable).toBe(routingCommand.formatRoutingTable);
+    expect(routing.formatProviderList).toBe(routingCommand.formatProviderList);
+
+    expect(routing.generatePreamble).toBe(routingPreamble.generatePreamble);
+  });
+});

package/server/lib/routing-command.js

@@ -7,6 +7,10 @@
 
 const path = require('path');
 
+function isMissingConfigError(error) {
+  return error?.code === 'ENOENT' || error?.message?.includes('ENOENT');
+}
+
 /**
  * Show effective routing table after precedence merge.
  * @param {Object} deps - Injected dependencies
@@ -70,8 +74,13 @@ function savePersonalRouting({ routing, homeDir, fs }) {
   try {
     const content = fs.readFileSync(configPath, 'utf-8');
     existing = JSON.parse(content);
-  } catch {
-    // No existing config, start fresh
+  } catch (error) {
+    if (!isMissingConfigError(error)) {
+      const message = error instanceof SyntaxError
+        ? 'Failed to parse existing personal routing config; overwriting task_routing'
+        : `Failed to load existing personal routing config; overwriting task_routing (${error?.message || 'unknown error'})`;
+      console.warn(`[TLC WARNING] ${message}`);
+    }
   }
 
   // Merge: replace task_routing, keep everything else