@google-cloud/cloud-run-mcp 1.2.0 → 1.5.0

package/lib/cloud-run-deploy.js

@@ -14,6 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { callWithRetry, ensureApisEnabled } from './gcp-api-helpers.js';
+
 // Configuration
 const REPO_NAME = 'mcp-cloud-run-deployments';
 const ZIP_FILE_NAME = 'source.zip';
@@ -46,7 +48,7 @@ let runClient;
  * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
  * @param {'debug' | 'info' | 'warn' | 'error'} [severity='info'] - The severity level of the message.
  */
-function logAndProgress(message, progressCallback, severity = 'info') {
+async function logAndProgress(message, progressCallback, severity = 'info') {
   switch (severity) {
     case 'error':
       console.error(message);
@@ -63,91 +65,6 @@ function logAndProgress(message, progressCallback, severity = 'info') {
   }
 }
 
-/**
- * Checks if a single Google Cloud API is enabled and enables it if not.
- *
- * @param {object} serviceUsageClient - The Service Usage client.
- * @param {string} serviceName - The full name of the service (e.g., 'projects/my-project/services/run.googleapis.com').
- * @param {string} api - The API identifier (e.g., 'run.googleapis.com').
- * @param {function(string, string=): void} progressCallback - A function to call with progress updates.
- * @returns {Promise<void>} A promise that resolves when the API is enabled.
- * @throws {Error} If the API fails to enable or if there's an issue checking its status.
- */
-async function checkAndEnableApi(
-  serviceUsageClient,
-  serviceName,
-  api,
-  progressCallback
-) {
-  const [service] = await serviceUsageClient.getService({
-    name: serviceName,
-  });
-  if (service.state !== 'ENABLED') {
-    logAndProgress(
-      `API [${api}] is not enabled. Enabling...`,
-      progressCallback
-    );
-    const [operation] = await serviceUsageClient.enableService({
-      name: serviceName,
-    });
-    await operation.promise();
-  }
-}
-
-/**
- * Ensures that the specified Google Cloud APIs are enabled for the given project.
- * If an API is not enabled, it attempts to enable it.  Retries any failure once after 1s.
- * Throws an error if an API cannot be enabled.
- *
- * @async
- * @param {string} projectId - The Google Cloud project ID.
- * @param {string[]} apis - An array of API identifiers to check and enable (e.g., 'run.googleapis.com').
- * @param {function(string, string=): void} progressCallback - A function to call with progress updates.
- * The first argument is the message, the optional second argument is the type ('error', 'warning', 'info').
- * @throws {Error} If an API fails to enable or if there's an issue checking its status.
- * @returns {Promise<void>} A promise that resolves when all specified APIs are enabled.
- */
-async function ensureApisEnabled(projectId, apis, progressCallback) {
-  const { ServiceUsageClient } = await import('@google-cloud/service-usage');
-  const serviceUsageClient = new ServiceUsageClient({ projectId });
-  logAndProgress('Checking and enabling required APIs...', progressCallback);
-
-  for (const api of apis) {
-    const serviceName = `projects/${projectId}/services/${api}`;
-    try {
-      await checkAndEnableApi(
-        serviceUsageClient,
-        serviceName,
-        api,
-        progressCallback
-      );
-    } catch (error) {
-      // First attempt failed, log a warning and retry once after a delay.
-      logAndProgress(
-        `Failed to check/enable ${api}, retrying in 1s...`,
-        progressCallback,
-        'warn'
-      );
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      try {
-        await checkAndEnableApi(
-          serviceUsageClient,
-          serviceName,
-          api,
-          progressCallback
-        );
-      } catch (retryError) {
-        // If the retry also fails, throw an error.
-        const errorMessage = `Failed to ensure API [${api}] is enabled after retry. Please check manually.`;
-        console.error(errorMessage, retryError);
-        logAndProgress(errorMessage, progressCallback, 'error');
-        throw new Error(errorMessage);
-      }
-    }
-  }
-  logAndProgress('All required APIs are enabled.', progressCallback);
-}
-
 /**
  * Checks if a Cloud Run service already exists.
  *
@@ -168,15 +85,18 @@ async function checkCloudRunServiceExists(
   const parent = runClient.locationPath(projectId, location);
   const servicePath = runClient.servicePath(projectId, location, serviceId);
   try {
-    await runClient.getService({ name: servicePath });
-    logAndProgress(
+    await callWithRetry(
+      () => runClient.getService({ name: servicePath }),
+      `getService ${serviceId}`
+    );
+    await logAndProgress(
       `Cloud Run service ${serviceId} already exists.`,
       progressCallback
     );
     return true;
   } catch (error) {
     if (error.code === 5) {
-      logAndProgress(
+      await logAndProgress(
         `Cloud Run service ${serviceId} does not exist.`,
         progressCallback
       );
@@ -184,7 +104,7 @@ async function checkCloudRunServiceExists(
     }
     const errorMessage = `Error checking Cloud Run service ${serviceId}: ${error.message}`;
     console.error(`Error checking Cloud Run service ${serviceId}:`, error);
-    logAndProgress(errorMessage, progressCallback, 'error');
+    await logAndProgress(errorMessage, progressCallback, 'error');
     throw error;
   }
 }
@@ -240,7 +160,7 @@ async function deployToCloudRun(
 
     // Always perform a dry run first for general validation
     try {
-      logAndProgress(
+      await logAndProgress(
         `Performing dry run for service ${serviceId}...`,
         progressCallback,
         'debug'
@@ -249,25 +169,33 @@ async function deployToCloudRun(
 
       if (exists) {
         dryRunServiceConfig.name = servicePath;
-        await runClient.updateService({
-          service: dryRunServiceConfig,
-          validateOnly: true,
-        });
+        await callWithRetry(
+          () =>
+            runClient.updateService({
+              service: dryRunServiceConfig,
+              validateOnly: true,
+            }),
+          `updateService (dry run) ${serviceId}`
+        );
       } else {
-        await runClient.createService({
-          parent: parent,
-          service: dryRunServiceConfig,
-          serviceId: serviceId,
-          validateOnly: true,
-        });
+        await callWithRetry(
+          () =>
+            runClient.createService({
+              parent: parent,
+              service: dryRunServiceConfig,
+              serviceId: serviceId,
+              validateOnly: true,
+            }),
+          `createService (dry run) ${serviceId}`
+        );
       }
-      logAndProgress(
+      await logAndProgress(
         `Dry run successful for ${serviceId} with current configuration.`,
         progressCallback,
         'debug'
       );
     } catch (dryRunError) {
-      logAndProgress(
+      await logAndProgress(
         `Dry run for ${serviceId} failed: ${dryRunError.message}`,
         progressCallback,
         'warn'
@@ -281,7 +209,7 @@ async function deployToCloudRun(
           dryRunError.message.toLowerCase().includes('iam policy violation') ||
           dryRunError.code === 3) /* INVALID_ARGUMENT */
       ) {
-        logAndProgress(
+        await logAndProgress(
           `Dry run suggests 'invokerIamDisabled' is not allowed or invalid. Attempting deployment without it.`,
           progressCallback,
           'warn'
@@ -290,32 +218,42 @@ async function deployToCloudRun(
       } else {
         // For any other validation errors, rethrow to stop the deployment
         const errorMessage = `Dry run validation failed for service ${serviceId}: ${dryRunError.message}`;
-        logAndProgress(errorMessage, progressCallback, 'error');
+        await logAndProgress(errorMessage, progressCallback, 'error');
         throw new Error(errorMessage);
       }
     }
 
     let operation;
     if (exists) {
-      logAndProgress(
+      await logAndProgress(
         `Updating existing service ${serviceId}...`,
         progressCallback
       );
       service.name = servicePath;
-      [operation] = await runClient.updateService({ service });
+      [operation] = await callWithRetry(
+        () => runClient.updateService({ service }),
+        `updateService ${serviceId}`
+      );
     } else {
-      logAndProgress(`Creating new service ${serviceId}...`, progressCallback);
-      [operation] = await runClient.createService({
-        parent: parent,
-        service: service, // 'service' object might have invokerIamDisabled removed
-        serviceId: serviceId,
-      });
+      await logAndProgress(`Creating new service ${serviceId}...`, progressCallback);
+      [operation] = await callWithRetry(
+        () =>
+          runClient.createService({
+            parent: parent,
+            service: service, // 'service' object might have invokerIamDisabled removed
+            serviceId: serviceId,
+          }),
+        `createService ${serviceId}`
+      );
     }
 
-    logAndProgress(`Deploying ${serviceId} to Cloud Run...`, progressCallback);
+    await logAndProgress(
+      `Deploying ${serviceId} to Cloud Run...`,
+      progressCallback
+    );
     const [response] = await operation.promise();
 
-    logAndProgress(
+    await logAndProgress(
       `Service deployed/updated successfully: ${response.uri}`,
       progressCallback
     );
@@ -323,7 +261,7 @@ async function deployToCloudRun(
   } catch (error) {
     const errorMessage = `Error deploying/updating service ${serviceId}: ${error.message}`;
     console.error(`Error deploying/updating service ${serviceId}:`, error);
-    logAndProgress(errorMessage, progressCallback, 'error');
+    await logAndProgress(errorMessage, progressCallback, 'error');
     throw error;
   }
 }
@@ -346,20 +284,27 @@ async function ensureStorageBucketExists(
 ) {
   const bucket = storage.bucket(bucketName);
   try {
-    const [exists] = await bucket.exists();
+    const [exists] = await callWithRetry(
+      () => bucket.exists(),
+      `storage.bucket.exists ${bucketName}`
+    );
     if (exists) {
-      logAndProgress(`Bucket ${bucketName} already exists.`, progressCallback);
+      await logAndProgress(
+        `Bucket ${bucketName} already exists.`,
+        progressCallback
+      );
       return bucket;
     } else {
-      logAndProgress(
+      await logAndProgress(
         `Bucket ${bucketName} does not exist. Creating in location ${location}...`,
         progressCallback
       );
       try {
-        const [createdBucket] = await storage.createBucket(bucketName, {
-          location: location,
-        });
-        logAndProgress(
+        const [createdBucket] = await callWithRetry(
+          () => storage.createBucket(bucketName, { location: location }),
+          `storage.createBucket ${bucketName}`
+        );
+        await logAndProgress(
           `Storage bucket ${createdBucket.name} created successfully in ${location}.`,
           progressCallback
         );
@@ -370,14 +315,14 @@ async function ensureStorageBucketExists(
           `Failed to create storage bucket ${bucketName}. Error details:`,
           createError
         );
-        logAndProgress(errorMessage, progressCallback, 'error');
+        await logAndProgress(errorMessage, progressCallback, 'error');
         throw createError;
       }
     }
   } catch (error) {
     const errorMessage = `Error checking/creating bucket ${bucketName}: ${error.message}`;
     console.error(`Error checking/creating bucket ${bucketName}:`, error);
-    logAndProgress(errorMessage, progressCallback, 'error');
+    await logAndProgress(errorMessage, progressCallback, 'error');
     throw error;
   }
 }
@@ -478,12 +423,15 @@ async function uploadToStorageBucket(
   progressCallback
 ) {
   try {
-    logAndProgress(
+    await logAndProgress(
       `Uploading buffer to gs://${bucket.name}/${destinationBlobName}...`,
       progressCallback
     );
-    await bucket.file(destinationBlobName).save(buffer);
-    logAndProgress(
+    await callWithRetry(
+      () => bucket.file(destinationBlobName).save(buffer),
+      `storage.bucket.file.save ${destinationBlobName}`
+    );
+    await logAndProgress(
       `File ${destinationBlobName} uploaded successfully to gs://${bucket.name}/${destinationBlobName}.`,
       progressCallback
     );
@@ -491,7 +439,7 @@ async function uploadToStorageBucket(
   } catch (error) {
     const errorMessage = `Error uploading buffer: ${error.message}`;
     console.error(`Error uploading buffer:`, error);
-    logAndProgress(errorMessage, progressCallback, 'error');
+    await logAndProgress(errorMessage, progressCallback, 'error');
     throw error;
   }
 }
@@ -524,70 +472,51 @@ async function ensureArtifactRegistryRepoExists(
   );
 
   try {
-    const [repository] = await artifactRegistryClient.getRepository({
-      name: repoPath,
-    });
-    logAndProgress(
+    const [repository] = await callWithRetry(
+      () => artifactRegistryClient.getRepository({ name: repoPath }),
+      `artifactRegistry.getRepository ${repositoryId}`
+    );
+    await logAndProgress(
       `Repository ${repositoryId} already exists in ${location}.`,
       progressCallback
     );
     return repository;
   } catch (error) {
     if (error.code === 5) {
-      logAndProgress(
+      await logAndProgress(
         `Repository ${repositoryId} does not exist in ${location}. Creating...`,
         progressCallback
       );
       const repositoryToCreate = {
         format: format,
       };
-      const maxRetries = 3;
-      const retryDelay = 10000; // 10s
 
-      for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        try {
-          const [operation] = await artifactRegistryClient.createRepository({
+      const [operation] = await callWithRetry(
+        () =>
+          artifactRegistryClient.createRepository({
             parent: parent,
             repository: repositoryToCreate,
             repositoryId: repositoryId,
-          });
-          logAndProgress(
-            `Creating Artifact Registry repository ${repositoryId}...`,
-            progressCallback
-          );
-          const [result] = await operation.promise();
-          logAndProgress(
-            `Artifact Registry repository ${result.name} created successfully.`,
-            progressCallback
-          );
-          return result;
-        } catch (createError) {
-          // PERMISSION_DENIED is code 7 for gRPC. Retry on this error.
-          if (createError.code === 7 && attempt < maxRetries) {
-            logAndProgress(
-              `Attempt ${attempt} to create repository failed. This can happen on new projects. Retrying in 10s...`,
-              progressCallback,
-              'warn'
-            );
-            await new Promise((resolve) => setTimeout(resolve, retryDelay));
-          } else {
-            const errorMessage = `Failed to create Artifact Registry repository ${repositoryId}. Error details: ${createError.message}`;
-            console.error(
-              `Failed to create Artifact Registry repository ${repositoryId}. Error details:`,
-              createError
-            );
-            logAndProgress(errorMessage, progressCallback, 'error');
-            throw createError;
-          }
-        }
-      }
+          }),
+        `artifactRegistry.createRepository ${repositoryId}`
+      );
+      await logAndProgress(
+        `Creating Artifact Registry repository ${repositoryId}...`,
+        progressCallback
+      );
+      const [result] = await operation.promise();
+      await logAndProgress(
+        `Artifact Registry repository ${result.name} created successfully.`,
+        progressCallback
+      );
+      return result;
     } else {
       const errorMessage = `Error checking/creating repository ${repositoryId}: ${error.message}`;
       console.error(
         `Error checking/creating repository ${repositoryId}:`,
         error
       );
-      logAndProgress(errorMessage, progressCallback, 'error');
+      await logAndProgress(errorMessage, progressCallback, 'error');
       throw error;
     }
   }
@@ -657,23 +586,23 @@ async function triggerCloudBuild(
     images: [targetImageUrl],
   };
 
-  logAndProgress(
+  await logAndProgress(
     `Initiating Cloud Build for gs://${sourceBucketName}/${sourceBlobName} in ${location}...`,
     progressCallback
   );
-  const [operation] = await cloudBuildClient.createBuild({
-    projectId: projectId,
-    build: build,
-  });
+  const [operation] = await callWithRetry(
+    () => cloudBuildClient.createBuild({ projectId: projectId, build: build }),
+    'cloudBuild.createBuild'
+  );
 
-  logAndProgress(`Cloud Build job started...`, progressCallback);
+  await logAndProgress(`Cloud Build job started...`, progressCallback);
   const buildId = operation.metadata.build.id;
   let completedBuild;
   while (true) {
-    const [getBuildOperation] = await cloudBuildClient.getBuild({
-      projectId: projectId,
-      id: buildId,
-    });
+    const [getBuildOperation] = await callWithRetry(
+      () => cloudBuildClient.getBuild({ projectId: projectId, id: buildId }),
+      `cloudBuild.getBuild ${buildId}`
+    );
     if (
       ['SUCCESS', 'FAILURE', 'INTERNAL_ERROR', 'TIMEOUT', 'CANCELLED'].includes(
         getBuildOperation.status
@@ -682,7 +611,7 @@ async function triggerCloudBuild(
       completedBuild = getBuildOperation;
       break;
     }
-    logAndProgress(
+    await logAndProgress(
       `Build status: ${getBuildOperation.status}. Waiting...`,
       progressCallback,
       'debug'
@@ -691,20 +620,20 @@ async function triggerCloudBuild(
   }
 
   if (completedBuild.status === 'SUCCESS') {
-    logAndProgress(
+    await logAndProgress(
       `Cloud Build job ${buildId} completed successfully.`,
       progressCallback
     );
-    logAndProgress(
+    await logAndProgress(
       `Image built: ${completedBuild.results.images[0].name}`,
       progressCallback
     );
     return completedBuild;
   } else {
     const failureMessage = `Cloud Build job ${buildId} failed with status: ${completedBuild.status}`;
-    logAndProgress(failureMessage, progressCallback, 'error');
+    await logAndProgress(failureMessage, progressCallback, 'error');
     const logsMessage = `Build logs: ${completedBuild.logUrl}`;
-    logAndProgress(logsMessage, progressCallback); // Log URL is info, failure is error
+    await logAndProgress(logsMessage, progressCallback); // Log URL is info, failure is error
 
     let buildLogsSnippet = `\n\nRefer to Log URL for full details: ${completedBuild.logUrl}`; // Default snippet
     try {
@@ -712,7 +641,7 @@ async function triggerCloudBuild(
       const loggingClient = new Logging({ projectId });
 
       const logFilter = `resource.type="build" AND resource.labels.build_id="${buildId}"`;
-      logAndProgress(
+      await logAndProgress(
         `Attempting to fetch last ${BUILD_LOGS_LINES_TO_FETCH} log lines for build ${buildId}...`,
         progressCallback,
         'debug'
@@ -724,25 +653,29 @@ async function triggerCloudBuild(
       );
 
       // Fetch the most recent N log entries
-      const [entries] = await loggingClient.getEntries({
-        filter: logFilter,
-        orderBy: 'timestamp desc', // Get latest logs first
-        pageSize: BUILD_LOGS_LINES_TO_FETCH,
-      });
+      const [entries] = await callWithRetry(
+        () =>
+          loggingClient.getEntries({
+            filter: logFilter,
+            orderBy: 'timestamp desc', // Get latest logs first
+            pageSize: BUILD_LOGS_LINES_TO_FETCH,
+          }),
+        `logging.getEntries for build ${buildId}`
+      );
 
       if (entries && entries.length > 0) {
         // Entries are newest first, reverse for chronological order of the snippet
         const logLines = entries.reverse().map((entry) => entry.data || '');
         if (logLines.length > 0) {
           buildLogsSnippet = `\n\nLast ${logLines.length} log lines from build ${buildId}:\n${logLines.join('\n')}`;
-          logAndProgress(
+          await logAndProgress(
             `Successfully fetched snippet of build logs for ${buildId}.`,
             progressCallback,
             'info'
           );
         }
       } else {
-        logAndProgress(
+        await logAndProgress(
           `No specific log entries retrieved for build ${buildId}. ${buildLogsSnippet}`,
           progressCallback,
           'warn'
@@ -750,7 +683,7 @@ async function triggerCloudBuild(
       }
     } catch (logError) {
       console.error(`Error fetching build logs for ${buildId}:`, logError);
-      logAndProgress(
+      await logAndProgress(
         `Failed to fetch build logs snippet: ${logError.message}. ${buildLogsSnippet}`,
         progressCallback,
         'warn'
@@ -783,14 +716,21 @@ export async function deploy({
   if (!projectId) {
     const errorMsg =
       'Error: projectId is required in the configuration object.';
-    logAndProgress(errorMsg, progressCallback, 'error');
-    process.exit(1);
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw new Error(errorMsg);
+  }
+
+  if (!serviceName) {
+    const errorMsg =
+      'Error: serviceName is required in the configuration object.';
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw new Error(errorMsg);
   }
 
   if (!files || !Array.isArray(files) || files.length === 0) {
     const errorMsg =
       'Error: files array is required in the configuration object.';
-    logAndProgress(errorMsg, progressCallback, 'error');
+    await logAndProgress(errorMsg, progressCallback, 'error');
     if (typeof process !== 'undefined' && process.exit) {
       process.exit(1);
     } else {
@@ -823,10 +763,10 @@ export async function deploy({
     const bucketName = `${projectId}-source-bucket`;
     const imageUrl = `${region}-docker.pkg.dev/${projectId}/${REPO_NAME}/${serviceName}:${IMAGE_TAG}`;
 
-    logAndProgress(`Project: ${projectId}`, progressCallback);
-    logAndProgress(`Region: ${region}`, progressCallback);
-    logAndProgress(`Service Name: ${serviceName}`, progressCallback);
-    logAndProgress(`Files to deploy: ${files.length}`, progressCallback);
+    await logAndProgress(`Project: ${projectId}`, progressCallback);
+    await logAndProgress(`Region: ${region}`, progressCallback);
+    await logAndProgress(`Service Name: ${serviceName}`, progressCallback);
+    await logAndProgress(`Files to deploy: ${files.length}`, progressCallback);
 
     let hasDockerfile = false;
     if (
@@ -859,7 +799,7 @@ export async function deploy({
         }
       }
     }
-    logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
+    await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
 
     const bucket = await ensureStorageBucketExists(
       bucketName,
@@ -874,7 +814,7 @@ export async function deploy({
       ZIP_FILE_NAME,
       progressCallback
     );
-    logAndProgress('Source code uploaded successfully', progressCallback);
+    await logAndProgress('Source code uploaded successfully', progressCallback);
 
     await ensureArtifactRegistryRepoExists(
       projectId,
@@ -906,12 +846,12 @@ export async function deploy({
       skipIamCheck
     );
 
-    logAndProgress(`Deployment Completed Successfully`, progressCallback);
+    await logAndProgress(`Deployment Completed Successfully`, progressCallback);
     return service;
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
     console.error(`Deployment Failed`, error);
-    logAndProgress(deployFailedMessage, progressCallback, 'error');
+    await logAndProgress(deployFailedMessage, progressCallback, 'error');
     throw error;
   }
 }
@@ -939,13 +879,20 @@ export async function deployImage({
   if (!projectId) {
     const errorMsg =
       'Error: projectId is required in the configuration object.';
-    logAndProgress(errorMsg, progressCallback, 'error');
-    process.exit(1);
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw new Error(errorMsg);
+  }
+
+  if (!serviceName) {
+    const errorMsg =
+      'Error: serviceName is required in the configuration object.';
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw new Error(errorMsg);
   }
 
   if (!imageUrl) {
     const errorMsg = 'Error: imageUrl is required in the configuration object.';
-    logAndProgress(errorMsg, progressCallback, 'error');
+    await logAndProgress(errorMsg, progressCallback, 'error');
     if (typeof process !== 'undefined' && process.exit) {
       process.exit(1);
     } else {
@@ -965,10 +912,10 @@ export async function deployImage({
 
     runClient = new ServicesClient({ projectId });
 
-    logAndProgress(`Project: ${projectId}`, progressCallback);
-    logAndProgress(`Region: ${region}`, progressCallback);
-    logAndProgress(`Service Name: ${serviceName}`, progressCallback);
-    logAndProgress(`Image URL: ${imageUrl}`, progressCallback);
+    await logAndProgress(`Project: ${projectId}`, progressCallback);
+    await logAndProgress(`Region: ${region}`, progressCallback);
+    await logAndProgress(`Service Name: ${serviceName}`, progressCallback);
+    await logAndProgress(`Image URL: ${imageUrl}`, progressCallback);
 
     const service = await deployToCloudRun(
       projectId,
@@ -979,12 +926,12 @@ export async function deployImage({
       skipIamCheck
     );
 
-    logAndProgress(`Deployment Completed Successfully`, progressCallback);
+    await logAndProgress(`Deployment Completed Successfully`, progressCallback);
     return service;
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
     console.error(`Deployment Failed`, error);
-    logAndProgress(deployFailedMessage, progressCallback, 'error');
+    await logAndProgress(deployFailedMessage, progressCallback, 'error');
     throw error;
   }
 }