tlc-claude-code 1.4.1 → 1.4.2

package/server/lib/cli-provider.test.js

@@ -0,0 +1,349 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createCLIProvider,
+  buildArgs,
+  parseOutput,
+  runLocal,
+  runViaDevserver,
+} from './cli-provider.js';
+
+// Mock child_process
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  execSync: vi.fn(),
+}));
+
+// Mock fetch for devserver calls
+global.fetch = vi.fn();
+
+import { spawn } from 'child_process';
+
+describe('cli-provider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createCLIProvider', () => {
+    it('creates provider with CLI type', () => {
+      const provider = createCLIProvider({
+        name: 'claude',
+        command: 'claude',
+        headlessArgs: ['-p', '--output-format', 'json'],
+        capabilities: ['review', 'code-gen'],
+      });
+
+      expect(provider.type).toBe('cli');
+      expect(provider.name).toBe('claude');
+    });
+
+    it('sets detected based on CLI detection', () => {
+      const provider = createCLIProvider({
+        name: 'claude',
+        command: 'claude',
+        detected: true,
+      });
+
+      expect(provider.detected).toBe(true);
+    });
+
+    it('defaults detected to false', () => {
+      const provider = createCLIProvider({
+        name: 'claude',
+        command: 'claude',
+      });
+
+      expect(provider.detected).toBe(false);
+    });
+  });
+
+  describe('runLocal', () => {
+    it('spawns claude -p with args', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      // Simulate process completion
+      setTimeout(() => {
+        const stdoutCallback = mockProcess.stdout.on.mock.calls.find(c => c[0] === 'data')[1];
+        stdoutCallback(Buffer.from('{"result": "ok"}'));
+
+        const closeCallback = mockProcess.on.mock.calls.find(c => c[0] === 'close')[1];
+        closeCallback(0);
+      }, 10);
+
+      const result = await runLocal('claude', 'test prompt', {
+        headlessArgs: ['-p', '--output-format', 'json'],
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'claude',
+        expect.arrayContaining(['-p', '--output-format', 'json']),
+        expect.any(Object)
+      );
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('spawns codex exec with args', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      setTimeout(() => {
+        const stdoutCallback = mockProcess.stdout.on.mock.calls.find(c => c[0] === 'data')[1];
+        stdoutCallback(Buffer.from('{"result": "ok"}'));
+
+        const closeCallback = mockProcess.on.mock.calls.find(c => c[0] === 'close')[1];
+        closeCallback(0);
+      }, 10);
+
+      await runLocal('codex', 'test prompt', {
+        headlessArgs: ['exec', '--json', '--sandbox', 'read-only'],
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        expect.arrayContaining(['exec', '--json', '--sandbox', 'read-only']),
+        expect.any(Object)
+      );
+    });
+
+    it('spawns gemini -p with args', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      setTimeout(() => {
+        const stdoutCallback = mockProcess.stdout.on.mock.calls.find(c => c[0] === 'data')[1];
+        stdoutCallback(Buffer.from('{"result": "ok"}'));
+
+        const closeCallback = mockProcess.on.mock.calls.find(c => c[0] === 'close')[1];
+        closeCallback(0);
+      }, 10);
+
+      await runLocal('gemini', 'test prompt', {
+        headlessArgs: ['-p', '--output-format', 'json'],
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'gemini',
+        expect.arrayContaining(['-p', '--output-format', 'json']),
+        expect.any(Object)
+      );
+    });
+
+    it('parses JSON output', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      setTimeout(() => {
+        const stdoutCallback = mockProcess.stdout.on.mock.calls.find(c => c[0] === 'data')[1];
+        stdoutCallback(Buffer.from('{"summary": "LGTM", "score": 85}'));
+
+        const closeCallback = mockProcess.on.mock.calls.find(c => c[0] === 'close')[1];
+        closeCallback(0);
+      }, 10);
+
+      const result = await runLocal('claude', 'test', { headlessArgs: ['-p'] });
+
+      expect(result.parsed).toEqual({ summary: 'LGTM', score: 85 });
+    });
+
+    it('handles non-JSON output', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      setTimeout(() => {
+        const stdoutCallback = mockProcess.stdout.on.mock.calls.find(c => c[0] === 'data')[1];
+        stdoutCallback(Buffer.from('Plain text output'));
+
+        const closeCallback = mockProcess.on.mock.calls.find(c => c[0] === 'close')[1];
+        closeCallback(0);
+      }, 10);
+
+      const result = await runLocal('claude', 'test', { headlessArgs: ['-p'] });
+
+      expect(result.raw).toBe('Plain text output');
+      expect(result.parsed).toBeNull();
+    });
+
+    it('respects timeout', async () => {
+      const mockProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+        kill: vi.fn(),
+      };
+
+      spawn.mockReturnValue(mockProcess);
+
+      // Don't complete the process - let it timeout
+      const promise = runLocal('claude', 'test', {
+        headlessArgs: ['-p'],
+        timeout: 50,
+      });
+
+      await expect(promise).rejects.toThrow(/timeout/i);
+    });
+  });
+
+  describe('runViaDevserver', () => {
+    it('posts to devserver API', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ taskId: 'task-123' }),
+      });
+
+      // Mock polling response
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ taskId: 'task-123' }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({
+            status: 'completed',
+            result: { raw: '{}', parsed: {}, exitCode: 0 },
+          }),
+        });
+
+      const result = await runViaDevserver({
+        devserverUrl: 'https://devserver.example.com',
+        provider: 'claude',
+        prompt: 'test prompt',
+        opts: {},
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://devserver.example.com/api/run',
+        expect.objectContaining({
+          method: 'POST',
+        })
+      );
+    });
+
+    it('polls for result', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ taskId: 'task-123' }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ status: 'running' }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({
+            status: 'completed',
+            result: { raw: '{"done": true}', parsed: { done: true }, exitCode: 0 },
+          }),
+        });
+
+      const result = await runViaDevserver({
+        devserverUrl: 'https://devserver.example.com',
+        provider: 'claude',
+        prompt: 'test',
+        opts: {},
+        pollInterval: 10,
+      });
+
+      expect(global.fetch).toHaveBeenCalledTimes(3);
+      expect(result.parsed).toEqual({ done: true });
+    });
+  });
+
+  describe('buildArgs', () => {
+    it('includes output-format json', () => {
+      const args = buildArgs('claude', 'test prompt', {
+        headlessArgs: ['-p', '--output-format', 'json'],
+      });
+
+      expect(args).toContain('--output-format');
+      expect(args).toContain('json');
+    });
+
+    it('includes sandbox for codex', () => {
+      const args = buildArgs('codex', 'test prompt', {
+        headlessArgs: ['exec', '--json', '--sandbox', 'read-only'],
+      });
+
+      expect(args).toContain('--sandbox');
+      expect(args).toContain('read-only');
+    });
+
+    it('includes prompt in args', () => {
+      const args = buildArgs('claude', 'review this code', {
+        headlessArgs: ['-p'],
+      });
+
+      expect(args).toContain('review this code');
+    });
+
+    it('includes cwd option', () => {
+      const args = buildArgs('claude', 'test', {
+        headlessArgs: ['-p'],
+        cwd: '/project/dir',
+      });
+
+      // cwd is passed to spawn options, not args
+      // But buildArgs should handle it
+      expect(args).toBeDefined();
+    });
+  });
+
+  describe('parseOutput', () => {
+    it('parses valid JSON', () => {
+      const result = parseOutput('{"key": "value"}');
+      expect(result).toEqual({ key: 'value' });
+    });
+
+    it('returns null for invalid JSON', () => {
+      const result = parseOutput('not json');
+      expect(result).toBeNull();
+    });
+
+    it('handles empty output', () => {
+      const result = parseOutput('');
+      expect(result).toBeNull();
+    });
+
+    it('handles multiline JSON', () => {
+      const result = parseOutput(`{
+        "key": "value",
+        "nested": {
+          "array": [1, 2, 3]
+        }
+      }`);
+      expect(result.nested.array).toEqual([1, 2, 3]);
+    });
+
+    it('extracts JSON from mixed output', () => {
+      // Some CLIs may output text before/after JSON
+      const result = parseOutput('Some text\n{"result": "ok"}\nMore text');
+      expect(result).toEqual({ result: 'ok' });
+    });
+  });
+});

package/server/lib/debug.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  findOrphanedAgents,
+  resetCleanup,
+} from './server/lib/agent-cleanup.js';
+import { getAgentRegistry, resetRegistry } from './server/lib/agent-registry.js';
+import { STATES } from './server/lib/agent-state.js';
+
+describe('debug', () => {
+  const BASE_TIME = new Date('2025-01-01T12:00:00Z').getTime();
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(BASE_TIME);
+    resetRegistry();
+    resetCleanup();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('debug test', () => {
+    const registry = getAgentRegistry();
+    
+    console.log('BASE_TIME:', BASE_TIME);
+    console.log('Date.now() in test:', Date.now());
+    
+    const lastActivity = Date.now() - 35 * 60 * 1000;
+    console.log('lastActivity:', lastActivity);
+    
+    const id = registry.registerAgent({
+      name: 'stuck-agent',
+      model: 'claude-3',
+      type: 'worker',
+      status: STATES.RUNNING,
+      lastActivity: lastActivity,
+    });
+    
+    const agent = registry.getAgent(id);
+    console.log('Registered agent:', agent);
+    console.log('Agent status:', agent.status);
+    console.log('Agent lastActivity:', agent.lastActivity);
+    
+    const running = registry.listAgents({ status: STATES.RUNNING });
+    console.log('Running agents:', running.length);
+    
+    const orphans = findOrphanedAgents();
+    console.log('Orphans found:', orphans.length);
+
+    // Let's see what Date.now() returns inside the filter
+    const timeout = 30 * 60 * 1000;
+    const now = Date.now();
+    console.log('now in test scope:', now);
+    console.log('lastActivity:', agent.lastActivity);
+    console.log('inactiveTime would be:', now - agent.lastActivity);
+    console.log('timeout:', timeout);
+    console.log('inactiveTime > timeout:', (now - agent.lastActivity) > timeout);
+
+    expect(orphans).toHaveLength(1);
+  });
+});

package/server/lib/devserver-router-api.js

@@ -0,0 +1,249 @@
+/**
+ * Devserver Router API - HTTP endpoints for task execution
+ */
+
+import { createRouter } from './model-router.js';
+import { createQueue } from './provider-queue.js';
+
+/**
+ * Create router API handlers
+ * @param {Object} options - API options
+ * @param {string} options.secret - Authentication secret
+ * @param {Object} [options.routerConfig] - Router configuration
+ * @param {Object} [options.queueConfig] - Queue configuration
+ * @returns {Promise<Object>} API handlers
+ */
+export async function createRouterAPI(options = {}) {
+  const { secret, routerConfig, queueConfig } = options;
+
+  // Initialize router and queue
+  const router = await createRouter(routerConfig);
+  const queue = createQueue(queueConfig);
+
+  return {
+    handleRun: handleRun(router, queue),
+    handleTaskStatus: handleTaskStatus(queue),
+    handleReview: handleReview(router),
+    handleDesign: handleDesign(router),
+    handleHealth: handleHealth(router),
+    validateAuth: validateAuth(secret),
+    router,
+    queue,
+  };
+}
+
+/**
+ * Handle POST /api/run - Queue a task
+ * @param {Object} router - Router instance
+ * @param {Object} queue - Queue instance
+ * @returns {Function} Express handler
+ */
+export function handleRun(router, queue) {
+  return async (req, res) => {
+    try {
+      const { capability, prompt, options = {} } = req.body;
+
+      // Create task function
+      const taskFn = async () => {
+        return await router.run(capability, prompt, options);
+      };
+
+      // Enqueue the task
+      const taskId = await queue.enqueue(taskFn, {
+        priority: options.priority || 5,
+        capability,
+      });
+
+      res.json({ taskId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  };
+}
+
+/**
+ * Handle GET /api/task/:taskId - Get task status
+ * @param {Object} queue - Queue instance
+ * @returns {Function} Express handler
+ */
+export function handleTaskStatus(queue) {
+  return async (req, res) => {
+    try {
+      const { taskId } = req.params;
+      const task = queue.getTask(taskId);
+
+      if (!task) {
+        return res.status(404).json({ error: 'Task not found' });
+      }
+
+      res.json({
+        status: task.status,
+        result: task.result,
+        error: task.error,
+        createdAt: task.createdAt,
+        completedAt: task.completedAt,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  };
+}
+
+/**
+ * Handle POST /api/review - Multi-model review
+ * @param {Object} router - Router instance
+ * @returns {Function} Express handler
+ */
+export function handleReview(router) {
+  return async (req, res) => {
+    try {
+      const { code, prompt = 'Review this code', options = {} } = req.body;
+
+      const fullPrompt = code ? `${prompt}\n\n\`\`\`\n${code}\n\`\`\`` : prompt;
+
+      const results = await router.run('review', fullPrompt, options);
+
+      // Calculate consensus
+      const consensus = calculateConsensus(results);
+
+      res.json({
+        consensus,
+        results,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  };
+}
+
+/**
+ * Handle POST /api/design - Design generation
+ * @param {Object} router - Router instance
+ * @returns {Function} Express handler
+ */
+export function handleDesign(router) {
+  return async (req, res) => {
+    try {
+      const { prompt, options = {} } = req.body;
+
+      const results = await router.run('design', prompt, options);
+
+      // Return first successful result
+      const successful = results.find((r) => r.success);
+
+      res.json({
+        result: successful?.result || null,
+        provider: successful?.provider,
+        error: successful ? null : 'No successful design generated',
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  };
+}
+
+/**
+ * Handle GET /api/health - Provider health
+ * @param {Object} router - Router instance
+ * @returns {Function} Express handler
+ */
+export function handleHealth(router) {
+  return async (req, res) => {
+    try {
+      const status = router.getStatus();
+
+      // Check if at least one provider is available
+      const hasAvailable = Object.values(status.providers || {}).some(
+        (p) => p.detected || p.type === 'api'
+      );
+
+      res.json({
+        healthy: hasAvailable,
+        providers: status.providers,
+        devserver: status.devserver,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message, healthy: false });
+    }
+  };
+}
+
+/**
+ * Authentication middleware
+ * @param {string} secret - Expected secret
+ * @returns {Function} Express middleware
+ */
+export function validateAuth(secret) {
+  return (req, res, next) => {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader) {
+      return res.status(401).json({ error: 'Authorization header required' });
+    }
+
+    const token = authHeader.replace('Bearer ', '');
+
+    if (token !== secret) {
+      return res.status(401).json({ error: 'Invalid authorization token' });
+    }
+
+    next();
+  };
+}
+
+/**
+ * Request body validation middleware
+ * @param {string[]} requiredFields - Required field names
+ * @returns {Function} Express middleware
+ */
+export function validateRequestBody(requiredFields) {
+  return (req, res, next) => {
+    const body = req.body || {};
+    const missing = requiredFields.filter((field) => !body[field]);
+
+    if (missing.length > 0) {
+      return res.status(400).json({
+        error: `Missing required fields: ${missing.join(', ')}`,
+      });
+    }
+
+    next();
+  };
+}
+
+/**
+ * Calculate consensus from multiple provider results
+ * @param {Object[]} results - Provider results
+ * @returns {Object} Consensus result
+ */
+function calculateConsensus(results) {
+  const successful = results.filter((r) => r.success);
+
+  if (successful.length === 0) {
+    return { approved: false, reason: 'No successful reviews' };
+  }
+
+  // Count approvals
+  const approvals = successful.filter((r) => r.result?.approved).length;
+  const total = successful.length;
+
+  // Majority vote
+  const approved = approvals > total / 2;
+
+  // Average score if available
+  const scores = successful
+    .map((r) => r.result?.score)
+    .filter((s) => typeof s === 'number');
+
+  const averageScore =
+    scores.length > 0
+      ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length)
+      : null;
+
+  return {
+    approved,
+    votes: { approve: approvals, reject: total - approvals },
+    averageScore,
+    providers: successful.map((r) => r.provider),
+  };
+}