Add common appUtils to augment get_environment with app level data

Author: schnecle

src/appUtils.spec.ts

@@ -0,0 +1,337 @@
+import * as fs from "fs-extra";
+import * as path from "path";
+import { glob } from "glob";
+import { PackageJSON } from "./frameworks/compose/discover/runtime/node";
+
+/**
+ * Supported application platforms.
+ */
+export enum Platform {
+  NONE = "NONE",
+  ANDROID = "ANDROID",
+  WEB = "WEB",
+  IOS = "IOS",
+  FLUTTER = "FLUTTER",
+}
+
+/**
+ * Supported web frameworks.
+ */
+export enum Framework {
+  REACT = "REACT",
+  ANGULAR = "ANGULAR",
+}
+
+interface AppIdentifier {
+  appId: string;
+  bundleId?: string;
+}
+
+/**
+ * Represents a detected application.
+ */
+export interface App {
+  platform: Platform;
+  directory: string;
+  appId?: string;
+  bundleId?: string;
+  frameworks?: Framework[];
+}
+
+/** Returns a string description of the app */
+export function appDescription(a: App): string {
+  return `${a.directory} (${a.platform.toLowerCase()})`;
+}
+
+/**
+ * Given a directory, determine the platform type.
+ * @param dirPath The directory to scan.
+ * @return A list of platforms detected.
+ */
+export async function getPlatformsFromFolder(dirPath: string): Promise<Platform[]> {
+  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];
+  }
+
+  const platforms = [];
+  if (hasWeb) {
+    platforms.push(Platform.WEB);
+  }
+
+  if (hasAndroid) {
+    platforms.push(Platform.ANDROID);
+  }
+
+  if (hasIOS) {
+    platforms.push(Platform.IOS);
+  }
+
+  if (hasDart) {
+    platforms.push(Platform.FLUTTER);
+  }
+
+  return platforms;
+}
+
+/**
+ * Detects the apps in a given directory.
+ * @param dirPath The current working directory to scan.
+ * @return A list of apps detected.
+ */
+export async function detectApps(dirPath: string): Promise<App[]> {
+  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 flutterAppPromises = await Promise.all(
+    pubSpecYamlFiles.map((f) => processFlutterDir(dirPath, f)),
+  );
+  const flutterApps = flutterAppPromises.flat();
+
+  const androidAppPromises = await Promise.all(
+    srcMainFolders.map((f) => processAndroidDir(dirPath, f)),
+  );
+  const androidApps = androidAppPromises
+    .flat()
+    .filter((a) => !flutterApps.some((f) => isPathInside(f.directory, a.directory)));
+
+  const iosAppPromises = await Promise.all(xCodeProjects.map((f) => processIosDir(dirPath, f)));
+  const iosApps = iosAppPromises
+    .flat()
+    .filter((a) => !flutterApps.some((f) => isPathInside(f.directory, a.directory)));
+  return [...webApps, ...flutterApps, ...androidApps, ...iosApps];
+}
+
+async function processIosDir(dirPath: string, filePath: string) {
+  // Search for apps in the parent directory
+  const iosDir = path.dirname(filePath);
+  const iosAppIds = await detectAppIdsForPlatform(dirPath, Platform.IOS);
+  if (iosAppIds.length === 0) {
+    return [
+      {
+        platform: Platform.IOS,
+        directory: iosDir,
+      },
+    ];
+  }
+  const iosApps = await Promise.all(
+    iosAppIds.map((app) => ({
+      platform: Platform.IOS,
+      directory: iosDir,
+      appId: app.appId,
+      bundleId: app.bundleId,
+    })),
+  );
+  return iosApps.flat();
+}
+
+async function processAndroidDir(dirPath: string, filePath: string) {
+  // Search for apps in the parent directory, not in the src/main directory
+  const androidDir = path.dirname(path.dirname(filePath));
+  const androidAppIds = await detectAppIdsForPlatform(dirPath, Platform.ANDROID);
+
+  if (androidAppIds.length === 0) {
+    return [
+      {
+        platform: Platform.ANDROID,
+        directory: androidDir,
+      },
+    ];
+  }
+
+  const androidApps = await Promise.all(
+    androidAppIds.map((app) => ({
+      platform: Platform.ANDROID,
+      directory: androidDir,
+      appId: app.appId,
+      bundleId: app.bundleId,
+    })),
+  );
+  return androidApps.flat();
+}
+
+async function processFlutterDir(dirPath: string, filePath: string) {
+  const flutterDir = path.dirname(filePath);
+  const flutterAppIds = await detectAppIdsForPlatform(dirPath, Platform.FLUTTER);
+
+  if (flutterAppIds.length === 0) {
+    return [
+      {
+        platform: Platform.FLUTTER,
+        directory: flutterDir,
+      },
+    ];
+  }
+
+  const flutterApps = await Promise.all(
+    flutterAppIds.map((app) => {
+      const flutterApp: App = {
+        platform: Platform.FLUTTER,
+        directory: flutterDir,
+        appId: app.appId,
+        bundleId: app.bundleId,
+      };
+      return flutterApp;
+    }),
+  );
+
+  return flutterApps.flat();
+}
+
+function isPathInside(parent: string, child: string): boolean {
+  const relativePath = path.relative(parent, child);
+  return !relativePath.startsWith(`..`);
+}
+
+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),
+  };
+}
+
+const WEB_FRAMEWORKS: Framework[] = Object.values(Framework);
+const WEB_FRAMEWORKS_SIGNALS: { [key in Framework]: string[] } = {
+  REACT: ["react", "next"],
+  ANGULAR: ["@angular/core"],
+};
+
+async function detectAppIdsForPlatform(
+  dirPath: string,
+  platform: Platform,
+): Promise<AppIdentifier[]> {
+  let appIdFiles;
+  let extractFunc: (fileContent: string) => AppIdentifier[];
+  switch (platform) {
+    case Platform.ANDROID:
+      appIdFiles = await detectFiles(dirPath, "google-services*.json*");
+      extractFunc = extractAppIdentifiersAndroid;
+      break;
+    case Platform.IOS:
+      appIdFiles = await detectFiles(dirPath, "GoogleService-*.plist*");
+      extractFunc = extractAppIdentifierIos;
+      break;
+    case Platform.FLUTTER:
+      appIdFiles = await detectFiles(dirPath, "firebase_options.dart");
+      extractFunc = extractAppIdentifiersFlutter;
+      break;
+    default:
+      return [];
+  }
+
+  const allAppIds = await Promise.all(
+    appIdFiles.map(async (file) => {
+      const fileContent = (await fs.readFile(path.join(dirPath, file))).toString();
+      return extractFunc(fileContent);
+    }),
+  );
+  return allAppIds.flat();
+}
+
+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)),
+  );
+}
+
+/**
+ * Reads a firebase_options.dart file and extracts all appIds and bundleIds.
+ * @param fileContent content of the dart file.
+ * @returns a list of appIds and bundleIds.
+ */
+export function extractAppIdentifiersFlutter(fileContent: string): AppIdentifier[] {
+  const optionsRegex = /FirebaseOptions\(([^)]*)\)/g;
+  const matches = fileContent.matchAll(optionsRegex);
+  const identifiers: AppIdentifier[] = [];
+  for (const match of matches) {
+    const optionsContent = match[1];
+    const appIdMatch = optionsContent.match(/appId: '([^']*)'/);
+    const bundleIdMatch = optionsContent.match(/iosBundleId: '([^']*)'/);
+    if (appIdMatch?.[1]) {
+      identifiers.push({
+        appId: appIdMatch[1],
+        bundleId: bundleIdMatch?.[1],
+      });
+    }
+  }
+
+  return identifiers;
+}
+
+/**
+ * Reads a GoogleService-Info.plist file and extracts the GOOGLE_APP_ID and BUNDLE_ID.
+ * @param fileContent content of the plist file.
+ * @returns The GOOGLE_APP_ID and BUNDLE_ID or an empty array.
+ */
+export function extractAppIdentifierIos(fileContent: string): AppIdentifier[] {
+  const appIdRegex = /<key>GOOGLE_APP_ID<\/key>\s*<string>([^<]*)<\/string>/;
+  const bundleIdRegex = /<key>BUNDLE_ID<\/key>\s*<string>([^<]*)<\/string>/;
+  const appIdMatch = fileContent.match(appIdRegex);
+  const bundleIdMatch = fileContent.match(bundleIdRegex);
+  if (appIdMatch?.[1]) {
+    return [
+      {
+        appId: appIdMatch[1],
+        bundleId: bundleIdMatch?.[1],
+      },
+    ];
+  }
+  return [];
+}
+
+/**
+ * Reads a google-services.json file and extracts all mobilesdk_app_id and package_name values.
+ * @param fileContent content of the google-services.json file.
+ * @returns a list of mobilesdk_app_id and package_name values.
+ */
+export function extractAppIdentifiersAndroid(fileContent: string): AppIdentifier[] {
+  const identifiers: AppIdentifier[] = [];
+  try {
+    const config = JSON.parse(fileContent);
+    if (config.client && Array.isArray(config.client)) {
+      for (const client of config.client) {
+        if (client.client_info?.mobilesdk_app_id) {
+          identifiers.push({
+            appId: client.client_info.mobilesdk_app_id,
+            bundleId: client.client_info.android_client_info?.package_name,
+          });
+        }
+      }
+    }
+  } catch (e) {
+    // Handle parsing errors if necessary
+    console.error("Error parsing google-services.json:", e);
+  }
+  return identifiers;
+}
+
+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,
+  };
+  return glob(`**/${filePattern}`, options);
+}

src/appUtils.ts

@@ -10,6 +10,7 @@ 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": {
@@ -26,6 +27,7 @@ export async function mcp(): Promise<void> {
       only: { type: "string", default: "" },
       dir: { type: "string" },
       "generate-tool-list": { type: "boolean", default: false },
+      project: { type: "string" },
     },
     allowPositionals: true,
   });
@@ -38,9 +40,11 @@ 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/bin/mcp.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.deep.equal([
+    expect(apps).to.have.deep.members([
       {
         platform: Platform.WEB,
         directory: `web`,
@@ -172,8 +172,6 @@ describe("detectApps", () => {
         frameworks: [],
       },
     ];
-    expect(apps.sort((a, b) => a.directory.localeCompare(b.directory))).to.deep.equal(
-      expected.sort((a, b) => a.directory.localeCompare(b.directory)),
-    );
+    expect(apps).to.have.deep.members(expected);
   });
 });