@akash-chowdhury-24/deployhub 2.0.4 → 2.0.5

package/README.md

@@ -185,6 +185,8 @@ The wizard asks the same core questions for every setup:
 - `.github/workflows/deployhub.yml` — CI pipeline
 - `.env.example` — list of env vars you may need
 - `nginx.conf` — auto-generated if frontend deploys to SSH
+- `Dockerfile` — auto-generated if missing and you chose Docker or Kubernetes deploy (your existing `Dockerfile` is never overwritten)
+- `k8s/deployment.yaml` and `k8s/service.yaml` — auto-generated if missing and you chose Kubernetes deploy (existing manifests are never overwritten)
 
 ---
 
@@ -596,7 +598,7 @@ DeployHub supports six deployment targets. Pick based on what infrastructure you
 | **ec2** | AWS users with an existing EC2 instance | Running EC2 instance, security group, key pair |
 | **azure-vm** | Azure users with an existing virtual machine | Running Azure VM, NSG allowing SSH |
 | **gcp-vm** | GCP users with an existing Compute Engine VM | Running VM, firewall rule for SSH, metadata SSH key |
-| **kubernetes** | Teams with an existing K8s cluster | Cluster, kubectl access, manifests in repo |
+| **kubernetes** | Teams with an existing K8s cluster | Cluster, kubectl access; manifests auto-generated if missing |
 
 ---
 
@@ -675,10 +677,11 @@ DeployHub detects whether the server uses Debian-style `sites-available` or RHEL
 
 **Prerequisites:**
 - [ ] Docker installed (`docker --version` works)
-- [ ] `Dockerfile` or `docker-compose.yml` in project
 - [ ] Registry account if pushing private images
+- [ ] `docker-compose.yml` in project if you use multi-service Compose (not auto-generated)
 
 **What DeployHub automates:**
+- Starter `Dockerfile` at project root when none exists (framework-aware; skipped if you already have one)
 - `.env.example` for image name, registry, remote `DOCKER_HOST`
 - Docker daemon connectivity test during `init`
 - `docker compose up` or build/push/run during deploy
@@ -812,11 +815,12 @@ DeployHub detects whether the server uses Debian-style `sites-available` or RHEL
 
 **Prerequisites:**
 - [ ] Existing Kubernetes cluster (DeployHub does not provision clusters)
-- [ ] `kubectl` installed and configured
-- [ ] Kubernetes manifests (`.yaml` or `k8s/` directory) in your repo
+- [ ] `kubectl` installed and configured on your **local machine** (for `deployhub doctor` / manual `deployhub deploy`)
 - [ ] Cluster reachable from CI (kubeconfig secret or cloud auth)
 
 **What DeployHub automates:**
+- Starter `k8s/deployment.yaml` and `k8s/service.yaml` when no manifests exist (skipped if you already have a `k8s/` directory or root-level Kubernetes YAML files)
+- GitHub Actions installs `kubectl` on the CI runner and writes kubeconfig from secrets (no local `kubectl` required for the automated push-to-main deploy path)
 - Lists `kubectl` contexts during `init` for easy selection
 - Auto-detects `~/.kube/config`
 - Complete `.env.example` for kubeconfig, context, namespace
@@ -835,6 +839,7 @@ DeployHub detects whether the server uses Debian-style `sites-available` or RHEL
 | `KUBE_CONTEXT` | Context name | `my-cluster` | `kubectl config get-contexts` |
 | `KUBE_NAMESPACE` | Target namespace | `my-app` | `kubectl get namespaces` |
 | `DOCKER_IMAGE_NAME` | Container image | `ghcr.io/org/app` | Your registry |
+| `DOCKER_IMAGE_TAG` | Image tag | `1.0.0` or `latest` | Project version or your choice |
 | `KUBE_IMAGE_PULL_SECRET` | Pull secret name | `regcred` | `kubectl create secret docker-registry` |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akash-chowdhury-24/deployhub",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Zero-configuration deployment and artifact manager",
   "type": "module",
   "main": "./src/cli/index.js",

package/src/artifact/engine.js

@@ -6,6 +6,11 @@ import { createLogger } from '../logger/index.js';
 import { generateChecksums, formatChecksums } from '../utils/checksums.js';
 import { getProjectVersion } from '../utils/version.js';
 import { generateNginxConfig } from '../utils/nginx.js';
+import {
+  ensureDeployScaffold,
+  copyKubernetesManifestsIfPresent,
+  copyDeployAssetsToArtifactDir,
+} from '../utils/scaffold.js';
 import { getGeneratedByMetadata, getArtifactReadmeFooter } from '../utils/author.js';
 
 /**
@@ -143,6 +148,8 @@ async function stageFrontendArtifact(cwd, stagingDir, config) {
     await copyIfExists(cwd, stagingDir, file);
   }
 
+  await copyKubernetesManifestsIfPresent(cwd, stagingDir);
+
   const hasSshDeploy = (config.deploy || []).some(
     (envName) => config.environments[envName]?.type === 'ssh'
   );
@@ -172,6 +179,8 @@ async function stageBackendArtifact(cwd, stagingDir, config) {
     await copyIfExists(cwd, stagingDir, file);
   }
 
+  await copyKubernetesManifestsIfPresent(cwd, stagingDir);
+
   await copyDirectoryIfExists(cwd, stagingDir, 'config');
   await copyDirectoryIfExists(cwd, stagingDir, 'migrations');
 
@@ -259,6 +268,8 @@ export async function createArtifact(config, deployedTargets = [], cwd = process
 
   log.info(`Staging ${projectType} artifact...`);
 
+  await ensureDeployScaffold(cwd, config, config.environments || {}, { silent: false });
+
   if (projectType === 'both') {
     await stageFrontendArtifact(cwd, stagingDir, config);
     const backendStaging = path.join(stagingDir, 'backend');
@@ -337,6 +348,8 @@ ${getArtifactReadmeFooter()}`;
   const zipPath = path.join(artifactDir, 'artifact.zip');
   await createZip(stagingDir, zipPath);
 
+  await copyDeployAssetsToArtifactDir(stagingDir, artifactDir);
+
   const checksums = await generateChecksums(stagingDir);
   const checksumContent = formatChecksums(checksums);
   await fs.writeFile(path.join(artifactDir, 'checksums.txt'), checksumContent);

package/src/commands/init.js

@@ -20,6 +20,10 @@ import {
 } from '../utils/github-actions.js';
 import { printAuthorFooter } from '../utils/author.js';
 import { generateNginxConfig } from '../utils/nginx.js';
+import {
+  ensureDockerfile,
+  ensureKubernetesManifests,
+} from '../utils/scaffold.js';
 import {
   promptServerDeployment,
   buildServerEnvEntry,
@@ -190,6 +194,21 @@ async function generateProjectScaffold(config, environments, cwd) {
     await fs.writeFile(path.join(cwd, 'nginx.conf'), nginxConf);
     console.log(chalk.gray('  • nginx.conf (auto-generated)'));
   }
+
+  const dockerResult = await ensureDockerfile(cwd, config);
+  if (dockerResult.generated) {
+    console.log(chalk.gray('  • Dockerfile (auto-generated)'));
+  }
+
+  const k8sResult = await ensureKubernetesManifests(cwd, config, environments);
+  if (k8sResult.generated) {
+    console.log(chalk.gray('  • k8s/deployment.yaml, k8s/service.yaml (auto-generated)'));
+  }
+
+  return {
+    dockerfileGenerated: dockerResult.generated,
+    kubernetesGenerated: k8sResult.generated,
+  };
 }
 
 /**
@@ -397,7 +416,7 @@ export function registerInitCommand(program) {
       }
 
       const version = await getProjectVersion(cwd);
-      const hasDocker =
+      let hasDocker =
         (detectedFrontend?.hasDocker || detectedBackend?.hasDocker) ?? false;
 
       /** @type {Record<string, unknown>} */
@@ -458,7 +477,14 @@ export function registerInitCommand(program) {
         config
       );
 
-      await generateProjectScaffold(config, environments, cwd);
+      const scaffoldResult = await generateProjectScaffold(config, environments, cwd);
+
+      if (scaffoldResult?.dockerfileGenerated) {
+        hasDocker = true;
+        config.docker = true;
+        config.pipeline.docker = true;
+        await saveConfig(config, cwd);
+      }
 
       const envExampleDest = path.join(cwd, '.env.example');
       const envExampleContent = generateEnvExampleContent(

package/src/core/stages.js

@@ -6,6 +6,7 @@ import { deployToAll } from '../deployment/index.js';
 import { sendNotifications } from '../notifications/index.js';
 import axios from 'axios';
 import { getProjectVersion } from '../utils/version.js';
+import { ensureDeployScaffold } from '../utils/scaffold.js';
 
 /**
  * @param {import('../core/config.js').DeployHubConfig} config
@@ -40,6 +41,18 @@ export function buildPipelineStages(config, cwd, state) {
             ctx.config.port = detected.port;
           }
         }
+        const scaffold = await ensureDeployScaffold(
+          ctx.cwd,
+          ctx.config,
+          ctx.config.environments || {},
+          { silent: false }
+        );
+        if (scaffold.dockerfile) {
+          ctx.config.docker = true;
+          if (ctx.config.pipeline) {
+            ctx.config.pipeline.docker = true;
+          }
+        }
         ctx.state.framework = ctx.config.framework;
         ctx.state.projectType = ctx.config.projectType || 'frontend';
       },

package/src/deployment/deployment-env.js

@@ -323,6 +323,15 @@ export const DEPLOYMENT_ENV_DEFS = {
       example: 'ghcr.io/myorg/myapp',
       when: 'optional',
     },
+    {
+      key: 'DOCKER_IMAGE_TAG',
+      optionalReason: 'defaults to your project version, then "latest" if unset',
+      comment: [
+        'Image tag written into generated manifests and used at deploy time.',
+      ],
+      example: 'latest',
+      when: 'optional',
+    },
     {
       key: 'KUBE_IMAGE_PULL_SECRET',
       optionalReason: 'only required when pulling from a private container registry',

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/dockerfile.js

@@ -0,0 +1,486 @@
+/**
+ * Dockerfile generation based on detected framework / project settings.
+ */
+
+const GENERATED_HEADER =
+  '# Generated by DeployHub — review exposed port and start command before deploying.\n';
+
+/**
+ * @param {string} projectName
+ * @returns {string}
+ */
+export function sanitizeDockerProjectName(projectName) {
+  return projectName.replace(/[^a-zA-Z0-9_-]/g, '-');
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @returns {{ framework: string, buildCommand: string|null, buildOutput: string, startCommand: string|null, port: number, projectType: string }}
+ */
+export function resolveDockerSettings(config) {
+  const projectType = config.projectType || 'frontend';
+
+  if (projectType === 'both' && config.backend) {
+    return {
+      framework: config.backend.framework || 'express',
+      buildCommand: config.backend.buildCommand ?? null,
+      buildOutput: config.backend.buildOutput || '.',
+      startCommand: config.backend.startCommand || 'npm start',
+      port: config.backend.port || 3000,
+      projectType,
+    };
+  }
+
+  return {
+    framework: config.framework || 'express',
+    buildCommand: config.buildCommand ?? null,
+    buildOutput: config.buildOutput || 'dist',
+    startCommand: config.startCommand || 'npm start',
+    port: config.port || 3000,
+    projectType,
+  };
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @returns {string}
+ */
+export function generateDockerfile(config) {
+  const settings = resolveDockerSettings(config);
+  const { framework } = settings;
+
+  const frontendStatic = ['react', 'vue', 'angular', 'svelte', 'astro', 'vanilla'];
+  if (frontendStatic.includes(framework)) {
+    return generateFrontendStaticDockerfile(settings);
+  }
+
+  switch (framework) {
+    case 'nextjs':
+      return generateNextjsDockerfile(settings);
+    case 'nestjs':
+      return generateNestjsDockerfile(settings);
+    case 'express':
+    case 'fastify':
+    case 'koa':
+      return generateNodeBackendDockerfile(settings);
+    case 'fastapi':
+      return generateFastapiDockerfile(settings);
+    case 'django':
+      return generateDjangoDockerfile(settings);
+    case 'flask':
+      return generateFlaskDockerfile(settings);
+    case 'laravel':
+      return generateLaravelDockerfile(settings);
+    case 'symfony':
+      return generateSymfonyDockerfile(settings);
+    case 'spring':
+      return generateSpringDockerfile(settings);
+    case 'go':
+      return generateGoDockerfile(settings);
+    case 'dotnet':
+      return generateDotnetDockerfile(settings);
+    case 'rails':
+      return generateRailsDockerfile(settings);
+    default:
+      return generateNodeBackendDockerfile(settings);
+  }
+}
+
+/**
+ * @param {{ buildCommand: string|null, buildOutput: string, port: number }} settings
+ */
+function generateFrontendStaticDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'npm run build';
+  const output = settings.buildOutput || 'dist';
+
+  return `${GENERATED_HEADER}
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN ${buildCmd}
+
+FROM nginx:alpine
+COPY --from=build /app/${output} /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, startCommand: string|null, port: number }} settings
+ */
+function generateNextjsDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'npm run build';
+  const startCmd = settings.startCommand || 'npm start';
+  const port = settings.port || 3000;
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN ${buildCmd}
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+COPY --from=build /app/package*.json ./
+COPY --from=build /app/node_modules ./node_modules
+COPY --from=build /app/.next ./.next
+COPY --from=build /app/public ./public
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, buildOutput: string, startCommand: string|null, port: number }} settings
+ */
+function generateNestjsDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'npm run build';
+  const startCmd = settings.startCommand || 'node dist/main';
+  const port = settings.port || 3000;
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN ${buildCmd}
+
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY --from=build /app/${settings.buildOutput || 'dist'} ./${settings.buildOutput || 'dist'}
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, buildOutput: string, startCommand: string|null, port: number }} settings
+ */
+function generateNodeBackendDockerfile(settings) {
+  const port = settings.port || 3000;
+  const startCmd = settings.startCommand || 'npm start';
+  const startParts = parseCommand(startCmd);
+
+  if (settings.buildCommand) {
+    return `${GENERATED_HEADER}
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN ${settings.buildCommand}
+
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY --from=build /app/${settings.buildOutput || '.'} ./${settings.buildOutput || '.'}
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+  }
+
+  return `${GENERATED_HEADER}
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --omit=dev
+
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ startCommand: string|null, port: number }} settings
+ */
+function generateFastapiDockerfile(settings) {
+  const port = settings.port || 8000;
+  const startCmd = settings.startCommand || `uvicorn main:app --host 0.0.0.0 --port ${port}`;
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM python:3.11-slim AS build
+WORKDIR /app
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+FROM python:3.11-slim
+WORKDIR /app
+COPY --from=build /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=build /usr/local/bin /usr/local/bin
+COPY . .
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ startCommand: string|null, port: number }} settings
+ */
+function generateDjangoDockerfile(settings) {
+  const port = settings.port || 8000;
+  const startCmd =
+    settings.startCommand || `gunicorn config.wsgi:application --bind 0.0.0.0:${port}`;
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM python:3.11-slim AS build
+WORKDIR /app
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+FROM python:3.11-slim
+WORKDIR /app
+COPY --from=build /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=build /usr/local/bin /usr/local/bin
+COPY . .
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ startCommand: string|null, port: number }} settings
+ */
+function generateFlaskDockerfile(settings) {
+  const port = settings.port || 5000;
+  const startCmd = settings.startCommand || `gunicorn app:app --bind 0.0.0.0:${port}`;
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM python:3.11-slim AS build
+WORKDIR /app
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+FROM python:3.11-slim
+WORKDIR /app
+COPY --from=build /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=build /usr/local/bin /usr/local/bin
+COPY . .
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {{ port: number }} settings
+ */
+function generateLaravelDockerfile(settings) {
+  const port = settings.port || 80;
+
+  return `${GENERATED_HEADER}
+FROM composer:2 AS vendor
+WORKDIR /app
+COPY composer.json composer.lock ./
+RUN composer install --no-dev --optimize-autoloader --no-interaction
+
+FROM php:8.2-fpm-alpine
+WORKDIR /var/www/html
+COPY --from=vendor /app/vendor ./vendor
+COPY . .
+RUN chown -R www-data:www-data storage bootstrap/cache || true
+EXPOSE ${port}
+CMD ["php-fpm"]
+`;
+}
+
+/**
+ * @param {{ port: number }} settings
+ */
+function generateSymfonyDockerfile(settings) {
+  const port = settings.port || 80;
+
+  return `${GENERATED_HEADER}
+FROM composer:2 AS vendor
+WORKDIR /app
+COPY composer.json composer.lock ./
+RUN composer install --no-dev --optimize-autoloader --no-interaction
+
+FROM php:8.2-fpm-alpine
+WORKDIR /var/www/html
+COPY --from=vendor /app/vendor ./vendor
+COPY . .
+EXPOSE ${port}
+CMD ["php-fpm"]
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, port: number }} settings
+ */
+function generateSpringDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'mvn package -DskipTests';
+  const port = settings.port || 8080;
+
+  return `${GENERATED_HEADER}
+FROM eclipse-temurin:17-jdk-alpine AS build
+WORKDIR /app
+COPY pom.xml ./
+COPY src ./src
+RUN apk add --no-cache maven && ${buildCmd}
+
+FROM eclipse-temurin:17-jre-alpine
+WORKDIR /app
+COPY --from=build /app/target/*.jar app.jar
+EXPOSE ${port}
+CMD ["java", "-jar", "app.jar"]
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, startCommand: string|null, port: number }} settings
+ */
+function generateGoDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'go build -o /app/bin/app .';
+  const port = settings.port || 8080;
+
+  return `${GENERATED_HEADER}
+FROM golang:1.22-alpine AS build
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN ${buildCmd}
+
+FROM alpine:3.19
+WORKDIR /app
+RUN apk add --no-cache ca-certificates
+COPY --from=build /app/bin/app ./app
+EXPOSE ${port}
+CMD ["./app"]
+`;
+}
+
+/**
+ * @param {{ buildCommand: string|null, buildOutput: string, startCommand: string|null, port: number }} settings
+ */
+function generateDotnetDockerfile(settings) {
+  const buildCmd = settings.buildCommand || 'dotnet publish -c Release -o /app/publish';
+  const port = settings.port || 5000;
+  const output = settings.buildOutput || 'publish';
+
+  return `${GENERATED_HEADER}
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+COPY *.csproj ./
+RUN dotnet restore
+COPY . .
+RUN ${buildCmd}
+
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+WORKDIR /app
+COPY --from=build /src/${output} .
+EXPOSE ${port}
+ENV ASPNETCORE_URLS=http://+:${port}
+CMD ["dotnet", "App.dll"]
+`;
+}
+
+/**
+ * @param {{ startCommand: string|null, port: number }} settings
+ */
+function generateRailsDockerfile(settings) {
+  const port = settings.port || 3000;
+  const startCmd = settings.startCommand || 'bundle exec puma -C config/puma.rb';
+  const startParts = parseCommand(startCmd);
+
+  return `${GENERATED_HEADER}
+FROM ruby:3.2-slim AS build
+WORKDIR /app
+RUN apt-get update -qq && apt-get install -y build-essential libpq-dev && rm -rf /var/lib/apt/lists/*
+COPY Gemfile Gemfile.lock ./
+RUN bundle install --without development test
+COPY . .
+RUN bundle exec rake assets:precompile || true
+
+FROM ruby:3.2-slim
+WORKDIR /app
+RUN apt-get update -qq && apt-get install -y libpq-dev && rm -rf /var/lib/apt/lists/*
+COPY --from=build /usr/local/bundle /usr/local/bundle
+COPY --from=build /app .
+EXPOSE ${port}
+CMD ${JSON.stringify(startParts)}
+`;
+}
+
+/**
+ * @param {string} command
+ * @returns {string[]}
+ */
+function parseCommand(command) {
+  const trimmed = command.trim();
+  if (trimmed.startsWith('[')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      // fall through
+    }
+  }
+
+  const match = trimmed.match(/^(\S+)(?:\s+(.*))?$/);
+  if (!match) return ['sh', '-c', trimmed];
+  const [, bin, rest] = match;
+  if (!rest) return [bin];
+  return [bin, ...rest.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g).map((part) => part.replace(/^['"]|['"]$/g, ''))];
+}
+
+/**
+ * Human-readable framework label for user messages.
+ * @param {string} framework
+ */
+export function getDockerfileFrameworkLabel(framework) {
+  const labels = {
+    react: 'React',
+    vue: 'Vue',
+    angular: 'Angular',
+    nextjs: 'Next.js',
+    svelte: 'Svelte',
+    astro: 'Astro',
+    vanilla: 'Vanilla JS',
+    express: 'Express',
+    nestjs: 'NestJS',
+    fastify: 'Fastify',
+    koa: 'Koa',
+    fastapi: 'FastAPI',
+    django: 'Django',
+    flask: 'Flask',
+    laravel: 'Laravel',
+    symfony: 'Symfony',
+    spring: 'Spring Boot',
+    go: 'Go',
+    dotnet: '.NET',
+    rails: 'Ruby on Rails',
+  };
+  return labels[framework] || framework;
+}
+
+export default {
+  generateDockerfile,
+  resolveDockerSettings,
+  sanitizeDockerProjectName,
+  getDockerfileFrameworkLabel,
+};

package/src/utils/github-actions.js

@@ -208,6 +208,56 @@ function getBackendSetupSteps(config) {
   return steps;
 }
 
+const KUBECTL_VERSION = 'v1.30.4';
+
+/**
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, { type: string }>} environments
+ * @returns {boolean}
+ */
+function hasKubernetesDeploy(deployEnvironments, environments) {
+  return deployEnvironments.some((envName) => environments[envName]?.type === 'kubernetes');
+}
+
+/**
+ * @returns {string}
+ */
+function getKubernetesSetupSteps() {
+  return `      - name: Setup kubectl
+        uses: azure/setup-kubectl@v4
+        with:
+          version: '${KUBECTL_VERSION}'
+
+      - name: Configure kubeconfig
+        env:
+          KUBECONFIG_SECRET: \${{ secrets.KUBECONFIG }}
+        run: |
+          mkdir -p "$GITHUB_WORKSPACE/.kube"
+          if echo "$KUBECONFIG_SECRET" | base64 -d > "$GITHUB_WORKSPACE/.kube/config" 2>/dev/null; then
+            :
+          else
+            printf '%s' "$KUBECONFIG_SECRET" > "$GITHUB_WORKSPACE/.kube/config"
+          fi
+          chmod 600 "$GITHUB_WORKSPACE/.kube/config"`;
+}
+
+/**
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, { type: string }>} environments
+ * @param {Set<string>} envVars
+ */
+function applyKubernetesWorkflowEnv(deployEnvironments, environments, envVars) {
+  if (!hasKubernetesDeploy(deployEnvironments, environments)) return;
+
+  for (const entry of envVars) {
+    if (entry.startsWith('KUBECONFIG:')) {
+      envVars.delete(entry);
+      break;
+    }
+  }
+  envVars.add('KUBECONFIG: ${{ github.workspace }}/.kube/config');
+}
+
 /**
  * @param {string[]} storageProviders
  * @param {string[]} deployEnvironments
@@ -243,6 +293,8 @@ export function generateWorkflowYaml(
     }
   }
 
+  applyKubernetesWorkflowEnv(deployEnvironments, environments, envVars);
+
   const envBlock = Array.from(envVars)
     .map((line) => `          ${line}`)
     .join('\n');
@@ -253,6 +305,9 @@ export function generateWorkflowYaml(
   const githubGitConfigStep = isGithubCliSource(cliSource)
     ? `${getGithubGitConfigStep()}\n`
     : '';
+  const kubernetesSteps = hasKubernetesDeploy(deployEnvironments, environments)
+    ? `${getKubernetesSetupSteps()}\n`
+    : '';
 
   const projectType = config?.projectType || 'frontend';
   const installDepsCommand =
@@ -272,7 +327,7 @@ jobs:
 ${uniqueBackendSteps ? `${uniqueBackendSteps}\n` : ''}      - uses: actions/setup-node@v4
         with:
           node-version: '20'
-${githubGitConfigStep}      - name: Install project dependencies
+${kubernetesSteps}${githubGitConfigStep}      - name: Install project dependencies
         run: ${installDepsCommand}
       - name: Install DeployHub CLI
         run: npm install ${installSpec} --no-save

package/src/utils/kubernetes-manifests.js

@@ -0,0 +1,168 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+export function sanitizeK8sName(name) {
+  const sanitized = String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 63);
+  return sanitized || 'app';
+}
+
+/**
+ * @param {string} cwd
+ * @returns {Promise<boolean>}
+ */
+export async function hasKubernetesManifests(cwd) {
+  if (await fs.pathExists(path.join(cwd, 'k8s'))) {
+    return true;
+  }
+
+  let files = [];
+  try {
+    files = await fs.readdir(cwd);
+  } catch {
+    return false;
+  }
+
+  for (const file of files) {
+    if (!/\.ya?ml$/i.test(file)) continue;
+    const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+    if (/^\s*apiVersion:/m.test(content) && /^\s*kind:/m.test(content)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.appName
+ * @param {string} options.imageName
+ * @param {string} [options.imageTag]
+ * @param {number} options.port
+ * @param {string} options.namespace
+ * @param {string} [options.imagePullSecret]
+ * @returns {{ deploymentYaml: string, serviceYaml: string }}
+ */
+export function generateKubernetesManifests({
+  appName,
+  imageName,
+  imageTag = 'latest',
+  port,
+  namespace,
+  imagePullSecret = '',
+}) {
+  const name = sanitizeK8sName(appName);
+  const image = imageName.includes(':') ? imageName : `${imageName}:${imageTag}`;
+  const pullSecretBlock = imagePullSecret
+    ? `      imagePullSecrets:\n      - name: ${imagePullSecret}\n`
+    : '';
+
+  const deploymentYaml = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${name}
+  namespace: ${namespace}
+spec:
+  # Adjust replica count as needed
+  replicas: 1
+  selector:
+    matchLabels:
+      app: ${name}
+  template:
+    metadata:
+      labels:
+        app: ${name}
+    spec:
+${pullSecretBlock}      containers:
+      - name: ${name}
+        image: ${image}
+        ports:
+        - containerPort: ${port}
+        resources:
+          requests:
+            memory: "128Mi"
+            cpu: "100m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+`;
+
+  const servicePort = port === 80 ? 80 : 80;
+  const targetPort = port;
+
+  const serviceYaml = `apiVersion: v1
+kind: Service
+metadata:
+  name: ${name}
+  namespace: ${namespace}
+spec:
+  type: ClusterIP
+  selector:
+    app: ${name}
+  ports:
+  - port: ${servicePort}
+    targetPort: ${targetPort}
+`;
+
+  return { deploymentYaml, serviceYaml };
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @returns {{ appName: string, imageName: string, imageTag: string, port: number, namespace: string, imagePullSecret: string }}
+ */
+export function resolveKubernetesManifestOptions(config, environments = {}) {
+  const envList = Object.values(environments);
+  const k8sEnv = envList.find((env) => env.type === 'kubernetes') || {};
+
+  const appName = config.project || 'app';
+  const imageName =
+    /** @type {string} */ (k8sEnv.dockerImageName) ||
+    process.env.DOCKER_IMAGE_NAME ||
+    appName;
+  const imageTag =
+    process.env.DOCKER_IMAGE_TAG || config.version || 'latest';
+  const namespace =
+    /** @type {string} */ (k8sEnv.kubeNamespace) ||
+    process.env.KUBE_NAMESPACE ||
+    appName ||
+    'default';
+  const imagePullSecret =
+    /** @type {string} */ (k8sEnv.kubeImagePullSecret) ||
+    process.env.KUBE_IMAGE_PULL_SECRET ||
+    '';
+
+  let port = 3000;
+  if (config.projectType === 'both' && config.backend?.port) {
+    port = config.backend.port;
+  } else if (config.port) {
+    port = config.port;
+  } else if (config.backend?.port) {
+    port = config.backend.port;
+  }
+
+  return {
+    appName,
+    imageName,
+    imageTag,
+    port,
+    namespace,
+    imagePullSecret,
+  };
+}
+
+export default {
+  sanitizeK8sName,
+  hasKubernetesManifests,
+  generateKubernetesManifests,
+  resolveKubernetesManifestOptions,
+};

package/src/utils/scaffold.js

@@ -0,0 +1,192 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import {
+  generateDockerfile,
+  getDockerfileFrameworkLabel,
+  resolveDockerSettings,
+} from './dockerfile.js';
+import {
+  generateKubernetesManifests,
+  hasKubernetesManifests,
+  resolveKubernetesManifestOptions,
+} from './kubernetes-manifests.js';
+
+/**
+ * @param {Record<string, Record<string, unknown>>} environments
+ * @returns {Set<string>}
+ */
+export function getDeployTypes(environments) {
+  return new Set(
+    Object.values(environments)
+      .map((env) => /** @type {string} */ (env.type))
+      .filter(Boolean)
+  );
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ */
+export function needsDockerfile(config, environments = config.environments || {}) {
+  const deployTypes = getDeployTypes(environments);
+  return deployTypes.has('docker') || deployTypes.has('kubernetes');
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ */
+export function needsKubernetesManifests(
+  config,
+  environments = config.environments || {}
+) {
+  return getDeployTypes(environments).has('kubernetes');
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ generated: boolean, framework?: string }>}
+ */
+export async function ensureDockerfile(cwd, config, options = {}) {
+  const dockerfilePath = path.join(cwd, 'Dockerfile');
+  if (await fs.pathExists(dockerfilePath)) {
+    return { generated: false };
+  }
+
+  if (!needsDockerfile(config)) {
+    return { generated: false };
+  }
+
+  const settings = resolveDockerSettings(config);
+  const content = generateDockerfile(config);
+  await fs.writeFile(dockerfilePath, content);
+
+  if (!options.silent) {
+    const label = getDockerfileFrameworkLabel(settings.framework);
+    console.log(
+      chalk.yellow(
+        `No Dockerfile found — generated a starter Dockerfile at ./Dockerfile based on your detected ${label}. Review it before deploying, especially the exposed port and start command.`
+      )
+    );
+  }
+
+  return { generated: true, framework: settings.framework };
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ generated: boolean }>}
+ */
+export async function ensureKubernetesManifests(
+  cwd,
+  config,
+  environments = config.environments || {},
+  options = {}
+) {
+  if (!needsKubernetesManifests(config, environments)) {
+    return { generated: false };
+  }
+
+  if (await hasKubernetesManifests(cwd)) {
+    return { generated: false };
+  }
+
+  const manifestOptions = resolveKubernetesManifestOptions(config, environments);
+  const { deploymentYaml, serviceYaml } = generateKubernetesManifests(manifestOptions);
+
+  const k8sDir = path.join(cwd, 'k8s');
+  await fs.ensureDir(k8sDir);
+  await fs.writeFile(path.join(k8sDir, 'deployment.yaml'), deploymentYaml);
+  await fs.writeFile(path.join(k8sDir, 'service.yaml'), serviceYaml);
+
+  if (!options.silent) {
+    console.log(
+      chalk.yellow(
+        'No Kubernetes manifests found — generated starter manifests at ./k8s/deployment.yaml and ./k8s/service.yaml. Review resource limits, replica count, and any environment-specific settings before deploying.'
+      )
+    );
+  }
+
+  return { generated: true };
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ dockerfile: boolean, kubernetes: boolean }>}
+ */
+export async function ensureDeployScaffold(
+  cwd,
+  config,
+  environments = config.environments || {},
+  options = {}
+) {
+  const dockerResult = await ensureDockerfile(cwd, config, options);
+  const k8sResult = await ensureKubernetesManifests(cwd, config, environments, options);
+  return {
+    dockerfile: dockerResult.generated,
+    kubernetes: k8sResult.generated,
+  };
+}
+
+/**
+ * @param {string} srcDir
+ * @param {string} destDir
+ */
+export async function copyKubernetesManifestsIfPresent(srcDir, destDir) {
+  const k8sSrc = path.join(srcDir, 'k8s');
+  if (await fs.pathExists(k8sSrc)) {
+    await fs.copy(k8sSrc, path.join(destDir, 'k8s'));
+    return;
+  }
+
+  let files = [];
+  try {
+    files = await fs.readdir(srcDir);
+  } catch {
+    return;
+  }
+
+  for (const file of files) {
+    if (!/\.ya?ml$/i.test(file)) continue;
+    const srcFile = path.join(srcDir, file);
+    const content = await fs.readFile(srcFile, 'utf-8');
+    if (/^\s*apiVersion:/m.test(content) && /^\s*kind:/m.test(content)) {
+      await fs.copy(srcFile, path.join(destDir, file));
+    }
+  }
+}
+
+/**
+ * Copy deploy-time assets from staging into artifactDir (alongside artifact.zip).
+ * @param {string} stagingDir
+ * @param {string} artifactDir
+ */
+export async function copyDeployAssetsToArtifactDir(stagingDir, artifactDir) {
+  for (const file of ['Dockerfile', 'docker-compose.yml']) {
+    const src = path.join(stagingDir, file);
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(artifactDir, file));
+    }
+  }
+
+  await copyKubernetesManifestsIfPresent(stagingDir, artifactDir);
+}
+
+export default {
+  ensureDockerfile,
+  ensureKubernetesManifests,
+  ensureDeployScaffold,
+  needsDockerfile,
+  needsKubernetesManifests,
+  copyKubernetesManifestsIfPresent,
+  copyDeployAssetsToArtifactDir,
+};