@google-cloud/cloud-run-mcp 1.6.0 → 1.8.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 (eg., 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

@@ -23,26 +23,35 @@ import { logAndProgress } from './helpers.js';
  * @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, progressCallback) {
+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 zip archive...', progressCallback);
+    logAndProgress('Creating in-memory archive...', progressCallback);
     const chunks = [];
-    const archive = archiver('zip', {
-      zlib: { level: 9 },
-    });
+
+    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(
-        `Files zipped successfully. Total size: ${archive.pointer()} bytes`,
+        `Archive created successfully. Total size: ${archive.pointer()} bytes`,
         progressCallback
       );
       resolve(Buffer.concat(chunks));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",
@@ -45,7 +45,7 @@
     "@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.24.3",
@@ -58,6 +58,6 @@
   "devDependencies": {
     "c8": "^10.1.3",
     "esmock": "^2.7.1",
-    "prettier": "3.6.2"
+    "prettier": "^3.8.0"
   }
 }

package/test/local/clients.test.js

@@ -0,0 +1,146 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { getClient } from '../../lib/clients.js';
+
+describe('getClient Helper', () => {
+  class MockClient {
+    constructor(options) {
+      this.options = options;
+    }
+  }
+
+  test('creates new client instance with authClient when access token provided', async () => {
+    const projectId = 'test-project-1';
+    const accessToken = 'fake-token-1';
+    const service = 'run'; // Must match keys in lib/clients.js clients object
+    const key = projectId + accessToken;
+
+    const client = await getClient(
+      service,
+      key,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+
+    assert.ok(client instanceof MockClient);
+    assert.strictEqual(client.options.projectId, projectId);
+    assert.ok(client.options.authClient);
+
+    const headers = client.options.authClient.getRequestHeaders();
+    assert.strictEqual(headers.get('Authorization'), 'Bearer fake-token-1');
+  });
+
+  test('creates new client instance WITHOUT authClient when NO access token provided', async () => {
+    const projectId = 'test-project-2';
+    const service = 'run';
+    const key = projectId;
+
+    const client = await getClient(
+      service,
+      key,
+      async () => MockClient,
+      { projectId },
+      null
+    );
+
+    assert.ok(client instanceof MockClient);
+    assert.strictEqual(client.options.projectId, projectId);
+    assert.strictEqual(client.options.authClient, undefined);
+  });
+
+  test('caches client instances by key', async () => {
+    const projectId = 'test-project-3';
+    const accessToken = 'token-A';
+    const service = 'run';
+    const key = projectId + accessToken;
+
+    const client1 = await getClient(
+      service,
+      key,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+
+    const client2 = await getClient(
+      service,
+      key,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+
+    assert.strictEqual(client1, client2);
+  });
+
+  test('creates DIFFERENT client instances for different keys', async () => {
+    const projectId = 'test-project-4';
+    const service = 'run';
+
+    const client1 = await getClient(
+      service,
+      projectId + 'token-A',
+      async () => MockClient,
+      { projectId },
+      'token-A'
+    );
+
+    const client2 = await getClient(
+      service,
+      projectId + 'token-B',
+      async () => MockClient,
+      { projectId },
+      'token-B'
+    );
+
+    assert.notStrictEqual(client1, client2);
+
+    const h1 = client1.options.authClient.getRequestHeaders();
+    assert.strictEqual(h1.get('Authorization'), 'Bearer token-A');
+
+    const h2 = client2.options.authClient.getRequestHeaders();
+    assert.strictEqual(h2.get('Authorization'), 'Bearer token-B');
+  });
+
+  test('supports different services', async () => {
+    const projectId = 'test-project-5';
+    const accessToken = 'token-C';
+
+    const runClient = await getClient(
+      'run',
+      projectId + accessToken,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+
+    const storageClient = await getClient(
+      'storage',
+      projectId + accessToken,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+
+    assert.notStrictEqual(runClient, storageClient); // Different maps
+    assert.ok(runClient.options.authClient);
+    assert.ok(storageClient.options.authClient);
+  });
+
+  test('passes additional options correctly', async () => {
+    const projectId = 'test-project-6';
+    const service = 'run';
+    const extraOpt = 'foo';
+
+    const client = await getClient(
+      service,
+      projectId,
+      async () => MockClient,
+      { projectId, extraOpt },
+      null
+    );
+
+    assert.strictEqual(client.options.extraOpt, extraOpt);
+  });
+});