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

package/test/local/tools.test.js

@@ -37,12 +37,16 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/gcp-projects.js': {
-          listProjects: () =>
-            Promise.resolve([{ id: 'project1' }, { id: 'project2' }]),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/projects.js': {
+            listProjects: () =>
+              Promise.resolve([{ id: 'project1' }, { id: 'project2' }]),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -68,15 +72,19 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/gcp-projects.js': {
-          createProjectAndAttachBilling: (projectId) =>
-            Promise.resolve({
-              projectId: projectId,
-              billingMessage: 'billing message',
-            }),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/projects.js': {
+            createProjectAndAttachBilling: (projectId) =>
+              Promise.resolve({
+                projectId: projectId,
+                billingMessage: `Project ${projectId} created successfully. Billing attached.`,
+              }),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -89,7 +97,7 @@ describe('registerTools', () => {
         content: [
           {
             type: 'text',
-            text: 'Successfully created GCP project with ID "my-project". You can now use this project ID for deployments.',
+            text: 'Project my-project created successfully. Billing attached.',
           },
         ],
       });
@@ -100,15 +108,20 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/gcp-projects.js': {
-          createProjectAndAttachBilling: () =>
-            Promise.resolve({
-              projectId: 'generated-project',
-              billingMessage: 'billing message',
-            }),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/projects.js': {
+            createProjectAndAttachBilling: () =>
+              Promise.resolve({
+                projectId: 'generated-project',
+                billingMessage:
+                  'Project generated-project created successfully. Billing attached.',
+              }),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -121,7 +134,7 @@ describe('registerTools', () => {
         content: [
           {
             type: 'text',
-            text: 'Successfully created GCP project with ID "generated-project". You can now use this project ID for deployments.',
+            text: 'Project generated-project created successfully. Billing attached.',
           },
         ],
       });
@@ -134,15 +147,25 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/cloud-run-services.js': {
-          listServices: () =>
-            Promise.resolve([
-              { name: 'service1', uri: 'uri1' },
-              { name: 'service2', uri: 'uri2' },
-            ]),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/run.js': {
+            listServices: () =>
+              Promise.resolve({
+                'my-region1': [
+                  { name: 'service1', uri: 'uri1' },
+                  { name: 'service2', uri: 'uri2' },
+                ],
+                'my-region2': [
+                  { name: 'service3', uri: 'uri3' },
+                  { name: 'service4', uri: 'uri4' },
+                ],
+              }),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -151,14 +174,17 @@ describe('registerTools', () => {
       ).arguments[2];
       const result = await handler({
         project: 'my-project',
-        region: 'my-region',
       });
 
       assert.deepStrictEqual(result, {
         content: [
           {
             type: 'text',
-            text: 'Services in project my-project (location my-region):\n- service1 (URL: uri1)\n- service2 (URL: uri2)',
+            text: 'Services in project my-project (location my-region1):\n- service1 (URL: uri1)\n- service2 (URL: uri2)',
+          },
+          {
+            type: 'text',
+            text: 'Services in project my-project (location my-region2):\n- service3 (URL: uri3)\n- service4 (URL: uri4)',
           },
         ],
       });
@@ -171,16 +197,20 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/cloud-run-services.js': {
-          getService: () =>
-            Promise.resolve({
-              name: 'my-service',
-              uri: 'my-uri',
-              lastModifier: 'me',
-            }),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/run.js': {
+            getService: () =>
+              Promise.resolve({
+                name: 'my-service',
+                uri: 'my-uri',
+                lastModifier: 'me',
+              }),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -222,11 +252,15 @@ describe('registerTools', () => {
         return Promise.resolve({ logs: 'log3\nlog4', requestOptions: null });
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/cloud-run-services.js': {
-          getServiceLogs: getServiceLogs,
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/cloud-api/run.js': {
+            getServiceLogs: getServiceLogs,
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -250,19 +284,21 @@ describe('registerTools', () => {
     });
   });
 
-  
-
   describe('deploy_local_folder', () => {
     it('should deploy local folder', async () => {
       const server = {
         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 });
 
@@ -296,11 +332,15 @@ describe('registerTools', () => {
         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 });
 
@@ -334,11 +374,15 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {}, {
-        '../../lib/cloud-run-deploy.js': {
-          deployImage: () => Promise.resolve({ uri: 'my-uri' }),
-        },
-      });
+      const { registerTools } = await esmock(
+        '../../tools/tools.js',
+        {},
+        {
+          '../../lib/deployment/deployer.js': {
+            deployImage: () => Promise.resolve({ uri: 'my-uri' }),
+          },
+        }
+      );
 
       registerTools(server, { gcpCredentialsAvailable: true });
 
@@ -372,7 +416,7 @@ describe('registerTools', () => {
         registerTool: mock.fn(),
       };
 
-  const { registerTools } = await esmock('../../tools/tools.js', {});
+      const { registerTools } = await esmock('../../tools/tools.js', {});
 
       registerTools(server, { gcpCredentialsAvailable: false });
 

package/test/need-gcp/cloud-run-services.test.js

@@ -15,66 +15,68 @@ limitations under the License.
 */
 
 import { test } from 'node:test';
+import { getServiceLogs, listServices } from '../../lib/cloud-api/run.js';
 import assert from 'node:assert';
-import {
-  getServiceLogs,
-  listServices,
-} from '../../lib/cloud-run-services.js';
 
 /**
- * Gets service details from GOOGLE_CLOUD_PROJECT or command line arguments.
- * @returns {{projectId: string, region: string, serviceId: string}} The service details
+ * Get the GCP project ID from GOOGLE_CLOUD_PROJECT or command line argument.
+ * @returns {string} The GCP project ID
  */
-function getServiceDetails() {
+function getProjectId() {
   const projectId = process.env.GOOGLE_CLOUD_PROJECT || process.argv[2];
-  const [, , arg1, arg2, arg3] = process.argv;
-
-  let region = 'europe-west1';
-  let serviceId;
-
-  if (process.env.GOOGLE_CLOUD_PROJECT) {
-    region = arg1 || 'europe-west1';
-    serviceId = arg2;
-  } else {
-    region = arg2 || 'europe-west1';
-    serviceId = arg3;
-  }
-
   if (!projectId) {
     console.error(
-      'Usage: node <script> <projectId> [region] [serviceId] or set GOOGLE_CLOUD_PROJECT'
+      'Usage: node <script> <projectId> or set GOOGLE_CLOUD_PROJECT'
     );
     process.exit(1);
   }
+  console.log(`Using Project ID: ${projectId}`);
+  return projectId;
+}
 
-  console.log(`Using:
-Project ID: ${projectId}
-Region: ${region}`);
-  if (serviceId) {
-    console.log(`Service ID: ${serviceId}`);
-  }
+/**
+ * Gets service details from GOOGLE_CLOUD_PROJECT or command line arguments.
+ * @returns {{projectId: string, region: string, serviceId: string}} The service details
+ */
+async function getServiceDetails() {
+  const projectId = getProjectId();
+  let region, serviceId;
 
-  return { projectId, region, serviceId };
-}
+  try {
+    const allServices = await listServices(projectId);
+
+    if (!allServices || Object.keys(allServices).length === 0) {
+      assert.fail('No services found for the given project.');
+    }
+
+    const regions = Object.keys(allServices);
+    region = regions[0];
+
+    if (!allServices[region] || allServices[region].length === 0) {
+      assert.fail(`No services found in region: ${region}`);
+    }
+
+    const serviceName = allServices[region][0].name;
+    serviceId = serviceName.split('/').pop();
+    console.log(`Using region - ${region} and service ID - ${serviceId}`);
 
-const { projectId, region, serviceId } = getServiceDetails();
+    return { projectId, region, serviceId };
+  } catch (error) {
+    // Better error handling for the API call itself
+    console.error('Error fetching services:', error.message);
+    throw error; // Re-throw the error to fail the test
+  }
+}
 
 test('should list services', async () => {
-  const services = await listServices(projectId, region);
-  assert(Array.isArray(services), 'services should be an array');
-  console.log('Services found:', services.length);
+  const projectId = getProjectId();
+  const services = await listServices(projectId);
+  console.log('Services found:', services ? Object.keys(services) : 'None');
+  console.log('All Services', services);
 });
 
 test('should fetch service logs', async () => {
-  if (!serviceId) {
-    console.log('Skipping service log test: no serviceId provided.');
-    return;
-  }
-
-  console.log(
-    `
-Fetching logs for service "${serviceId}" in project "${projectId}" (region: ${region})...`
-  );
+  const { projectId, region, serviceId } = await getServiceDetails();
 
   const result = await getServiceLogs(projectId, region, serviceId);
 
@@ -85,5 +87,3 @@ Fetching logs for service "${serviceId}" in project "${projectId}" (region: ${re
     console.log('No logs found for this service.');
   }
 });
-
-

package/test/need-gcp/{cloud-run-deploy.test.js → deployer.test.js}

@@ -16,68 +16,15 @@ limitations under the License.
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert';
-import { deploy, deployImage } from '../../lib/cloud-run-deploy.js';
-import fs from 'fs/promises';
-import path from 'path';
+import { deploy, deployImage } from '../../lib/deployment/deployer.js';
 
 const projectId = process.env.GOOGLE_CLOUD_PROJECT || process.argv[2];
 if (!projectId) {
-  console.error(
-    'Usage: node <script> <projectId> or set GOOGLE_CLOUD_PROJECT'
-  );
+  console.error('Usage: node <script> <projectId> or set GOOGLE_CLOUD_PROJECT');
   process.exit(1);
 }
 
 describe('Cloud Run Deployments', () => {
-  test('should deploy a container image', async () => {
-    const configImageDeploy = {
-      projectId: projectId,
-      serviceName: 'hello-from-image',
-      region: 'europe-west1',
-      imageUrl: 'gcr.io/cloudrun/hello',
-    };
-    await deployImage(configImageDeploy);
-  });
-
-  test('should fail to deploy with invalid files', async () => {
-    const configFailingBuild = {
-      projectId: projectId,
-      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.',
-        },
-      ],
-    };
-    await assert.rejects(deploy(configFailingBuild));
-  });
-
-  
-
-  test('should deploy a Go app with file content (Buildpacks)', async () => {
-    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'
-    );
-    const configGoWithContent = {
-      projectId: projectId,
-      serviceName: 'example-go-app-content',
-      region: 'europe-west1',
-      files: [
-        { filename: 'main.go', content: mainGoContent },
-        { filename: 'go.mod', content: goModContent },
-      ],
-    };
-    await deploy(configGoWithContent);
-  });
-
   test('should fail to deploy without a service name', async () => {
     const config = {
       projectId: projectId,
@@ -121,4 +68,4 @@ describe('Cloud Run Deployments', () => {
       message: 'Error: projectId is required in the configuration object.',
     });
   });
-});
+});

package/test/need-gcp/gcp-auth-check.test.js

@@ -17,7 +17,7 @@ limitations under the License.
 import assert from 'node:assert/strict';
 import { describe, it, mock, beforeEach, afterEach } from 'node:test';
 import { GoogleAuth } from 'google-auth-library';
-import { ensureGCPCredentials } from '../../lib/gcp-auth-check.js';
+import { ensureGCPCredentials } from '../../lib/cloud-api/auth.js';
 
 describe('ensureGCPCredentials', () => {
   let originalConsoleLog;

package/test/need-gcp/gcp-projects.test.js

@@ -15,21 +15,9 @@ limitations under the License.
 */
 
 import { test } from 'node:test';
-import assert from 'node:assert';
-import { createProjectAndAttachBilling } from '../../lib/gcp-projects.js';
+import { setupProject } from './test-helpers.js';
 
-test('should create a new project and attach billing', async () => {
+test('should create a new project and attach billing', async (t) => {
   console.log('Attempting to create a new project and attach billing...');
-  const newProjectResult = await createProjectAndAttachBilling();
-
-  assert(newProjectResult, 'newProjectResult should not be null');
-  assert(
-    newProjectResult.projectId,
-    'newProjectResult.projectId should not be null'
-  );
-
-  console.log(
-    `Successfully created project: ${newProjectResult.projectId}`
-  );
-  console.log(newProjectResult.billingMessage);
+  await setupProject(t);
 });

package/test/need-gcp/test-helpers.js

@@ -0,0 +1,175 @@
+/*
+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 assert from 'node:assert';
+import {
+  createProjectAndAttachBilling,
+  deleteProject,
+  generateProjectId,
+} from '../../lib/cloud-api/projects.js';
+import {
+  callWithRetry,
+  ensureApisEnabled,
+} from '../../lib/cloud-api/helpers.js';
+
+/**
+ * Gets project number from project ID.
+ * @param {string} projectId
+ * @returns {Promise<string>} project number
+ */
+export async function getProjectNumber(projectId) {
+  const { ProjectsClient } = await import('@google-cloud/resource-manager');
+  const client = new ProjectsClient();
+  try {
+    const [project] = await client.getProject({
+      name: `projects/${projectId}`,
+    });
+    // project.name is in format projects/123456
+    return project.name.split('/')[1];
+  } catch (error) {
+    console.error(
+      `Error getting project number for project ${projectId}:`,
+      error.message
+    );
+    throw error;
+  }
+}
+
+/**
+ * Adds an IAM policy binding to a project.
+ * @param {string} projectId The project ID.
+ * @param {string} member The member to add, e.g., 'user:foo@example.com'.
+ * @param {string} role The role to grant, e.g., 'roles/viewer'.
+ */
+export async function addIamPolicyBinding(projectId, member, role) {
+  const { ProjectsClient } = await import('@google-cloud/resource-manager');
+  const client = new ProjectsClient();
+
+  console.log(
+    `Adding IAM binding for ${member} with role ${role} to project ${projectId}`
+  );
+
+  try {
+    const [policy] = await client.getIamPolicy({
+      resource: `projects/${projectId}`,
+    });
+
+    console.log('Current IAM Policy:', JSON.stringify(policy, null, 2));
+
+    // Check if the binding already exists
+    const binding = policy.bindings.find((b) => b.role === role);
+    if (binding) {
+      if (!binding.members.includes(member)) {
+        binding.members.push(member);
+      }
+    } else {
+      policy.bindings.push({
+        role: role,
+        members: [member],
+      });
+    }
+
+    console.log('Updated IAM Policy:', JSON.stringify(policy, null, 2));
+
+    // Set the updated policy
+    await client.setIamPolicy({
+      resource: `projects/${projectId}`,
+      policy: policy,
+    });
+
+    console.log(
+      `Successfully added IAM binding for ${member} with role ${
+        role
+      } to project ${projectId}`
+    );
+  } catch (error) {
+    console.error(
+      `Error adding IAM policy binding to project ${projectId}:`,
+      error.message
+    );
+    throw error;
+  }
+}
+
+/**
+ * Create project, attach billing.
+ * @returns {Promise<string>} projectId
+ */
+export async function setupProject() {
+  const projectId = 'test-' + generateProjectId();
+  console.log(`Generated project ID: ${projectId}`);
+  const parent = process.env.GCP_PARENT || process.argv[2];
+  const newProjectResult = await createProjectAndAttachBilling(
+    projectId,
+    parent
+  );
+  assert(newProjectResult, 'newProjectResult should not be null');
+  assert(
+    newProjectResult.projectId,
+    'newProjectResult.projectId should not be null'
+  );
+  assert(
+    newProjectResult.billingMessage,
+    'newProjectResult.billingMessage should not be null'
+  );
+  assert(
+    newProjectResult.billingMessage.startsWith(
+      `Project ${newProjectResult.projectId} created successfully.`
+    ),
+    'newProjectResult.billingMessage should start with success message'
+  );
+  console.log(`Successfully created project: ${newProjectResult.projectId}`);
+  console.log(newProjectResult.billingMessage);
+
+  return projectId;
+}
+
+/**
+ * Delete project
+ * @param {string} projectId
+ */
+export async function cleanupProject(projectId) {
+  try {
+    await deleteProject(projectId);
+    console.log(`Successfully deleted project: ${projectId}`);
+  } catch (e) {
+    console.error(`Failed to delete project ${projectId}:`, e.message);
+  }
+}
+
+/**
+ * Enable APIs and set IAM permissions for source deployments.
+ * Note: This function is only needed for Cloud Build since it uses the compute
+ * default service account. The compute service account needs the editor role to
+ * deploy to Cloud Run, which is usually granted by default, but in this case we
+ * ensure it due to restrictions in some organizations.
+ * @param {string} projectId
+ */
+export async function setSourceDeployProjectPermissions(projectId) {
+  const { ServiceUsageClient } = await import('@google-cloud/service-usage');
+  const serviceUsageClient = new ServiceUsageClient({ projectId });
+  const context = {
+    serviceUsageClient: serviceUsageClient,
+  };
+  await ensureApisEnabled(context, projectId, ['run.googleapis.com']);
+  console.log('Adding editor role to Compute SA...');
+  const projectNumber = await getProjectNumber(projectId);
+  const member = `serviceAccount:${projectNumber}-compute@developer.gserviceaccount.com`;
+  await callWithRetry(
+    () => addIamPolicyBinding(projectId, member, 'roles/editor'),
+    `addIamPolicyBinding roles/editor to ${member}`
+  );
+  console.log('Compute SA editor role added.');
+}