tlc-claude-code 1.4.1 → 1.4.4

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

@@ -0,0 +1,269 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  detectCLI,
+  detectAllCLIs,
+  clearCache,
+  getCapabilities,
+  CLI_TOOLS,
+} from './cli-detector.js';
+
+// Mock child_process
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+  exec: vi.fn(),
+}));
+
+import { execSync } from 'child_process';
+
+describe('cli-detector', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearCache();
+  });
+
+  describe('detectCLI', () => {
+    it('finds claude when installed', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('which claude') || cmd.includes('where claude')) {
+          return Buffer.from('/usr/local/bin/claude\n');
+        }
+        if (cmd.includes('--version')) {
+          return Buffer.from('claude v4.2.1\n');
+        }
+        throw new Error('Command not found');
+      });
+
+      const result = await detectCLI('claude');
+
+      expect(result).not.toBeNull();
+      expect(result.name).toBe('claude');
+      expect(result.path).toContain('claude');
+    });
+
+    it('returns null when CLI not installed', async () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Command not found');
+      });
+
+      const result = await detectCLI('claude');
+
+      expect(result).toBeNull();
+    });
+
+    it('gets version string', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('which') || cmd.includes('where')) {
+          return Buffer.from('/usr/local/bin/claude\n');
+        }
+        if (cmd.includes('--version')) {
+          return Buffer.from('claude v4.2.1\n');
+        }
+        return Buffer.from('');
+      });
+
+      const result = await detectCLI('claude');
+
+      expect(result.version).toBe('v4.2.1');
+    });
+
+    it('detects codex CLI', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('which codex') || cmd.includes('where codex')) {
+          return Buffer.from('/usr/local/bin/codex\n');
+        }
+        if (cmd.includes('--version')) {
+          return Buffer.from('codex 1.3.0\n');
+        }
+        throw new Error('not found');
+      });
+
+      const result = await detectCLI('codex');
+
+      expect(result).not.toBeNull();
+      expect(result.name).toBe('codex');
+    });
+
+    it('detects gemini CLI', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('which gemini') || cmd.includes('where gemini')) {
+          return Buffer.from('/usr/local/bin/gemini\n');
+        }
+        if (cmd.includes('--version')) {
+          return Buffer.from('gemini 0.9.2\n');
+        }
+        throw new Error('not found');
+      });
+
+      const result = await detectCLI('gemini');
+
+      expect(result).not.toBeNull();
+      expect(result.name).toBe('gemini');
+    });
+  });
+
+  describe('detectAllCLIs', () => {
+    it('returns map of detected CLIs', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('claude')) {
+          if (cmd.includes('which') || cmd.includes('where')) {
+            return Buffer.from('/usr/local/bin/claude\n');
+          }
+          return Buffer.from('v4.2.1\n');
+        }
+        throw new Error('not found');
+      });
+
+      const result = await detectAllCLIs();
+
+      expect(result).toBeInstanceOf(Map);
+      expect(result.has('claude')).toBe(true);
+    });
+
+    it('caches results', async () => {
+      let callCount = 0;
+      execSync.mockImplementation((cmd) => {
+        callCount++;
+        if (cmd.includes('which') || cmd.includes('where')) {
+          return Buffer.from('/path/to/cli\n');
+        }
+        return Buffer.from('v1.0.0\n');
+      });
+
+      await detectAllCLIs();
+      const initialCount = callCount;
+
+      await detectAllCLIs();
+
+      // Should not have called execSync again
+      expect(callCount).toBe(initialCount);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('forces re-detection', async () => {
+      let callCount = 0;
+      execSync.mockImplementation((cmd) => {
+        callCount++;
+        if (cmd.includes('which') || cmd.includes('where')) {
+          return Buffer.from('/path/to/cli\n');
+        }
+        return Buffer.from('v1.0.0\n');
+      });
+
+      await detectAllCLIs();
+      const countAfterFirst = callCount;
+
+      clearCache();
+      await detectAllCLIs();
+
+      // Should have called again after cache clear
+      expect(callCount).toBeGreaterThan(countAfterFirst);
+    });
+  });
+
+  describe('getCapabilities', () => {
+    it('returns CLI capabilities for claude', () => {
+      const caps = getCapabilities('claude');
+
+      expect(caps).toContain('review');
+      expect(caps).toContain('code-gen');
+      expect(caps).toContain('refactor');
+    });
+
+    it('returns CLI capabilities for codex', () => {
+      const caps = getCapabilities('codex');
+
+      expect(caps).toContain('review');
+      expect(caps).toContain('code-gen');
+    });
+
+    it('returns CLI capabilities for gemini', () => {
+      const caps = getCapabilities('gemini');
+
+      expect(caps).toContain('design');
+      expect(caps).toContain('vision');
+      expect(caps).toContain('review');
+    });
+
+    it('returns empty array for unknown CLI', () => {
+      const caps = getCapabilities('unknown');
+
+      expect(caps).toEqual([]);
+    });
+  });
+
+  describe('CLI_TOOLS', () => {
+    it('exports claude tool config', () => {
+      expect(CLI_TOOLS.claude).toBeDefined();
+      expect(CLI_TOOLS.claude.command).toBe('claude');
+    });
+
+    it('exports codex tool config', () => {
+      expect(CLI_TOOLS.codex).toBeDefined();
+      expect(CLI_TOOLS.codex.command).toBe('codex');
+    });
+
+    it('exports gemini tool config', () => {
+      expect(CLI_TOOLS.gemini).toBeDefined();
+      expect(CLI_TOOLS.gemini.command).toBe('gemini');
+    });
+
+    it('includes headless args for each tool', () => {
+      expect(CLI_TOOLS.claude.headlessArgs).toBeDefined();
+      expect(CLI_TOOLS.codex.headlessArgs).toBeDefined();
+      expect(CLI_TOOLS.gemini.headlessArgs).toBeDefined();
+    });
+  });
+
+  describe('Windows compatibility', () => {
+    it('handles Windows command extensions', async () => {
+      // Simulate Windows where 'where' is used instead of 'which'
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('where')) {
+          return Buffer.from('C:\\Program Files\\claude\\claude.exe\n');
+        }
+        return Buffer.from('v1.0.0\n');
+      });
+
+      const result = await detectCLI('claude');
+
+      // Restore
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+
+      expect(result).not.toBeNull();
+    });
+  });
+
+  describe('PATH variations', () => {
+    it('handles CLI in non-standard paths', async () => {
+      execSync.mockImplementation((cmd) => {
+        if (cmd.includes('which') || cmd.includes('where')) {
+          return Buffer.from('/opt/custom/bin/claude\n');
+        }
+        return Buffer.from('v4.0.0\n');
+      });
+
+      const result = await detectCLI('claude');
+
+      expect(result.path).toBe('/opt/custom/bin/claude');
+    });
+  });
+
+  describe('timeout handling', () => {
+    it('handles slow detection with timeout', async () => {
+      execSync.mockImplementation(() => {
+        // Simulate timeout by throwing
+        const error = new Error('Command timed out');
+        error.code = 'ETIMEDOUT';
+        throw error;
+      });
+
+      const result = await detectCLI('claude');
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/server/lib/cli-provider.js

@@ -0,0 +1,212 @@
+/**
+ * CLI Provider - Provider implementation for CLI tools
+ *
+ * Supports running AI CLI tools locally or via devserver:
+ * - claude (Claude Code)
+ * - codex (Codex CLI)
+ * - gemini (Gemini CLI)
+ */
+
+import { spawn } from 'child_process';
+import { createProvider, PROVIDER_TYPES } from './provider-interface.js';
+
+/**
+ * Parse output, trying to extract JSON
+ * @param {string} output - Raw output string
+ * @returns {Object|null} Parsed JSON or null
+ */
+export function parseOutput(output) {
+  if (!output || output.trim() === '') {
+    return null;
+  }
+
+  // Try parsing the whole thing as JSON
+  try {
+    return JSON.parse(output);
+  } catch (e) {
+    // Try to find JSON in the output
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[0]);
+      } catch (e2) {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
+/**
+ * Build command-line arguments for a CLI tool
+ * @param {string} command - CLI command name
+ * @param {string} prompt - The prompt
+ * @param {Object} opts - Options
+ * @returns {string[]} Array of arguments
+ */
+export function buildArgs(command, prompt, opts = {}) {
+  const args = [...(opts.headlessArgs || [])];
+
+  // Add the prompt
+  args.push(prompt);
+
+  return args;
+}
+
+/**
+ * Run a CLI tool locally
+ * @param {string} command - CLI command
+ * @param {string} prompt - The prompt
+ * @param {Object} opts - Options
+ * @returns {Promise<Object>} ProviderResult
+ */
+export function runLocal(command, prompt, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const args = buildArgs(command, prompt, opts);
+    const timeout = opts.timeout || 120000;
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const proc = spawn(command, args, {
+      cwd: opts.cwd,
+      env: process.env,
+      shell: false,
+    });
+
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      proc.kill('SIGTERM');
+      reject(new Error(`CLI timeout after ${timeout}ms`));
+    }, timeout);
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutId);
+
+      if (timedOut) return;
+
+      const parsed = parseOutput(stdout);
+
+      resolve({
+        raw: stdout,
+        parsed,
+        exitCode: code || 0,
+        stderr,
+      });
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeoutId);
+      if (!timedOut) {
+        reject(err);
+      }
+    });
+  });
+}
+
+/**
+ * Run a CLI tool via devserver
+ * @param {Object} params - Parameters
+ * @param {string} params.devserverUrl - Devserver URL
+ * @param {string} params.provider - Provider name
+ * @param {string} params.prompt - The prompt
+ * @param {Object} params.opts - Run options
+ * @param {number} [params.pollInterval=1000] - Poll interval in ms
+ * @param {number} [params.maxPollTime=300000] - Max poll time in ms
+ * @returns {Promise<Object>} ProviderResult
+ */
+export async function runViaDevserver({
+  devserverUrl,
+  provider,
+  prompt,
+  opts = {},
+  pollInterval = 1000,
+  maxPollTime = 300000,
+}) {
+  // Submit task
+  const submitResponse = await fetch(`${devserverUrl}/api/run`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      provider,
+      prompt,
+      opts,
+    }),
+  });
+
+  if (!submitResponse.ok) {
+    throw new Error(`Failed to submit task: ${submitResponse.statusText}`);
+  }
+
+  const { taskId } = await submitResponse.json();
+
+  // Poll for result
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < maxPollTime) {
+    const statusResponse = await fetch(`${devserverUrl}/api/task/${taskId}`);
+
+    if (!statusResponse.ok) {
+      throw new Error(`Failed to get task status: ${statusResponse.statusText}`);
+    }
+
+    const status = await statusResponse.json();
+
+    if (status.status === 'completed') {
+      return status.result;
+    }
+
+    if (status.status === 'failed') {
+      throw new Error(status.error || 'Task failed');
+    }
+
+    // Wait before polling again
+    await new Promise(r => setTimeout(r, pollInterval));
+  }
+
+  throw new Error('Task timed out waiting for devserver response');
+}
+
+/**
+ * Create a CLI provider instance
+ * @param {Object} config - Provider configuration
+ * @returns {Object} Provider instance
+ */
+export function createCLIProvider(config) {
+  const runner = async (prompt, opts) => {
+    if (config.detected) {
+      return runLocal(config.command, prompt, {
+        ...opts,
+        headlessArgs: config.headlessArgs,
+      });
+    }
+
+    if (config.devserverUrl) {
+      return runViaDevserver({
+        devserverUrl: config.devserverUrl,
+        provider: config.name,
+        prompt,
+        opts,
+      });
+    }
+
+    throw new Error(`CLI ${config.name} not detected and no devserver configured`);
+  };
+
+  return createProvider({
+    ...config,
+    type: PROVIDER_TYPES.CLI,
+    runner,
+  });
+}