firebase-tools 14.24.0 → 14.24.1

package/lib/appUtils.js

@@ -32,8 +32,6 @@ async function detectApps(dirPath) {
     const srcMainFolders = await detectFiles(dirPath, "src/main/");
     const xCodeProjects = await detectFiles(dirPath, "*.xcodeproj/");
     const adminAndWebApps = (await Promise.all(packageJsonFiles.map((p) => packageJsonToAdminOrWebApp(dirPath, p)))).flat();
-    console.log("packageJsonFiles", packageJsonFiles);
-    console.log("adminAndWebApps", adminAndWebApps);
     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)));

package/lib/appdistribution/client.js

@@ -228,7 +228,7 @@ class AppDistributionClient {
         }
         utils.logSuccess(`Testers removed from group successfully`);
     }
-    async createReleaseTest(releaseName, devices, loginCredential, testCaseName) {
+    async createReleaseTest(releaseName, devices, aiInstruction, loginCredential, testCaseName) {
         try {
             const response = await this.appDistroV1AlphaClient.request({
                 method: "POST",
@@ -237,6 +237,7 @@ class AppDistributionClient {
                     deviceExecutions: devices.map((device) => ({ device })),
                     loginCredential,
                     testCase: testCaseName,
+                    aiInstructions: aiInstruction,
                 },
             });
             return response.body;

package/lib/appdistribution/distribution.js

@@ -1,16 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Distribution = exports.DistributionFileType = void 0;
+exports.awaitTestResults = exports.Distribution = exports.upload = exports.DistributionFileType = void 0;
 const fs = require("fs-extra");
-const error_1 = require("../error");
 const logger_1 = require("../logger");
 const pathUtil = require("path");
+const utils = require("../utils");
+const types_1 = require("../appdistribution/types");
+const error_1 = require("../error");
+const TEST_MAX_POLLING_RETRIES = 40;
+const TEST_POLLING_INTERVAL_MILLIS = 30000;
 var DistributionFileType;
 (function (DistributionFileType) {
     DistributionFileType["IPA"] = "ipa";
     DistributionFileType["APK"] = "apk";
     DistributionFileType["AAB"] = "aab";
 })(DistributionFileType = exports.DistributionFileType || (exports.DistributionFileType = {}));
+async function upload(requests, appName, distribution) {
+    utils.logBullet("uploading binary...");
+    try {
+        const operationName = await requests.uploadRelease(appName, distribution);
+        const uploadResponse = await requests.pollUploadStatus(operationName);
+        const release = uploadResponse.release;
+        switch (uploadResponse.result) {
+            case types_1.UploadReleaseResult.RELEASE_CREATED:
+                utils.logSuccess(`uploaded new release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            case types_1.UploadReleaseResult.RELEASE_UPDATED:
+                utils.logSuccess(`uploaded update to existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            case types_1.UploadReleaseResult.RELEASE_UNMODIFIED:
+                utils.logSuccess(`re-uploaded already existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            default:
+                utils.logSuccess(`uploaded release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+        }
+        utils.logSuccess(`View this release in the Firebase console: ${release.firebaseConsoleUri}`);
+        utils.logSuccess(`Share this release with testers who have access: ${release.testingUri}`);
+        utils.logSuccess(`Download the release binary (link expires in 1 hour): ${release.binaryDownloadUri}`);
+        return uploadResponse.release.name;
+    }
+    catch (err) {
+        if ((0, error_1.getErrStatus)(err) === 404) {
+            throw new error_1.FirebaseError(`App Distribution could not find your app ${appName}. ` +
+                `Make sure to onboard your app by pressing the "Get started" ` +
+                "button on the App Distribution page in the Firebase console: " +
+                "https://console.firebase.google.com/project/_/appdistribution", { exit: 1 });
+        }
+        throw new error_1.FirebaseError(`Failed to upload release. ${(0, error_1.getErrMsg)(err)}`, { exit: 1 });
+    }
+}
+exports.upload = upload;
 class Distribution {
     constructor(path) {
         this.path = path;
@@ -49,3 +88,47 @@ class Distribution {
     }
 }
 exports.Distribution = Distribution;
+async function awaitTestResults(releaseTests, requests) {
+    const releaseTestNames = new Set(releaseTests.map((rt) => rt.name).filter((n) => !!n));
+    for (let i = 0; i < TEST_MAX_POLLING_RETRIES; i++) {
+        utils.logBullet(`${releaseTestNames.size} automated test results are pending...`);
+        await delay(TEST_POLLING_INTERVAL_MILLIS);
+        for (const releaseTestName of releaseTestNames) {
+            const releaseTest = await requests.getReleaseTest(releaseTestName);
+            if (releaseTest.deviceExecutions.every((e) => e.state === "PASSED")) {
+                releaseTestNames.delete(releaseTestName);
+                if (releaseTestNames.size === 0) {
+                    utils.logSuccess("Automated test(s) passed!");
+                    return;
+                }
+                else {
+                    continue;
+                }
+            }
+            for (const execution of releaseTest.deviceExecutions) {
+                const device = deviceToString(execution.device);
+                switch (execution.state) {
+                    case "PASSED":
+                    case "IN_PROGRESS":
+                        continue;
+                    case "FAILED":
+                        throw new error_1.FirebaseError(`Automated test failed for ${device}: ${execution.failedReason}`, { exit: 1 });
+                    case "INCONCLUSIVE":
+                        throw new error_1.FirebaseError(`Automated test inconclusive for ${device}: ${execution.inconclusiveReason}`, { exit: 1 });
+                    default:
+                        throw new error_1.FirebaseError(`Unsupported automated test state for ${device}: ${execution.state}`, { exit: 1 });
+                }
+            }
+        }
+    }
+    throw new error_1.FirebaseError("It took longer than expected to run your test(s), please try again.", {
+        exit: 1,
+    });
+}
+exports.awaitTestResults = awaitTestResults;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function deviceToString(device) {
+    return `${device.model} (${device.version}/${device.orientation}/${device.locale})`;
+}

package/lib/appdistribution/options-parser-util.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLoginCredential = exports.parseTestDevices = exports.getAppName = exports.getProjectName = exports.ensureFileExists = exports.getEmails = exports.parseIntoStringArray = void 0;
+exports.getLoginCredential = exports.parseTestDevices = exports.toAppName = exports.getAppName = exports.getProjectName = exports.ensureFileExists = exports.getEmails = exports.parseIntoStringArray = void 0;
 const fs = require("fs-extra");
 const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
-function parseIntoStringArray(value, file) {
+function parseIntoStringArray(value, file = "") {
     if (!value && file) {
         ensureFileExists(file);
         value = fs.readFileSync(file, "utf8");
@@ -45,11 +45,14 @@ function getAppName(options) {
     if (!options.app) {
         throw new error_1.FirebaseError("set the --app option to a valid Firebase app id and try again");
     }
-    const appId = options.app;
-    return `projects/${appId.split(":")[1]}/apps/${appId}`;
+    return toAppName(options.app);
 }
 exports.getAppName = getAppName;
-function parseTestDevices(value, file) {
+function toAppName(appId) {
+    return `projects/${appId.split(":")[1]}/apps/${appId}`;
+}
+exports.toAppName = toAppName;
+function parseTestDevices(value, file = "") {
     if (!value && file) {
         ensureFileExists(file);
         value = fs.readFileSync(file, "utf8");

package/lib/commands/appdistribution-distribute.js

@@ -3,15 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = void 0;
 const fs = require("fs-extra");
 const command_1 = require("../command");
-const utils = require("../utils");
 const requireAuth_1 = require("../requireAuth");
-const client_1 = require("../appdistribution/client");
-const types_1 = require("../appdistribution/types");
 const error_1 = require("../error");
 const distribution_1 = require("../appdistribution/distribution");
 const options_parser_util_1 = require("../appdistribution/options-parser-util");
-const TEST_MAX_POLLING_RETRIES = 40;
-const TEST_POLLING_INTERVAL_MILLIS = 30000;
+const types_1 = require("../appdistribution/types");
+const client_1 = require("../appdistribution/client");
+const utils = require("../utils");
 function getReleaseNotes(releaseNotes, releaseNotesFile) {
     if (releaseNotes) {
         return releaseNotes.replace(/\\n/g, "\n");
@@ -60,6 +58,9 @@ exports.command = new command_1.Command("appdistribution:distribute <release-bin
         usernameResourceName: options.testUsernameResource,
         passwordResourceName: options.testPasswordResource,
     });
+    await distribute(appName, distribution, testCases, testDevices, releaseNotes, testers, groups, options.testNonBlocking, loginCredential);
+});
+async function distribute(appName, distribution, testCases, testDevices, releaseNotes, testers, groups, testNonBlocking, loginCredential) {
     const requests = new client_1.AppDistributionClient();
     let aabInfo;
     if (distribution.distributionFileType() === distribution_1.DistributionFileType.AAB) {
@@ -68,7 +69,7 @@ exports.command = new command_1.Command("appdistribution:distribute <release-bin
         }
         catch (err) {
             if ((0, error_1.getErrStatus)(err) === 404) {
-                throw new error_1.FirebaseError(`App Distribution could not find your app ${options.app}. ` +
+                throw new error_1.FirebaseError(`App Distribution could not find your app ${appName}. ` +
                     `Make sure to onboard your app by pressing the "Get started" ` +
                     "button on the App Distribution page in the Firebase console: " +
                     "https://console.firebase.google.com/project/_/appdistribution", { exit: 1 });
@@ -96,39 +97,7 @@ exports.command = new command_1.Command("appdistribution:distribute <release-bin
             }
         }
     }
-    utils.logBullet("uploading binary...");
-    let releaseName;
-    try {
-        const operationName = await requests.uploadRelease(appName, distribution);
-        const uploadResponse = await requests.pollUploadStatus(operationName);
-        const release = uploadResponse.release;
-        switch (uploadResponse.result) {
-            case types_1.UploadReleaseResult.RELEASE_CREATED:
-                utils.logSuccess(`uploaded new release ${release.displayVersion} (${release.buildVersion}) successfully!`);
-                break;
-            case types_1.UploadReleaseResult.RELEASE_UPDATED:
-                utils.logSuccess(`uploaded update to existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
-                break;
-            case types_1.UploadReleaseResult.RELEASE_UNMODIFIED:
-                utils.logSuccess(`re-uploaded already existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
-                break;
-            default:
-                utils.logSuccess(`uploaded release ${release.displayVersion} (${release.buildVersion}) successfully!`);
-        }
-        utils.logSuccess(`View this release in the Firebase console: ${release.firebaseConsoleUri}`);
-        utils.logSuccess(`Share this release with testers who have access: ${release.testingUri}`);
-        utils.logSuccess(`Download the release binary (link expires in 1 hour): ${release.binaryDownloadUri}`);
-        releaseName = uploadResponse.release.name;
-    }
-    catch (err) {
-        if ((0, error_1.getErrStatus)(err) === 404) {
-            throw new error_1.FirebaseError(`App Distribution could not find your app ${options.app}. ` +
-                `Make sure to onboard your app by pressing the "Get started" ` +
-                "button on the App Distribution page in the Firebase console: " +
-                "https://console.firebase.google.com/project/_/appdistribution", { exit: 1 });
-        }
-        throw new error_1.FirebaseError(`Failed to upload release. ${(0, error_1.getErrMsg)(err)}`, { exit: 1 });
-    }
+    const releaseName = await (0, distribution_1.upload)(requests, appName, distribution);
     if (aabInfo && !aabInfo.testCertificate) {
         aabInfo = await requests.getAabInfo(appName);
         if (aabInfo.testCertificate) {
@@ -147,59 +116,17 @@ exports.command = new command_1.Command("appdistribution:distribute <release-bin
         utils.logBullet("starting automated test (note: this feature is in beta)");
         const releaseTestPromises = [];
         if (!testCases.length) {
-            releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, loginCredential));
+            releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential));
         }
         else {
             for (const testCaseId of testCases) {
-                releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, loginCredential, `${appName}/testCases/${testCaseId}`));
+                releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential, `${appName}/testCases/${testCaseId}`));
             }
         }
         const releaseTests = await Promise.all(releaseTestPromises);
         utils.logSuccess(`${releaseTests.length} release test(s) started successfully`);
-        if (!options.testNonBlocking) {
-            await awaitTestResults(releaseTests, requests);
+        if (!testNonBlocking) {
+            await (0, distribution_1.awaitTestResults)(releaseTests, requests);
         }
     }
-});
-async function awaitTestResults(releaseTests, requests) {
-    const releaseTestNames = new Set(releaseTests.map((rt) => rt.name));
-    for (let i = 0; i < TEST_MAX_POLLING_RETRIES; i++) {
-        utils.logBullet(`${releaseTestNames.size} automated test results are pending...`);
-        await delay(TEST_POLLING_INTERVAL_MILLIS);
-        for (const releaseTestName of releaseTestNames) {
-            const releaseTest = await requests.getReleaseTest(releaseTestName);
-            if (releaseTest.deviceExecutions.every((e) => e.state === "PASSED")) {
-                releaseTestNames.delete(releaseTestName);
-                if (releaseTestNames.size === 0) {
-                    utils.logSuccess("Automated test(s) passed!");
-                    return;
-                }
-                else {
-                    continue;
-                }
-            }
-            for (const execution of releaseTest.deviceExecutions) {
-                switch (execution.state) {
-                    case "PASSED":
-                    case "IN_PROGRESS":
-                        continue;
-                    case "FAILED":
-                        throw new error_1.FirebaseError(`Automated test failed for ${deviceToString(execution.device)}: ${execution.failedReason}`, { exit: 1 });
-                    case "INCONCLUSIVE":
-                        throw new error_1.FirebaseError(`Automated test inconclusive for ${deviceToString(execution.device)}: ${execution.inconclusiveReason}`, { exit: 1 });
-                    default:
-                        throw new error_1.FirebaseError(`Unsupported automated test state for ${deviceToString(execution.device)}: ${execution.state}`, { exit: 1 });
-                }
-            }
-        }
-    }
-    throw new error_1.FirebaseError("It took longer than expected to run your test(s), please try again.", {
-        exit: 1,
-    });
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function deviceToString(device) {
-    return `${device.model} (${device.version}/${device.orientation}/${device.locale})`;
 }

package/lib/mcp/prompts/apptesting/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apptestingPrompts = void 0;
+const experiments_1 = require("../../../experiments");
+const run_test_1 = require("./run_test");
+exports.apptestingPrompts = [];
+if ((0, experiments_1.isEnabled)("mcpalpha")) {
+    exports.apptestingPrompts.push(run_test_1.runTest);
+}

package/lib/mcp/prompts/apptesting/run_test.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTest = void 0;
+const prompt_1 = require("../../prompt");
+exports.runTest = (0, prompt_1.prompt)("apptesting", {
+    name: "run_test",
+    description: "Run a test with the Firebase App Testing agent",
+    omitPrefix: false,
+    arguments: [
+        {
+            name: "testDescription",
+            description: "Description of the test you want to run. The agent will use the description to generate a test case that will be used as input for the AI-guided test",
+            required: false,
+        },
+    ],
+    annotations: {
+        title: "Run an App Testing AI-guided test",
+    },
+}, async ({ testDescription }, { accountEmail, projectId }) => {
+    return [
+        {
+            role: "user",
+            content: {
+                type: "text",
+                text: `
+You are going to help a developer run a test for their mobile app 
+using the Firebase App Testing agent.
+
+Active user: ${accountEmail || "<NONE>"}
+Project ID: ${projectId || "<NONE>"}
+
+## Prerequisites
+
+Here are a list of prerequisite steps that must be completed before running a test.
+
+1. **Make sure this is an Android app**. The App Testing agent only works with Android apps. If 
+   this is not an Android app, instruct the user that this command can't be used with this app.
+2. **Make sure the user is logged in. No App Testing tools will work if the user is not logged in.**
+  a. Use the \`firebase_get_environment\` tool to verify that the user is logged in.
+  b. If the Firebase 'Active user' is set to <NONE>, instruct the user to run \`firebase login\` 
+      before continuing. Ignore other fields that are set to <NONE>. We are just making sure the
+      user is logged in. 
+3. **Get the Firebase app ID.** 
+  The \`firebase_get_environment\` tool should return a list of detected app IDs, where the app
+  ID contains four colon (":") delimited parts: a version number (typically "1"), a project
+  number, a platform type ("android", "ios", or "web"). Ask the user confirm if there is only
+  a single app ID, or to choose one if there are multiple app IDs. 
+
+  If the tool does not return a list of detected apps, just ask the user for it.
+  
+4. **Confirm that the application ID of the app matches the bundle ID of the Firebase app**
+
+  The \`firebase_get_environment\` tool returns a list of detected app IDs mapped to their corresponding
+  bundle IDs. If the developer selected an app ID from the the list of detected app IDs, this already
+  confirms that the bundle ID matches the app ID. If not, get the application IDs of all the variants of
+  the app. Then get the bundle ID of the Firebase app by calling the \`firebase_list_apps\` tool and
+  confirming that the \`namespace\` field of the app with the selected app ID matches one of the application
+  IDs of the variants.
+    
+## Test Case Generation
+
+  Once you have completed the required steps, you need the help the user generate a "test case", which is the input to the
+  app testing agent. A test case consists of multiple steps where each step contains the following fields:
+
+	* Goal (required): In one sentence or less, describe what you want the agent to do in this step.
+	* Hint (optional): Provide additional information to help Gemini understand and navigate your app.
+	* Success Criteria (optional): Your success criteria should be phrased as an observation, such as 'The screen shows a
+    success message' or 'The checkout page is visible'.
+
+  The developer has optionally specified the following description for their test:
+  * ${testDescription}
+
+  Sometimes, test descriptions that developers provide tend to be too vague and lack the necessary details for the
+  app testing agent to be able to reliably re-run the tests with consistent results. Test cases should follow these
+  guidelines to ensure that they are structured in a way to make the agent more reliable.
+
+	* Prefer multiple steps with smaller, detailed goals. Broader, more open-ended goals can lead to unreliable tests 
+    since the app testing agent can more easily veer of course. It should only take a few actions to accomplish a goal.
+    For example, if a step has a list in it, it should probably be broken up into multiple steps. Steps do not need
+    to be too small though. The test case should provide a good balance between strict guidance and flexibility. As a
+    rule of thumb, each step should require between 2-5 actions.
+	* Include a hint and success criteria whenever possible. Specifically, try to always include a success criteria to help
+    the agent determine when the goal has been completed.
+	* Avoid functionality that the app testing agent struggles with. The app testing agent struggles with the following:
+		* Journeys that require specific timing (like observing that something should be visible for a certain number of
+      seconds), interacting with moving or transient elements, etc.
+		* Playing games or generally interacting with drawn visuals that would require pixel input
+ 		* Complex swipe interactions, multi-finger gestures, etc., which aren't supported
+  
+  First, analyze the code to get an understanding of how the app works. Get all the available screens in the app and the
+  different actions for each screen. Understand what functionality is and isn't available to the app testing agent.
+  Only include specific details in the test case if you are certain they will be available to the agent, otherwise the
+  agent will likely fail if it tries to follow specific guidance that doesn't work (e.g. click the 'Play' button but the
+  button isn't visible to the app testing agent). Do not include Android resource ids in the test case. Include
+  explanations that prove that each step includes between 2-5 actions. Using that information as context and the guidelines
+  above, convert the test description provided by the user to make it easier for the agent to follow so that the tests can
+  be re-run reliably. If there is no test description, generate a test case that you think will be useful given the functionality 
+  of the app. Generate an explanation on why you generated the new test case the way you did, and then generate the
+  new test case, which again is an array of steps where each step contains a goal, hint, and success criteria. Show this
+  to the user and have them confirm before moving forward. 
+
+## Run Test
+
+  Use the \`apptesting_run_test\` tool to run an automated test with the following as input:
+    * The generated test case that as been confirmed by the user
+    * An APK. If there is no APK present, build the app to produce one. Make sure to build the variant of the app
+      with the same bundle ID as the Firebase app.
+    * The devices to test on. If the user doesn't specify any devices in the test description, you can leave this
+      blank and the test will run on a the default virtual device. If the user does specify a device,
+      Use the \`apptesting_check_status\` tool with \`getAvailableDevices\` set to true to get a list of available
+      devices.
+
+  Once the test has started, provide the developer a link to see the results of the test in the Firebase Console.
+  You should already know the value of \`appId\' and \`projectId\` from earlier (if you only know \`projectNumber\',
+  use the \`firebase_get_project\` tool to get \`projectId\`). \`packageName\` is the package name of the app we tested. 
+  The \`apptesting_run_test\` tool returns a response with field \`name\` in the form 
+  projects/{projectNumber}/apps/{appId}/releases/{releaseId}/tests/{releaseTestId}. Extract the values for \'releaseId\' 
+  and \`releaseTestId\` and use provide a link to the results in the Firebase Console in the format:
+  \`https://console.firebase.google.com/u/0/project/{projectId}/apptesting/app/android:{packageName}/releases/{releaseId}/tests/{releaseTestId}\`.
+
+  You can check the status of the test using the \`apptesting_check_status\` tool with \`release_test_name\' set to
+  the name of the release test returned by the \`run_test\` tool.
+`.trim(),
+            },
+        },
+    ];
+});

package/lib/mcp/prompts/crashlytics/connect.js

@@ -21,6 +21,12 @@ mobile application by accessing their Firebase Crashlytics data.
 
 Active user: ${accountEmail || "<NONE>"}
 
+General rules:
+**ASK THE USER WHAT THEY WOULD LIKE TO DO BEFORE TAKING ACTION**
+**ASK ONLY ONE QUESTION OF THE USER AT A TIME**
+**MAKE SURE TO FOLLOW THE INSTRUCTIONS, ESPECIALLY WHERE THEY ASK YOU TO CHECK IN WITH THE USER**
+**ADHERE TO SUGGESTED FORMATTING**
+
 ## Required first steps! Absolutely required! Incredibly important!
 
   1. **Make sure the user is logged in. No Crashlytics tools will work if the user is not logged in.**
@@ -30,40 +36,40 @@ Active user: ${accountEmail || "<NONE>"}
        user is logged in. 
 
   2. **Get the app ID for the Firebase application.** 
-     
-    Use the information below to help you find the developer's app ID. If you cannot find it after 2-3 
-    attempts, just ask the user for the value they want to use, providing the description of what the 
-    value looks like.
-    
-    * **Description:** The app ID we are looking for contains four colon (":") delimited parts: a version 
-      number (typically "1"), a project number, a platform type ("android", "ios", or "web"), 
-      and a sequence of hexadecimal characters. This can be found in the project settings in the Firebase Console
-      or in the appropriate google services file for the application type.
-    * For Android apps, you will typically find the app ID in a file called google-services.json under the
-      mobilesdk_app_id key. The file is most often located in the app directory that contains the src directory.
-    * For iOS apps, you will typically find the app ID in a property list file called GoogleService-Info.plist under the
-      GOOGLE_APP_ID key. The plist file is most often located in the main project directory.
-    * Sometimes developers will not check in the google services file because it is a shared or public
-      repository. If you can't find the file, the files may be included in the .gitignore. Check again for the file 
-      removing restrictions around looking for tracked files.
-    * Developers may have multiple google services files that map to different releases. In cases like this,
-      developers may create different directories to hold each like alpha/google-services.json or alpha/GoogleService-Info.plist.
-      In other cases, developers may change the suffix of the file to something like google-services-alpha.json or 
-      GoogleService-Alpha.plist. Look for as many google services files as you can find.
-    * Sometimes developers may include the codebase for both the Android app and the iOS app in the same repository.
-    * If there are multiple files or multiple app IDs in a single file, ask the user to choose one by providing 
-      a numbered list of all the package names.
-    * Again, if you have trouble finding the app ID, just ask the user for it.
+    a. **PRIORITIZE REMEMBERED APP ID ENTRIES** If an entry for this directory exists in the remembered app ids, use the remembered app id 
+       for this directory without presenting any additional options.
+       i. If there are multiple remembered app ids for this directory, ask the user to choose one by providing 
+          a numbered list of all the package names. Tell them that these values came from memories and how they can modify those values.
+    b. **IF THERE IS NO REMEMBERED ENTRY FOR THIS DIRECTORY** Use the app IDs from the \`firebase_get_environment\` tool. 
+       i. If you've already called this tool, use the previous response from context.
+       ii. If the 'Detected App IDs' is set to <NONE>, ask the user for the value they want to use.
+       iii. If there are multiple 'Detected App IDs', ask the user to choose one by providing 
+            a numbered list of all the package names and app ids.
+    c. **IF THERE IS A REMEMBERED VALUE BUT IT DOES NOT MATCH ANY DETECTED APP IDS** Ask if the user would like to replace the value with one of
+       the detected values.
+       i. **Description:** A valid app ID to remember contains four colon (":") delimited parts: a version 
+          number (typically "1"), a project number, a platform type ("android", "ios", or "web"), 
+          and a sequence of hexadecimal characters. 
+       ii. Replace the value for this directory with this valid app id, the android package name or ios bundle identifier, and the project directory.
+    c. **IF THERE IS NO REMEMBERED ENTRY FOR THIS DIRECTORY** Ask if the user would like to remember the app id selection
+       i. **Description:** A valid app ID to remember contains four colon (":") delimited parts: a version 
+          number (typically "1"), a project number, a platform type ("android", "ios", or "web"), 
+          and a sequence of hexadecimal characters. 
+       ii. Store the valid app id value, the android package name or ios bundle identifier, and the project directory.
 
 ## Next steps
 
-Once you have confirmed that the user is logged in to Firebase, and confirmed the
-id for the application that they want to access, then you can ask the user what actions
-they would like to perform. Here are some possibilities and instructions follow below:
+Once you have confirmed that the user is logged in to Firebase, confirmed the
+id for the application that they want to access, and asked if they want to remember the app id for this directory, 
+ask the user what actions they would like to perform. 
+
+Use the following format to ask the user what actions they would like to perform:
 
   1. Prioritize the most impactful stability issues
   2. Diagnose and propose a fix for a crash
 
+Wait for their response before taking action.
+
 ## Instructions for Using Crashlytics Data
 
 ### How to prioritize issues

package/lib/mcp/prompts/index.js

@@ -4,6 +4,7 @@ exports.markdownDocsOfPrompts = exports.availablePrompts = void 0;
 const core_1 = require("./core");
 const dataconnect_1 = require("./dataconnect");
 const crashlytics_1 = require("./crashlytics");
+const apptesting_1 = require("./apptesting");
 const prompts = {
     core: namespacePrompts(core_1.corePrompts, "core"),
     firestore: [],
@@ -14,6 +15,7 @@ const prompts = {
     functions: [],
     remoteconfig: [],
     crashlytics: namespacePrompts(crashlytics_1.crashlyticsPrompts, "crashlytics"),
+    apptesting: namespacePrompts(apptesting_1.apptestingPrompts, "apptesting"),
     apphosting: [],
     database: [],
 };

package/lib/mcp/tools/apptesting/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apptestingTools = void 0;
+const experiments_1 = require("../../../experiments");
+const tests_1 = require("./tests");
+exports.apptestingTools = [];
+if ((0, experiments_1.isEnabled)("mcpalpha")) {
+    exports.apptestingTools.push(...[tests_1.run_tests, tests_1.check_status]);
+}

package/lib/mcp/tools/apptesting/tests.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check_status = exports.run_tests = void 0;
+const zod_1 = require("zod");
+const filters_1 = require("../../../crashlytics/filters");
+const distribution_1 = require("../../../appdistribution/distribution");
+const tool_1 = require("../../tool");
+const util_1 = require("../../util");
+const options_parser_util_1 = require("../../../appdistribution/options-parser-util");
+const client_1 = require("../../../appdistribution/client");
+const googleapis_1 = require("googleapis");
+const apiv2_1 = require("../../../apiv2");
+const TestDeviceSchema = zod_1.z
+    .object({
+    model: zod_1.z.string(),
+    version: zod_1.z.string(),
+    locale: zod_1.z.string(),
+    orientation: zod_1.z.string(),
+})
+    .describe(`Device to run automated test on. Can run 'gcloud firebase test android|ios models list' to see available devices.`);
+const AIStepSchema = zod_1.z
+    .object({
+    goal: zod_1.z.string().describe("A goal to be accomplished during the test."),
+    hint: zod_1.z
+        .string()
+        .optional()
+        .describe("Hint text containing suggestions to help the agent accomplish the goal."),
+    successCriteria: zod_1.z
+        .string()
+        .optional()
+        .describe("A description of criteria the agent should use to determine if the goal has been successfully completed."),
+})
+    .describe("Step within a test case; run during the execution of the test.");
+const defaultDevices = [
+    {
+        model: "MediumPhone.arm",
+        version: "30",
+        locale: "en_US",
+        orientation: "portrait",
+    },
+];
+exports.run_tests = (0, tool_1.tool)("apptesting", {
+    name: "run_test",
+    description: `Run a remote test.`,
+    inputSchema: zod_1.z.object({
+        appId: filters_1.ApplicationIdSchema,
+        releaseBinaryFile: zod_1.z.string().describe("Path to the binary release (APK)."),
+        testDevices: zod_1.z.array(TestDeviceSchema).default(defaultDevices),
+        testCase: zod_1.z.object({
+            steps: zod_1.z
+                .array(AIStepSchema)
+                .describe("Test case containing the steps that are run during its execution."),
+        }),
+    }),
+    annotations: {
+        title: "Run a Remote Test",
+        readOnlyHint: false,
+    },
+}, async ({ appId, releaseBinaryFile, testDevices, testCase }) => {
+    const devices = testDevices || defaultDevices;
+    const client = new client_1.AppDistributionClient();
+    const releaseName = await (0, distribution_1.upload)(client, (0, options_parser_util_1.toAppName)(appId), new distribution_1.Distribution(releaseBinaryFile));
+    return (0, util_1.toContent)(await client.createReleaseTest(releaseName, devices, testCase));
+});
+exports.check_status = (0, tool_1.tool)("apptesting", {
+    name: "check_status",
+    description: "Check the status of an apptesting release test and/or get available devices that can be used for automated tests ",
+    inputSchema: zod_1.z.object({
+        release_test_name: zod_1.z
+            .string()
+            .optional()
+            .describe("The name of the release test returned by the run_test tool. If set, the tool will fetch the release test"),
+        getAvailableDevices: zod_1.z
+            .boolean()
+            .optional()
+            .describe("If set to true, the tool will get the available devices that can be used for automated tests using the app testing agent"),
+    }),
+    annotations: {
+        title: "Check Remote Test",
+        readOnlyHint: true,
+    },
+}, async ({ release_test_name, getAvailableDevices }) => {
+    let devices = undefined;
+    let releaseTest = undefined;
+    if (release_test_name) {
+        const client = new client_1.AppDistributionClient();
+        releaseTest = await client.getReleaseTest(release_test_name);
+    }
+    if (getAvailableDevices) {
+        const testing = googleapis_1.google.testing("v1");
+        devices = await testing.testEnvironmentCatalog.get({
+            oauth_token: await (0, apiv2_1.getAccessToken)(),
+            environmentType: "ANDROID",
+        });
+    }
+    return (0, util_1.toContent)({
+        devices,
+        releaseTest,
+    });
+});

package/lib/mcp/tools/index.js

@@ -10,8 +10,9 @@ const index_6 = require("./messaging/index");
 const index_7 = require("./remoteconfig/index");
 const index_8 = require("./crashlytics/index");
 const index_9 = require("./apphosting/index");
-const index_10 = require("./realtime_database/index");
-const index_11 = require("./functions/index");
+const index_10 = require("./apptesting/index");
+const index_11 = require("./realtime_database/index");
+const index_12 = require("./functions/index");
 async function availableTools(ctx, activeFeatures) {
     const allTools = getAllTools(activeFeatures);
     const availabilities = await Promise.all(allTools.map((t) => {
@@ -43,11 +44,12 @@ const tools = {
     dataconnect: addFeaturePrefix("dataconnect", index_2.dataconnectTools),
     storage: addFeaturePrefix("storage", index_5.storageTools),
     messaging: addFeaturePrefix("messaging", index_6.messagingTools),
-    functions: addFeaturePrefix("functions", index_11.functionsTools),
+    functions: addFeaturePrefix("functions", index_12.functionsTools),
     remoteconfig: addFeaturePrefix("remoteconfig", index_7.remoteConfigTools),
     crashlytics: addFeaturePrefix("crashlytics", index_8.crashlyticsTools),
+    apptesting: addFeaturePrefix("apptesting", index_10.apptestingTools),
     apphosting: addFeaturePrefix("apphosting", index_9.appHostingTools),
-    database: addFeaturePrefix("realtimedatabase", index_10.realtimeDatabaseTools),
+    database: addFeaturePrefix("realtimedatabase", index_11.realtimeDatabaseTools),
 };
 function addFeaturePrefix(feature, tools) {
     return tools.map((tool) => (Object.assign(Object.assign({}, tool), { mcp: Object.assign(Object.assign({}, tool.mcp), { name: `${feature}_${tool.mcp.name}`, _meta: Object.assign(Object.assign({}, tool.mcp._meta), { feature }) }) })));

package/lib/mcp/types.js

@@ -11,6 +11,7 @@ exports.SERVER_FEATURES = [
     "functions",
     "remoteconfig",
     "crashlytics",
+    "apptesting",
     "apphosting",
     "database",
 ];

package/lib/mcp/util/apptesting/availability.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAppTestingAvailable = void 0;
+const api_1 = require("../../../api");
+const appUtils_1 = require("../../../appUtils");
+const ensureApiEnabled_1 = require("../../../ensureApiEnabled");
+const timeout_1 = require("../../../timeout");
+async function isAppTestingAvailable(ctx) {
+    const host = ctx.host;
+    const projectDir = ctx.config.projectDir;
+    const platforms = await (0, appUtils_1.getPlatformsFromFolder)(projectDir);
+    const supportedPlatforms = [appUtils_1.Platform.FLUTTER, appUtils_1.Platform.ANDROID, appUtils_1.Platform.IOS];
+    if (!platforms.some((p) => supportedPlatforms.includes(p))) {
+        host.log("debug", `Found no supported App Testing platforms.`);
+        return false;
+    }
+    try {
+        return await (0, timeout_1.timeoutFallback)((0, ensureApiEnabled_1.check)(ctx.projectId, (0, api_1.appDistributionOrigin)(), "", true), true, 3000);
+    }
+    catch (e) {
+        return true;
+    }
+}
+exports.isAppTestingAvailable = isAppTestingAvailable;

package/lib/mcp/util/availability.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultFeatureAvailabilityCheck = void 0;
 const util_1 = require("../util");
 const availability_1 = require("./crashlytics/availability");
+const availability_2 = require("./apptesting/availability");
 const DEFAULT_AVAILABILITY_CHECKS = {
     core: async (ctx) => true,
     firestore: (ctx) => (0, util_1.checkFeatureActive)("firestore", ctx.projectId, { config: ctx.config }),
@@ -14,6 +15,7 @@ const DEFAULT_AVAILABILITY_CHECKS = {
     remoteconfig: (ctx) => (0, util_1.checkFeatureActive)("remoteconfig", ctx.projectId, { config: ctx.config }),
     crashlytics: availability_1.isCrashlyticsAvailable,
     apphosting: (ctx) => (0, util_1.checkFeatureActive)("apphosting", ctx.projectId, { config: ctx.config }),
+    apptesting: availability_2.isAppTestingAvailable,
     database: (ctx) => (0, util_1.checkFeatureActive)("database", ctx.projectId, { config: ctx.config }),
 };
 function getDefaultFeatureAvailabilityCheck(feature) {

package/lib/mcp/util.js

@@ -49,6 +49,7 @@ const SERVER_FEATURE_APIS = {
     functions: (0, api_1.functionsOrigin)(),
     remoteconfig: (0, api_1.remoteConfigApiOrigin)(),
     crashlytics: (0, api_1.crashlyticsApiOrigin)(),
+    apptesting: (0, api_1.appDistributionOrigin)(),
     apphosting: (0, api_1.apphostingOrigin)(),
     database: (0, api_1.realtimeOrigin)(),
 };
@@ -62,6 +63,7 @@ const DETECTED_API_FEATURES = {
     functions: undefined,
     remoteconfig: undefined,
     crashlytics: undefined,
+    apptesting: undefined,
     apphosting: undefined,
     database: undefined,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "14.24.0",
+  "version": "14.24.1",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {