tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/scaffolding/snapshot-manager.test.js

@@ -0,0 +1,225 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'path';
+
+const fixedDate = new Date('2026-03-30T08:15:00.000Z');
+const mockedFs = vi.hoisted(() => ({
+  copyFileSync: vi.fn(),
+}));
+
+vi.mock('fs', () => mockedFs);
+
+describe('snapshot-manager', () => {
+  let exec;
+  let fsMock;
+  let takeSnapshot;
+  let restoreSnapshot;
+  let listSnapshots;
+  let enforceRetention;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.useFakeTimers();
+    vi.setSystemTime(fixedDate);
+
+    exec = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+    mockedFs.copyFileSync.mockReset();
+    fsMock = {
+      ...mockedFs,
+      readdirSync: vi.fn(),
+      statSync: vi.fn(),
+      unlinkSync: vi.fn(),
+    };
+
+    ({
+      takeSnapshot,
+      restoreSnapshot,
+      listSnapshots,
+      enforceRetention,
+    } = await import('./snapshot-manager.js'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('PostgreSQL snapshot runs pg_dump with correct args', async () => {
+    const result = await takeSnapshot({
+      dbType: 'postgresql',
+      connectionString: 'postgres://user:secret@db.example.com:5432/app_db',
+      snapshotDir: '/tmp/snaps',
+      gitRef: 'abc1234',
+      exec,
+    });
+
+    expect(exec).toHaveBeenCalledWith(
+      'pg_dump --format=custom -f "/tmp/snaps/2026-03-30-abc1234-app_db.dump" "postgres://user:secret@db.example.com:5432/app_db"'
+    );
+    expect(result).toEqual({
+      success: true,
+      snapshotPath: '/tmp/snaps/2026-03-30-abc1234-app_db.dump',
+    });
+  });
+
+  it('MySQL snapshot runs mysqldump with correct args', async () => {
+    const result = await takeSnapshot({
+      dbType: 'mysql',
+      connectionString: 'mysql://root:secret@mysql.example.com:3307/shop',
+      snapshotDir: '/tmp/snaps',
+      gitRef: 'feature-x',
+      exec,
+    });
+
+    expect(exec).toHaveBeenCalledWith(
+      'mysqldump --host=mysql.example.com --port=3307 --user=root --password=secret shop > "/tmp/snaps/2026-03-30-feature-x-shop.dump"'
+    );
+    expect(result.snapshotPath).toBe('/tmp/snaps/2026-03-30-feature-x-shop.dump');
+  });
+
+  it('SQLite snapshot copies file', async () => {
+    const result = await takeSnapshot({
+      dbType: 'sqlite',
+      connectionString: '/data/app.sqlite',
+      snapshotDir: '/tmp/snaps',
+      gitRef: 'main',
+      exec,
+      fs: fsMock,
+    });
+
+    expect(fsMock.copyFileSync).toHaveBeenCalledWith(
+      '/data/app.sqlite',
+      '/tmp/snaps/2026-03-30-main-app.dump'
+    );
+    expect(exec).not.toHaveBeenCalled();
+    expect(result.snapshotPath).toBe('/tmp/snaps/2026-03-30-main-app.dump');
+  });
+
+  it('Snapshot filename has correct format', async () => {
+    const result = await takeSnapshot({
+      dbType: 'postgresql',
+      connectionString: 'postgres://user:secret@localhost:5432/reporting',
+      snapshotDir: '/tmp/snaps',
+      gitRef: 'release-1',
+      exec,
+    });
+
+    expect(path.basename(result.snapshotPath)).toBe('2026-03-30-release-1-reporting.dump');
+  });
+
+  it('Restore runs correct command per dbType', async () => {
+    await restoreSnapshot({
+      snapshotPath: '/tmp/snaps/sample.dump',
+      dbType: 'postgresql',
+      connectionString: 'postgres://user:secret@db.example.com:5432/app_db',
+      exec,
+    });
+
+    expect(exec).toHaveBeenNthCalledWith(
+      1,
+      'pg_restore --clean --if-exists --dbname="postgres://user:secret@db.example.com:5432/app_db" "/tmp/snaps/sample.dump"'
+    );
+
+    await restoreSnapshot({
+      snapshotPath: '/tmp/snaps/sample.dump',
+      dbType: 'mysql',
+      connectionString: 'mysql://root:secret@mysql.example.com:3307/shop',
+      exec,
+    });
+
+    expect(exec).toHaveBeenNthCalledWith(
+      2,
+      'mysql --host=mysql.example.com --port=3307 --user=root --password=secret shop < "/tmp/snaps/sample.dump"'
+    );
+
+    await restoreSnapshot({
+      snapshotPath: '/tmp/snaps/sample.dump',
+      dbType: 'sqlite',
+      connectionString: '/data/app.sqlite',
+      exec,
+      fs: fsMock,
+    });
+
+    expect(fsMock.copyFileSync).toHaveBeenCalledWith('/tmp/snaps/sample.dump', '/data/app.sqlite');
+  });
+
+  it('List returns snapshots sorted newest first', () => {
+    fsMock.readdirSync.mockReturnValue([
+      '2026-03-28-main-app.dump',
+      '2026-03-30-feature-app.dump',
+      '2026-03-29-fix-auth.dump',
+    ]);
+    fsMock.statSync.mockImplementation((filePath) => ({
+      size: filePath.includes('feature') ? 300 : filePath.includes('fix') ? 200 : 100,
+    }));
+
+    const result = listSnapshots({
+      snapshotDir: '/tmp/snaps',
+      fs: fsMock,
+    });
+
+    expect(result).toEqual([
+      {
+        path: '/tmp/snaps/2026-03-30-feature-app.dump',
+        date: '2026-03-30',
+        gitRef: 'feature',
+        dbName: 'app',
+        size: 300,
+      },
+      {
+        path: '/tmp/snaps/2026-03-29-fix-auth.dump',
+        date: '2026-03-29',
+        gitRef: 'fix',
+        dbName: 'auth',
+        size: 200,
+      },
+      {
+        path: '/tmp/snaps/2026-03-28-main-app.dump',
+        date: '2026-03-28',
+        gitRef: 'main',
+        dbName: 'app',
+        size: 100,
+      },
+    ]);
+  });
+
+  it('Retention deletes oldest when over limit', () => {
+    fsMock.readdirSync.mockReturnValue([
+      '2026-03-27-main-app.dump',
+      '2026-03-28-main-app.dump',
+      '2026-03-29-main-app.dump',
+      '2026-03-30-main-app.dump',
+    ]);
+    fsMock.statSync.mockImplementation(() => ({ size: 100 }));
+
+    const deleted = enforceRetention({
+      snapshotDir: '/tmp/snaps',
+      maxSnapshots: 2,
+      fs: fsMock,
+    });
+
+    expect(fsMock.unlinkSync).toHaveBeenCalledTimes(2);
+    expect(fsMock.unlinkSync).toHaveBeenNthCalledWith(1, '/tmp/snaps/2026-03-27-main-app.dump');
+    expect(fsMock.unlinkSync).toHaveBeenNthCalledWith(2, '/tmp/snaps/2026-03-28-main-app.dump');
+    expect(deleted).toEqual([
+      '/tmp/snaps/2026-03-27-main-app.dump',
+      '/tmp/snaps/2026-03-28-main-app.dump',
+    ]);
+  });
+
+  it('DB unreachable returns failure with reason', async () => {
+    exec.mockRejectedValueOnce(new Error('connect ECONNREFUSED'));
+
+    const result = await takeSnapshot({
+      dbType: 'postgresql',
+      connectionString: 'postgres://user:secret@localhost:5432/app_db',
+      snapshotDir: '/tmp/snaps',
+      gitRef: 'abc1234',
+      exec,
+    });
+
+    expect(result).toEqual({
+      success: false,
+      reason: 'connect ECONNREFUSED',
+      error: expect.any(Error),
+    });
+  });
+});

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

@@ -23,28 +23,50 @@ const ROUTABLE_COMMANDS = [
 ];
 
 /**
- * Default routing: coding commands → codex, thinking commands → claude.
+ * Dispatch modes for provider execution.
  *
- * Coding: build, quick, autofix (single) + edge-cases, review (parallel)
- * Thinking: plan, discuss, docs, coverage, test, design, vision (single)
+ * - 'interactive': Provider needs write access (build, fix, implement).
+ *   Dispatched via tmux session with --dangerously-bypass-approvals-and-sandbox.
+ *   Codex exec sandbox blocks disk writes — interactive mode is required for coding.
  *
- * @type {Record<string, {models: string[], strategy: string}>}
+ * - 'exec': Provider only reads (review, analysis, coverage).
+ *   Dispatched via `codex exec --full-auto` or `gemini -p`. Fast, no tmux needed.
+ *
+ * - 'inline': Runs in the current Claude session (discuss, plan, docs).
+ *   No external dispatch.
+ */
+const DISPATCH_MODES = {
+  interactive: 'interactive',
+  exec: 'exec',
+  inline: 'inline',
+};
+
+/**
+ * Default routing: coding commands → codex interactive, review → codex exec,
+ * thinking commands → claude inline.
+ *
+ * Coding (write): build, quick, autofix → codex interactive (tmux)
+ * Analysis (read): review, edge-cases → codex exec
+ * Thinking: plan, discuss, docs, coverage → claude inline
+ *
+ * @type {Record<string, {models: string[], strategy: string, mode: string}>}
  */
 const SHIPPED_DEFAULTS = {
-  // Coding — codex
-  'build':      { models: ['codex'], strategy: 'single' },
-  'quick':      { models: ['codex'], strategy: 'single' },
-  'autofix':    { models: ['codex'], strategy: 'single' },
-  'edge-cases': { models: ['codex'], strategy: 'parallel' },
-  'review':     { models: ['codex', 'claude'], strategy: 'parallel' },
-  // Thinking — claude
-  'plan':       { models: ['codex', 'claude'], strategy: 'parallel' },
-  'discuss':    { models: ['claude'], strategy: 'single' },
-  'docs':       { models: ['claude'], strategy: 'single' },
-  'coverage':   { models: ['claude'], strategy: 'single' },
-  'test':       { models: ['claude'], strategy: 'single' },
-  'design':     { models: ['claude'], strategy: 'single' },
-  'vision':     { models: ['claude'], strategy: 'single' },
+  // Coding — codex interactive (needs disk writes, tmux session)
+  'build':      { models: ['codex'], strategy: 'single', mode: 'interactive' },
+  'quick':      { models: ['codex'], strategy: 'single', mode: 'interactive' },
+  'autofix':    { models: ['codex'], strategy: 'single', mode: 'interactive' },
+  // Analysis — codex exec (read-only, fast)
+  'edge-cases': { models: ['codex'], strategy: 'parallel', mode: 'exec' },
+  'review':     { models: ['codex', 'claude'], strategy: 'parallel', mode: 'exec' },
+  // Thinking — claude inline
+  'plan':       { models: ['codex', 'claude'], strategy: 'parallel', mode: 'inline' },
+  'discuss':    { models: ['claude'], strategy: 'single', mode: 'inline' },
+  'docs':       { models: ['claude'], strategy: 'single', mode: 'inline' },
+  'coverage':   { models: ['claude'], strategy: 'single', mode: 'exec' },
+  'test':       { models: ['claude'], strategy: 'single', mode: 'inline' },
+  'design':     { models: ['claude'], strategy: 'single', mode: 'inline' },
+  'vision':     { models: ['claude'], strategy: 'single', mode: 'inline' },
 };
 
 /**
@@ -107,9 +129,10 @@ function loadProjectOverride({ projectDir, fs }) {
  */
 function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDir = require('os').homedir(), fs = require('fs') }) {
   // Start with shipped defaults
-  const defaultEntry = SHIPPED_DEFAULTS[command] || { models: ['claude'], strategy: 'single' };
+  const defaultEntry = SHIPPED_DEFAULTS[command] || { models: ['claude'], strategy: 'single', mode: 'inline' };
   let models = [...defaultEntry.models];
   let strategy = defaultEntry.strategy;
+  let mode = defaultEntry.mode || 'inline';
   let source = 'shipped-defaults';
   let providers;
   const warnings = [];
@@ -136,6 +159,9 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
       if (personalRouting.strategy) {
         strategy = personalRouting.strategy;
       }
+      if (personalRouting.mode) {
+        mode = personalRouting.mode;
+      }
       source = 'personal-config';
     }
   }
@@ -157,6 +183,9 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
       if (overrideEntry.strategy) {
         strategy = overrideEntry.strategy;
       }
+      if (overrideEntry.mode) {
+        mode = overrideEntry.mode;
+      }
       source = 'project-override';
     }
   }
@@ -168,7 +197,7 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
     source = 'flag-override';
   }
 
-  const result = { models, strategy, source, warnings };
+  const result = { models, strategy, mode, source, warnings };
   if (providers) {
     result.providers = providers;
   }
@@ -181,4 +210,5 @@ module.exports = {
   loadProjectOverride,
   SHIPPED_DEFAULTS,
   ROUTABLE_COMMANDS,
+  DISPATCH_MODES,
 };

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

@@ -27,22 +27,25 @@ function mockFs(fileMap = {}) {
 describe('task-router-config', () => {
   // ── SHIPPED_DEFAULTS ──────────────────────────────────────────────
   describe('SHIPPED_DEFAULTS', () => {
-    it('routes coding commands to codex', () => {
-      expect(SHIPPED_DEFAULTS['build']).toEqual({ models: ['codex'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['quick']).toEqual({ models: ['codex'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['autofix']).toEqual({ models: ['codex'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['edge-cases']).toEqual({ models: ['codex'], strategy: 'parallel' });
-      expect(SHIPPED_DEFAULTS['review']).toEqual({ models: ['codex', 'claude'], strategy: 'parallel' });
+    it('routes coding commands to codex interactive', () => {
+      expect(SHIPPED_DEFAULTS['build']).toEqual({ models: ['codex'], strategy: 'single', mode: 'interactive' });
+      expect(SHIPPED_DEFAULTS['quick']).toEqual({ models: ['codex'], strategy: 'single', mode: 'interactive' });
+      expect(SHIPPED_DEFAULTS['autofix']).toEqual({ models: ['codex'], strategy: 'single', mode: 'interactive' });
     });
 
-    it('routes thinking commands to claude', () => {
-      expect(SHIPPED_DEFAULTS['plan']).toEqual({ models: ['codex', 'claude'], strategy: 'parallel' });
-      expect(SHIPPED_DEFAULTS['discuss']).toEqual({ models: ['claude'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['docs']).toEqual({ models: ['claude'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['coverage']).toEqual({ models: ['claude'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['test']).toEqual({ models: ['claude'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['design']).toEqual({ models: ['claude'], strategy: 'single' });
-      expect(SHIPPED_DEFAULTS['vision']).toEqual({ models: ['claude'], strategy: 'single' });
+    it('routes analysis commands to exec mode', () => {
+      expect(SHIPPED_DEFAULTS['edge-cases']).toEqual({ models: ['codex'], strategy: 'parallel', mode: 'exec' });
+      expect(SHIPPED_DEFAULTS['review']).toEqual({ models: ['codex', 'claude'], strategy: 'parallel', mode: 'exec' });
+      expect(SHIPPED_DEFAULTS['coverage']).toEqual({ models: ['claude'], strategy: 'single', mode: 'exec' });
+    });
+
+    it('routes thinking commands to claude inline', () => {
+      expect(SHIPPED_DEFAULTS['plan']).toEqual({ models: ['codex', 'claude'], strategy: 'parallel', mode: 'inline' });
+      expect(SHIPPED_DEFAULTS['discuss']).toEqual({ models: ['claude'], strategy: 'single', mode: 'inline' });
+      expect(SHIPPED_DEFAULTS['docs']).toEqual({ models: ['claude'], strategy: 'single', mode: 'inline' });
+      expect(SHIPPED_DEFAULTS['test']).toEqual({ models: ['claude'], strategy: 'single', mode: 'inline' });
+      expect(SHIPPED_DEFAULTS['design']).toEqual({ models: ['claude'], strategy: 'single', mode: 'inline' });
+      expect(SHIPPED_DEFAULTS['vision']).toEqual({ models: ['claude'], strategy: 'single', mode: 'inline' });
     });
 
     it('has an entry for every routable command', () => {
@@ -156,6 +159,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['codex'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'shipped-defaults',
         warnings: [],
       });
@@ -173,6 +177,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['claude'],
         strategy: 'single',
+        mode: 'inline',
         source: 'shipped-defaults',
         warnings: [],
       });
@@ -198,6 +203,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['codex'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'personal-config',
         warnings: [],
       });
@@ -229,6 +235,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['local'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'project-override',
         warnings: [],
       });
@@ -261,6 +268,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['gemini'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'flag-override',
         warnings: [],
       });
@@ -278,6 +286,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['claude'],
         strategy: 'single',
+        mode: 'inline',
         source: 'shipped-defaults',
         warnings: [],
       });
@@ -303,11 +312,12 @@ describe('task-router-config', () => {
       expect(reviewResult).toEqual({
         models: ['claude', 'codex'],
         strategy: 'parallel',
+        mode: 'exec',
         source: 'personal-config',
         warnings: [],
       });
 
-      // 'build' should still use its shipped default (codex/single)
+      // 'build' should still use its shipped default (codex/single/interactive)
       const buildResult = resolveRouting({
         command: 'build',
         projectDir: '/project',
@@ -317,6 +327,7 @@ describe('task-router-config', () => {
       expect(buildResult).toEqual({
         models: ['codex'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'shipped-defaults',
         warnings: [],
       });
@@ -388,6 +399,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['local'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'project-override',
         warnings: [],
       });
@@ -428,6 +440,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['codex'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'shipped-defaults',
         warnings: [expect.stringContaining('/home/user/.tlc/config.json')],
       });
@@ -448,6 +461,7 @@ describe('task-router-config', () => {
       expect(result).toEqual({
         models: ['codex'],
         strategy: 'single',
+        mode: 'interactive',
         source: 'shipped-defaults',
         warnings: [expect.stringContaining('/project/.tlc.json')],
       });