@automattic/vip 4.1.5 → 4.1.8

package/dist/lib/client-file-uploader.js

@@ -1,87 +1,82 @@
 "use strict";
-
-exports.__esModule = true;
-exports.MULTIPART_THRESHOLD = exports.COMPRESS_THRESHOLD = void 0;
-exports.checkFileAccess = checkFileAccess;
-exports.detectCompressedMimeType = detectCompressedMimeType;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzipFile = exports.getFileHash = exports.MULTIPART_THRESHOLD = exports.COMPRESS_THRESHOLD = void 0;
+exports.parseEtagHeader = parseEtagHeader;
 exports.fetchWithRetry = fetchWithRetry;
-exports.getFileHash = void 0;
 exports.getFileMeta = getFileMeta;
-exports.getFileSize = getFileSize;
-exports.getPartBoundaries = getPartBoundaries;
+exports.uploadImportFileToS3 = uploadImportFileToS3;
 exports.getSignedUploadRequestData = getSignedUploadRequestData;
+exports.checkFileAccess = checkFileAccess;
 exports.isFile = isFile;
-exports.parseEtagHeader = parseEtagHeader;
-exports.unzipFile = void 0;
-exports.uploadImportFileToS3 = uploadImportFileToS3;
+exports.getFileSize = getFileSize;
+exports.detectCompressedMimeType = detectCompressedMimeType;
+exports.getPartBoundaries = getPartBoundaries;
 exports.uploadParts = uploadParts;
-var _chalk = _interopRequireDefault(require("chalk"));
-var _crypto = require("crypto");
-var _debug = _interopRequireDefault(require("debug"));
-var _fs = require("fs");
-var _promises = require("node:fs/promises");
-var _promises2 = require("node:stream/promises");
-var _nodeTimers = require("node:timers");
-var _promises3 = require("node:timers/promises");
-var _os = _interopRequireDefault(require("os"));
-var _path = _interopRequireDefault(require("path"));
-var _stream = require("stream");
-var _undici = require("undici");
-var _xml2js = require("xml2js");
-var _zlib = require("zlib");
-var _http = _interopRequireDefault(require("../lib/api/http"));
-var _fileSize = require("../lib/constants/file-size");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = require("crypto");
+const debug_1 = __importDefault(require("debug"));
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const promises_2 = require("node:stream/promises");
+const node_timers_1 = require("node:timers");
+const promises_3 = require("node:timers/promises");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const undici_1 = require("undici");
+const xml2js_1 = require("xml2js");
+const zlib_1 = require("zlib");
+const http_1 = __importDefault(require("../lib/api/http"));
+const file_size_1 = require("../lib/constants/file-size");
 function parseEtagHeader(etag) {
-  const normalizedEtag = etag.replace(/^W\//u, '').trim();
-  if (normalizedEtag.startsWith('"') && normalizedEtag.endsWith('"')) {
-    try {
-      return JSON.parse(normalizedEtag);
-    } catch (err) {
-      debug(`Unable to JSON.parse ETag header, falling back to raw value: ${err.message}`);
+    const normalizedEtag = etag.replace(/^W\//u, '').trim();
+    if (normalizedEtag.startsWith('"') && normalizedEtag.endsWith('"')) {
+        try {
+            return JSON.parse(normalizedEtag);
+        }
+        catch (err) {
+            debug(`Unable to JSON.parse ETag header, falling back to raw value: ${err.message}`);
+        }
     }
-  }
-  return normalizedEtag.replace(/^"(.*)"$/u, '$1');
+    return normalizedEtag.replace(/^"(.*)"$/u, '$1');
 }
-const isStreamBody = body => typeof body?.pipe === 'function';
+const isStreamBody = (body) => typeof body?.pipe === 'function';
 function createProgressTransform(onChunk) {
-  return new _stream.Transform({
-    transform(chunk, _encoding, callback) {
-      onChunk(chunk);
-      callback(null, chunk);
-    }
-  });
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            onChunk(chunk);
+            callback(null, chunk);
+        },
+    });
 }
 function omitUnsupportedFetchHeaders(init) {
-  if (!init.headers) {
-    return init;
-  }
-  const headers = new _undici.Headers(init.headers);
-  headers.delete('expect');
-  return {
-    ...init,
-    headers
-  };
+    if (!init.headers) {
+        return init;
+    }
+    const headers = new undici_1.Headers(init.headers);
+    headers.delete('expect');
+    return { ...init, headers };
 }
 function withCauseMessage(err) {
-  if (!(err instanceof Error)) {
-    return err;
-  }
-  const cause = err.cause;
-  let causeMessage;
-  if (cause instanceof Error) {
-    causeMessage = cause.message;
-  } else if (typeof cause === 'string') {
-    causeMessage = cause;
-  }
-  if (!causeMessage || err.message.includes(causeMessage)) {
-    return err;
-  }
-  return new Error(`${err.message}: ${causeMessage}`, {
-    cause: err
-  });
+    if (!(err instanceof Error)) {
+        return err;
+    }
+    const cause = err.cause;
+    let causeMessage;
+    if (cause instanceof Error) {
+        causeMessage = cause.message;
+    }
+    else if (typeof cause === 'string') {
+        causeMessage = cause;
+    }
+    if (!causeMessage || err.message.includes(causeMessage)) {
+        return err;
+    }
+    return new Error(`${err.message}: ${causeMessage}`, { cause: err });
 }
-
 /**
  * Wraps `fetch` with exponential-backoff retries.
  *
@@ -97,74 +92,67 @@ function withCauseMessage(err) {
  * once so the underlying error surfaces instead of the misleading undici one.
  */
 async function fetchWithRetry(input, init = {}, retries = 3, createBody) {
-  const bodyIsStream = isStreamBody(init.body);
-  // Only retry when we can hand `fetch` a fresh, replayable body each attempt.
-  const maxAttempts = createBody || !bodyIsStream ? retries : 0;
-  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
-    const requestInit = createBody ? {
-      ...init,
-      body: createBody()
-    } : {
-      ...init
-    };
-    if (isStreamBody(requestInit.body) && !requestInit.duplex) {
-      requestInit.duplex = 'half';
+    const bodyIsStream = isStreamBody(init.body);
+    // Only retry when we can hand `fetch` a fresh, replayable body each attempt.
+    const maxAttempts = createBody || !bodyIsStream ? retries : 0;
+    for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+        const requestInit = createBody
+            ? { ...init, body: createBody() }
+            : { ...init };
+        if (isStreamBody(requestInit.body) && !requestInit.duplex) {
+            requestInit.duplex = 'half';
+        }
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            return await (0, undici_1.fetch)(input, omitUnsupportedFetchHeaders(requestInit));
+        }
+        catch (err) {
+            if (attempt === maxAttempts) {
+                throw withCauseMessage(err);
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await (0, promises_3.setTimeout)(Math.pow(2, attempt) * 1000); // 1000, 2000, 4000
+        }
     }
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      return await (0, _undici.fetch)(input, omitUnsupportedFetchHeaders(requestInit));
-    } catch (err) {
-      if (attempt === maxAttempts) {
-        throw withCauseMessage(err);
-      }
-      // eslint-disable-next-line no-await-in-loop
-      await (0, _promises3.setTimeout)(Math.pow(2, attempt) * 1000); // 1000, 2000, 4000
-    }
-  }
-  throw new Error('unreachable');
+    throw new Error('unreachable');
 }
-const debug = (0, _debug.default)('vip:lib/client-file-uploader');
-
+const debug = (0, debug_1.default)('vip:lib/client-file-uploader');
 // Files smaller than COMPRESS_THRESHOLD will not be compressed before upload
-const COMPRESS_THRESHOLD = exports.COMPRESS_THRESHOLD = 16 * _fileSize.MB_IN_BYTES;
-
+exports.COMPRESS_THRESHOLD = 16 * file_size_1.MB_IN_BYTES;
 // Files smaller than MULTIPART_THRESHOLD will use `PutObject` vs Multipart Uploads
-const MULTIPART_THRESHOLD = exports.MULTIPART_THRESHOLD = 32 * _fileSize.MB_IN_BYTES;
-
+exports.MULTIPART_THRESHOLD = 32 * file_size_1.MB_IN_BYTES;
 // This is how big each part of a Multipart Upload is (except the last / remainder)
-const UPLOAD_PART_SIZE = 16 * _fileSize.MB_IN_BYTES;
-
+const UPLOAD_PART_SIZE = 16 * file_size_1.MB_IN_BYTES;
 // How many parts will upload at the same time
 const MAX_CONCURRENT_PART_UPLOADS = 5;
-
-// TODO: Replace with a proper definitions once we convert lib/cli/command.js to TypeScript
-
-const getWorkingTempDir = () => (0, _promises.mkdtemp)(_path.default.join(_os.default.tmpdir(), 'vip-client-file-uploader'));
+// How many times a presigned URL request is retried after a network error, 429 or 5xx
+const SIGNED_REQUEST_RETRIES = 3;
+const getWorkingTempDir = () => (0, promises_1.mkdtemp)(path_1.default.join(os_1.default.tmpdir(), 'vip-client-file-uploader'));
 const getFileHash = async (fileName, hashType = 'md5') => {
-  const src = (0, _fs.createReadStream)(fileName);
-  const dst = (0, _crypto.createHash)(hashType);
-  try {
-    await (0, _promises2.pipeline)(src, dst);
-    return dst.digest().toString('hex');
-  } catch (err) {
-    throw new Error(`Could not generate file hash: ${err.message}`, {
-      cause: err
-    });
-  } finally {
-    src.close();
-  }
+    const src = (0, fs_1.createReadStream)(fileName);
+    const dst = (0, crypto_1.createHash)(hashType);
+    try {
+        await (0, promises_2.pipeline)(src, dst);
+        return dst.digest().toString('hex');
+    }
+    catch (err) {
+        throw new Error(`Could not generate file hash: ${err.message}`, {
+            cause: err,
+        });
+    }
+    finally {
+        src.close();
+    }
 };
 exports.getFileHash = getFileHash;
 const gzipFile = async (uncompressedFileName, compressedFileName) => {
-  try {
-    await (0, _promises2.pipeline)((0, _fs.createReadStream)(uncompressedFileName), (0, _zlib.createGzip)(), (0, _fs.createWriteStream)(compressedFileName));
-  } catch (err) {
-    throw new Error(`Could not compress file: ${err.message}`, {
-      cause: err
-    });
-  }
+    try {
+        await (0, promises_2.pipeline)((0, fs_1.createReadStream)(uncompressedFileName), (0, zlib_1.createGzip)(), (0, fs_1.createWriteStream)(compressedFileName));
+    }
+    catch (err) {
+        throw new Error(`Could not compress file: ${err.message}`, { cause: err });
+    }
 };
-
 /**
  * Extract a .gz file and save it to a specified location
  *
@@ -173,520 +161,409 @@ const gzipFile = async (uncompressedFileName, compressedFileName) => {
  * @return {Promise} A promise that resolves when the file is unzipped
  */
 const unzipFile = async (inputFilename, outputFilename) => {
-  const mimeType = await detectCompressedMimeType(inputFilename);
-  const extractFunctions = {
-    'application/gzip': {
-      extractor: _zlib.createGunzip
-    }
-  };
-  const extractionInfo = extractFunctions[mimeType];
-  if (!extractionInfo) {
-    throw new Error(`unsupported file format: ${mimeType}`);
-  }
-  const source = (0, _fs.createReadStream)(inputFilename);
-  const destination = (0, _fs.createWriteStream)(outputFilename);
-  await (0, _promises2.pipeline)(source, extractionInfo.extractor(), destination);
+    const mimeType = await detectCompressedMimeType(inputFilename);
+    const extractFunctions = {
+        'application/gzip': {
+            extractor: zlib_1.createGunzip,
+        },
+    };
+    const extractionInfo = extractFunctions[mimeType];
+    if (!extractionInfo) {
+        throw new Error(`unsupported file format: ${mimeType}`);
+    }
+    const source = (0, fs_1.createReadStream)(inputFilename);
+    const destination = (0, fs_1.createWriteStream)(outputFilename);
+    await (0, promises_2.pipeline)(source, extractionInfo.extractor(), destination);
 };
 exports.unzipFile = unzipFile;
 async function getFileMeta(fileName) {
-  const fileSize = await getFileSize(fileName);
-  const basename = _path.default.basename(fileName);
-  // TODO Validate File basename...  encodeURIComponent, maybe...?
-
-  const mimeType = await detectCompressedMimeType(fileName);
-  // TODO Only allow a subset of Mime Types...?
-
-  const isCompressed = ['application/zip', 'application/gzip'].includes(mimeType);
-  return {
-    basename,
-    fileName,
-    fileSize,
-    isCompressed
-  };
+    const fileSize = await getFileSize(fileName);
+    const basename = path_1.default.basename(fileName);
+    // TODO Validate File basename...  encodeURIComponent, maybe...?
+    const mimeType = await detectCompressedMimeType(fileName);
+    // TODO Only allow a subset of Mime Types...?
+    const isCompressed = ['application/zip', 'application/gzip'].includes(mimeType);
+    return {
+        basename,
+        fileName,
+        fileSize,
+        isCompressed,
+    };
 }
-async function uploadImportFileToS3({
-  app,
-  env,
-  fileMeta,
-  progressCallback,
-  hashType = 'md5'
-}) {
-  let tmpDir;
-  try {
-    tmpDir = await getWorkingTempDir();
-  } catch (err) {
-    throw new Error(`Unable to create temporary working directory: ${err.message}`, {
-      cause: err
-    });
-  }
-  debug(`File ${_chalk.default.cyan(fileMeta.basename)} is ~ ${Math.floor(fileMeta.fileSize / _fileSize.MB_IN_BYTES)} MB\n`);
-
-  // TODO Compression will probably fail over a certain file size... break into pieces...?
-  // TODO if needed add a flag to bypass auto-compression
-
-  if (!fileMeta.isCompressed && fileMeta.fileSize >= COMPRESS_THRESHOLD) {
-    // Compress to the temp dir & annotate `fileMeta`
-    const uncompressedFileName = fileMeta.fileName;
-    const uncompressedFileSize = fileMeta.fileSize;
-    fileMeta.basename = fileMeta.basename.replace(/(.gz)?$/i, '.gz');
-    fileMeta.fileName = _path.default.join(tmpDir, fileMeta.basename);
-    debug(`Compressing the file to ${_chalk.default.cyan(fileMeta.fileName)} prior to transfer...`);
-    await gzipFile(uncompressedFileName, fileMeta.fileName);
-    fileMeta.isCompressed = true;
-    fileMeta.fileSize = await getFileSize(fileMeta.fileName);
-    debug(`Compressed file is ~ ${Math.floor(fileMeta.fileSize / _fileSize.MB_IN_BYTES)} MB\n`);
-    const fewerBytes = uncompressedFileSize - fileMeta.fileSize;
-    const calculation = `${(fewerBytes / _fileSize.MB_IN_BYTES).toFixed(2)}MB (${Math.floor(100 * fewerBytes / uncompressedFileSize)}%)`;
-    debug(`** Compression resulted in a ${calculation} smaller file 📦 **\n`);
-  }
-  debug(`Calculating file ${hashType} checksum...`);
-  const checksum = await getFileHash(fileMeta.fileName, hashType);
-  debug(`Calculated file ${hashType} checksum: ${checksum}\n`);
-  const result = fileMeta.fileSize < MULTIPART_THRESHOLD ? await uploadUsingPutObject({
-    app,
-    env,
-    fileMeta,
-    progressCallback
-  }) : await uploadUsingMultipart({
-    app,
-    env,
-    fileMeta,
-    progressCallback
-  });
-  return {
-    fileMeta,
-    checksum,
-    result
-  };
+async function uploadImportFileToS3({ app, env, fileMeta, progressCallback, hashType = 'md5', }) {
+    let tmpDir;
+    try {
+        tmpDir = await getWorkingTempDir();
+    }
+    catch (err) {
+        throw new Error(`Unable to create temporary working directory: ${err.message}`, { cause: err });
+    }
+    debug(`File ${chalk_1.default.cyan(fileMeta.basename)} is ~ ${Math.floor(fileMeta.fileSize / file_size_1.MB_IN_BYTES)} MB\n`);
+    // TODO Compression will probably fail over a certain file size... break into pieces...?
+    // TODO if needed add a flag to bypass auto-compression
+    if (!fileMeta.isCompressed && fileMeta.fileSize >= exports.COMPRESS_THRESHOLD) {
+        // Compress to the temp dir & annotate `fileMeta`
+        const uncompressedFileName = fileMeta.fileName;
+        const uncompressedFileSize = fileMeta.fileSize;
+        fileMeta.basename = fileMeta.basename.replace(/(.gz)?$/i, '.gz');
+        fileMeta.fileName = path_1.default.join(tmpDir, fileMeta.basename);
+        debug(`Compressing the file to ${chalk_1.default.cyan(fileMeta.fileName)} prior to transfer...`);
+        await gzipFile(uncompressedFileName, fileMeta.fileName);
+        fileMeta.isCompressed = true;
+        fileMeta.fileSize = await getFileSize(fileMeta.fileName);
+        debug(`Compressed file is ~ ${Math.floor(fileMeta.fileSize / file_size_1.MB_IN_BYTES)} MB\n`);
+        const fewerBytes = uncompressedFileSize - fileMeta.fileSize;
+        const calculation = `${(fewerBytes / file_size_1.MB_IN_BYTES).toFixed(2)}MB (${Math.floor((100 * fewerBytes) / uncompressedFileSize)}%)`;
+        debug(`** Compression resulted in a ${calculation} smaller file 📦 **\n`);
+    }
+    debug(`Calculating file ${hashType} checksum...`);
+    const checksum = await (0, exports.getFileHash)(fileMeta.fileName, hashType);
+    debug(`Calculated file ${hashType} checksum: ${checksum}\n`);
+    const result = fileMeta.fileSize < exports.MULTIPART_THRESHOLD
+        ? await uploadUsingPutObject({ app, env, fileMeta, progressCallback })
+        : await uploadUsingMultipart({ app, env, fileMeta, progressCallback });
+    return {
+        fileMeta,
+        checksum,
+        result,
+    };
 }
-
-/**
- * @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html#API_CompleteMultipartUpload_Example_3
- */
-
-async function uploadUsingPutObject({
-  app,
-  env,
-  fileMeta: {
-    basename,
-    fileContent,
-    fileName,
-    fileSize
-  },
-  progressCallback
-}) {
-  debug(`Uploading ${_chalk.default.cyan(basename)} to S3 using the \`PutObject\` command`);
-  const presignedRequest = await getSignedUploadRequestData({
-    appId: app.id,
-    envId: env.id,
-    basename,
-    action: 'PutObject'
-  });
-  const fetchOptions = presignedRequest.options;
-  fetchOptions.headers = {
-    ...fetchOptions.headers,
-    'Content-Length': `${fileSize}` // This has to be a string
-  };
-
-  // Build a fresh request body for every attempt. The upload streams the file
-  // from disk, and a stream can only be consumed once; recreating it per
-  // attempt lets `fetchWithRetry` retry without reusing a consumed stream
-  // (which would otherwise throw `... should not be disturbed or locked`).
-  const createBody = () => {
-    if (fileContent) {
-      return fileContent;
-    }
-    let readBytes = 0;
-    const progressTransform = createProgressTransform(data => {
-      readBytes += data.length;
-      const percentage = `${Math.floor(100 * readBytes / fileSize)}%`;
-      debug(percentage);
-      if (typeof progressCallback === 'function') {
-        progressCallback(percentage);
-      }
+async function uploadUsingPutObject({ app, env, fileMeta: { basename, fileContent, fileName, fileSize }, progressCallback, }) {
+    debug(`Uploading ${chalk_1.default.cyan(basename)} to S3 using the \`PutObject\` command`);
+    const presignedRequest = await getSignedUploadRequestData({
+        appId: app.id,
+        envId: env.id,
+        basename,
+        action: 'PutObject',
     });
-    return (0, _fs.createReadStream)(fileName).pipe(progressTransform);
-  };
-  const response = await fetchWithRetry(presignedRequest.url, fetchOptions, 3, createBody);
-  if (response.status === 200) {
-    return 'ok';
-  }
-  const result = await response.text();
-
-  // TODO is any additional hardening needed here?
-  const parser = new _xml2js.Parser({
-    explicitArray: false,
-    ignoreAttrs: true
-  });
-  let parsedResponse;
-  try {
-    parsedResponse = await parser.parseStringPromise(result);
-  } catch (err) {
-    throw new Error(`Invalid response from cloud service. ${err.message}`, {
-      cause: err
+    const fetchOptions = presignedRequest.options;
+    fetchOptions.headers = {
+        ...fetchOptions.headers,
+        'Content-Length': `${fileSize}`, // This has to be a string
+    };
+    // Build a fresh request body for every attempt. The upload streams the file
+    // from disk, and a stream can only be consumed once; recreating it per
+    // attempt lets `fetchWithRetry` retry without reusing a consumed stream
+    // (which would otherwise throw `... should not be disturbed or locked`).
+    const createBody = () => {
+        if (fileContent) {
+            return fileContent;
+        }
+        let readBytes = 0;
+        const progressTransform = createProgressTransform(data => {
+            readBytes += data.length;
+            const percentage = `${Math.floor((100 * readBytes) / fileSize)}%`;
+            debug(percentage);
+            if (typeof progressCallback === 'function') {
+                progressCallback(percentage);
+            }
+        });
+        return (0, fs_1.createReadStream)(fileName).pipe(progressTransform);
+    };
+    const response = await fetchWithRetry(presignedRequest.url, fetchOptions, 3, createBody);
+    if (response.status === 200) {
+        return 'ok';
+    }
+    const result = await response.text();
+    // TODO is any additional hardening needed here?
+    const parser = new xml2js_1.Parser({
+        explicitArray: false,
+        ignoreAttrs: true,
     });
-  }
-  let Code;
-  let Message;
-  if (parsedResponse?.Error) {
-    ({
-      Code,
-      Message
-    } = parsedResponse.Error);
-  } else {
-    Code = `HTTP Error ${response.status}`;
-    Message = response.statusText;
-  }
-  throw new Error(`Unable to upload to cloud storage. ${JSON.stringify({
-    Code,
-    Message
-  })}`);
+    let parsedResponse;
+    try {
+        parsedResponse = (await parser.parseStringPromise(result));
+    }
+    catch (err) {
+        throw new Error(`Invalid response from cloud service. ${err.message}`, {
+            cause: err,
+        });
+    }
+    let Code;
+    let Message;
+    if (parsedResponse?.Error) {
+        ({ Code, Message } = parsedResponse.Error);
+    }
+    else {
+        Code = `HTTP Error ${response.status}`;
+        Message = response.statusText;
+    }
+    throw new Error(`Unable to upload to cloud storage. ${JSON.stringify({ Code, Message })}`);
 }
-
-/**
- * @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html#API_CreateMultipartUpload_ResponseSyntax
- */
-
-async function uploadUsingMultipart({
-  app,
-  env,
-  fileMeta,
-  progressCallback
-}) {
-  const {
-    basename
-  } = fileMeta;
-  debug(`Uploading ${_chalk.default.cyan(basename)} to S3 using the Multipart API.`);
-  const presignedCreateMultipartUpload = await getSignedUploadRequestData({
-    appId: app.id,
-    envId: env.id,
-    basename,
-    action: 'CreateMultipartUpload'
-  });
-  const multipartUploadResponse = await fetchWithRetry(presignedCreateMultipartUpload.url, presignedCreateMultipartUpload.options);
-  const multipartUploadResult = await multipartUploadResponse.text();
-
-  // TODO is any hardening needed here?
-  const parser = new _xml2js.Parser({
-    explicitArray: false,
-    ignoreAttrs: true
-  });
-  const parsedResponse = await parser.parseStringPromise(multipartUploadResult);
-  if ('Error' in parsedResponse) {
-    const {
-      Code,
-      Message
-    } = parsedResponse.Error;
-    throw new Error(`Unable to create cloud storage object. Error: ${JSON.stringify({
-      Code,
-      Message
-    })}`);
-  }
-  if (!('InitiateMultipartUploadResult' in parsedResponse) || !parsedResponse.InitiateMultipartUploadResult.UploadId) {
-    throw new Error(`Unable to get Upload ID from cloud storage. Error: ${multipartUploadResult}`);
-  }
-  const uploadId = parsedResponse.InitiateMultipartUploadResult.UploadId;
-  debug({
-    uploadId
-  });
-  const parts = getPartBoundaries(fileMeta.fileSize);
-  const etagResults = await uploadParts({
-    app,
-    env,
-    fileMeta,
-    parts,
-    uploadId,
-    progressCallback
-  });
-  debug({
-    etagResults
-  });
-  return completeMultipartUpload({
-    app,
-    env,
-    basename,
-    uploadId,
-    etagResults
-  });
+async function uploadUsingMultipart({ app, env, fileMeta, progressCallback, }) {
+    const { basename } = fileMeta;
+    debug(`Uploading ${chalk_1.default.cyan(basename)} to S3 using the Multipart API.`);
+    const presignedCreateMultipartUpload = await getSignedUploadRequestData({
+        appId: app.id,
+        envId: env.id,
+        basename,
+        action: 'CreateMultipartUpload',
+    });
+    const multipartUploadResponse = await fetchWithRetry(presignedCreateMultipartUpload.url, presignedCreateMultipartUpload.options);
+    const multipartUploadResult = await multipartUploadResponse.text();
+    // TODO is any hardening needed here?
+    const parser = new xml2js_1.Parser({
+        explicitArray: false,
+        ignoreAttrs: true,
+    });
+    const parsedResponse = (await parser.parseStringPromise(multipartUploadResult));
+    if ('Error' in parsedResponse) {
+        const { Code, Message } = parsedResponse.Error;
+        throw new Error(`Unable to create cloud storage object. Error: ${JSON.stringify({ Code, Message })}`);
+    }
+    if (!('InitiateMultipartUploadResult' in parsedResponse) ||
+        !parsedResponse.InitiateMultipartUploadResult.UploadId) {
+        throw new Error(`Unable to get Upload ID from cloud storage. Error: ${multipartUploadResult}`);
+    }
+    const uploadId = parsedResponse.InitiateMultipartUploadResult.UploadId;
+    debug({ uploadId });
+    const parts = getPartBoundaries(fileMeta.fileSize);
+    const etagResults = await uploadParts({
+        app,
+        env,
+        fileMeta,
+        parts,
+        uploadId,
+        progressCallback,
+    });
+    debug({ etagResults });
+    return completeMultipartUpload({
+        app,
+        env,
+        basename,
+        uploadId,
+        etagResults,
+    });
 }
-async function getSignedUploadRequestData({
-  action,
-  appId,
-  basename,
-  envId,
-  etagResults,
-  uploadId = undefined,
-  partNumber = undefined
-}) {
-  const WPVIP_DEPLOY_TOKEN = process.env.WPVIP_DEPLOY_TOKEN;
-  const reqOptions = {
-    method: 'POST',
-    body: {
-      action,
-      appId,
-      basename,
-      envId,
-      etagResults,
-      partNumber,
-      uploadId
-    }
-  };
-  if (WPVIP_DEPLOY_TOKEN) {
-    reqOptions.headers = {
-      Authorization: `Bearer ${WPVIP_DEPLOY_TOKEN}`
+async function getSignedUploadRequestData({ action, appId, basename, envId, etagResults, uploadId = undefined, partNumber = undefined, }, retries = SIGNED_REQUEST_RETRIES) {
+    const WPVIP_DEPLOY_TOKEN = process.env.WPVIP_DEPLOY_TOKEN;
+    const reqOptions = {
+        method: 'POST',
+        body: { action, appId, basename, envId, etagResults, partNumber, uploadId },
     };
-  }
-  const response = await (0, _http.default)('/upload/site-import-presigned-url', reqOptions);
-  if (response.status !== 200) {
-    throw new Error((await response.text()) || response.statusText);
-  }
-  return response.json();
+    if (WPVIP_DEPLOY_TOKEN) {
+        reqOptions.headers = {
+            Authorization: `Bearer ${WPVIP_DEPLOY_TOKEN}`,
+        };
+    }
+    // A large upload makes one of these requests per part, so a single network blip
+    // would otherwise abort the whole upload. The JSON body is re-serialized on every
+    // call, so retrying is safe.
+    for (let attempt = 0;; attempt++) {
+        const isLastAttempt = attempt >= retries;
+        let response;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            response = await (0, http_1.default)('/upload/site-import-presigned-url', reqOptions);
+            if (response.status === 200) {
+                // Body transport failures must stay inside the retry boundary.
+                // eslint-disable-next-line no-await-in-loop
+                return (await response.json());
+            }
+        }
+        catch (err) {
+            if (err instanceof SyntaxError || isLastAttempt) {
+                throw withCauseMessage(err);
+            }
+            response = undefined;
+        }
+        const isRetryableStatus = response && (response.status === 429 || response.status >= 500);
+        if (response && (!isRetryableStatus || isLastAttempt)) {
+            // eslint-disable-next-line no-await-in-loop
+            throw new Error((await response.text()) || response.statusText);
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await response?.body?.cancel().catch(err => debug('Response cleanup failed: %s', err));
+        // eslint-disable-next-line no-await-in-loop
+        await (0, promises_3.setTimeout)(Math.pow(2, attempt) * 1000); // 1000, 2000, 4000
+    }
 }
 async function checkFileAccess(fileName) {
-  return (0, _promises.access)(fileName, _fs.constants.R_OK);
+    return (0, promises_1.access)(fileName, fs_1.constants.R_OK);
 }
 async function isFile(fileName) {
-  try {
-    const stats = await (0, _promises.stat)(fileName);
-    return stats.isFile();
-  } catch (err) {
-    debug(`isFile error: ${err.message}`);
-    return false;
-  }
+    try {
+        const stats = await (0, promises_1.stat)(fileName);
+        return stats.isFile();
+    }
+    catch (err) {
+        debug(`isFile error: ${err.message}`);
+        return false;
+    }
 }
 async function getFileSize(fileName) {
-  const stats = await (0, _promises.stat)(fileName);
-  return stats.size;
+    const stats = await (0, promises_1.stat)(fileName);
+    return stats.size;
 }
 async function detectCompressedMimeType(fileName) {
-  const ZIP_MAGIC_NUMBER = '504b0304';
-  const GZ_MAGIC_NUMBER = '1f8b';
-  const file = await (0, _promises.open)(fileName, 'r');
-  const {
-    buffer
-  } = await file.read(Buffer.alloc(4), 0, 4, 0);
-  const fileHeader = buffer.toString('hex');
-  await file.close();
-  if (ZIP_MAGIC_NUMBER === fileHeader.slice(0, ZIP_MAGIC_NUMBER.length)) {
-    return 'application/zip';
-  }
-  if (GZ_MAGIC_NUMBER === fileHeader.slice(0, GZ_MAGIC_NUMBER.length)) {
-    return 'application/gzip';
-  }
-  return '';
+    const ZIP_MAGIC_NUMBER = '504b0304';
+    const GZ_MAGIC_NUMBER = '1f8b';
+    const file = await (0, promises_1.open)(fileName, 'r');
+    const { buffer } = await file.read(Buffer.alloc(4), 0, 4, 0);
+    const fileHeader = buffer.toString('hex');
+    await file.close();
+    if (ZIP_MAGIC_NUMBER === fileHeader.slice(0, ZIP_MAGIC_NUMBER.length)) {
+        return 'application/zip';
+    }
+    if (GZ_MAGIC_NUMBER === fileHeader.slice(0, GZ_MAGIC_NUMBER.length)) {
+        return 'application/gzip';
+    }
+    return '';
 }
 function getPartBoundaries(fileSize) {
-  if (fileSize < 1) {
-    throw new Error('fileSize must be greater than zero');
-  }
-  const numParts = Math.ceil(fileSize / UPLOAD_PART_SIZE);
-  return new Array(numParts).fill(undefined).map((_numPart, index) => {
-    const start = index * UPLOAD_PART_SIZE;
-    const remaining = fileSize - start;
-    const end = (remaining > UPLOAD_PART_SIZE ? start + UPLOAD_PART_SIZE : start + remaining) - 1;
-    const partSize = end + 1 - start;
-    return {
-      end,
-      index,
-      partSize,
-      start
+    if (fileSize < 1) {
+        throw new Error('fileSize must be greater than zero');
+    }
+    const numParts = Math.ceil(fileSize / UPLOAD_PART_SIZE);
+    return new Array(numParts).fill(undefined).map((_numPart, index) => {
+        const start = index * UPLOAD_PART_SIZE;
+        const remaining = fileSize - start;
+        const end = (remaining > UPLOAD_PART_SIZE ? start + UPLOAD_PART_SIZE : start + remaining) - 1;
+        const partSize = end + 1 - start;
+        return { end, index, partSize, start };
+    });
+}
+async function uploadParts({ app, env, fileMeta, uploadId, parts, progressCallback, }) {
+    let uploadsInProgress = 0;
+    const partPercentages = new Array(parts.length).fill(0);
+    const partBytesRead = new Array(parts.length).fill(0);
+    const readyForPartUpload = () => new Promise(resolve => {
+        const canDoInterval = (0, node_timers_1.setInterval)(() => {
+            if (uploadsInProgress < MAX_CONCURRENT_PART_UPLOADS) {
+                uploadsInProgress++;
+                (0, node_timers_1.clearInterval)(canDoInterval);
+                resolve();
+            }
+        }, 300);
+    });
+    const updateProgress = () => {
+        const totalBytesRead = partBytesRead.reduce((sum, bytes) => sum + bytes, 0);
+        const percentage = `${Math.floor((100 * totalBytesRead) / fileMeta.fileSize)}%`;
+        if (typeof progressCallback === 'function') {
+            progressCallback(percentage);
+        }
+        debug(partPercentages
+            .map((partPercentage, index) => {
+            const { partSize } = parts[index];
+            return `Part # ${index}: ${partPercentage}% of ${(partSize / file_size_1.MB_IN_BYTES).toFixed(2)}MB`;
+        })
+            .join('\n') +
+            `\n\nOverall Progress: ${percentage}% of ${(fileMeta.fileSize / file_size_1.MB_IN_BYTES).toFixed(2)}MB`);
     };
-  });
+    const updateProgressInterval = (0, node_timers_1.setInterval)(updateProgress, 500);
+    const allDone = await Promise.all(parts.map(async (part) => {
+        const { index, partSize, start, end } = part;
+        // Build a fresh request body for every attempt. A stream can only be
+        // consumed once, so recreating the ranged read stream (and its progress
+        // PassThrough) per attempt lets `fetchWithRetry` retry without reusing a
+        // disturbed/locked stream. Reset this part's progress counters so a retry
+        // re-streams the part without double-counting bytes.
+        const createBody = () => {
+            partBytesRead[index] = 0;
+            partPercentages[index] = 0;
+            const progressTransform = createProgressTransform(data => {
+                partBytesRead[index] += data.length;
+                partPercentages[index] = Math.floor((100 * partBytesRead[index]) / partSize);
+            });
+            return (0, fs_1.createReadStream)(fileMeta.fileName, { start, end }).pipe(progressTransform);
+        };
+        await readyForPartUpload();
+        const uploadResult = await uploadPart({
+            app,
+            env,
+            fileMeta,
+            part,
+            createBody,
+            uploadId,
+        });
+        uploadsInProgress--;
+        return uploadResult;
+    }));
+    (0, node_timers_1.clearInterval)(updateProgressInterval);
+    updateProgress();
+    return allDone;
 }
-async function uploadParts({
-  app,
-  env,
-  fileMeta,
-  uploadId,
-  parts,
-  progressCallback
-}) {
-  let uploadsInProgress = 0;
-  const partPercentages = new Array(parts.length).fill(0);
-  const partBytesRead = new Array(parts.length).fill(0);
-  const readyForPartUpload = () => new Promise(resolve => {
-    const canDoInterval = (0, _nodeTimers.setInterval)(() => {
-      if (uploadsInProgress < MAX_CONCURRENT_PART_UPLOADS) {
-        uploadsInProgress++;
-        (0, _nodeTimers.clearInterval)(canDoInterval);
-        resolve();
-      }
-    }, 300);
-  });
-  const updateProgress = () => {
-    const totalBytesRead = partBytesRead.reduce((sum, bytes) => sum + bytes, 0);
-    const percentage = `${Math.floor(100 * totalBytesRead / fileMeta.fileSize)}%`;
-    if (typeof progressCallback === 'function') {
-      progressCallback(percentage);
-    }
-    debug(partPercentages.map((partPercentage, index) => {
-      const {
-        partSize
-      } = parts[index];
-      return `Part # ${index}: ${partPercentage}% of ${(partSize / _fileSize.MB_IN_BYTES).toFixed(2)}MB`;
-    }).join('\n') + `\n\nOverall Progress: ${percentage}% of ${(fileMeta.fileSize / _fileSize.MB_IN_BYTES).toFixed(2)}MB`);
-  };
-  const updateProgressInterval = (0, _nodeTimers.setInterval)(updateProgress, 500);
-  const allDone = await Promise.all(parts.map(async part => {
-    const {
-      index,
-      partSize,
-      start,
-      end
-    } = part;
-
-    // Build a fresh request body for every attempt. A stream can only be
-    // consumed once, so recreating the ranged read stream (and its progress
-    // PassThrough) per attempt lets `fetchWithRetry` retry without reusing a
-    // disturbed/locked stream. Reset this part's progress counters so a retry
-    // re-streams the part without double-counting bytes.
-    const createBody = () => {
-      partBytesRead[index] = 0;
-      partPercentages[index] = 0;
-      const progressTransform = createProgressTransform(data => {
-        partBytesRead[index] += data.length;
-        partPercentages[index] = Math.floor(100 * partBytesRead[index] / partSize);
-      });
-      return (0, _fs.createReadStream)(fileMeta.fileName, {
-        start,
-        end
-      }).pipe(progressTransform);
+async function uploadPart({ app, env, fileMeta: { basename }, part, createBody, uploadId, }) {
+    const { index, partSize } = part;
+    const s3PartNumber = index + 1; // S3 multipart is indexed from 1
+    // TODO: handle failures / retries, etc.
+    const doUpload = async () => {
+        // Get the signed request data from Parker
+        const partUploadRequestData = await getSignedUploadRequestData({
+            action: 'UploadPart',
+            appId: app.id,
+            envId: env.id,
+            basename,
+            partNumber: s3PartNumber,
+            uploadId,
+        });
+        const fetchOptions = partUploadRequestData.options;
+        fetchOptions.headers = {
+            ...fetchOptions.headers,
+            'Content-Length': `${partSize}`, // This has to be a string
+            /**
+             * TODO? 'Content-MD5': Buffer.from( ... ).toString( 'base64' ),
+             * Content-MD5 has to be base64 encoded.
+             * It's the hash of the entire request object & has to be included in the signature,
+             *   ...so it may not be feasible to include with presigned requests.
+             */
+        };
+        const fetchResponse = await fetchWithRetry(partUploadRequestData.url, fetchOptions, 3, createBody);
+        if (fetchResponse.status === 200) {
+            const etag = fetchResponse.headers.get('etag');
+            if (!etag) {
+                throw new Error('Unable to upload file part. Missing ETag response header.');
+            }
+            return parseEtagHeader(etag);
+        }
+        const result = await fetchResponse.text();
+        // TODO is any hardening needed here?
+        const parser = new xml2js_1.Parser({
+            explicitArray: false,
+            ignoreAttrs: true,
+        });
+        const parsed = (await parser.parseStringPromise(result));
+        const { Code, Message } = parsed.Error;
+        throw new Error(`Unable to upload file part. Error: ${JSON.stringify({ Code, Message })}`);
+    };
+    return {
+        ETag: await doUpload(),
+        PartNumber: s3PartNumber,
     };
-    await readyForPartUpload();
-    const uploadResult = await uploadPart({
-      app,
-      env,
-      fileMeta,
-      part,
-      createBody,
-      uploadId
-    });
-    uploadsInProgress--;
-    return uploadResult;
-  }));
-  (0, _nodeTimers.clearInterval)(updateProgressInterval);
-  updateProgress();
-  return allDone;
 }
-async function uploadPart({
-  app,
-  env,
-  fileMeta: {
-    basename
-  },
-  part,
-  createBody,
-  uploadId
-}) {
-  const {
-    index,
-    partSize
-  } = part;
-  const s3PartNumber = index + 1; // S3 multipart is indexed from 1
-
-  // TODO: handle failures / retries, etc.
-  const doUpload = async () => {
-    // Get the signed request data from Parker
-    const partUploadRequestData = await getSignedUploadRequestData({
-      action: 'UploadPart',
-      appId: app.id,
-      envId: env.id,
-      basename,
-      partNumber: s3PartNumber,
-      uploadId
+async function completeMultipartUpload({ app, env, basename, uploadId, etagResults, }) {
+    const completeMultipartUploadRequestData = await getSignedUploadRequestData({
+        action: 'CompleteMultipartUpload',
+        appId: app.id,
+        envId: env.id,
+        basename,
+        uploadId,
+        etagResults,
     });
-    const fetchOptions = partUploadRequestData.options;
-    fetchOptions.headers = {
-      ...fetchOptions.headers,
-      'Content-Length': `${partSize}` // This has to be a string
-      /**
-       * TODO? 'Content-MD5': Buffer.from( ... ).toString( 'base64' ),
-       * Content-MD5 has to be base64 encoded.
-       * It's the hash of the entire request object & has to be included in the signature,
-       *   ...so it may not be feasible to include with presigned requests.
-       */
-    };
-    const fetchResponse = await fetchWithRetry(partUploadRequestData.url, fetchOptions, 3, createBody);
-    if (fetchResponse.status === 200) {
-      const etag = fetchResponse.headers.get('etag');
-      if (!etag) {
-        throw new Error('Unable to upload file part. Missing ETag response header.');
-      }
-      return parseEtagHeader(etag);
-    }
-    const result = await fetchResponse.text();
-
-    // TODO is any hardening needed here?
-    const parser = new _xml2js.Parser({
-      explicitArray: false,
-      ignoreAttrs: true
+    const completeMultipartUploadResponse = await fetchWithRetry(completeMultipartUploadRequestData.url, completeMultipartUploadRequestData.options);
+    if (completeMultipartUploadResponse.status !== 200) {
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
+        throw await completeMultipartUploadResponse.text();
+    }
+    /**
+     * Processing of a Complete Multipart Upload request could take several minutes to complete.
+     * After Amazon S3 begins processing the request, it sends an HTTP response header that specifies a 200 OK response.
+     * While processing is in progress, Amazon S3 periodically sends white space characters to keep the connection from timing out.
+     * Because a request could fail after the initial 200 OK response has been sent, it is important that you check the
+     * response body to determine whether the request succeeded.
+     * Note that if CompleteMultipartUpload fails, applications should be prepared to retry the failed requests.
+     *
+     * https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html
+     */
+    const result = await completeMultipartUploadResponse.text();
+    const parser = new xml2js_1.Parser({
+        explicitArray: false,
+        ignoreAttrs: true,
     });
-    const parsed = await parser.parseStringPromise(result);
-    const {
-      Code,
-      Message
-    } = parsed.Error;
-    throw new Error(`Unable to upload file part. Error: ${JSON.stringify({
-      Code,
-      Message
-    })}`);
-  };
-  return {
-    ETag: await doUpload(),
-    PartNumber: s3PartNumber
-  };
+    const parsed = (await parser.parseStringPromise(result));
+    if ('Error' in parsed) {
+        const { Code, Message } = parsed.Error;
+        throw new Error(`Unable to complete the upload. Error: ${JSON.stringify({ Code, Message })}`);
+    }
+    return parsed;
 }
-
-/**
- * @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html#API_CompleteMultipartUpload_ResponseSyntax
- */
-
-async function completeMultipartUpload({
-  app,
-  env,
-  basename,
-  uploadId,
-  etagResults
-}) {
-  const completeMultipartUploadRequestData = await getSignedUploadRequestData({
-    action: 'CompleteMultipartUpload',
-    appId: app.id,
-    envId: env.id,
-    basename,
-    uploadId,
-    etagResults
-  });
-  const completeMultipartUploadResponse = await fetchWithRetry(completeMultipartUploadRequestData.url, completeMultipartUploadRequestData.options);
-  if (completeMultipartUploadResponse.status !== 200) {
-    // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw await completeMultipartUploadResponse.text();
-  }
-
-  /**
-   * Processing of a Complete Multipart Upload request could take several minutes to complete.
-   * After Amazon S3 begins processing the request, it sends an HTTP response header that specifies a 200 OK response.
-   * While processing is in progress, Amazon S3 periodically sends white space characters to keep the connection from timing out.
-   * Because a request could fail after the initial 200 OK response has been sent, it is important that you check the
-   * response body to determine whether the request succeeded.
-   * Note that if CompleteMultipartUpload fails, applications should be prepared to retry the failed requests.
-   *
-   * https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html
-   */
-  const result = await completeMultipartUploadResponse.text();
-  const parser = new _xml2js.Parser({
-    explicitArray: false,
-    ignoreAttrs: true
-  });
-  const parsed = await parser.parseStringPromise(result);
-  if ('Error' in parsed) {
-    const {
-      Code,
-      Message
-    } = parsed.Error;
-    throw new Error(`Unable to complete the upload. Error: ${JSON.stringify({
-      Code,
-      Message
-    })}`);
-  }
-  return parsed;
-}