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

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.7.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",

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

@@ -0,0 +1,231 @@
+/*
+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';
+import { DEPLOYMENT_CONFIG } from '../../lib/deployment/constants.js';
+
+describe('Deployment Helpers', () => {
+  const fsMock = {
+    statSync: mock.fn(),
+    existsSync: mock.fn(),
+    readFileSync: mock.fn(),
+  };
+
+  test('makeFileDeploymentMetadata correctly identifies Dockerfile in folder', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/folder';
+
+    // Mock isFolder logic
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock Dockerfile check
+    fsMock.existsSync.mock.mockImplementation((filePath) => {
+      if (filePath.endsWith('Dockerfile') || filePath.endsWith('dockerfile'))
+        return true;
+      return false;
+    });
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.hasDockerfile, true);
+  });
+
+  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/node-app';
+
+    // Mock isFolder
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock existsSync
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('Dockerfile')) return false;
+      if (p.endsWith('package.json')) return true;
+      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 () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: false,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+        baseImage: 'base-image',
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), true);
+  });
+
+  test('canDeployWithoutBuild returns false if Dockerfile exists', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: true,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
+  });
+
+  test('createDirectSourceDeploymentContainer creates correct object', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
+      deploymentAttrs: {
+        cmd: ['node'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
+      },
+    };
+
+    const result =
+      deploymentHelpers.createDirectSourceDeploymentContainer(input);
+
+    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'],
+    });
+  });
+
+  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);
+  });
+});

package/test/local/mcp-server-stdio.test.js

@@ -0,0 +1,59 @@
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'child_process';
+import { waitForString } from './test-utils.js';
+
+describe('MCP Server stdio startup', () => {
+  let serverProcess;
+  let stderr = '';
+  const stdioMsg = 'Cloud Run MCP server stdio transport connected';
+
+  describe('when GCP_STDIO=true', () => {
+    before(async () => {
+      stderr = '';
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: { ...process.env, GCP_STDIO: 'true' },
+      });
+      stderr = await waitForString(serverProcess.stderr, stdioMsg);
+    });
+
+    after(() => {
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
+
+    test('should start in stdio mode', () => {
+      assert.ok(stderr.includes(stdioMsg));
+    });
+  });
+
+  describe('when GCP_STDIO=false', () => {
+    before(async () => {
+      stderr = '';
+      const env = { ...process.env };
+      env.GCP_STDIO = 'false';
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: env,
+      });
+      const stderrChunks = [];
+      serverProcess.stderr.on('data', (chunk) => {
+        stderrChunks.push(chunk);
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      stderr = Buffer.concat(stderrChunks).toString();
+    });
+
+    after(() => {
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
+
+    test('should not start in stdio mode', () => {
+      assert.ok(!stderr.includes(stdioMsg));
+    });
+  });
+});

package/test/local/mcp-server-streamable-http.test.js

@@ -3,6 +3,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { test, describe, before, after } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawn } from 'child_process';
+import { waitForString } from './test-utils.js';
 
 class MCPClient {
   client = null;
@@ -29,29 +30,32 @@ class MCPClient {
 describe('MCP Server in Streamble HTTP mode', () => {
   let client;
   let serverProcess;
-
-  before(async () => {
-    // Start MCP server as a child process
-    serverProcess = spawn('node', ['mcp-server.js'], {
-      cwd: process.cwd(),
-      env: { ...process.env, GCP_STDIO: 'false' },
-      stdio: 'inherit',
+  let stdout = '';
+  const httpMsg = 'Cloud Run MCP server listening on port 3000';
+
+  describe('when GCP_STDIO=false', () => {
+    before(async () => {
+      stdout = '';
+      // Start MCP server as a child process
+      serverProcess = spawn('node', ['mcp-server.js'], {
+        cwd: process.cwd(),
+        env: { ...process.env, GCP_STDIO: 'false' },
+      });
+      stdout = await waitForString(serverProcess.stdout, httpMsg);
+
+      client = new MCPClient('http-server');
     });
 
-    // Wait for server to start (better: poll the port, here we just wait)
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    client = new MCPClient('http-server');
-  });
-
-  after(async () => {
-    await client.cleanup();
-    if (serverProcess) {
-      serverProcess.kill();
-    }
-  });
+    after(async () => {
+      await client.cleanup();
+      if (serverProcess) {
+        serverProcess.kill();
+      }
+    });
 
-  test('should start an HTTP server', async () => {
-    await client.connectToServer('http://localhost:3000/mcp');
+    test('should start an HTTP server', async () => {
+      await client.connectToServer('http://localhost:3000/mcp');
+      assert.ok(stdout.includes(httpMsg));
+    });
   });
 });