firebase-tools 14.15.2 → 14.17.0

package/lib/commands/firestore-bulkdelete.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const fsi = require("../firestore/api");
+const logger_1 = require("../logger");
+const requirePermissions_1 = require("../requirePermissions");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const prompt_1 = require("../prompt");
+const utils = require("../utils");
+const clc = require("colorette");
+const utils_1 = require("../utils");
+const error_1 = require("../error");
+function confirmationMessage(options, databaseId, collectionIds) {
+    const root = `projects/${options.project}/databases/${databaseId}/documents`;
+    return ("You are about to delete all documents in the following collection groups: " +
+        clc.cyan(collectionIds.map((item) => `"${item}"`).join(", ")) +
+        " in " +
+        clc.cyan(`"${root}"`) +
+        ". Are you sure?");
+}
+exports.command = new command_1.Command("firestore:bulkdelete")
+    .description("managed bulk delete service to delete data from one or more collection groups")
+    .option("--database <databaseName>", 'Database ID for database to delete from. "(default)" if none is provided.')
+    .option("--collection-ids <collectionIds>", "A comma-separated list of collection group IDs to delete. Deletes all documents in the specified collection groups.")
+    .before(requirePermissions_1.requirePermissions, ["datastore.databases.bulkDeleteDocuments"])
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.FIRESTORE)
+    .action(async (options) => {
+    if (!options.collectionIds) {
+        throw new error_1.FirebaseError("Missing required flag --collection-ids=[comma separated list of collection groups]");
+    }
+    let collectionIds = [];
+    try {
+        collectionIds = options.collectionIds
+            .split(",")
+            .filter((id) => id.trim() !== "");
+    }
+    catch (e) {
+        throw new error_1.FirebaseError("The value for --collection-ids must a list of comma separated collection group names");
+    }
+    if (collectionIds.length === 0) {
+        throw new error_1.FirebaseError("Must specify at least one collection ID in --collection-ids.");
+    }
+    const databaseId = options.database || "(default)";
+    const api = new fsi.FirestoreApi();
+    const confirmed = await (0, prompt_1.confirm)({
+        message: confirmationMessage(options, databaseId, collectionIds),
+        default: false,
+        force: options.force,
+        nonInteractive: options.nonInteractive,
+    });
+    if (!confirmed) {
+        return utils.reject("Command aborted.", { exit: 1 });
+    }
+    const op = await api.bulkDeleteDocuments(options.project, databaseId, collectionIds);
+    if (options.json) {
+        logger_1.logger.info(JSON.stringify(op, undefined, 2));
+    }
+    else {
+        if (op.name) {
+            (0, utils_1.logSuccess)(`Successfully started bulk delete operation.`);
+            (0, utils_1.logBullet)(`Operation name: ` + clc.cyan(op.name));
+            (0, utils_1.logBullet)("You can monitor the operation's progress using the " +
+                clc.cyan(`gcloud firestore operations describe`) +
+                ` command.`);
+        }
+        else {
+            (0, utils_1.logLabeledError)(`Bulk Delete:`, `Failed to start a bulk delete operation.`);
+        }
+    }
+    return op;
+});

package/lib/commands/firestore-operations-cancel.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const fsi = require("../firestore/api");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const firestore_utils_1 = require("./firestore-utils");
+const prompt_1 = require("../prompt");
+const clc = require("colorette");
+const utils = require("../utils");
+const logger_1 = require("../logger");
+exports.command = new command_1.Command("firestore:operations:cancel <operationName>")
+    .description("cancels a long-running Cloud Firestore admin operation")
+    .option("--database <databaseName>", 'Database ID for which the operation is running. "(default)" if none is provided.')
+    .option("--force", "Forces the operation cancellation without asking for confirmation")
+    .before(commandUtils_1.errorMissingProject)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.FIRESTORE)
+    .action(async (operationName, options) => {
+    const databaseId = options.database || "(default)";
+    operationName = (0, firestore_utils_1.getShortOperationName)(operationName);
+    if (!options.force) {
+        const fullName = `/projects/${options.project}/databases/${databaseId}/operations/${operationName}`;
+        const confirmMessage = `You are about to cancel the operation: ${clc.bold(clc.yellow(clc.underline(fullName)))}. Do you wish to continue?`;
+        const consent = await (0, prompt_1.confirm)(confirmMessage);
+        if (!consent) {
+            return utils.reject("Command aborted.", { exit: 1 });
+        }
+    }
+    const api = new fsi.FirestoreApi();
+    const status = await api.cancelOperation(options.project, databaseId, operationName);
+    if (options.json) {
+        logger_1.logger.info(JSON.stringify(status, undefined, 2));
+    }
+    else {
+        if (status.success) {
+            utils.logSuccess("Operation cancelled successfully.");
+        }
+        else {
+            utils.logWarning("Canceling the operation failed.");
+        }
+    }
+    return status;
+});

package/lib/commands/firestore-operations-describe.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const fsi = require("../firestore/api");
+const logger_1 = require("../logger");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const pretty_print_1 = require("../firestore/pretty-print");
+const firestore_utils_1 = require("./firestore-utils");
+exports.command = new command_1.Command("firestore:operations:describe <operationName>")
+    .description("retrieves information about a Cloud Firestore admin operation")
+    .option("--database <databaseName>", 'Database ID for which the operation is running. "(default)" if none is provided.')
+    .before(commandUtils_1.errorMissingProject)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.FIRESTORE)
+    .action(async (operationName, options) => {
+    const databaseId = options.database || "(default)";
+    operationName = (0, firestore_utils_1.getShortOperationName)(operationName);
+    const api = new fsi.FirestoreApi();
+    const operation = await api.describeOperation(options.project, databaseId, operationName);
+    if (options.json) {
+        logger_1.logger.info(JSON.stringify(operation, undefined, 2));
+    }
+    else {
+        const printer = new pretty_print_1.PrettyPrint();
+        printer.prettyPrintOperation(operation);
+    }
+    return operation;
+});

package/lib/commands/firestore-operations-list.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const fsi = require("../firestore/api");
+const logger_1 = require("../logger");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const pretty_print_1 = require("../firestore/pretty-print");
+exports.command = new command_1.Command("firestore:operations:list")
+    .description("list pending Cloud Firestore admin operations and their status")
+    .option("--database <databaseName>", 'Database ID for database to list operations for. "(default)" if none is provided.')
+    .option("--limit <number>", "The maximum number of operations to list. Uses 100 by default.")
+    .before(commandUtils_1.errorMissingProject)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.FIRESTORE)
+    .action(async (options) => {
+    const databaseId = options.database || "(default)";
+    const limit = options.limit === undefined ? 100 : Number(options.limit);
+    const api = new fsi.FirestoreApi();
+    const { operations } = await api.listOperations(options.project, databaseId, limit);
+    if (options.json) {
+        logger_1.logger.info(JSON.stringify(operations, undefined, 2));
+    }
+    else {
+        const printer = new pretty_print_1.PrettyPrint();
+        printer.prettyPrintOperations(operations);
+    }
+    return operations;
+});

package/lib/commands/firestore-utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShortOperationName = void 0;
+const error_1 = require("../error");
+function getShortOperationName(operationName) {
+    let opName = operationName;
+    if (operationName.includes("/operations/")) {
+        opName = operationName.split("/operations/")[1];
+    }
+    if (opName.length === 0 || opName.includes("/")) {
+        throw new error_1.FirebaseError(`"${operationName}" is not a valid operation name.`);
+    }
+    return opName;
+}
+exports.getShortOperationName = getShortOperationName;

package/lib/commands/functions-config-export.js

@@ -78,7 +78,10 @@ exports.command = new command_1.Command("functions:config:export")
     .before(requireInteractive_1.default)
     .action(async (options) => {
     const config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions)[0];
-    const functionsDir = config.source;
+    const configDir = (0, projectConfig_1.resolveConfigDir)(config);
+    if (!configDir) {
+        throw new error_1.FirebaseError("functions:config:export requires a local env directory. Set functions[].configDir in firebase.json when using remoteSource.");
+    }
     let pInfos = configExport.getProjectInfos(options);
     checkReservedAliases(pInfos);
     (0, utils_1.logBullet)("Importing functions configs from projects [" +
@@ -111,6 +114,6 @@ exports.command = new command_1.Command("functions:config:export")
     filesToWrite[".env"] =
         `${header}# .env file contains environment variables that applies to all projects.\n`;
     for (const [filename, content] of Object.entries(filesToWrite)) {
-        await options.config.askWriteProjectFile(path.join(functionsDir, filename), content);
+        await options.config.askWriteProjectFile(path.join(configDir, filename), content);
     }
 });

package/lib/commands/index.js

@@ -96,8 +96,13 @@ function load(client) {
     client.ext.dev.usage = loadCommand("ext-dev-usage");
     client.firestore = {};
     client.firestore.delete = loadCommand("firestore-delete");
+    client.firestore.bulkDelete = loadCommand("firestore-bulkdelete");
     client.firestore.indexes = loadCommand("firestore-indexes-list");
     client.firestore.locations = loadCommand("firestore-locations");
+    client.firestore.operations = {};
+    client.firestore.operations.cancel = loadCommand("firestore-operations-cancel");
+    client.firestore.operations.describe = loadCommand("firestore-operations-describe");
+    client.firestore.operations.list = loadCommand("firestore-operations-list");
     client.firestore.databases = {};
     client.firestore.databases.list = loadCommand("firestore-databases-list");
     client.firestore.databases.get = loadCommand("firestore-databases-get");

package/lib/config.js

@@ -42,13 +42,25 @@ class Config {
         });
         if (this.get("functions")) {
             if (this.projectDir && fsutils.dirExistsSync(this.path(Config.DEFAULT_FUNCTIONS_SOURCE))) {
-                if (Array.isArray(this.get("functions"))) {
-                    if (!this.get("functions.[0].source")) {
-                        this.set("functions.[0].source", Config.DEFAULT_FUNCTIONS_SOURCE);
+                const funcs = this.get("functions");
+                if (Array.isArray(funcs)) {
+                    let emptyIdx;
+                    for (let i = 0; i < funcs.length; i++) {
+                        const hasSource = this.get(`functions.[${i}].source`);
+                        const hasRemote = this.get(`functions.[${i}].remoteSource`);
+                        if (!hasSource && !hasRemote) {
+                            emptyIdx = i;
+                            break;
+                        }
+                    }
+                    if (emptyIdx !== undefined) {
+                        this.set(`functions.[${emptyIdx}].source`, Config.DEFAULT_FUNCTIONS_SOURCE);
                     }
                 }
                 else {
-                    if (!this.get("functions.source")) {
+                    const hasSource = this.get("functions.source");
+                    const hasRemote = this.get("functions.remoteSource");
+                    if (!hasSource && !hasRemote) {
                         this.set("functions.source", Config.DEFAULT_FUNCTIONS_SOURCE);
                     }
                 }

package/lib/crashlytics/{listNotes.js → events.js}

@@ -1,29 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listNotes = void 0;
+exports.listEvents = void 0;
 const logger_1 = require("../logger");
 const error_1 = require("../error");
 const utils_1 = require("./utils");
-async function listNotes(appId, issueId, noteCount) {
+const filters_1 = require("./filters");
+async function listEvents(appId, filter, pageSize = 1) {
     const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
     try {
-        const queryParams = new URLSearchParams();
-        queryParams.set("page_size", `${noteCount}`);
-        logger_1.logger.debug(`[mcp][crashlytics] listNotes called with appId: ${appId}, issueId: ${issueId}, noteCount: ${noteCount}`);
+        const queryParams = (0, filters_1.filterToUrlSearchParams)(filter);
+        queryParams.set("page_size", `${pageSize}`);
+        logger_1.logger.debug(`[crashlytics] listEvents called with appId: ${appId}, filter: ${queryParams.toString()}, pageSize: ${pageSize}`);
         const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
             method: "GET",
             headers: {
                 "Content-Type": "application/json",
             },
-            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}/notes`,
+            path: `/projects/${requestProjectNumber}/apps/${appId}/events`,
             queryParams: queryParams,
             timeout: utils_1.TIMEOUT,
         });
         return response.body;
     }
     catch (err) {
-        logger_1.logger.debug(err.message);
-        throw new error_1.FirebaseError(`Failed to fetch notes for issue ${issueId} for app ${appId}. Error: ${err}.`, { original: err });
+        throw new error_1.FirebaseError(`Failed to list events for app_id ${appId}.`, {
+            original: (0, error_1.getError)(err),
+        });
     }
 }
-exports.listNotes = listNotes;
+exports.listEvents = listEvents;

package/lib/crashlytics/filters.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterToUrlSearchParams = exports.EventFilterSchema = exports.IssueIdSchema = exports.ApplicationIdSchema = void 0;
+const zod_1 = require("zod");
+exports.ApplicationIdSchema = zod_1.z
+    .string()
+    .describe("Firebase app id. For an Android application, read the " +
+    "mobilesdk_app_id value specified in the google-services.json file for " +
+    "the current package name. For an iOS Application, read the GOOGLE_APP_ID " +
+    "from GoogleService-Info.plist. If neither is available, ask the user to " +
+    "provide the app id.");
+exports.IssueIdSchema = zod_1.z.string().describe("Crashlytics issue id, as hexidecimal uuid");
+exports.EventFilterSchema = zod_1.z
+    .object({
+    intervalStartTime: zod_1.z.string().optional().describe(`A timestamp in ISO 8601 string format`),
+    intervalEndTime: zod_1.z.string().optional().describe(`A timestamp in ISO 8601 string format.`),
+    versionDisplayNames: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe(`The version display names should be obtained from an API response.`),
+    issueId: zod_1.z.string().optional().describe(`Count events for the given issue`),
+    issueVariantId: zod_1.z.string().optional().describe(`Count events for the given issue variant`),
+    issueErrorTypes: zod_1.z
+        .array(zod_1.z.enum(["FATAL", "NON_FATAL", "ANR"]))
+        .optional()
+        .describe(`Count FATAL events (crashes), NON_FATAL events (exceptions) or ANR events (application not responding)`),
+    issueSignals: zod_1.z
+        .array(zod_1.z.enum(["SIGNAL_EARLY", "SIGNAL_FRESH", "SIGNAL_REGRESSED", "SIGNAL_REPETITIVE"]))
+        .optional()
+        .describe(`Count events matching the given signals`),
+    operatingSystemDisplayNames: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe(`The operating system displayNames should be obtained from an API response`),
+    deviceDisplayNames: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe(`The operating system displayNames should be obtained from an API response`),
+    deviceFormFactors: zod_1.z
+        .array(zod_1.z.enum(["PHONE", "TABLET", "DESKTOP", "TV", "WATCH"]))
+        .optional()
+        .describe(`Count events originating from the given device form factors`),
+})
+    .optional()
+    .describe(`Only events matching the given filters will be counted. All filters are optional. 
+    If setting a time interval, set both intervalStartTime and intervalEndTime.`);
+const toolToParamMap = {
+    intervalStartTime: "filter.interval.start_time",
+    intervalEndTime: "filter.interval.end_time",
+    versionDisplayNames: "filter.version.display_names",
+    issueId: "filter.issue.id",
+    issueVariantId: "filter.issue.variant_id",
+    issueErrorTypes: "filter.issue.error_types",
+    issueSignals: "filter.issue.signals",
+    operatingSystemDisplayNames: "filter.operating_system.display_names",
+    deviceDisplayNames: "filter.device.display_names",
+    deviceFormFactors: "filter.device.form_factors",
+};
+function filterToUrlSearchParams(filter) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filter || {})) {
+        if (value === undefined) {
+            continue;
+        }
+        const paramKey = toolToParamMap[key];
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                params.append(paramKey, v);
+            }
+        }
+        else if (value) {
+            params.set(paramKey, value);
+        }
+    }
+    return params;
+}
+exports.filterToUrlSearchParams = filterToUrlSearchParams;

package/lib/crashlytics/issues.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateIssue = exports.getIssue = void 0;
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const utils_1 = require("./utils");
+async function getIssue(appId, issueId) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    logger_1.logger.debug(`[crashlytics] getIssue called with appId: ${appId}, issueId: ${issueId}`);
+    try {
+        const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}`,
+            timeout: utils_1.TIMEOUT,
+        });
+        return response.body;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to fetch issue for appId ${appId}, issueId ${issueId}`, {
+            original: (0, error_1.getError)(err),
+        });
+    }
+}
+exports.getIssue = getIssue;
+async function updateIssue(appId, issueId, state) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    try {
+        logger_1.logger.debug(`[crashlytics] updateIssue called with appId: ${appId}, issueId: ${issueId}, state: ${state}`);
+        const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}`,
+            queryParams: { updateMask: "state" },
+            body: { issue: { state } },
+            timeout: utils_1.TIMEOUT,
+        });
+        return response.body;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to update issue ${issueId} for app ${appId}`, {
+            original: (0, error_1.getError)(err),
+        });
+    }
+}
+exports.updateIssue = updateIssue;

package/lib/crashlytics/notes.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listNotes = exports.deleteNote = exports.createNote = void 0;
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const utils_1 = require("./utils");
+async function createNote(appId, issueId, note) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    logger_1.logger.debug(`[crashlytics] createNote called with appId: ${appId}, issueId: ${issueId}, note: ${note}`);
+    try {
+        const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}/notes`,
+            body: { body: note },
+            timeout: utils_1.TIMEOUT,
+        });
+        return response.body;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to create note for issue ${issueId}, app ${appId}`, {
+            original: (0, error_1.getError)(err),
+        });
+    }
+}
+exports.createNote = createNote;
+async function deleteNote(appId, issueId, noteId) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    logger_1.logger.debug(`[crashlytics] deleteNote called with appId: ${appId}, issueId: ${issueId}, noteId: ${noteId}`);
+    try {
+        await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "DELETE",
+            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}/notes/${noteId}`,
+            timeout: utils_1.TIMEOUT,
+        });
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to delete note ${noteId} from issue ${issueId} for app ${appId}`, { original: (0, error_1.getError)(err) });
+    }
+}
+exports.deleteNote = deleteNote;
+async function listNotes(appId, issueId, pageSize = 20) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    try {
+        const queryParams = new URLSearchParams();
+        queryParams.set("page_size", `${pageSize}`);
+        logger_1.logger.debug(`[crashlytics] listNotes called with appId: ${appId}, issueId: ${issueId}, pageSize: ${pageSize}`);
+        const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectNumber}/apps/${appId}/issues/${issueId}/notes`,
+            queryParams: queryParams,
+            timeout: utils_1.TIMEOUT,
+        });
+        return response.body.notes || [];
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to list notes for issue ${issueId}, app ${appId}`, {
+            original: (0, error_1.getError)(err),
+        });
+    }
+}
+exports.listNotes = listNotes;

package/lib/crashlytics/reports.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReport = exports.CrashlyticsReport = exports.ReportInputSchema = void 0;
+const zod_1 = require("zod");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const utils_1 = require("./utils");
+const filters_1 = require("./filters");
+const DEFAULT_PAGE_SIZE = 10;
+exports.ReportInputSchema = zod_1.z.object({
+    appId: filters_1.ApplicationIdSchema,
+    filter: filters_1.EventFilterSchema,
+    pageSize: zod_1.z.number().optional().describe("Number of rows to return").default(DEFAULT_PAGE_SIZE),
+});
+var CrashlyticsReport;
+(function (CrashlyticsReport) {
+    CrashlyticsReport["TopIssues"] = "topIssues";
+    CrashlyticsReport["TopVariants"] = "topVariants";
+    CrashlyticsReport["TopVersions"] = "topVersions";
+    CrashlyticsReport["TopOperatingSystems"] = "topOperatingSystems";
+    CrashlyticsReport["TopAppleDevices"] = "topAppleDevices";
+    CrashlyticsReport["TopAndroidDevices"] = "topAndroidDevices";
+})(CrashlyticsReport = exports.CrashlyticsReport || (exports.CrashlyticsReport = {}));
+async function getReport(report, appId, filter, pageSize = DEFAULT_PAGE_SIZE) {
+    const requestProjectNumber = (0, utils_1.parseProjectNumber)(appId);
+    try {
+        const queryParams = (0, filters_1.filterToUrlSearchParams)(filter);
+        queryParams.set("page_size", `${pageSize}`);
+        logger_1.logger.debug(`[crashlytics] report ${report} called with appId: ${appId} filter: ${queryParams.toString()}, page_size: ${pageSize}`);
+        const response = await utils_1.CRASHLYTICS_API_CLIENT.request({
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            path: `/projects/${requestProjectNumber}/apps/${appId}/reports/${report}`,
+            queryParams: queryParams,
+            timeout: utils_1.TIMEOUT,
+        });
+        return response.body;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to fetch ${report} report for app: ${appId}`, {
+            original: (0, error_1.getError)(err),
+        });
+    }
+}
+exports.getReport = getReport;

package/lib/crashlytics/types.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadState = exports.Signal = exports.State = exports.SessionEventType = exports.FormFactor = exports.TrackType = exports.ErrorType = void 0;
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["ERROR_TYPE_UNSPECIFIED"] = "ERROR_TYPE_UNSPECIFIED";
+    ErrorType["FATAL"] = "FATAL";
+    ErrorType["NON_FATAL"] = "NON_FATAL";
+    ErrorType["ANR"] = "ANR";
+})(ErrorType = exports.ErrorType || (exports.ErrorType = {}));
+var TrackType;
+(function (TrackType) {
+    TrackType["TRACK_TYPE_UNSPECIFIED"] = "TRACK_TYPE_UNSPECIFIED";
+    TrackType["TRACK_TYPE_PROD"] = "TRACK_TYPE_PROD";
+    TrackType["TRACK_TYPE_INTERNAL"] = "TRACK_TYPE_INTERNAL";
+    TrackType["TRACK_TYPE_OPEN_TESTING"] = "TRACK_TYPE_OPEN_TESTING";
+    TrackType["TRACK_TYPE_CLOSED_TESTING"] = "TRACK_TYPE_CLOSED_TESTING";
+    TrackType["TRACK_TYPE_EARLY_ACCESS"] = "TRACK_TYPE_EARLY_ACCESS";
+})(TrackType = exports.TrackType || (exports.TrackType = {}));
+var FormFactor;
+(function (FormFactor) {
+    FormFactor["FORM_FACTOR_UNSPECIFIED"] = "FORM_FACTOR_UNSPECIFIED";
+    FormFactor["PHONE"] = "PHONE";
+    FormFactor["TABLET"] = "TABLET";
+    FormFactor["DESKTOP"] = "DESKTOP";
+    FormFactor["TV"] = "TV";
+    FormFactor["WATCH"] = "WATCH";
+})(FormFactor = exports.FormFactor || (exports.FormFactor = {}));
+var SessionEventType;
+(function (SessionEventType) {
+    SessionEventType["SESSION_EVENT_TYPE_UNKNOWN"] = "SESSION_EVENT_TYPE_UNKNOWN";
+    SessionEventType["SESSION_START"] = "SESSION_START";
+})(SessionEventType = exports.SessionEventType || (exports.SessionEventType = {}));
+var State;
+(function (State) {
+    State["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
+    State["OPEN"] = "OPEN";
+    State["CLOSED"] = "CLOSED";
+    State["MUTED"] = "MUTED";
+})(State = exports.State || (exports.State = {}));
+var Signal;
+(function (Signal) {
+    Signal["SIGNAL_UNSPECIFIED"] = "SIGNAL_UNSPECIFIED";
+    Signal["SIGNAL_EARLY"] = "SIGNAL_EARLY";
+    Signal["SIGNAL_FRESH"] = "SIGNAL_FRESH";
+    Signal["SIGNAL_REGRESSED"] = "SIGNAL_REGRESSED";
+    Signal["SIGNAL_REPETITIVE"] = "SIGNAL_REPETITIVE";
+})(Signal = exports.Signal || (exports.Signal = {}));
+var ThreadState;
+(function (ThreadState) {
+    ThreadState["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
+    ThreadState["THREAD_STATE_TERMINATED"] = "THREAD_STATE_TERMINATED";
+    ThreadState["THREAD_STATE_RUNNABLE"] = "THREAD_STATE_RUNNABLE";
+    ThreadState["THREAD_STATE_TIMED_WAITING"] = "THREAD_STATE_TIMED_WAITING";
+    ThreadState["THREAD_STATE_BLOCKED"] = "THREAD_STATE_BLOCKED";
+    ThreadState["THREAD_STATE_WAITING"] = "THREAD_STATE_WAITING";
+    ThreadState["THREAD_STATE_NEW"] = "THREAD_STATE_NEW";
+    ThreadState["THREAD_STATE_NATIVE_RUNNABLE"] = "THREAD_STATE_NATIVE_RUNNABLE";
+    ThreadState["THREAD_STATE_NATIVE_WAITING"] = "THREAD_STATE_NATIVE_WAITING";
+})(ThreadState = exports.ThreadState || (exports.ThreadState = {}));

package/lib/dataconnect/ensureApis.js

@@ -4,10 +4,10 @@ exports.ensureGIFApis = exports.ensureApis = void 0;
 const api = require("../api");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const prefix = "dataconnect";
-async function ensureApis(projectId) {
+async function ensureApis(projectId, silent = false) {
     await Promise.all([
-        (0, ensureApiEnabled_1.ensure)(projectId, api.dataconnectOrigin(), prefix),
-        (0, ensureApiEnabled_1.ensure)(projectId, api.cloudSQLAdminOrigin(), prefix),
+        (0, ensureApiEnabled_1.ensure)(projectId, api.dataconnectOrigin(), prefix, silent),
+        (0, ensureApiEnabled_1.ensure)(projectId, api.cloudSQLAdminOrigin(), prefix, silent),
     ]);
 }
 exports.ensureApis = ensureApis;

package/lib/deploy/apphosting/deploy.js

@@ -60,7 +60,8 @@ async function default_1(context, options) {
         }
     }
     for (const cfg of context.backendConfigs.values()) {
-        const { projectSourcePath, zippedSourcePath } = await (0, util_1.createArchive)(cfg, options.projectRoot);
+        const projectSourcePath = options.projectRoot ? options.projectRoot : process.cwd();
+        const zippedSourcePath = await (0, util_1.createArchive)(cfg, projectSourcePath);
         const backendLocation = context.backendLocations.get(cfg.backendId);
         if (!backendLocation) {
             throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);