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

package/lib/{gcp-projects.js → cloud-api/projects.js}

@@ -17,7 +17,7 @@ limitations under the License.
 import {
   listBillingAccounts,
   attachProjectToBillingAccount,
-} from './gcp-billing-accounts.js';
+} from './billing.js';
 
 /**
  * Lists all accessible Google Cloud Platform projects.
@@ -39,40 +39,50 @@ export async function listProjects() {
   }
 }
 
+/**
+ * Creates a compliant GCP project ID in the format 'mcp-cvc-cvc', where 'c' is a consonant and 'v' is a vowel.
+ * @function generateProjectId
+ * @returns {string} A randomly generated, compliant GCP project ID in the format 'mcp-cvc-cvc'.
+ */
+export function generateProjectId() {
+  const consonants = 'bcdfghjklmnpqrstvwxyz';
+  const vowels = 'aeiou';
+
+  const getRandomChar = (source) =>
+    source.charAt(Math.floor(Math.random() * source.length));
+
+  const generateCVC = () => {
+    const c1 = getRandomChar(consonants);
+    const v = getRandomChar(vowels);
+    const c2 = getRandomChar(consonants);
+    return `${c1}${v}${c2}`;
+  };
+
+  const cvc1 = generateCVC();
+  const cvc2 = generateCVC();
+  return `mcp-${cvc1}-${cvc2}`;
+}
+
 /**
  * Creates a new Google Cloud Platform project.
  * @async
  * @function createProject
  * @param {string} [projectId] - Optional. The desired ID for the new project. If not provided, a compliant ID will be generated automatically (e.g., app-cvc-cvc).
+ * @param {string} [parent] - Optional. The resource name of the parent under which the project is to be created. e.g., "organizations/123" or "folders/456".
  * @returns {Promise<{projectId: string}|null>} A promise that resolves to an object containing the new project's ID.
  */
-export async function createProject(projectId) {
+export async function createProject(projectId, parent) {
   const { ProjectsClient } = await import('@google-cloud/resource-manager');
   const client = new ProjectsClient();
   let projectIdToUse = projectId;
 
   if (!projectIdToUse) {
-    const consonants = 'bcdfghjklmnpqrstvwxyz';
-    const vowels = 'aeiou';
-
-    const getRandomChar = (source) =>
-      source.charAt(Math.floor(Math.random() * source.length));
-
-    const generateCVC = () => {
-      const c1 = getRandomChar(consonants);
-      const v = getRandomChar(vowels);
-      const c2 = getRandomChar(consonants);
-      return `${c1}${v}${c2}`;
-    };
-
-    const cvc1 = generateCVC();
-    const cvc2 = generateCVC();
-    projectIdToUse = `mcp-${cvc1}-${cvc2}`;
+    projectIdToUse = generateProjectId();
     console.log(`Project ID not provided, generated ID: ${projectIdToUse}`);
   }
 
   try {
-    const projectPayload = { projectId: projectIdToUse };
+    const projectPayload = { projectId: projectIdToUse, parent };
 
     console.log(`Attempting to create project with ID: ${projectIdToUse}`);
 
@@ -100,12 +110,13 @@ export async function createProject(projectId) {
  * @async
  * @function createProjectAndAttachBilling
  * @param {string} [projectIdParam] - Optional. The desired ID for the new project.
+ * @param {string} [parent] - Optional. The resource name of the parent under which the project is to be created. e.g., "organizations/123" or "folders/456".
  * @returns {Promise<{projectId: string, billingMessage: string}>} A promise that resolves to an object containing the project ID and a billing status message.
  */
-export async function createProjectAndAttachBilling(projectIdParam) {
+export async function createProjectAndAttachBilling(projectIdParam, parent) {
   let newProject;
   try {
-    newProject = await createProject(projectIdParam);
+    newProject = await createProject(projectIdParam, parent);
   } catch (error) {
     throw new Error(`Failed to create project: ${error.message}`);
   }
@@ -115,7 +126,7 @@ export async function createProjectAndAttachBilling(projectIdParam) {
   }
 
   const { projectId } = newProject;
-  let billingMessage = `Project ${projectId} created.`;
+  let billingMessage = `Project ${projectId} created successfully.`;
 
   try {
     const billingAccounts = await listBillingAccounts();
@@ -130,27 +141,46 @@ export async function createProjectAndAttachBilling(projectIdParam) {
           firstBillingAccount.name
         );
         if (billingInfo && billingInfo.billingEnabled) {
-          billingMessage += ` Successfully attached to billing account ${firstBillingAccount.displayName}.`;
+          billingMessage += ` It has been attached to billing account ${firstBillingAccount.displayName}.`;
         } else {
-          billingMessage += ` Could not attach to billing account ${firstBillingAccount.displayName} or billing not enabled. Please check manually. Console: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
+          billingMessage += ` However, it could not be attached to billing account ${firstBillingAccount.displayName} or billing not enabled. Please check manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
         }
       } else {
         const allBillingAccounts = billingAccounts
           .map((b) => `${b.displayName} (Open: ${b.open})`)
           .join(', ');
-        billingMessage += ` No open billing accounts found. Available (may not be usable): ${allBillingAccounts || 'None'}. Please link billing manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
+        billingMessage += ` However, no open billing accounts were found. Available (may not be usable): ${allBillingAccounts || 'None'}. Please link billing manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
       }
     } else {
-      billingMessage +=
-        ' No billing accounts found. Please link billing manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}';
+      billingMessage += ` However, no billing accounts were found. Please link billing manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
     }
   } catch (billingError) {
     console.error(
       `Error during billing operations for project ${projectId}:`,
       billingError
     );
-    billingMessage += ` Error during billing operations: ${billingError.message}. Please check manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
+    billingMessage += ` However, an error occurred during billing operations: ${billingError.message}. Please check manually: https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
   }
 
   return { projectId, billingMessage };
 }
+
+/**
+ * Deletes a Google Cloud Platform project.
+ * @async
+ * @function deleteProject
+ * @param {string} projectId - The ID of the project to delete.
+ * @returns {Promise<void>} A promise that resolves when the delete operation is initiated.
+ */
+export async function deleteProject(projectId) {
+  const { ProjectsClient } = await import('@google-cloud/resource-manager');
+  const client = new ProjectsClient();
+  try {
+    console.log(`Attempting to delete project with ID: ${projectId}`);
+    await client.deleteProject({ name: `projects/${projectId}` });
+    console.log(`Project ${projectId} deletion initiated successfully.`);
+  } catch (error) {
+    console.error(`Error deleting GCP project ${projectId}:`, error.message);
+    throw error; // Re-throw to be caught by the caller
+  }
+}

package/lib/cloud-api/registry.js

@@ -0,0 +1,98 @@
+/*
+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 { callWithRetry } from './helpers.js';
+import { logAndProgress } from '../util/helpers.js';
+
+/**
+ * Ensures that an Artifact Registry repository exists.
+ * If the repository does not exist, it attempts to create it with the specified format.
+ *
+ * @async
+ * @param {object} context - The context object containing clients and other parameters.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} location - The Google Cloud region for the repository.
+ * @param {string} repositoryId - The ID for the Artifact Registry repository.
+ * @param {string} [format='DOCKER'] - The format of the repository (e.g., 'DOCKER', 'NPM'). Defaults to 'DOCKER'.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<object>} A promise that resolves with the Artifact Registry repository object.
+ * @throws {Error} If there's an error checking or creating the repository.
+ */
+export async function ensureArtifactRegistryRepoExists(
+  context,
+  projectId,
+  location,
+  repositoryId,
+  format = 'DOCKER',
+  progressCallback
+) {
+  const parent = `projects/${projectId}/locations/${location}`;
+  const repoPath = context.artifactRegistryClient.repositoryPath(
+    projectId,
+    location,
+    repositoryId
+  );
+
+  try {
+    const [repository] = await callWithRetry(
+      () => context.artifactRegistryClient.getRepository({ name: repoPath }),
+      `artifactRegistry.getRepository ${repositoryId}`
+    );
+    await logAndProgress(
+      `Repository ${repositoryId} already exists in ${location}.`,
+      progressCallback
+    );
+    return repository;
+  } catch (error) {
+    if (error.code === 5) {
+      await logAndProgress(
+        `Repository ${repositoryId} does not exist in ${location}. Creating...`,
+        progressCallback
+      );
+      const repositoryToCreate = {
+        format: format,
+      };
+
+      const [operation] = await callWithRetry(
+        () =>
+          context.artifactRegistryClient.createRepository({
+            parent: parent,
+            repository: repositoryToCreate,
+            repositoryId: repositoryId,
+          }),
+        `artifactRegistry.createRepository ${repositoryId}`
+      );
+      await logAndProgress(
+        `Creating Artifact Registry repository ${repositoryId}...`,
+        progressCallback
+      );
+      const [result] = await operation.promise();
+      await logAndProgress(
+        `Artifact Registry repository ${result.name} created successfully.`,
+        progressCallback
+      );
+      return result;
+    } else {
+      const errorMessage = `Error checking/creating repository ${repositoryId}: ${error.message}`;
+      console.error(
+        `Error checking/creating repository ${repositoryId}:`,
+        error
+      );
+      await logAndProgress(errorMessage, progressCallback, 'error');
+      throw error;
+    }
+  }
+}

package/lib/{cloud-run-services.js → cloud-api/run.js}

@@ -15,42 +15,74 @@ limitations under the License.
 */
 
 import protofiles from 'google-proto-files';
-import { callWithRetry, ensureApisEnabled } from './gcp-api-helpers.js';
+import { callWithRetry, ensureApisEnabled } from './helpers.js';
+import { logAndProgress } from '../util/helpers.js';
 
 let runClient;
+let serviceUsageClient;
 let loggingClient;
 
+async function listCloudRunLocations(projectId) {
+  const listLocationsRequest = {
+    name: `projects/${projectId}`,
+  };
+
+  const availableLocations = [];
+  try {
+    console.log('Listing Cloud Run supported locations:');
+    const iterable = runClient.listLocationsAsync(listLocationsRequest);
+    for await (const location of iterable) {
+      if (location.labels.initialized) {
+        console.log(`${location.locationId}: ${location.name}`);
+        availableLocations.push(location.locationId);
+      }
+    }
+  } catch (err) {
+    console.error('Error listing locations:', err);
+    throw err;
+  }
+  return availableLocations;
+}
+
 /**
- * Lists all Cloud Run services in a given project and location.
+ * Lists all Cloud Run services in a given project.
  * @param {string} projectId - The Google Cloud project ID.
- * @param {string} location - The Google Cloud location (e.g., 'europe-west1').
- * @returns {Promise<Array<object>>} - A promise that resolves to an array of service objects.
+ * @returns {Promise<object>} - A promise that resolves to an object mapping region to list of service objects in that region.
  */
-export async function listServices(projectId, location) {
-  // TODO make location optional, if not provided, list all services from all regions
+export async function listServices(projectId) {
   if (!runClient) {
     const { v2 } = await import('@google-cloud/run');
     const { ServicesClient } = v2;
+    const { ServiceUsageClient } = await import('@google-cloud/service-usage');
     runClient = new ServicesClient({ projectId });
+    serviceUsageClient = new ServiceUsageClient({ projectId });
   }
+  const context = {
+    runClient: runClient,
+    serviceUsageClient: serviceUsageClient,
+  };
+  await ensureApisEnabled(context, projectId, ['run.googleapis.com']);
+  const locations = await listCloudRunLocations(projectId);
 
-  await ensureApisEnabled(projectId, ['run.googleapis.com']);
+  const allServices = {};
+  for (const location of locations) {
+    const parent = runClient.locationPath(projectId, location);
 
-  const parent = runClient.locationPath(projectId, location);
-
-  try {
-    console.log(
-      `Listing Cloud Run services in project ${projectId}, location ${location}...`
-    );
-    const [services] = await callWithRetry(
-      () => runClient.listServices({ parent }),
-      'listServices'
-    );
-    return services;
-  } catch (error) {
-    console.error(`Error listing Cloud Run services:`, error);
-    throw error;
+    try {
+      console.log(
+        `Listing Cloud Run services in project ${projectId}, location ${location}...`
+      );
+      const [services] = await callWithRetry(
+        () => runClient.listServices({ parent }),
+        'listServices'
+      );
+      allServices[location] = services;
+    } catch (error) {
+      console.error(`Error listing Cloud Run services:`, error);
+      throw error;
+    }
   }
+  return allServices;
 }
 
 /**
@@ -191,3 +223,53 @@ function formatLogEntry(entry) {
   }
   return `[${timestampStr}] [${severity}] ${responseData} ${data}`;
 }
+
+/**
+ * Checks if a Cloud Run service already exists.
+ *
+ * @async
+ * @param {object} context - The context object containing clients and other parameters.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} location - The Google Cloud region where the service is located.
+ * @param {string} serviceId - The ID of the Cloud Run service.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<boolean>} A promise that resolves to true if the service exists, false otherwise.
+ * @throws {Error} If there's an error checking the service (other than not found).
+ */
+export async function checkCloudRunServiceExists(
+  context,
+  projectId,
+  location,
+  serviceId,
+  progressCallback
+) {
+  const parent = context.runClient.locationPath(projectId, location);
+  const servicePath = context.runClient.servicePath(
+    projectId,
+    location,
+    serviceId
+  );
+  try {
+    await callWithRetry(
+      () => context.runClient.getService({ name: servicePath }),
+      `getService ${serviceId}`
+    );
+    await logAndProgress(
+      `Cloud Run service ${serviceId} already exists.`,
+      progressCallback
+    );
+    return true;
+  } catch (error) {
+    if (error.code === 5) {
+      await logAndProgress(
+        `Cloud Run service ${serviceId} does not exist.`,
+        progressCallback
+      );
+      return false;
+    }
+    const errorMessage = `Error checking Cloud Run service ${serviceId}: ${error.message}`;
+    console.error(`Error checking Cloud Run service ${serviceId}:`, error);
+    await logAndProgress(errorMessage, progressCallback, 'error');
+    throw error;
+  }
+}

package/lib/cloud-api/storage.js

@@ -0,0 +1,123 @@
+/*
+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 { callWithRetry } from './helpers.js';
+import { logAndProgress } from '../util/helpers.js';
+
+/**
+ * Ensures that a Google Cloud Storage bucket exists.
+ * If the bucket does not exist, it attempts to create it in the specified location.
+ *
+ * @async
+ * @param {object} context - The context object containing clients and other parameters.
+ * @param {string} bucketName - The name of the storage bucket.
+ * @param {string} [location='us'] - The location to create the bucket in if it doesn't exist. Defaults to 'us'.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<import('@google-cloud/storage').Bucket>} A promise that resolves with the GCS Bucket object.
+ * @throws {Error} If there's an error checking or creating the bucket.
+ */
+export async function ensureStorageBucketExists(
+  context,
+  bucketName,
+  location = 'us',
+  progressCallback
+) {
+  const bucket = context.storage.bucket(bucketName);
+  try {
+    const [exists] = await callWithRetry(
+      () => bucket.exists(),
+      `storage.bucket.exists ${bucketName}`
+    );
+    if (exists) {
+      await logAndProgress(
+        `Bucket ${bucketName} already exists.`,
+        progressCallback
+      );
+      return bucket;
+    } else {
+      await logAndProgress(
+        `Bucket ${bucketName} does not exist. Creating in location ${location}...`,
+        progressCallback
+      );
+      try {
+        const [createdBucket] = await callWithRetry(
+          () =>
+            context.storage.createBucket(bucketName, { location: location }),
+          `storage.createBucket ${bucketName}`
+        );
+        await logAndProgress(
+          `Storage bucket ${createdBucket.name} created successfully in ${location}.`,
+          progressCallback
+        );
+        return createdBucket;
+      } catch (createError) {
+        const errorMessage = `Failed to create storage bucket ${bucketName}. Error details: ${createError.message}`;
+        console.error(
+          `Failed to create storage bucket ${bucketName}. Error details:`,
+          createError
+        );
+        await logAndProgress(errorMessage, progressCallback, 'error');
+        throw createError;
+      }
+    }
+  } catch (error) {
+    const errorMessage = `Error checking/creating bucket ${bucketName}: ${error.message}`;
+    console.error(`Error checking/creating bucket ${bucketName}:`, error);
+    await logAndProgress(errorMessage, progressCallback, 'error');
+    throw error;
+  }
+}
+
+/**
+ * Uploads a buffer to a specified Google Cloud Storage bucket and blob name.
+ *
+ * @async
+ * @param {object} context - The context object containing clients and other parameters.
+ * @param {import('@google-cloud/storage').Bucket} bucket - The Google Cloud Storage bucket object.
+ * @param {Buffer} buffer - The buffer containing the data to upload.
+ * @param {string} destinationBlobName - The name for the blob in the bucket.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<import('@google-cloud/storage').File>} A promise that resolves with the GCS File object representing the uploaded blob.
+ * @throws {Error} If the upload fails.
+ */
+export async function uploadToStorageBucket(
+  context,
+  bucket,
+  buffer,
+  destinationBlobName,
+  progressCallback
+) {
+  try {
+    await logAndProgress(
+      `Uploading buffer to gs://${bucket.name}/${destinationBlobName}...`,
+      progressCallback
+    );
+    await callWithRetry(
+      () => bucket.file(destinationBlobName).save(buffer),
+      `storage.bucket.file.save ${destinationBlobName}`
+    );
+    await logAndProgress(
+      `File ${destinationBlobName} uploaded successfully to gs://${bucket.name}/${destinationBlobName}.`,
+      progressCallback
+    );
+    return bucket.file(destinationBlobName);
+  } catch (error) {
+    const errorMessage = `Error uploading buffer: ${error.message}`;
+    console.error(`Error uploading buffer:`, error);
+    await logAndProgress(errorMessage, progressCallback, 'error');
+    throw error;
+  }
+}