@google-cloud/cloud-run-mcp 1.6.0 → 1.8.0

package/lib/deployment/deployer.js

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { getRunClient } from '../clients.js';
 import { callWithRetry, ensureApisEnabled } from '../cloud-api/helpers.js';
 import { zipFiles } from '../util/archive.js';
 import {
@@ -24,27 +25,23 @@ import { ensureArtifactRegistryRepoExists } from '../cloud-api/registry.js';
 import { triggerCloudBuild } from '../cloud-api/build.js';
 import { logAndProgress } from '../util/helpers.js';
 import { checkCloudRunServiceExists } from '../cloud-api/run.js';
+import {
+  canDeployWithoutBuild,
+  createDirectSourceDeploymentContainer,
+  makeFileDeploymentMetadata,
+} from './helpers.js';
+import {
+  prepareSourceDirectory,
+  installDependencies,
+  cleanupTempDirectory,
+} from './source-processor.js';
 
-// Configuration
-const REPO_NAME = 'mcp-cloud-run-deployments';
-const ZIP_FILE_NAME = 'source.zip';
-const IMAGE_TAG = 'latest';
-
-// APIs required for deploying from source code.
-const REQUIRED_APIS_FOR_SOURCE_DEPLOY = [
-  'iam.googleapis.com',
-  'storage.googleapis.com',
-  'cloudbuild.googleapis.com',
-  'artifactregistry.googleapis.com',
-  'run.googleapis.com',
-  'serviceusage.googleapis.com',
-];
-
-// APIs required for deploying a container image.
-const REQUIRED_APIS_FOR_IMAGE_DEPLOY = [
-  'run.googleapis.com',
-  'serviceusage.googleapis.com',
-];
+import {
+  DEPLOYMENT_CONFIG,
+  DEPLOYMENT_TYPES,
+  MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES,
+  REQUIRED_APIS,
+} from './constants.js';
 
 /**
  * Deploys or updates a Cloud Run service with the specified container image.
@@ -62,29 +59,35 @@ const REQUIRED_APIS_FOR_IMAGE_DEPLOY = [
  * @throws {Error} If the deployment or update process fails.
  */
 async function deployToCloudRun(
-  context,
   projectId,
   location,
   serviceId,
   imgUrl,
   progressCallback,
-  skipIamCheck
+  skipIamCheck,
+  deploymentType,
+  zippedSourceContainer,
+  runtime
 ) {
-  const parent = context.runClient.locationPath(projectId, location);
-  const servicePath = context.runClient.servicePath(
-    projectId,
-    location,
-    serviceId
-  );
+  const runClient = await getRunClient(projectId);
+  const parent = runClient.locationPath(projectId, location);
+  const servicePath = runClient.servicePath(projectId, location, serviceId);
   const revisionName = `${serviceId}-${Date.now()}`; // Generate a unique revision name
 
+  const containers =
+    deploymentType === DEPLOYMENT_TYPES.NO_BUILD
+      ? [zippedSourceContainer]
+      : [{ image: imgUrl }];
+
   const service = {
     template: {
       revision: revisionName,
-      containers: [{ image: imgUrl }],
+      containers,
     },
     labels: {
-      'created-by': 'cloud-run-mcp',
+      'created-by': DEPLOYMENT_CONFIG.LABEL_CREATED_BY,
+      'deployment-type': deploymentType,
+      runtime: runtime,
     },
   };
 
@@ -95,7 +98,6 @@ async function deployToCloudRun(
 
   try {
     const exists = await checkCloudRunServiceExists(
-      context,
       projectId,
       location,
       serviceId,
@@ -115,7 +117,7 @@ async function deployToCloudRun(
         dryRunServiceConfig.name = servicePath;
         await callWithRetry(
           () =>
-            context.runClient.updateService({
+            runClient.updateService({
               service: dryRunServiceConfig,
               validateOnly: true,
             }),
@@ -124,7 +126,7 @@ async function deployToCloudRun(
       } else {
         await callWithRetry(
           () =>
-            context.runClient.createService({
+            runClient.createService({
               parent: parent,
               service: dryRunServiceConfig,
               serviceId: serviceId,
@@ -175,7 +177,7 @@ async function deployToCloudRun(
       );
       service.name = servicePath;
       [operation] = await callWithRetry(
-        () => context.runClient.updateService({ service }),
+        () => runClient.updateService({ service }),
         `updateService ${serviceId}`
       );
     } else {
@@ -185,7 +187,7 @@ async function deployToCloudRun(
       );
       [operation] = await callWithRetry(
         () =>
-          context.runClient.createService({
+          runClient.createService({
             parent: parent,
             service: service, // 'service' object might have invokerIamDisabled removed
             serviceId: serviceId,
@@ -213,6 +215,187 @@ async function deployToCloudRun(
   }
 }
 
+/**
+ * Handles deployment directly from source via a zipped archive (no Cloud Build).
+ * This function prepares the source code, installs dependencies, zips the code,
+ * uploads it to Google Cloud Storage, and then deploys it to Cloud Run
+ * using the direct source deployment mechanism.
+ *
+ * @param {object} context - The context object containing various GCP clients.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} region - The Google Cloud region for the deployment.
+ * @param {string} serviceName - The name of the Cloud Run service.
+ * @param {Array<string|{filename: string, content: Buffer|string}>} files - Files to deploy.
+ * @param {string} bucketName - The name of the GCS bucket to use for staging.
+ * @param {object} deploymentAttrs - Deployment attributes detected from the source.
+ * @param {string} [deploymentAttrs.runtime] - The detected runtime (e.g., 'nodejs').
+ * @param {string[]} [deploymentAttrs.cmd] - The command to run the application.
+ * @param {string[]} [deploymentAttrs.args] - The arguments for the command.
+ * @param {string} [deploymentAttrs.baseImage] - The base image to use for the deployment.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @param {boolean} [skipIamCheck=false] - Whether to skip the IAM check during Cloud Run service creation/update.
+ * @returns {Promise<object>} A promise that resolves with the deployed Cloud Run service object.
+ * @throws {Error} If any part of the deployment process fails.
+ */
+async function deployWithZip(
+  projectId,
+  region,
+  serviceName,
+  files,
+  bucketName,
+  deploymentAttrs,
+  progressCallback,
+  skipIamCheck
+) {
+  await logAndProgress(
+    `Attempting direct source deployment...`,
+    progressCallback
+  );
+
+  let tempDir;
+
+  try {
+    tempDir = await prepareSourceDirectory(files);
+    await installDependencies(tempDir, deploymentAttrs);
+
+    const archiveBuffer = await zipFiles([tempDir], true, progressCallback);
+    const archiveName = DEPLOYMENT_CONFIG.TARGZ_FILE_NAME;
+
+    if (archiveBuffer.length > MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES) {
+      const errorMsg = `Warning: Source archive size (${(
+        archiveBuffer.length /
+        (1024 * 1024)
+      ).toFixed(
+        2
+      )} MiB) exceeds the ${MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES / (1024 * 1024)} MiB limit.`;
+      await logAndProgress(errorMsg, progressCallback, 'warn');
+      throw new Error('Archive size exceeds limit');
+    }
+
+    const bucket = await ensureStorageBucketExists(
+      projectId,
+      bucketName,
+      region,
+      progressCallback
+    );
+
+    await uploadToStorageBucket(
+      bucket,
+      archiveBuffer,
+      archiveName,
+      progressCallback
+    );
+    await logAndProgress('Source code uploaded successfully', progressCallback);
+
+    const container = createDirectSourceDeploymentContainer({
+      bucketName,
+      fileName: archiveName,
+      deploymentAttrs,
+    });
+
+    const service = await deployToCloudRun(
+      projectId,
+      region,
+      serviceName,
+      undefined,
+      progressCallback,
+      skipIamCheck,
+      DEPLOYMENT_TYPES.NO_BUILD,
+      container,
+      deploymentAttrs.runtime
+    );
+
+    return service;
+  } finally {
+    await cleanupTempDirectory(tempDir);
+  }
+}
+
+/**
+ * Handles deployment using Google Cloud Build.
+ * This function zips the source code, uploads it to Google Cloud Storage,
+ * triggers a Cloud Build job to build a container image, pushes the image
+ * to Artifact Registry, and then deploys the image to Cloud Run.
+ *
+ * @param {object} context - The context object containing various GCP clients.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} region - The Google Cloud region for the deployment.
+ * @param {string} serviceName - The name of the Cloud Run service.
+ * @param {Array<string|{filename: string, content: Buffer|string}>} files - Files to deploy.
+ * @param {boolean} hasDockerfile - Whether a Dockerfile is present in the files.
+ * @param {string} bucketName - The name of the GCS bucket to use for staging.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @param {boolean} [skipIamCheck=false] - Whether to skip the IAM check during Cloud Run service creation/update.
+ * @returns {Promise<object>} A promise that resolves with the deployed Cloud Run service object.
+ * @throws {Error} If any part of the build or deployment process fails.
+ */
+async function deployWithBuild(
+  projectId,
+  region,
+  serviceName,
+  files,
+  hasDockerfile,
+  bucketName,
+  progressCallback,
+  skipIamCheck
+) {
+  const imageUrl = `${region}-docker.pkg.dev/${projectId}/${DEPLOYMENT_CONFIG.REPO_NAME}/${serviceName}:${DEPLOYMENT_CONFIG.IMAGE_TAG}`;
+
+  const bucket = await ensureStorageBucketExists(
+    projectId,
+    bucketName,
+    region,
+    progressCallback
+  );
+
+  const archiveBuffer = await zipFiles(files, false, progressCallback);
+  const archiveName = DEPLOYMENT_CONFIG.ZIP_FILE_NAME;
+
+  await uploadToStorageBucket(
+    bucket,
+    archiveBuffer,
+    archiveName,
+    progressCallback
+  );
+  await logAndProgress('Source code uploaded successfully', progressCallback);
+
+  await ensureArtifactRegistryRepoExists(
+    projectId,
+    region,
+    DEPLOYMENT_CONFIG.REPO_NAME,
+    'DOCKER',
+    progressCallback
+  );
+
+  await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
+
+  const buildResult = await triggerCloudBuild(
+    projectId,
+    region,
+    bucketName,
+    archiveName,
+    DEPLOYMENT_CONFIG.REPO_NAME,
+    imageUrl,
+    hasDockerfile,
+    progressCallback
+  );
+
+  const builtImageUrl = buildResult.results.images[0].name;
+
+  const service = await deployToCloudRun(
+    projectId,
+    region,
+    serviceName,
+    builtImageUrl,
+    progressCallback,
+    skipIamCheck,
+    DEPLOYMENT_TYPES.WITH_BUILD
+  );
+
+  await logAndProgress(`Deployment completed successfully`, progressCallback);
+  return service;
+}
+
 /**
  * Deploys a service to Google Cloud Run.
  * @param {object} config - The deployment configuration.
@@ -257,128 +440,57 @@ export async function deploy({
     }
   }
 
-  const path = await import('path');
-  const fs = await import('fs');
-  const { Storage } = await import('@google-cloud/storage');
-  const { CloudBuildClient } = await import('@google-cloud/cloudbuild');
-  const { ArtifactRegistryClient } = await import(
-    '@google-cloud/artifact-registry'
-  );
-  const { v2: CloudRunV2Module } = await import('@google-cloud/run');
-  const { ServicesClient } = CloudRunV2Module;
-  const { ServiceUsageClient } = await import('@google-cloud/service-usage');
-  const { Logging } = await import('@google-cloud/logging');
-
   try {
-    const context = {
-      storage: new Storage({ projectId }),
-      cloudBuildClient: new CloudBuildClient({ projectId }),
-      artifactRegistryClient: new ArtifactRegistryClient({ projectId }),
-      runClient: new ServicesClient({ projectId }),
-      serviceUsageClient: new ServiceUsageClient({ projectId }),
-      loggingClient: new Logging({ projectId }),
-    };
-
     await ensureApisEnabled(
-      context,
       projectId,
-      REQUIRED_APIS_FOR_SOURCE_DEPLOY,
+      REQUIRED_APIS.SOURCE_DEPLOY,
       progressCallback
     );
 
     const bucketName = `${projectId}-source-bucket`;
-    const imageUrl = `${region}-docker.pkg.dev/${projectId}/${REPO_NAME}/${serviceName}:${IMAGE_TAG}`;
 
     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 (
-      files.length === 1 &&
-      typeof files[0] === 'string' &&
-      fs.statSync(files[0]).isDirectory()
-    ) {
-      // Handle folder deployment: check for Dockerfile inside the folder
-      const dockerfilePath = path.join(files[0], 'Dockerfile');
-      const dockerfilePathLowerCase = path.join(files[0], 'dockerfile');
-      if (
-        fs.existsSync(dockerfilePath) ||
-        fs.existsSync(dockerfilePathLowerCase)
-      ) {
-        hasDockerfile = true;
-      }
-    } else {
-      // Handle file list deployment or file content deployment
-      for (const file of files) {
-        if (typeof file === 'string') {
-          if (path.basename(file).toLowerCase() === 'dockerfile') {
-            hasDockerfile = true;
-            break;
-          }
-        } else if (typeof file === 'object' && file.filename) {
-          if (path.basename(file.filename).toLowerCase() === 'dockerfile') {
-            hasDockerfile = true;
-            break;
-          }
-        }
-      }
-    }
-    await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
-
-    const bucket = await ensureStorageBucketExists(
-      context,
-      bucketName,
-      region,
-      progressCallback
-    );
-
-    const zipBuffer = await zipFiles(files, progressCallback);
-    await uploadToStorageBucket(
-      context,
-      bucket,
-      zipBuffer,
-      ZIP_FILE_NAME,
-      progressCallback
-    );
-    await logAndProgress('Source code uploaded successfully', progressCallback);
+    // Determines if we can use the direct source deployment (no Cloud Build)
+    const { hasDockerfile, deploymentAttrs } =
+      makeFileDeploymentMetadata(files);
 
-    await ensureArtifactRegistryRepoExists(
-      context,
-      projectId,
-      region,
-      REPO_NAME,
-      'DOCKER',
-      progressCallback
-    );
-
-    const buildResult = await triggerCloudBuild(
-      context,
-      projectId,
-      region,
-      bucketName,
-      ZIP_FILE_NAME,
-      REPO_NAME,
-      imageUrl,
-      hasDockerfile,
-      progressCallback
-    );
+    await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
 
-    const builtImageUrl = buildResult.results.images[0].name;
+    if (canDeployWithoutBuild({ hasDockerfile, deploymentAttrs })) {
+      try {
+        return await deployWithZip(
+          projectId,
+          region,
+          serviceName,
+          files,
+          bucketName,
+          deploymentAttrs,
+          progressCallback,
+          skipIamCheck
+        );
+      } catch (error) {
+        await logAndProgress(
+          `Failed to deploy directly from source: ${error.message}. Retrying to deploy using Cloud Build...`,
+          progressCallback,
+          'warn'
+        );
+      }
+    }
 
-    const service = await deployToCloudRun(
-      context,
+    return await deployWithBuild(
       projectId,
       region,
       serviceName,
-      builtImageUrl,
+      files,
+      hasDockerfile,
+      bucketName,
       progressCallback,
       skipIamCheck
     );
-
-    await logAndProgress(`Deployment Completed Successfully`, progressCallback);
-    return service;
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
     console.error(`Deployment Failed`, error);
@@ -431,20 +543,10 @@ export async function deployImage({
     }
   }
 
-  const { v2: CloudRunV2Module } = await import('@google-cloud/run');
-  const { ServicesClient } = CloudRunV2Module;
-  const { ServiceUsageClient } = await import('@google-cloud/service-usage');
-
   try {
-    const context = {
-      runClient: new ServicesClient({ projectId }),
-      serviceUsageClient: new ServiceUsageClient({ projectId }),
-    };
-
     await ensureApisEnabled(
-      context,
       projectId,
-      REQUIRED_APIS_FOR_IMAGE_DEPLOY,
+      REQUIRED_APIS.IMAGE_DEPLOY,
       progressCallback
     );
 
@@ -454,16 +556,16 @@ export async function deployImage({
     await logAndProgress(`Image URL: ${imageUrl}`, progressCallback);
 
     const service = await deployToCloudRun(
-      context,
       projectId,
       region,
       serviceName,
       imageUrl,
       progressCallback,
-      skipIamCheck
+      skipIamCheck,
+      DEPLOYMENT_TYPES.IMAGE
     );
 
-    await logAndProgress(`Deployment Completed Successfully`, progressCallback);
+    await logAndProgress(`Deployment completed successfully`, progressCallback);
     return service;
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;