initial apphosting mcp tool

src/gcp/apphosting.ts

@@ -266,7 +266,7 @@
   done: boolean;
   // oneof result
   error?: Status;
   response?: any;
   // end oneof result
 }
 
@@ -333,6 +333,19 @@
   return res.body;
 }
 
+/**
+ * Gets traffic details.
+ */
+export async function getTraffic(
+  projectId: string,
+  location: string,
+  backendId: string,
+): Promise<Traffic> {
+  const name = `projects/${projectId}/locations/${location}/backends/${backendId}/traffic`;
+  const res = await client.get<Traffic>(name);
+  return res.body;
+}
+
 /**
  * List all backends present in a project and location.
  */
@@ -548,14 +561,14 @@
 /**
  * Ensure that the App Hosting API is enabled on the project.
  */
 export async function ensureApiEnabled(options: any): Promise<void> {
   const projectId = needProjectId(options);
   return await ensure(projectId, apphostingOrigin(), "app hosting", true);
 }
 
 /**
  * Generates the next build ID to fit with the naming scheme of the backend API.
  * @param counter Overrides the counter to use, avoiding an API call.
  */
 export async function getNextRolloutId(
   projectId: string,

src/gcp/run.ts

@@ -1,6 +1,6 @@
 import { Client } from "../apiv2";
 import { FirebaseError } from "../error";
-import { runOrigin } from "../api";
+import { cloudloggingOrigin, runOrigin } from "../api";
 import * as proto from "./proto";
 import * as iam from "./iam";
 import { backoff } from "../throttler/throttler";
@@ -150,10 +150,10 @@
   try {
     const response = await client.get<Service>(name);
     return response.body;
   } catch (err: any) {
     throw new FirebaseError(`Failed to fetch Run service ${name}`, {
       original: err,
       status: err?.context?.response?.statusCode,
     });
   }
 }
@@ -163,7 +163,7 @@
  */
 export async function updateService(name: string, service: Service): Promise<Service> {
   delete service.status;
   service = await exports.replaceService(name, service);
 
   // Now we need to wait for reconciliation or we might delete the docker
   // image while the service is still rolling out a new revision.
@@ -344,3 +344,72 @@
   };
   await setIamPolicy(serviceName, policy, httpClient);
 }
+
+interface EntriesListRequest {
+  resourceNames: string[];
+  filter?: string;
+  orderBy?: string;
+  pageSize?: number;
+  pageToken?: string;
+}
+
+interface EntriesListResponse {
+  entries?: LogEntry[];
+  nextPageToken?: string;
+}
+
+interface LogEntry {
+  logName: string;
+  resource: unknown;
+  timestamp: string;
+  receiveTimestamp: string;
+  httpRequest?: unknown;
+
+  protoPayload?: unknown;
+  textPayload?: string;
+  jsonPayload?: unknown;
+
+  severity:
+    | "DEFAULT"
+    | "DEBUG"
+    | "INFO"
+    | "NOTICE"
+    | "WARNING"
+    | "ERROR"
+    | "CRITICAL"
+    | "ALERT"
+    | "EMERGENCY";
+}
+
+/**
+ * Fetches recent logs for a given Cloud Run service using the Cloud Logging API.
+ * @param projectId The Google Cloud project ID.
+ * @param serviceId The resource name of the Cloud Run service.
+ * @return A promise that resolves with the log entries.
+ */
+export async function fetchServiceLogs(projectId: string, serviceId: string): Promise<LogEntry[]> {
+  const loggingClient = new Client({
+    urlPrefix: cloudloggingOrigin(),
+    apiVersion: "v2",
+  });
+
+  const requestBody: EntriesListRequest = {
+    resourceNames: [`projects/${projectId}`],
+    filter: `resource.type="cloud_run_revision" AND resource.labels.service_name="${serviceId}"`,
+    orderBy: "timestamp desc",
+    pageSize: 100,
+  };
+
+  try {
+    const response = await loggingClient.post<EntriesListRequest, EntriesListResponse>(
+      "/entries:list",
+      requestBody,
+    );
+    return response.body.entries || [];
+  } catch (err: any) {
+    throw new FirebaseError(`Failed to fetch logs for Cloud Run service ${serviceId}`, {
+      original: err,
+      status: err?.context?.response?.statusCode,
+    });
+  }
+}

src/mcp/tools/apphosting/index.ts

@@ -0,0 +1,4 @@
+import { ServerTool } from "../../tool";
+import { list_backends } from "./list_backends";
+
+export const appHostingTools: ServerTool[] = [list_backends];

src/mcp/tools/apphosting/list_backends.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { NO_PROJECT_ERROR } from "../../errors.js";
+import {
+  Backend,
+  getTraffic,
+  listBackends,
+  parseBackendName,
+  Traffic,
+} from "../../../gcp/apphosting.js";
+
+export const list_backends = tool(
+  {
+    name: "list_backends",
+    description:
+      "Retrieves a list of App Hosting backends in the current project. An empty list means that there are no backends. " +
+      "The `uri` is the public URL of the backend. " +
+      "A working backend will have a `managed_resources` array that will contain a `run_service` entry. That `run_service.service` " +
+      "is the resource name of the Cloud Run service serving the App Hosting backend. The last segment of that name is the service ID.",
+    inputSchema: z.object({
+      location: z
+        .string()
+        .optional()
+        .default("-")
+        .describe(
+          "Limit the listed backends to this region. By default, it will list all backends across all regions.",
+        ),
+    }),
+    annotations: {
+      title: "List App Hosting backends.",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ location } = {}, { projectId }) => {
+    if (!projectId) return NO_PROJECT_ERROR;
+    if (!location) location = "-";
+    const data: (Backend & { traffic: Traffic })[] = [];
+    const backends = await listBackends(projectId, location);
+    for (const backend of backends.backends) {
+      const { location, id } = parseBackendName(backend.name);
+      const traffic = await getTraffic(projectId, location, id);
+      data.push({ ...backend, traffic: traffic });
+    }
+    return toContent(data);
+  },
+);

src/mcp/tools/index.ts

@@ -8,6 +8,8 @@ import { storageTools } from "./storage/index.js";
 import { messagingTools } from "./messaging/index.js";
 import { remoteConfigTools } from "./remoteconfig/index.js";
 import { crashlyticsTools } from "./crashlytics/index.js";
+import { appHostingTools } from "./apphosting/index.js";
+import { runTools } from "./run/index.js";
 
 /** availableTools returns the list of MCP tools available given the server flags */
 export function availableTools(activeFeatures?: ServerFeature[]): ServerTool[] {
@@ -30,6 +32,8 @@ const tools: Record<ServerFeature, ServerTool[]> = {
   messaging: addFeaturePrefix("messaging", messagingTools),
   remoteconfig: addFeaturePrefix("remoteconfig", remoteConfigTools),
   crashlytics: addFeaturePrefix("crashlytics", crashlyticsTools),
+  apphosting: addFeaturePrefix("apphosting", appHostingTools),
+  run: addFeaturePrefix("run", runTools),
 };
 
 function addFeaturePrefix(feature: string, tools: ServerTool[]): ServerTool[] {

src/mcp/tools/run/fetch_logs.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { NO_PROJECT_ERROR } from "../../errors.js";
+import { fetchServiceLogs } from "../../../gcp/run.js";
+
+export const fetch_logs = tool(
+  {
+    name: "fetch_logs",
+    description:
+      "Fetches recent logs for a Cloud Run service. Includes details such as the message, severity, and timestamp.",
+    inputSchema: z.object({
+      serviceId: z.string().describe("The Cloud Run service ID."),
+    }),
+    annotations: {
+      title: "Fetch recent Cloud Run service logs.",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ serviceId } = {}, { projectId }) => {
+    if (!projectId) return NO_PROJECT_ERROR;
+    if (!serviceId) return toContent("A Cloud Run service ID must be provided.");
+    const data = await fetchServiceLogs(projectId, serviceId);
+    return toContent(data);
+  },
+);

src/mcp/tools/run/index.ts

@@ -0,0 +1,4 @@
+import { ServerTool } from "../../tool";
+import { fetch_logs } from "./fetch_logs";
+
+export const runTools: ServerTool[] = [fetch_logs];

src/mcp/types.ts

@@ -6,6 +6,8 @@ export const SERVER_FEATURES = [
   "messaging",
   "remoteconfig",
   "crashlytics",
+  "apphosting",
+  "run",
 ] as const;
 export type ServerFeature = (typeof SERVER_FEATURES)[number];
 

src/mcp/util.ts

@@ -4,13 +4,15 @@ import { dump } from "js-yaml";
 import { platform } from "os";
 import { ServerFeature } from "./types";
 import {
+  apphostingOrigin,
   authManagementOrigin,
   dataconnectOrigin,
   firestoreOrigin,
   messagingApiOrigin,
   remoteConfigApiOrigin,
   storageOrigin,
   crashlyticsApiOrigin,
+  cloudRunApiOrigin,
 } from "../api";
 import { check } from "../ensureApiEnabled";
 
@@ -87,6 +89,8 @@ const SERVER_FEATURE_APIS: Record<ServerFeature, string> = {
   messaging: messagingApiOrigin(),
   remoteconfig: remoteConfigApiOrigin(),
   crashlytics: crashlyticsApiOrigin(),
+  apphosting: apphostingOrigin(),
+  run: cloudRunApiOrigin(),
 };
 
 /**