@akash-chowdhury-24/deployhub 2.0.11 → 2.0.14

package/src/storage/storage-errors.js

@@ -0,0 +1,106 @@
+/**
+ * Shared helpers for storage provider errors (history load, verify, etc.).
+ */
+
+/**
+ * Concise, actionable one-line reason — no SDK stack dumps.
+ * @param {unknown} err
+ * @returns {string}
+ */
+export function summarizeStorageError(err) {
+  if (!err) return 'unknown error';
+
+  if (typeof err === 'string') {
+    return truncateReason(err);
+  }
+
+  const e = /** @type {Record<string, unknown>} */ (err);
+  const name = typeof e.name === 'string' ? e.name : '';
+  const code =
+    typeof e.Code === 'string'
+      ? e.Code
+      : typeof e.code === 'string'
+        ? e.code
+        : '';
+  const message =
+    err instanceof Error
+      ? err.message
+      : typeof e.message === 'string'
+        ? e.message
+        : String(err);
+
+  const firstLine = message.split(/\r?\n/)[0].trim();
+
+  // Prefer a short "AccessDenied: ..." style when the SDK exposes a name/code.
+  const label = [name, code].find(
+    (v) => v && v !== 'Error' && !firstLine.includes(v)
+  );
+  const combined = label ? `${label}: ${firstLine}` : firstLine;
+  return truncateReason(combined || 'unknown error');
+}
+
+/**
+ * @param {string} text
+ */
+function truncateReason(text) {
+  const cleaned = text.replace(/\s+/g, ' ').trim();
+  if (cleaned.length <= 200) return cleaned;
+  return `${cleaned.slice(0, 197)}...`;
+}
+
+/**
+ * True when an error almost certainly means the object/key is missing
+ * (as opposed to auth, network, or permission failures).
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+export function isNotFoundStorageError(err) {
+  if (!err || typeof err !== 'object') return false;
+  const e = /** @type {Record<string, unknown>} */ (err);
+  const status =
+    (e.$metadata &&
+      typeof e.$metadata === 'object' &&
+      /** @type {{ httpStatusCode?: number }} */ (e.$metadata).httpStatusCode) ||
+    (typeof e.statusCode === 'number' ? e.statusCode : undefined) ||
+    (typeof e.status === 'number' ? e.status : undefined);
+
+  const name = String(e.name || e.Code || e.code || '');
+  const msg = String(e.message || '').toLowerCase();
+  const blob = `${name} ${msg}`;
+
+  // Auth / permission / credential failures are never "not found"
+  if (
+    /\b(accessdenied|access denied|invalidaccesskey|forbidden|unauthorized|credentials|signaturedoesnotmatch|expiredtoken)\b/i.test(
+      blob
+    )
+  ) {
+    return false;
+  }
+
+  if (status === 403 || status === 401) return false;
+
+  if (status === 404) return true;
+
+  if (/^(NoSuchKey|NotFound|NotFoundError|ENOENT)$/i.test(name)) return true;
+
+  if (
+    /\b(nosuchkey|not\s*found|no such file|path\/not_found)\b/i.test(msg) ||
+    /\bthe specified key does not exist\b/i.test(msg)
+  ) {
+    return true;
+  }
+
+  // Dropbox often uses 409 with path/not_found
+  if (status === 409 && /not_found/i.test(msg + name + JSON.stringify(e.error || ''))) {
+    return true;
+  }
+
+  // FTP / classic responses
+  if (/\b550\b/.test(msg) && /not found|no such|failed to open/i.test(msg)) {
+    return true;
+  }
+
+  return false;
+}
+
+export default { summarizeStorageError, isNotFoundStorageError };

package/src/utils/artifact-history.js

@@ -0,0 +1,155 @@
+/**
+ * Artifact upload history (newest-first) and rollback target resolution.
+ */
+
+/**
+ * @typedef {{
+ *   buildId: string,
+ *   semver: string,
+ *   uploadedAt: string,
+ *   remoteKey: string,
+ * }} ArtifactHistoryEntry
+ */
+
+/**
+ * @param {string|unknown} raw
+ * @returns {ArtifactHistoryEntry[]}
+ */
+export function parseArtifactHistory(raw) {
+  if (!raw) return [];
+  try {
+    const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (!Array.isArray(data)) return [];
+    return data
+      .filter(
+        (e) =>
+          e &&
+          typeof e === 'object' &&
+          typeof e.buildId === 'string' &&
+          typeof e.remoteKey === 'string'
+      )
+      .map((e) => ({
+        buildId: String(e.buildId),
+        semver: String(e.semver || '').replace(/^v/i, '') || '0.0.0',
+        uploadedAt: String(e.uploadedAt || ''),
+        remoteKey: String(e.remoteKey),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * @param {ArtifactHistoryEntry[]} history
+ * @param {ArtifactHistoryEntry} entry
+ * @returns {ArtifactHistoryEntry[]}
+ */
+export function prependHistoryEntry(history, entry) {
+  const filtered = history.filter((e) => e.buildId !== entry.buildId);
+  return [entry, ...filtered];
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function normalizeVersionArg(input) {
+  return String(input || '')
+    .trim()
+    .replace(/^v/i, '');
+}
+
+/**
+ * Resolve which history entry to roll back to.
+ *
+ * @param {ArtifactHistoryEntry[]} history newest-first
+ * @param {string} [versionOrBuildId] omitted = previous build (history[1])
+ * @returns {{
+ *   ok: true,
+ *   entry: ArtifactHistoryEntry,
+ * } | {
+ *   ok: false,
+ *   reason: 'empty'|'no-previous'|'not-found'|'ambiguous',
+ *   message: string,
+ *   matches?: ArtifactHistoryEntry[],
+ * }}
+ */
+export function resolveRollbackTarget(history, versionOrBuildId) {
+  if (!history.length) {
+    return {
+      ok: false,
+      reason: 'empty',
+      message: 'No artifact history found in storage. Deploy at least once first.',
+    };
+  }
+
+  if (!versionOrBuildId) {
+    if (history.length < 2) {
+      return {
+        ok: false,
+        reason: 'no-previous',
+        message: 'No previous build available for rollback (only one build in history).',
+      };
+    }
+    return { ok: true, entry: history[1] };
+  }
+
+  const needle = normalizeVersionArg(versionOrBuildId);
+
+  const exact = history.find((e) => e.buildId === needle || e.buildId === versionOrBuildId);
+  if (exact) {
+    return { ok: true, entry: exact };
+  }
+
+  const current = history[0];
+  const semverMatches = history.filter(
+    (e) => e.semver === needle || `v${e.semver}` === String(versionOrBuildId).trim()
+  );
+
+  if (semverMatches.length === 0) {
+    return {
+      ok: false,
+      reason: 'not-found',
+      message: `No artifact found for '${versionOrBuildId}'. Use an exact buildId from: deployhub artifact list --remote`,
+    };
+  }
+
+  const nonCurrent = semverMatches.filter((e) => e.buildId !== current.buildId);
+
+  if (nonCurrent.length === 1) {
+    return { ok: true, entry: nonCurrent[0] };
+  }
+
+  if (nonCurrent.length === 0) {
+    return {
+      ok: false,
+      reason: 'not-found',
+      message: `Only the current build matches semver '${needle}' (${current.buildId}). Nothing to roll back to for that label.`,
+    };
+  }
+
+  return {
+    ok: false,
+    reason: 'ambiguous',
+    message: `Multiple builds match semver '${needle}'. Re-run with an exact buildId:`,
+    matches: nonCurrent,
+  };
+}
+
+/**
+ * @param {ArtifactHistoryEntry[]} matches
+ * @returns {string}
+ */
+export function formatAmbiguousRollbackMatches(matches) {
+  return matches
+    .map((e) => `  ${e.buildId}  uploadedAt=${e.uploadedAt || '(unknown)'}  key=${e.remoteKey}`)
+    .join('\n');
+}
+
+export default {
+  parseArtifactHistory,
+  prependHistoryEntry,
+  normalizeVersionArg,
+  resolveRollbackTarget,
+  formatAmbiguousRollbackMatches,
+};

package/src/utils/build-id.js

@@ -0,0 +1,149 @@
+/**
+ * Unique per-build identity shared by artifact storage keys and (when unset)
+ * Docker image tags.
+ */
+
+import { execFileSync } from 'child_process';
+
+/** @typedef {'git'|'ci'|'timestamp'} BuildStampSource */
+
+/**
+ * High-resolution timestamp stamp (seconds+ms) for uniqueness in fast rebuild loops.
+ * @param {Date} [now]
+ * @returns {string}
+ */
+export function highResBuildStamp(now = new Date()) {
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, '0');
+  const d = String(now.getDate()).padStart(2, '0');
+  const h = String(now.getHours()).padStart(2, '0');
+  const min = String(now.getMinutes()).padStart(2, '0');
+  const sec = String(now.getSeconds()).padStart(2, '0');
+  const ms = String(now.getMilliseconds()).padStart(3, '0');
+  return `${y}.${m}.${d}.${h}${min}-${sec}${ms}`;
+}
+
+/**
+ * @returns {string|null}
+ */
+function defaultGetGitShortSha() {
+  try {
+    const sha = execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return sha || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Unique build stamp: git SHA → CI id → high-res timestamp.
+ * Does not read DOCKER_IMAGE_TAG (explicit image tags stay separate from artifact identity).
+ *
+ * @param {Record<string, string|undefined>} [env]
+ * @param {{
+ *   getGitShortSha?: () => string|null,
+ *   now?: () => Date,
+ * }} [options]
+ * @returns {{ stamp: string, source: BuildStampSource }}
+ */
+export function resolveUniqueBuildStamp(env = process.env, options = {}) {
+  const getGitShortSha = options.getGitShortSha || defaultGetGitShortSha;
+  const gitSha = getGitShortSha();
+  if (gitSha) {
+    return { stamp: gitSha, source: 'git' };
+  }
+
+  const ciTag =
+    (env.GITHUB_SHA && String(env.GITHUB_SHA).slice(0, 7)) ||
+    env.GITHUB_RUN_ID ||
+    env.CI_COMMIT_SHORT_SHA ||
+    env.CI_PIPELINE_ID;
+  if (ciTag) {
+    return { stamp: String(ciTag), source: 'ci' };
+  }
+
+  const now = options.now ? options.now() : new Date();
+  return { stamp: highResBuildStamp(now), source: 'timestamp' };
+}
+
+/**
+ * Sanitize for use in paths and image tags.
+ * @param {string} value
+ * @returns {string}
+ */
+export function sanitizeBuildIdPart(value) {
+  return String(value)
+    .replace(/^v/i, '')
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64) || 'build';
+}
+
+/**
+ * @param {{
+ *   semver?: string,
+ *   env?: Record<string, string|undefined>,
+ *   getGitShortSha?: () => string|null,
+ *   now?: () => Date,
+ * }} [options]
+ * @returns {{ buildId: string, semver: string, stamp: string, source: BuildStampSource }}
+ */
+export function resolveBuildId(options = {}) {
+  const env = options.env || process.env;
+  const semver = sanitizeBuildIdPart(options.semver || '0.0.0');
+  const { stamp, source } = resolveUniqueBuildStamp(env, options);
+  const safeStamp = sanitizeBuildIdPart(stamp);
+  return {
+    buildId: `${semver}-${safeStamp}`,
+    semver,
+    stamp: safeStamp,
+    source,
+  };
+}
+
+/**
+ * Remote key for an immutable build artifact.
+ * @param {string} project
+ * @param {string} buildId
+ */
+export function buildArtifactRemoteKey(project, buildId) {
+  return `${project}/builds/${buildId}/artifact.zip`;
+}
+
+/**
+ * Mutable pointer overwritten every upload (not a backup slot).
+ * @param {string} project
+ */
+export function latestArtifactRemoteKey(project) {
+  return `${project}/latest/artifact.zip`;
+}
+
+/**
+ * @param {string} project
+ */
+export function historyRemoteKey(project) {
+  return `${project}/history.json`;
+}
+
+/**
+ * Pre-buildId legacy key (read-only fallback; never written by new uploads).
+ * @param {string} project
+ * @param {string} semver
+ */
+export function legacyArtifactRemoteKey(project, semver) {
+  return `${project}/v${sanitizeBuildIdPart(semver)}/artifact.zip`;
+}
+
+export default {
+  highResBuildStamp,
+  resolveUniqueBuildStamp,
+  resolveBuildId,
+  sanitizeBuildIdPart,
+  buildArtifactRemoteKey,
+  latestArtifactRemoteKey,
+  historyRemoteKey,
+  legacyArtifactRemoteKey,
+};

package/src/utils/docker-image-deploy.js

@@ -10,6 +10,7 @@ import {
   generateSpringRuntimeDockerfile,
   isFrontendStaticFramework,
   isInterpretedBackendFramework,
+  replaceDockerImageTag,
   resolveDockerImageRef,
   EXPLICIT_IMAGE_TAG_WARNING,
 } from './docker-image.js';
@@ -67,8 +68,9 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
   /**
    * Push only when registry credentials are configured. Avoids a noisy failed
    * push to Docker Hub for local-only image names.
+   * @param {string} [imageRef]
    */
-  async function maybePushImage() {
+  async function maybePushImage(imageRef = fullImage) {
     if (!hasRegistryCredentials()) {
       log.info(
         'docker push skipped (DOCKER_REGISTRY_USERNAME/TOKEN not set — local image only)'
@@ -76,12 +78,12 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
       return;
     }
 
-    log.info(`Pushing ${fullImage} to registry...`);
-    await execa('docker', ['push', fullImage], {
+    log.info(`Pushing ${imageRef} to registry...`);
+    await execa('docker', ['push', imageRef], {
       stdio: 'inherit',
       env: getDockerEnv(),
     });
-    log.success(`Pushed ${fullImage}`);
+    log.success(`Pushed ${imageRef}`);
   }
 
   /**
@@ -102,21 +104,22 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
   /**
    * Prefer the image already built during the pipeline `docker` stage.
    * Retag when the pipeline used `:latest` and deploy needs a version tag.
+   * @param {string} [imageRef]
    */
-  async function ensureImageFromPipeline() {
-    if (await imageExistsLocally(fullImage)) {
-      log.info(`Reusing existing image ${fullImage}`);
+  async function ensureImageFromPipeline(imageRef = fullImage) {
+    if (await imageExistsLocally(imageRef)) {
+      log.info(`Reusing existing image ${imageRef}`);
       return true;
     }
 
     const candidates = [...new Set([latestImage, legacyLatestImage])].filter(
-      (ref) => ref !== fullImage
+      (ref) => ref !== imageRef
     );
 
     for (const candidate of candidates) {
       if (!(await imageExistsLocally(candidate))) continue;
-      log.info(`Re-tagging pipeline image ${candidate} → ${fullImage}`);
-      await execa('docker', ['tag', candidate, fullImage], {
+      log.info(`Re-tagging pipeline image ${candidate} → ${imageRef}`);
+      await execa('docker', ['tag', candidate, imageRef], {
         stdio: 'inherit',
         env: getDockerEnv(),
       });
@@ -211,12 +214,13 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
 
   /**
    * @param {string} artifactDir
+   * @param {string} [imageRef]
    */
-  async function buildFromArtifactContents(artifactDir) {
+  async function buildFromArtifactContents(artifactDir, imageRef = fullImage) {
     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. ` +
+        `No local image found for ${imageRef} and no artifact.zip to build from. ` +
           'Enable pipeline.docker so the image is built from project source, or run deployhub build first.'
       );
     }
@@ -281,7 +285,7 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
         await prepareBackendBuildContext(buildContext, metadata, framework, port);
       }
 
-      await execa('docker', ['build', '-t', fullImage, '.'], {
+      await execa('docker', ['build', '-t', imageRef, '.'], {
         cwd: buildContext,
         stdio: 'inherit',
         env: getDockerEnv(),
@@ -295,36 +299,55 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
   /**
    * Ensure a deployable image exists locally, then push when credentials are set.
    * @param {string} artifactDir
-   * @param {{ skipPush?: boolean }} [options]
+   * @param {{
+   *   skipPush?: boolean,
+   *   fullImage?: string,
+   *   skipImageReuse?: boolean,
+   * }} [options]
    */
   async function ensureImageReadyForDeploy(artifactDir, options = {}) {
+    const imageRef = options.fullImage || fullImage;
+    const latestRef = options.fullImage
+      ? replaceDockerImageTag(options.fullImage, 'latest')
+      : latestImage;
+    const lastSlash = imageRef.lastIndexOf('/');
+    const lastColon = imageRef.lastIndexOf(':');
+    const effectiveTag =
+      lastColon > lastSlash ? imageRef.slice(lastColon + 1) : 'latest';
+
     await dockerLogin();
 
-    const reused = await ensureImageFromPipeline();
+    let reused = false;
+    if (!options.skipImageReuse) {
+      reused = await ensureImageFromPipeline(imageRef);
+    } else {
+      log.info(`Skipping local image reuse — rebuilding ${imageRef} from artifact`);
+    }
+
     let ranCompose = false;
 
     if (!reused) {
-      const result = await buildFromArtifactContents(artifactDir);
+      const result = await buildFromArtifactContents(artifactDir, imageRef);
       ranCompose = Boolean(result?.ranCompose);
     }
 
     if (ranCompose) {
-      return { ranCompose: true };
+      return { ranCompose: true, fullImage: imageRef };
     }
 
     if (!options.skipPush) {
-      await maybePushImage();
+      await maybePushImage(imageRef);
     }
 
     const dockerEnv = getDockerEnv();
-    if (imageTag !== 'latest' && fullImage !== latestImage) {
-      await execa('docker', ['tag', fullImage, latestImage], {
+    if (effectiveTag !== 'latest' && imageRef !== latestRef) {
+      await execa('docker', ['tag', imageRef, latestRef], {
         stdio: 'pipe',
         env: dockerEnv,
       }).catch(() => {});
     }
 
-    return { ranCompose: false };
+    return { ranCompose: false, fullImage: imageRef };
   }
 
   return {