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

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

package/lib/deployment/source-processor.js

@@ -0,0 +1,124 @@
+/*
+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 'node:path';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import util from 'node:util';
+import { exec } from 'node:child_process';
+import { TEMP_PATHS, RUNTIMES } from './constants.js';
+import { logAndProgress } from '../util/helpers.js';
+
+const execAsync = util.promisify(exec);
+
+/**
+ * Prepares a temporary directory with the source code for deployment.
+ * Handles both file paths and content objects.
+ *
+ * @param {Array<string|{filename: string, content: string|Buffer}>} files - Files to deploy.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<string>} The path to the prepared temporary directory.
+ */
+export async function prepareSourceDirectory(files, progressCallback) {
+  const homeDir = os.homedir();
+  const tempBaseDir = path.join(homeDir, TEMP_PATHS.BASE, TEMP_PATHS.SUBDIR);
+  const sourceName = path.basename(files[0]);
+
+  const tempDir = path.join(tempBaseDir, `${sourceName}-${Date.now()}`);
+
+  // Creates a temporary directory to store the source code.
+  await fsp.mkdir(tempDir, { recursive: true });
+
+  // Copies the source code to the temporary directory.
+  for (const file of files) {
+    const stats = await fsp.stat(file);
+    if (stats.isDirectory()) {
+      // Copy directory contents
+      await execAsync(`cp -R "${file}/." "${tempDir}/"`);
+    } else {
+      const destPath = path.join(tempDir, path.basename(file));
+      await fsp.copyFile(file, destPath);
+    }
+  }
+
+  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.
+ *
+ * @param {string} dirPath - Path to the directory to remove.
+ */
+export async function cleanupTempDirectory(dirPath) {
+  if (!dirPath) return;
+
+  try {
+    if (fs.existsSync(dirPath)) {
+      await fsp.rm(dirPath, { recursive: true, force: true });
+    }
+  } catch (cleanupError) {
+    console.error(`Failed to cleanup temp directory ${dirPath}:`, cleanupError);
+  }
+}

package/lib/util/archive.js

@@ -0,0 +1,104 @@
+/*
+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 { logAndProgress } from './helpers.js';
+
+/**
+ * Creates a zip archive in memory from a list of file paths and/or file objects.
+ * File objects should have `filename` (string) and `content` (Buffer or string) properties.
+ *
+ * @param {Array<string|{filename: string, content: Buffer|string}>} files - An array of items to zip.
+ * Each item can be a string representing a file/directory path, or an object
+ * with `filename` and `content` properties for in-memory files.
+ * @param {boolean} [useTarGz] - If true, creates a tar.gz archive instead of a zip.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<Buffer>} A promise that resolves with a Buffer containing the zip data.
+ * @throws {Error} If an input file path is not found, an input item has an invalid format, or an archiver error occurs.
+ */
+export async function zipFiles(files, useTarGz, progressCallback) {
+  const path = await import('path');
+  const fs = await import('fs');
+  const archiver = (await import('archiver')).default;
+
+  return new Promise((resolve, reject) => {
+    logAndProgress('Creating in-memory archive...', progressCallback);
+    const chunks = [];
+
+    let archive;
+    if (useTarGz) {
+      archive = archiver('tar', {
+        gzip: { level: 9 },
+      });
+    } else {
+      archive = archiver('zip', {
+        zlib: { level: 9 },
+      });
+    }
+
+    archive.on('data', (chunk) => chunks.push(chunk));
+    archive.on('end', () => {
+      logAndProgress(
+        `Archive created successfully. Total size: ${archive.pointer()} bytes`,
+        progressCallback
+      );
+      resolve(Buffer.concat(chunks));
+    });
+
+    archive.on('warning', (err) => {
+      const warningMessage = `Archiver warning: ${err}`;
+      logAndProgress(warningMessage, progressCallback, 'warn');
+      if (err.code !== 'ENOENT') {
+        // ENOENT is often just a warning, others might be more critical for zip
+        reject(err);
+      }
+    });
+
+    archive.on('error', (err) => {
+      const errorMessage = `Archiver error: ${err.message}`;
+      console.error(errorMessage, err);
+      logAndProgress(errorMessage, progressCallback, 'error');
+      reject(err);
+    });
+
+    files.forEach((file) => {
+      if (typeof file === 'object' && 'filename' in file && 'content' in file) {
+        archive.append(file.content, { name: file.filename });
+      } else if (typeof file === 'string') {
+        let pathInput = file;
+
+        // This is a "hack" to better support WSL on Windows. AI agents tend to send path that start with '/c' in that case. Re-write it to '/mnt/c'
+        if (pathInput.startsWith('/c')) {
+          pathInput = `/mnt${pathInput}`;
+        }
+        const filePath = path.resolve(pathInput);
+        if (!fs.existsSync(filePath)) {
+          throw new Error(`File or directory not found: ${filePath}`);
+        }
+
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory()) {
+          archive.directory(filePath, false);
+        } else {
+          archive.file(filePath, { name: path.basename(filePath) });
+        }
+      } else {
+        throw new Error(`Invalid file format: ${JSON.stringify(file)}`);
+      }
+    });
+
+    archive.finalize();
+  });
+}

package/lib/util/helpers.js

@@ -0,0 +1,42 @@
+/*
+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.
+*/
+
+/**
+ * Helper function to log a message and call the progress callback.
+ * @param {string} message - The message to log.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @param {'debug' | 'info' | 'warn' | 'error'} [severity='info'] - The severity level of the message.
+ */
+export async function logAndProgress(
+  message,
+  progressCallback,
+  severity = 'info'
+) {
+  switch (severity) {
+    case 'error':
+      console.error(message);
+      break;
+    case 'warn':
+    case 'info':
+    case 'debug':
+    default:
+      console.log(message);
+      break;
+  }
+  if (progressCallback) {
+    progressCallback({ level: severity, data: message });
+  }
+}

package/mcp-server.js

@@ -16,7 +16,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import express from 'express';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 // Support SSE for backward compatibility
@@ -26,8 +26,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { registerTools, registerToolsRemote } from './tools/tools.js';
 import { SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { registerPrompts } from './prompts.js';
-import { checkGCP } from './lib/gcp-metadata.js';
-import { ensureGCPCredentials } from './lib/gcp-auth-check.js';
+import { checkGCP } from './lib/cloud-api/metadata.js';
+import { ensureGCPCredentials } from './lib/cloud-api/auth.js';
 import 'dotenv/config';
 
 const gcpInfo = await checkGCP();
@@ -43,10 +43,7 @@ function makeLoggingCompatibleWithStdio() {
 }
 
 function shouldStartStdio() {
-  if (process.env.GCP_STDIO) {
-    return true;
-  }
-  if (gcpInfo && gcpInfo.project) {
+  if (process.env.GCP_STDIO === 'false' || (gcpInfo && gcpInfo.project)) {
     return false;
   }
   return true;
@@ -61,6 +58,10 @@ const envProjectId = process.env.GOOGLE_CLOUD_PROJECT || undefined;
 const envRegion = process.env.GOOGLE_CLOUD_REGION;
 const defaultServiceName = process.env.DEFAULT_SERVICE_NAME;
 const skipIamCheck = process.env.SKIP_IAM_CHECK !== 'false';
+const enableHostValidation = process.env.ENABLE_HOST_VALIDATION === 'true';
+const allowedHosts = process.env.ALLOWED_HOSTS
+  ? process.env.ALLOWED_HOSTS.split(',')
+  : undefined;
 
 async function getServer() {
   // Create an MCP server with implementation details
@@ -125,10 +126,20 @@ if (shouldStartStdio()) {
   await server.connect(stdioTransport);
   console.log('Cloud Run MCP server stdio transport connected');
 } else {
-  console.log('Running on GCP, stdio transport will not be started.');
+  // non-stdio mode
+  console.log('Stdio transport mode is turned off.');
   gcpCredentialsAvailable = await ensureGCPCredentials();
-  const app = express();
-  app.use(express.json());
+
+  const app = enableHostValidation
+    ? createMcpExpressApp({ allowedHosts })
+    : createMcpExpressApp({ host: null });
+
+  if (!enableHostValidation) {
+    console.warn(
+      `Warning: Server is running without DNS rebinding protection. ` +
+        'Consider enabling host validation by passing env variable ENABLE_HOST_VALIDATION=true and adding the ALLOWED_HOSTS to restrict allowed hosts'
+    );
+  }
 
   app.post('/mcp', async (req, res) => {
     console.log('/mcp Received:', req.body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",
@@ -9,14 +9,16 @@
   },
   "scripts": {
     "deploy": "gcloud run deploy cloud-run-mcp --source . --no-invoker-iam-check",
-    "test:deploy": "node test/need-gcp/cloud-run-deploy.test.js",
+    "test:workflows": "node --test test/need-gcp/workflows/*.test.js",
+    "test:deploy": "node test/need-gcp/deployer.test.js",
     "test:projects": "node test/need-gcp/gcp-projects.test.js",
     "test:services": "node test/need-gcp/cloud-run-services.test.js",
     "test:gcp-auth": "node test/need-gcp/gcp-auth-check.test.js",
     "test:prompts": "node --test test/local/prompts.test.js",
     "test:mcp": "node --test test/local/mcp-server.test.js",
     "test:tools": "node --test test/local/tools.test.js",
-    "test": "node --test test/local/*.test.js",
+    "test:local": "node --test test/local/*.test.js test/local/**/*.test.js",
+    "test": "c8 --check-coverage npm run test:local",
     "mcp-inspector": "npx @modelcontextprotocol/inspector node mcp-server.js",
     "start": "node mcp-server.js",
     "lint:check": "prettier --check .",
@@ -43,10 +45,10 @@
     "@google-cloud/cloudbuild": "^5.0.1",
     "@google-cloud/logging": "^11.2.0",
     "@google-cloud/resource-manager": "^6.0.1",
-    "@google-cloud/run": "^2.0.1",
+    "@google-cloud/run": "^3.1.0",
     "@google-cloud/service-usage": "^4.1.0",
     "@google-cloud/storage": "^7.16.0",
-    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "archiver": "^7.0.1",
     "dotenv": "^17.2.1",
     "express": "^5.1.0",
@@ -54,6 +56,7 @@
     "zod": "^3.25.76"
   },
   "devDependencies": {
+    "c8": "^10.1.3",
     "esmock": "^2.7.1",
     "prettier": "3.6.2"
   }