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

package/lib/cloud-run-services.js

@@ -15,6 +15,7 @@ limitations under the License.
 */
 
 import protofiles from 'google-proto-files';
+import { callWithRetry, ensureApisEnabled } from './gcp-api-helpers.js';
 
 let runClient;
 let loggingClient;
@@ -32,13 +33,19 @@ export async function listServices(projectId, location) {
     const { ServicesClient } = v2;
     runClient = new ServicesClient({ projectId });
   }
+
+  await ensureApisEnabled(projectId, ['run.googleapis.com']);
+
   const parent = runClient.locationPath(projectId, location);
 
   try {
     console.log(
       `Listing Cloud Run services in project ${projectId}, location ${location}...`
     );
-    const [services] = await runClient.listServices({ parent });
+    const [services] = await callWithRetry(
+      () => runClient.listServices({ parent }),
+      'listServices'
+    );
     return services;
   } catch (error) {
     console.error(`Error listing Cloud Run services:`, error);
@@ -66,7 +73,10 @@ export async function getService(projectId, location, serviceId) {
     console.log(
       `Getting details for Cloud Run service ${serviceId} in project ${projectId}, location ${location}...`
     );
-    const [service] = await runClient.getService({ name: servicePath });
+    const [service] = await callWithRetry(
+      () => runClient.getService({ name: servicePath }),
+      'getService'
+    );
     return service;
   } catch (error) {
     console.error(
@@ -123,8 +133,10 @@ export async function getServiceLogs(
     console.log(`Request options: ${JSON.stringify(options)}`);
 
     // getEntries returns the entries and the full API response
-    const [entries, nextRequestOptions, apiResponse] =
-      await loggingClient.getEntries(options);
+    const [entries, nextRequestOptions, apiResponse] = await callWithRetry(
+      () => loggingClient.getEntries(options),
+      'getEntries'
+    );
 
     const formattedLogLines = entries
       .map((entry) => formatLogEntry(entry))

package/lib/gcp-api-helpers.js

@@ -0,0 +1,143 @@
+/*
+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.
+*/
+
+/**
+ * Calls a function with retry logic for GCP API calls.
+ * Retries on gRPC error code 7 (PERMISSION_DENIED).
+ * @param {Function} fn The function to call.
+ * @param {string} description A description of the function being called, for logging.
+ * @returns {Promise<any>} The result of the function.
+ */
+export async function callWithRetry(fn, description) {
+  const maxRetries = 7;
+  const initialBackoff = 1000; // 1 second
+  let retries = 0;
+
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (error.code === 7 && retries < maxRetries) {
+        retries++;
+        let backoff;
+        if (retries === 1) {
+          backoff = 15000; // 15 seconds for the first retry
+        } else {
+          backoff = initialBackoff * Math.pow(2, retries - 2);
+        }
+        console.warn(
+          `API call "${description}" failed with PERMISSION_DENIED. Retrying in ${
+            backoff / 1000
+          }s... (attempt ${retries}/${maxRetries})`
+        );
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+/**
+ * Checks if a single Google Cloud API is enabled and enables it if not.
+ *
+ * @param {object} serviceUsageClient - The Service Usage client.
+ * @param {string} serviceName - The full name of the service (e.g., 'projects/my-project/services/run.googleapis.com').
+ * @param {string} api - The API identifier (e.g., 'run.googleapis.com').
+ * @param {function(string, string=): void} progressCallback - A function to call with progress updates.
+ * @returns {Promise<void>} A promise that resolves when the API is enabled.
+ * @throws {Error} If the API fails to enable or if there's an issue checking its status.
+ */
+async function checkAndEnableApi(
+  serviceUsageClient,
+  serviceName,
+  api,
+  progressCallback
+) {
+  const [service] = await callWithRetry(
+    () => serviceUsageClient.getService({ name: serviceName }),
+    `getService ${api}`
+  );
+  if (service.state !== 'ENABLED') {
+    const message = `API [${api}] is not enabled. Enabling...`;
+    console.log(message);
+    if (progressCallback) progressCallback({ level: 'info', data: message });
+
+    const [operation] = await callWithRetry(
+      () => serviceUsageClient.enableService({ name: serviceName }),
+      `enableService ${api}`
+    );
+    await operation.promise();
+  }
+}
+
+/**
+ * Ensures that the specified Google Cloud APIs are enabled for the given project.
+ * If an API is not enabled, it attempts to enable it.  Retries any failure once after 1s.
+ * Throws an error if an API cannot be enabled.
+ *
+ * @async
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string[]} apis - An array of API identifiers to check and enable (e.g., 'run.googleapis.com').
+ * @param {function(string, string=): void} progressCallback - A function to call with progress updates.
+ * The first argument is the message, the optional second argument is the type ('error', 'warning', 'info').
+ * @throws {Error} If an API fails to enable or if there's an issue checking its status.
+ * @returns {Promise<void>} A promise that resolves when all specified APIs are enabled.
+ */
+export async function ensureApisEnabled(projectId, apis, progressCallback) {
+  const { ServiceUsageClient } = await import('@google-cloud/service-usage');
+  const serviceUsageClient = new ServiceUsageClient({ projectId });
+  const message = 'Checking and enabling required APIs...';
+  console.log(message);
+  if (progressCallback) progressCallback({ level: 'info', data: message });
+
+
+  for (const api of apis) {
+    const serviceName = `projects/${projectId}/services/${api}`;
+    try {
+      await checkAndEnableApi(
+        serviceUsageClient,
+        serviceName,
+        api,
+        progressCallback
+      );
+    } catch (error) {
+      // First attempt failed, log a warning and retry once after a delay.
+      const warnMsg = `Failed to check/enable ${api}, retrying in 1s...`;
+      console.warn(warnMsg);
+      if (progressCallback) progressCallback({ level: 'warn', data: warnMsg });
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      try {
+        await checkAndEnableApi(
+          serviceUsageClient,
+          serviceName,
+          api,
+          progressCallback
+        );
+      } catch (retryError) {
+        // If the retry also fails, throw an error.
+        const errorMessage = `Failed to ensure API [${api}] is enabled after retry. Please check manually.`;
+        console.error(errorMessage, retryError);
+        if (progressCallback) progressCallback({ level: 'error', data: errorMessage });
+        throw new Error(errorMessage);
+      }
+    }
+  }
+  const successMsg = 'All required APIs are enabled.';
+  console.log(successMsg);
+  if (progressCallback) progressCallback({ level: 'info', data: successMsg });
+}

package/lib/gcp-projects.js

@@ -72,7 +72,7 @@ export async function createProject(projectId) {
   }
 
   try {
-    const projectPayload = { projectId: projectIdToUse, name: projectIdToUse };
+    const projectPayload = { projectId: projectIdToUse };
 
     console.log(`Attempting to create project with ID: ${projectIdToUse}`);
 

package/mcp-server.js

@@ -23,7 +23,8 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 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 { 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';
@@ -71,6 +72,12 @@ async function getServer() {
     { capabilities: { logging: {} } }
   );
 
+  // this is no-op handler is required for mcp-inspector to function due to a mismatch between the SDK mcp-inspector
+  server.server.setRequestHandler(SetLevelRequestSchema, (request) => {
+    console.log(`Log Level: ${request.params.level}`);
+    return {};
+  });
+
   // Get GCP metadata info once
   const gcpInfo = await checkGCP();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",
@@ -10,8 +10,8 @@
   "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:create-project": "node test/need-gcp/gcp-projects.test.js",
-    "test:service-logs": "node test/need-gcp/cloud-run-services.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",

package/test/local/gemini-extension.test.js

@@ -0,0 +1,35 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..', '..');
+const geminiExtensionJsonPath = path.resolve(rootDir, 'gemini-extension.json');
+
+describe('Gemini CLI extension', () => {
+  test('gemini-extension.json should be at the root', () => {
+    assert.ok(
+      fs.existsSync(geminiExtensionJsonPath),
+      'gemini-extension.json not found at the project root'
+    );
+  });
+
+  test('contextFileName from gemini-extension.json should exist', () => {
+    const geminiExtensionJson = JSON.parse(
+      fs.readFileSync(geminiExtensionJsonPath, 'utf-8')
+    );
+    const contextFileName = geminiExtensionJson.contextFileName;
+    assert.ok(
+      contextFileName,
+      'contextFileName not found in gemini-extension.json'
+    );
+    const contextFilePath = path.resolve(rootDir, contextFileName);
+    assert.ok(
+      fs.existsSync(contextFilePath),
+      `context file name '${contextFileName}' not found`
+    );
+  });
+});

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

@@ -35,7 +35,6 @@ describe('MCP Server in stdio mode', () => {
         'create_project',
         'deploy_container_image',
         'deploy_file_contents',
-        'deploy_local_files',
         'deploy_local_folder',
         'get_service',
         'get_service_log',

package/test/local/notifications.test.js

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+import esmock from 'esmock';
+
+describe('Tool Notifications', () => {
+  it('should send notifications during deployment', async () => {
+    const server = {
+      registerTool: mock.fn(),
+    };
+
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
+      '../../lib/cloud-run-deploy.js': {
+        deploy: () => Promise.resolve({ uri: 'my-uri' }),
+      },
+    },
+  );
+
+    registerTools(server, { gcpCredentialsAvailable: true });
+
+    const handler = server.registerTool.mock.calls.find(
+      (call) => call.arguments[0] === 'deploy_local_folder'
+    ).arguments[2];
+
+    const sendNotification = mock.fn();
+
+    await handler(
+      {
+        project: 'my-project',
+        region: 'my-region',
+        service: 'my-service',
+        folderPath: '/my/folder',
+      },
+      { sendNotification }
+    );
+
+    assert.strictEqual(sendNotification.mock.callCount(), 1);
+    assert.deepStrictEqual(sendNotification.mock.calls[0].arguments[0], {
+      method: 'notifications/message',
+      params: {
+        level: 'info',
+        data: 'Starting deployment of local folder for service my-service in project my-project...',
+      },
+    });
+  });
+});

package/test/local/npx.test.js

@@ -0,0 +1,36 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageJsonPath = path.resolve(__dirname, '..', '..', 'package.json');
+const mcpServerPath = path.resolve(__dirname, '..', '..', 'mcp-server.js');
+
+describe('The repository is properly structured to be executed using npx', () => {
+  test('package.json should be at the root', () => {
+    assert.ok(
+      fs.existsSync(packageJsonPath),
+      'package.json not found at the project root'
+    );
+  });
+
+  test('package.json should have a bin attribute for cloud-run-mcp', () => {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    assert.ok(packageJson.bin, 'bin attribute not found in package.json');
+    assert.ok(
+      packageJson.bin['cloud-run-mcp'],
+      'cloud-run-mcp not found in bin attribute'
+    );
+  });
+
+  test('mcp-server.js should start with #!/usr/bin/env node', () => {
+    const mcpServerContent = fs.readFileSync(mcpServerPath, 'utf-8');
+    assert.ok(
+      mcpServerContent.startsWith('#!/usr/bin/env node'),
+      'mcp-server.js does not start with #!/usr/bin/env node'
+    );
+  });
+});

package/test/local/tools.test.js

@@ -8,11 +8,11 @@ describe('registerTools', () => {
       registerTool: mock.fn(),
     };
 
-    const { registerTools } = await esmock('../../tools.js', {});
+    const { registerTools } = await esmock('../../tools/tools.js', {});
 
     registerTools(server);
 
-    assert.strictEqual(server.registerTool.mock.callCount(), 9);
+    assert.strictEqual(server.registerTool.mock.callCount(), 8);
     const toolNames = server.registerTool.mock.calls.map(
       (call) => call.arguments[0]
     );
@@ -22,7 +22,6 @@ describe('registerTools', () => {
         'create_project',
         'deploy_container_image',
         'deploy_file_contents',
-        'deploy_local_files',
         'deploy_local_folder',
         'get_service',
         'get_service_log',
@@ -38,7 +37,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/gcp-projects.js': {
           listProjects: () =>
             Promise.resolve([{ id: 'project1' }, { id: 'project2' }]),
@@ -69,7 +68,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/gcp-projects.js': {
           createProjectAndAttachBilling: (projectId) =>
             Promise.resolve({
@@ -101,7 +100,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/gcp-projects.js': {
           createProjectAndAttachBilling: () =>
             Promise.resolve({
@@ -135,7 +134,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-services.js': {
           listServices: () =>
             Promise.resolve([
@@ -172,7 +171,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-services.js': {
           getService: () =>
             Promise.resolve({
@@ -223,7 +222,7 @@ describe('registerTools', () => {
         return Promise.resolve({ logs: 'log3\nlog4', requestOptions: null });
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-services.js': {
           getServiceLogs: getServiceLogs,
         },
@@ -251,40 +250,7 @@ describe('registerTools', () => {
     });
   });
 
-  describe('deploy_local_files', () => {
-    it('should deploy local files', async () => {
-      const server = {
-        registerTool: mock.fn(),
-      };
-
-      const { registerTools } = await esmock('../../tools.js', {
-        '../../lib/cloud-run-deploy.js': {
-          deploy: () => Promise.resolve({ uri: 'my-uri' }),
-        },
-      });
-
-      registerTools(server, { gcpCredentialsAvailable: true });
-
-      const handler = server.registerTool.mock.calls.find(
-        (call) => call.arguments[0] === 'deploy_local_files'
-      ).arguments[2];
-      const result = await handler({
-        project: 'my-project',
-        region: 'my-region',
-        service: 'my-service',
-        files: ['file1', 'file2'],
-      });
-
-      assert.deepStrictEqual(result, {
-        content: [
-          {
-            type: 'text',
-            text: 'Cloud Run service my-service deployed in project my-project\nCloud Console: https://console.cloud.google.com/run/detail/my-region/my-service?project=my-project\nService URL: my-uri',
-          },
-        ],
-      });
-    });
-  });
+  
 
   describe('deploy_local_folder', () => {
     it('should deploy local folder', async () => {
@@ -292,7 +258,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-deploy.js': {
           deploy: () => Promise.resolve({ uri: 'my-uri' }),
         },
@@ -303,12 +269,15 @@ describe('registerTools', () => {
       const handler = server.registerTool.mock.calls.find(
         (call) => call.arguments[0] === 'deploy_local_folder'
       ).arguments[2];
-      const result = await handler({
-        project: 'my-project',
-        region: 'my-region',
-        service: 'my-service',
-        folderPath: '/my/folder',
-      });
+      const result = await handler(
+        {
+          project: 'my-project',
+          region: 'my-region',
+          service: 'my-service',
+          folderPath: '/my/folder',
+        },
+        { sendNotification: mock.fn() }
+      );
 
       assert.deepStrictEqual(result, {
         content: [
@@ -327,7 +296,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-deploy.js': {
           deploy: () => Promise.resolve({ uri: 'my-uri' }),
         },
@@ -338,12 +307,15 @@ describe('registerTools', () => {
       const handler = server.registerTool.mock.calls.find(
         (call) => call.arguments[0] === 'deploy_file_contents'
       ).arguments[2];
-      const result = await handler({
-        project: 'my-project',
-        region: 'my-region',
-        service: 'my-service',
-        files: [{ filename: 'file1', content: 'content1' }],
-      });
+      const result = await handler(
+        {
+          project: 'my-project',
+          region: 'my-region',
+          service: 'my-service',
+          files: [{ filename: 'file1', content: 'content1' }],
+        },
+        { sendNotification: mock.fn() }
+      );
 
       assert.deepStrictEqual(result, {
         content: [
@@ -362,7 +334,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {
+  const { registerTools } = await esmock('../../tools/tools.js', {}, {
         '../../lib/cloud-run-deploy.js': {
           deployImage: () => Promise.resolve({ uri: 'my-uri' }),
         },
@@ -373,12 +345,15 @@ describe('registerTools', () => {
       const handler = server.registerTool.mock.calls.find(
         (call) => call.arguments[0] === 'deploy_container_image'
       ).arguments[2];
-      const result = await handler({
-        project: 'my-project',
-        region: 'my-region',
-        service: 'my-service',
-        imageUrl: 'gcr.io/my-project/my-image',
-      });
+      const result = await handler(
+        {
+          project: 'my-project',
+          region: 'my-region',
+          service: 'my-service',
+          imageUrl: 'gcr.io/my-project/my-image',
+        },
+        { sendNotification: mock.fn() }
+      );
 
       assert.deepStrictEqual(result, {
         content: [
@@ -397,7 +372,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-      const { registerTools } = await esmock('../../tools.js', {});
+  const { registerTools } = await esmock('../../tools/tools.js', {});
 
       registerTools(server, { gcpCredentialsAvailable: false });