fix: use app display name instead of project display name in AI Logic provisioning

src/init/features/ailogic/index.spec.ts

@@ -51,6 +51,7 @@ describe("init ailogic", () => {
       expect(mockSetup.featureInfo).to.have.property("ailogic");
       expect(mockSetup.featureInfo?.ailogic).to.deep.equal({
         appId: "1:123456789:android:abcdef123456",
+        displayName: "Test Android App",
       });
     });
 

src/init/features/ailogic/index.ts

@@ -11,6 +11,7 @@ import {
 
 export interface AiLogicInfo {
   appId: string;
+  displayName?: string;
 }
 
 function checkForApps(apps: AppMetadata[]): void {
@@ -69,25 +70,29 @@ export async function askQuestions(setup: Setup): Promise<void> {
 
   setup.featureInfo.ailogic = {
     appId: selectedApp.appId,
+    displayName: selectedApp.displayName,
   };
 }
 
-function getAppOptions(appInfo: AppInfo): ProvisionAppOptions {
+function getAppOptions(appInfo: AppInfo, displayName?: string): ProvisionAppOptions {
   switch (appInfo.platform) {
     case AppPlatform.IOS:
       return {
         platform: AppPlatform.IOS,
         appId: appInfo.appId,
+        displayName,
       };
     case AppPlatform.ANDROID:
       return {
         platform: AppPlatform.ANDROID,
         appId: appInfo.appId,
+        displayName,
       };
     case AppPlatform.WEB:
       return {
         platform: AppPlatform.WEB,
         appId: appInfo.appId,
+        displayName,
       };
     default:
       throw new FirebaseError(`Unsupported platform ${appInfo.platform}`, { exit: 1 });
@@ -115,10 +120,9 @@ export async function actuate(setup: Setup): Promise<void> {
     // Build provision options and call API directly
     const provisionOptions: ProvisionFirebaseAppOptions = {
       project: {
-        displayName: "Firebase Project",
         parent: { type: "existing_project", projectId: setup.projectId },
       },
-      app: getAppOptions(appInfo),
+      app: getAppOptions(appInfo, ailogicInfo.displayName),
       features: {
         firebaseAiLogicInput: {},
       },

src/init/features/ailogic/utils.spec.ts

@@ -139,10 +139,10 @@ describe("ailogic utils", () => {
   });
 
   describe("validateAppExists", () => {
-    let getAppConfigStub: sinon.SinonStub;
+    let listFirebaseAppsStub: sinon.SinonStub;
 
     beforeEach(() => {
-      getAppConfigStub = sandbox.stub(apps, "getAppConfig");
+      listFirebaseAppsStub = sandbox.stub(apps, "listFirebaseApps");
     });
 
     it("should not throw when app exists for web platform", async () => {
@@ -151,10 +151,14 @@ describe("ailogic utils", () => {
         appId: "1:123456789:web:abcdef",
         platform: AppPlatform.WEB,
       };
-      getAppConfigStub.resolves({ mockConfig: true });
+      const mockApps = [
+        { appId: "1:123456789:web:abcdef", displayName: "Test App", platform: AppPlatform.WEB },
+      ];
+      listFirebaseAppsStub.resolves(mockApps);
 
-      await expect(utils.validateAppExists(appInfo)).to.not.be.rejected;
-      sinon.assert.calledWith(getAppConfigStub, "1:123456789:web:abcdef", AppPlatform.WEB);
+      const result = await utils.validateAppExists(appInfo, "test-project");
+      expect(result).to.deep.equal(mockApps[0]);
+      sinon.assert.calledWith(listFirebaseAppsStub, "test-project", AppPlatform.WEB);
     });
 
     it("should not throw when app exists for ios platform", async () => {
@@ -163,10 +167,14 @@ describe("ailogic utils", () => {
         appId: "1:123456789:ios:abcdef",
         platform: AppPlatform.IOS,
       };
-      getAppConfigStub.resolves({ mockConfig: true });
+      const mockApps = [
+        { appId: "1:123456789:ios:abcdef", displayName: "Test iOS App", platform: AppPlatform.IOS },
+      ];
+      listFirebaseAppsStub.resolves(mockApps);
 
-      await expect(utils.validateAppExists(appInfo)).to.not.be.rejected;
-      sinon.assert.calledWith(getAppConfigStub, "1:123456789:ios:abcdef", AppPlatform.IOS);
+      const result = await utils.validateAppExists(appInfo, "test-project");
+      expect(result).to.deep.equal(mockApps[0]);
+      sinon.assert.calledWith(listFirebaseAppsStub, "test-project", AppPlatform.IOS);
     });
 
     it("should not throw when app exists for android platform", async () => {
@@ -175,10 +183,18 @@ describe("ailogic utils", () => {
         appId: "1:123456789:android:abcdef",
         platform: AppPlatform.ANDROID,
       };
-      getAppConfigStub.resolves({ mockConfig: true });
+      const mockApps = [
+        {
+          appId: "1:123456789:android:abcdef",
+          displayName: "Test Android App",
+          platform: AppPlatform.ANDROID,
+        },
+      ];
+      listFirebaseAppsStub.resolves(mockApps);
 
-      await expect(utils.validateAppExists(appInfo)).to.not.be.rejected;
-      sinon.assert.calledWith(getAppConfigStub, "1:123456789:android:abcdef", AppPlatform.ANDROID);
+      const result = await utils.validateAppExists(appInfo, "test-project");
+      expect(result).to.deep.equal(mockApps[0]);
+      sinon.assert.calledWith(listFirebaseAppsStub, "test-project", AppPlatform.ANDROID);
     });
 
     it("should throw when app does not exist", async () => {
@@ -187,11 +203,11 @@ describe("ailogic utils", () => {
         appId: "1:123456789:web:nonexistent",
         platform: AppPlatform.WEB,
       };
-      getAppConfigStub.throws(new Error("App not found"));
+      listFirebaseAppsStub.resolves([]);
 
-      await expect(utils.validateAppExists(appInfo)).to.be.rejectedWith(
+      await expect(utils.validateAppExists(appInfo, "test-project")).to.be.rejectedWith(
         FirebaseError,
-        "App 1:123456789:web:nonexistent does not exist or is not accessible.",
+        "App 1:123456789:web:nonexistent does not exist in project test-project.",
       );
     });
   });

src/init/features/ailogic/utils.ts

@@ -1,4 +1,4 @@
-import { AppPlatform, getAppConfig } from "../../../management/apps";
+import { AppPlatform, listFirebaseApps, AppMetadata } from "../../../management/apps";
 import { FirebaseError } from "../../../error";
 import { FirebaseProjectMetadata } from "../../../types/project";
 
@@ -81,10 +81,23 @@ export function validateProjectNumberMatch(
 /**
  * Validate that app exists
  */
-export async function validateAppExists(appInfo: AppInfo): Promise<void> {
+export async function validateAppExists(appInfo: AppInfo, projectId: string): Promise<AppMetadata> {
   try {
-    await getAppConfig(appInfo.appId, appInfo.platform);
+    // Get apps list to find the specific app with metadata
+    const apps = await listFirebaseApps(projectId, appInfo.platform);
+    const app = apps.find((a) => a.appId === appInfo.appId);
+
+    if (!app) {
+      throw new FirebaseError(`App ${appInfo.appId} does not exist in project ${projectId}.`, {
+        exit: 1,
+      });
+    }
+
+    return app;
   } catch (error) {
+    if (error instanceof FirebaseError) {
+      throw error;
+    }
     throw new FirebaseError(`App ${appInfo.appId} does not exist or is not accessible.`, {
       exit: 1,
       original: error instanceof Error ? error : new Error(String(error)),

src/management/provisioning/provision.ts

@@ -86,7 +86,7 @@ export function buildProvisionRequest(
 
   return {
     appNamespace: buildAppNamespace(options.app),
-    displayName: options.project.displayName,
+    displayName: options.app.displayName,
     ...(options.project.parent && { parent: buildParentString(options.project.parent) }),
     ...(options.features?.location && { location: options.features.location }),
     ...(options.requestId && { requestId: options.requestId }),

src/management/provisioning/types.ts

@@ -3,6 +3,7 @@ import { AppPlatform } from "../apps";
 interface BaseProvisionAppOptions {
   platform: AppPlatform;
   appId?: string;
+  displayName?: string;
 }
 
 interface IosAppOptions extends BaseProvisionAppOptions {

src/mcp/tools/core/init.ts

@@ -208,11 +208,12 @@ export const init = tool(
       const appInfo = parseAppId(features.ailogic.app_id);
       const projectInfo = await getFirebaseProject(projectId);
       validateProjectNumberMatch(appInfo, projectInfo);
-      await validateAppExists(appInfo);
+      const appData = await validateAppExists(appInfo, projectId);
 
       featuresList.push("ailogic");
       featureInfo.ailogic = {
         appId: features.ailogic.app_id,
+        displayName: appData.displayName,
       };
     }
     const setup: Setup = {