@akash-chowdhury-24/deployhub 2.0.11 → 2.0.14

package/src/deployment/providers/docker.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { createLogger } from '../../logger/index.js';
 import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.js';
+import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -14,12 +15,17 @@ export function createDockerProvider(config, envName, env = process.env) {
 
   /**
    * @param {string} artifactDir
+   * @param {{ fullImage?: string, skipImageReuse?: boolean }} [options]
    */
-  async function deploy(artifactDir) {
-    log.info(`Deploying via Docker (image: ${fullImage})...`);
+  async function deploy(artifactDir, options = {}) {
+    const imageRef = options.fullImage || fullImage;
+    log.info(`Deploying via Docker (image: ${imageRef})...`);
     const dockerEnv = getDockerEnv();
 
-    const result = await ensureImageReadyForDeploy(artifactDir);
+    const result = await ensureImageReadyForDeploy(artifactDir, {
+      fullImage: options.fullImage,
+      skipImageReuse: options.skipImageReuse,
+    });
     if (result.ranCompose) {
       log.success('Docker deployment complete');
       return;
@@ -31,7 +37,7 @@ export function createDockerProvider(config, envName, env = process.env) {
       { stdio: 'pipe', env: dockerEnv }
     ).catch(() => {});
 
-    await execa('docker', ['run', '-d', '--rm', '--name', config.project, fullImage], {
+    await execa('docker', ['run', '-d', '--rm', '--name', config.project, imageRef], {
       stdio: 'inherit',
       env: dockerEnv,
     });
@@ -39,9 +45,25 @@ export function createDockerProvider(config, envName, env = process.env) {
     log.success('Docker deployment complete');
   }
 
-  async function rollback(artifactDir) {
-    log.info('Rolling back Docker deployment (redeploy previous artifact)...');
-    await deploy(artifactDir);
+  /**
+   * @param {string} artifactDir
+   * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
+   */
+  async function rollback(artifactDir, meta = {}) {
+    if (!meta.buildId) {
+      throw new Error(
+        'Docker rollback requires buildId from the restored artifact history entry'
+      );
+    }
+
+    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    log.info(
+      `Rolling back Docker to buildId=${meta.buildId} (image: ${rollbackImage})...`
+    );
+    await deploy(artifactDir, {
+      fullImage: rollbackImage,
+      skipImageReuse: true,
+    });
   }
 
   async function healthCheck() {

package/src/deployment/providers/ec2.js

@@ -20,7 +20,8 @@ export function createEc2Provider(config, envName, env = process.env) {
 
     if (!instanceId) {
       throw new Error(
-        'EC2 host unknown. Set SSH_HOST to your instance public IP, or set EC2_INSTANCE_ID with AWS credentials for auto lookup.'
+        'Could not resolve host via EC2 instance lookup, and no SSH_HOST was set — ' +
+          'provide SSH_HOST (instance public IP/DNS) or set EC2_INSTANCE_ID with AWS credentials for auto lookup.'
       );
     }
 
@@ -58,34 +59,54 @@ export function createEc2Provider(config, envName, env = process.env) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Could not resolve public IP for ${instanceId} — ${msg}. Set SSH_HOST manually or install/configure AWS CLI with ec2:DescribeInstances access.`
+        `Could not resolve host via EC2 instance lookup (${instanceId}): ${msg}. ` +
+          'Set SSH_HOST to the instance public IP/DNS, or fix AWS CLI credentials / ec2:DescribeInstances access.'
       );
     }
   }
 
-  const sshProvider = createSshProvider(config, envName, env);
-
-  async function connect() {
+  /**
+   * Resolve host (skipping cloud lookup when SSH_HOST/environment.host is set),
+   * then create an SSH provider that closes over the resolved host.
+   */
+  async function getSshProvider() {
     const host = await resolveHost();
+    if (!host) {
+      throw new Error(
+        'Could not resolve host via EC2 instance lookup, and no SSH_HOST was set — provide one or the other.'
+      );
+    }
     const environment = config.environments[envName];
-    if (environment && !environment.host) {
+    if (environment) {
       environment.host = host;
     }
-    if (!env.SSH_HOST) {
-      env.SSH_HOST = host;
-    }
-    return sshProvider.connect();
+    return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 
   return {
-    ...sshProvider,
-    connect,
-    deploy: sshProvider.deploy.bind(sshProvider),
-    rollback: sshProvider.rollback.bind(sshProvider),
-    healthCheck: sshProvider.healthCheck.bind(sshProvider),
-    testConnection: async () => {
-      const ssh = await connect();
-      ssh.dispose();
+    async connect() {
+      const ssh = await getSshProvider();
+      return ssh.connect();
+    },
+    async deploy(artifactDir, options) {
+      const ssh = await getSshProvider();
+      return ssh.deploy(artifactDir, options);
+    },
+    async rollback(artifactDir, meta) {
+      const ssh = await getSshProvider();
+      return ssh.rollback(artifactDir, meta);
+    },
+    async healthCheck() {
+      const ssh = await getSshProvider();
+      return ssh.healthCheck();
+    },
+    async testConnection() {
+      const ssh = await getSshProvider();
+      return ssh.testConnection();
+    },
+    async runRemoteCheck(command) {
+      const ssh = await getSshProvider();
+      return ssh.runRemoteCheck(command);
     },
   };
 }

package/src/deployment/providers/gcp-vm.js

@@ -21,7 +21,8 @@ export function createGcpVmProvider(config, envName, env = process.env) {
 
     if (!projectId || !zone || !instanceName) {
       throw new Error(
-        'GCP VM host unknown. Set SSH_HOST to your instance external IP, or set GCP_PROJECT_ID, GCP_ZONE, and GCP_INSTANCE_NAME for auto lookup.'
+        'Could not resolve host via GCP instance lookup, and no SSH_HOST was set — ' +
+          'provide SSH_HOST (instance external IP/DNS) or set GCP_PROJECT_ID, GCP_ZONE, and GCP_INSTANCE_NAME for auto lookup.'
       );
     }
 
@@ -59,34 +60,54 @@ export function createGcpVmProvider(config, envName, env = process.env) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Could not resolve external IP for ${instanceName} — ${msg}. Set SSH_HOST manually or run gcloud auth login and verify project/zone/instance name.`
+        `Could not resolve host via GCP instance lookup (${instanceName}): ${msg}. ` +
+          'Set SSH_HOST to the instance external IP/DNS, or run gcloud auth login and verify project/zone/instance name.'
       );
     }
   }
 
-  const sshProvider = createSshProvider(config, envName, env);
-
-  async function connect() {
+  /**
+   * Resolve host (skipping cloud lookup when SSH_HOST/environment.host is set),
+   * then create an SSH provider that closes over the resolved host.
+   */
+  async function getSshProvider() {
     const host = await resolveHost();
+    if (!host) {
+      throw new Error(
+        'Could not resolve host via GCP instance lookup, and no SSH_HOST was set — provide one or the other.'
+      );
+    }
     const environment = config.environments[envName];
-    if (environment && !environment.host) {
+    if (environment) {
       environment.host = host;
     }
-    if (!env.SSH_HOST) {
-      env.SSH_HOST = host;
-    }
-    return sshProvider.connect();
+    return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 
   return {
-    ...sshProvider,
-    connect,
-    deploy: sshProvider.deploy.bind(sshProvider),
-    rollback: sshProvider.rollback.bind(sshProvider),
-    healthCheck: sshProvider.healthCheck.bind(sshProvider),
-    testConnection: async () => {
-      const ssh = await connect();
-      ssh.dispose();
+    async connect() {
+      const ssh = await getSshProvider();
+      return ssh.connect();
+    },
+    async deploy(artifactDir, options) {
+      const ssh = await getSshProvider();
+      return ssh.deploy(artifactDir, options);
+    },
+    async rollback(artifactDir, meta) {
+      const ssh = await getSshProvider();
+      return ssh.rollback(artifactDir, meta);
+    },
+    async healthCheck() {
+      const ssh = await getSshProvider();
+      return ssh.healthCheck();
+    },
+    async testConnection() {
+      const ssh = await getSshProvider();
+      return ssh.testConnection();
+    },
+    async runRemoteCheck(command) {
+      const ssh = await getSshProvider();
+      return ssh.runRemoteCheck(command);
     },
   };
 }

package/src/deployment/providers/kubernetes.js

@@ -5,6 +5,7 @@ import os from 'os';
 import { createLogger } from '../../logger/index.js';
 import { sanitizeK8sName } from '../../utils/kubernetes-manifests.js';
 import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.js';
+import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
 import { ensureKubernetesNamespace } from '../../utils/kubernetes-namespace.js';
 import { syncKubernetesDeploymentImage } from '../../utils/kubernetes-deploy-image.js';
 
@@ -50,10 +51,24 @@ export function createKubernetesProvider(config, envName, env = process.env) {
 
   /**
    * @param {string} artifactDir
+   * @param {{ fullImage?: string, skipImageReuse?: boolean }} [options]
    */
-  async function deploy(artifactDir) {
+  async function deploy(artifactDir, options = {}) {
+    const imageRef = options.fullImage || imageOps.fullImage;
+    const isRollbackRedeploy = Boolean(options.skipImageReuse);
+
     log.info(`Deploying to Kubernetes (namespace: ${namespace}${context ? `, context: ${context}` : ''})...`);
 
+    // Rollback always rebuilds and must push — without registry creds the cluster
+    // cannot pull the new tag and would sit in ImagePullBackOff after a false success.
+    if (isRollbackRedeploy && !imageOps.hasRegistryCredentials()) {
+      throw new Error(
+        'Kubernetes rollback requires DOCKER_REGISTRY_USERNAME and DOCKER_REGISTRY_TOKEN ' +
+          `so the rebuilt image (${imageRef}) can be pushed for the cluster to pull. ` +
+          'Set those credentials and retry.'
+      );
+    }
+
     const manifestDir = artifactDir;
     const hasManifests =
       (await fs.pathExists(path.join(manifestDir, 'k8s'))) ||
@@ -65,8 +80,11 @@ export function createKubernetesProvider(config, envName, env = process.env) {
       );
     }
 
-    log.info(`Ensuring container image ${imageOps.fullImage} is built and pushed before apply...`);
-    const imageResult = await imageOps.ensureImageReadyForDeploy(artifactDir);
+    log.info(`Ensuring container image ${imageRef} is built and pushed before apply...`);
+    const imageResult = await imageOps.ensureImageReadyForDeploy(artifactDir, {
+      fullImage: options.fullImage,
+      skipImageReuse: options.skipImageReuse,
+    });
     if (imageResult.ranCompose) {
       log.warn(
         'docker compose was used — ensure the cluster can pull the resulting image from your registry.'
@@ -93,23 +111,60 @@ export function createKubernetesProvider(config, envName, env = process.env) {
     // If the live ref already equals fullImage, rollout restart so a new digest is pulled.
     await syncKubernetesDeploymentImage({
       deploymentName,
-      fullImage: imageOps.fullImage,
+      fullImage: imageRef,
       kubectlArgs,
       getKubectlEnv,
       log,
     });
 
+    // Rollback-only safety net: wait until pods are actually healthy (catches ImagePullBackOff).
+    if (isRollbackRedeploy) {
+      const timeout = '120s';
+      log.info(
+        `Waiting for deployment/${deploymentName} rollout to complete (timeout ${timeout})...`
+      );
+      try {
+        await execa(
+          'kubectl',
+          kubectlArgs([
+            'rollout',
+            'status',
+            `deployment/${deploymentName}`,
+            `--timeout=${timeout}`,
+          ]),
+          { stdio: 'inherit', env: getKubectlEnv() }
+        );
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Kubernetes rollback failed: deployment/${deploymentName} did not become healthy within ${timeout}. ` +
+            `The cluster may be unable to pull ${imageRef} (ImagePullBackOff) or pods are failing. ${detail}`
+        );
+      }
+    }
+
     log.success('Kubernetes deployment complete');
   }
 
-  async function rollback(artifactDir) {
-    log.info('Rolling back Kubernetes deployment...');
-    await execa('kubectl', kubectlArgs(['rollout', 'undo', `deployment/${deploymentName}`]), {
-      stdio: 'inherit',
-      env: getKubectlEnv(),
-    }).catch(async () => {
-      log.warn('kubectl rollout undo failed — redeploying previous artifact instead');
-      await deploy(artifactDir);
+  /**
+   * Artifact-based rollback: restore buildId X's code and image (not cluster undo history).
+   * @param {string} artifactDir
+   * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
+   */
+  async function rollback(artifactDir, meta = {}) {
+    if (!meta.buildId) {
+      throw new Error(
+        'Kubernetes rollback requires buildId from the restored artifact history entry'
+      );
+    }
+
+    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    log.info(
+      `Rolling back Kubernetes to buildId=${meta.buildId} (image: ${rollbackImage})...`
+    );
+    await deploy(artifactDir, {
+      fullImage: rollbackImage,
+      skipImageReuse: true,
     });
   }
 

package/src/deployment/providers/ssh.js

@@ -405,7 +405,7 @@ export function createSshProvider(config, envName, env = process.env) {
     return result.code === 0 && result.stdout.trim() === 'yes';
   }
 
-  async function rollback(artifactDir) {
+  async function rollback(artifactDir, _meta) {
     await deploy(artifactDir);
   }
 

package/src/storage/index.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
 import { createLogger } from '../logger/index.js';
 import { createAwsProvider } from './providers/aws.js';
 import { createLocalProvider } from './providers/local.js';
@@ -7,8 +9,20 @@ import { createGcpProvider } from './providers/gcp.js';
 import { createGdriveProvider } from './providers/gdrive.js';
 import { createDropboxProvider } from './providers/dropbox.js';
 import { createFtpProvider } from './providers/ftp.js';
+import {
+  buildArtifactRemoteKey,
+  historyRemoteKey,
+  latestArtifactRemoteKey,
+  legacyArtifactRemoteKey,
+  resolveBuildId,
+} from '../utils/build-id.js';
+import {
+  parseArtifactHistory,
+  prependHistoryEntry,
+} from '../utils/artifact-history.js';
+import { summarizeStorageError } from './storage-errors.js';
 
-/** @type {Record<string, (env?: Record<string, string>) => import('./providers/aws.js').default>} */
+/** @type {Record<string, (env?: Record<string, string>) => ReturnType<typeof createAwsProvider>>} */
 const PROVIDER_FACTORIES = {
   aws: createAwsProvider,
   local: createLocalProvider,
@@ -32,21 +46,135 @@ export function getStorageProvider(name, env = process.env) {
 }
 
 /**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ */
+function ensureBuildIdentity(config) {
+  if (!config.version) {
+    config.version = '0.0.0';
+  }
+  if (!config.buildId) {
+    const { buildId } = resolveBuildId({ semver: config.version });
+    config.buildId = buildId;
+  }
+}
+
+/**
+ * Read history.json from the first provider that has it.
+ * Missing keys across all providers → { entries: [], source: null }.
+ * Auth / network / permission failures → thrown with a concise actionable message
+ * (not silently treated as "no history").
+ *
+ * @param {string[]} providers
+ * @param {string} project
+ * @returns {Promise<{
+ *   entries: import('../utils/artifact-history.js').ArtifactHistoryEntry[],
+ *   source: string|null,
+ * }>}
+ */
+export async function loadArtifactHistory(providers, project) {
+  if (!providers || providers.length === 0) {
+    return { entries: [], source: null };
+  }
+
+  const key = historyRemoteKey(project);
+  const tmp = path.join(os.tmpdir(), `deployhub-history-${Date.now()}.json`);
+
+  try {
+    for (const name of providers) {
+      try {
+        const provider = getStorageProvider(name);
+        const exists = await provider.verify(key);
+        if (!exists) continue;
+
+        await provider.download(key, tmp);
+        const raw = await fs.readFile(tmp, 'utf8');
+        return {
+          entries: parseArtifactHistory(raw),
+          source: name,
+        };
+      } 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(() => {});
+  }
+
+  return { entries: [], source: null };
+}
+
+/**
+ * @param {ReturnType<typeof getStorageProvider>} provider
+ * @param {string} project
+ * @param {import('../utils/artifact-history.js').ArtifactHistoryEntry[]} history
+ */
+async function writeArtifactHistory(provider, project, history) {
+  const key = historyRemoteKey(project);
+  const tmp = path.join(os.tmpdir(), `deployhub-history-write-${Date.now()}.json`);
+  await fs.writeJson(tmp, history, { spaces: 2 });
+  try {
+    await provider.upload(tmp, key);
+  } finally {
+    await fs.remove(tmp).catch(() => {});
+  }
+}
+
+/**
+ * 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;
+ * legacy keys remain readable for older artifacts).
+ *
  * @param {string[]} providers
  * @param {string} zipPath
  * @param {import('../core/config.js').DeployHubConfig} config
  */
 export async function uploadToAll(providers, zipPath, config) {
   const log = createLogger('storage');
-  const remoteKey = `${config.project}/v${config.version}/artifact.zip`;
+  ensureBuildIdentity(config);
+
+  const buildId = /** @type {string} */ (config.buildId);
+  const remoteKey = buildArtifactRemoteKey(config.project, buildId);
+  const latestKey = latestArtifactRemoteKey(config.project);
+  const entry = {
+    buildId,
+    semver: String(config.version || '0.0.0').replace(/^v/i, ''),
+    uploadedAt: new Date().toISOString(),
+    remoteKey,
+  };
 
   const uploads = providers.map(async (name) => {
     try {
       const provider = getStorageProvider(name);
-      log.info(`Uploading to ${name}...`);
+      log.info(`Uploading build ${buildId} to ${name}...`);
       await provider.upload(zipPath, remoteKey);
-      log.success(`Uploaded to ${name}`);
-      return { name, success: true };
+      // Intentional overwrite: mutable "current" pointer, not a versioned backup.
+      await provider.upload(zipPath, latestKey);
+
+      let history = [];
+      try {
+        const histKey = historyRemoteKey(config.project);
+        if (await provider.verify(histKey)) {
+          const tmp = path.join(os.tmpdir(), `deployhub-hist-${name}-${Date.now()}.json`);
+          try {
+            await provider.download(histKey, tmp);
+            history = parseArtifactHistory(await fs.readFile(tmp, 'utf8'));
+          } finally {
+            await fs.remove(tmp).catch(() => {});
+          }
+        }
+      } catch {
+        history = [];
+      }
+
+      const next = prependHistoryEntry(history, entry);
+      await writeArtifactHistory(provider, config.project, next);
+
+      log.success(`Uploaded to ${name} (${remoteKey})`);
+      return { name, success: true, remoteKey, buildId };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`Storage upload to ${name} failed: ${message}`);
@@ -73,6 +201,27 @@ export async function downloadFromFirst(providers, remoteKey, localPath) {
   throw new Error(`Artifact not found in any configured storage provider`);
 }
 
+/**
+ * Download a build by history entry, with legacy key fallback for pre-buildId uploads.
+ *
+ * @param {string[]} providers
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ remoteKey: string, buildId: string, semver: string }} entry
+ * @param {string} localPath
+ */
+export async function downloadArtifactEntry(providers, config, entry, localPath) {
+  try {
+    return await downloadFromFirst(providers, entry.remoteKey, localPath);
+  } catch {
+    const legacyKey = legacyArtifactRemoteKey(config.project, entry.semver);
+    const log = createLogger('storage');
+    log.warn(
+      `Build key not found; trying legacy key ${legacyKey} (may be an overwritten single-slot artifact)`
+    );
+    return downloadFromFirst(providers, legacyKey, localPath);
+  }
+}
+
 /**
  * @param {string} name
  */
@@ -99,11 +248,18 @@ export async function testAllProviders(providers) {
     }
     return {
       name,
-      status: 'error',
-      error: result.reason?.message || String(result.reason),
+      status: 'failed',
+      error: result.reason instanceof Error ? result.reason.message : String(result.reason),
     };
   });
 }
 
-export { PROVIDER_FACTORIES };
-export default { getStorageProvider, uploadToAll, downloadFromFirst, testProvider, testAllProviders };
+export default {
+  getStorageProvider,
+  uploadToAll,
+  downloadFromFirst,
+  downloadArtifactEntry,
+  loadArtifactHistory,
+  testProvider,
+  testAllProviders,
+};

package/src/storage/providers/aws.js

@@ -2,6 +2,7 @@ import { S3Client, HeadBucketCommand, DeleteObjectCommand, GetObjectCommand } fr
 import { Upload } from '@aws-sdk/lib-storage';
 import fs from 'fs-extra';
 import path from 'path';
+import { isNotFoundStorageError } from '../storage-errors.js';
 
 /**
  * @param {Record<string, string>} env
@@ -65,6 +66,8 @@ export function createAwsProvider(env = process.env) {
 
   /**
    * @param {string} remoteKey
+   * @returns {Promise<boolean>} true if object exists; false if missing.
+   *   Auth / network / permission errors are rethrown (not treated as missing).
    */
   async function verify(remoteKey) {
     try {
@@ -72,8 +75,9 @@ export function createAwsProvider(env = process.env) {
         new GetObjectCommand({ Bucket: bucket, Key: remoteKey })
       );
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      if (isNotFoundStorageError(err)) return false;
+      throw err;
     }
   }
 

package/src/storage/providers/dropbox.js

@@ -1,6 +1,7 @@
 import { Dropbox } from 'dropbox';
 import fs from 'fs-extra';
 import path from 'path';
+import { isNotFoundStorageError } from '../storage-errors.js';
 
 export function createDropboxProvider(env = process.env) {
   const token = env.DROPBOX_ACCESS_TOKEN;
@@ -24,13 +25,18 @@ export function createDropboxProvider(env = process.env) {
     await fs.writeFile(localPath, fileBlob);
   }
 
+  /**
+   * @param {string} remoteKey
+   * @returns {Promise<boolean>}
+   */
   async function verify(remoteKey) {
     const key = remoteKey.startsWith('/') ? remoteKey : `/${remoteKey}`;
     try {
       await dbx.filesGetMetadata({ path: key });
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      if (isNotFoundStorageError(err)) return false;
+      throw err;
     }
   }
 

package/src/storage/providers/ftp.js

@@ -1,6 +1,7 @@
 import { Client } from 'basic-ftp';
 import fs from 'fs-extra';
 import path from 'path';
+import { isNotFoundStorageError } from '../storage-errors.js';
 
 export function createFtpProvider(env = process.env) {
   const host = env.FTP_HOST;
@@ -38,6 +39,10 @@ export function createFtpProvider(env = process.env) {
     });
   }
 
+  /**
+   * @param {string} remoteKey
+   * @returns {Promise<boolean>}
+   */
   async function verify(remoteKey) {
     const remotePath = `${basePath}/${remoteKey}`;
     try {
@@ -45,8 +50,9 @@ export function createFtpProvider(env = process.env) {
         await client.size(remotePath);
       });
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      if (isNotFoundStorageError(err)) return false;
+      throw err;
     }
   }