tlc-claude-code 2.5.0 → 2.6.0

package/server/lib/scaffolding/deploy-detector.test.js

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { detectDeployTarget } from './deploy-detector.js';
+
+function makeTempProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'deploy-detector-test-'));
+}
+
+function writeFile(projectDir, relativePath, contents = '') {
+  const filePath = path.join(projectDir, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+}
+
+function makeDir(projectDir, relativePath) {
+  fs.mkdirSync(path.join(projectDir, relativePath), { recursive: true });
+}
+
+const tempDirs = [];
+
+function createProject() {
+  const projectDir = makeTempProject();
+  tempDirs.push(projectDir);
+  return projectDir;
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('detectDeployTarget', () => {
+  it('detects docker-compose.yml as docker-compose with high confidence', () => {
+    const projectDir = createProject();
+    writeFile(projectDir, 'docker-compose.yml', 'services:\n  app:\n    image: app\n');
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'docker-compose',
+      confidence: 'high',
+      evidence: ['docker-compose.yml'],
+    });
+  });
+
+  it('detects helm directory as k8s with high confidence', () => {
+    const projectDir = createProject();
+    makeDir(projectDir, 'helm');
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'k8s',
+      confidence: 'high',
+      evidence: ['helm/'],
+    });
+  });
+
+  it('detects Dockerfile alone as vps with medium confidence', () => {
+    const projectDir = createProject();
+    writeFile(projectDir, 'Dockerfile', 'FROM node:20-alpine\n');
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'vps',
+      confidence: 'medium',
+      evidence: ['Dockerfile'],
+    });
+  });
+
+  it('returns unknown when docker-compose and helm both exist', () => {
+    const projectDir = createProject();
+    writeFile(projectDir, 'docker-compose.yaml', 'services:\n  app:\n    image: app\n');
+    makeDir(projectDir, 'helm');
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'unknown',
+      confidence: 'low',
+      evidence: ['docker-compose.yaml', 'helm/', 'multiple deployment targets detected'],
+    });
+  });
+
+  it('returns unknown with low confidence for an empty project', () => {
+    const projectDir = createProject();
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'unknown',
+      confidence: 'low',
+      evidence: [],
+    });
+  });
+
+  it('includes file evidence for k8s deployment manifests', () => {
+    const projectDir = createProject();
+    writeFile(
+      projectDir,
+      'manifests/api-deployment.yaml',
+      'apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: api\n'
+    );
+
+    expect(detectDeployTarget({ projectDir, fs })).toEqual({
+      target: 'k8s',
+      confidence: 'high',
+      evidence: ['kind: Deployment in manifests/api-deployment.yaml'],
+    });
+  });
+});

package/server/lib/scaffolding/health-scaffold.js

@@ -0,0 +1,374 @@
+const { detectDeployTarget } = require('./deploy-detector.js');
+
+function scaffoldHealth({ projectDir, deployTarget, framework, fs }) {
+  const resolvedFramework = framework === 'fastify' ? 'fastify' : 'express';
+  const resolvedDeployTarget = resolveDeployTarget({ projectDir, deployTarget, fs });
+  const files = [
+    {
+      path: 'src/health.js',
+      content: createHealthFileContent({
+        deployTarget: resolvedDeployTarget,
+        framework: resolvedFramework,
+      }),
+    },
+  ];
+
+  if (resolvedDeployTarget === 'vps') {
+    files.push({
+      path: 'ecosystem.config.js',
+      content: createPm2Snippet(),
+    });
+  }
+
+  return {
+    files,
+    dependencies: [],
+  };
+}
+
+function resolveDeployTarget({ projectDir, deployTarget, fs }) {
+  if (deployTarget && typeof deployTarget === 'object' && deployTarget.target) {
+    return deployTarget.target;
+  }
+
+  if (typeof deployTarget === 'string' && deployTarget.length > 0) {
+    return deployTarget;
+  }
+
+  if (projectDir && fs) {
+    return detectDeployTarget({ projectDir, fs }).target;
+  }
+
+  return 'unknown';
+}
+
+function createHealthFileContent({ deployTarget, framework }) {
+  if (framework === 'fastify') {
+    return createFastifyContent(deployTarget);
+  }
+
+  return createExpressContent(deployTarget);
+}
+
+function createExpressContent(deployTarget) {
+  const routeDefinitions = createExpressRouteDefinitions(deployTarget);
+
+  return `'use strict';
+
+function withTimeout(operation, timeoutMs = 2000) {
+  return Promise.race([
+    Promise.resolve().then(operation),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('timeout')), timeoutMs);
+    }),
+  ]);
+}
+
+async function pingDatabase(options = {}) {
+  if (!options.db) {
+    return { configured: false, ok: true, status: 'not_configured' };
+  }
+
+  try {
+    await withTimeout(async () => {
+      if (typeof options.db.ping === 'function') {
+        await options.db.ping();
+        return;
+      }
+
+      if (typeof options.db.query === 'function') {
+        await options.db.query('SELECT 1');
+        return;
+      }
+
+      throw new Error('no supported database ping method');
+    });
+
+    return { configured: true, ok: true, status: 'up' };
+  } catch (error) {
+    return { configured: true, ok: false, status: 'down', error: error.message };
+  }
+}
+
+async function pingRedis(options = {}) {
+  if (!options.redis) {
+    return { configured: false, ok: true, status: 'not_configured' };
+  }
+
+  try {
+    await withTimeout(async () => {
+      if (typeof options.redis.ping === 'function') {
+        await options.redis.ping();
+        return;
+      }
+
+      if (typeof options.redis.sendCommand === 'function') {
+        await options.redis.sendCommand(['PING']);
+        return;
+      }
+
+      throw new Error('no supported redis ping method');
+    });
+
+    return { configured: true, ok: true, status: 'up' };
+  } catch (error) {
+    return { configured: true, ok: false, status: 'down', error: error.message };
+  }
+}
+
+async function getDependencyStatus(options = {}) {
+  const [database, redis] = await Promise.all([
+    pingDatabase(options),
+    pingRedis(options),
+  ]);
+
+  const dependencies = {};
+
+  if (database.configured) {
+    dependencies.db = database;
+  }
+
+  if (redis.configured) {
+    dependencies.redis = redis;
+  }
+
+  const status = Object.values(dependencies).every(dependency => dependency.ok !== false)
+    ? 'ok'
+    : 'degraded';
+
+  return {
+    status,
+    dependencies,
+    uptime: process.uptime(),
+  };
+}
+
+function getStartupState(options = {}) {
+  if (typeof options.isStartupComplete === 'function') {
+    return Boolean(options.isStartupComplete());
+  }
+
+  if (typeof options.startupComplete === 'boolean') {
+    return options.startupComplete;
+  }
+
+  return true;
+}
+
+function sendJson(res, statusCode, payload) {
+  res.status(statusCode).json(payload);
+}
+
+function registerHealthRoutes(app, options = {}) {
+${routeDefinitions}
+}
+
+module.exports = {
+  registerHealthRoutes,
+};
+`;
+}
+
+function createFastifyContent(deployTarget) {
+  const routeDefinitions = createFastifyRouteDefinitions(deployTarget);
+
+  return `'use strict';
+
+function withTimeout(operation, timeoutMs = 2000) {
+  return Promise.race([
+    Promise.resolve().then(operation),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('timeout')), timeoutMs);
+    }),
+  ]);
+}
+
+async function pingDatabase(options = {}) {
+  if (!options.db) {
+    return { configured: false, ok: true, status: 'not_configured' };
+  }
+
+  try {
+    await withTimeout(async () => {
+      if (typeof options.db.ping === 'function') {
+        await options.db.ping();
+        return;
+      }
+
+      if (typeof options.db.query === 'function') {
+        await options.db.query('SELECT 1');
+        return;
+      }
+
+      throw new Error('no supported database ping method');
+    });
+
+    return { configured: true, ok: true, status: 'up' };
+  } catch (error) {
+    return { configured: true, ok: false, status: 'down', error: error.message };
+  }
+}
+
+async function pingRedis(options = {}) {
+  if (!options.redis) {
+    return { configured: false, ok: true, status: 'not_configured' };
+  }
+
+  try {
+    await withTimeout(async () => {
+      if (typeof options.redis.ping === 'function') {
+        await options.redis.ping();
+        return;
+      }
+
+      if (typeof options.redis.sendCommand === 'function') {
+        await options.redis.sendCommand(['PING']);
+        return;
+      }
+
+      throw new Error('no supported redis ping method');
+    });
+
+    return { configured: true, ok: true, status: 'up' };
+  } catch (error) {
+    return { configured: true, ok: false, status: 'down', error: error.message };
+  }
+}
+
+async function getDependencyStatus(options = {}) {
+  const [database, redis] = await Promise.all([
+    pingDatabase(options),
+    pingRedis(options),
+  ]);
+
+  const dependencies = {};
+
+  if (database.configured) {
+    dependencies.db = database;
+  }
+
+  if (redis.configured) {
+    dependencies.redis = redis;
+  }
+
+  const status = Object.values(dependencies).every(dependency => dependency.ok !== false)
+    ? 'ok'
+    : 'degraded';
+
+  return {
+    status,
+    dependencies,
+    uptime: process.uptime(),
+  };
+}
+
+function getStartupState(options = {}) {
+  if (typeof options.isStartupComplete === 'function') {
+    return Boolean(options.isStartupComplete());
+  }
+
+  if (typeof options.startupComplete === 'boolean') {
+    return options.startupComplete;
+  }
+
+  return true;
+}
+
+async function registerHealthRoutes(fastify, options = {}) {
+${routeDefinitions}
+}
+
+module.exports = {
+  registerHealthRoutes,
+};
+`;
+}
+
+function createExpressRouteDefinitions(deployTarget) {
+  if (deployTarget === 'k8s') {
+    return `  app.get('/healthz', async (_req, res) => {
+    sendJson(res, 200, {
+      status: 'ok',
+      dependencies: {},
+      uptime: process.uptime(),
+    });
+  });
+
+  app.get('/ready', async (_req, res) => {
+    const { status, dependencies, uptime } = await getDependencyStatus(options);
+    const statusCode = status === 'ok' ? 200 : 503;
+    sendJson(res, statusCode, { status, dependencies, uptime });
+  });
+
+  app.get('/startup', (_req, res) => {
+    const startupComplete = getStartupState(options);
+    const status = startupComplete ? 'ok' : 'starting';
+    const statusCode = startupComplete ? 200 : 503;
+    sendJson(res, statusCode, {
+      status,
+      dependencies: {},
+      uptime: process.uptime(),
+    });
+  });`;
+  }
+
+  return `  app.get('/health', async (_req, res) => {
+    const { status, dependencies, uptime } = await getDependencyStatus(options);
+    const statusCode = status === 'ok' ? 200 : 503;
+    sendJson(res, statusCode, { status, dependencies, uptime });
+  });`;
+}
+
+function createFastifyRouteDefinitions(deployTarget) {
+  if (deployTarget === 'k8s') {
+    return `  fastify.get('/healthz', async () => ({
+    status: 'ok',
+    dependencies: {},
+    uptime: process.uptime(),
+  }));
+
+  fastify.get('/ready', async (_request, reply) => {
+    const { status, dependencies, uptime } = await getDependencyStatus(options);
+    reply.code(status === 'ok' ? 200 : 503);
+    return { status, dependencies, uptime };
+  });
+
+  fastify.get('/startup', async (_request, reply) => {
+    const startupComplete = getStartupState(options);
+    const status = startupComplete ? 'ok' : 'starting';
+    reply.code(startupComplete ? 200 : 503);
+    return {
+      status,
+      dependencies: {},
+      uptime: process.uptime(),
+    };
+  });`;
+  }
+
+  return `  fastify.get('/health', async (_request, reply) => {
+    const { status, dependencies, uptime } = await getDependencyStatus(options);
+    reply.code(status === 'ok' ? 200 : 503);
+    return { status, dependencies, uptime };
+  });`;
+}
+
+function createPm2Snippet() {
+  return `module.exports = {
+  apps: [
+    {
+      name: 'app',
+      script: 'src/index.js',
+      instances: 1,
+      exec_mode: 'fork',
+      env: {
+        NODE_ENV: 'production',
+      },
+    },
+  ],
+};
+`;
+}
+
+module.exports = {
+  scaffoldHealth,
+};

package/server/lib/scaffolding/health-scaffold.test.js

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+
+import { scaffoldHealth } from './health-scaffold.js';
+
+function createFsMock() {
+  return {};
+}
+
+describe('scaffoldHealth', () => {
+  it('generates a single /health endpoint for docker-compose targets', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'docker-compose',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.dependencies).toEqual([]);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].path).toBe('src/health.js');
+    expect(result.files[0].content).toContain("'/health'");
+    expect(result.files[0].content).not.toContain('/healthz');
+    expect(result.files[0].content).not.toContain('/ready');
+    expect(result.files[0].content).not.toContain('/startup');
+  });
+
+  it('generates three probe endpoints for k8s targets', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'k8s',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].content).toContain("'/healthz'");
+    expect(result.files[0].content).toContain("'/ready'");
+    expect(result.files[0].content).toContain("'/startup'");
+  });
+
+  it('generates /health and a pm2 ecosystem config snippet for vps targets', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'vps',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.files).toHaveLength(2);
+    expect(result.files.map(file => file.path)).toEqual(['src/health.js', 'ecosystem.config.js']);
+
+    const healthFile = result.files.find(file => file.path === 'src/health.js');
+    const pm2File = result.files.find(file => file.path === 'ecosystem.config.js');
+
+    expect(healthFile.content).toContain("'/health'");
+    expect(pm2File.content).toContain('module.exports');
+    expect(pm2File.content).toContain('apps:');
+    expect(pm2File.content).toContain('env:');
+  });
+
+  it('uses Express route syntax for express projects', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'docker-compose',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.files[0].content).toContain('function registerHealthRoutes(app');
+    expect(result.files[0].content).toContain("app.get('/health'");
+  });
+
+  it('uses Fastify route syntax for fastify projects', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'docker-compose',
+      framework: 'fastify',
+      fs: createFsMock(),
+    });
+
+    expect(result.files[0].content).toContain('async function registerHealthRoutes(fastify');
+    expect(result.files[0].content).toContain("fastify.get('/health'");
+  });
+
+  it('includes status, dependencies, and uptime fields in the generated health response', () => {
+    const result = scaffoldHealth({
+      projectDir: '/project',
+      deployTarget: 'docker-compose',
+      framework: 'express',
+      fs: createFsMock(),
+    });
+
+    expect(result.files[0].content).toContain('status,');
+    expect(result.files[0].content).toContain('dependencies,');
+    expect(result.files[0].content).toContain('uptime: process.uptime()');
+    expect(result.files[0].content).toContain('Promise.race');
+    expect(result.files[0].content).toContain('2000');
+  });
+});