Revert changes to dataconnect appFinder utils and manual project entry

Author: schnecle

src/bin/mcp.ts

@@ -12,7 +12,6 @@ import { resolve } from "path";
 const STARTUP_MESSAGE = `
 This is a running process of the Firebase MCP server. This command should only be executed by an MCP client. An example MCP client configuration might be:
 
-An example MCP client configuration for apps using Firebase Build tools might be:
 {
   "mcpServers": {
     "firebase": {
@@ -28,7 +27,6 @@ export async function mcp(): Promise<void> {
     options: {
       only: { type: "string", default: "" },
       dir: { type: "string" },
-      project: { type: "string" },
       "generate-tool-list": { type: "boolean", default: false },
       "generate-prompt-list": { type: "boolean", default: false },
       "generate-resource-list": { type: "boolean", default: false },
@@ -56,11 +54,9 @@ export async function mcp(): Promise<void> {
   const activeFeatures = (values.only || "")
     .split(",")
     .filter((f) => SERVER_FEATURES.includes(f as ServerFeature)) as ServerFeature[];
-
   const server = new FirebaseMcpServer({
     activeFeatures,
     projectRoot: values.dir ? resolve(values.dir) : undefined,
-    projectId: values["project"],
   });
   await server.start();
   if (process.stdin.isTTY) process.stderr.write(STARTUP_MESSAGE);

src/dataconnect/appFinder.spec.ts

@@ -105,7 +105,7 @@ describe("detectApps", () => {
     fs.outputFileSync(`${testDir}/web/package.json`, "{}");
     fs.mkdirpSync(`${testDir}/android/src/main`);
     const apps = await detectApps(testDir);
-    expect(apps).to.have.deep.members([
+    expect(apps).to.deep.equal([
       {
         platform: Platform.WEB,
         directory: `web`,
@@ -172,6 +172,8 @@ describe("detectApps", () => {
         frameworks: [],
       },
     ];
-    expect(apps).to.have.deep.members(expected);
+    expect(apps.sort((a, b) => a.directory.localeCompare(b.directory))).to.deep.equal(
+      expected.sort((a, b) => a.directory.localeCompare(b.directory)),
+    );
   });
 });

src/dataconnect/appFinder.ts

@@ -1,12 +1,8 @@
+import * as fs from "fs-extra";
 import * as path from "path";
+import { glob } from "glob";
 import { Framework, Platform } from "./types";
-import {
-  detectApps as appUtilsDetectApps,
-  getPlatformsFromFolder,
-  Platform as AppUtilsPlatform,
-  Framework as AppUtilsFramework,
-  App as AppUtilsApp,
-} from "../appUtils";
+import { PackageJSON } from "../frameworks/compose/discover/runtime/node";
 
 export interface App {
   platform: Platform;
@@ -21,61 +17,96 @@ export function appDescription(a: App): string {
 
 /** Given a directory, determine the platform type */
 export async function getPlatformFromFolder(dirPath: string): Promise<Platform> {
-  const platforms = await getPlatformsFromFolder(dirPath);
-
-  if (platforms.length === 0) {
+  const apps = await detectApps(dirPath);
+  const hasWeb = apps.some((app) => app.platform === Platform.WEB);
+  const hasAndroid = apps.some((app) => app.platform === Platform.ANDROID);
+  const hasIOS = apps.some((app) => app.platform === Platform.IOS);
+  const hasDart = apps.some((app) => app.platform === Platform.FLUTTER);
+  if (!hasWeb && !hasAndroid && !hasIOS && !hasDart) {
     return Platform.NONE;
+  } else if (hasWeb && !hasAndroid && !hasIOS && !hasDart) {
+    return Platform.WEB;
+  } else if (hasAndroid && !hasWeb && !hasIOS && !hasDart) {
+    return Platform.ANDROID;
+  } else if (hasIOS && !hasWeb && !hasAndroid && !hasDart) {
+    return Platform.IOS;
+  } else if (hasDart && !hasWeb && !hasIOS && !hasAndroid) {
+    return Platform.FLUTTER;
   }
-
-  // Its not clear which platform the app directory is
+  // At this point, its not clear which platform the app directory is
   // because we found indicators for multiple platforms.
-  if (platforms.length > 1) {
-    return Platform.MULTIPLE;
-  }
-
-  return toDataConnectPlatform(platforms[0]);
+  return Platform.MULTIPLE;
 }
 
 /** Detects the apps in a given directory */
 export async function detectApps(dirPath: string): Promise<App[]> {
-  return appUtilsDetectApps(dirPath).then((apps) => apps.map(toDataConnectApp));
+  const packageJsonFiles = await detectFiles(dirPath, "package.json");
+  const pubSpecYamlFiles = await detectFiles(dirPath, "pubspec.yaml");
+  const srcMainFolders = await detectFiles(dirPath, "src/main/");
+  const xCodeProjects = await detectFiles(dirPath, "*.xcodeproj/");
+  const webApps = await Promise.all(packageJsonFiles.map((p) => packageJsonToWebApp(dirPath, p)));
+  const flutterApps = pubSpecYamlFiles.map((f) => ({
+    platform: Platform.FLUTTER,
+    directory: path.dirname(f),
+  }));
+  const androidApps = srcMainFolders
+    .map((f) => ({
+      platform: Platform.ANDROID,
+      directory: path.dirname(path.dirname(f)),
+    }))
+    .filter((a) => !flutterApps.some((f) => isPathInside(f.directory, a.directory)));
+  const iosApps = xCodeProjects
+    .map((f) => ({
+      platform: Platform.IOS,
+      directory: path.dirname(f),
+    }))
+    .filter((a) => !flutterApps.some((f) => isPathInside(f.directory, a.directory)));
+  return [...webApps, ...flutterApps, ...androidApps, ...iosApps];
 }
 
 export function isPathInside(parent: string, child: string): boolean {
   const relativePath = path.relative(parent, child);
   return !relativePath.startsWith(`..`);
 }
 
-function toDataConnectPlatform(platform: AppUtilsPlatform): Platform {
-  switch (platform) {
-    case AppUtilsPlatform.IOS:
-      return Platform.IOS;
-    case AppUtilsPlatform.ANDROID:
-      return Platform.ANDROID;
-    case AppUtilsPlatform.FLUTTER:
-      return Platform.FLUTTER;
-    case AppUtilsPlatform.WEB:
-      return Platform.WEB;
-  }
+async function packageJsonToWebApp(dirPath: string, packageJsonFile: string): Promise<App> {
+  const fullPath = path.join(dirPath, packageJsonFile);
+  const packageJson = JSON.parse((await fs.readFile(fullPath)).toString());
+  return {
+    platform: Platform.WEB,
+    directory: path.dirname(packageJsonFile),
+    frameworks: getFrameworksFromPackageJson(packageJson),
+  };
 }
 
-function toDataConnectFramework(framework: AppUtilsFramework): Framework {
-  switch (framework) {
-    case AppUtilsFramework.ANGULAR:
-      return "angular";
-    case AppUtilsFramework.REACT:
-      return "react";
-  }
+export const WEB_FRAMEWORKS: Framework[] = ["react", "angular"];
+export const WEB_FRAMEWORKS_SIGNALS: { [key in Framework]: string[] } = {
+  react: ["react", "next"],
+  angular: ["@angular/core"],
+};
+
+export function getFrameworksFromPackageJson(packageJson: PackageJSON): Framework[] {
+  const devDependencies = Object.keys(packageJson.devDependencies ?? {});
+  const dependencies = Object.keys(packageJson.dependencies ?? {});
+  const allDeps = Array.from(new Set([...devDependencies, ...dependencies]));
+  return WEB_FRAMEWORKS.filter((framework) =>
+    WEB_FRAMEWORKS_SIGNALS[framework]!.find((dep) => allDeps.includes(dep)),
+  );
 }
 
-function toDataConnectApp(app: AppUtilsApp): App {
-  const output: App = {
-    platform: toDataConnectPlatform(app.platform),
-    directory: app.directory,
+async function detectFiles(dirPath: string, filePattern: string): Promise<string[]> {
+  const options = {
+    cwd: dirPath,
+    ignore: [
+      "**/dataconnect*/**",
+      "**/node_modules/**", // Standard dependency directory
+      "**/dist/**", // Common build output
+      "**/build/**", // Common build output
+      "**/out/**", // Another common build output
+      "**/.next/**", // Next.js build directory
+      "**/coverage/**", // Test coverage reports
+    ],
+    absolute: false,
   };
-
-  if (app.frameworks) {
-    output.frameworks = app.frameworks.map((framework) => toDataConnectFramework(framework));
-  }
-  return output;
+  return glob(`**/${filePattern}`, options);
 }

src/mcp/index.ts

@@ -66,7 +66,6 @@ export class FirebaseMcpServer {
   private _readyPromises: { resolve: () => void; reject: (err: unknown) => void }[] = [];
   startupRoot?: string;
   cachedProjectDir?: string;
-  cachedProjectId?: string;
   server: Server;
   activeFeatures?: ServerFeature[];
   detectedFeatures?: ServerFeature[];
@@ -103,11 +102,7 @@ export class FirebaseMcpServer {
     return trackGA4(event, { ...params, ...clientInfoParams });
   }
 
-  constructor(options: {
-    activeFeatures?: ServerFeature[];
-    projectRoot?: string;
-    projectId?: string;
-  }) {
+  constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
     this.activeFeatures = options.activeFeatures;
     this.startupRoot = options.projectRoot || process.env.PROJECT_ROOT;
     this.server = new Server({ name: "firebase", version: SERVER_VERSION });
@@ -151,7 +146,6 @@ export class FirebaseMcpServer {
       return {};
     });
 
-    this.cachedProjectId = options.projectId;
     this.detectProjectRoot();
     this.detectActiveFeatures();
   }
@@ -271,11 +265,7 @@ export class FirebaseMcpServer {
   }
 
   async resolveOptions(): Promise<Partial<Options>> {
-    const options: Partial<Options> = {
-      cwd: this.cachedProjectDir,
-      isMCP: true,
-      projectId: this.cachedProjectId,
-    };
+    const options: Partial<Options> = { cwd: this.cachedProjectDir, isMCP: true };
     await cmd.prepare(options);
     return options;
   }