@akash-chowdhury-24/deployhub 2.0.4 → 2.0.6

package/src/deployment/providers/docker.js

@@ -2,6 +2,17 @@ import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'path';
 import { createLogger } from '../../logger/index.js';
+import { extractArtifact } from '../../artifact/engine.js';
+import {
+  describeInterpretedBackendGap,
+  generateDotnetRuntimeDockerfile,
+  generateFrontendRuntimeDockerfile,
+  generateGoRuntimeDockerfile,
+  generateSpringRuntimeDockerfile,
+  isFrontendStaticFramework,
+  isInterpretedBackendFramework,
+  resolveDockerImageRef,
+} from '../../utils/docker-image.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -11,8 +22,8 @@ import { createLogger } from '../../logger/index.js';
 export function createDockerProvider(config, envName, env = process.env) {
   const log = createLogger('docker');
 
-  const imageName = env.DOCKER_IMAGE_NAME || config.project;
-  const imageTag = env.DOCKER_IMAGE_TAG || config.version || 'latest';
+  const { fullImage, latestImage, legacyLatestImage, imageTag } =
+    resolveDockerImageRef(config, env);
   const registryUrl = env.DOCKER_REGISTRY_URL || '';
   const registryUser = env.DOCKER_REGISTRY_USERNAME || '';
   const registryToken = env.DOCKER_REGISTRY_TOKEN || '';
@@ -27,12 +38,12 @@ export function createDockerProvider(config, envName, env = process.env) {
     return dockerEnv;
   }
 
-  const fullImage = registryUrl && !imageName.includes('/')
-    ? `${registryUrl.replace(/\/$/, '')}/${imageName}:${imageTag}`
-    : `${imageName}:${imageTag}`;
+  function hasRegistryCredentials() {
+    return Boolean(registryUser && registryToken);
+  }
 
   async function dockerLogin() {
-    if (!registryUser || !registryToken) return;
+    if (!hasRegistryCredentials()) return;
     const registry = registryUrl || 'https://index.docker.io/v1/';
     log.info('Logging in to container registry...');
     await execa(
@@ -47,48 +58,284 @@ export function createDockerProvider(config, envName, env = process.env) {
   }
 
   /**
-   * @param {string} artifactDir
+   * Push only when registry credentials are configured. Avoids a noisy failed
+   * push to Docker Hub for local-only image names.
    */
-  async function deploy(artifactDir) {
-    log.info(`Deploying via Docker (image: ${fullImage})...`);
-    const dockerEnv = getDockerEnv();
+  async function maybePushImage() {
+    if (!hasRegistryCredentials()) {
+      log.info(
+        'docker push skipped (DOCKER_REGISTRY_USERNAME/TOKEN not set — local image only)'
+      );
+      return;
+    }
 
-    const composePath = path.join(artifactDir, 'docker-compose.yml');
-    const dockerfilePath = path.join(artifactDir, 'Dockerfile');
+    log.info(`Pushing ${fullImage} to registry...`);
+    await execa('docker', ['push', fullImage], {
+      stdio: 'inherit',
+      env: getDockerEnv(),
+    });
+    log.success(`Pushed ${fullImage}`);
+  }
 
-    const hasCompose = await fs.pathExists(composePath);
-    const hasDockerfile = await fs.pathExists(dockerfilePath);
+  /**
+   * @param {string} ref
+   */
+  async function imageExists(ref) {
+    try {
+      await execa('docker', ['image', 'inspect', ref], {
+        stdio: 'pipe',
+        env: getDockerEnv(),
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
 
-    await dockerLogin();
+  /**
+   * Prefer the image already built during the pipeline `docker` stage.
+   * Retag when the pipeline used `:latest` and deploy needs a version tag.
+   */
+  async function ensureImageFromPipeline() {
+    if (await imageExists(fullImage)) {
+      log.info(`Reusing existing image ${fullImage}`);
+      return true;
+    }
 
-    if (hasCompose) {
-      await execa(
-        'docker',
-        ['compose', 'up', '-d', '--build'],
-        { cwd: artifactDir, stdio: 'inherit', env: dockerEnv }
-      );
-    } else if (hasDockerfile) {
-      await execa('docker', ['build', '-t', fullImage, '.'], {
-        cwd: artifactDir,
+    const candidates = [...new Set([latestImage, legacyLatestImage])].filter(
+      (ref) => ref !== fullImage
+    );
+
+    for (const candidate of candidates) {
+      if (!(await imageExists(candidate))) continue;
+      log.info(`Re-tagging pipeline image ${candidate} → ${fullImage}`);
+      await execa('docker', ['tag', candidate, fullImage], {
         stdio: 'inherit',
-        env: dockerEnv,
+        env: getDockerEnv(),
       });
-      await execa('docker', ['push', fullImage], {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Backend artifacts omit lockfiles/node_modules. Prefer a pre-built binary
+   * runtime image when present; otherwise fail with an actionable error.
+   * @param {string} buildContext
+   * @param {Record<string, unknown>} metadata
+   * @param {string} framework
+   * @param {number} port
+   */
+  async function prepareBackendBuildContext(buildContext, metadata, framework, port) {
+    if (framework === 'spring') {
+      const targetDir = path.join(buildContext, 'target');
+      if (await fs.pathExists(targetDir)) {
+        const jars = (await fs.readdir(targetDir)).filter((f) => f.endsWith('.jar'));
+        if (jars.length > 0) {
+          const jarRel = `target/${jars[0]}`;
+          log.info(`Building runtime image from pre-built JAR (${jarRel})...`);
+          await fs.writeFile(
+            path.join(buildContext, 'Dockerfile'),
+            generateSpringRuntimeDockerfile(jarRel, port)
+          );
+          return;
+        }
+      }
+    }
+
+    if (framework === 'go') {
+      const binDir = path.join(buildContext, 'bin');
+      if (await fs.pathExists(binDir)) {
+        const bins = await fs.readdir(binDir);
+        if (bins.length > 0) {
+          const binRel = `bin/${bins[0]}`;
+          log.info(`Building runtime image from pre-built Go binary (${binRel})...`);
+          await fs.writeFile(
+            path.join(buildContext, 'Dockerfile'),
+            generateGoRuntimeDockerfile(binRel, port)
+          );
+          return;
+        }
+      }
+    }
+
+    if (framework === 'dotnet') {
+      const publishDir =
+        /** @type {string} */ (metadata.buildOutput) ||
+        config.buildOutput ||
+        'publish';
+      const publishPath = path.join(buildContext, publishDir);
+      if (await fs.pathExists(publishPath)) {
+        log.info(`Building runtime image from pre-built .NET output (${publishDir}/)...`);
+        await fs.writeFile(
+          path.join(buildContext, 'Dockerfile'),
+          generateDotnetRuntimeDockerfile(publishDir, port)
+        );
+        return;
+      }
+    }
+
+    const dockerfilePath = path.join(buildContext, 'Dockerfile');
+    if (!(await fs.pathExists(dockerfilePath))) {
+      throw new Error(
+        'No Dockerfile found in artifact and no pipeline image to reuse. ' +
+          'Add a Dockerfile and enable pipeline.docker so the image is built from project source.'
+      );
+    }
+
+    // Interpreted backends (Node/Python/PHP/Ruby): never rebuild from artifact.
+    // Artifacts ship source + manifest files, not installed dependency trees.
+    if (isInterpretedBackendFramework(framework)) {
+      const gap = describeInterpretedBackendGap(framework);
+      throw new Error(
+        `Cannot rebuild ${gap.ecosystem} backend image "${fullImage}" from the packaged artifact.\n` +
+          `Backend artifacts include source/manifests but not ${gap.missing}, ` +
+          `so Dockerfiles that run \`${gap.installCmd}\` cannot reliably succeed from the artifact alone.\n\n` +
+          'What to do instead:\n' +
+          '  1. Enable pipeline.docker in deployhub.config.json (default when Docker deploy is selected).\n' +
+          '  2. Run a full `deployhub build` so the image is built from the project root (with full deps).\n' +
+          '  3. Deploy will reuse that local image (retag/push/run) — it will not rebuild from the artifact.\n\n' +
+          `Standalone \`deployhub deploy\` without a pre-built local image is not supported for ${gap.ecosystem} backends.`
+      );
+    }
+
+    // Remaining backends (unknown frameworks): try the packaged Dockerfile, but warn.
+    log.warn(
+      'Building backend image from extracted artifact. Prefer pipeline.docker so the image ' +
+        'is built once from full project source, then reused on deploy.'
+    );
+  }
+
+  /**
+   * Standalone deploy fallback: extract the packaged artifact and build a
+   * runtime image from pre-built output (frontend) or compiled backend artifacts.
+   * Never builds from artifactDir root — that only has zip/metadata + a source Dockerfile.
+   * @param {string} artifactDir
+   */
+  async function buildFromArtifactContents(artifactDir) {
+    const zipPath = path.join(artifactDir, 'artifact.zip');
+    if (!(await fs.pathExists(zipPath))) {
+      throw new Error(
+        `No local image found for ${fullImage} and no artifact.zip to build from. ` +
+          'Enable pipeline.docker so the image is built from project source, or run deployhub build first.'
+      );
+    }
+
+    const buildContext = path.join(artifactDir, '_docker_build');
+    await fs.remove(buildContext);
+    await extractArtifact(artifactDir, buildContext);
+
+    try {
+      const metadataPath = path.join(buildContext, 'metadata.json');
+      const metadata = (await fs.pathExists(metadataPath))
+        ? await fs.readJson(metadataPath)
+        : {};
+
+      const projectType = metadata.projectType || config.projectType || 'frontend';
+      const framework =
+        metadata.framework ||
+        config.framework ||
+        config.frontend?.framework ||
+        '';
+      const buildOutput =
+        metadata.buildOutput ||
+        config.buildOutput ||
+        config.frontend?.buildOutput ||
+        'dist';
+      const port =
+        Number(metadata.port) ||
+        config.port ||
+        config.backend?.port ||
+        3000;
+
+      const composePath = path.join(buildContext, 'docker-compose.yml');
+      if (await fs.pathExists(composePath)) {
+        log.info('Building via docker compose from extracted artifact...');
+        await execa('docker', ['compose', 'up', '-d', '--build'], {
+          cwd: buildContext,
+          stdio: 'inherit',
+          env: getDockerEnv(),
+        });
+        return { ranCompose: true };
+      }
+
+      const isStaticFrontend =
+        projectType === 'frontend' || isFrontendStaticFramework(framework);
+
+      if (isStaticFrontend) {
+        const outputDir = path.join(buildContext, buildOutput);
+        if (!(await fs.pathExists(outputDir))) {
+          throw new Error(
+            `Frontend artifact is missing build output "${buildOutput}". ` +
+              'Cannot build a runtime image from this artifact.'
+          );
+        }
+        log.info(
+          `Building runtime image from pre-built ${buildOutput}/ (no source rebuild)...`
+        );
+        await fs.writeFile(
+          path.join(buildContext, 'Dockerfile'),
+          generateFrontendRuntimeDockerfile(buildOutput)
+        );
+      } else {
+        await prepareBackendBuildContext(buildContext, metadata, framework, port);
+      }
+
+      await execa('docker', ['build', '-t', fullImage, '.'], {
+        cwd: buildContext,
         stdio: 'inherit',
-        env: dockerEnv,
-      }).catch(() => {
-        log.warn('docker push skipped (registry may be local or push not configured)');
+        env: getDockerEnv(),
       });
-      await execa('docker', ['run', '-d', '--rm', '--name', config.project, fullImage], {
-        stdio: 'inherit',
+      return { ranCompose: false };
+    } finally {
+      await fs.remove(buildContext).catch(() => {});
+    }
+  }
+
+  /**
+   * @param {string} artifactDir
+   */
+  async function deploy(artifactDir) {
+    log.info(`Deploying via Docker (image: ${fullImage})...`);
+    const dockerEnv = getDockerEnv();
+
+    await dockerLogin();
+
+    const reused = await ensureImageFromPipeline();
+    let ranCompose = false;
+
+    if (!reused) {
+      const result = await buildFromArtifactContents(artifactDir);
+      ranCompose = Boolean(result?.ranCompose);
+    }
+
+    if (ranCompose) {
+      log.success('Docker deployment complete');
+      return;
+    }
+
+    await maybePushImage();
+
+    // Keep :latest in sync when deploy uses a version tag
+    if (imageTag !== 'latest' && fullImage !== latestImage) {
+      await execa('docker', ['tag', fullImage, latestImage], {
+        stdio: 'pipe',
         env: dockerEnv,
-      });
-    } else {
-      throw new Error(
-        'No Dockerfile or docker-compose.yml found in artifact. Add one to your project or enable Docker in pipeline config.'
-      );
+      }).catch(() => {});
     }
 
+    await execa(
+      'docker',
+      ['rm', '-f', config.project],
+      { stdio: 'pipe', env: dockerEnv }
+    ).catch(() => {});
+
+    await execa('docker', ['run', '-d', '--rm', '--name', config.project, fullImage], {
+      stdio: 'inherit',
+      env: dockerEnv,
+    });
+
     log.success('Docker deployment complete');
   }
 

package/src/deployment/providers/kubernetes.js

@@ -3,6 +3,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import { createLogger } from '../../logger/index.js';
+import { sanitizeK8sName } from '../../utils/kubernetes-manifests.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -15,6 +16,7 @@ export function createKubernetesProvider(config, envName, env = process.env) {
   const kubeconfig = env.KUBECONFIG || path.join(os.homedir(), '.kube', 'config');
   const context = env.KUBE_CONTEXT || '';
   const namespace = env.KUBE_NAMESPACE || config.project || 'default';
+  const deploymentName = sanitizeK8sName(config.project || 'app');
 
   function getKubectlEnv() {
     const expanded = kubeconfig.replace(/^~/, os.homedir());
@@ -66,8 +68,8 @@ export function createKubernetesProvider(config, envName, env = process.env) {
         kubectlArgs([
           'set',
           'image',
-          `deployment/${config.project}`,
-          `${config.project}=${imageName}:${imageTag}`,
+          `deployment/${deploymentName}`,
+          `${deploymentName}=${imageName}:${imageTag}`,
         ]),
         { stdio: 'pipe', env: getKubectlEnv() }
       ).catch(() => {
@@ -80,7 +82,7 @@ export function createKubernetesProvider(config, envName, env = process.env) {
 
   async function rollback(artifactDir) {
     log.info('Rolling back Kubernetes deployment...');
-    await execa('kubectl', kubectlArgs(['rollout', 'undo', `deployment/${config.project}`]), {
+    await execa('kubectl', kubectlArgs(['rollout', 'undo', `deployment/${deploymentName}`]), {
       stdio: 'inherit',
       env: getKubectlEnv(),
     }).catch(async () => {
@@ -105,7 +107,7 @@ export function createKubernetesProvider(config, envName, env = process.env) {
     try {
       await execa(
         'kubectl',
-        kubectlArgs(['rollout', 'status', `deployment/${config.project}`, '--timeout=30s']),
+        kubectlArgs(['rollout', 'status', `deployment/${deploymentName}`, '--timeout=30s']),
         { stdio: 'pipe', env: getKubectlEnv() }
       );
       return true;

package/src/utils/docker-image.js

@@ -0,0 +1,181 @@
+/**
+ * Shared Docker image naming for pipeline builds and deploy.
+ */
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, string|undefined>} [env]
+ * @returns {{
+ *   imageName: string,
+ *   imageTag: string,
+ *   fullImage: string,
+ *   latestImage: string,
+ *   legacyLatestImage: string,
+ * }}
+ */
+export function resolveDockerImageRef(config, env = process.env) {
+  const imageName = env.DOCKER_IMAGE_NAME || config.project;
+  const imageTag = env.DOCKER_IMAGE_TAG || config.version || 'latest';
+  const registryUrl = env.DOCKER_REGISTRY_URL || '';
+
+  const repository =
+    registryUrl && !imageName.includes('/')
+      ? `${registryUrl.replace(/\/$/, '')}/${imageName}`
+      : imageName;
+
+  return {
+    imageName,
+    imageTag,
+    fullImage: `${repository}:${imageTag}`,
+    latestImage: `${repository}:latest`,
+    legacyLatestImage: `${config.project}:latest`,
+  };
+}
+
+/**
+ * Runtime-only Dockerfile for frontend artifacts that already contain built static output.
+ * Used when deploy must build from an artifact (no source / no package-lock).
+ * @param {string} [buildOutput]
+ * @returns {string}
+ */
+export function generateFrontendRuntimeDockerfile(buildOutput = 'dist') {
+  const output = buildOutput.replace(/^\/+|\/+$/g, '') || 'dist';
+  return `# Generated by DeployHub for artifact deploy (pre-built static output)
+FROM nginx:alpine
+COPY ${output}/ /usr/share/nginx/html/
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}
+
+/**
+ * @param {string} jarRelativePath e.g. target/app.jar
+ * @param {number} [port]
+ */
+export function generateSpringRuntimeDockerfile(jarRelativePath, port = 8080) {
+  return `# Generated by DeployHub for artifact deploy (pre-built JAR)
+FROM eclipse-temurin:17-jre-alpine
+WORKDIR /app
+COPY ${jarRelativePath} app.jar
+EXPOSE ${port}
+CMD ["java", "-jar", "app.jar"]
+`;
+}
+
+/**
+ * @param {string} binaryRelativePath e.g. bin/app
+ * @param {number} [port]
+ */
+export function generateGoRuntimeDockerfile(binaryRelativePath, port = 8080) {
+  return `# Generated by DeployHub for artifact deploy (pre-built Go binary)
+FROM alpine:3.19
+WORKDIR /app
+RUN apk add --no-cache ca-certificates
+COPY ${binaryRelativePath} ./app
+RUN chmod +x ./app
+EXPOSE ${port}
+CMD ["./app"]
+`;
+}
+
+/**
+ * @param {string} publishDir
+ * @param {number} [port]
+ */
+export function generateDotnetRuntimeDockerfile(publishDir = 'publish', port = 5000) {
+  const dir = publishDir.replace(/^\/+|\/+$/g, '') || 'publish';
+  return `# Generated by DeployHub for artifact deploy (pre-built .NET publish output)
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+WORKDIR /app
+COPY ${dir}/ .
+EXPOSE ${port}
+ENV ASPNETCORE_URLS=http://+:${port}
+CMD ["dotnet", "App.dll"]
+`;
+}
+
+/**
+ * @param {string} framework
+ * @returns {boolean}
+ */
+export function isFrontendStaticFramework(framework) {
+  return ['react', 'vue', 'angular', 'svelte', 'astro', 'vanilla'].includes(framework || '');
+}
+
+/**
+ * Node-style backends whose generated Dockerfiles run npm ci and need a lockfile.
+ * @param {string} framework
+ */
+export function isNodeBackendFramework(framework) {
+  return ['express', 'nestjs', 'fastify', 'koa', 'nextjs'].includes(framework || '');
+}
+
+/**
+ * Interpreted backends that install deps at image-build time (pip/composer/bundle/npm).
+ * Their artifacts lack vendor/venv/node_modules, so standalone artifact rebuild is unsupported.
+ * @param {string} framework
+ */
+export function isInterpretedBackendFramework(framework) {
+  return [
+    ...['express', 'nestjs', 'fastify', 'koa', 'nextjs'],
+    'fastapi',
+    'django',
+    'flask',
+    'laravel',
+    'symfony',
+    'rails',
+  ].includes(framework || '');
+}
+
+/**
+ * Human-readable dependency gap for interpreted backend artifact rebuilds.
+ * @param {string} framework
+ * @returns {{ ecosystem: string, missing: string, installCmd: string }}
+ */
+export function describeInterpretedBackendGap(framework) {
+  if (isNodeBackendFramework(framework)) {
+    return {
+      ecosystem: 'Node',
+      missing: 'package-lock.json / node_modules',
+      installCmd: 'npm ci',
+    };
+  }
+  if (['fastapi', 'django', 'flask'].includes(framework)) {
+    return {
+      ecosystem: 'Python',
+      missing: 'a pre-installed virtualenv / site-packages (artifacts only ship requirements.txt + source)',
+      installCmd: 'pip install',
+    };
+  }
+  if (['laravel', 'symfony'].includes(framework)) {
+    return {
+      ecosystem: 'PHP',
+      missing: 'vendor/ (Composer dependencies are not packaged into the artifact)',
+      installCmd: 'composer install',
+    };
+  }
+  if (framework === 'rails') {
+    return {
+      ecosystem: 'Ruby',
+      missing: 'vendor/bundle / installed gems (artifacts only ship Gemfile + lock)',
+      installCmd: 'bundle install',
+    };
+  }
+  return {
+    ecosystem: 'backend',
+    missing: 'installed dependencies (not packaged into the artifact)',
+    installCmd: 'dependency install',
+  };
+}
+
+export default {
+  resolveDockerImageRef,
+  generateFrontendRuntimeDockerfile,
+  generateSpringRuntimeDockerfile,
+  generateGoRuntimeDockerfile,
+  generateDotnetRuntimeDockerfile,
+  isFrontendStaticFramework,
+  isNodeBackendFramework,
+  isInterpretedBackendFramework,
+  describeInterpretedBackendGap,
+};