@google-cloud/cloud-run-mcp 1.0.0

package/mcp-server.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/*
+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 express from 'express';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+// Support SSE for backward compatibility
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+// Support stdio, as it is easier to use locally
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerTools, registerToolsRemote } from './tools.js';
+import { registerPrompts } from './prompts.js';
+import { checkGCP } from './lib/gcp-metadata.js';
+import { ensureGCPCredentials } from './lib/gcp-auth-check.js';
+import 'dotenv/config';
+
+const gcpInfo = await checkGCP();
+
+/**
+ * Ensure that console.log and console.error are compatible with stdio.
+ * (Right now, it just disables them)
+ */
+function makeLoggingCompatibleWithStdio() {
+  // redirect all console.log (which usually go to to stdout) to stderr.
+  console.log = console.error;
+}
+
+function shouldStartStdio() {
+  if (process.env.GCP_STDIO) {
+    return true;
+  }
+  if (gcpInfo && gcpInfo.project) {
+    return false;
+  }
+  return true;
+}
+
+if (shouldStartStdio()) {
+  makeLoggingCompatibleWithStdio();
+  await ensureGCPCredentials();
+}
+
+// Read default configurations from environment variables
+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';
+
+async function getServer() {
+  // Create an MCP server with implementation details
+  const server = new McpServer(
+    {
+      name: 'cloud-run',
+      version: '1.0.0',
+    },
+    { capabilities: { logging: {} } }
+  );
+
+  // Get GCP metadata info once
+  const gcpInfo = await checkGCP();
+
+  // Determine the effective project and region based on priority: Env Var > GCP Metadata > Hardcoded default
+  const effectiveProjectId =
+    envProjectId || (gcpInfo && gcpInfo.project) || undefined;
+  const effectiveRegion =
+    envRegion || (gcpInfo && gcpInfo.region) || 'europe-west1';
+
+  if (shouldStartStdio() || !(gcpInfo && gcpInfo.project)) {
+    console.log('Using tools optimized for local or stdio mode.');
+    // Pass the determined defaults to the local tool registration
+    await registerTools(server, {
+      defaultProjectId: effectiveProjectId,
+      defaultRegion: effectiveRegion,
+      defaultServiceName,
+      skipIamCheck,
+    });
+  } else {
+    console.log(
+      `Running on GCP project: ${effectiveProjectId}, region: ${effectiveRegion}. Using tools optimized for remote use.`
+    );
+    // Pass the determined defaults to the remote tool registration
+    await registerToolsRemote(server, {
+      defaultProjectId: effectiveProjectId,
+      defaultRegion: effectiveRegion,
+      defaultServiceName,
+      skipIamCheck,
+    });
+  }
+
+  // Register prompts with the server
+  registerPrompts(server);
+
+  return server;
+}
+
+// stdio
+if (shouldStartStdio()) {
+  const stdioTransport = new StdioServerTransport();
+  const server = await getServer();
+  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.');
+  await ensureGCPCredentials();
+  const app = express();
+  app.use(express.json());
+
+  app.post('/mcp', async (req, res) => {
+    console.log('/mcp Received:', req.body);
+    const server = await getServer();
+    try {
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      res.on('close', () => {
+        console.log('Request closed');
+        transport.close();
+        server.close();
+      });
+    } catch (error) {
+      console.error('Error handling MCP request:', error);
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32603,
+            message: 'Internal server error',
+          },
+          id: null,
+        });
+      }
+    }
+  });
+
+  app.get('/mcp', async (req, res) => {
+    console.log('Received GET MCP request');
+    res.writeHead(405).end(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        error: {
+          code: -32000,
+          message: 'Method not allowed.',
+        },
+        id: null,
+      })
+    );
+  });
+
+  app.delete('/mcp', async (req, res) => {
+    console.log('Received DELETE MCP request');
+    res.writeHead(405).end(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        error: {
+          code: -32000,
+          message: 'Method not allowed.',
+        },
+        id: null,
+      })
+    );
+  });
+
+  // Support SSE for baackward compatibility
+  const sseTransports = {};
+
+  // Legacy SSE endpoint for older clients
+  app.get('/sse', async (req, res) => {
+    console.log('/sse Received:', req.body);
+    const server = await getServer();
+    // Create SSE transport for legacy clients
+    const transport = new SSEServerTransport('/messages', res);
+    sseTransports[transport.sessionId] = transport;
+
+    res.on('close', () => {
+      delete sseTransports[transport.sessionId];
+    });
+
+    await server.connect(transport);
+  });
+
+  // Legacy message endpoint for older clients
+  app.post('/messages', async (req, res) => {
+    console.log('/messages Received:', req.body);
+    const sessionId = req.query.sessionId;
+    const transport = sseTransports[sessionId];
+    if (transport) {
+      await transport.handlePostMessage(req, res, req.body);
+    } else {
+      res.status(400).send('No transport found for sessionId');
+    }
+  });
+
+  // Start the server
+  const PORT = process.env.PORT || 3000;
+  app.listen(PORT, () => {
+    console.log(`Cloud Run MCP server listening on port ${PORT}`);
+  });
+}
+
+// Handle server shutdown
+process.on('SIGINT', async () => {
+  console.log('Shutting down server...');
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@google-cloud/cloud-run-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Cloud Run MCP deployment tool",
+  "main": "mcp-server.js",
+  "bin": {
+    "cloud-run-mcp": "mcp-server.js"
+  },
+  "scripts": {
+    "deploy": "gcloud run deploy cloud-run-mcp --source . --no-invoker-iam-check",
+    "test:deploy": "node test/test-deploy.js",
+    "test:create-project": "node test/test-create-project.js",
+    "test:service-logs": "node test/test-service-logs.js",
+    "test:gcp-auth": "node test/test-gcp-auth.js",
+    "test:prompts": "node --test test/test-prompts.js",
+    "test:mcp": "node --test test/test-mcp-server.js",
+    "test:tools": "node --test test/test-tools.js",
+    "test": "node test/run-all-tests.js",
+    "mcp-inspector": "npx @modelcontextprotocol/inspector node mcp-server.js",
+    "start": "node mcp-server.js",
+    "lint:check": "prettier --check .",
+    "lint": "prettier --write ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GoogleCloudPlatform/cloud-run-mcp.git"
+  },
+  "keywords": [
+    "mcp",
+    "cloud-run",
+    "gcp"
+  ],
+  "author": "steren@google.com",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/GoogleCloudPlatform/cloud-run-mcp/issues"
+  },
+  "homepage": "https://github.com/GoogleCloudPlatform/cloud-run-mcp#readme",
+  "dependencies": {
+    "@google-cloud/artifact-registry": "^4.0.1",
+    "@google-cloud/billing": "^5.0.1",
+    "@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/service-usage": "^4.1.0",
+    "@google-cloud/storage": "^7.16.0",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "archiver": "^7.0.1",
+    "dotenv": "^17.2.1",
+    "express": "^5.1.0",
+    "google-proto-files": "^5.0.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "esmock": "^2.7.1",
+    "prettier": "3.6.2"
+  }
+}

package/prompts.js

@@ -0,0 +1,96 @@
+/*
+ * 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 { z } from 'zod';
+
+export const registerPrompts = (server) => {
+  // Prompts will be registered here.
+  server.registerPrompt(
+    'deploy',
+    {
+      description: 'Deploys the current working directory to Cloud Run.',
+      argsSchema: {
+        name: z
+          .string()
+          .describe(
+            'Name of the Cloud Run service to deploy to.  Defaults to the name of the current directory'
+          )
+          .optional(),
+        project: z.string().describe('Google Cloud project ID').optional(),
+        region: z
+          .string()
+          .describe('Region where the services are located')
+          .optional(),
+      },
+    },
+    async ({ name, project, region }) => {
+      const serviceNamePrompt =
+        name ||
+        'a name for the application based on the current working directory.';
+      const projectPrompt = project ? ` in project ${project}` : '';
+      const regionPrompt = region ? ` in region ${region}` : '';
+
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Use the deploy_local_folder tool to deploy the current folder${projectPrompt}${regionPrompt}. The service name should be ${serviceNamePrompt}`,
+            },
+          },
+        ],
+      };
+    }
+  );
+
+  server.registerPrompt(
+    'logs',
+    {
+      description: 'Gets the logs for a Cloud Run service.',
+      argsSchema: {
+        service: z
+          .string()
+          .describe(
+            'Name of the Cloud Run service. Defaults to the name of the current directory.'
+          )
+          .optional(),
+        project: z.string().describe('Google Cloud project ID').optional(),
+        region: z
+          .string()
+          .describe('Region where the services are located')
+          .optional(),
+      },
+    },
+    async ({ service, project, region }) => {
+      const serviceNamePrompt =
+        service || 'named for the current working directory';
+      const projectPrompt = project ? ` in project ${project}` : '';
+      const regionPrompt = region ? ` in region ${region}` : '';
+
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Use get_service_log to get logs${projectPrompt}${regionPrompt} for the service ${serviceNamePrompt}`,
+            },
+          },
+        ],
+      };
+    }
+  );
+};

package/test/run-all-tests.js

@@ -0,0 +1,19 @@
+import { execSync } from 'child_process';
+
+const tests = [
+  'npm run test:deploy',
+  'npm run test:service-logs',
+  'npm run test:gcp-auth',
+  'npm run test:create-project',
+  'npm run test:prompts',
+];
+
+for (const test of tests) {
+  try {
+    console.log(`Running: ${test}`);
+    execSync(test, { stdio: 'inherit' });
+  } catch (error) {
+    console.error(`Failed to run: ${test}`);
+    process.exit(1);
+  }
+}

package/test/test-create-project.js

@@ -0,0 +1,77 @@
+/*
+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 readline from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
+import { createProjectAndAttachBilling } from '../lib/gcp-projects.js';
+
+/**
+ * Prompts the user for an optional project ID or allows them to proceed with auto-generation.
+ * Checks for a project ID from command line arguments first.
+ * @returns {Promise<string|undefined>} The Google Cloud project ID or undefined if auto-generation is chosen.
+ */
+async function getOptionalProjectId() {
+  let projectIdInput = process.argv[2]; // Get the third element (index 2) which is the first argument
+
+  if (projectIdInput && projectIdInput.trim() !== '') {
+    console.log(
+      `Using Project ID from command line argument: ${projectIdInput.trim()}`
+    );
+    return projectIdInput.trim();
+  }
+
+  const rl = readline.createInterface({ input, output });
+  projectIdInput = await rl.question(
+    'Enter a specific Project ID to use (or press Enter to auto-generate): '
+  );
+  rl.close();
+
+  if (projectIdInput && projectIdInput.trim() !== '') {
+    console.log(
+      `Attempting to create project with specified ID: ${projectIdInput.trim()}`
+    );
+    return projectIdInput.trim();
+  }
+  console.log('No Project ID specified. An ID will be auto-generated.');
+  return undefined;
+}
+
+async function main() {
+  try {
+    const optionalProjectId = await getOptionalProjectId();
+    console.log('Attempting to create a new project and attach billing...');
+    const newProjectResult =
+      await createProjectAndAttachBilling(optionalProjectId);
+
+    if (newProjectResult && newProjectResult.projectId) {
+      console.log(
+        `Successfully created project: ${newProjectResult.projectId}`
+      );
+      console.log(newProjectResult.billingMessage);
+      console.log('\nProject creation test completed successfully.');
+    } else {
+      console.error(
+        'Failed to create a new project or retrieve project details.'
+      );
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('Error during project creation test:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/test/test-deploy.js

@@ -0,0 +1,158 @@
+/*
+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 { deploy, deployImage } from '../lib/cloud-run-deploy.js';
+import readline from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Gets the project ID from command line arguments or prompts the user.
+ * If "new" is provided, it returns undefined to trigger new project creation.
+ * @returns {Promise<string|undefined>} The Google Cloud project ID or undefined.
+ */
+async function getProjectId() {
+  let projectIdInput = process.argv[2]; // Get the third element (index 2) which is the first argument
+
+  if (!projectIdInput) {
+    const rl = readline.createInterface({ input, output });
+    projectIdInput = await rl.question(
+      'Please enter your Google Cloud project ID: '
+    );
+    rl.close();
+  }
+
+  if (!projectIdInput || projectIdInput.trim() === '') {
+    console.error('No project ID provided. Exiting.');
+    process.exit(1);
+  }
+  if (projectIdInput.toLowerCase() === 'new') {
+    console.error(
+      'Project creation ("new") is now handled by test-create-project.js. Please provide an existing project ID. Exiting.'
+    );
+    process.exit(1);
+  }
+  console.log(`Using Project ID: ${projectIdInput}`);
+  return projectIdInput;
+}
+
+const projectIdToUse = await getProjectId();
+
+// Configuration for Go deployment with Dockerfile
+const configGoWithDockerfile = {
+  projectId: projectIdToUse, // Use the obtained project ID
+  serviceName: 'example-go-app-docker', // Name of the Cloud Run service
+  region: 'europe-west1', // Google Cloud region
+  files: [
+    'example-sources-to-deploy/main.go',
+    'example-sources-to-deploy/go.mod',
+    'example-sources-to-deploy/Dockerfile',
+  ],
+};
+
+// Configuration for Go deployment without Dockerfile (using buildpacks)
+const configGoWithoutDockerfile = {
+  projectId: projectIdToUse,
+  serviceName: 'example-go-app-buildpack',
+  region: 'europe-west1',
+  files: [
+    'example-sources-to-deploy/main.go',
+    'example-sources-to-deploy/go.mod',
+    // Dockerfile is intentionally omitted here
+  ],
+};
+
+// Configuration for Go deployment with file content (using buildpacks)
+const configGoWithContent = {
+  projectId: projectIdToUse,
+  serviceName: 'example-go-app-content',
+  region: 'europe-west1',
+  files: [], // To be populated with file content
+};
+
+// Configuration for a deployment that is expected to fail
+const configFailingBuild = {
+  projectId: projectIdToUse,
+  serviceName: 'example-failing-app',
+  region: 'europe-west1',
+  files: [
+    {
+      filename: 'main.txt',
+      content:
+        'This is not a valid application source file and should cause a build failure.',
+    },
+  ],
+};
+
+// Configuration for deploying a container image
+const configImageDeploy = {
+  projectId: projectIdToUse,
+  serviceName: 'hello-from-image',
+  region: 'europe-west1',
+  imageUrl: 'gcr.io/cloudrun/hello',
+};
+
+try {
+  console.log('\n--- Testing container image deployment ---');
+  await deployImage(configImageDeploy);
+  console.log('--- Container image deployment test completed ---');
+
+  console.log('\n--- Testing intentionally failing build ---');
+  try {
+    await deploy(configFailingBuild);
+    // If deploy doesn't throw an error, then the test has failed because it was expected to fail.
+    console.error(
+      'Deployment test failed: The build with invalid files succeeded when it was expected to fail.'
+    );
+    process.exit(1);
+  } catch (error) {
+    console.log('Intentionally failing build test completed as expected.');
+  }
+
+  console.log('--- Testing Go deployment with Dockerfile ---');
+  await deploy(configGoWithDockerfile);
+  console.log('--- Go deployment with Dockerfile test completed ---');
+
+  console.log(
+    '\n--- Testing Go deployment without Dockerfile (Buildpacks) ---'
+  );
+  await deploy(configGoWithoutDockerfile);
+  console.log(
+    '--- Go deployment without Dockerfile (Buildpacks) test completed ---'
+  );
+
+  console.log('\n--- Testing Go deployment with file content (Buildpacks) ---');
+  const mainGoContent = await fs.readFile(
+    path.resolve('example-sources-to-deploy/main.go'),
+    'utf-8'
+  );
+  const goModContent = await fs.readFile(
+    path.resolve('example-sources-to-deploy/go.mod'),
+    'utf-8'
+  );
+  configGoWithContent.files = [
+    { filename: 'main.go', content: mainGoContent },
+    { filename: 'go.mod', content: goModContent },
+  ];
+  await deploy(configGoWithContent);
+  console.log(
+    '--- Go deployment with file content (Buildpacks) test completed ---'
+  );
+} catch (error) {
+  console.error('An unexpected error occurred in the test script:', error);
+  process.exit(1);
+}