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

package/gemini-extension.json

@@ -7,5 +7,17 @@
       "args": ["-y", "@google-cloud/cloud-run-mcp"]
     }
   },
+  "settings": [
+    {
+      "name": "Project ID",
+      "description": "Google Cloud project ID to use for Cloud Run operations.",
+      "envVar": "GOOGLE_CLOUD_PROJECT"
+    },
+    {
+      "name": "Region",
+      "description": "Google Cloud region where Cloud Run services will be managed.",
+      "envVar": "GOOGLE_CLOUD_REGION"
+    }
+  ],
   "contextFileName": "gemini-extension/GEMINI.md"
 }

package/lib/deployment/constants.js

@@ -21,12 +21,14 @@ export const DEPLOYMENT_CONFIG = {
   IMAGE_TAG: 'latest',
   LABEL_CREATED_BY: 'cloud-run-mcp',
   DEFAULT_NODE_BASE_IMAGE: 'nodejs22',
+  DEFAULT_PYTHON_BASE_IMAGE: 'python314',
   NO_BUILD_IMAGE_TYPE: 'scratch',
 };
 
 export const TEMP_PATHS = {
   BASE: '.cloud-run-mcp',
   SUBDIR: 'source',
+  BIN_SUBDIR: 'bin',
 };
 
 export const REQUIRED_APIS = {
@@ -49,6 +51,7 @@ export const DEPLOYMENT_TYPES = {
 
 export const RUNTIMES = {
   NODEJS: 'nodejs',
+  PYTHON: 'python',
 };
 
 export const MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES = 250 * 1024 * 1024; // 250 MiB

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';
 
 /**
@@ -259,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;
@@ -316,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,

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
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",

package/test/local/deployment-helpers.test.js

@@ -50,7 +50,7 @@ describe('Deployment Helpers', () => {
     assert.equal(result.hasDockerfile, true);
   });
 
-  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+  test('makeFileDeploymentMetadata correctly identifies Node.js project', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -69,75 +69,13 @@ describe('Deployment Helpers', () => {
       return false;
     });
 
-    // Mock readFileSync for package.json
-    fsMock.readFileSync.mock.mockImplementation(() =>
-      JSON.stringify({
-        scripts: { start: 'node server.js' },
-      })
-    );
-
     const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
 
     assert.equal(result.hasDockerfile, false);
     assert.equal(result.deploymentAttrs.runtime, 'nodejs');
-    assert.deepEqual(result.deploymentAttrs.cmd, ['node']);
-    assert.deepEqual(result.deploymentAttrs.args, ['server.js']);
-  });
-
-  test('makeFileDeploymentMetadata ignores Node.js if engines.node is present', async () => {
-    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
-      fs: fsMock,
-    });
-
-    const folderPath = '/absolute/path/to/node-app-engines';
-
-    fsMock.statSync.mock.mockImplementation(() => ({
-      isDirectory: () => true,
-    }));
-
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.endsWith('package.json')) return true;
-      return false;
-    });
-
-    fsMock.readFileSync.mock.mockImplementation(() =>
-      JSON.stringify({
-        scripts: { start: 'node server.js' },
-        engines: { node: '>=14' },
-      })
-    );
-
-    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
-
-    assert.equal(result.deploymentAttrs.runtime, undefined);
-  });
-
-  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
-    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
-      fs: fsMock,
-    });
-
-    const folderPath = '/absolute/path/to/bad-json-app';
-
-    fsMock.statSync.mock.mockImplementation(() => ({
-      isDirectory: () => true,
-    }));
-
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.endsWith('package.json')) return true;
-      return false;
-    });
-
-    // Mock readFileSync to return invalid JSON
-    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
-
-    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
-
-    // Should return empty deployment attrs
-    assert.equal(result.deploymentAttrs.runtime, undefined);
   });
 
-  test('canDeployWithoutBuild returns true for valid Node.js zip deploy', async () => {
+  test('canDeployWithoutBuild returns true for valid Node.js project', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -146,9 +84,6 @@ describe('Deployment Helpers', () => {
       hasDockerfile: false,
       deploymentAttrs: {
         runtime: 'nodejs',
-        cmd: ['node'],
-        args: ['index.js'],
-        baseImage: 'base-image',
       },
     };
 
@@ -164,15 +99,13 @@ describe('Deployment Helpers', () => {
       hasDockerfile: true,
       deploymentAttrs: {
         runtime: 'nodejs',
-        cmd: ['node'],
-        args: ['index.js'],
       },
     };
 
     assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
   });
 
-  test('createDirectSourceDeploymentContainer creates correct object', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object without envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -204,28 +137,43 @@ describe('Deployment Helpers', () => {
     });
   });
 
-  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object with envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
 
-    const folderPath = '/absolute/path/to/bad-json-app';
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
+      deploymentAttrs: {
+        cmd: ['node'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
+        envVars: {
+          PORT: '8080',
+          NODE_ENV: 'production',
+        },
+      },
+    };
 
-    fsMock.statSync.mock.mockImplementation(() => ({
-      isDirectory: () => true,
-    }));
+    const result =
+      deploymentHelpers.createDirectSourceDeploymentContainer(input);
 
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.endsWith('package.json')) return true;
-      return false;
+    assert.deepEqual(result, {
+      image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
+      baseImageUri: 'gcr.io/google-appengine/nodejs',
+      sourceCode: {
+        cloudStorageSource: {
+          bucket: 'test-bucket',
+          object: 'source.tar.gz',
+        },
+      },
+      command: ['node'],
+      args: ['server.js'],
+      env: [
+        { name: 'PORT', value: '8080' },
+        { name: 'NODE_ENV', value: 'production' },
+      ],
     });
-
-    // Mock readFileSync to return invalid JSON
-    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
-
-    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
-
-    // Should return empty deployment attrs
-    assert.equal(result.deploymentAttrs.runtime, undefined);
   });
 });

package/test/local/source-processor.test.js

@@ -75,171 +75,6 @@ describe('Source Processor', () => {
     assert.ok(cpCall, 'Should call cp -R for directories');
   });
 
-  test('installDependencies runs npm install for Node.js', async () => {
-    // We need to mock fs.existsSync as well
-    const fsMock = {
-      existsSync: mock.fn(),
-    };
-
-    const sourceProcessor = await esmock(
-      '../../lib/deployment/source-processor.js',
-      {
-        'node:fs': fsMock,
-        'node:fs/promises': fspMock,
-        'node:child_process': childProcessMock,
-      }
-    );
-
-    const targetDir = '/temp/dir';
-    const deploymentAttrs = {
-      runtime: 'nodejs',
-      cmd: ['node', 'server.js'],
-      args: ['server.js'],
-      baseImage: 'node:22',
-    };
-    const progressCallback = mock.fn();
-
-    // Mock existsSync
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.includes('node_modules')) return false; // not installed yet
-      if (p.includes('package-lock.json')) return false; // no lock file
-      return false;
-    });
-
-    // Mock exec for npm install
-    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
-      if (typeof opts === 'function') callback = opts;
-      if (callback) callback(null, 'ok', '');
-    });
-
-    await sourceProcessor.installDependencies(
-      targetDir,
-      deploymentAttrs,
-      progressCallback
-    );
-
-    const calls = childProcessMock.exec.mock.calls;
-    const npmCall = calls.find((call) =>
-      call.arguments[0].includes('npm install')
-    );
-    assert.ok(npmCall, 'Should run npm install');
-    assert.strictEqual(npmCall.arguments[1].cwd, targetDir);
-  });
-
-  test('installDependencies uses npm ci if lockfile exists', async () => {
-    const fsMock = {
-      existsSync: mock.fn(),
-    };
-
-    const sourceProcessor = await esmock(
-      '../../lib/deployment/source-processor.js',
-      {
-        'node:fs': fsMock,
-        'node:child_process': childProcessMock,
-      }
-    );
-
-    const targetDir = '/temp/dir';
-    const deploymentAttrs = {
-      runtime: 'nodejs',
-      cmd: ['node', 'server.js'],
-      args: ['server.js'],
-      baseImage: 'node:22',
-    };
-
-    // Mock existsSync
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.includes('node_modules')) return false;
-      if (p.includes('package-lock.json')) return true; // has lock file
-      return false;
-    });
-
-    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
-      if (typeof opts === 'function') callback = opts;
-      if (callback) callback(null, 'ok', '');
-    });
-
-    await sourceProcessor.installDependencies(
-      targetDir,
-      deploymentAttrs,
-      () => {}
-    );
-
-    const calls = childProcessMock.exec.mock.calls;
-    const npmCall = calls.find((call) => call.arguments[0].includes('npm ci'));
-    assert.ok(npmCall, 'Should run npm ci');
-  });
-
-  test('installDependencies skips if node_modules exists', async () => {
-    const fsMock = {
-      existsSync: mock.fn(),
-    };
-
-    const sourceProcessor = await esmock(
-      '../../lib/deployment/source-processor.js',
-      {
-        'node:fs': fsMock,
-        'node:child_process': childProcessMock,
-      }
-    );
-
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.includes('node_modules')) return true;
-      return false;
-    });
-
-    // clear mock calls
-    childProcessMock.exec.mock.resetCalls();
-
-    await sourceProcessor.installDependencies(
-      '/dir',
-      {
-        runtime: 'nodejs',
-        cmd: ['node', 'server.js'],
-        args: ['server.js'],
-        baseImage: 'node:22',
-      },
-      () => {}
-    );
-
-    assert.equal(childProcessMock.exec.mock.callCount(), 0);
-  });
-
-  test('installDependencies logs warn on failure but does not throw', async () => {
-    const fsMock = { existsSync: mock.fn(() => false) };
-    const sourceProcessor = await esmock(
-      '../../lib/deployment/source-processor.js',
-      {
-        'node:fs': fsMock,
-        'node:child_process': childProcessMock,
-      }
-    );
-
-    childProcessMock.exec.mock.mockImplementation((cmd, opts, callback) => {
-      if (typeof opts === 'function') callback = opts;
-      callback(new Error('npm failed'));
-    });
-
-    const consoleLogMock = mock.method(console, 'log');
-
-    await assert.doesNotReject(async () => {
-      await sourceProcessor.installDependencies('/dir', { runtime: 'nodejs' });
-    });
-
-    assert.equal(
-      consoleLogMock.mock.callCount(),
-      1,
-      'console.log should be called once'
-    );
-    const logArgs = consoleLogMock.mock.calls[0].arguments;
-    assert.ok(
-      logArgs[0].includes('Dependency installation failed: npm failed'),
-      'console.log should contain the error message'
-    );
-
-    consoleLogMock.mock.restore();
-  });
-
   test('cleanupTempDirectory removes directory', async () => {
     const fsMock = {
       existsSync: mock.fn(() => true),

package/test/local/universal-maker.test.js

@@ -0,0 +1,248 @@
+/*
+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 { test, describe, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import esmock from 'esmock';
+
+describe('Universal Maker', () => {
+  const fsMock = {
+    existsSync: mock.fn(),
+    mkdirSync: mock.fn(),
+    chmodSync: mock.fn(),
+    readFileSync: mock.fn(),
+    rmSync: mock.fn(),
+    unlinkSync: mock.fn(),
+    createWriteStream: mock.fn(),
+  };
+
+  const cryptoMock = {
+    createHash: mock.fn(),
+  };
+
+  const childProcessMock = {
+    exec: mock.fn(),
+  };
+
+  const osMock = {
+    homedir: () => '/home/user',
+    tmpdir: () => '/tmp',
+  };
+
+  const helpersMock = {
+    logAndProgress: mock.fn(),
+  };
+
+  const clientsMock = {
+    getArtifactRegistryClient: mock.fn(),
+  };
+
+  test('runUniversalMaker skips download if binary exists and runs successfully', async () => {
+    fsMock.existsSync.mock.resetCalls();
+    fsMock.readFileSync.mock.resetCalls();
+    childProcessMock.exec.mock.resetCalls();
+
+    const localContent = 'local content';
+    const sha256 =
+      'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+
+    cryptoMock.createHash.mock.mockImplementation(() => ({
+      update: mock.fn(() => ({
+        digest: mock.fn(() => sha256),
+      })),
+    }));
+
+    // Mock binary exists
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('universal_maker')) return true;
+      if (p.includes('build_output.json')) return true;
+      return false;
+    });
+
+    fsMock.readFileSync.mock.mockImplementation((p) => {
+      if (p.includes('universal_maker')) return localContent;
+      if (p.includes('build_output.json')) {
+        return JSON.stringify({
+          command: 'node',
+          args: ['index.js'],
+          runtime: 'nodejs20',
+          envVars: { DEBUG: 'true' },
+        });
+      }
+      return '';
+    });
+
+    // Mock Artifact Registry client
+    const artifactRegistryClientMock = {
+      filePath: mock.fn(
+        (p, l, r, f) =>
+          `projects/${p}/locations/${l}/repositories/${r}/files/${f}`
+      ),
+      getFile: mock.fn(() => [
+        {
+          hashes: [
+            {
+              type: 'SHA256',
+              value: Buffer.from(sha256, 'hex').toString('base64'),
+            },
+          ],
+        },
+      ]),
+    };
+    clientsMock.getArtifactRegistryClient.mock.mockImplementation(
+      () => artifactRegistryClientMock
+    );
+
+    const um = await esmock('../../lib/deployment/universal-maker.js', {
+      fs: fsMock,
+      child_process: childProcessMock,
+      os: osMock,
+      crypto: cryptoMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/clients.js': clientsMock,
+    });
+
+    // Mock exec only for binary execution
+    childProcessMock.exec.mock.mockImplementation((cmd, cb) => {
+      cb(null, { stdout: '', stderr: '' });
+    });
+
+    // runUniversalMaker(appDir, accessToken, progressCallback)
+    const result = await um.runUniversalMaker(
+      '/app/dir',
+      'fake-token',
+      mock.fn()
+    );
+
+    assert.ok(result);
+    assert.equal(result.command, 'node');
+    assert.deepEqual(result.args, ['index.js']);
+    assert.equal(result.runtime, 'nodejs20');
+
+    // Verify bin check was performed
+    const binExistsCall = fsMock.existsSync.mock.calls.find((c) =>
+      c.arguments[0].includes('universal_maker')
+    );
+    assert.ok(binExistsCall);
+  });
+
+  test('runUniversalMaker downloads binary if missing', async () => {
+    fsMock.existsSync.mock.resetCalls();
+    fsMock.readFileSync.mock.resetCalls();
+    childProcessMock.exec.mock.resetCalls();
+
+    let downloaded = false;
+
+    // Mock binary missing first, then exists after "download"
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.includes('universal_maker')) return downloaded;
+      if (p.includes('build_output.json')) return true;
+      return true; // for dir checks
+    });
+
+    // Mock Artifact Registry client for download
+    const artifactRegistryClientMock = {
+      filePath: mock.fn(
+        (p, l, r, f) =>
+          `projects/${p}/locations/${l}/repositories/${r}/files/${f}`
+      ),
+      getFile: mock.fn(() => [{ hashes: [] }]), // trigger download
+      auth: {
+        request: mock.fn(() => {
+          downloaded = true;
+          return {
+            data: {
+              pipe: (dest) => {
+                setTimeout(() => dest.emit('finish'), 10);
+                return dest;
+              },
+            },
+          };
+        }),
+      },
+    };
+    clientsMock.getArtifactRegistryClient.mock.mockImplementation(
+      () => artifactRegistryClientMock
+    );
+
+    const writeStreamMock = {
+      on: mock.fn(function (event, cb) {
+        if (event === 'finish') this.finishCb = cb;
+        return this;
+      }),
+      emit: mock.fn(function (event) {
+        if (event === 'finish' && this.finishCb) this.finishCb();
+      }),
+      pipeFrom: mock.fn(),
+    };
+    fsMock.createWriteStream = mock.fn(() => writeStreamMock);
+
+    fsMock.readFileSync.mock.mockImplementation(() =>
+      JSON.stringify({ command: 'npm', args: ['start'] })
+    );
+
+    const um = await esmock('../../lib/deployment/universal-maker.js', {
+      fs: fsMock,
+      child_process: childProcessMock,
+      os: osMock,
+      crypto: cryptoMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/clients.js': clientsMock,
+    });
+
+    // Mock exec only for binary execution
+    childProcessMock.exec.mock.mockImplementation((cmd, cb) => {
+      cb(null, { stdout: '', stderr: '' });
+    });
+
+    // runUniversalMaker(appDir, accessToken, progressCallback)
+    const result = await um.runUniversalMaker(
+      '/app/dir',
+      'fake-token',
+      mock.fn()
+    );
+
+    assert.ok(result);
+    assert.equal(result.command, 'npm');
+    assert.ok(downloaded);
+  });
+
+  test('runUniversalMaker returns null if binary not supported on platform', async () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+
+    try {
+      const um = await esmock('../../lib/deployment/universal-maker.js', {
+        fs: fsMock,
+        child_process: childProcessMock,
+        os: osMock,
+        crypto: cryptoMock,
+        '../../lib/util/helpers.js': helpersMock,
+        '../../lib/clients.js': clientsMock,
+      });
+
+      const result = await um.runUniversalMaker(
+        '/app/dir',
+        'fake-token',
+        mock.fn()
+      );
+      assert.equal(result, null);
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    }
+  });
+});