tlc-claude-code 2.0.1 → 2.1.0

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');
+    });
+  });
+});

package/server/lib/docker-client.js

@@ -0,0 +1,297 @@
+/**
+ * Docker Client — wraps dockerode for Docker socket communication
+ * Phase 80 Task 1
+ */
+
+const Docker = require('dockerode');
+
+/**
+ * Create a Docker client instance
+ * @param {Object} options
+ * @param {string} [options.socketPath=/var/run/docker.sock] - Docker socket path
+ * @param {Object} [options._docker] - Injected Docker instance (for testing)
+ * @returns {Object} Docker client API
+ */
+function createDockerClient(options = {}) {
+  const socketPath = options.socketPath || '/var/run/docker.sock';
+  const docker = options._docker || new Docker({ socketPath });
+
+  /**
+   * Check if Docker daemon is accessible
+   */
+  async function isAvailable() {
+    try {
+      await docker.ping();
+      const info = await docker.version();
+      return { available: true, version: info.Version, apiVersion: info.ApiVersion };
+    } catch (err) {
+      return { available: false, error: err.message };
+    }
+  }
+
+  /**
+   * List containers
+   * @param {boolean} [all=false] - Include stopped containers
+   */
+  async function listContainers(all = false) {
+    const containers = await docker.listContainers({ all });
+    return containers.map(c => ({
+      id: c.Id,
+      name: (c.Names[0] || '').replace(/^\//, ''),
+      image: c.Image,
+      state: c.State,
+      status: c.Status,
+      ports: (c.Ports || []).map(p => ({
+        private: p.PrivatePort,
+        public: p.PublicPort,
+        type: p.Type,
+      })),
+      created: c.Created,
+      labels: c.Labels || {},
+    }));
+  }
+
+  /**
+   * Get container detail
+   * @param {string} id - Container ID or name
+   */
+  async function getContainer(id) {
+    const container = docker.getContainer(id);
+    const info = await container.inspect();
+    return {
+      id: info.Id,
+      name: (info.Name || '').replace(/^\//, ''),
+      image: info.Config.Image,
+      state: info.State.Status,
+      startedAt: info.State.StartedAt,
+      env: info.Config.Env || [],
+      mounts: (info.Mounts || []).map(m => ({
+        source: m.Source,
+        destination: m.Destination,
+        rw: m.RW,
+      })),
+      networks: info.NetworkSettings.Networks || {},
+      ports: info.HostConfig.PortBindings || {},
+    };
+  }
+
+  /**
+   * Start a container
+   * @param {string} id - Container ID
+   */
+  async function startContainer(id) {
+    const container = docker.getContainer(id);
+    await container.start();
+  }
+
+  /**
+   * Stop a container
+   * @param {string} id - Container ID
+   */
+  async function stopContainer(id) {
+    const container = docker.getContainer(id);
+    await container.stop();
+  }
+
+  /**
+   * Restart a container
+   * @param {string} id - Container ID
+   */
+  async function restartContainer(id) {
+    const container = docker.getContainer(id);
+    await container.restart();
+  }
+
+  /**
+   * Remove a container
+   * @param {string} id - Container ID
+   * @param {boolean} [force=false] - Force removal
+   */
+  async function removeContainer(id, force = false) {
+    const container = docker.getContainer(id);
+    await container.remove({ force });
+  }
+
+  /**
+   * Get container stats snapshot
+   * @param {string} id - Container ID
+   */
+  async function getContainerStats(id) {
+    const container = docker.getContainer(id);
+    const stats = await container.stats({ stream: false });
+
+    // Calculate CPU %
+    const cpuDelta = (stats.cpu_stats?.cpu_usage?.total_usage || 0) - (stats.precpu_stats?.cpu_usage?.total_usage || 0);
+    const systemDelta = (stats.cpu_stats?.system_cpu_usage || 0) - (stats.precpu_stats?.system_cpu_usage || 0);
+    const numCpus = stats.cpu_stats?.online_cpus || 1;
+    const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * numCpus * 100 : 0;
+
+    // Memory
+    const cache = stats.memory_stats?.stats?.cache || stats.memory_stats?.stats?.inactive_file || 0;
+    const memoryUsage = (stats.memory_stats?.usage || 0) - cache;
+    const memoryLimit = stats.memory_stats?.limit || 0;
+
+    // Network
+    let networkRx = 0;
+    let networkTx = 0;
+    if (stats.networks) {
+      for (const iface of Object.values(stats.networks)) {
+        networkRx += iface.rx_bytes || 0;
+        networkTx += iface.tx_bytes || 0;
+      }
+    }
+
+    return { cpuPercent, memoryUsage, memoryLimit, networkRx, networkTx };
+  }
+
+  /**
+   * Get container logs
+   * @param {string} id - Container ID
+   * @param {Object} [opts]
+   * @param {number} [opts.tail=100] - Number of lines
+   */
+  async function getContainerLogs(id, opts = {}) {
+    const container = docker.getContainer(id);
+    const logs = await container.logs({
+      stdout: true,
+      stderr: true,
+      tail: opts.tail || 100,
+      timestamps: true,
+    });
+    // logs may be Buffer or string
+    return typeof logs === 'string' ? logs : logs.toString('utf8');
+  }
+
+  /**
+   * Stream container logs (live)
+   * @param {string} id - Container ID
+   * @param {Function} callback - Called with each log chunk
+   * @returns {Function} abort function
+   */
+  function streamContainerLogs(id, callback) {
+    let aborted = false;
+    let streamRef = null;
+    const container = docker.getContainer(id);
+    container.logs({ follow: true, stdout: true, stderr: true, tail: 50, timestamps: true })
+      .then(stream => {
+        streamRef = stream;
+        if (aborted) { stream.destroy && stream.destroy(); return; }
+        stream.on('data', chunk => {
+          if (!aborted) callback(chunk.toString('utf8'));
+        });
+        stream.on('end', () => {});
+      })
+      .catch((err) => { callback && callback(null, err); });
+    return () => { aborted = true; if (streamRef) { streamRef.destroy && streamRef.destroy(); } };
+  }
+
+  /**
+   * Stream container stats (live)
+   * @param {string} id - Container ID
+   * @param {Function} callback - Called with each stats update
+   * @returns {Function} abort function
+   */
+  function streamContainerStats(id, callback) {
+    let aborted = false;
+    let streamRef = null;
+    const container = docker.getContainer(id);
+    container.stats({ stream: true })
+      .then(stream => {
+        streamRef = stream;
+        if (aborted) { stream.destroy && stream.destroy(); return; }
+        let buffer = '';
+        stream.on('data', chunk => {
+          if (aborted) { stream.destroy(); return; }
+          buffer += chunk.toString('utf8');
+          const lines = buffer.split('\n');
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const stats = JSON.parse(line);
+                const cpuDelta = (stats.cpu_stats?.cpu_usage?.total_usage || 0) - (stats.precpu_stats?.cpu_usage?.total_usage || 0);
+                const systemDelta = (stats.cpu_stats?.system_cpu_usage || 0) - (stats.precpu_stats?.system_cpu_usage || 0);
+                const numCpus = stats.cpu_stats?.online_cpus || 1;
+                callback({
+                  cpuPercent: systemDelta > 0 ? (cpuDelta / systemDelta) * numCpus * 100 : 0,
+                  memoryUsage: stats.memory_stats?.usage || 0,
+                  memoryLimit: stats.memory_stats?.limit || 0,
+                });
+              } catch {}
+            }
+          }
+        });
+      })
+      .catch((err) => { callback && callback(null, err); });
+    return () => { aborted = true; if (streamRef) { streamRef.destroy && streamRef.destroy(); } };
+  }
+
+  /**
+   * List images
+   */
+  async function listImages() {
+    const images = await docker.listImages();
+    return images.map(img => ({
+      id: img.Id,
+      tags: img.RepoTags || [],
+      size: img.Size,
+      created: img.Created,
+    }));
+  }
+
+  /**
+   * List volumes
+   */
+  async function listVolumes() {
+    const result = await docker.listVolumes();
+    return (result.Volumes || []).map(v => ({
+      name: v.Name,
+      driver: v.Driver,
+      mountpoint: v.Mountpoint,
+      createdAt: v.CreatedAt,
+    }));
+  }
+
+  /**
+   * Match a container to a TLC project by name or labels
+   * @param {Object} container - { name, labels }
+   * @param {Array} projects - [{ name, path }]
+   * @returns {string|null} matched project name or null
+   */
+  function matchContainerToProject(container, projects) {
+    // Match by compose project label
+    const composeProject = container.labels && container.labels['com.docker.compose.project'];
+    if (composeProject) {
+      const match = projects.find(p => p.name.toLowerCase() === composeProject.toLowerCase());
+      if (match) return match.name;
+    }
+
+    // Match by container name containing project name
+    const cName = (container.name || '').toLowerCase();
+    for (const project of projects) {
+      const pName = project.name.toLowerCase();
+      if (cName.includes(pName)) return project.name;
+    }
+
+    return null;
+  }
+
+  return {
+    isAvailable,
+    listContainers,
+    getContainer,
+    startContainer,
+    stopContainer,
+    restartContainer,
+    removeContainer,
+    getContainerStats,
+    getContainerLogs,
+    streamContainerLogs,
+    streamContainerStats,
+    listImages,
+    listVolumes,
+    matchContainerToProject,
+  };
+}
+
+module.exports = { createDockerClient };