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

package/.env.example

@@ -0,0 +1,13 @@
+PORT = 3000
+GCP_STDIO = false
+
+OAUTH_ENABLED = true
+GOOGLE_OAUTH_CLIENT_ID = YOUR_CLIENT_ID
+GOOGLE_OAUTH_CLIENT_SECRET = YOUR_CLIENT_SECRET
+GOOGLE_OAUTH_AUDIENCE = YOUR_AUDIENCE # generally, same as your client id
+GOOGLE_OAUTH_REDIRECT_URI = http://localhost:7777/oauth/callback
+
+OAUTH_PROTECTED_RESOURCE = http://localhost:${PORT}/mcp
+OAUTH_AUTHORIZATION_SERVER = http://localhost:${PORT}/auth/google
+OAUTH_AUTHORIZATION_ENDPOINT = https://accounts.google.com/o/oauth2/v2/auth
+OAUTH_TOKEN_ENDPOINT = https://oauth2.googleapis.com/token

package/.env.gcloud-sdk-oauth

@@ -0,0 +1,13 @@
+PORT = 3000
+GCP_STDIO = false
+
+OAUTH_ENABLED = true
+GOOGLE_OAUTH_CLIENT_ID = 32555940559.apps.googleusercontent.com
+GOOGLE_OAUTH_CLIENT_SECRET = ZmssLNjJy2998hD4CTg2ejr2
+GOOGLE_OAUTH_AUDIENCE = 32555940559.apps.googleusercontent.com
+GOOGLE_OAUTH_REDIRECT_URI = http://localhost:7777/oauth/callback
+
+OAUTH_PROTECTED_RESOURCE = http://localhost:${PORT}/mcp
+OAUTH_AUTHORIZATION_SERVER = http://localhost:${PORT}/auth/google
+OAUTH_AUTHORIZATION_ENDPOINT = https://accounts.google.com/o/oauth2/v2/auth
+OAUTH_TOKEN_ENDPOINT = https://oauth2.googleapis.com/token

package/README.md

@@ -235,4 +235,42 @@ With this option, you will only be able to deploy code to the same Google Cloud
       }
    ```
 
+## Using MCP Server with OAuth
+
+Cloud Run MCP server supports OAuth as an authentication mechanism. In order to use OAuth, create the OAuth client, and configure a `.env` file with the appropriate values pertaining to your OAuth client. A `.env.example` is provided for reference.
+
+The Cloud Run MCP server works seamlessly with Google Cloud SDK OAuth client. In order to leverage the Google Cloud SDK OAuth client, you can use the `.env.gcloud-sdk-oauth` file as your `.env` file as follows:
+
+```bash
+cp .env.gcloud-sdk-oauth .env
+node mcp-server.js
+```
+
+### Configure MCP Server on Gemini CLI to use OAuth
+
+When the Cloud Run MCP server is started in the OAuth mode, the MCP client should also be configured to use OAuth. You can setup the MCP server in OAuth mode in the Gemini CLI by using the following JSON in the `~/.gemini/settings.json` file:
+
+```json
+{
+  "mcpServers": {
+    "cloud-run": {
+      "httpUrl": "http://localhost:3000/mcp",
+      "oauth": {
+        "enabled": true,
+        "clientId": "<OAUTH_CLIENT_ID>",
+        "clientSecret": "<OAUTH_CLIENT_SECRET>"
+      }
+    }
+  }
+}
+```
+
+Post the configuration changes as shown above, start the Gemini CLI. You should authenticate the Cloud Run MCP server using the following prompt in the Gemini CLI:
+
+```
+/mcp auth cloud-run
+```
+
+This will take you to the authentication page on your browser, wherein you need to sign in using the appropriate gmail id, and accept the terms and conditions. Once the authentication is succcessful, you can come back to the Gemini CLI, and the Cloud Run MCP server will be ready to use.
+
 The Google Cloud Platform Terms of Service (available at https://cloud.google.com/terms/) and the Data Processing and Security Terms (available at https://cloud.google.com/terms/data-processing-terms) do not apply to any component of the Cloud Run MCP Server software.

package/constants.js

@@ -0,0 +1,8 @@
+export const SCOPES = {
+  OPENID: 'openid',
+  EMAIL: 'https://www.googleapis.com/auth/userinfo.email',
+  CLOUD_PLATFORM: 'https://www.googleapis.com/auth/cloud-platform',
+};
+export const BEARER_METHODS_SUPPORTED = ['header'];
+export const RESPONSE_TYPES_SUPPORTED = ['code'];
+export const GCLOUD_AUTH = 'gcloud_auth';

package/lib/clients.js

@@ -0,0 +1,292 @@
+/*
+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 { OAuth2Client } from 'google-auth-library';
+import { GCLOUD_AUTH } from '../constants.js';
+
+const CLIENT_ID = process.env.GOOGLE_OAUTH_CLIENT_ID;
+const CLIENT_SECRET = process.env.GOOGLE_OAUTH_CLIENT_SECRET;
+const REDIRECT_URI = process.env.GOOGLE_OAUTH_REDIRECT_URI;
+const AUTHORIZATION_HEADER = 'Authorization';
+const BEARER_PREFIX = 'Bearer';
+
+function keyGenerator(projectId, accessToken) {
+  return accessToken !== GCLOUD_AUTH ? projectId + accessToken : projectId;
+}
+
+const clients = {
+  run: new Map(),
+  builds: new Map(),
+  serviceUsage: new Map(),
+  storage: new Map(),
+  cloudBuild: new Map(),
+  artifactRegistry: new Map(),
+  logging: new Map(),
+  billing: new Map(),
+  projects: new Map(),
+  oauth: new Map(),
+};
+
+function getAuthClient(accessToken) {
+  return {
+    getRequestHeaders: () => {
+      const headers = new Map();
+      headers.set(AUTHORIZATION_HEADER, `${BEARER_PREFIX} ${accessToken}`);
+      return headers;
+    },
+  };
+}
+
+/**
+ * Wraps an OAuth2Client to be compatible with gRPC-based Google Cloud clients.
+ *
+ * Some Google Cloud SDK clients (like Cloud Run, Service Usage, etc.) use gRPC
+ * and expect the `getRequestHeaders()` method of the auth client to return a
+ * `Map` of headers. However, the standard `OAuth2Client` from `google-auth-library`
+ * returns a plain Javascript object (e.g., `{ Authorization: 'Bearer ...' }`).
+ *
+ * This wrapper uses a Proxy to intercept calls to `getRequestHeaders`. It calls
+ * the original method and converts the result from a plain object to a `Map`
+ * if necessary, ensuring compatibility with gRPC-based clients while maintaining
+ * the original behavior for other properties.
+ *
+ * @param {OAuth2Client} authClient - The original OAuth2Client instance.
+ * @returns {Proxy<OAuth2Client>} A proxy compatible with gRPC clients.
+ */
+function wrapForGrpc(authClient) {
+  return new Proxy(authClient, {
+    get(target, prop, receiver) {
+      if (prop === 'getRequestHeaders') {
+        return async (...args) => {
+          const headers = await target.getRequestHeaders(...args);
+          if (headers instanceof Map) {
+            return headers;
+          }
+          // Convert plain object (from OAuth2Client) to Map (expected by grpc-js)
+          const headerMap = new Map();
+          for (const [k, v] of Object.entries(headers)) {
+            headerMap.set(k, v);
+          }
+          return headerMap;
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+}
+
+// Services that use HTTP/REST (or prefer Object headers) instead of gRPC (Map headers)
+const HTTP_SERVICES = ['storage', 'logging'];
+
+export async function getClient(
+  service,
+  key,
+  loadClient,
+  options = {},
+  accessToken = null
+) {
+  if (!clients[service].has(key)) {
+    const ClientClass = await loadClient();
+    const finalOptions = { ...options };
+    if (accessToken && accessToken !== GCLOUD_AUTH) {
+      const oauthClient = await getOAuthClient(accessToken);
+      // Storage and Logging use HTTP and expect the native OAuth2Client (headers as Object).
+      // Other services (Run, ServiceUsage, etc.) use gRPC and expect headers as Map.
+      if (HTTP_SERVICES.includes(service)) {
+        finalOptions.authClient = oauthClient;
+      } else {
+        finalOptions.authClient = wrapForGrpc(oauthClient);
+      }
+    }
+    clients[service].set(key, new ClientClass(finalOptions));
+  }
+  return clients[service].get(key);
+}
+
+/**
+ * Gets a Cloud Run Services Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/run').v2.ServicesClient>}
+ */
+export async function getRunClient(projectId, accessToken = GCLOUD_AUTH) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'run',
+    key,
+    async () => (await import('@google-cloud/run')).v2.ServicesClient,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Cloud Run Build Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/run').v2.BuildsClient>}
+ */
+export async function getBuildsClient(projectId, accessToken = GCLOUD_AUTH) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'builds',
+    key,
+    async () => (await import('@google-cloud/run')).v2.BuildsClient,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Service Usage Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/service-usage').ServiceUsageClient>}
+ */
+export async function getServiceUsageClient(
+  projectId,
+  accessToken = GCLOUD_AUTH
+) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'serviceUsage',
+    key,
+    async () =>
+      (await import('@google-cloud/service-usage')).ServiceUsageClient,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Storage Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/storage').Storage>}
+ */
+export async function getStorageClient(projectId, accessToken = GCLOUD_AUTH) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'storage',
+    key,
+    async () => (await import('@google-cloud/storage')).Storage,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Cloud Build Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/cloudbuild').CloudBuildClient>}
+ */
+export async function getCloudBuildClient(
+  projectId,
+  accessToken = GCLOUD_AUTH
+) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'cloudBuild',
+    key,
+    async () => (await import('@google-cloud/cloudbuild')).CloudBuildClient,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets an Artifact Registry Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/artifact-registry').ArtifactRegistryClient>}
+ */
+export async function getArtifactRegistryClient(
+  projectId,
+  accessToken = GCLOUD_AUTH
+) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'artifactRegistry',
+    key,
+    async () =>
+      (await import('@google-cloud/artifact-registry')).ArtifactRegistryClient,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Logging Client for the specified project.
+ * @param {string} projectId - The Google Cloud project ID.
+ * @returns {Promise<import('@google-cloud/logging').Logging>}
+ */
+export async function getLoggingClient(projectId, accessToken = GCLOUD_AUTH) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'logging',
+    key,
+    async () => (await import('@google-cloud/logging')).Logging,
+    { projectId },
+    accessToken
+  );
+}
+
+/**
+ * Gets a Billing Client for the specified project.
+ * Note: BillingClient usually doesn't take projectId in constructor for listing accounts,
+ * but might for project billing info. We will cache by projectId anyway or 'global' if projectId is null.
+ * @param {string} [projectId] - The Google Cloud project ID (optional).
+ * @returns {Promise<import('@google-cloud/billing').CloudBillingClient>}
+ */
+export async function getBillingClient(
+  projectId = 'global',
+  accessToken = GCLOUD_AUTH
+) {
+  const key = keyGenerator(projectId, accessToken);
+  return getClient(
+    'billing',
+    key,
+    async () => (await import('@google-cloud/billing')).CloudBillingClient,
+    projectId !== 'global' ? { projectId } : {},
+    accessToken
+  );
+}
+
+/**
+ * Gets a Projects Client (Resource Manager).
+ * @returns {Promise<import('@google-cloud/resource-manager').ProjectsClient>}
+ */
+export async function getProjectsClient(accessToken = GCLOUD_AUTH) {
+  const key = keyGenerator('global', accessToken);
+  return getClient(
+    'projects',
+    key,
+    async () => (await import('@google-cloud/resource-manager')).ProjectsClient,
+    {},
+    accessToken
+  );
+}
+
+/**
+ * Gets an OAuth2 Client for the specified access token.
+ * @param {string} accessToken - The access token.
+ * @returns {Promise<OAuth2Client>}
+ */
+export async function getOAuthClient(accessToken) {
+  // Use the access token itself as the key since it's unique per session/user
+  if (!clients.oauth.has(accessToken)) {
+    const client = new OAuth2Client(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);
+    client.setCredentials({ access_token: accessToken });
+    clients.oauth.set(accessToken, client);
+  }
+
+  return clients.oauth.get(accessToken);
+}

package/lib/cloud-api/auth.js

@@ -23,6 +23,7 @@ import { GoogleAuth } from 'google-auth-library';
  * @async
  * @returns {Promise<boolean>} A promise that resolves to true if GCP auth are found, and false otherwise.
  */
+//TODO: Rename ensureGCPCredentials to ensureADCCredentials
 export async function ensureGCPCredentials() {
   console.error('Checking for Google Cloud Application Default Credentials...');
   try {

package/lib/cloud-api/billing.js

@@ -21,9 +21,17 @@ limitations under the License.
  * @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();
+import { getBillingClient } from '../clients.js';
+
+/**
+ * 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(accessToken) {
+  const client = await getBillingClient('global', accessToken);
   try {
     const [accounts] = await client.listBillingAccounts();
     if (!accounts || accounts.length === 0) {
@@ -51,10 +59,10 @@ export async function listBillingAccounts() {
  */
 export async function attachProjectToBillingAccount(
   projectId,
-  billingAccountName
+  billingAccountName,
+  accessToken
 ) {
-  const { CloudBillingClient } = await import('@google-cloud/billing');
-  const client = new CloudBillingClient();
+  const client = await getBillingClient(projectId, accessToken);
   const projectName = `projects/${projectId}`;
 
   if (!projectId) {
@@ -104,9 +112,8 @@ export async function attachProjectToBillingAccount(
  * @param {string} projectId - The ID of the project to check.
  * @returns {Promise<boolean>} A promise that resolves to true if billing is enabled, false otherwise.
  */
-export async function isBillingEnabled(projectId) {
-  const { CloudBillingClient } = await import('@google-cloud/billing');
-  const client = new CloudBillingClient();
+export async function isBillingEnabled(projectId, accessToken) {
+  const client = await getBillingClient(projectId, accessToken);
   const projectName = `projects/${projectId}`;
   try {
     // getProjectBillingInfo requires cloudbilling.googleapis.com API to check billing status
@@ -127,18 +134,17 @@ export async function isBillingEnabled(projectId) {
 /**
  * Ensures billing is enabled for a project. If not, attempts to enable it
  * by attaching the single open billing account if one is found.
- * @param {object} context - The context object containing clients and other parameters.
  * @param {string} projectId The project ID to check billing for.
  * @param {function} progressCallback A callback function for progress updates.
  */
 export async function ensureBillingEnabled(
-  context,
   projectId,
+  accessToken,
   progressCallback
 ) {
-  if (!(await isBillingEnabled(projectId))) {
+  if (!(await isBillingEnabled(projectId, accessToken))) {
     // Billing is disabled, try to fix it.
-    const accounts = await listBillingAccounts();
+    const accounts = await listBillingAccounts(accessToken);
 
     if (accounts && accounts.length === 1 && accounts[0].open) {
       // Exactly one open account found, try to attach it.
@@ -150,7 +156,8 @@ export async function ensureBillingEnabled(
 
       const attachmentResult = await attachProjectToBillingAccount(
         projectId,
-        account.name
+        account.name,
+        accessToken
       );
 
       if (!attachmentResult || !attachmentResult.billingEnabled) {

package/lib/cloud-api/build.js

@@ -14,8 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import {
+  getCloudBuildClient,
+  getLoggingClient,
+  getRunClient,
+  getBuildsClient,
+} from '../clients.js';
 import { callWithRetry } from './helpers.js';
 import { logAndProgress } from '../util/helpers.js';
+import { checkCloudRunServiceExists } from './run.js';
 
 const DELAY_WAIT_FOR_BUILD_LOGS = 10000; // 10 seconds delay to allow logs to propagate
 const BUILD_LOGS_LINES_TO_FETCH = 100; // Number of log lines to fetch for build logs snippet
@@ -23,10 +30,10 @@ const BUILD_LOGS_LINES_TO_FETCH = 100; // Number of log lines to fetch for build
 /**
  * Triggers a Google Cloud Build job to build a container image from source code in a GCS bucket.
  * It uses either a Dockerfile found in the source or Google Cloud Buildpacks if no Dockerfile is present.
+ * It performs a dry-run deployment check before starting the build.
  * Waits for the build to complete and returns the build result.
  *
  * @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 build.
  * @param {string} sourceBucketName - The GCS bucket name where the source code (zip) is stored.
@@ -39,7 +46,6 @@ const BUILD_LOGS_LINES_TO_FETCH = 100; // Number of log lines to fetch for build
  * @throws {Error} If the Cloud Build job fails, times out, or encounters an error during initiation or execution.
  */
 export async function triggerCloudBuild(
-  context,
   projectId,
   location,
   sourceBucketName,
@@ -47,67 +53,111 @@ export async function triggerCloudBuild(
   targetRepoName,
   targetImageUrl,
   hasDockerfile,
+  accessToken,
   progressCallback
 ) {
+  const serviceName = targetImageUrl.split('/').pop().split(/[:@]/)[0];
+  const parent = `projects/${projectId}/locations/${location}`;
+  const serviceFullName = `${parent}/services/${serviceName}`;
+  const buildsClient = await getBuildsClient(projectId, accessToken);
+  const runClient = await getRunClient(projectId, accessToken);
+  const serviceExists = await checkCloudRunServiceExists(
+    projectId,
+    location,
+    serviceName,
+    accessToken,
+    progressCallback
+  );
+  const cloudBuildClient = await getCloudBuildClient(projectId, accessToken);
+  const loggingClient = await getLoggingClient(projectId, accessToken);
   let buildSteps;
 
-  if (hasDockerfile) {
-    buildSteps = [
-      {
-        name: 'gcr.io/cloud-builders/docker',
-        args: ['build', '-t', targetImageUrl, '.'],
-        dir: '/workspace',
-      },
-    ];
-  } else {
-    buildSteps = [
-      {
-        name: 'gcr.io/k8s-skaffold/pack',
-        entrypoint: 'pack',
-        args: [
-          'build',
-          targetImageUrl,
-          '--builder',
-          'gcr.io/buildpacks/builder:latest',
-        ],
-        dir: '/workspace',
-      },
-    ];
+  const servicePatch = {
+    template: {
+      containers: [{ image: targetImageUrl }],
+    },
+  };
+
+  try {
+    if (serviceExists) {
+      await logAndProgress(
+        `Performing dry-run update for service ${serviceName}...`,
+        progressCallback
+      );
+      servicePatch.name = serviceFullName;
+      await callWithRetry(
+        () =>
+          runClient.updateService({
+            service: servicePatch,
+            validateOnly: true,
+          }),
+        'run.updateService-dryrun'
+      );
+    } else {
+      await logAndProgress(
+        `Performing dry-run creation for service ${serviceName}...`,
+        progressCallback
+      );
+      await callWithRetry(
+        () =>
+          runClient.createService({
+            parent: parent,
+            service: servicePatch,
+            serviceId: serviceName,
+            validateOnly: true,
+          }),
+        'run.createService-dryrun'
+      );
+    }
+    await logAndProgress(
+      `Dry-run validation successful.`,
+      progressCallback,
+      'debug'
+    );
+  } catch (err) {
+    await logAndProgress(
+      `Dry-run validation failed for service ${serviceName}.`,
+      progressCallback,
+      'error'
+    );
+    throw new Error(`Dry-run deployment failed: ${err.message}`);
   }
 
-  const build = {
-    source: {
-      storageSource: {
-        bucket: sourceBucketName,
-        object: sourceBlobName,
-      },
+  const request = {
+    parent: `projects/${projectId}/locations/${location}`,
+    storageSource: {
+      bucket: sourceBucketName,
+      object: sourceBlobName,
     },
-    steps: buildSteps,
-    images: [targetImageUrl],
+    imageUri: targetImageUrl,
+    client: 'cloud-run-mcp',
   };
+  if (hasDockerfile) {
+    request.dockerBuild = {};
+  } else {
+    request.buildpackBuild = {};
+  }
 
   await logAndProgress(
     `Initiating Cloud Build for gs://${sourceBucketName}/${sourceBlobName} in ${location}...`,
     progressCallback
   );
-  const [operation] = await callWithRetry(
-    () =>
-      context.cloudBuildClient.createBuild({
-        projectId: projectId,
-        build: build,
-      }),
-    'cloudBuild.createBuild'
-  );
 
+  const [submitBuildResponse] = await callWithRetry(
+    () => buildsClient.submitBuild(request),
+    'builds.submitBuild'
+  );
   await logAndProgress(`Cloud Build job started...`, progressCallback);
-  const buildId = operation.metadata.build.id;
+  const encodedBuildId = submitBuildResponse.buildOperation.name
+    .split('/')
+    .pop();
+  const buildId = Buffer.from(encodedBuildId, 'base64').toString('ascii');
   let completedBuild;
   while (true) {
     const [getBuildOperation] = await callWithRetry(
       () =>
-        context.cloudBuildClient.getBuild({
-          projectId: projectId,
-          id: buildId,
+        cloudBuildClient.getBuild({
+          name: `projects/${projectId}/locations/${location}/builds/${buildId}`,
         }),
       `cloudBuild.getBuild ${buildId}`
     );
@@ -132,10 +182,9 @@ export async function triggerCloudBuild(
       `Cloud Build job ${buildId} completed successfully.`,
       progressCallback
     );
-    await logAndProgress(
-      `Image built: ${completedBuild.results.images[0].name}`,
-      progressCallback
-    );
+    const builtImage = completedBuild.results.images[0].name;
+    await logAndProgress(`Image built: ${builtImage}`, progressCallback);
+
     return completedBuild;
   } else {
     const failureMessage = `Cloud Build job ${buildId} failed with status: ${completedBuild.status}`;
@@ -160,7 +209,7 @@ export async function triggerCloudBuild(
       // Fetch the most recent N log entries
       const [entries] = await callWithRetry(
         () =>
-          context.loggingClient.getEntries({
+          loggingClient.getEntries({
             filter: logFilter,
             orderBy: 'timestamp desc', // Get latest logs first
             pageSize: BUILD_LOGS_LINES_TO_FETCH,