@scrymore/scry-deployer 0.9.1-next.20260927093719 → 0.9.1

package/bin/cli.js

@@ -400,7 +400,15 @@ async function runDeployment(argv) {
             }
         );
         const uploadMs = uploadTimer.stop();
-        logger.success('✅ Archive uploaded.');
+        // A metadata upload that failed is the essential part of this deploy
+        // failing: no success line may follow it (RCA 2: the log printed
+        // "Archive uploaded" and "Upload complete" after the timeout).
+        const metadataFailed = uploadResult?.metadataUpload?.success === false;
+        if (metadataFailed) {
+            logger.info('Storybook ZIP uploaded; the metadata upload failed (see above and below).');
+        } else {
+            logger.success('✅ Archive uploaded.');
+        }
         logger.debug(`Upload result: ${JSON.stringify(uploadResult)}`);
 
         await postPRComment(buildDeployResult(argv, coverageSummary, uploadResult), coverageSummary);
@@ -414,8 +422,8 @@ async function runDeployment(argv) {
         // credential — and this command previously printed
         // "Deployment successful" over it, sending people looking for the
         // cause three steps downstream (ISSUES.md #4).
-        logger.success('\n✅ Upload complete.');
-        logUploadLinks(argv, coverageSummary, uploadResult, logger);
+        if (!metadataFailed) logger.success('\n✅ Upload complete.');
+        logUploadLinks(argv, coverageSummary, uploadResult, logger, { indexed: !metadataFailed });
 
         reportIndexingOutcome({ argv, analysis, uploadResult, emptyArchive, sbcovFailure, dropped, logger });
 
@@ -475,9 +483,15 @@ function reportIndexingOutcome({ argv, analysis, uploadResult, emptyArchive, sbc
         // check tested only that the object existed, printed "uploaded but
         // not queued" and exited 0.
         process.exitCode = 1;
+        const zip = uploadResult?.zipUpload || {};
+        const build = zip.buildId
+            ? `Build ${zip.buildId}${zip.buildNumber !== undefined ? ` (#${zip.buildNumber})` : ''}`
+            : 'The build';
         logger.error(
             `\n❌ The metadata upload failed (${metadataUpload.error || 'no reason given'}), so NOTHING WILL BE INDEXED.\n` +
-            HOSTED_NOT_SEARCHABLE
+            HOSTED_NOT_SEARCHABLE + '\n' +
+            `   ${build} is left pending: the upload service has no way to mark it failed,\n` +
+            '   so it will not show as failed. Re-run this job to index it.'
         );
         return;
     }
@@ -1102,10 +1116,14 @@ function buildDeployResult(argv, coverageSummary, uploadResult) {
     };
 }
 
-function logUploadLinks(argv, coverageSummary, uploadResult, logger) {
+function logUploadLinks(argv, coverageSummary, uploadResult, logger, { indexed = true } = {}) {
     const deployResult = buildDeployResult(argv, coverageSummary, uploadResult);
 
-    logger.success('\n✅ Storybook hosted.\n');
+    if (indexed) {
+        logger.success('\n✅ Storybook hosted.\n');
+    } else {
+        logger.info('\nStorybook hosted (browsable, NOT indexed):\n');
+    }
     logger.info(`📖 Storybook: ${deployResult.viewUrl}`);
     if (deployResult.coverageUrl) {
         logger.info(`📊 Coverage:  ${deployResult.coverageUrl}`);

package/lib/apiClient.js

@@ -22,6 +22,12 @@ const COVERAGE_RETRY_DELAY_MS = 60000;
 const UPLOAD_MAX_ATTEMPTS = 4;
 const UPLOAD_BACKOFF_BASE_MS = 2000;
 
+// Bodies POSTed through the upload service (metadata ZIP, coverage JSON).
+const SERVICE_UPLOAD_MAX_ATTEMPTS = 3;
+const UPLOAD_TIMEOUT_FLOOR_MS = 60000;
+const UPLOAD_MIN_BYTES_PER_S = 100 * 1024;
+const UPLOAD_TIMEOUT_CAP_MS = 15 * 60 * 1000;
+
 // Network-level failures that a later attempt can plausibly survive. Flapping
 // DNS reports EAI_AGAIN (and, mid-flap, ENOTFOUND) rather than a clean refusal.
 const TRANSIENT_CODES = new Set([
@@ -93,6 +99,80 @@ async function withUploadRetry(attemptFn, label) {
   throw lastError;
 }
 
+/**
+ * How long one upload through the upload service may take: max(60 s,
+ * bytes / 100 KB/s), capped at 15 min (RCA 2 of storybook-preview-ci-runtime).
+ * A fixed 60 s failed a 28 MB metadata ZIP on a 0.4-0.85 MB/s runner uplink.
+ * SCRY_UPLOAD_TIMEOUT_FLOOR_MS lowers or raises the 60 s floor (tests, very
+ * slow links).
+ *
+ * @param {number} bytes
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {number} milliseconds
+ */
+function uploadTimeoutMs(bytes, env = process.env) {
+  const floorRaw = Number(env.SCRY_UPLOAD_TIMEOUT_FLOOR_MS);
+  const floor = Number.isFinite(floorRaw) && floorRaw > 0 ? floorRaw : UPLOAD_TIMEOUT_FLOOR_MS;
+  const scaled = Math.ceil((Math.max(0, bytes) / UPLOAD_MIN_BYTES_PER_S) * 1000);
+  return Math.min(UPLOAD_TIMEOUT_CAP_MS, Math.max(floor, scaled));
+}
+
+function formatBytes(n) {
+  if (n >= 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${n} B`;
+}
+
+function describeUploadError(error) {
+  if (error?.response?.status) return `HTTP ${error.response.status}`;
+  if (error?.code === 'ECONNABORTED' || /timeout/i.test(String(error?.message))) return `timeout: ${error.message}`;
+  return error?.code || error?.message || 'unknown error';
+}
+
+/**
+ * POST a body through the upload service with a size-scaled timeout, retrying
+ * timeouts, 5xx/429 and network errors (never other 4xx) up to 3 attempts
+ * with backoff. Every attempt is logged with its size and elapsed time, so a
+ * slow link reads as slow, not hung. Throws the last error.
+ *
+ * @param {axios.AxiosInstance} apiClient
+ * @param {string} url
+ * @param {Buffer|string|object} body
+ * @param {{label:string, bytes:number, headers:object, log?:{info:Function}}} o
+ */
+async function postThroughService(apiClient, url, body, { label, bytes, headers, log = logger }) {
+  const timeout = uploadTimeoutMs(bytes);
+  const backoffRaw = Number(process.env.SCRY_UPLOAD_BACKOFF_MS);
+  const backoffBase = Number.isFinite(backoffRaw) && backoffRaw >= 0 ? backoffRaw : UPLOAD_BACKOFF_BASE_MS;
+  const size = formatBytes(bytes);
+  let lastError;
+  for (let attempt = 1; attempt <= SERVICE_UPLOAD_MAX_ATTEMPTS; attempt++) {
+    const started = Date.now();
+    log.info(`${label}: attempt ${attempt}/${SERVICE_UPLOAD_MAX_ATTEMPTS}, ${size}, timeout ${Math.round(timeout / 1000)} s...`);
+    try {
+      const response = await apiClient.post(url, body, {
+        headers,
+        timeout,
+        maxContentLength: 100 * 1024 * 1024,
+        maxBodyLength: 100 * 1024 * 1024,
+      });
+      log.info(`${label}: sent ${size} in ${((Date.now() - started) / 1000).toFixed(1)} s (attempt ${attempt}/${SERVICE_UPLOAD_MAX_ATTEMPTS}).`);
+      return response;
+    } catch (error) {
+      lastError = error;
+      const elapsed = ((Date.now() - started) / 1000).toFixed(1);
+      if (!isTransientUploadError(error) || attempt === SERVICE_UPLOAD_MAX_ATTEMPTS) {
+        log.info(`${label}: attempt ${attempt}/${SERVICE_UPLOAD_MAX_ATTEMPTS} (${size}) failed after ${elapsed} s (${describeUploadError(error)}).`);
+        throw error;
+      }
+      const backoff = backoffBase * Math.pow(2, attempt - 1);
+      log.info(`${label}: attempt ${attempt}/${SERVICE_UPLOAD_MAX_ATTEMPTS} (${size}) failed after ${elapsed} s (${describeUploadError(error)}); retrying in ${backoff / 1000} s...`);
+      await sleep(backoff);
+    }
+  }
+  throw lastError;
+}
+
 /**
  * Creates a pre-configured axios instance for making API calls.
  * @param {string} apiUrl The base URL of the API.
@@ -329,14 +409,12 @@ async function uploadCoverageReportDirectly(apiClient, target, coverageReport) {
   logger.debug(`Uploading coverage report for ${projectName}/${versionName}`);
 
   try {
-    const response = await apiClient.post(
+    const json = JSON.stringify(coverageReport);
+    const response = await postThroughService(
+      apiClient,
       `/upload/${projectName}/${versionName}/coverage`,
-      coverageReport,
-      {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      }
+      json,
+      { label: 'Coverage report', bytes: Buffer.byteLength(json), headers: { 'Content-Type': 'application/json' } },
     );
 
     logger.debug(`Coverage upload response status: ${response.status}`);
@@ -402,10 +480,11 @@ async function uploadMetadataZip(apiClient, target, metadataZipPath, customLogge
 
   try {
     const fileBuffer = fs.readFileSync(metadataZipPath);
-    const response = await apiClient.post(url, fileBuffer, {
+    const response = await postThroughService(apiClient, url, fileBuffer, {
+      label: 'Metadata ZIP',
+      bytes: fileBuffer.length,
       headers: { 'Content-Type': 'application/zip' },
-      maxContentLength: 100 * 1024 * 1024,
-      maxBodyLength: 100 * 1024 * 1024,
+      log: customLogger,
     });
 
     const data = response.data || {};
@@ -458,19 +537,27 @@ async function uploadBuild(apiClient, target, options) {
     // failure in the optional artifact was silently taking down the essential
     // one. Observed on a 467-story library: every story captured, nothing
     // indexed, twice.
+    // Timeouts, 5xx and network errors are retried inside the upload. The
+    // one 4xx worth waiting for is the build record not existing yet (the
+    // presigned call creates it), so only that gets the old 60 s second try.
+    const coverageFailed = (err) => logger.warn(
+      `⚠️  Coverage report upload failed: ${err.message}\n` +
+      '   Continuing — this affects the coverage report only. Screenshots and\n' +
+      '   metadata still upload, so components will still be indexed.'
+    );
     try {
       coverageUpload = await uploadCoverageReportDirectly(apiClient, target, options.coverageReport);
     } catch (error) {
-      logger.info('Coverage upload failed; retrying in 60s...');
-      await sleep(COVERAGE_RETRY_DELAY_MS);
-      try {
-        coverageUpload = await uploadCoverageReportDirectly(apiClient, target, options.coverageReport);
-      } catch (retryError) {
-        logger.warn(
-          `⚠️  Coverage report upload failed: ${retryError.message}\n` +
-          '   Continuing — this affects the coverage report only. Screenshots and\n' +
-          '   metadata still upload, so components will still be indexed.'
-        );
+      if (error.statusCode === 404 && /Build not found/.test(error.message)) {
+        logger.info('Coverage upload found no build yet; retrying in 60s...');
+        await sleep(COVERAGE_RETRY_DELAY_MS);
+        try {
+          coverageUpload = await uploadCoverageReportDirectly(apiClient, target, options.coverageReport);
+        } catch (retryError) {
+          coverageFailed(retryError);
+        }
+      } else {
+        coverageFailed(error);
       }
     }
   }
@@ -502,5 +589,8 @@ module.exports = {
   putToPresignedUrl,
   isTransientUploadError,
   withUploadRetry,
+  uploadTimeoutMs,
+  postThroughService,
   UPLOAD_MAX_ATTEMPTS,
+  SERVICE_UPLOAD_MAX_ATTEMPTS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrymore/scry-deployer",
-  "version": "0.9.1-next.20260927093719",
+  "version": "0.9.1",
   "description": "A CLI to automate the deployment of Storybook static builds.",
   "main": "index.js",
   "bin": {