tlc-claude-code 2.0.1 → 2.2.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/vps-api.js

@@ -0,0 +1,184 @@
+/**
+ * VPS API Router — Express routes for VPS management
+ * Phase 80 Task 4
+ */
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Read VPS data from disk
+ */
+function readVpsData(vpsJsonPath) {
+  try {
+    if (fs.existsSync(vpsJsonPath)) {
+      return JSON.parse(fs.readFileSync(vpsJsonPath, 'utf8'));
+    }
+  } catch {}
+  return { servers: [] };
+}
+
+/**
+ * Write VPS data to disk
+ */
+function writeVpsData(vpsJsonPath, data) {
+  const dir = path.dirname(vpsJsonPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(vpsJsonPath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Create VPS API router
+ * @param {Object} options
+ * @param {Object} options.sshClient - SSH client instance
+ * @param {string} options.configDir - Directory for vps.json
+ * @returns {express.Router}
+ */
+function createVpsRouter({ sshClient, configDir }) {
+  const router = express.Router();
+  const vpsJsonPath = path.join(configDir, 'vps.json');
+
+  // GET /vps/servers
+  router.get('/servers', (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    res.json(data.servers);
+  });
+
+  // POST /vps/servers
+  router.post('/servers', (req, res) => {
+    const { name, host, port, username, privateKeyPath, domain, provider, pool } = req.body;
+
+    if (!name || !host || !username) {
+      return res.status(400).json({ error: 'name, host, and username are required' });
+    }
+
+    const server = {
+      id: crypto.randomUUID(),
+      name,
+      host,
+      port: port || 22,
+      username,
+      privateKeyPath: privateKeyPath || '',
+      domain: domain || '',
+      provider: provider || '',
+      pool: pool !== false,
+      assignedProjects: [],
+      status: 'unknown',
+      lastChecked: null,
+      bootstrapped: false,
+      createdAt: new Date().toISOString(),
+    };
+
+    const data = readVpsData(vpsJsonPath);
+    data.servers.push(server);
+    writeVpsData(vpsJsonPath, data);
+
+    res.status(201).json(server);
+  });
+
+  // GET /vps/servers/:id
+  router.get('/servers/:id', (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    const server = data.servers.find(s => s.id === req.params.id);
+    if (!server) return res.status(404).json({ error: 'Server not found' });
+    res.json(server);
+  });
+
+  // PUT /vps/servers/:id
+  router.put('/servers/:id', (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    const idx = data.servers.findIndex(s => s.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: 'Server not found' });
+
+    const allowed = ['name', 'host', 'port', 'username', 'privateKeyPath', 'domain', 'provider', 'pool'];
+    for (const key of allowed) {
+      if (req.body[key] !== undefined) {
+        data.servers[idx][key] = req.body[key];
+      }
+    }
+    writeVpsData(vpsJsonPath, data);
+    res.json(data.servers[idx]);
+  });
+
+  // DELETE /vps/servers/:id
+  router.delete('/servers/:id', (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    const idx = data.servers.findIndex(s => s.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: 'Server not found' });
+    data.servers.splice(idx, 1);
+    writeVpsData(vpsJsonPath, data);
+    res.json({ ok: true });
+  });
+
+  // POST /vps/servers/:id/test
+  router.post('/servers/:id/test', async (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    const server = data.servers.find(s => s.id === req.params.id);
+    if (!server) return res.status(404).json({ error: 'Server not found' });
+
+    try {
+      const info = await sshClient.testConnection({
+        host: server.host,
+        port: server.port,
+        username: server.username,
+        privateKeyPath: server.privateKeyPath,
+      });
+
+      // Update status
+      const idx = data.servers.findIndex(s => s.id === req.params.id);
+      data.servers[idx].status = 'online';
+      data.servers[idx].lastChecked = new Date().toISOString();
+      writeVpsData(vpsJsonPath, data);
+
+      res.json(info);
+    } catch (err) {
+      res.status(502).json({ connected: false, error: err.message });
+    }
+  });
+
+  // POST /vps/servers/:id/assign
+  router.post('/servers/:id/assign', (req, res) => {
+    const { projectId } = req.body;
+    if (!projectId) return res.status(400).json({ error: 'projectId required' });
+
+    const data = readVpsData(vpsJsonPath);
+    const idx = data.servers.findIndex(s => s.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: 'Server not found' });
+
+    if (!data.servers[idx].assignedProjects) data.servers[idx].assignedProjects = [];
+    if (!data.servers[idx].assignedProjects.includes(projectId)) {
+      data.servers[idx].assignedProjects.push(projectId);
+    }
+    writeVpsData(vpsJsonPath, data);
+    res.json(data.servers[idx]);
+  });
+
+  // POST /vps/servers/:id/unassign
+  router.post('/servers/:id/unassign', (req, res) => {
+    const { projectId } = req.body;
+    if (!projectId) return res.status(400).json({ error: 'projectId required' });
+
+    const data = readVpsData(vpsJsonPath);
+    const idx = data.servers.findIndex(s => s.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: 'Server not found' });
+
+    if (data.servers[idx].assignedProjects) {
+      data.servers[idx].assignedProjects = data.servers[idx].assignedProjects.filter(p => p !== projectId);
+    }
+    writeVpsData(vpsJsonPath, data);
+    res.json(data.servers[idx]);
+  });
+
+  // GET /vps/pool
+  router.get('/pool', (req, res) => {
+    const data = readVpsData(vpsJsonPath);
+    const pool = data.servers.filter(s => s.pool === true);
+    res.json(pool);
+  });
+
+  return router;
+}
+
+module.exports = { createVpsRouter };

package/server/lib/vps-api.test.js

@@ -0,0 +1,208 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { createVpsRouter } = await import('./vps-api.js');
+
+function createMockSshClient() {
+  return {
+    exec: vi.fn().mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 }),
+    execStream: vi.fn().mockResolvedValue(),
+    testConnection: vi.fn().mockResolvedValue({
+      connected: true,
+      os: 'Linux',
+      docker: 'Docker version 24.0.0',
+      disk: '42%',
+    }),
+    upload: vi.fn().mockResolvedValue(),
+  };
+}
+
+describe('VPS API Router', () => {
+  let app;
+  let mockSsh;
+  let tempDir;
+  let vpsJsonPath;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vps-api-test-'));
+    vpsJsonPath = path.join(tempDir, 'vps.json');
+    mockSsh = createMockSshClient();
+
+    const router = createVpsRouter({
+      sshClient: mockSsh,
+      configDir: tempDir,
+    });
+
+    app = express();
+    app.use(express.json());
+    app.use('/vps', router);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('GET /vps/servers', () => {
+    it('returns empty list when no servers registered', async () => {
+      const res = await request(app).get('/vps/servers');
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual([]);
+    });
+
+    it('returns registered servers', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{ id: '1', name: 'dev-1', host: '1.2.3.4', port: 22, username: 'deploy' }],
+      }));
+      const res = await request(app).get('/vps/servers');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].name).toBe('dev-1');
+    });
+  });
+
+  describe('POST /vps/servers', () => {
+    it('creates a new server with UUID', async () => {
+      const res = await request(app).post('/vps/servers').send({
+        name: 'dev-1',
+        host: '1.2.3.4',
+        port: 22,
+        username: 'deploy',
+        privateKeyPath: '~/.ssh/id_rsa',
+        domain: 'myapp.dev',
+      });
+      expect(res.status).toBe(201);
+      expect(res.body.id).toBeTruthy();
+      expect(res.body.name).toBe('dev-1');
+      expect(res.body.host).toBe('1.2.3.4');
+
+      // Verify persisted
+      const data = JSON.parse(fs.readFileSync(vpsJsonPath, 'utf8'));
+      expect(data.servers).toHaveLength(1);
+    });
+
+    it('validates required fields', async () => {
+      const res = await request(app).post('/vps/servers').send({ name: 'dev-1' });
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBeTruthy();
+    });
+  });
+
+  describe('GET /vps/servers/:id', () => {
+    it('returns server detail', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{ id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22, username: 'deploy' }],
+      }));
+      const res = await request(app).get('/vps/servers/abc');
+      expect(res.status).toBe(200);
+      expect(res.body.id).toBe('abc');
+    });
+
+    it('returns 404 for unknown server', async () => {
+      const res = await request(app).get('/vps/servers/nonexistent');
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('PUT /vps/servers/:id', () => {
+    it('updates server config', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{ id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22, username: 'deploy' }],
+      }));
+      const res = await request(app).put('/vps/servers/abc').send({ name: 'dev-updated' });
+      expect(res.status).toBe(200);
+      expect(res.body.name).toBe('dev-updated');
+
+      // Verify persisted
+      const data = JSON.parse(fs.readFileSync(vpsJsonPath, 'utf8'));
+      expect(data.servers[0].name).toBe('dev-updated');
+    });
+  });
+
+  describe('DELETE /vps/servers/:id', () => {
+    it('removes server', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{ id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22, username: 'deploy' }],
+      }));
+      const res = await request(app).delete('/vps/servers/abc');
+      expect(res.status).toBe(200);
+
+      const data = JSON.parse(fs.readFileSync(vpsJsonPath, 'utf8'));
+      expect(data.servers).toHaveLength(0);
+    });
+  });
+
+  describe('POST /vps/servers/:id/test', () => {
+    it('tests SSH connection and returns server info', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{
+          id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22,
+          username: 'deploy', privateKeyPath: '~/.ssh/id_rsa',
+        }],
+      }));
+      const res = await request(app).post('/vps/servers/abc/test');
+      expect(res.status).toBe(200);
+      expect(res.body.connected).toBe(true);
+      expect(mockSsh.testConnection).toHaveBeenCalled();
+    });
+  });
+
+  describe('POST /vps/servers/:id/assign', () => {
+    it('assigns project to server', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{
+          id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22,
+          username: 'deploy', assignedProjects: [],
+        }],
+      }));
+      const res = await request(app).post('/vps/servers/abc/assign').send({ projectId: 'proj1' });
+      expect(res.status).toBe(200);
+      expect(res.body.assignedProjects).toContain('proj1');
+    });
+
+    it('does not duplicate project assignment', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{
+          id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22,
+          username: 'deploy', assignedProjects: ['proj1'],
+        }],
+      }));
+      const res = await request(app).post('/vps/servers/abc/assign').send({ projectId: 'proj1' });
+      expect(res.status).toBe(200);
+      expect(res.body.assignedProjects.filter(p => p === 'proj1')).toHaveLength(1);
+    });
+  });
+
+  describe('POST /vps/servers/:id/unassign', () => {
+    it('removes project from server', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [{
+          id: 'abc', name: 'dev-1', host: '1.2.3.4', port: 22,
+          username: 'deploy', assignedProjects: ['proj1', 'proj2'],
+        }],
+      }));
+      const res = await request(app).post('/vps/servers/abc/unassign').send({ projectId: 'proj1' });
+      expect(res.status).toBe(200);
+      expect(res.body.assignedProjects).not.toContain('proj1');
+      expect(res.body.assignedProjects).toContain('proj2');
+    });
+  });
+
+  describe('GET /vps/pool', () => {
+    it('returns only pool servers', async () => {
+      fs.writeFileSync(vpsJsonPath, JSON.stringify({
+        servers: [
+          { id: '1', name: 'shared', host: '1.1.1.1', port: 22, username: 'deploy', pool: true },
+          { id: '2', name: 'dedicated', host: '2.2.2.2', port: 22, username: 'deploy', pool: false },
+        ],
+      }));
+      const res = await request(app).get('/vps/pool');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].name).toBe('shared');
+    });
+  });
+});