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

package/lib/deployment/deployer.js

@@ -24,27 +24,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.
@@ -68,7 +64,10 @@ async function deployToCloudRun(
   serviceId,
   imgUrl,
   progressCallback,
-  skipIamCheck
+  skipIamCheck,
+  deploymentType,
+  zippedSourceContainer,
+  runtime
 ) {
   const parent = context.runClient.locationPath(projectId, location);
   const servicePath = context.runClient.servicePath(
@@ -78,13 +77,20 @@ async function deployToCloudRun(
   );
   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,
     },
   };
 
@@ -213,6 +219,195 @@ 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(
+  context,
+  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(
+      context,
+      bucketName,
+      region,
+      progressCallback
+    );
+
+    await uploadToStorageBucket(
+      context,
+      bucket,
+      archiveBuffer,
+      archiveName,
+      progressCallback
+    );
+    await logAndProgress('Source code uploaded successfully', progressCallback);
+
+    const container = createDirectSourceDeploymentContainer({
+      bucketName,
+      fileName: archiveName,
+      deploymentAttrs,
+    });
+
+    const service = await deployToCloudRun(
+      context,
+      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(
+  context,
+  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(
+    context,
+    bucketName,
+    region,
+    progressCallback
+  );
+
+  const archiveBuffer = await zipFiles(files, false, progressCallback);
+  const archiveName = DEPLOYMENT_CONFIG.ZIP_FILE_NAME;
+
+  await uploadToStorageBucket(
+    context,
+    bucket,
+    archiveBuffer,
+    archiveName,
+    progressCallback
+  );
+  await logAndProgress('Source code uploaded successfully', progressCallback);
+
+  await ensureArtifactRegistryRepoExists(
+    context,
+    projectId,
+    region,
+    DEPLOYMENT_CONFIG.REPO_NAME,
+    'DOCKER',
+    progressCallback
+  );
+
+  await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
+
+  const buildResult = await triggerCloudBuild(
+    context,
+    projectId,
+    region,
+    bucketName,
+    archiveName,
+    DEPLOYMENT_CONFIG.REPO_NAME,
+    imageUrl,
+    hasDockerfile,
+    progressCallback
+  );
+
+  const builtImageUrl = buildResult.results.images[0].name;
+
+  const service = await deployToCloudRun(
+    context,
+    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,8 +452,6 @@ 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(
@@ -282,103 +475,56 @@ export async function deploy({
     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);
-
-    await ensureArtifactRegistryRepoExists(
-      context,
-      projectId,
-      region,
-      REPO_NAME,
-      'DOCKER',
-      progressCallback
-    );
+    // Determines if we can use the direct source deployment (no Cloud Build)
+    const { hasDockerfile, deploymentAttrs } =
+      makeFileDeploymentMetadata(files);
 
-    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(
+          context,
+          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(
+    return await deployWithBuild(
       context,
       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);
@@ -444,7 +590,7 @@ export async function deployImage({
     await ensureApisEnabled(
       context,
       projectId,
-      REQUIRED_APIS_FOR_IMAGE_DEPLOY,
+      REQUIRED_APIS.IMAGE_DEPLOY,
       progressCallback
     );
 
@@ -460,10 +606,11 @@ export async function deployImage({
       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}`;

package/lib/deployment/helpers.js

@@ -0,0 +1,194 @@
+/*
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import path from 'path';
+import fs from 'fs';
+import { DEPLOYMENT_CONFIG, RUNTIMES } from './constants.js';
+
+/**
+ * Checks if the input is a single folder path.
+ * @param {Array<string|Object>} files - Array of file paths or file objects.
+ * @returns {boolean} - true if files contains exactly one string which is a directory.
+ */
+function isFolder(files) {
+  if (files.length !== 1 || typeof files[0] !== 'string') return false;
+  try {
+    return fs.statSync(files[0]).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if a Dockerfile exists in the provided files array.
+ * @param {Array<string|Object>} files - An array of file paths or objects with filename properties.
+ * @returns {boolean} - Returns true if a Dockerfile is found, false otherwise.
+ */
+function checkIfDockerFileExists(files) {
+  if (isFolder(files)) {
+    // Handle folder deployment: check for Dockerfile inside the folder
+    return (
+      fs.existsSync(path.join(files[0], 'Dockerfile')) ||
+      fs.existsSync(path.join(files[0], 'dockerfile'))
+    );
+  }
+
+  // Handle file list deployment or file content deployment
+  for (const file of files) {
+    if (typeof file === 'string') {
+      if (path.basename(file).toLowerCase() === 'dockerfile') {
+        return true;
+      }
+    } else if (typeof file === 'object' && file.filename) {
+      if (path.basename(file.filename).toLowerCase() === 'dockerfile') {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Checks if the provided folder appears to be a Node.js project.
+ * It looks for a `package.json` file in the root of the first path in the `files` array.
+ * @param {string[]} files - Array of file paths
+ * @returns {boolean}
+ */
+function checkIfNodeJsRuntime(files) {
+  const packageJsonPath = path.join(files[0], 'package.json');
+  return fs.existsSync(packageJsonPath);
+}
+
+/**
+ * Returns an empty deployment attributes object.
+ * This is used as a default or when attributes cannot be determined.
+ * @returns {{runtime: undefined, cmd: undefined, args: undefined, baseImage: undefined}}
+ */
+function getEmptyDeploymentAttrs() {
+  return {
+    runtime: undefined,
+    cmd: undefined,
+    args: undefined,
+    baseImage: undefined,
+  };
+}
+
+/**
+ * Extracts deployment attributes (runtime, command, args, baseImage) from a Node.js project's `package.json`.
+ * This function is used for direct source deployments, bypassing Cloud Build.
+ * It returns empty attributes if a `start` script is missing, invalid, or if `engines.node` is specified (indicating a need for Cloud Build).
+ * @param {string[]} files - Array of file paths
+ * @returns {{runtime: string|undefined, cmd: string[]|undefined, args: string[]|undefined, baseImage: string|undefined}} Deployment attributes object.
+ */
+function getNodeJsDeploymentAttrs(files) {
+  const packageJsonPath = path.join(files[0], 'package.json');
+  let packageJson;
+
+  try {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  } catch (error) {
+    // If package.json exists but is invalid, we can't extract attributes.
+    return getEmptyDeploymentAttrs();
+  }
+
+  const startScript = packageJson?.scripts?.start;
+  const hasNodeEngine = packageJson?.engines?.node;
+
+  if (typeof startScript !== 'string' || !startScript.trim() || hasNodeEngine) {
+    return getEmptyDeploymentAttrs();
+  }
+
+  // Handle multiple spaces properly
+  const parts = startScript.trim().split(/\s+/);
+
+  return {
+    runtime: RUNTIMES.NODEJS,
+    cmd: [parts[0]],
+    args: parts.slice(1),
+    baseImage: DEPLOYMENT_CONFIG.DEFAULT_NODE_BASE_IMAGE, // latest default base image
+  };
+}
+
+/**
+ * Determines deployment attributes based on the file list/folder content.
+ * @param {Array<string|Object>} files - Array of file paths or file objects.
+ * @returns {{runtime: string|undefined, cmd: string[]|undefined, args: string[]|undefined, baseImage: string|undefined}} Deployment attributes object.
+ */
+function getDeploymentAttrs(files) {
+  // Currently only support detection of NodeJs runtime
+  if (!isFolder(files) || !checkIfNodeJsRuntime(files)) {
+    // TODO: support file list deployment runtime detection
+    return getEmptyDeploymentAttrs();
+  }
+
+  return getNodeJsDeploymentAttrs(files);
+}
+
+/**
+ * Creates metadata for the file deployment, including Dockerfile presence and runtime attributes.
+ * @param {Array<string|Object>} files - Array of file paths or file objects to be deployed.
+ * @returns {{hasDockerfile: boolean, deploymentAttrs: {runtime: string|undefined, cmd: string[]|undefined, args: string[]|undefined, baseImage: string|undefined}}} Metadata object.
+ */
+export function makeFileDeploymentMetadata(files) {
+  return {
+    hasDockerfile: checkIfDockerFileExists(files),
+    deploymentAttrs: getDeploymentAttrs(files),
+  };
+}
+
+/**
+ * Checks if a zip-based source deployment (no-build) is feasible.
+ * @param {object} metadata - The deployment metadata.
+ * @param {boolean} metadata.hasDockerfile - Whether a Dockerfile is present.
+ * @param {{runtime: string|undefined, cmd: string[]|undefined, args: string[]|undefined}} metadata.deploymentAttrs - Deployment attributes.
+ * @returns {boolean} True if zip deployment is feasible.
+ */
+export function canDeployWithoutBuild({ hasDockerfile, deploymentAttrs }) {
+  return !!(
+    !hasDockerfile &&
+    deploymentAttrs &&
+    deploymentAttrs.runtime &&
+    deploymentAttrs.cmd &&
+    deploymentAttrs.args
+  );
+}
+
+/**
+ * Creates the container spec for a direct source deployment (no Cloud Build).
+ * @param {object} params - The parameters for creating the container spec.
+ * @param {string} params.bucketName - The GCS bucket name where the source is uploaded.
+ * @param {string} params.fileName - The GCS object name (e.g., source.tar.gz).
+ * @param {{cmd: string[], args: string[], baseImage: string}} params.deploymentAttrs - Deployment attributes including command, args, and the base image to use.
+ * @returns {object} The container specification object for the Cloud Run service.
+ */
+export function createDirectSourceDeploymentContainer({
+  bucketName,
+  fileName,
+  deploymentAttrs,
+}) {
+  return {
+    image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
+    baseImageUri: deploymentAttrs.baseImage,
+    sourceCode: {
+      cloudStorageSource: {
+        bucket: bucketName,
+        object: fileName,
+      },
+    },
+    command: deploymentAttrs.cmd,
+    args: deploymentAttrs.args,
+  };
+}