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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google-cloud/cloud-run-mcp",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "type": "module",
   "description": "Cloud Run MCP deployment tool",
   "main": "mcp-server.js",
@@ -9,14 +9,16 @@
   },
   "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:workflows": "node --test test/need-gcp/workflows/*.test.js",
+    "test:deploy": "node test/need-gcp/deployer.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",
     "test:tools": "node --test test/local/tools.test.js",
-    "test": "node --test test/local/*.test.js",
+    "test:local": "node --test test/local/*.test.js test/local/**/*.test.js",
+    "test": "c8 --check-coverage npm run test:local",
     "mcp-inspector": "npx @modelcontextprotocol/inspector node mcp-server.js",
     "start": "node mcp-server.js",
     "lint:check": "prettier --check .",
@@ -46,7 +48,7 @@
     "@google-cloud/run": "^2.0.1",
     "@google-cloud/service-usage": "^4.1.0",
     "@google-cloud/storage": "^7.16.0",
-    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "archiver": "^7.0.1",
     "dotenv": "^17.2.1",
     "express": "^5.1.0",
@@ -54,6 +56,7 @@
     "zod": "^3.25.76"
   },
   "devDependencies": {
+    "c8": "^10.1.3",
     "esmock": "^2.7.1",
     "prettier": "3.6.2"
   }

package/test/local/cloud-api/build.test.js

@@ -0,0 +1,436 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+import esmock from 'esmock';
+
+describe('triggerCloudBuild', () => {
+  it('should return a successful build and log correct messages', async () => {
+    const mockBuildId = 'mock-build-id';
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockSuccessResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(), // Directly execute the function
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+    };
+
+    const result = await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      true,
+      () => {}
+    );
+
+    assert.deepStrictEqual(result, mockSuccessResult);
+    assert.strictEqual(
+      context.cloudBuildClient.createBuild.mock.callCount(),
+      1
+    );
+    assert.strictEqual(context.cloudBuildClient.getBuild.mock.callCount(), 1);
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /completed successfully/);
+    assert.match(logCalls[3].arguments[0], /Image built/);
+  });
+
+  it('should throw an error for a failed build and log correct messages', async () => {
+    const mockBuildId = 'mock-build-id-failure';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+    const setTimeoutMock = mock.fn((resolve) => resolve());
+    mock.method(global, 'setTimeout', setTimeoutMock);
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() =>
+          Promise.resolve([[{ data: 'log line 1' }, { data: 'log line 2' }]])
+        ),
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-failure failed/);
+        assert.match(err.message, /log line 1/);
+        assert.match(err.message, /log line 2/);
+        return true;
+      }
+    );
+
+    assert.strictEqual(
+      context.cloudBuildClient.createBuild.mock.callCount(),
+      1
+    );
+    assert.strictEqual(context.cloudBuildClient.getBuild.mock.callCount(), 1);
+    assert.strictEqual(context.loggingClient.getEntries.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.calls[0].arguments[1], 10000);
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(logCalls[5].arguments[0], /Successfully fetched snippet/);
+  });
+
+  it('should use buildpacks when no Dockerfile is present', async () => {
+    const mockBuildId = 'mock-build-id-buildpacks';
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockSuccessResult]));
+    const createBuildMock = mock.fn(() =>
+      Promise.resolve([
+        {
+          metadata: {
+            build: {
+              id: mockBuildId,
+            },
+          },
+        },
+      ])
+    );
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: () => {},
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: createBuildMock,
+        getBuild: getBuildMock,
+      },
+    };
+
+    await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      false, // hasDockerfile = false
+      () => {}
+    );
+
+    assert.strictEqual(createBuildMock.mock.callCount(), 1);
+    const buildArg = createBuildMock.mock.calls[0].arguments[0].build;
+    const buildStep = buildArg.steps[0];
+    assert.strictEqual(buildStep.name, 'gcr.io/k8s-skaffold/pack');
+  });
+
+  it('should poll for build status until completion', async () => {
+    const mockBuildId = 'mock-build-id-polling';
+    const mockWorkingResult = { id: mockBuildId, status: 'WORKING' };
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    let getBuildCallCount = 0;
+    const getBuildMock = mock.fn(() => {
+      getBuildCallCount++;
+      if (getBuildCallCount === 1) {
+        return Promise.resolve([mockWorkingResult]);
+      }
+      return Promise.resolve([mockSuccessResult]);
+    });
+
+    const logAndProgressMock = mock.fn();
+    const setTimeoutMock = mock.fn((resolve) => resolve());
+    mock.method(global, 'setTimeout', setTimeoutMock);
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+    };
+
+    await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      true,
+      () => {}
+    );
+
+    assert.strictEqual(getBuildMock.mock.callCount(), 2);
+    assert.strictEqual(setTimeoutMock.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.calls[0].arguments[1], 5000);
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /Build status: WORKING/);
+    assert.match(logCalls[3].arguments[0], /completed successfully/);
+    assert.match(logCalls[4].arguments[0], /Image built/);
+  });
+
+  it('should handle failed build when no logs are found', async () => {
+    const mockBuildId = 'mock-build-id-no-logs';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() => Promise.resolve([[]])), // No log entries
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-no-logs failed/);
+        assert.doesNotMatch(err.message, /Last log lines/);
+        return true;
+      }
+    );
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(logCalls[5].arguments[0], /No specific log entries retrieved/);
+  });
+
+  it('should handle error when fetching logs for a failed build', async () => {
+    const mockBuildId = 'mock-build-id-log-error';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() => Promise.reject(new Error('Log fetch error'))),
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-log-error failed/);
+        assert.doesNotMatch(err.message, /Last log lines/);
+        return true;
+      }
+    );
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(
+      logCalls[5].arguments[0],
+      /Failed to fetch build logs snippet/
+    );
+  });
+});

package/test/local/cloud-api/projects.test.js

@@ -0,0 +1,18 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import esmock from 'esmock';
+
+describe('projects', () => {
+  describe('generateProjectId', () => {
+    it('should generate a project id in the correct format', async () => {
+      const { generateProjectId } = await esmock(
+        '../../../lib/cloud-api/projects.js',
+        {}
+      );
+
+      const projectId = generateProjectId();
+      assert.ok(projectId.startsWith('mcp-'));
+      assert.strictEqual(projectId.length, 11);
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'child_process';
+
+class MCPClient {
+  client = null;
+  transport = null;
+
+  constructor(serverName) {
+    this.client = new Client({
+      name: `mcp-client-for-${serverName}`,
+      version: '1.0.0',
+      url: `http://localhost:3000/mcp`,
+    });
+  }
+
+  async connectToServer(serverUrl) {
+    this.transport = new StreamableHTTPClientTransport(serverUrl);
+    await this.client.connect(this.transport);
+  }
+
+  async cleanup() {
+    await this.client.close();
+  }
+}
+
+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',
+    });
+
+    // 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();
+    }
+  });
+
+  test('should start an HTTP server', async () => {
+    await client.connectToServer('http://localhost:3000/mcp');
+  });
+});

package/test/local/notifications.test.js

@@ -8,12 +8,15 @@ describe('Tool Notifications', () => {
       registerTool: mock.fn(),
     };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-      '../../lib/cloud-run-deploy.js': {
-        deploy: () => Promise.resolve({ uri: 'my-uri' }),
-      },
-    },
-  );
+    const { registerTools } = await esmock(
+      '../../tools/tools.js',
+      {},
+      {
+        '../../lib/deployment/deployer.js': {
+          deploy: () => Promise.resolve({ uri: 'my-uri' }),
+        },
+      }
+    );
 
     registerTools(server, { gcpCredentialsAvailable: true });