firebase-tools 13.8.3 → 13.10.0

package/lib/dataconnect/client.js

@@ -56,7 +56,7 @@ async function createService(projectId, locationId, serviceId) {
 }
 exports.createService = createService;
 async function deleteService(projectId, locationId, serviceId) {
-    const op = await dataconnectClient().delete(`projects/${projectId}/locations/${locationId}/services/${serviceId}?force=true`);
+    const op = await dataconnectClient().delete(`projects/${projectId}/locations/${locationId}/services/${serviceId}`);
     const pollRes = await operationPoller.pollOperation({
         apiOrigin: (0, api_1.dataconnectOrigin)(),
         apiVersion: DATACONNECT_API_VERSION,

package/lib/dataconnect/errors.js

@@ -5,27 +5,35 @@ const INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING = "IncompatibleSqlSchemaError";
 const PRECONDITION_ERROR_TYPESTRING = "type.googleapis.com/google.rpc.PreconditionFailure";
 const INCOMPATIBLE_CONNECTOR_TYPE = "INCOMPATIBLE_CONNECTOR";
 function getIncompatibleSchemaError(err) {
-    var _a, _b;
-    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || err.orignal;
-    if (!original) {
-        throw err;
+    const incompatibles = errorDetails(err, INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING);
+    if (incompatibles.length === 0) {
+        return undefined;
     }
-    const details = original.details;
-    const incompatibles = details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING); });
-    return incompatibles[0];
+    const incompatible = incompatibles[0];
+    const preconditionErrs = errorDetails(err, PRECONDITION_ERROR_TYPESTRING);
+    const violationTypes = (incompatible.violationType = preconditionErrs
+        .flatMap((preCondErr) => preCondErr.violations)
+        .flatMap((viol) => viol.type)
+        .filter((type) => type === "INACCESSIBLE_SCHEMA" || type === "INCOMPATIBLE_SCHEMA"));
+    incompatible.violationType = violationTypes[0];
+    return incompatible;
 }
 exports.getIncompatibleSchemaError = getIncompatibleSchemaError;
 function getInvalidConnectors(err) {
-    var _a, _b, _c, _d;
+    var _a, _b;
+    const preconditionErrs = errorDetails(err, PRECONDITION_ERROR_TYPESTRING);
     const invalidConns = [];
-    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || (err === null || err === void 0 ? void 0 : err.orignal);
-    const details = original === null || original === void 0 ? void 0 : original.details;
-    const preconditionErrs = details === null || details === void 0 ? void 0 : details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(PRECONDITION_ERROR_TYPESTRING); });
     for (const preconditionErr of preconditionErrs) {
-        const incompatibleConnViolation = (_c = preconditionErr === null || preconditionErr === void 0 ? void 0 : preconditionErr.violations) === null || _c === void 0 ? void 0 : _c.filter((v) => v.type === INCOMPATIBLE_CONNECTOR_TYPE);
-        const newConns = (_d = incompatibleConnViolation === null || incompatibleConnViolation === void 0 ? void 0 : incompatibleConnViolation.map((i) => i.subject)) !== null && _d !== void 0 ? _d : [];
+        const incompatibleConnViolation = (_a = preconditionErr === null || preconditionErr === void 0 ? void 0 : preconditionErr.violations) === null || _a === void 0 ? void 0 : _a.filter((v) => v.type === INCOMPATIBLE_CONNECTOR_TYPE);
+        const newConns = (_b = incompatibleConnViolation === null || incompatibleConnViolation === void 0 ? void 0 : incompatibleConnViolation.map((i) => i.subject)) !== null && _b !== void 0 ? _b : [];
         invalidConns.push(...newConns);
     }
     return invalidConns;
 }
 exports.getInvalidConnectors = getInvalidConnectors;
+function errorDetails(err, ofType) {
+    var _a, _b;
+    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || (err === null || err === void 0 ? void 0 : err.original);
+    const details = original === null || original === void 0 ? void 0 : original.details;
+    return (details === null || details === void 0 ? void 0 : details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(ofType); })) || [];
+}

package/lib/dataconnect/provisionCloudSql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkInstanceConfig = exports.provisionCloudSql = void 0;
+exports.getUpdateReason = exports.provisionCloudSql = void 0;
 const cloudSqlAdminClient = require("../gcp/cloudsql/cloudsqladmin");
 const utils = require("../utils");
 const checkIam_1 = require("./checkIam");
@@ -15,10 +15,12 @@ async function provisionCloudSql(args) {
         const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
         silent || utils.logLabeledBullet("dataconnect", `Found existing instance ${instanceId}.`);
         connectionName = (existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.connectionName) || "";
-        if (!checkInstanceConfig(existingInstance, enableGoogleMlIntegration)) {
+        const why = getUpdateReason(existingInstance, enableGoogleMlIntegration);
+        if (why) {
             silent ||
                 utils.logLabeledBullet("dataconnect", `Instance ${instanceId} settings not compatible with Firebase Data Connect. ` +
-                    `Updating instance to enable Cloud IAM authentication and public IP. This may take a few minutes...`);
+                    `Updating instance. This may take a few minutes...` +
+                    why);
             await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.updateInstanceForDataConnect(existingInstance, enableGoogleMlIntegration), "Updating your instance...");
             silent || utils.logLabeledBullet("dataconnect", "Instance updated");
         }
@@ -44,10 +46,15 @@ async function provisionCloudSql(args) {
         silent || utils.logLabeledBullet("dataconnect", `Found existing database ${databaseId}.`);
     }
     catch (err) {
-        silent ||
-            utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
-        await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
-        silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+        if (err.status === 404) {
+            silent ||
+                utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
+            await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
+            silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+        }
+        else {
+            silent || utils.logLabeledWarning("dataconnect", `Database ${databaseId} is not accessible.`);
+        }
     }
     if (enableGoogleMlIntegration) {
         await (0, checkIam_1.grantRolesToCloudSqlServiceAccount)(projectId, instanceId, [GOOGLE_ML_INTEGRATION_ROLE]);
@@ -55,21 +62,25 @@ async function provisionCloudSql(args) {
     return connectionName;
 }
 exports.provisionCloudSql = provisionCloudSql;
-function checkInstanceConfig(instance, requireGoogleMlIntegration) {
+function getUpdateReason(instance, requireGoogleMlIntegration) {
     var _a, _b, _c, _d;
+    let reason = "";
     const settings = instance.settings;
     if (!((_a = settings.ipConfiguration) === null || _a === void 0 ? void 0 : _a.ipv4Enabled)) {
-        return false;
+        reason += "\n - to enable public IP.";
     }
     if (requireGoogleMlIntegration) {
         if (!settings.enableGoogleMlIntegration) {
-            return false;
+            reason += "\n - to enable Google ML integration.";
         }
         if (!((_b = settings.databaseFlags) === null || _b === void 0 ? void 0 : _b.some((f) => f.name === "cloudsql.enable_google_ml_integration" && f.value === "on"))) {
-            return false;
+            reason += "\n - to enable Google ML integration database flag.";
         }
     }
     const isIamEnabled = (_d = (_c = settings.databaseFlags) === null || _c === void 0 ? void 0 : _c.some((f) => f.name === "cloudsql.iam_authentication" && f.value === "on")) !== null && _d !== void 0 ? _d : false;
-    return isIamEnabled;
+    if (!isIamEnabled) {
+        reason += "\n - to enable IAM authentication database flag.";
+    }
+    return reason;
 }
-exports.checkInstanceConfig = checkInstanceConfig;
+exports.getUpdateReason = getUpdateReason;

package/lib/dataconnect/schemaMigration.js

@@ -14,44 +14,49 @@ const utils_1 = require("../utils");
 const errors = require("./errors");
 async function diffSchema(schema) {
     const { serviceName, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     try {
         await (0, client_1.upsertSchema)(schema, true);
+        (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is up to date.`);
     }
     catch (err) {
+        if (err.status !== 400) {
+            throw err;
+        }
         const invalidConnectors = errors.getInvalidConnectors(err);
+        const incompatible = errors.getIncompatibleSchemaError(err);
+        if (!incompatible && !invalidConnectors.length) {
+            throw err;
+        }
         if (invalidConnectors.length) {
             displayInvalidConnectors(invalidConnectors);
         }
-        const incompatible = errors.getIncompatibleSchemaError(err);
         if (incompatible) {
             displaySchemaChanges(incompatible);
             return incompatible.diffs;
         }
     }
-    (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is up to date.`);
     return [];
 }
 exports.diffSchema = diffSchema;
 async function migrateSchema(args) {
     const { options, schema, allowNonInteractiveMigration, validateOnly } = args;
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
         logger_1.logger.debug(`Database schema was up to date for ${instanceId}:${databaseId}`);
     }
     catch (err) {
+        if (err.status !== 400) {
+            throw err;
+        }
         const incompatible = errors.getIncompatibleSchemaError(err);
         const invalidConnectors = errors.getInvalidConnectors(err);
         if (!incompatible && !invalidConnectors.length) {
             throw err;
         }
-        const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, invalidConnectors, validateOnly);
-        if (!shouldDeleteInvalidConnectors && invalidConnectors.length) {
-            const cmd = suggestedCommand(serviceName, invalidConnectors);
-            throw new error_1.FirebaseError(`Command aborted. Try deploying compatible connectors first with ${clc.bold(cmd)}`);
-        }
+        const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly);
         const migrationMode = incompatible
             ? await promptForSchemaMigration(options, databaseId, incompatible, allowNonInteractiveMigration)
             : "none";
@@ -68,10 +73,12 @@ async function migrateSchema(args) {
                 choice: migrationMode,
             });
         }
-        if (invalidConnectors.length) {
+        if (shouldDeleteInvalidConnectors) {
             await deleteInvalidConnectors(invalidConnectors);
         }
-        await (0, client_1.upsertSchema)(schema, validateOnly);
+        if (!validateOnly) {
+            await (0, client_1.upsertSchema)(schema, validateOnly);
+        }
         return diffs;
     }
     return [];
@@ -169,20 +176,26 @@ async function promptForSchemaMigration(options, databaseName, err, allowNonInte
         return "none";
     }
 }
-async function promptForInvalidConnectorError(options, invalidConnectors, validateOnly) {
+async function promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly) {
     if (!invalidConnectors.length) {
         return false;
     }
     displayInvalidConnectors(invalidConnectors);
     if (validateOnly) {
-        return false;
+        if (options.force) {
+            return false;
+        }
+        throw new error_1.FirebaseError(`Command aborted. If you'd like to migrate it anyway, you may override with --force.`);
+    }
+    if (options.force) {
+        return true;
     }
-    else if (options.force ||
-        (!options.nonInteractive &&
-            (await (0, prompt_1.confirm)(Object.assign(Object.assign({}, options), { message: "Would you like to delete and recreate these connectors?" }))))) {
+    if (!options.nonInteractive &&
+        (await (0, prompt_1.confirm)(Object.assign(Object.assign({}, options), { message: `Would you like to delete and recreate these connectors? This will cause ${clc.red(`downtime.`)}.` })))) {
         return true;
     }
-    return false;
+    const cmd = suggestedCommand(serviceName, invalidConnectors);
+    throw new error_1.FirebaseError(`Command aborted. Try deploying those connectors first with ${clc.bold(cmd)}`);
 }
 async function deleteInvalidConnectors(invalidConnectors) {
     return Promise.all(invalidConnectors.map(client_1.deleteConnector));
@@ -190,39 +203,48 @@ async function deleteInvalidConnectors(invalidConnectors) {
 function displayInvalidConnectors(invalidConnectors) {
     const connectorIds = invalidConnectors.map((i) => i.split("/").pop()).join(", ");
     (0, utils_1.logLabeledWarning)("dataconnect", `The schema you are deploying is incompatible with the following existing connectors: ${connectorIds}.`);
-    (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and will cause a brief downtime.`);
+    (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and may break existing apps.`);
 }
-async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, databaseId) {
+async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, databaseId, linkIfNotConnected) {
     let currentSchema;
     try {
         currentSchema = await (0, client_1.getSchema)(serviceName);
     }
     catch (err) {
-        if (err.status === 404) {
-            currentSchema = {
-                name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
-                source: {
-                    files: [],
-                },
-                primaryDatasource: {
-                    postgresql: {
-                        database: databaseId,
-                        cloudSql: {
-                            instance: instanceId,
-                        },
-                    },
-                },
-            };
-        }
-        else {
+        if (err.status !== 404) {
             throw err;
         }
+        if (!linkIfNotConnected) {
+            (0, utils_1.logLabeledWarning)("dataconnect", `Not yet linked to the Cloud SQL instance.`);
+            return;
+        }
+        (0, utils_1.logLabeledBullet)("dataconnect", `Linking the Cloud SQL instance...`);
+        currentSchema = {
+            name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
+            source: {
+                files: [],
+            },
+            primaryDatasource: {
+                postgresql: {
+                    database: databaseId,
+                    cloudSql: {
+                        instance: instanceId,
+                    },
+                },
+            },
+        };
     }
-    if (!currentSchema.primaryDatasource.postgresql ||
-        currentSchema.primaryDatasource.postgresql.schemaValidation === "STRICT") {
+    const postgresql = currentSchema.primaryDatasource.postgresql;
+    if ((postgresql === null || postgresql === void 0 ? void 0 : postgresql.cloudSql.instance) !== instanceId) {
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Cloud SQL instance\nFrom ${postgresql === null || postgresql === void 0 ? void 0 : postgresql.cloudSql.instance}\nTo ${instanceId}`);
+    }
+    if ((postgresql === null || postgresql === void 0 ? void 0 : postgresql.database) !== databaseId) {
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Postgres database from ${postgresql === null || postgresql === void 0 ? void 0 : postgresql.database} to ${databaseId}`);
+    }
+    if (!postgresql || postgresql.schemaValidation === "STRICT") {
         return;
     }
-    currentSchema.primaryDatasource.postgresql.schemaValidation = "STRICT";
+    postgresql.schemaValidation = "STRICT";
     try {
         await (0, client_1.upsertSchema)(currentSchema, false);
     }
@@ -234,10 +256,27 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
     }
 }
 function displaySchemaChanges(error) {
-    const message = "Your new schema is incompatible with the schema of your CloudSQL database. " +
-        "The following SQL statements will migrate your database schema to match your new Data Connect schema.\n" +
-        error.diffs.map(toString).join("\n");
-    (0, utils_1.logLabeledWarning)("dataconnect", message);
+    switch (error.violationType) {
+        case "INCOMPATIBLE_SCHEMA":
+            {
+                const message = "Your new schema is incompatible with the schema of your CloudSQL database. " +
+                    "The following SQL statements will migrate your database schema to match your new Data Connect schema.\n" +
+                    error.diffs.map(toString).join("\n");
+                (0, utils_1.logLabeledWarning)("dataconnect", message);
+            }
+            break;
+        case "INACCESSIBLE_SCHEMA":
+            {
+                const message = "Cannot access your CloudSQL database to validate schema. " +
+                    "The following SQL statements can setup a new database schema.\n" +
+                    error.diffs.map(toString).join("\n");
+                (0, utils_1.logLabeledWarning)("dataconnect", message);
+                (0, utils_1.logLabeledWarning)("dataconnect", "Some SQL resources may already exist.");
+            }
+            break;
+        default:
+            throw new error_1.FirebaseError(`Unknown schema violation type: ${error.violationType}, IncompatibleSqlSchemaError: ${error}`);
+    }
 }
 function toString(diff) {
     return `\/** ${diff.destructive ? clc.red("Destructive: ") : ""}${diff.description}*\/\n${(0, sql_formatter_1.format)(diff.sql, { language: "postgresql" })}`;

package/lib/deploy/functions/runtimes/discovery/index.js

@@ -11,6 +11,7 @@ const api = require("../../.../../../../api");
 const v1alpha1 = require("./v1alpha1");
 const error_1 = require("../../../../error");
 exports.readFileAsync = (0, util_1.promisify)(fs.readFile);
+const TIMEOUT_OVERRIDE_ENV_VAR = "FUNCTIONS_DISCOVERY_TIMEOUT";
 function yamlToBuild(yaml, project, region, runtime) {
     try {
         if (!yaml.specVersion) {
@@ -50,7 +51,7 @@ async function detectFromPort(port, project, runtime, timeout = 10000) {
     const timedOut = new Promise((resolve, reject) => {
         setTimeout(() => {
             reject(new error_1.FirebaseError("User code failed to load. Cannot determine backend specification"));
-        }, timeout);
+        }, +(process.env[TIMEOUT_OVERRIDE_ENV_VAR] || 0) * 1000 || timeout);
     });
     while (true) {
         try {

package/lib/emulator/downloadableEmulators.js

@@ -35,9 +35,9 @@ const EMULATOR_UPDATE_DETAILS = {
     ui: experiments.isEnabled("emulatoruisnapshot")
         ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }
         : {
-            version: "1.11.8",
-            expectedSize: 3523907,
-            expectedChecksum: "49f6dc1911dda9d10df62a6c09aaf9a0",
+            version: "1.12.1",
+            expectedSize: 3498269,
+            expectedChecksum: "a7f4398a00e5ca22abdcd78dc3877d00",
         },
     pubsub: {
         version: "0.8.2",

package/lib/experiments.js

@@ -88,7 +88,7 @@ exports.ALL_EXPERIMENTS = experiments({
     },
     apphosting: {
         shortDescription: "Allow CLI option for Frameworks",
-        default: false,
+        default: true,
         public: false,
     },
     dataconnect: {
@@ -99,6 +99,7 @@ exports.ALL_EXPERIMENTS = experiments({
     genkit: {
         shortDescription: "Enable Genkit related features.",
         fullDescription: "Enable Genkit related features.",
+        default: true,
         public: false,
     },
 });

package/lib/frameworks/next/utils.js

@@ -231,7 +231,6 @@ async function getProductionDistDirFiles(sourceDir, distDir) {
         cwd: (0, path_1.join)(sourceDir, distDir),
         nodir: true,
         absolute: false,
-        realpath: utils_2.IS_WINDOWS,
     }, (err, matches) => {
         if (err)
             reject(err);

package/lib/gcp/cloudsql/cloudsqladmin.js

@@ -42,6 +42,8 @@ async function createInstance(projectId, location, instanceId, enableGoogleMlInt
             userLabels: { "firebase-data-connect": "ft" },
             insightsConfig: {
                 queryInsightsEnabled: true,
+                queryPlansPerMinute: 5,
+                queryStringLength: 1024,
             },
         },
     });

package/lib/gcp/cloudsql/connect.js

@@ -16,7 +16,7 @@ async function execute(sqlStatements, opts) {
     const user = await cloudSqlAdminClient.getUser(opts.projectId, opts.instanceId, opts.username);
     const connectionName = instance.connectionName;
     if (!connectionName) {
-        throw new error_1.FirebaseError(`Could not get instance conection string for ${opts.instanceId}:${opts.databaseId}`);
+        throw new error_1.FirebaseError(`Could not get instance connection string for ${opts.instanceId}:${opts.databaseId}`);
     }
     let connector;
     let pool;
@@ -30,7 +30,7 @@ async function execute(sqlStatements, opts) {
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
                 authType: cloud_sql_connector_1.AuthTypes.IAM,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId }));
             break;
         }
         case "CLOUD_IAM_SERVICE_ACCOUNT": {
@@ -40,7 +40,7 @@ async function execute(sqlStatements, opts) {
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
                 authType: cloud_sql_connector_1.AuthTypes.IAM,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId }));
             break;
         }
         default: {
@@ -54,19 +54,22 @@ async function execute(sqlStatements, opts) {
                 instanceConnectionName: connectionName,
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, password: opts.password, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, password: opts.password, database: opts.databaseId }));
             break;
         }
     }
+    const conn = await pool.connect();
+    logFn(`Logged in as ${opts.username}`);
     for (const s of sqlStatements) {
-        logFn(`Executing: '${s}' as ${opts.username}`);
+        logFn(`Executing: '${s}'`);
         try {
-            await pool.query(s);
+            await conn.query(s);
         }
         catch (err) {
             throw new error_1.FirebaseError(`Error executing ${err}`);
         }
     }
+    conn.release();
     await pool.end();
     connector.close();
 }

package/lib/requireAuth.js

@@ -10,7 +10,6 @@ const logger_1 = require("./logger");
 const utils = require("./utils");
 const scopes = require("./scopes");
 const auth_1 = require("./auth");
-const monospace_1 = require("./monospace");
 const AUTH_ERROR_MESSAGE = `Command requires authentication, please run ${clc.bold("firebase login")}`;
 let authClient;
 function getAuthClient(config) {
@@ -21,6 +20,9 @@ function getAuthClient(config) {
     return authClient;
 }
 async function autoAuth(options, authScopes) {
+    if (process.env.MONOSPACE_ENV) {
+        throw new error_1.FirebaseError("autoAuth not yet implemented for IDX. Please run 'firebase login'");
+    }
     const client = getAuthClient({ scopes: authScopes, projectId: options.project });
     const token = await client.getAccessToken();
     token !== null ? apiv2.setAccessToken(token) : false;
@@ -32,13 +34,6 @@ async function autoAuth(options, authScopes) {
     catch (e) {
         logger_1.logger.debug(`Error getting account credentials.`);
     }
-    if (!options.isVSCE && (0, monospace_1.isMonospaceEnv)()) {
-        await (0, monospace_1.selectProjectInMonospace)({
-            projectRoot: options.config.projectDir,
-            project: options.project,
-            isVSCE: options.isVSCE,
-        });
-    }
     return clientEmail;
 }
 async function requireAuth(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "13.8.3",
+  "version": "13.10.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {
@@ -59,7 +59,7 @@
   },
   "dependencies": {
     "@google-cloud/cloud-sql-connector": "^1.2.3",
-    "@google-cloud/pubsub": "^3.0.1",
+    "@google-cloud/pubsub": "^4.4.0",
     "abort-controller": "^3.0.0",
     "ajv": "^6.12.6",
     "archiver": "^5.0.0",

package/lib/monospace/index.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMonospaceEnv = exports.selectProjectInMonospace = void 0;
-const node_fetch_1 = require("node-fetch");
-const error_1 = require("../error");
-const logger_1 = require("../logger");
-const rc_1 = require("../rc");
-const POLL_USER_RESPONSE_MILLIS = 2000;
-async function selectProjectInMonospace({ projectRoot, project, isVSCE, }) {
-    const initFirebaseResponse = await initFirebase(project);
-    if (initFirebaseResponse.success === false) {
-        throw new Error(String(initFirebaseResponse.error));
-    }
-    const { rid } = initFirebaseResponse;
-    const authorizedProject = await pollAuthorizedProject(rid);
-    if (!authorizedProject)
-        return null;
-    if (isVSCE)
-        return authorizedProject;
-    if (projectRoot)
-        createFirebaseRc(projectRoot, authorizedProject);
-}
-exports.selectProjectInMonospace = selectProjectInMonospace;
-async function pollAuthorizedProject(rid) {
-    const getInitFirebaseRes = await getInitFirebaseResponse(rid);
-    if ("userResponse" in getInitFirebaseRes) {
-        if (getInitFirebaseRes.userResponse.success) {
-            return getInitFirebaseRes.userResponse.projectId;
-        }
-        return null;
-    }
-    const { error } = getInitFirebaseRes;
-    if (error === "WAITING_FOR_RESPONSE") {
-        await new Promise((res) => setTimeout(res, POLL_USER_RESPONSE_MILLIS));
-        return pollAuthorizedProject(rid);
-    }
-    if (error === "USER_CANCELED") {
-        throw new error_1.FirebaseError("User canceled without authorizing any project");
-    }
-    throw new error_1.FirebaseError(`Unhandled /get-init-firebase-response error`, {
-        original: new Error(error),
-    });
-}
-async function initFirebase(project) {
-    const port = getMonospaceDaemonPort();
-    if (!port)
-        throw new error_1.FirebaseError("Undefined MONOSPACE_DAEMON_PORT");
-    const initFirebaseURL = new URL(`http://localhost:${port}/init-firebase`);
-    if (project) {
-        initFirebaseURL.searchParams.set("known_project", project);
-    }
-    const initFirebaseRes = await (0, node_fetch_1.default)(initFirebaseURL.toString(), {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-    });
-    const initFirebaseResponse = (await initFirebaseRes.json());
-    return initFirebaseResponse;
-}
-async function getInitFirebaseResponse(rid) {
-    const port = getMonospaceDaemonPort();
-    if (!port)
-        throw new error_1.FirebaseError("Undefined MONOSPACE_DAEMON_PORT");
-    const getInitFirebaseRes = await (0, node_fetch_1.default)(`http://localhost:${port}/get-init-firebase-response?rid=${rid}`);
-    const getInitFirebaseJson = (await getInitFirebaseRes.json());
-    logger_1.logger.debug(`/get-init-firebase-response?rid=${rid} response:`);
-    logger_1.logger.debug(getInitFirebaseJson);
-    return getInitFirebaseJson;
-}
-function createFirebaseRc(projectDir, authorizedProject) {
-    const firebaseRc = (0, rc_1.loadRC)({ cwd: projectDir });
-    firebaseRc.addProjectAlias("default", authorizedProject);
-    return firebaseRc.save();
-}
-function isMonospaceEnv() {
-    return getMonospaceDaemonPort() !== undefined;
-}
-exports.isMonospaceEnv = isMonospaceEnv;
-function getMonospaceDaemonPort() {
-    return process.env.MONOSPACE_DAEMON_PORT;
-}

package/lib/monospace/interfaces.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });