@akash-chowdhury-24/deployhub 2.0.14 → 2.0.16

package/src/storage/index.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import fs from 'fs-extra';
 import os from 'os';
+import { randomUUID } from 'crypto';
 import { createLogger } from '../logger/index.js';
 import { createAwsProvider } from './providers/aws.js';
 import { createLocalProvider } from './providers/local.js';
@@ -11,6 +12,8 @@ import { createDropboxProvider } from './providers/dropbox.js';
 import { createFtpProvider } from './providers/ftp.js';
 import {
   buildArtifactRemoteKey,
+  envHistoryRemoteKey,
+  envLatestArtifactRemoteKey,
   historyRemoteKey,
   latestArtifactRemoteKey,
   legacyArtifactRemoteKey,
@@ -22,6 +25,16 @@ import {
 } from '../utils/artifact-history.js';
 import { summarizeStorageError } from './storage-errors.js';
 
+/**
+ * Unique temp path — never Date.now() alone (collides across concurrent
+ * processes / Jest workers in the same millisecond and corrupts history reads).
+ * @param {string} prefix
+ * @param {string} [ext]
+ */
+function uniqueTmpPath(prefix, ext = '.json') {
+  return path.join(os.tmpdir(), `${prefix}-${randomUUID()}${ext}`);
+}
+
 /** @type {Record<string, (env?: Record<string, string>) => ReturnType<typeof createAwsProvider>>} */
 const PROVIDER_FACTORIES = {
   aws: createAwsProvider,
@@ -77,7 +90,7 @@ export async function loadArtifactHistory(providers, project) {
   }
 
   const key = historyRemoteKey(project);
-  const tmp = path.join(os.tmpdir(), `deployhub-history-${Date.now()}.json`);
+  const tmp = uniqueTmpPath('deployhub-history');
 
   try {
     for (const name of providers) {
@@ -114,7 +127,24 @@ export async function loadArtifactHistory(providers, project) {
  */
 async function writeArtifactHistory(provider, project, history) {
   const key = historyRemoteKey(project);
-  const tmp = path.join(os.tmpdir(), `deployhub-history-write-${Date.now()}.json`);
+  const tmp = uniqueTmpPath('deployhub-history-write');
+  await fs.writeJson(tmp, history, { spaces: 2 });
+  try {
+    await provider.upload(tmp, key);
+  } finally {
+    await fs.remove(tmp).catch(() => {});
+  }
+}
+
+/**
+ * @param {ReturnType<typeof getStorageProvider>} provider
+ * @param {string} project
+ * @param {string} envName
+ * @param {import('../utils/artifact-history.js').ArtifactHistoryEntry[]} history
+ */
+async function writeEnvArtifactHistory(provider, project, envName, history) {
+  const key = envHistoryRemoteKey(project, envName);
+  const tmp = uniqueTmpPath('deployhub-env-hist-write');
   await fs.writeJson(tmp, history, { spaces: 2 });
   try {
     await provider.upload(tmp, key);
@@ -123,6 +153,200 @@ async function writeArtifactHistory(provider, project, history) {
   }
 }
 
+function legacyHistoryCopiedMarkerKey(project) {
+  return `${project}/.legacy-env-history-copied`;
+}
+
+/**
+ * Record that legacy history migration was handled (copy attempted or not needed).
+ * Prevents later rollback from copying the build catalog into the default env.
+ *
+ * @param {string[]} providers
+ * @param {string} project
+ */
+async function markLegacyHistoryMigrationHandled(providers, project) {
+  if (!providers?.length || !project) return;
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    if (await provider.verify(legacyHistoryCopiedMarkerKey(project))) {
+      return;
+    }
+    const markerTmp = uniqueTmpPath('deployhub-legacy-copied', '.txt');
+    await fs.writeFile(markerTmp, '1');
+    try {
+      await provider.upload(markerTmp, legacyHistoryCopiedMarkerKey(project));
+    } finally {
+      await fs.remove(markerTmp).catch(() => {});
+    }
+  }
+}
+
+/**
+ * One-time copy of legacy `{project}/history.json` into the default environment's
+ * `envs/{default}/history.json`. Separate from `recordEnvDeployment` (which never
+ * seeds from the project build catalog).
+ *
+ * Guard scope (judgment call — see comment in source):
+ * Only skips when the default env's own history key already exists, or when migration
+ * was already handled (storage marker / config.legacyHistoryMigrated). We do NOT skip
+ * just because a sibling env (e.g. testing) has history — that would lock default out
+ * of recovering real pre-multi-env deploy history after shape migration.
+ *
+ * @param {string[]} providers
+ * @param {string} project
+ * @param {string} defaultEnvironment
+ * @param {{ legacyHistoryMigrated?: boolean }} [options]
+ * @returns {Promise<boolean>} true when a copy was written
+ */
+export async function ensureLegacyHistoryCopiedToDefaultEnv(
+  providers,
+  project,
+  defaultEnvironment,
+  options = {}
+) {
+  if (!providers?.length || !project || !defaultEnvironment) return false;
+  if (options.legacyHistoryMigrated === true) return false;
+
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    if (await provider.verify(legacyHistoryCopiedMarkerKey(project))) {
+      return false;
+    }
+  }
+
+  const envKey = envHistoryRemoteKey(project, defaultEnvironment);
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    if (await provider.verify(envKey)) {
+      return false;
+    }
+  }
+
+  const legacy = await loadArtifactHistory(providers, project);
+  if (legacy.entries.length === 0) {
+    await markLegacyHistoryMigrationHandled(providers, project);
+    return false;
+  }
+
+  const log = createLogger('storage');
+  log.info(
+    `Migrating legacy deploy history into env "${defaultEnvironment}" (${legacy.entries.length} entries)...`
+  );
+
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    await writeEnvArtifactHistory(provider, project, defaultEnvironment, legacy.entries);
+  }
+  await markLegacyHistoryMigrationHandled(providers, project);
+  return true;
+}
+
+/**
+ * Load per-environment deploy history.
+ * Legacy project-wide `{project}/history.json` is NOT merged here during rollback
+ * (use `ensureLegacyHistoryCopiedToDefaultEnv` first). Read-only legacy fallback for
+ * list/doctor when `allowLegacyFallback` is true.
+ *
+ * @param {string[]} providers
+ * @param {string} project
+ * @param {string} envName
+ * @param {{ defaultEnvironment?: string|null, allowLegacyFallback?: boolean }} [options]
+ */
+export async function loadEnvArtifactHistory(providers, project, envName, options = {}) {
+  if (!providers || providers.length === 0) {
+    return { entries: [], source: null, key: envHistoryRemoteKey(project, envName) };
+  }
+
+  const envKey = envHistoryRemoteKey(project, envName);
+  const tmp = uniqueTmpPath('deployhub-env-history');
+
+  try {
+    for (const name of providers) {
+      try {
+        const provider = getStorageProvider(name);
+        const exists = await provider.verify(envKey);
+        if (!exists) continue;
+
+        await provider.download(envKey, tmp);
+        const raw = await fs.readFile(tmp, 'utf8');
+        return {
+          entries: parseArtifactHistory(raw),
+          source: name,
+          key: envKey,
+        };
+      } catch (err) {
+        const reason = summarizeStorageError(err);
+        throw new Error(
+          `Could not check remote history via ${name}: ${reason} — ` +
+            'verify your storage credentials and configuration are correct.'
+        );
+      }
+    }
+  } finally {
+    await fs.remove(tmp).catch(() => {});
+  }
+
+  const defaultName =
+    typeof options.defaultEnvironment === 'string' ? options.defaultEnvironment : null;
+  const allowLegacy =
+    options.allowLegacyFallback !== false &&
+    (envName === 'default' || (defaultName !== null && envName === defaultName));
+
+  if (allowLegacy) {
+    const legacy = await loadArtifactHistory(providers, project);
+    if (legacy.entries.length > 0) {
+      return {
+        entries: legacy.entries,
+        source: legacy.source,
+        key: historyRemoteKey(project),
+        legacyFallback: true,
+      };
+    }
+  }
+
+  return { entries: [], source: null, key: envKey };
+}
+
+/**
+ * Record a successful deploy into per-env history + env latest pointer.
+ * Does not touch other environments' history.
+ *
+ * @param {string[]} providers
+ * @param {string} zipPath path to artifact.zip to copy into envs/{env}/latest/
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {{ buildId: string, semver?: string, remoteKey?: string }} meta
+ */
+export async function recordEnvDeployment(providers, zipPath, config, envName, meta) {
+  const log = createLogger('storage');
+  const buildId = meta.buildId;
+  const remoteKey =
+    meta.remoteKey || buildArtifactRemoteKey(config.project, buildId);
+  const entry = {
+    buildId,
+    semver: String(meta.semver || config.version || '0.0.0').replace(/^v/i, ''),
+    uploadedAt: new Date().toISOString(),
+    remoteKey,
+  };
+  const envLatestKey = envLatestArtifactRemoteKey(config.project, envName);
+
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    log.info(`Recording deploy of ${buildId} to env "${envName}" on ${name}...`);
+
+    if (zipPath && (await fs.pathExists(zipPath))) {
+      await provider.upload(zipPath, envLatestKey);
+    }
+
+    const loaded = await loadEnvArtifactHistory([name], config.project, envName, {
+      // Never seed deploy history from the project-wide build catalog on record.
+      allowLegacyFallback: false,
+    });
+    const next = prependHistoryEntry(loaded.entries, entry);
+    await writeEnvArtifactHistory(provider, config.project, envName, next);
+  }
+}
+
 /**
  * Upload artifact zip under a unique build key, update latest/ pointer and history.json.
  * Does NOT write legacy `{project}/v{semver}/artifact.zip` (retired for new uploads;
@@ -158,7 +382,7 @@ export async function uploadToAll(providers, zipPath, config) {
       try {
         const histKey = historyRemoteKey(config.project);
         if (await provider.verify(histKey)) {
-          const tmp = path.join(os.tmpdir(), `deployhub-hist-${name}-${Date.now()}.json`);
+          const tmp = uniqueTmpPath(`deployhub-hist-${name}`);
           try {
             await provider.download(histKey, tmp);
             history = parseArtifactHistory(await fs.readFile(tmp, 'utf8'));
@@ -260,6 +484,9 @@ export default {
   downloadFromFirst,
   downloadArtifactEntry,
   loadArtifactHistory,
+  loadEnvArtifactHistory,
+  ensureLegacyHistoryCopiedToDefaultEnv,
+  recordEnvDeployment,
   testProvider,
   testAllProviders,
 };

package/src/utils/build-id.js

@@ -122,12 +122,33 @@ export function latestArtifactRemoteKey(project) {
 }
 
 /**
+ * Project-wide build catalog (newest-first). Legacy pre-multi-env history;
+ * also still written on upload as the available-builds index for `artifact list --remote`.
+ * Per-environment deploy history lives under envs/{env}/history.json.
  * @param {string} project
  */
 export function historyRemoteKey(project) {
   return `${project}/history.json`;
 }
 
+/**
+ * Per-environment deploy history (newest-first). Rollback resolves against this only.
+ * @param {string} project
+ * @param {string} envName
+ */
+export function envHistoryRemoteKey(project, envName) {
+  return `${project}/envs/${sanitizeBuildIdPart(envName)}/history.json`;
+}
+
+/**
+ * Per-environment "currently deployed" pointer (NOT a backup — same semantics as project latest/).
+ * @param {string} project
+ * @param {string} envName
+ */
+export function envLatestArtifactRemoteKey(project, envName) {
+  return `${project}/envs/${sanitizeBuildIdPart(envName)}/latest/artifact.zip`;
+}
+
 /**
  * Pre-buildId legacy key (read-only fallback; never written by new uploads).
  * @param {string} project
@@ -145,5 +166,7 @@ export default {
   buildArtifactRemoteKey,
   latestArtifactRemoteKey,
   historyRemoteKey,
+  envHistoryRemoteKey,
+  envLatestArtifactRemoteKey,
   legacyArtifactRemoteKey,
 };

package/src/utils/dockerfile-expose.js

@@ -0,0 +1,117 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/** Static SPA frameworks that use nginx:alpine + EXPOSE 80 in generated Dockerfiles. */
+const STATIC_FRONTEND_FRAMEWORKS = new Set([
+  'react',
+  'vue',
+  'angular',
+  'svelte',
+  'astro',
+  'vanilla',
+]);
+
+/**
+ * Parse the listening port from Dockerfile EXPOSE instructions.
+ * Uses the last EXPOSE line (final stage in multi-stage builds).
+ * Supports `EXPOSE 80`, `EXPOSE 80/tcp`, and multi-port lines (first numeric wins on that line).
+ *
+ * @param {string} content
+ * @returns {number|null}
+ */
+export function parseDockerfileExposePort(content) {
+  if (!content || typeof content !== 'string') return null;
+
+  /** @type {number|null} */
+  let lastPort = null;
+
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    const match = line.match(/^EXPOSE\s+(.+)$/i);
+    if (!match) continue;
+
+    const tokens = match[1].trim().split(/\s+/);
+    for (const token of tokens) {
+      const portToken = token.split('/')[0];
+      if (!/^\d+$/.test(portToken)) continue;
+      const port = Number(portToken);
+      if (port >= 1 && port <= 65535) {
+        lastPort = port;
+        break;
+      }
+    }
+  }
+
+  return lastPort;
+}
+
+/**
+ * Per-type fallback matching generated Dockerfile templates when EXPOSE is unavailable.
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @returns {number}
+ */
+export function resolveFallbackContainerPort(config) {
+  const projectType = config.projectType || 'frontend';
+  const framework =
+    (projectType === 'both'
+      ? config.backend?.framework || config.framework
+      : config.framework) ||
+    (projectType === 'frontend' ? 'react' : 'express');
+
+  if (projectType === 'frontend' && STATIC_FRONTEND_FRAMEWORKS.has(framework)) {
+    return 80;
+  }
+
+  if (['laravel', 'symfony', 'php'].includes(framework)) return 80;
+  if (['fastapi', 'django', 'flask', 'python'].includes(framework)) return 8000;
+  if (['spring', 'java'].includes(framework)) return 8080;
+  if (framework === 'go') return 8080;
+  if (framework === 'dotnet') return 5000;
+  if (framework === 'rails') return 3000;
+
+  // nextjs, nestjs, express, and other Node backends
+  return 3000;
+}
+
+/**
+ * Precedence: Dockerfile EXPOSE → config.port / backend.port → per-type fallback.
+ *
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @returns {Promise<{ port: number, source: 'expose'|'config'|'fallback' }>}
+ */
+export async function resolveContainerPort(cwd, config) {
+  const dockerfilePath = path.join(cwd, 'Dockerfile');
+  if (await fs.pathExists(dockerfilePath)) {
+    try {
+      const content = await fs.readFile(dockerfilePath, 'utf8');
+      const exposed = parseDockerfileExposePort(content);
+      if (exposed != null) {
+        return { port: exposed, source: 'expose' };
+      }
+    } catch {
+      // treat as unparseable / unreadable → continue
+    }
+  }
+
+  if (config.projectType === 'both' && config.backend?.port) {
+    return { port: Number(config.backend.port), source: 'config' };
+  }
+  if (config.port) {
+    return { port: Number(config.port), source: 'config' };
+  }
+  if (config.backend?.port) {
+    return { port: Number(config.backend.port), source: 'config' };
+  }
+
+  return { port: resolveFallbackContainerPort(config), source: 'fallback' };
+}
+
+export default {
+  parseDockerfileExposePort,
+  resolveFallbackContainerPort,
+  resolveContainerPort,
+};