tlc-claude-code 1.8.5 → 2.1.0

package/server/lib/ssh-client.js

@@ -0,0 +1,184 @@
+/**
+ * SSH Client — wraps ssh2 for VPS communication
+ * Phase 80 Task 4
+ */
+
+const { Client } = require('ssh2');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Resolve ~ in key paths
+ */
+function resolveKeyPath(keyPath) {
+  if (!keyPath) return null;
+  if (keyPath.startsWith('~')) {
+    return path.join(require('os').homedir(), keyPath.slice(1));
+  }
+  return keyPath;
+}
+
+/**
+ * Create an SSH client wrapper
+ * @param {Object} [options]
+ * @param {Function} [options._execFn] - Injected exec function (for testing)
+ * @returns {Object} SSH client API
+ */
+function createSshClient(options = {}) {
+  const injectedExec = options._execFn;
+
+  /**
+   * Execute a command via SSH
+   * @param {Object} config - { host, port, username, privateKeyPath }
+   * @param {string} command
+   * @returns {Promise<{ stdout, stderr, exitCode }>}
+   */
+  async function exec(config, command) {
+    if (injectedExec) {
+      return injectedExec(config, command);
+    }
+
+    if (!config.host || !config.username) {
+      throw new Error('SSH config requires host and username');
+    }
+
+    const keyPath = resolveKeyPath(config.privateKeyPath);
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      conn.on('ready', () => {
+        conn.exec(command, (err, stream) => {
+          if (err) { conn.end(); return reject(err); }
+
+          let stdout = '';
+          let stderr = '';
+
+          stream.on('data', (data) => { stdout += data.toString(); });
+          stream.stderr.on('data', (data) => { stderr += data.toString(); });
+          stream.on('close', (code) => {
+            conn.end();
+            resolve({ stdout, stderr, exitCode: code });
+          });
+        });
+      });
+      conn.on('error', (err) => reject(err));
+
+      const connOpts = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username,
+        readyTimeout: 10000,
+        keepaliveInterval: 5000,
+      };
+      if (keyPath && fs.existsSync(keyPath)) {
+        connOpts.privateKey = fs.readFileSync(keyPath);
+      }
+      conn.connect(connOpts);
+    });
+  }
+
+  /**
+   * Execute with streaming output
+   * @param {Object} config
+   * @param {string} command
+   * @param {Function} onData - Called with each output chunk
+   * @returns {Promise<number>} exit code
+   */
+  async function execStream(config, command, onData) {
+    if (injectedExec) {
+      const result = await injectedExec(config, command);
+      if (onData && result.stdout) onData(result.stdout);
+      return result.exitCode;
+    }
+
+    if (!config.host || !config.username) {
+      throw new Error('SSH config requires host and username');
+    }
+
+    const keyPath = resolveKeyPath(config.privateKeyPath);
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      conn.on('ready', () => {
+        conn.exec(command, (err, stream) => {
+          if (err) { conn.end(); return reject(err); }
+          stream.on('data', (data) => onData && onData(data.toString()));
+          stream.stderr.on('data', (data) => onData && onData(data.toString()));
+          stream.on('close', (code) => { conn.end(); resolve(code); });
+        });
+      });
+      conn.on('error', (err) => reject(err));
+
+      const connOpts = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username,
+      };
+      if (keyPath && fs.existsSync(keyPath)) {
+        connOpts.privateKey = fs.readFileSync(keyPath);
+      }
+      conn.connect(connOpts);
+    });
+  }
+
+  /**
+   * Upload a file via SFTP
+   * @param {Object} config
+   * @param {string} localPath
+   * @param {string} remotePath
+   */
+  async function upload(config, localPath, remotePath) {
+    if (!config.host || !config.username) {
+      throw new Error('SSH config requires host and username');
+    }
+
+    const keyPath = resolveKeyPath(config.privateKeyPath);
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      conn.on('ready', () => {
+        conn.sftp((err, sftp) => {
+          if (err) { conn.end(); return reject(err); }
+          sftp.fastPut(localPath, remotePath, (err) => {
+            conn.end();
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+      });
+      conn.on('error', (err) => reject(err));
+
+      const connOpts = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username,
+      };
+      if (keyPath && fs.existsSync(keyPath)) {
+        connOpts.privateKey = fs.readFileSync(keyPath);
+      }
+      conn.connect(connOpts);
+    });
+  }
+
+  /**
+   * Test SSH connection and gather server info
+   * @param {Object} config
+   * @returns {Promise<{ connected, os, docker, disk }>}
+   */
+  async function testConnection(config) {
+    const osResult = await exec(config, 'uname -a');
+    const dockerResult = await exec(config, 'docker --version 2>/dev/null || echo "not installed"');
+    const diskResult = await exec(config, 'df -h / | tail -1');
+
+    return {
+      connected: true,
+      os: osResult.stdout.trim(),
+      docker: dockerResult.stdout.trim(),
+      disk: diskResult.stdout.trim(),
+    };
+  }
+
+  return { exec, execStream, upload, testConnection };
+}
+
+module.exports = { createSshClient };

package/server/lib/ssh-client.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+const { createSshClient } = await import('./ssh-client.js');
+
+/**
+ * Create a mock ssh2 Client for injection
+ */
+function createMockSsh2() {
+  const mockStream = {
+    on: vi.fn().mockReturnThis(),
+    stderr: { on: vi.fn().mockReturnThis() },
+    end: vi.fn(),
+    write: vi.fn(),
+  };
+
+  const mockSftp = {
+    fastPut: vi.fn(),
+  };
+
+  const mockClient = {
+    on: vi.fn().mockReturnThis(),
+    connect: vi.fn(),
+    exec: vi.fn(),
+    sftp: vi.fn(),
+    end: vi.fn(),
+    _mockStream: mockStream,
+    _mockSftp: mockSftp,
+  };
+
+  return mockClient;
+}
+
+describe('SshClient', () => {
+  let sshClient;
+
+  beforeEach(() => {
+    sshClient = createSshClient();
+  });
+
+  describe('testConnection', () => {
+    it('resolves with server info on successful connection', async () => {
+      const config = { host: '1.2.3.4', port: 22, username: 'deploy', privateKeyPath: '/fake/key' };
+      // Test that testConnection is a function
+      expect(typeof sshClient.testConnection).toBe('function');
+    });
+
+    it('rejects when host is unreachable', async () => {
+      const config = { host: 'invalid', port: 22, username: 'root', privateKeyPath: '/nonexistent' };
+      await expect(sshClient.testConnection(config)).rejects.toThrow();
+    });
+  });
+
+  describe('exec', () => {
+    it('is a function that accepts config and command', () => {
+      expect(typeof sshClient.exec).toBe('function');
+    });
+
+    it('rejects with error for bad config', async () => {
+      await expect(sshClient.exec({}, 'whoami')).rejects.toThrow();
+    });
+  });
+
+  describe('execStream', () => {
+    it('is a function that accepts config, command, and callback', () => {
+      expect(typeof sshClient.execStream).toBe('function');
+    });
+  });
+
+  describe('upload', () => {
+    it('is a function that accepts config, localPath, remotePath', () => {
+      expect(typeof sshClient.upload).toBe('function');
+    });
+  });
+});
+
+describe('SshClient with mock', () => {
+  it('exec resolves with stdout, stderr, exitCode via injected client', async () => {
+    // Create a mock that simulates successful exec
+    const mockExecResult = { stdout: 'root\n', stderr: '', exitCode: 0 };
+    const sshClient = createSshClient({
+      _execFn: vi.fn().mockResolvedValue(mockExecResult),
+    });
+
+    const result = await sshClient.exec(
+      { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' },
+      'whoami'
+    );
+    expect(result).toEqual(mockExecResult);
+  });
+
+  it('exec rejects when command fails', async () => {
+    const sshClient = createSshClient({
+      _execFn: vi.fn().mockRejectedValue(new Error('command failed')),
+    });
+
+    await expect(
+      sshClient.exec({ host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' }, 'bad-cmd')
+    ).rejects.toThrow('command failed');
+  });
+
+  it('testConnection returns server info', async () => {
+    const sshClient = createSshClient({
+      _execFn: vi.fn()
+        .mockResolvedValueOnce({ stdout: 'Linux\n', stderr: '', exitCode: 0 }) // uname
+        .mockResolvedValueOnce({ stdout: 'Docker version 24.0.0\n', stderr: '', exitCode: 0 }) // docker
+        .mockResolvedValueOnce({ stdout: '/dev/sda1 50G 20G 28G 42% /\n', stderr: '', exitCode: 0 }), // df
+    });
+
+    const info = await sshClient.testConnection(
+      { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' }
+    );
+    expect(info.os).toContain('Linux');
+    expect(info.docker).toContain('24.0.0');
+    expect(info.disk).toBeTruthy();
+    expect(info.connected).toBe(true);
+  });
+
+  it('testConnection reports disconnected on failure', async () => {
+    const sshClient = createSshClient({
+      _execFn: vi.fn().mockRejectedValue(new Error('Connection refused')),
+    });
+
+    await expect(
+      sshClient.testConnection({ host: '1.2.3.4', username: 'root', privateKeyPath: '/key' })
+    ).rejects.toThrow('Connection refused');
+  });
+});

package/server/lib/test-inventory.js

@@ -0,0 +1,112 @@
+/**
+ * @file test-inventory.js
+ * @description Test Suite Inventory API (Phase 75, Task 2).
+ *
+ * Factory function that accepts injected dependencies (globSync, fs) and returns
+ * functions for discovering test files, counting tests per file, grouping by
+ * directory, and reading cached test runs.
+ */
+
+const { join, relative, dirname } = require('path');
+
+/**
+ * Creates a test inventory service with injected dependencies.
+ * @param {Object} deps - Injected dependencies
+ * @param {Function} deps.globSync - Glob function for file discovery
+ * @param {{ readFileSync: Function, existsSync: Function }} deps.fs - File system operations
+ * @returns {{ getTestInventory: Function, getLastTestRun: Function }}
+ */
+function createTestInventory({ globSync, fs }) {
+  /**
+   * Count the number of test cases in a file's content.
+   * Matches: it(, it.only(, it.skip(, test(, test.only(, test.skip(
+   * @param {string} content - File content to scan
+   * @returns {number} Number of test cases found
+   */
+  function countTests(content) {
+    const pattern = /\b(?:it|test)(?:\.only|\.skip)?\s*\(/g;
+    const matches = content.match(pattern);
+    return matches ? matches.length : 0;
+  }
+
+  /**
+   * Discover test files, count tests, and group by directory.
+   * @param {string} projectPath - Absolute path to the project root
+   * @returns {{ totalFiles: number, totalTests: number, groups: Array<{ name: string, fileCount: number, testCount: number, files: Array }> }}
+   */
+  function getTestInventory(projectPath) {
+    const patterns = [
+      '**/*.test.js',
+      '**/*.test.ts',
+      '**/*.test.tsx',
+      '**/*.spec.*',
+    ];
+
+    const files = globSync(patterns, {
+      cwd: projectPath,
+      absolute: true,
+      ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    });
+
+    /** @type {Map<string, Array<{ relativePath: string, testCount: number }>>} */
+    const groupMap = new Map();
+
+    for (const filePath of files) {
+      const rel = relative(projectPath, filePath);
+      const dir = dirname(rel);
+
+      let content;
+      try {
+        content = fs.readFileSync(filePath, 'utf-8');
+      } catch {
+        content = '';
+      }
+
+      const testCount = countTests(content);
+
+      if (!groupMap.has(dir)) {
+        groupMap.set(dir, []);
+      }
+      groupMap.get(dir).push({ relativePath: rel, testCount });
+    }
+
+    const groups = [];
+    for (const [name, fileList] of groupMap) {
+      const testCount = fileList.reduce((sum, f) => sum + f.testCount, 0);
+      groups.push({
+        name,
+        fileCount: fileList.length,
+        testCount,
+        files: fileList,
+      });
+    }
+
+    // Sort by testCount descending
+    groups.sort((a, b) => b.testCount - a.testCount);
+
+    const totalFiles = files.length;
+    const totalTests = groups.reduce((sum, g) => sum + g.testCount, 0);
+
+    return { totalFiles, totalTests, groups };
+  }
+
+  /**
+   * Read the cached last test run result.
+   * @param {string} projectPath - Absolute path to the project root
+   * @returns {Object|null} Parsed test run data, or null if no cache exists
+   */
+  function getLastTestRun(projectPath) {
+    const cachePath = join(projectPath, '.tlc', 'last-test-run.json');
+
+    if (!fs.existsSync(cachePath)) {
+      return null;
+    }
+
+    const raw = fs.readFileSync(cachePath, 'utf-8');
+    return JSON.parse(raw);
+  }
+
+  return { getTestInventory, getLastTestRun };
+}
+
+module.exports = { createTestInventory };