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

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;
+  }
+}

package/lib/deployment/constants.js

@@ -0,0 +1,54 @@
+/*
+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.
+*/
+
+export const DEPLOYMENT_CONFIG = {
+  REPO_NAME: 'mcp-cloud-run-deployments',
+  ZIP_FILE_NAME: 'source.zip',
+  TARGZ_FILE_NAME: 'source.tar.gz',
+  IMAGE_TAG: 'latest',
+  LABEL_CREATED_BY: 'cloud-run-mcp',
+  DEFAULT_NODE_BASE_IMAGE: 'nodejs22',
+  NO_BUILD_IMAGE_TYPE: 'scratch',
+};
+
+export const TEMP_PATHS = {
+  BASE: '.cloud-run-mcp',
+  SUBDIR: 'source',
+};
+
+export const REQUIRED_APIS = {
+  SOURCE_DEPLOY: [
+    'serviceusage.googleapis.com',
+    'iam.googleapis.com',
+    'storage.googleapis.com',
+    'cloudbuild.googleapis.com',
+    'artifactregistry.googleapis.com',
+    'run.googleapis.com',
+  ],
+  IMAGE_DEPLOY: ['serviceusage.googleapis.com', 'run.googleapis.com'],
+};
+
+export const DEPLOYMENT_TYPES = {
+  NO_BUILD: 'no-build',
+  IMAGE: 'image',
+  WITH_BUILD: 'with-build',
+};
+
+export const RUNTIMES = {
+  NODEJS: 'nodejs',
+};
+
+export const MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES = 250 * 1024 * 1024; // 250 MiB