tlc-claude-code 2.0.1 → 2.2.0

package/server/lib/deploy-engine.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+const { createDeployEngine } = await import('./deploy-engine.js');
+
+function createMockSsh() {
+  return {
+    exec: vi.fn().mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 }),
+    execStream: vi.fn().mockResolvedValue(0),
+    upload: vi.fn().mockResolvedValue(),
+  };
+}
+
+describe('DeployEngine', () => {
+  let engine;
+  let mockSsh;
+
+  beforeEach(() => {
+    mockSsh = createMockSsh();
+    engine = createDeployEngine({ sshClient: mockSsh });
+  });
+
+  describe('deploy', () => {
+    it('executes git clone + docker compose + nginx steps', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+      const progress = [];
+
+      await engine.deploy(sshConfig, project, { domain: 'myapp.dev', branch: 'main' }, (step) => progress.push(step));
+
+      // Should have called ssh exec multiple times
+      expect(mockSsh.exec.mock.calls.length).toBeGreaterThan(0);
+      // Should have progress steps
+      expect(progress.length).toBeGreaterThan(0);
+      // Verify key steps happened
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      expect(commands.some(c => c.includes('git'))).toBe(true);
+      expect(commands.some(c => c.includes('docker'))).toBe(true);
+    });
+
+    it('generates correct Nginx config for project domain', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+
+      await engine.deploy(sshConfig, project, { domain: 'myapp.dev', branch: 'main' });
+
+      // Should write nginx config
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      const nginxWrite = commands.find(c => c.includes('sites-available') || c.includes('nginx'));
+      expect(nginxWrite).toBeTruthy();
+    });
+  });
+
+  describe('deployBranch', () => {
+    it('creates subdomain config for branch', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+
+      await engine.deployBranch(sshConfig, project, 'feat-login', 'myapp.dev');
+
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      expect(commands.some(c => c.includes('feat-login'))).toBe(true);
+    });
+
+    it('sanitizes branch name for DNS', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+
+      await engine.deployBranch(sshConfig, project, 'feature/login-page', 'myapp.dev');
+
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      // Should contain sanitized name (slashes → dashes)
+      expect(commands.some(c => c.includes('feature-login-page'))).toBe(true);
+    });
+
+    // Phase 81 Task 5: git commands must use original branch name
+    it('git clone uses original branch name not sanitized', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+
+      await engine.deployBranch(sshConfig, project, 'feature/login-page', 'myapp.dev');
+
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      // git clone -b must use the ORIGINAL branch name (feature/login-page)
+      const cloneCmd = commands.find(c => c.includes('git clone'));
+      if (cloneCmd) {
+        expect(cloneCmd).toContain('-b feature/login-page');
+      }
+      // git reset/checkout must use the ORIGINAL branch name
+      const resetCmd = commands.find(c => c.includes('git reset') || c.includes('git checkout'));
+      if (resetCmd) {
+        expect(resetCmd).toContain('origin/feature/login-page');
+      }
+    });
+
+    it('allocates unique port', async () => {
+      mockSsh.exec.mockImplementation(async (config, cmd) => {
+        if (cmd.includes('cat') && cmd.includes('ports.json')) {
+          return { stdout: '{}', stderr: '', exitCode: 0 };
+        }
+        return { stdout: '', stderr: '', exitCode: 0 };
+      });
+
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const project = { name: 'myapp', repoUrl: 'git@github.com:user/myapp.git' };
+
+      const result = await engine.deployBranch(sshConfig, project, 'main', 'myapp.dev');
+      expect(result.port).toBeGreaterThan(0);
+    });
+  });
+
+  describe('rollback', () => {
+    it('checks out previous commit', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+
+      await engine.rollback(sshConfig, { name: 'myapp' });
+
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      expect(commands.some(c => c.includes('git') && c.includes('HEAD~1'))).toBe(true);
+    });
+  });
+
+  describe('cleanupBranch', () => {
+    it('removes container and nginx config', async () => {
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+
+      await engine.cleanupBranch(sshConfig, { name: 'myapp' }, 'feat-login');
+
+      const commands = mockSsh.exec.mock.calls.map(c => c[1]);
+      expect(commands.some(c => c.includes('docker') && (c.includes('stop') || c.includes('rm')))).toBe(true);
+      expect(commands.some(c => c.includes('rm') && c.includes('sites-enabled'))).toBe(true);
+    });
+  });
+
+  describe('listDeployments', () => {
+    it('returns active deploys', async () => {
+      mockSsh.exec.mockResolvedValue({
+        stdout: 'main\nfeat-login\n',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      const sshConfig = { host: '1.2.3.4', username: 'deploy', privateKeyPath: '/key' };
+      const deploys = await engine.listDeployments(sshConfig, { name: 'myapp' });
+      expect(Array.isArray(deploys)).toBe(true);
+    });
+  });
+});

package/server/lib/docker-api.js

@@ -0,0 +1,137 @@
+/**
+ * Docker API Router — Express routes for Docker management
+ * Phase 80 Task 1
+ */
+
+const express = require('express');
+
+/**
+ * Create Docker API router
+ * @param {Object} options
+ * @param {Object} options.dockerClient - Docker client instance
+ * @returns {express.Router}
+ */
+function createDockerRouter({ dockerClient }) {
+  const router = express.Router();
+
+  // GET /docker/status
+  router.get('/status', async (req, res) => {
+    try {
+      const status = await dockerClient.isAvailable();
+      if (!status.available) {
+        return res.status(503).json(status);
+      }
+      res.json(status);
+    } catch (err) {
+      res.status(503).json({ available: false, error: err.message });
+    }
+  });
+
+  // GET /docker/containers
+  router.get('/containers', async (req, res) => {
+    try {
+      const all = req.query.all === 'true';
+      const containers = await dockerClient.listContainers(all);
+      res.json(containers);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /docker/containers/:id
+  router.get('/containers/:id', async (req, res) => {
+    try {
+      const detail = await dockerClient.getContainer(req.params.id);
+      res.json(detail);
+    } catch (err) {
+      const status = err.statusCode === 404 ? 404 : 500;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  // POST /docker/containers/:id/start
+  router.post('/containers/:id/start', async (req, res) => {
+    try {
+      await dockerClient.startContainer(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /docker/containers/:id/stop
+  router.post('/containers/:id/stop', async (req, res) => {
+    try {
+      await dockerClient.stopContainer(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /docker/containers/:id/restart
+  router.post('/containers/:id/restart', async (req, res) => {
+    try {
+      await dockerClient.restartContainer(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // DELETE /docker/containers/:id
+  router.delete('/containers/:id', async (req, res) => {
+    try {
+      const force = req.query.force === 'true';
+      await dockerClient.removeContainer(req.params.id, force);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /docker/containers/:id/logs
+  router.get('/containers/:id/logs', async (req, res) => {
+    try {
+      const tail = parseInt(req.query.tail, 10) || 100;
+      const logs = await dockerClient.getContainerLogs(req.params.id, { tail });
+      res.json({ logs });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /docker/containers/:id/stats
+  router.get('/containers/:id/stats', async (req, res) => {
+    try {
+      const stats = await dockerClient.getContainerStats(req.params.id);
+      res.json(stats);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /docker/images
+  router.get('/images', async (req, res) => {
+    try {
+      const images = await dockerClient.listImages();
+      res.json(images);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /docker/volumes
+  router.get('/volumes', async (req, res) => {
+    try {
+      const volumes = await dockerClient.listVolumes();
+      res.json(volumes);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = { createDockerRouter };

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

@@ -0,0 +1,202 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+
+const { createDockerRouter } = await import('./docker-api.js');
+
+/**
+ * Helper: create mock docker client
+ */
+function createMockDockerClient(available = true) {
+  return {
+    isAvailable: vi.fn().mockResolvedValue(
+      available
+        ? { available: true, version: '24.0.0', apiVersion: '1.43' }
+        : { available: false, error: 'Docker not available' }
+    ),
+    listContainers: vi.fn().mockResolvedValue([
+      {
+        id: 'abc123',
+        name: 'tlc-dev-dashboard',
+        image: 'node:20-alpine',
+        state: 'running',
+        status: 'Up 2 hours',
+        ports: [{ private: 3147, public: 3147, type: 'tcp' }],
+        created: 1708300000,
+        labels: {},
+      },
+    ]),
+    getContainer: vi.fn().mockResolvedValue({
+      id: 'abc123',
+      name: 'tlc-dev-dashboard',
+      image: 'node:20-alpine',
+      state: 'running',
+      env: ['NODE_ENV=development'],
+      mounts: [],
+      networks: {},
+    }),
+    startContainer: vi.fn().mockResolvedValue(),
+    stopContainer: vi.fn().mockResolvedValue(),
+    restartContainer: vi.fn().mockResolvedValue(),
+    removeContainer: vi.fn().mockResolvedValue(),
+    getContainerStats: vi.fn().mockResolvedValue({
+      cpuPercent: 2.5,
+      memoryUsage: 104857600,
+      memoryLimit: 2147483648,
+      networkRx: 1024000,
+      networkTx: 512000,
+    }),
+    getContainerLogs: vi.fn().mockResolvedValue('log line 1\nlog line 2\n'),
+    listImages: vi.fn().mockResolvedValue([
+      { id: 'sha256:abc', tags: ['node:20-alpine'], size: 180000000, created: 1708200000 },
+    ]),
+    listVolumes: vi.fn().mockResolvedValue([
+      { name: 'postgres-data', driver: 'local', mountpoint: '/var/lib/docker/volumes/pg/_data' },
+    ]),
+    matchContainerToProject: vi.fn().mockReturnValue(null),
+  };
+}
+
+function createApp(dockerClient) {
+  const app = express();
+  app.use(express.json());
+  app.use('/docker', createDockerRouter({ dockerClient }));
+  return app;
+}
+
+describe('Docker API Router', () => {
+  let mockClient;
+  let app;
+
+  beforeEach(() => {
+    mockClient = createMockDockerClient();
+    app = createApp(mockClient);
+  });
+
+  describe('GET /docker/status', () => {
+    it('returns Docker status and version', async () => {
+      const res = await request(app).get('/docker/status');
+      expect(res.status).toBe(200);
+      expect(res.body.available).toBe(true);
+      expect(res.body.version).toBe('24.0.0');
+    });
+
+    it('returns 503 when Docker unavailable', async () => {
+      const unavailableClient = createMockDockerClient(false);
+      const unavailableApp = createApp(unavailableClient);
+      const res = await request(unavailableApp).get('/docker/status');
+      expect(res.status).toBe(503);
+      expect(res.body.available).toBe(false);
+      expect(res.body.error).toBeTruthy();
+    });
+  });
+
+  describe('GET /docker/containers', () => {
+    it('returns list of containers', async () => {
+      const res = await request(app).get('/docker/containers');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].name).toBe('tlc-dev-dashboard');
+    });
+
+    it('passes all=true query parameter', async () => {
+      await request(app).get('/docker/containers?all=true');
+      expect(mockClient.listContainers).toHaveBeenCalledWith(true);
+    });
+  });
+
+  describe('GET /docker/containers/:id', () => {
+    it('returns container detail', async () => {
+      const res = await request(app).get('/docker/containers/abc123');
+      expect(res.status).toBe(200);
+      expect(res.body.id).toBe('abc123');
+      expect(mockClient.getContainer).toHaveBeenCalledWith('abc123');
+    });
+
+    it('returns 404 for unknown container', async () => {
+      mockClient.getContainer.mockRejectedValue(
+        Object.assign(new Error('no such container'), { statusCode: 404 })
+      );
+      const res = await request(app).get('/docker/containers/nonexistent');
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('POST /docker/containers/:id/start', () => {
+    it('starts a container', async () => {
+      const res = await request(app).post('/docker/containers/abc123/start');
+      expect(res.status).toBe(200);
+      expect(mockClient.startContainer).toHaveBeenCalledWith('abc123');
+    });
+  });
+
+  describe('POST /docker/containers/:id/stop', () => {
+    it('stops a container', async () => {
+      const res = await request(app).post('/docker/containers/abc123/stop');
+      expect(res.status).toBe(200);
+      expect(mockClient.stopContainer).toHaveBeenCalledWith('abc123');
+    });
+  });
+
+  describe('POST /docker/containers/:id/restart', () => {
+    it('restarts a container', async () => {
+      const res = await request(app).post('/docker/containers/abc123/restart');
+      expect(res.status).toBe(200);
+      expect(mockClient.restartContainer).toHaveBeenCalledWith('abc123');
+    });
+  });
+
+  describe('DELETE /docker/containers/:id', () => {
+    it('removes a container', async () => {
+      const res = await request(app).delete('/docker/containers/abc123');
+      expect(res.status).toBe(200);
+      expect(mockClient.removeContainer).toHaveBeenCalledWith('abc123', false);
+    });
+
+    it('removes with force when requested', async () => {
+      const res = await request(app).delete('/docker/containers/abc123?force=true');
+      expect(res.status).toBe(200);
+      expect(mockClient.removeContainer).toHaveBeenCalledWith('abc123', true);
+    });
+  });
+
+  describe('GET /docker/containers/:id/logs', () => {
+    it('returns container logs', async () => {
+      const res = await request(app).get('/docker/containers/abc123/logs');
+      expect(res.status).toBe(200);
+      expect(res.body.logs).toContain('log line 1');
+    });
+
+    it('passes tail parameter', async () => {
+      await request(app).get('/docker/containers/abc123/logs?tail=50');
+      expect(mockClient.getContainerLogs).toHaveBeenCalledWith('abc123', { tail: 50 });
+    });
+  });
+
+  describe('GET /docker/containers/:id/stats', () => {
+    it('returns container stats snapshot', async () => {
+      const res = await request(app).get('/docker/containers/abc123/stats');
+      expect(res.status).toBe(200);
+      expect(res.body.cpuPercent).toBe(2.5);
+      expect(res.body.memoryUsage).toBe(104857600);
+    });
+  });
+
+  describe('GET /docker/images', () => {
+    it('returns list of images', async () => {
+      const res = await request(app).get('/docker/images');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].tags).toContain('node:20-alpine');
+    });
+  });
+
+  describe('GET /docker/volumes', () => {
+    it('returns list of volumes', async () => {
+      const res = await request(app).get('/docker/volumes');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].name).toBe('postgres-data');
+    });
+  });
+});