@google-cloud/cloud-run-mcp 1.9.0 → 1.11.0

package/lib/deployment/helpers.js

@@ -15,8 +15,9 @@ limitations under the License.
 */
 
 import path from 'path';
-import fs from 'fs';
+import fs, { promises as fsPromises } from 'fs';
 import { DEPLOYMENT_CONFIG, RUNTIMES } from './constants.js';
+import { uploadToStorageBucket } from '../cloud-api/storage.js';
 
 /**
  * Checks if the input is a single folder path.
@@ -61,6 +62,30 @@ function checkIfDockerFileExists(files) {
   return false;
 }
 
+/**
+ * Checks if a compose file exists in the provided files array.
+ * @param {Array<string|Object>} files - An array of file paths or objects with filename properties.
+ * @returns {string|null} - Returns the path/filename of the compose file if found, null otherwise.
+ */
+function checkIfComposeFileExists(files) {
+  const composeFiles = [
+    'compose.yaml',
+    'compose.yml',
+    'docker-compose.yaml',
+    'docker-compose.yml',
+  ];
+  if (isFolder(files)) {
+    for (const name of composeFiles) {
+      const fullPath = path.join(files[0], name);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  // TODO: we do not handle file content deployment at present as run-compose binary does not support it
+  return null;
+}
+
 /**
  * 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.
@@ -72,6 +97,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 +123,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;
 }
 
 /**
@@ -145,6 +157,7 @@ function getDeploymentAttrs(files) {
 export function makeFileDeploymentMetadata(files) {
   return {
     hasDockerfile: checkIfDockerFileExists(files),
+    composeFilePath: checkIfComposeFileExists(files),
     deploymentAttrs: getDeploymentAttrs(files),
   };
 }
@@ -157,13 +170,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 +186,7 @@ export function createDirectSourceDeploymentContainer({
   fileName,
   deploymentAttrs,
 }) {
-  return {
+  const container = {
     image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
     baseImageUri: deploymentAttrs.baseImage,
     sourceCode: {
@@ -191,4 +198,47 @@ 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;
+}
+
+/**
+ * Uploads a local directory to a GCS bucket recursively.
+ * @param {*} bucket - GCS bucket object
+ * @param {string} localPath - Local directory path
+ * @param {string} gcsPrefix - GCS prefix (blob name starting part)
+ * @param {function} progressCallback - Callback for progress
+ */
+export async function uploadDirectory(
+  bucket,
+  localPath,
+  gcsPrefix,
+  progressCallback
+) {
+  const entries = await fsPromises.readdir(localPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(localPath, entry.name);
+    const destination = `${gcsPrefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await uploadDirectory(bucket, fullPath, destination, progressCallback);
+    } else {
+      const buffer = await fsPromises.readFile(fullPath);
+      await uploadToStorageBucket(
+        bucket,
+        buffer,
+        destination,
+        progressCallback
+      );
+    }
+  }
 }

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,147 @@
+/*
+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 { logAndProgress } from '../util/helpers.js';
+import { TEMP_PATHS } from './constants.js';
+import { ensureRepositoryDownloaded } from '../util/artifacts.js';
+
+const execAsync = util.promisify(exec);
+
+const UNIVERSAL_MAKER_BIN = 'universal_maker';
+const UM_VERSION = '1.0.0';
+
+const AR_PROJECT = 'serverless-runtimes';
+const AR_LOCATION = 'us-central1';
+const AR_REPOSITORY = 'universal-maker';
+
+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;
+}
+
+/**
+ * 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 key = getUniversalMakerArchitectureKey();
+  if (!key) {
+    await logAndProgress(
+      `Universal Maker is not supported on ${process.platform} ${process.arch}.`,
+      progressCallback,
+      'debug'
+    );
+    return null;
+  }
+
+  const arch = ARCH_MAPPING[key];
+  const binPath = path.join(binDir, UNIVERSAL_MAKER_BIN);
+
+  const binPathResult = await ensureRepositoryDownloaded(
+    binPath,
+    {
+      project: AR_PROJECT,
+      location: AR_LOCATION,
+      repository: AR_REPOSITORY,
+      artifactPath: `${arch}:${UM_VERSION}:${UNIVERSAL_MAKER_BIN}`,
+      displayName: 'Universal Maker',
+    },
+    accessToken,
+    progressCallback
+  );
+
+  if (!binPathResult) {
+    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
+    }
+  }
+}

package/lib/util/archive.js

@@ -31,7 +31,7 @@ import { logAndProgress } from './helpers.js';
 export async function zipFiles(files, useTarGz, progressCallback) {
   const path = await import('path');
   const fs = await import('fs');
-  const archiver = (await import('archiver')).default;
+  const { TarArchive, ZipArchive } = await import('archiver');
 
   return new Promise((resolve, reject) => {
     logAndProgress('Creating in-memory archive...', progressCallback);
@@ -39,11 +39,11 @@ export async function zipFiles(files, useTarGz, progressCallback) {
 
     let archive;
     if (useTarGz) {
-      archive = archiver('tar', {
+      archive = new TarArchive({
         gzip: { level: 9 },
       });
     } else {
-      archive = archiver('zip', {
+      archive = new ZipArchive({
         zlib: { level: 9 },
       });
     }

package/lib/util/artifacts.js

@@ -0,0 +1,189 @@
+/*
+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 fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { logAndProgress } from './helpers.js';
+import { getArtifactRegistryClient } from '../clients.js';
+
+const AR_HOST = 'https://artifactregistry.googleapis.com';
+const AR_DOWNLOAD_PATH_PREFIX = '/download/v1/';
+const AR_DOWNLOAD_URL_SUFFIX = ':download?alt=media';
+
+/**
+ * Checks if the existing binary is up to date by comparing its SHA256 hash with the remote metadata.
+ * If the binary is out of date, it removes it.
+ * @param {string} binPath - Path to the local binary.
+ * @param {object} artifactParams - Parameters for the remote artifact.
+ * @param {string} artifactParams.project - Artifact Registry project.
+ * @param {string} artifactParams.location - Artifact Registry location.
+ * @param {string} artifactParams.repository - Artifact Registry repository.
+ * @param {string} artifactParams.artifactPath - Path to the artifact within the repository.
+ * @param {string} artifactParams.displayName - A friendly name for logging.
+ * @param {string} accessToken - Access token for authentication.
+ * @param {function} progressCallback - Progress callback.
+ * @returns {Promise<boolean>} True if the binary is up to date, false otherwise.
+ */
+export async function isBinaryUpToDate(
+  binPath,
+  artifactParams,
+  accessToken,
+  progressCallback
+) {
+  const { project, location, repository, artifactPath, displayName } =
+    artifactParams;
+
+  if (!fs.existsSync(binPath)) {
+    return false;
+  }
+
+  try {
+    await logAndProgress(
+      `Checking for ${displayName} updates...`,
+      progressCallback,
+      'debug'
+    );
+
+    const artifactRegistryClient = await getArtifactRegistryClient(
+      project,
+      accessToken
+    );
+    const resourceName = artifactRegistryClient.filePath(
+      project,
+      location,
+      repository,
+      artifactPath
+    );
+
+    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(
+        `${displayName} binary is up to date.`,
+        progressCallback,
+        'debug'
+      );
+      return true;
+    }
+
+    await logAndProgress(
+      `${displayName} binary is out of date. Removing existing binary.`,
+      progressCallback,
+      'debug'
+    );
+    fs.unlinkSync(binPath);
+    return false;
+  } catch (error) {
+    await logAndProgress(
+      `Could not check for ${displayName} updates: ${error.message}. Downloading the new binary.`,
+      progressCallback,
+      'debug'
+    );
+    return false; // On error, fallback to downloading the new binary
+  }
+}
+
+/**
+ * Downloads a binary from Artifact Registry if it doesn't exist or is out of date.
+ * @param {string} binPath - Path where the binary should be stored.
+ * @param {object} artifactParams - Parameters for the remote artifact.
+ * @param {string} artifactParams.project - Artifact Registry project.
+ * @param {string} artifactParams.location - Artifact Registry location.
+ * @param {string} artifactParams.repository - Artifact Registry repository.
+ * @param {string} artifactParams.artifactPath - Path to the artifact within the repository.
+ * @param {string} artifactParams.displayName - A friendly name for logging.
+ * @param {string} accessToken - Access token for authentication.
+ * @param {function} progressCallback - Progress callback.
+ * @returns {Promise<string|null>} Path to the binary or null if it fails.
+ */
+export async function ensureRepositoryDownloaded(
+  binPath,
+  artifactParams,
+  accessToken,
+  progressCallback
+) {
+  const { project, location, repository, artifactPath, displayName } =
+    artifactParams;
+  const binDir = path.dirname(binPath);
+
+  if (
+    await isBinaryUpToDate(
+      binPath,
+      artifactParams,
+      accessToken,
+      progressCallback
+    )
+  ) {
+    return binPath;
+  }
+
+  await logAndProgress(`Downloading ${displayName}...`, progressCallback);
+
+  try {
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+
+    const artifactRegistryClient = await getArtifactRegistryClient(
+      project,
+      accessToken
+    );
+    const resourceName = artifactRegistryClient.filePath(
+      project,
+      location,
+      repository,
+      artifactPath
+    );
+
+    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 ${displayName}: ${error.message}`,
+      progressCallback,
+      'debug'
+    );
+    return null;
+  }
+}