@google-cloud/cloud-run-mcp 1.8.0 → 1.10.0

package/lib/middleware/oauth.js

@@ -0,0 +1,92 @@
+import { getOAuthClient } from '../clients.js';
+import { extractAccessToken } from '../util/helpers.js';
+
+const TOOLS_CALL_METHOD = 'tools/call';
+
+/**
+ * Verifies the validity of an access token and checks the audience.
+ * @param {string} accessToken - The access token to verify.
+ * @param {string} [audience] - Audience to check against the token's audience.
+ * @returns {Promise<object>} - The token info if valid.
+ * @throws {Error} - If the token is invalid or the audience does not match.
+ */
+async function verifyAccessToken(accessToken, audience) {
+  try {
+    const client = await getOAuthClient(accessToken);
+    const tokenInfo = await client.getTokenInfo(accessToken);
+
+    //An expired token will not have audience
+    if (audience && tokenInfo.aud !== audience) {
+      throw new Error(`Invalid audience: expected ${audience}`);
+    }
+
+    console.log('Access token verified successfully.');
+    return tokenInfo;
+  } catch (error) {
+    console.error('Error verifying access token:', error);
+    throw error;
+  }
+}
+
+/**
+ * Ensures that a valid OAuth token is present in the request headers
+ * and verifies it against the configured audience.
+ * @param {object} req - The request object.
+ * @param {object} res - The response object.
+ * @throws {Error} - If the token is missing or invalid.
+ */
+async function ensureOAuthTokenInEnv(req, res) {
+  try {
+    const audience = process.env.GOOGLE_OAUTH_AUDIENCE;
+    console.log('Verifying token');
+    if (req.headers.authorization === undefined) {
+      console.log('No authorization header found in request');
+      throw new Error('No authorization header');
+    }
+    console.log('Authorization header found.. Verifying token');
+    await verifyAccessToken(
+      extractAccessToken(req.headers.authorization),
+      audience
+    );
+    console.log('Token verified');
+  } catch (error) {
+    console.error('Authentication failed: ', error);
+    throw error;
+  }
+}
+
+/**
+ * Middleware to check for OAuth token if OAuth is enabled.
+ * If OAUTH_ENABLED is 'true', it verifies the Authorization header.
+ *
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ */
+export const oauthMiddleware = async (req, res, next) => {
+  //If OAUTH_ENABLED is not true or the request is not a tools/call, skip the middleware
+  if (
+    process.env.OAUTH_ENABLED !== 'true' ||
+    req.body.method !== TOOLS_CALL_METHOD
+  ) {
+    return next();
+  }
+
+  try {
+    await ensureOAuthTokenInEnv(req, res);
+    next();
+  } catch (error) {
+    console.error('OAuth Middleware Error:', error);
+    // ensureOAuthTokenInEnv throws an error if auth fails.
+    // We catch it and send a 401 response.
+    res.status(401).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32001, // Custom auth error code or standard -32000
+        message: 'Authentication failed',
+        data: error.message,
+      },
+      id: null,
+    });
+  }
+};

package/lib/util/helpers.js

@@ -40,3 +40,15 @@ export async function logAndProgress(
     progressCallback({ level: severity, data: message });
   }
 }
+
+/**
+ * Extracts the access token from the Authorization header.
+ * @param {string} authorizationHeader - The Authorization header string.
+ * @returns {string | undefined} - The extracted access token or undefined if not found.
+ */
+export function extractAccessToken(authorizationHeader) {
+  if (!authorizationHeader) {
+    return undefined;
+  }
+  return authorizationHeader.split(' ')[1];
+}

package/mcp-server.js

@@ -28,7 +28,18 @@ import { SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { registerPrompts } from './prompts.js';
 import { checkGCP } from './lib/cloud-api/metadata.js';
 import { ensureGCPCredentials } from './lib/cloud-api/auth.js';
-import 'dotenv/config';
+import { extractAccessToken } from './lib/util/helpers.js';
+import { oauthMiddleware } from './lib/middleware/oauth.js';
+import { config } from '@dotenvx/dotenvx';
+import {
+  SCOPES,
+  GCLOUD_AUTH,
+  BEARER_METHODS_SUPPORTED,
+  RESPONSE_TYPES_SUPPORTED,
+} from './constants.js';
+
+//Suppress the warning related to missing .env file in case of non-OAuth mode
+config({ quiet: true, ignore: ['MISSING_ENV_FILE'] });
 
 const gcpInfo = await checkGCP();
 let gcpCredentialsAvailable = false;
@@ -63,7 +74,7 @@ const allowedHosts = process.env.ALLOWED_HOSTS
   ? process.env.ALLOWED_HOSTS.split(',')
   : undefined;
 
-async function getServer() {
+async function getServer(accessToken = GCLOUD_AUTH) {
   // Create an MCP server with implementation details
   const server = new McpServer(
     {
@@ -97,6 +108,7 @@ async function getServer() {
       defaultServiceName,
       skipIamCheck,
       gcpCredentialsAvailable,
+      accessToken,
     });
   } else {
     console.log(
@@ -109,6 +121,7 @@ async function getServer() {
       defaultServiceName,
       skipIamCheck,
       gcpCredentialsAvailable,
+      accessToken,
     });
   }
 
@@ -118,7 +131,28 @@ async function getServer() {
   return server;
 }
 
-// stdio
+const getOAuthProtectedResource = (req, res) => {
+  res.json({
+    resource: process.env.OAUTH_PROTECTED_RESOURCE,
+    authorization_servers: [process.env.OAUTH_AUTHORIZATION_SERVER],
+    scopes_supported: [SCOPES.OPENID, SCOPES.EMAIL, SCOPES.CLOUD_PLATFORM],
+    bearer_methods_supported: [...BEARER_METHODS_SUPPORTED],
+  });
+  res.status(200).send();
+};
+
+const getOAuthAuthorizationServer = (req, res) => {
+  res.json({
+    issuer: process.env.OAUTH_PROTECTED_RESOURCE,
+    authorization_endpoint: process.env.OAUTH_AUTHORIZATION_ENDPOINT,
+    token_endpoint: process.env.OAUTH_TOKEN_ENDPOINT,
+    scopes_supported: [SCOPES.OPENID, SCOPES.EMAIL, SCOPES.CLOUD_PLATFORM],
+    response_types_supported: [...RESPONSE_TYPES_SUPPORTED],
+  });
+  res.status(200).send();
+};
+
+// stdio mode
 if (shouldStartStdio()) {
   gcpCredentialsAvailable = await ensureGCPCredentials();
   const stdioTransport = new StdioServerTransport();
@@ -128,7 +162,8 @@ if (shouldStartStdio()) {
 } else {
   // non-stdio mode
   console.log('Stdio transport mode is turned off.');
-  gcpCredentialsAvailable = await ensureGCPCredentials();
+  gcpCredentialsAvailable =
+    process.env.OAUTH_ENABLED === 'true' || (await ensureGCPCredentials());
 
   const app = enableHostValidation
     ? createMcpExpressApp({ allowedHosts })
@@ -141,9 +176,17 @@ if (shouldStartStdio()) {
     );
   }
 
-  app.post('/mcp', async (req, res) => {
+  app.get('/.well-known/oauth-protected-resource', getOAuthProtectedResource);
+
+  app.get(
+    '/.well-known/oauth-authorization-server',
+    getOAuthAuthorizationServer
+  );
+
+  app.post('/mcp', oauthMiddleware, async (req, res) => {
     console.log('/mcp Received:', req.body);
-    const server = await getServer();
+    const accessToken = extractAccessToken(req.headers.authorization);
+    const server = await getServer(accessToken);
     try {
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
@@ -204,7 +247,8 @@ if (shouldStartStdio()) {
   // Legacy SSE endpoint for older clients
   app.get('/sse', async (req, res) => {
     console.log('/sse Received:', req.body);
-    const server = await getServer();
+    const accessToken = extractAccessToken(req.headers.authorization);
+    const server = await getServer(accessToken);
     // Create SSE transport for legacy clients
     const transport = new SSEServerTransport('/messages', res);
     sseTransports[transport.sessionId] = transport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",
@@ -50,7 +50,7 @@
     "@google-cloud/storage": "^7.16.0",
     "@modelcontextprotocol/sdk": "^1.24.3",
     "archiver": "^7.0.1",
-    "dotenv": "^17.2.1",
+    "@dotenvx/dotenvx": "^1.52.0",
     "express": "^5.1.0",
     "google-proto-files": "^5.0.0",
     "zod": "^3.25.76"

package/test/local/clients.test.js

@@ -27,7 +27,9 @@ describe('getClient Helper', () => {
     assert.strictEqual(client.options.projectId, projectId);
     assert.ok(client.options.authClient);
 
-    const headers = client.options.authClient.getRequestHeaders();
+    const headers = await client.options.authClient.getRequestHeaders();
+    // 'run' is a gRPC service, so it should be wrapped to return a Map
+    assert.ok(headers instanceof Map);
     assert.strictEqual(headers.get('Authorization'), 'Bearer fake-token-1');
   });
 
@@ -96,10 +98,12 @@ describe('getClient Helper', () => {
 
     assert.notStrictEqual(client1, client2);
 
-    const h1 = client1.options.authClient.getRequestHeaders();
+    const h1 = await client1.options.authClient.getRequestHeaders();
+    assert.ok(h1 instanceof Map);
     assert.strictEqual(h1.get('Authorization'), 'Bearer token-A');
 
-    const h2 = client2.options.authClient.getRequestHeaders();
+    const h2 = await client2.options.authClient.getRequestHeaders();
+    assert.ok(h2 instanceof Map);
     assert.strictEqual(h2.get('Authorization'), 'Bearer token-B');
   });
 
@@ -126,6 +130,32 @@ describe('getClient Helper', () => {
     assert.notStrictEqual(runClient, storageClient); // Different maps
     assert.ok(runClient.options.authClient);
     assert.ok(storageClient.options.authClient);
+
+    const runHeaders = await runClient.options.authClient.getRequestHeaders();
+    assert.ok(runHeaders instanceof Map, 'Run client headers should be a Map');
+
+    const storageHeaders =
+      await storageClient.options.authClient.getRequestHeaders();
+    assert.ok(
+      !(storageHeaders instanceof Map),
+      'Storage client headers should NOT be a Map'
+    );
+    assert.strictEqual(storageHeaders.Authorization, `Bearer ${accessToken}`);
+
+    const loggingClient = await getClient(
+      'logging',
+      projectId + accessToken,
+      async () => MockClient,
+      { projectId },
+      accessToken
+    );
+    const loggingHeaders =
+      await loggingClient.options.authClient.getRequestHeaders();
+    assert.ok(
+      !(loggingHeaders instanceof Map),
+      'Logging client headers should NOT be a Map'
+    );
+    assert.strictEqual(loggingHeaders.Authorization, `Bearer ${accessToken}`);
   });
 
   test('passes additional options correctly', async () => {

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

@@ -50,7 +50,7 @@ describe('Deployment Helpers', () => {
     assert.equal(result.hasDockerfile, true);
   });
 
-  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+  test('makeFileDeploymentMetadata correctly identifies Node.js project', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -69,75 +69,13 @@ describe('Deployment Helpers', () => {
       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 () => {
+  test('canDeployWithoutBuild returns true for valid Node.js project', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -146,9 +84,6 @@ describe('Deployment Helpers', () => {
       hasDockerfile: false,
       deploymentAttrs: {
         runtime: 'nodejs',
-        cmd: ['node'],
-        args: ['index.js'],
-        baseImage: 'base-image',
       },
     };
 
@@ -164,15 +99,13 @@ describe('Deployment Helpers', () => {
       hasDockerfile: true,
       deploymentAttrs: {
         runtime: 'nodejs',
-        cmd: ['node'],
-        args: ['index.js'],
       },
     };
 
     assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
   });
 
-  test('createDirectSourceDeploymentContainer creates correct object', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object without envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
@@ -204,28 +137,43 @@ describe('Deployment Helpers', () => {
     });
   });
 
-  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+  test('createDirectSourceDeploymentContainer creates correct object with envVars', async () => {
     const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
       fs: fsMock,
     });
 
-    const folderPath = '/absolute/path/to/bad-json-app';
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
+      deploymentAttrs: {
+        cmd: ['node'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
+        envVars: {
+          PORT: '8080',
+          NODE_ENV: 'production',
+        },
+      },
+    };
 
-    fsMock.statSync.mock.mockImplementation(() => ({
-      isDirectory: () => true,
-    }));
+    const result =
+      deploymentHelpers.createDirectSourceDeploymentContainer(input);
 
-    fsMock.existsSync.mock.mockImplementation((p) => {
-      if (p.endsWith('package.json')) return true;
-      return false;
+    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'],
+      env: [
+        { name: 'PORT', value: '8080' },
+        { name: 'NODE_ENV', value: 'production' },
+      ],
     });
-
-    // 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

@@ -13,7 +13,6 @@ describe('MCP Server stdio startup', () => {
       stderr = '';
       serverProcess = spawn('node', ['mcp-server.js'], {
         cwd: process.cwd(),
-        env: { ...process.env, GCP_STDIO: 'true' },
       });
       stderr = await waitForString(serverProcess.stderr, stdioMsg);
     });

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

@@ -4,6 +4,11 @@ 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';
+import {
+  SCOPES,
+  BEARER_METHODS_SUPPORTED,
+  RESPONSE_TYPES_SUPPORTED,
+} from '../../constants.js';
 
 class MCPClient {
   client = null;
@@ -59,3 +64,67 @@ describe('MCP Server in Streamble HTTP mode', () => {
     });
   });
 });
+
+describe('OAuth Endpoints', () => {
+  let serverProcess;
+  let stdout = '';
+  const httpMsg = 'Cloud Run MCP server listening on port 3001';
+  const oauthProtectedResource = 'https://example.com/resource';
+  const oauthAuthorizationServer = 'https://example.com/auth';
+  const oauthAuthorizationEndpoint = 'https://example.com/auth/authorize';
+  const oauthTokenEndpoint = 'https://example.com/auth/token';
+
+  before(async () => {
+    stdout = '';
+    serverProcess = spawn('node', ['mcp-server.js'], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        GCP_STDIO: 'false',
+        PORT: '3001',
+        OAUTH_PROTECTED_RESOURCE: oauthProtectedResource,
+        OAUTH_AUTHORIZATION_SERVER: oauthAuthorizationServer,
+        OAUTH_AUTHORIZATION_ENDPOINT: oauthAuthorizationEndpoint,
+        OAUTH_TOKEN_ENDPOINT: oauthTokenEndpoint,
+      },
+    });
+    stdout = await waitForString(serverProcess.stdout, httpMsg);
+  });
+
+  after(() => {
+    if (serverProcess) {
+      serverProcess.kill();
+    }
+  });
+
+  test('should return correct OAuth protected resource configuration', async () => {
+    const response = await fetch(
+      'http://localhost:3001/.well-known/oauth-protected-resource'
+    );
+    assert.equal(response.status, 200);
+    const data = await response.json();
+
+    assert.deepStrictEqual(data, {
+      resource: oauthProtectedResource,
+      authorization_servers: [oauthAuthorizationServer],
+      scopes_supported: [SCOPES.OPENID, SCOPES.EMAIL, SCOPES.CLOUD_PLATFORM],
+      bearer_methods_supported: [...BEARER_METHODS_SUPPORTED],
+    });
+  });
+
+  test('should return correct OAuth authorization server configuration', async () => {
+    const response = await fetch(
+      'http://localhost:3001/.well-known/oauth-authorization-server'
+    );
+    assert.equal(response.status, 200);
+    const data = await response.json();
+
+    assert.deepStrictEqual(data, {
+      issuer: oauthProtectedResource,
+      authorization_endpoint: oauthAuthorizationEndpoint,
+      token_endpoint: oauthTokenEndpoint,
+      scopes_supported: [SCOPES.OPENID, SCOPES.EMAIL, SCOPES.CLOUD_PLATFORM],
+      response_types_supported: [...RESPONSE_TYPES_SUPPORTED],
+    });
+  });
+});

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

@@ -11,6 +11,7 @@ describe('MCP Server in stdio mode', () => {
     transport = new StdioClientTransport({
       command: 'node',
       args: ['mcp-server.js'],
+      env: { ...process.env, GCP_STDIO: 'true' },
     });
     client = new Client({
       name: 'test-client',