[FDC MCP] Merge multiple tools into dataconnect_info (#9056)

* Deleted the old files: `list_services.ts`, `get_schema.ts`, and `get_connector.ts`.

* feat(dataconnect): merge list, get schema, and get connector tools

Merges the `dataconnect_list_services`, `dataconnect_get_connector`, and `dataconnect_get_schema` tools into a single `dataconnect_info` tool.

This new tool provides a comprehensive view of all Data Connect services, schemas, and connectors, indicating whether they exist locally, remotely, or both.

The output is formatted to prioritize information from the local workspace.

* save

* save

* done

* instructions

* instructions

* rename

* changelog

* add

* m

* renmae back to info

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-authored-by: Joe Hanley <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -3,3 +3,4 @@
 - Fixed the bugs when MCP tools cannot connect to emulator due to CLI version mis-matched. (#9068)
 - Fixed a bug where `firebase dataconnect:sdk:generate --watch` swallowed all logs. (#9055)
 - Added GA4 agent user property to tag CLI usage by coding agents. (#9070)
+- Consolidated Data Connect MCP tools into `dataconnect_info` tool to surface information of local workspace and backend resources. (#9056)

src/dataconnect/client.ts

@@ -100,7 +100,7 @@ export async function getSchema(serviceName: string): Promise<types.Schema | und
 export async function listSchemas(
   serviceName: string,
   fields: string[] = [],
-): Promise<types.Schema[] | undefined> {
+): Promise<types.Schema[]> {
   const schemas: types.Schema[] = [];
   const getNextPage = async (pageToken = "") => {
     const res = await dataconnectClient().get<{

src/mcp/tools/dataconnect/get_connector.ts

@@ -1,18 +1,14 @@
 import type { ServerTool } from "../../tool";
 import { generate_operation } from "./generate_operation";
 import { generate_schema } from "./generate_schema";
-import { list_services } from "./list_services";
-import { get_schema } from "./get_schema";
-import { get_connectors } from "./get_connector";
+import { info } from "./info";
 import { compile } from "./compile";
 import { execute } from "./execute";
 
 export const dataconnectTools: ServerTool[] = [
   compile,
-  list_services,
   generate_schema,
   generate_operation,
-  get_schema,
-  get_connectors,
+  info,
   execute,
 ];

src/mcp/tools/dataconnect/get_schema.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import * as path from "path";
+import { tool } from "../../tool";
+import { toContent } from "../../util";
+import * as client from "../../../dataconnect/client";
+import { loadAll } from "../../../dataconnect/load";
+import { Service, Schema, ServiceInfo, Connector } from "../../../dataconnect/types";
+import { dump } from "js-yaml";
+import { logger } from "../../../logger";
+
+interface CombinedServiceInfo {
+  local?: ServiceInfo;
+  deployed?: DeployServiceInfo;
+}
+
+interface DeployServiceInfo {
+  service?: Service;
+  schemas?: Schema[];
+  connectors?: Connector[];
+}
+
+export const info = tool(
+  {
+    name: "info",
+    description: "Get information about the Firebase Data Connect local and deployed resources.",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Get information about Firebase Data Connect",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresProject: false,
+      requiresAuth: false,
+    },
+  },
+  async (_, { projectId, config }) => {
+    const localServiceInfos = await loadAll(projectId, config);
+    const serviceInfos = new Map<string, CombinedServiceInfo>();
+
+    for (const l of localServiceInfos) {
+      serviceInfos.set(
+        `locations/${l.dataConnectYaml.location}/services/${l.dataConnectYaml.serviceId}`,
+        { local: l },
+      );
+    }
+
+    if (projectId) {
+      try {
+        const [services, schemas, connectors] = await Promise.all([
+          client.listAllServices(projectId),
+          client.listSchemas(`projects/${projectId}/locations/-/services/-`),
+          client.listConnectors(`projects/${projectId}/locations/-/services/-`),
+        ]);
+        console.log(services, schemas, connectors);
+        for (const s of services) {
+          const k = s.name.split("/").slice(2, 6).join("/");
+          const st = serviceInfos.get(k) || {};
+          st.deployed = st.deployed || {};
+          st.deployed.service = s;
+          serviceInfos.set(k, st);
+        }
+        for (const s of schemas) {
+          const k = s.name.split("/").slice(2, 6).join("/");
+          const st = serviceInfos.get(k) || {};
+          st.deployed = st.deployed || {};
+          st.deployed.schemas = st.deployed.schemas || [];
+          st.deployed.schemas.push(s);
+          serviceInfos.set(k, st);
+        }
+        for (const s of connectors) {
+          const k = s.name.split("/").slice(2, 6).join("/");
+          const st = serviceInfos.get(k) || {};
+          st.deployed = st.deployed || {};
+          st.deployed.connectors = st.deployed.connectors || [];
+          st.deployed.connectors.push(s);
+          serviceInfos.set(k, st);
+        }
+      } catch (e: any) {
+        logger.debug("cannot fetch dataconnect resources in the backend", e);
+      }
+    }
+
+    const localServices = Array.from(serviceInfos.values()).filter((s) => s.local);
+    const remoteOnlyServices = Array.from(serviceInfos.values()).filter((s) => !s.local);
+
+    const output: string[] = [];
+
+    function includeDeployedServiceInfo(deployed: DeployServiceInfo): void {
+      if (deployed.schemas?.length) {
+        output.push(`### Schemas`);
+        for (const s of deployed.schemas) {
+          clearCCFEFields(s);
+          output.push(dump(s));
+        }
+      }
+      if (deployed.connectors?.length) {
+        output.push(`### Connectors`);
+        for (const c of deployed.connectors) {
+          clearCCFEFields(c);
+          output.push(dump(c));
+        }
+      }
+    }
+
+    if (localServices.length) {
+      output.push(`# Local Data Connect Sources`);
+      for (const s of localServices) {
+        const local = s.local!;
+        output.push(dump(local.dataConnectYaml));
+        const schemaDir = path.join(local.sourceDirectory, local.dataConnectYaml.schema.source);
+        output.push(`You can find all of schema sources under ${schemaDir}/`);
+        if (s.deployed) {
+          output.push(`It's already deployed in the backend:\n`);
+          includeDeployedServiceInfo(s.deployed);
+        }
+      }
+    }
+
+    if (remoteOnlyServices.length) {
+      output.push(`# Data Connect Services in project ${projectId}`);
+      for (const s of remoteOnlyServices) {
+        if (s.deployed) {
+          includeDeployedServiceInfo(s.deployed);
+        }
+      }
+    }
+
+    output.push(`\n# What's next?`);
+    if (!localServices.length) {
+      output.push(
+        `- There is no local Data Connect service in the local workspace. Consider use the \`firebase_init\` MCP tool to setup one.`,
+      );
+    }
+    output.push(
+      `- You can use the \`dataconnect_compile\` tool to compile all local Data Connect schemas and query sources.`,
+    );
+    output.push(
+      `- You run \`firebase deploy\` in command line to deploy the Data Connect schemas, connector and perform SQL migrations.`,
+    );
+    return toContent(output.join("\n"));
+  },
+);
+
+function clearCCFEFields(r: any): void {
+  const fieldsToClear = ["updateTime", "uid", "etag"];
+  for (const k of fieldsToClear) {
+    delete r[k];
+  }
+}