tlc-claude-code 2.8.0 → 2.9.0

package/server/lib/orchestration/skill-dispatcher.test.js

@@ -0,0 +1,449 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  checkHealth,
+  dispatch,
+  pollUntilDone,
+  captureResult,
+} = require('./skill-dispatcher.js');
+
+describe('skill-dispatcher', () => {
+  const tempDirs = [];
+  let originalAbortSignalTimeout;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+    originalAbortSignalTimeout = AbortSignal.timeout;
+  });
+
+  afterEach(() => {
+    AbortSignal.timeout = originalAbortSignalTimeout;
+    vi.useRealTimers();
+
+    while (tempDirs.length > 0) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  function makeTempDir() {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-dispatcher-test-'));
+    tempDirs.push(tempDir);
+    return tempDir;
+  }
+
+  function makeActiveSessionsPath() {
+    return path.join(makeTempDir(), '.tlc', '.active-sessions.json');
+  }
+
+  describe('checkHealth', () => {
+    it('returns availability with latency and uses AbortSignal.timeout', async () => {
+      const signal = { type: 'timeout-signal' };
+      const timeoutSpy = vi.fn().mockReturnValue(signal);
+      AbortSignal.timeout = timeoutSpy;
+
+      const fetch = vi.fn().mockResolvedValue({ ok: true });
+
+      const result = await checkHealth({
+        orchestratorUrl: 'http://orchestrator.test/',
+        fetch,
+        timeout: 1500,
+      });
+
+      expect(timeoutSpy).toHaveBeenCalledWith(1500);
+      expect(fetch).toHaveBeenCalledWith('http://orchestrator.test/health', {
+        signal,
+      });
+      expect(result.available).toBe(true);
+      expect(result.latencyMs).toBeTypeOf('number');
+      expect(result.latencyMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it('returns unavailable when health endpoint returns non-ok status', async () => {
+      const fetch = vi.fn().mockResolvedValue({ ok: false, status: 503 });
+
+      const result = await checkHealth({ fetch });
+
+      expect(result).toEqual({
+        available: false,
+        reason: 'health check failed with status 503',
+      });
+    });
+
+    it('returns unavailable reason for network errors', async () => {
+      const fetch = vi.fn().mockRejectedValue(new Error('connect ECONNREFUSED'));
+
+      const result = await checkHealth({ fetch });
+
+      expect(result).toEqual({
+        available: false,
+        reason: 'connect ECONNREFUSED',
+      });
+    });
+  });
+
+  describe('dispatch', () => {
+    it('posts to orchestrator and appends a session entry', async () => {
+      const activeSessionsPath = makeActiveSessionsPath();
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ id: 'session-101' }),
+      });
+
+      const result = await dispatch({
+        skill: 'design-review',
+        prompt: 'Review the architecture',
+        project: 'tlc',
+        provider: 'codex',
+        orchestratorUrl: 'http://orchestrator.test/',
+        activeSessionsPath,
+        fetch,
+      });
+
+      expect(fetch).toHaveBeenCalledWith('http://orchestrator.test/sessions', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          project: 'tlc',
+          pool: 'local-tmux',
+          command: 'codex',
+          prompt: 'Review the architecture',
+        }),
+      });
+      expect(result).toEqual({
+        sessionId: 'session-101',
+        dispatched: true,
+      });
+
+      const sessions = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'));
+      expect(sessions).toEqual([
+        {
+          sessionId: 'session-101',
+          taskName: 'design-review',
+          startedAt: expect.any(String),
+        },
+      ]);
+    });
+
+    it('uses codex as the default provider', async () => {
+      const activeSessionsPath = makeActiveSessionsPath();
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ sessionId: 'session-102' }),
+      });
+
+      await dispatch({
+        skill: 'qa',
+        prompt: 'Run QA checks',
+        project: 'tlc',
+        activeSessionsPath,
+        fetch,
+      });
+
+      expect(JSON.parse(fetch.mock.calls[0][1].body)).toEqual({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'codex',
+        prompt: 'Run QA checks',
+      });
+    });
+
+    it('creates the parent directory when missing', async () => {
+      const activeSessionsPath = makeActiveSessionsPath();
+      const parentDir = path.dirname(activeSessionsPath);
+      fs.rmSync(parentDir, { recursive: true, force: true });
+
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ id: 'session-103' }),
+      });
+
+      await dispatch({
+        skill: 'lint',
+        prompt: 'Fix lint',
+        project: 'tlc',
+        activeSessionsPath,
+        fetch,
+      });
+
+      expect(fs.existsSync(parentDir)).toBe(true);
+      expect(fs.existsSync(activeSessionsPath)).toBe(true);
+    });
+
+    it('appends to existing active sessions', async () => {
+      const activeSessionsPath = makeActiveSessionsPath();
+      fs.mkdirSync(path.dirname(activeSessionsPath), { recursive: true });
+      fs.writeFileSync(activeSessionsPath, JSON.stringify([
+        { sessionId: 'existing-1', taskName: 'existing', startedAt: '2026-04-03T00:00:00.000Z' },
+      ], null, 2));
+
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ id: 'session-104' }),
+      });
+
+      await dispatch({
+        skill: 'security',
+        prompt: 'Scan security',
+        project: 'tlc',
+        activeSessionsPath,
+        fetch,
+      });
+
+      expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([
+        { sessionId: 'existing-1', taskName: 'existing', startedAt: '2026-04-03T00:00:00.000Z' },
+        { sessionId: 'session-104', taskName: 'security', startedAt: expect.any(String) },
+      ]);
+    });
+
+    it('resets corrupt active sessions JSON to an empty array before appending', async () => {
+      const activeSessionsPath = makeActiveSessionsPath();
+      fs.mkdirSync(path.dirname(activeSessionsPath), { recursive: true });
+      fs.writeFileSync(activeSessionsPath, '{this is not valid json');
+
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ id: 'session-105' }),
+      });
+
+      await dispatch({
+        skill: 'review',
+        prompt: 'Do review',
+        project: 'tlc',
+        activeSessionsPath,
+        fetch,
+      });
+
+      expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([
+        { sessionId: 'session-105', taskName: 'review', startedAt: expect.any(String) },
+      ]);
+    });
+
+    it('returns a failure reason when the orchestrator rejects the dispatch', async () => {
+      const fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
+
+      const result = await dispatch({
+        skill: 'review',
+        prompt: 'Do review',
+        project: 'tlc',
+        fetch,
+      });
+
+      expect(result).toEqual({
+        dispatched: false,
+        reason: 'dispatch failed with status 500',
+      });
+    });
+
+    it('returns a failure reason for invalid session payloads', async () => {
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true }),
+      });
+
+      const result = await dispatch({
+        skill: 'review',
+        prompt: 'Do review',
+        project: 'tlc',
+        fetch,
+      });
+
+      expect(result).toEqual({
+        dispatched: false,
+        reason: 'invalid session response',
+      });
+    });
+
+    it('returns a failure reason for network errors', async () => {
+      const fetch = vi.fn().mockRejectedValue(new Error('socket hang up'));
+
+      const result = await dispatch({
+        skill: 'review',
+        prompt: 'Do review',
+        project: 'tlc',
+        fetch,
+      });
+
+      expect(result).toEqual({
+        dispatched: false,
+        reason: 'socket hang up',
+      });
+    });
+  });
+
+  describe('pollUntilDone', () => {
+    it('resolves when the session reaches a terminal state', async () => {
+      vi.useFakeTimers();
+
+      const fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ status: 'running', result: { progress: 10 } }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ status: 'completed', result: { summary: 'done' } }),
+        });
+
+      const pending = pollUntilDone('session-201', {
+        orchestratorUrl: 'http://orchestrator.test/',
+        interval: 1000,
+        timeout: 10000,
+        fetch,
+      });
+
+      await vi.runAllTimersAsync();
+
+      await expect(pending).resolves.toEqual({
+        status: 'completed',
+        result: { summary: 'done' },
+      });
+      expect(fetch).toHaveBeenNthCalledWith(
+        1,
+        'http://orchestrator.test/sessions/session-201/status'
+      );
+      expect(fetch).toHaveBeenNthCalledWith(
+        2,
+        'http://orchestrator.test/sessions/session-201/status'
+      );
+    });
+
+    it('treats intervals below 1000ms as 1000ms', async () => {
+      vi.useFakeTimers();
+
+      const fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ status: 'running' }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ status: 'failed', result: { reason: 'boom' } }),
+        });
+
+      const pending = pollUntilDone('session-202', {
+        orchestratorUrl: 'http://orchestrator.test',
+        interval: 100,
+        timeout: 10000,
+        fetch,
+      });
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+      await vi.advanceTimersByTimeAsync(999);
+      expect(fetch).toHaveBeenCalledTimes(1);
+      await vi.advanceTimersByTimeAsync(1);
+      await expect(pending).resolves.toEqual({
+        status: 'failed',
+        result: { reason: 'boom' },
+      });
+      expect(fetch).toHaveBeenCalledTimes(2);
+    });
+
+    it('returns top-level payload as result when result field is missing', async () => {
+      vi.useFakeTimers();
+
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ status: 'loop_detected', summary: 'stopped looping' }),
+      });
+
+      await expect(pollUntilDone('session-203', { fetch })).resolves.toEqual({
+        status: 'loop_detected',
+        result: { status: 'loop_detected', summary: 'stopped looping' },
+      });
+    });
+
+    it('rejects with Poll timeout when the session never reaches a terminal state', async () => {
+      vi.useFakeTimers();
+
+      const fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ status: 'running' }),
+      });
+
+      const pending = pollUntilDone('session-204', {
+        fetch,
+        interval: 1000,
+        timeout: 2500,
+      });
+      const assertion = expect(pending).rejects.toThrow('Poll timeout');
+
+      await vi.runAllTimersAsync();
+
+      await assertion;
+      expect(fetch).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('captureResult', () => {
+    it('returns output, exitCode, and summary from the status payload', async () => {
+      const fetch = vi.fn().mockResolvedValue({
+        status: 200,
+        json: async () => ({
+          status: 'completed',
+          result: {
+            paneSnapshot: 'build output',
+            exitCode: 0,
+            summary: 'tests passed',
+          },
+        }),
+      });
+
+      const result = await captureResult('session-301', {
+        orchestratorUrl: 'http://orchestrator.test/',
+        fetch,
+      });
+
+      expect(fetch).toHaveBeenCalledWith('http://orchestrator.test/sessions/session-301/status');
+      expect(result).toEqual({
+        output: 'build output',
+        exitCode: 0,
+        summary: 'tests passed',
+      });
+    });
+
+    it('returns output null for 404 responses', async () => {
+      const fetch = vi.fn().mockResolvedValue({
+        status: 404,
+        json: async () => ({ message: 'missing' }),
+      });
+
+      const result = await captureResult('session-302', { fetch });
+
+      expect(result).toEqual({ output: null });
+    });
+
+    it('reads top-level paneSnapshot fields when result is not nested', async () => {
+      const fetch = vi.fn().mockResolvedValue({
+        status: 200,
+        json: async () => ({
+          paneSnapshot: 'stdout',
+          exitCode: 17,
+          summary: 'failed',
+        }),
+      });
+
+      const result = await captureResult('session-303', { fetch });
+
+      expect(result).toEqual({
+        output: 'stdout',
+        exitCode: 17,
+        summary: 'failed',
+      });
+    });
+
+    it('returns output null and the error message on network failure', async () => {
+      const fetch = vi.fn().mockRejectedValue(new Error('connect ETIMEDOUT'));
+
+      const result = await captureResult('session-304', { fetch });
+
+      expect(result).toEqual({
+        output: null,
+        error: 'connect ETIMEDOUT',
+      });
+    });
+  });
+});