@google-cloud/cloud-run-mcp 1.0.0

package/lib/cloud-run-services.js

@@ -0,0 +1,181 @@
+/*
+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 protofiles from 'google-proto-files';
+
+let runClient;
+let loggingClient;
+
+/**
+ * Lists all Cloud Run services in a given project and location.
+ * @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.
+ */
+export async function listServices(projectId, location) {
+  // TODO make location optional, if not provided, list all services from all regions
+  if (!runClient) {
+    const { v2 } = await import('@google-cloud/run');
+    const { ServicesClient } = v2;
+    runClient = new ServicesClient({ projectId });
+  }
+  const parent = runClient.locationPath(projectId, location);
+
+  try {
+    console.log(
+      `Listing Cloud Run services in project ${projectId}, location ${location}...`
+    );
+    const [services] = await runClient.listServices({ parent });
+    return services;
+  } catch (error) {
+    console.error(`Error listing Cloud Run services:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Gets details for a specific Cloud Run service.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} location - The Google Cloud location (e.g., 'europe-west1').
+ * @param {string} serviceId - The ID of the Cloud Run service.
+ * @returns {Promise<object>} - A promise that resolves to the service object.
+ */
+export async function getService(projectId, location, serviceId) {
+  if (!runClient) {
+    const { v2 } = await import('@google-cloud/run');
+    const { ServicesClient } = v2;
+    runClient = new ServicesClient({ projectId });
+  }
+
+  const servicePath = runClient.servicePath(projectId, location, serviceId);
+
+  try {
+    console.log(
+      `Getting details for Cloud Run service ${serviceId} in project ${projectId}, location ${location}...`
+    );
+    const [service] = await runClient.getService({ name: servicePath });
+    return service;
+  } catch (error) {
+    console.error(
+      `Error getting details for Cloud Run service ${serviceId}:`,
+      error
+    );
+    // Check if the error is a "not found" error (gRPC code 5)
+    if (error.code === 5) {
+      console.log(`Cloud Run service ${serviceId} not found.`);
+      return null; // Or throw a custom error, or handle as needed
+    }
+    throw error; // Re-throw other errors
+  }
+}
+
+/**
+ * Fetches a paginated list of logs for a specific Cloud Run service.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @param {string} location - The Google Cloud location (e.g., 'europe-west1').
+ * @param {string} serviceId - The ID of the Cloud Run service.
+ * @param {string} [requestOptions] - The token for the next page of results.
+ * @returns {Promise<{logs: string, requestOptions: object | undefined }>} - A promise that resolves to an object with log entries and a token for the next page.
+ */
+export async function getServiceLogs(
+  projectId,
+  location,
+  serviceId,
+  requestOptions
+) {
+  if (!loggingClient) {
+    const { Logging } = await import('@google-cloud/logging');
+    loggingClient = new Logging({ projectId });
+  }
+
+  try {
+    const LOG_SEVERITY = 'DEFAULT'; // e.g., 'DEFAULT', 'INFO', 'WARNING', 'ERROR'
+    const PAGE_SIZE = 100; // Number of log entries to retrieve per page
+
+    const filter = `resource.type="cloud_run_revision"
+                    resource.labels.service_name="${serviceId}"
+                    resource.labels.location="${location}"
+                    severity>=${LOG_SEVERITY}`;
+
+    console.log(
+      `Fetching logs for Cloud Run service ${serviceId} in project ${projectId}, location ${location}...`
+    );
+
+    // Options for the getEntries API call
+    const options = requestOptions || {
+      filter: filter,
+      orderBy: 'timestamp desc', // Get the latest logs first
+      pageSize: PAGE_SIZE,
+    };
+    console.log(`Request options: ${JSON.stringify(options)}`);
+
+    // getEntries returns the entries and the full API response
+    const [entries, nextRequestOptions, apiResponse] =
+      await loggingClient.getEntries(options);
+
+    const formattedLogLines = entries
+      .map((entry) => formatLogEntry(entry))
+      .join('\n');
+
+    // The nextPageToken is available in the apiResponse object
+    const nextOptions = apiResponse?.nextPageToken
+      ? nextRequestOptions
+      : undefined;
+
+    return {
+      logs: formattedLogLines,
+      requestOptions: nextOptions,
+    };
+  } catch (error) {
+    console.error(
+      `Error fetching logs for Cloud Run service ${serviceId}:`,
+      error
+    );
+    throw error;
+  }
+}
+
+/**
+ * Formats a single log entry for display.
+ * @param {object} entry - A log entry object from the Cloud Logging API.
+ * @returns {string} - A formatted string representation of the log entry.
+ */
+function formatLogEntry(entry) {
+  const timestampStr = entry.metadata.timestamp.toISOString() || 'N/A';
+  const severity = entry.metadata.severity || 'N/A';
+  let responseData = '';
+  if (entry.metadata.httpRequest) {
+    const responseMethod = entry.metadata.httpRequest.requestMethod;
+    const responseCode = entry.metadata.httpRequest.status;
+    const requestUrl = entry.metadata.httpRequest.requestUrl;
+    const responseSize = entry.metadata.httpRequest.responseSize;
+    responseData = `HTTP Request: ${responseMethod} StatusCode: ${responseCode} ResponseSize: ${responseSize} Byte - ${requestUrl}`;
+  }
+
+  let data = '';
+  if (entry.data && entry.data.value) {
+    const protopath = protofiles.getProtoPath(
+      '../google/cloud/audit/audit_log.proto'
+    );
+    const root = protofiles.loadSync(protopath);
+    const type = root.lookupType('google.cloud.audit.AuditLog');
+    const value = type.decode(entry.data.value);
+    data = `${value.methodName}: ${value.status?.message || ''}${value.authenticationInfo?.principalEmail || ''}`;
+  } else if (entry.data) {
+    data = entry.data;
+  }
+  return `[${timestampStr}] [${severity}] ${responseData} ${data}`;
+}

package/lib/gcp-auth-check.js

@@ -0,0 +1,79 @@
+/*
+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 { GoogleAuth } from 'google-auth-library';
+
+/**
+ * Checks for the presence of properly setup Google Cloud Platform (GCP) authentication
+ * using the official Google Auth Library for Node.js. If GCP auth is not found, it logs an
+ * error message and exits the process, instructing the user on how to set them up.
+ * This check is primarily for local/stdio environments where explicit setup is often needed.
+ * @async
+ * @returns {Promise<void>} A promise that resolves if GCP auth are found, or rejects and exits the process if not.
+ */
+export async function ensureGCPCredentials() {
+  console.error('Checking for Google Cloud Application Default Credentials...');
+  try {
+    const auth = new GoogleAuth();
+    // Attempt to get credentials. This will throw an error if ADC are not found.
+    const client = await auth.getClient();
+    // Attempt to get an access token to verify credentials are usable.
+    // This is done because getClient() might succeed but credentials might be invalid/expired.
+    await client.getAccessToken();
+
+    console.log('Application Default Credentials found.');
+  } catch (error) {
+    console.error(
+      'ERROR: Google Cloud Application Default Credentials are not set up.'
+    );
+
+    if (error.response && error.response.status) {
+      console.error(
+        `An HTTP error occurred (Status: ${error.response.status}). This often means misconfigured, expired credentials, or a network issue.`
+      );
+    } else if (error instanceof TypeError) {
+      // Catches TypeErrors specifically, which might indicate a malformed response or unexpected data type
+      console.error(
+        'An unexpected error occurred during credential verification (e.g., malformed response or invalid type).'
+      );
+    } else {
+      // General fallback for any other unexpected errors
+      console.error(
+        'An unexpected error occurred during credential verification.'
+      );
+    }
+
+    console.error('\nFor more details or alternative setup methods, consider:');
+    console.error(
+      '1. If running locally, run: gcloud auth application-default login.'
+    );
+    console.error(
+      '2. Ensuring the `GOOGLE_APPLICATION_CREDENTIALS` environment variable points to a valid service account key file.'
+    );
+    console.error(
+      '3. If on a Google Cloud environment (e.g., GCE, Cloud Run), verify the associated service account has necessary permissions.'
+    );
+    console.error(
+      `\nOriginal error message from Google Auth Library: ${error.message}`
+    );
+
+    // Print the stack for debugging
+    if (error.stack) {
+      console.error('Error stack:', error.stack);
+    }
+    // process.exit(1);
+  }
+}

package/lib/gcp-billing-accounts.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.
+*/
+
+/**
+ * Lists all accessible Google Cloud Billing Accounts.
+ * @async
+ * @function listBillingAccounts
+ * @returns {Promise<Array<{name: string, displayName: string, open: boolean}>>} A promise that resolves to an array of billing account objects,
+ * each with 'name', 'displayName', and 'open' status. Returns an empty array on error.
+ */
+export async function listBillingAccounts() {
+  const { CloudBillingClient } = await import('@google-cloud/billing');
+  const client = new CloudBillingClient();
+  try {
+    const [accounts] = await client.listBillingAccounts();
+    if (!accounts || accounts.length === 0) {
+      console.log('No billing accounts found.');
+      return [];
+    }
+    return accounts.map((account) => ({
+      name: account.name, // e.g., billingAccounts/0X0X0X-0X0X0X-0X0X0X
+      displayName: account.displayName,
+      open: account.open,
+    }));
+  } catch (error) {
+    console.error('Error listing GCP billing accounts:', error);
+    return [];
+  }
+}
+
+/**
+ * Attaches a Google Cloud Project to a specified Billing Account.
+ * @async
+ * @function attachProjectToBillingAccount
+ * @param {string} projectId - The ID of the project to attach.
+ * @param {string} billingAccountName - The resource name of the billing account (e.g., 'billingAccounts/0X0X0X-0X0X0X-0X0X0X').
+ * @returns {Promise<object|null>} A promise that resolves to the updated project billing information object if successful, or null on error.
+ */
+export async function attachProjectToBillingAccount(
+  projectId,
+  billingAccountName
+) {
+  const { CloudBillingClient } = await import('@google-cloud/billing');
+  const client = new CloudBillingClient();
+  const projectName = `projects/${projectId}`;
+
+  if (!projectId) {
+    console.error('Error: projectId is required.');
+    return null;
+  }
+  if (
+    !billingAccountName ||
+    !billingAccountName.startsWith('billingAccounts/')
+  ) {
+    console.error(
+      'Error: billingAccountName is required and must be in the format "billingAccounts/XXXXXX-XXXXXX-XXXXXX".'
+    );
+    return null;
+  }
+
+  try {
+    console.log(
+      `Attempting to attach project ${projectId} to billing account ${billingAccountName}...`
+    );
+    const [updatedBillingInfo] = await client.updateProjectBillingInfo({
+      name: projectName,
+      projectBillingInfo: {
+        billingAccountName: billingAccountName,
+      },
+    });
+    console.log(
+      `Successfully attached project ${projectId} to billing account ${billingAccountName}.`
+    );
+    console.log(`Billing enabled: ${updatedBillingInfo.billingEnabled}`);
+    return updatedBillingInfo;
+  } catch (error) {
+    console.error(
+      `Error attaching project ${projectId} to billing account ${billingAccountName}:`,
+      error.message || error
+    );
+    // Log more details if available, e.g. error.details
+    // if (error.details) console.error("Error details:", error.details);
+    return null;
+  }
+}

package/lib/gcp-metadata.js

@@ -0,0 +1,62 @@
+/*
+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.
+*/
+
+// Helper function to fetch data from GCP metadata server
+/**
+ * Fetches metadata from the Google Cloud metadata server.
+ *
+ * @param {string} path - The metadata path to fetch (e.g., `/computeMetadata/v1/...`).
+ * @returns {Promise<string>} A promise that resolves to the metadata value as a string.
+ * @throws {Error} If the metadata request fails with a non-OK status.
+ */
+async function fetchMetadata(path) {
+  const response = await fetch(`http://metadata.google.internal${path}`, {
+    headers: {
+      'Metadata-Flavor': 'Google',
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Metadata request failed with status ${response.status}`);
+  }
+  return await response.text();
+}
+
+/**
+ * Checks if the GCP metadata server is available and retrieves project ID and region.
+ * @returns {Promise<Object|null>} A promise that resolves to an object { project: string, region: string } or null if not available or an error occurs.
+ */
+export async function checkGCP() {
+  try {
+    const projectId = await fetchMetadata(
+      '/computeMetadata/v1/project/project-id'
+    );
+    // Expected format: projects/PROJECT_NUMBER/regions/REGION_NAME
+    const regionPath = await fetchMetadata(
+      '/computeMetadata/v1/instance/region'
+    );
+
+    if (projectId && regionPath) {
+      const regionParts = regionPath.split('/');
+      const region = regionParts[regionParts.length - 1];
+      return { project: projectId, region: region };
+    }
+    return null;
+  } catch (error) {
+    // Intentionally suppress error logging for cleaner output if metadata server is not available.
+    // console.warn('Failed to fetch GCP metadata:', error.message); // Uncomment for debugging
+    return null;
+  }
+}

package/lib/gcp-projects.js

@@ -0,0 +1,156 @@
+/*
+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 {
+  listBillingAccounts,
+  attachProjectToBillingAccount,
+} from './gcp-billing-accounts.js';
+
+/**
+ * Lists all accessible Google Cloud Platform projects.
+ * @async
+ * @function listProjects
+ * @returns {Promise<Array<{id: string}>>} A promise that resolves to an array of project objects, each with an 'id' property. Returns an empty array on error.
+ */
+export async function listProjects() {
+  const { ProjectsClient } = await import('@google-cloud/resource-manager');
+  const client = new ProjectsClient();
+  try {
+    const [projects] = await client.searchProjects();
+    return projects.map((project) => ({
+      id: project.projectId,
+    }));
+  } catch (error) {
+    console.error('Error listing GCP projects:', error);
+    return [];
+  }
+}
+
+/**
+ * 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).
+ * @returns {Promise<{projectId: string}|null>} A promise that resolves to an object containing the new project's ID.
+ */
+export async function createProject(projectId) {
+  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}`;
+    console.log(`Project ID not provided, generated ID: ${projectIdToUse}`);
+  }
+
+  try {
+    const projectPayload = { projectId: projectIdToUse, name: projectIdToUse };
+
+    console.log(`Attempting to create project with ID: ${projectIdToUse}`);
+
+    const [operation] = await client.createProject({ project: projectPayload });
+
+    const [createdProjectResponse] = await operation.promise();
+
+    console.log(
+      `Project ${createdProjectResponse.projectId} created successfully.`
+    );
+    return {
+      projectId: createdProjectResponse.projectId,
+    };
+  } catch (error) {
+    console.error(
+      `Error creating GCP project ${projectIdToUse}:`,
+      error.message
+    );
+    throw error; // Re-throw to be caught by the caller
+  }
+}
+
+/**
+ * Creates a new Google Cloud Platform project and attempts to attach it to the first available billing account.
+ * @async
+ * @function createProjectAndAttachBilling
+ * @param {string} [projectIdParam] - Optional. The desired ID for the new project.
+ * @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) {
+  let newProject;
+  try {
+    newProject = await createProject(projectIdParam);
+  } catch (error) {
+    throw new Error(`Failed to create project: ${error.message}`);
+  }
+
+  if (!newProject || !newProject.projectId) {
+    throw new Error('Project creation did not return a valid project ID.');
+  }
+
+  const { projectId } = newProject;
+  let billingMessage = `Project ${projectId} created.`;
+
+  try {
+    const billingAccounts = await listBillingAccounts();
+    if (billingAccounts && billingAccounts.length > 0) {
+      const firstBillingAccount = billingAccounts.find((acc) => acc.open); // Prefer an open account
+      if (firstBillingAccount) {
+        console.log(
+          `Found billing account: ${firstBillingAccount.displayName} (${firstBillingAccount.name}). Attempting to attach project ${projectId}.`
+        );
+        const billingInfo = await attachProjectToBillingAccount(
+          projectId,
+          firstBillingAccount.name
+        );
+        if (billingInfo && billingInfo.billingEnabled) {
+          billingMessage += ` Successfully 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}`;
+        }
+      } 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}`;
+      }
+    } else {
+      billingMessage +=
+        ' No billing accounts 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}`;
+  }
+
+  return { projectId, billingMessage };
+}