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

package/lib/deployment/deployer.js

@@ -32,15 +32,16 @@ import {
 } from './helpers.js';
 import {
   prepareSourceDirectory,
-  installDependencies,
   cleanupTempDirectory,
 } from './source-processor.js';
+import { runUniversalMaker } from './universal-maker.js';
 
 import {
   DEPLOYMENT_CONFIG,
   DEPLOYMENT_TYPES,
   MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES,
   REQUIRED_APIS,
+  RUNTIMES,
 } from './constants.js';
 
 /**
@@ -66,10 +67,11 @@ async function deployToCloudRun(
   progressCallback,
   skipIamCheck,
   deploymentType,
+  accessToken,
   zippedSourceContainer,
   runtime
 ) {
-  const runClient = await getRunClient(projectId);
+  const runClient = await getRunClient(projectId, accessToken);
   const parent = runClient.locationPath(projectId, location);
   const servicePath = runClient.servicePath(projectId, location, serviceId);
   const revisionName = `${serviceId}-${Date.now()}`; // Generate a unique revision name
@@ -101,6 +103,7 @@ async function deployToCloudRun(
       projectId,
       location,
       serviceId,
+      accessToken,
       progressCallback
     );
 
@@ -245,7 +248,8 @@ async function deployWithZip(
   bucketName,
   deploymentAttrs,
   progressCallback,
-  skipIamCheck
+  skipIamCheck,
+  accessToken
 ) {
   await logAndProgress(
     `Attempting direct source deployment...`,
@@ -256,7 +260,18 @@ async function deployWithZip(
 
   try {
     tempDir = await prepareSourceDirectory(files);
-    await installDependencies(tempDir, deploymentAttrs);
+
+    if (
+      deploymentAttrs.runtime === RUNTIMES.NODEJS ||
+      deploymentAttrs.runtime === RUNTIMES.PYTHON
+    ) {
+      deploymentAttrs = await updateDeploymentAttrsWithUniversalMaker(
+        tempDir,
+        deploymentAttrs,
+        accessToken,
+        progressCallback
+      );
+    }
 
     const archiveBuffer = await zipFiles([tempDir], true, progressCallback);
     const archiveName = DEPLOYMENT_CONFIG.TARGZ_FILE_NAME;
@@ -276,6 +291,7 @@ async function deployWithZip(
       projectId,
       bucketName,
       region,
+      accessToken,
       progressCallback
     );
 
@@ -301,6 +317,7 @@ async function deployWithZip(
       progressCallback,
       skipIamCheck,
       DEPLOYMENT_TYPES.NO_BUILD,
+      accessToken,
       container,
       deploymentAttrs.runtime
     );
@@ -311,6 +328,43 @@ async function deployWithZip(
   }
 }
 
+/**
+ * Updates deployment attributes using result from Universal Maker.
+ *
+ * @async
+ * @param {string} tempDir - Path to the temporary source directory.
+ * @param {object} deploymentAttrs - The initial deployment attributes.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<object>} A promise that resolves with the updated deployment attributes.
+ */
+async function updateDeploymentAttrsWithUniversalMaker(
+  tempDir,
+  deploymentAttrs,
+  accessToken,
+  progressCallback
+) {
+  const umResult = await runUniversalMaker(
+    tempDir,
+    accessToken,
+    progressCallback
+  );
+  if (umResult) {
+    await logAndProgress(
+      'Updating deployment attributes using Universal Maker results.',
+      progressCallback
+    );
+    return {
+      ...deploymentAttrs,
+      baseImage: umResult.runtime || deploymentAttrs.baseImage,
+      runtime: umResult.runtime || deploymentAttrs.runtime,
+      cmd: umResult.command ? [umResult.command] : deploymentAttrs.cmd,
+      args: umResult.args || deploymentAttrs.args,
+      envVars: umResult.envVars || {},
+    };
+  }
+  return deploymentAttrs;
+}
+
 /**
  * Handles deployment using Google Cloud Build.
  * This function zips the source code, uploads it to Google Cloud Storage,
@@ -337,7 +391,8 @@ async function deployWithBuild(
   hasDockerfile,
   bucketName,
   progressCallback,
-  skipIamCheck
+  skipIamCheck,
+  accessToken
 ) {
   const imageUrl = `${region}-docker.pkg.dev/${projectId}/${DEPLOYMENT_CONFIG.REPO_NAME}/${serviceName}:${DEPLOYMENT_CONFIG.IMAGE_TAG}`;
 
@@ -345,6 +400,7 @@ async function deployWithBuild(
     projectId,
     bucketName,
     region,
+    accessToken,
     progressCallback
   );
 
@@ -361,6 +417,7 @@ async function deployWithBuild(
 
   await ensureArtifactRegistryRepoExists(
     projectId,
+    accessToken,
     region,
     DEPLOYMENT_CONFIG.REPO_NAME,
     'DOCKER',
@@ -377,6 +434,7 @@ async function deployWithBuild(
     DEPLOYMENT_CONFIG.REPO_NAME,
     imageUrl,
     hasDockerfile,
+    accessToken,
     progressCallback
   );
 
@@ -389,7 +447,8 @@ async function deployWithBuild(
     builtImageUrl,
     progressCallback,
     skipIamCheck,
-    DEPLOYMENT_TYPES.WITH_BUILD
+    DEPLOYMENT_TYPES.WITH_BUILD,
+    accessToken
   );
 
   await logAndProgress(`Deployment completed successfully`, progressCallback);
@@ -414,6 +473,7 @@ export async function deploy({
   files,
   progressCallback,
   skipIamCheck,
+  accessToken,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -444,6 +504,7 @@ export async function deploy({
     await ensureApisEnabled(
       projectId,
       REQUIRED_APIS.SOURCE_DEPLOY,
+      accessToken,
       progressCallback
     );
 
@@ -470,7 +531,8 @@ export async function deploy({
           bucketName,
           deploymentAttrs,
           progressCallback,
-          skipIamCheck
+          skipIamCheck,
+          accessToken
         );
       } catch (error) {
         await logAndProgress(
@@ -489,7 +551,8 @@ export async function deploy({
       hasDockerfile,
       bucketName,
       progressCallback,
-      skipIamCheck
+      skipIamCheck,
+      accessToken
     );
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
@@ -518,6 +581,7 @@ export async function deployImage({
   imageUrl,
   progressCallback,
   skipIamCheck,
+  accessToken,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -547,6 +611,7 @@ export async function deployImage({
     await ensureApisEnabled(
       projectId,
       REQUIRED_APIS.IMAGE_DEPLOY,
+      accessToken,
       progressCallback
     );
 
@@ -562,7 +627,8 @@ export async function deployImage({
       imageUrl,
       progressCallback,
       skipIamCheck,
-      DEPLOYMENT_TYPES.IMAGE
+      DEPLOYMENT_TYPES.IMAGE,
+      accessToken
     );
 
     await logAndProgress(`Deployment completed successfully`, progressCallback);

package/lib/deployment/helpers.js

@@ -72,6 +72,18 @@ function checkIfNodeJsRuntime(files) {
   return fs.existsSync(packageJsonPath);
 }
 
+/**
+ * Checks if the provided folder appears to be a Python project.
+ * It looks for a `requirements.txt` or `pyproject.toml` file in the root of the first path in the `files` array.
+ * @param {string[]} files - Array of file paths
+ * @returns {boolean}
+ */
+function checkIfPythonRuntime(files) {
+  const requirementsTxtPath = path.join(files[0], 'requirements.txt');
+  const pyprojectTomlPath = path.join(files[0], 'pyproject.toml');
+  return fs.existsSync(requirementsTxtPath) || fs.existsSync(pyprojectTomlPath);
+}
+
 /**
  * Returns an empty deployment attributes object.
  * This is used as a default or when attributes cannot be determined.
@@ -86,55 +98,30 @@ function getEmptyDeploymentAttrs() {
   };
 }
 
-/**
- * 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.
+ * @returns {{runtime: string|undefined, baseImage: string|undefined}} Deployment attributes object.
  */
 function getDeploymentAttrs(files) {
+  let deploymentAttrs = getEmptyDeploymentAttrs();
   // Currently only support detection of NodeJs runtime
-  if (!isFolder(files) || !checkIfNodeJsRuntime(files)) {
+  if (
+    !isFolder(files) ||
+    !(checkIfNodeJsRuntime(files) || checkIfPythonRuntime(files))
+  ) {
     // TODO: support file list deployment runtime detection
-    return getEmptyDeploymentAttrs();
+    return deploymentAttrs;
   }
 
-  return getNodeJsDeploymentAttrs(files);
+  if (checkIfPythonRuntime(files)) {
+    deploymentAttrs.runtime = RUNTIMES.PYTHON;
+    deploymentAttrs.baseImage = DEPLOYMENT_CONFIG.DEFAULT_PYTHON_BASE_IMAGE;
+  } else {
+    deploymentAttrs.runtime = RUNTIMES.NODEJS;
+    deploymentAttrs.baseImage = DEPLOYMENT_CONFIG.DEFAULT_NODE_BASE_IMAGE;
+  }
+  return deploymentAttrs;
 }
 
 /**
@@ -157,13 +144,7 @@ export function makeFileDeploymentMetadata(files) {
  * @returns {boolean} True if zip deployment is feasible.
  */
 export function canDeployWithoutBuild({ hasDockerfile, deploymentAttrs }) {
-  return !!(
-    !hasDockerfile &&
-    deploymentAttrs &&
-    deploymentAttrs.runtime &&
-    deploymentAttrs.cmd &&
-    deploymentAttrs.args
-  );
+  return !!(!hasDockerfile && deploymentAttrs && deploymentAttrs.runtime);
 }
 
 /**
@@ -179,7 +160,7 @@ export function createDirectSourceDeploymentContainer({
   fileName,
   deploymentAttrs,
 }) {
-  return {
+  const container = {
     image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
     baseImageUri: deploymentAttrs.baseImage,
     sourceCode: {
@@ -191,4 +172,16 @@ export function createDirectSourceDeploymentContainer({
     command: deploymentAttrs.cmd,
     args: deploymentAttrs.args,
   };
+
+  // Add environment variables if provided
+  if (deploymentAttrs.envVars && typeof deploymentAttrs.envVars === 'object') {
+    container.env = Object.entries(deploymentAttrs.envVars).map(
+      ([name, value]) => ({
+        name,
+        value: String(value),
+      })
+    );
+  }
+
+  return container;
 }

package/lib/deployment/source-processor.js

@@ -58,54 +58,6 @@ export async function prepareSourceDirectory(files, progressCallback) {
   return tempDir;
 }
 
-/**
- * Installs Node.js dependencies in the target directory if a package.json exists.
- * Skips if node_modules already exists (assumed pre-installed or copied).
- *
- * @param {string} targetDir - The directory containing the source code.
- */
-async function installNodeDependencies(targetDir) {
-  const nodeModulesPath = path.join(targetDir, 'node_modules');
-
-  if (fs.existsSync(nodeModulesPath)) {
-    console.log(
-      `Existing node_modules detected. Skipping dependency installation.`
-    );
-    return;
-  }
-
-  // Check for lock file to decide between install and ci
-  const hasLockFile = fs.existsSync(path.join(targetDir, 'package-lock.json'));
-  const npmCommand = hasLockFile
-    ? 'npm ci --omit=dev'
-    : 'npm install --omit=dev';
-
-  try {
-    await execAsync(npmCommand, { cwd: targetDir });
-    console.log(`${npmCommand} completed successfully`);
-  } catch (e) {
-    console.log(`Dependency installation failed: ${e.message}`);
-  }
-}
-
-/**
- * Generic wrapper to install dependencies for the detected runtime.
- *
- * @param {string} targetDir - The directory containing the source code.
- * @param {Object} deploymentAttrs - Deployment attributes containing runtime info.
- */
-export async function installDependencies(targetDir, deploymentAttrs) {
-  switch (deploymentAttrs?.runtime) {
-    case RUNTIMES.NODEJS:
-      await installNodeDependencies(targetDir);
-      break;
-    default:
-      console.log(
-        `No specific dependency installation logic for runtime: ${deploymentAttrs?.runtime}`
-      );
-  }
-}
-
 /**
  * Cleans up the temporary directory.
  *

package/lib/deployment/universal-maker.js

@@ -0,0 +1,274 @@
+/*
+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 { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import util from 'util';
+import crypto from 'crypto';
+import { logAndProgress } from '../util/helpers.js';
+import { TEMP_PATHS } from './constants.js';
+import { getArtifactRegistryClient } from '../clients.js';
+
+const execAsync = util.promisify(exec);
+
+const UNIVERSAL_MAKER_BIN = 'universal_maker';
+const UM_VERSION = '1.0.0';
+
+const AR_HOST = 'https://artifactregistry.googleapis.com';
+const AR_PROJECT = 'serverless-runtimes';
+const AR_LOCATION = 'us-central1';
+const AR_REPOSITORY = 'universal-maker';
+const AR_DOWNLOAD_PATH_PREFIX = '/download/v1/';
+const AR_DOWNLOAD_URL_SUFFIX = ':download?alt=media';
+
+const ARCH_MAPPING = {
+  linux_x64: 'x86-64',
+  darwin_arm64: 'darwin-arm64',
+};
+
+/**
+ * Gets the architecture key for the current platform.
+ * @returns {string|null} The architecture key or null if not supported.
+ */
+function getUniversalMakerArchitectureKey() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'linux' && arch === 'x64') {
+    return 'linux_x64';
+  } else if (platform === 'darwin' && arch === 'arm64') {
+    return 'darwin_arm64';
+  }
+  return null;
+}
+
+/**
+ * Checks if the existing binary is up to date by comparing its SHA256 mash with the remote metadata.
+ * If the binary is out of date, it removes it.
+ * @param {string} binPath - Path to the local binary.
+ * @param {string} arch - Current architecture.
+ * @param {string} accessToken - Access token for authentication.
+ * @param {function} progressCallback - Progress callback.
+ * @returns {Promise<boolean>} True if the binary is up to date (or if updating fails), false otherwise.
+ */
+async function isBinaryUpToDate(binPath, arch, accessToken, progressCallback) {
+  if (!fs.existsSync(binPath)) {
+    return false;
+  }
+
+  try {
+    await logAndProgress(
+      'Checking for Universal Maker updates...',
+      progressCallback,
+      'debug'
+    );
+
+    const artifactRegistryClient = await getArtifactRegistryClient(
+      AR_PROJECT,
+      accessToken
+    );
+    const resourceName = artifactRegistryClient.filePath(
+      AR_PROJECT,
+      AR_LOCATION,
+      AR_REPOSITORY,
+      `${arch}:${UM_VERSION}:${UNIVERSAL_MAKER_BIN}`
+    );
+
+    const [file] = await artifactRegistryClient.getFile({ name: resourceName });
+    const remoteSha256Base64 = file.hashes?.find(
+      (h) => h.type === 'SHA256'
+    )?.value;
+
+    if (!remoteSha256Base64) {
+      return false; // Cannot verify, download new binary
+    }
+
+    const remoteSha256Hex = Buffer.from(remoteSha256Base64, 'base64').toString(
+      'hex'
+    );
+    const localFileContent = fs.readFileSync(binPath);
+    const localSha256Hex = crypto
+      .createHash('sha256')
+      .update(localFileContent)
+      .digest('hex');
+
+    if (remoteSha256Hex === localSha256Hex) {
+      await logAndProgress(
+        'Universal Maker binary is up to date.',
+        progressCallback,
+        'debug'
+      );
+      return true;
+    }
+
+    await logAndProgress(
+      'Universal Maker binary is out of date. Removing existing binary.',
+      progressCallback,
+      'debug'
+    );
+    fs.unlinkSync(binPath);
+    return false;
+  } catch (error) {
+    await logAndProgress(
+      `Could not check for Universal Maker updates: ${error.message}. Downloading the new binary.`,
+      progressCallback,
+      'debug'
+    );
+    return false; // On error, fallback to downloading the new binary
+  }
+}
+
+/**
+ * Downloads the universal maker binary if it doesn't exist.
+ * @param {string} binDir - Directory to store the binary.
+ * @param {string} accessToken - Access token for authentication.
+ * @param {function} progressCallback - Progress callback.
+ * @returns {Promise<string|null>} Path to the binary or null if not supported.
+ */
+async function ensureUniversalMaker(binDir, accessToken, progressCallback) {
+  const key = getUniversalMakerArchitectureKey();
+
+  if (!key) {
+    await logAndProgress(
+      `Universal Maker is not supported on ${process.platform} ${process.arch}.`,
+      progressCallback,
+      'debug'
+    );
+    return null;
+  }
+
+  const binPath = path.join(binDir, UNIVERSAL_MAKER_BIN);
+  const arch = ARCH_MAPPING[key];
+
+  if (await isBinaryUpToDate(binPath, arch, accessToken, progressCallback)) {
+    return binPath;
+  }
+
+  await logAndProgress(`Downloading Universal Maker...`, progressCallback);
+
+  try {
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+
+    const artifactRegistryClient = await getArtifactRegistryClient(
+      AR_PROJECT,
+      accessToken
+    );
+    const resourceName = artifactRegistryClient.filePath(
+      AR_PROJECT,
+      AR_LOCATION,
+      AR_REPOSITORY,
+      `${arch}:${UM_VERSION}:${UNIVERSAL_MAKER_BIN}`
+    );
+
+    const url = `${AR_HOST}${AR_DOWNLOAD_PATH_PREFIX}${resourceName}${AR_DOWNLOAD_URL_SUFFIX}`;
+    const response = await artifactRegistryClient.auth.request({
+      url,
+      responseType: 'stream',
+    });
+
+    const dest = fs.createWriteStream(binPath);
+    await new Promise((resolve, reject) => {
+      response.data.pipe(dest).on('finish', resolve).on('error', reject);
+    });
+
+    fs.chmodSync(binPath, '755');
+    return binPath;
+  } catch (error) {
+    await logAndProgress(
+      `Failed to download Universal Maker: ${error.message}`,
+      progressCallback,
+      'debug'
+    );
+    return null;
+  }
+}
+
+/**
+ * Runs Universal Maker on the given application directory.
+ * @param {string} appDir - Directory containing the application source.
+ * @param {function} progressCallback - Progress callback.
+ * @param {string} accessToken - Access token for authentication.
+ * @returns {Promise<object|null>} The parsed build_output.json or null.
+ */
+export async function runUniversalMaker(appDir, accessToken, progressCallback) {
+  const binDir = path.join(
+    os.homedir(),
+    TEMP_PATHS.BASE,
+    TEMP_PATHS.BIN_SUBDIR
+  );
+  const binPath = await ensureUniversalMaker(
+    binDir,
+    accessToken,
+    progressCallback
+  );
+
+  if (!binPath) {
+    return null;
+  }
+
+  const outputDir = path.join(os.tmpdir(), `um-output-${Date.now()}`);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  try {
+    // ./universal_maker -application_dir <source_code_path> -output_dir <output_results_path> -output_format json
+    await logAndProgress(
+      `Running Universal Maker: ${binPath} -application_dir ${appDir} -output_dir ${outputDir} -output_format json`,
+      progressCallback,
+      'debug'
+    );
+    const command = `"${binPath}" -application_dir "${appDir}" -output_dir "${outputDir}" -output_format json`;
+    await execAsync(command);
+
+    const outputPath = path.join(outputDir, 'build_output.json');
+    if (fs.existsSync(outputPath)) {
+      const output = JSON.parse(fs.readFileSync(outputPath, 'utf-8'));
+      await logAndProgress(
+        'Universal Maker completed successfully.',
+        progressCallback
+      );
+      return output;
+    } else {
+      await logAndProgress(
+        'Universal Maker did not produce build_output.json',
+        progressCallback,
+        'debug'
+      );
+      return null;
+    }
+  } catch (error) {
+    await logAndProgress(
+      `Universal Maker failed: ${error.message}`,
+      progressCallback,
+      'debug'
+    );
+    return null;
+  } finally {
+    // Cleanup output dir
+    try {
+      if (fs.existsSync(outputDir)) {
+        fs.rmSync(outputDir, { recursive: true, force: true });
+      }
+    } catch (e) {
+      // ignore cleanup errors
+    }
+  }
+}