feat(v2): refonte complète vps-monitor — mini-Railway

Merge de feat/v2-redesign → staging

Sprint 1 — Backend :
- registry.js : CRUD apps.json v2 avec historique déploiements (10 max)
- build.js : capture logs build sur disque + EventEmitter WS temps réel
- metrics.js : CPU/RAM via Docker stats API
- deploy.js : machine d'état PENDING→BUILDING→STARTING→RUNNING/FAILED
  avec logs persistés, git spawn streamé, healthcheck HTTP post-deploy
- Nouvelles routes /api/projects CRUD + déploiements + métriques
- WS build logs (/ws?deployId=) + container logs (/ws?container=)

Sprint 2 — Frontend :
- SPA Vanilla JS avec router hash-based
- Sidebar projets avec dots de statut temps réel
- Vue projet unifiée : Overview | Deployments | Variables | Paramètres
- Logs de build en streaming WebSocket pendant le deploy
- Métriques CPU/RAM par container
- Modal nouveau projet, exec, logs container

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: RustyRory

app/api/server.js

@@ -1,23 +1,30 @@
 import { jest } from '@jest/globals';
 
-// Définis avant l'import pour que dotenv ne les écrase pas
 process.env.AUTH_USER = 'admin';
 process.env.AUTH_PASS = 'testpass';
 process.env.SESSION_SECRET = 'test-secret';
 
+const mockProjects = [
+  { id: 'lucky7', name: 'lucky7', gitUrl: 'https://github.com/RustyRory/Lucky7.git', status: 'running', deployments: [] },
+];
+
 jest.unstable_mockModule('./services/docker.js', () => ({
   getContainers: jest.fn().mockResolvedValue([
-    { name: 'app1', status: 'running', image: 'img', ports: ['3000'], uptime: 'Up 1 hour' },
+    { name: 'lucky7', status: 'running', image: 'img', ports: ['3002'], uptime: 'Up 1 hour' },
+  ]),
+  getContainersByNames: jest.fn().mockResolvedValue([
+    { name: 'lucky7', status: 'running', image: 'img', ports: ['3002'], uptime: 'Up 1 hour' },
   ]),
   restartContainer: jest.fn().mockResolvedValue(),
   stopContainer: jest.fn().mockResolvedValue(),
   startContainer: jest.fn().mockResolvedValue(),
+  removeContainer: jest.fn().mockResolvedValue(),
   streamContainerLogs: jest.fn().mockResolvedValue({ destroy: jest.fn() }),
 }));
 
 jest.unstable_mockModule('./services/http.js', () => ({
   checkWebsites: jest.fn().mockResolvedValue([
-    { name: 'SaintBarth Volley', url: '/saintbarthvolley/', httpCode: 200, status: 'OK' },
+    { name: 'lucky7', url: '/lucky7/', httpCode: 200, status: 'OK' },
   ]),
 }));
 
@@ -32,6 +39,45 @@ jest.unstable_mockModule('./services/nginx.js', () => ({
   removeApp: jest.fn().mockResolvedValue(),
 }));
 
+jest.unstable_mockModule('./services/deploy.js', () => ({
+  getProjects: jest.fn().mockResolvedValue(mockProjects),
+  getProject: jest.fn().mockImplementation((id) => {
+    const p = mockProjects.find((x) => x.id === id);
+    if (!p) throw new Error(`Projet "${id}" introuvable`);
+    return Promise.resolve(p);
+  }),
+  addProject: jest.fn().mockResolvedValue(mockProjects[0]),
+  updateProject: jest.fn().mockResolvedValue(mockProjects[0]),
+  deleteProject: jest.fn().mockResolvedValue(mockProjects[0]),
+  deployProject: jest.fn().mockResolvedValue('d-test-abc'),
+  createDeploymentRecord: jest.fn().mockResolvedValue('d-test-abc'),
+  runDeployment: jest.fn().mockResolvedValue(),
+  deleteProjectFiles: jest.fn().mockResolvedValue(),
+  syncProjectStatus: jest.fn().mockResolvedValue('running'),
+  readEnvFile: jest.fn().mockResolvedValue('KEY=value'),
+  writeEnvFile: jest.fn().mockResolvedValue(),
+  readEnvExample: jest.fn().mockResolvedValue('KEY='),
+}));
+
+jest.unstable_mockModule('./services/compose.js', () => ({
+  getAllServiceNames: jest.fn().mockResolvedValue(['lucky7']),
+  composeFullRestart: jest.fn().mockResolvedValue({ services: ['lucky7'], network: 'lucky7-net', connections: [] }),
+  ensureInfraInclude: jest.fn().mockResolvedValue(),
+  composeUp: jest.fn().mockResolvedValue(),
+}));
+
+jest.unstable_mockModule('./services/metrics.js', () => ({
+  getProjectMetrics: jest.fn().mockResolvedValue([
+    { name: 'lucky7', cpu_percent: 1.2, mem_usage: 50000, mem_limit: 2000000, mem_percent: 2.5 },
+  ]),
+}));
+
+jest.unstable_mockModule('./services/build.js', () => ({
+  readBuildLog: jest.fn().mockResolvedValue('build log content'),
+  subscribeBuildSession: jest.fn().mockReturnValue(null),
+  isBuildActive: jest.fn().mockReturnValue(false),
+}));
+
 const { default: app } = await import('./server.js');
 const { default: request } = await import('supertest');
 
@@ -77,3 +123,45 @@ describe('GET /api/status', () => {
     expect(res.body.globalStatus).toBe('OK');
   });
 });
+
+describe('GET /api/projects', () => {
+  let agent;
+
+  beforeEach(async () => {
+    agent = request.agent(app);
+    await agent.post('/auth/login').send(CREDENTIALS);
+  });
+
+  it('retourne la liste des projets', async () => {
+    const res = await agent.get('/api/projects');
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+    expect(res.body[0]).toHaveProperty('id');
+  });
+
+  it('retourne un projet par id', async () => {
+    const res = await agent.get('/api/projects/lucky7');
+    expect(res.statusCode).toBe(200);
+    expect(res.body.id).toBe('lucky7');
+  });
+
+  it('retourne 404 pour un projet inexistant', async () => {
+    const res = await agent.get('/api/projects/does-not-exist');
+    expect(res.statusCode).toBe(404);
+  });
+});
+
+describe('GET /api/projects/:id/deployments', () => {
+  let agent;
+
+  beforeEach(async () => {
+    agent = request.agent(app);
+    await agent.post('/auth/login').send(CREDENTIALS);
+  });
+
+  it('retourne la liste des déploiements', async () => {
+    const res = await agent.get('/api/projects/lucky7/deployments');
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+  });
+});

app/api/server.test.js

@@ -0,0 +1,66 @@
+import { createWriteStream } from 'fs';
+import { readFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { EventEmitter } from 'events';
+
+const REPO_ROOT = process.env.VPSCONFIG_PATH || '/var/www/vps-monitor';
+const LOGS_DIR = join(REPO_ROOT, 'data', 'logs');
+
+// Active build sessions: deployId → { emitter, fileStream }
+const activeSessions = new Map();
+
+export function getBuildLogPath(projectId, deployId) {
+  return join(LOGS_DIR, `${projectId}-${deployId}.log`);
+}
+
+export async function startBuildSession(projectId, deployId) {
+  await mkdir(LOGS_DIR, { recursive: true });
+  const logPath = getBuildLogPath(projectId, deployId);
+  const fileStream = createWriteStream(logPath, { flags: 'a' });
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(20);
+
+  const session = {
+    emitter,
+    fileStream,
+    write(text) {
+      fileStream.write(text);
+      emitter.emit('data', text);
+    },
+    end() {
+      fileStream.end();
+      emitter.emit('end');
+      activeSessions.delete(deployId);
+    },
+  };
+
+  activeSessions.set(deployId, session);
+  return session;
+}
+
+// Returns an unsubscribe function, or null if session is not active (build already ended).
+export function subscribeBuildSession(deployId, onData, onEnd) {
+  const session = activeSessions.get(deployId);
+  if (!session) return null;
+
+  session.emitter.on('data', onData);
+  session.emitter.once('end', onEnd);
+
+  return () => {
+    session.emitter.off('data', onData);
+    session.emitter.off('end', onEnd);
+  };
+}
+
+export function isBuildActive(deployId) {
+  return activeSessions.has(deployId);
+}
+
+export async function readBuildLog(projectId, deployId) {
+  const logPath = getBuildLogPath(projectId, deployId);
+  try {
+    return await readFile(logPath, 'utf8');
+  } catch {
+    return '';
+  }
+}

app/api/services/build.js

@@ -114,6 +114,35 @@ export async function composeRebuild(serviceNames, forceBuild = false) {
   await execFile('docker', args, { cwd: APPS_ROOT });
 }
 
+export async function composeRebuildStreaming(serviceNames, forceBuild = false, onOutput = null) {
+  const { spawn } = await import('child_process');
+  const names = Array.isArray(serviceNames) ? serviceNames : [serviceNames];
+  const build = forceBuild || !(await hasImages(names));
+
+  const emit = (text) => { if (onOutput) onOutput(text); };
+
+  emit(`[vps] Arrêt des containers existants...\n`);
+  await execFile('docker', ['compose', '-f', MAIN_COMPOSE, 'rm', '-sf', ...names], { cwd: APPS_ROOT }).catch(() => {});
+  await Promise.all(names.map((n) => execFile('docker', ['rm', '-f', n]).catch(() => {})));
+
+  const args = ['compose', '-f', MAIN_COMPOSE, 'up', '-d'];
+  if (build) args.push('--build');
+  args.push(...names);
+
+  emit(`[vps] docker ${args.join(' ')}\n`);
+
+  await new Promise((resolve, reject) => {
+    const child = spawn('docker', args, { cwd: APPS_ROOT });
+    child.stdout.on('data', (chunk) => emit(chunk.toString('utf8')));
+    child.stderr.on('data', (chunk) => emit(chunk.toString('utf8')));
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`docker compose exited with code ${code}`));
+    });
+    child.on('error', reject);
+  });
+}
+
 async function freePortsFromCompose(appName) {
   const relPath = await findComposePath(appName);
   try {