firebase-tools 12.3.1 → 12.4.1

package/lib/frameworks/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareFrameworks = exports.discover = exports.WebFrameworks = void 0;
+exports.prepareFrameworks = exports.generateSSRCodebaseId = exports.discover = exports.WebFrameworks = void 0;
 const path_1 = require("path");
 const process_1 = require("process");
 const child_process_1 = require("child_process");
@@ -25,21 +25,22 @@ const experiments = require("../experiments");
 const implicitInit_1 = require("../hosting/implicitInit");
 const utils_1 = require("./utils");
 const constants_2 = require("./constants");
-Object.defineProperty(exports, "WebFrameworks", { enumerable: true, get: function () { return constants_2.WebFrameworks; } });
 const utils_2 = require("../utils");
 const ensureTargeted_1 = require("../functions/ensureTargeted");
 const util_1 = require("util");
 const projectPath_1 = require("../projectPath");
 const logger_1 = require("../logger");
+const frameworks_1 = require("./frameworks");
+Object.defineProperty(exports, "WebFrameworks", { enumerable: true, get: function () { return frameworks_1.WebFrameworks; } });
 async function discover(dir, warn = true) {
     const allFrameworkTypes = [
-        ...new Set(Object.values(constants_2.WebFrameworks).map(({ type }) => type)),
+        ...new Set(Object.values(frameworks_1.WebFrameworks).map(({ type }) => type)),
     ].sort();
     for (const discoveryType of allFrameworkTypes) {
         const frameworksDiscovered = [];
-        for (const framework in constants_2.WebFrameworks) {
-            if (constants_2.WebFrameworks[framework]) {
-                const { discover, type } = constants_2.WebFrameworks[framework];
+        for (const framework in frameworks_1.WebFrameworks) {
+            if (frameworks_1.WebFrameworks[framework]) {
+                const { discover, type } = frameworks_1.WebFrameworks[framework];
                 if (type !== discoveryType)
                     continue;
                 const result = await discover(dir);
@@ -72,6 +73,10 @@ function memoizeBuild(dir, build, deps, target) {
     BUILD_MEMO.set(key, value);
     return value;
 }
+function generateSSRCodebaseId(site) {
+    return `firebase-frameworks-${site}`;
+}
+exports.generateSSRCodebaseId = generateSSRCodebaseId;
 async function prepareFrameworks(purpose, targetNames, context, options, emulators = []) {
     var _a, _b, _c, _d, _e, _f;
     var _g, _h, _j, _k, _l;
@@ -185,7 +190,7 @@ async function prepareFrameworks(purpose, targetNames, context, options, emulato
             throw new error_1.FirebaseError((0, utils_1.frameworksCallToAction)("Unable to detect the web framework in use, check firebase-debug.log for more info."));
         }
         const { framework, mayWantBackend, publicDirectory } = results;
-        const { build, ɵcodegenPublicDirectory, ɵcodegenFunctionsDirectory: codegenProdModeFunctionsDirectory, getDevModeHandle, name, support, docsUrl, getValidBuildTargets = constants_2.GET_DEFAULT_BUILD_TARGETS, shouldUseDevModeHandle = constants_2.DEFAULT_SHOULD_USE_DEV_MODE_HANDLE, } = constants_2.WebFrameworks[framework];
+        const { build, ɵcodegenPublicDirectory, ɵcodegenFunctionsDirectory: codegenProdModeFunctionsDirectory, getDevModeHandle, name, support, docsUrl, getValidBuildTargets = constants_2.GET_DEFAULT_BUILD_TARGETS, shouldUseDevModeHandle = constants_2.DEFAULT_SHOULD_USE_DEV_MODE_HANDLE, } = frameworks_1.WebFrameworks[framework];
         logger_1.logger.info(`\n${(0, utils_1.frameworksCallToAction)(constants_2.SupportLevelWarnings[support](name), docsUrl, "   ")}\n`);
         const hostingEmulatorInfo = emulators.find((e) => e.name === types_1.Emulators.HOSTING);
         const validBuildTargets = await getValidBuildTargets(purpose, getProjectPath());
@@ -242,7 +247,7 @@ async function prepareFrameworks(purpose, targetNames, context, options, emulato
             if (context === null || context === void 0 ? void 0 : context.hostingChannel) {
                 experiments.assertEnabled("pintags", "deploy an app that requires a backend to a preview channel");
             }
-            const codebase = `firebase-frameworks-${site}`;
+            const codebase = generateSSRCodebaseId(site);
             const existingFunctionsConfig = options.config.get("functions")
                 ? [].concat(options.config.get("functions"))
                 : [];

package/lib/frameworks/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFrameworksBuildTarget = exports.validateLocales = exports.frameworksCallToAction = exports.conjoinOptions = exports.relativeRequire = exports.findDependency = exports.getNodeModuleBin = exports.getNpmRoot = exports.simpleProxy = exports.warnIfCustomBuildScript = exports.readJSON = exports.isUrl = void 0;
+exports.getFrameworksBuildTarget = exports.validateLocales = exports.frameworksCallToAction = exports.conjoinOptions = exports.relativeRequire = exports.findDependency = exports.getNodeModuleBin = exports.getNpmRoot = exports.simpleProxy = exports.proxyResponse = exports.warnIfCustomBuildScript = exports.readJSON = exports.isUrl = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const promises_1 = require("fs/promises");
@@ -32,21 +32,51 @@ async function warnIfCustomBuildScript(dir, framework, defaultBuildScripts) {
     }
 }
 exports.warnIfCustomBuildScript = warnIfCustomBuildScript;
-function proxyResponse(original, next) {
-    return (response) => {
-        const { statusCode, statusMessage } = response;
-        if (!statusCode) {
-            original.end();
-            return;
-        }
-        if (statusCode === 404) {
-            return next();
-        }
-        const headers = "getHeaders" in response ? response.getHeaders() : response.headers;
-        original.writeHead(statusCode, statusMessage, headers);
-        response.pipe(original);
-    };
+function proxyResponse(req, res, next) {
+    const proxiedRes = new http_1.ServerResponse(req);
+    const buffer = [];
+    proxiedRes.write = new Proxy(proxiedRes.write.bind(proxiedRes), {
+        apply: (target, thisArg, args) => {
+            target.call(thisArg, ...args);
+            buffer.push(["write", args]);
+        },
+    });
+    proxiedRes.setHeader = new Proxy(proxiedRes.setHeader.bind(proxiedRes), {
+        apply: (target, thisArg, args) => {
+            target.call(thisArg, ...args);
+            buffer.push(["setHeader", args]);
+        },
+    });
+    proxiedRes.removeHeader = new Proxy(proxiedRes.removeHeader.bind(proxiedRes), {
+        apply: (target, thisArg, args) => {
+            target.call(thisArg, ...args);
+            buffer.push(["removeHeader", args]);
+        },
+    });
+    proxiedRes.writeHead = new Proxy(proxiedRes.writeHead.bind(proxiedRes), {
+        apply: (target, thisArg, args) => {
+            target.call(thisArg, ...args);
+            buffer.push(["writeHead", args]);
+        },
+    });
+    proxiedRes.end = new Proxy(proxiedRes.end.bind(proxiedRes), {
+        apply: (target, thisArg, args) => {
+            target.call(thisArg, ...args);
+            if (proxiedRes.statusCode === 404) {
+                next();
+            }
+            else {
+                for (const [fn, args] of buffer) {
+                    res[fn](...args);
+                }
+                res.end(...args);
+                buffer.length = 0;
+            }
+        },
+    });
+    return proxiedRes;
 }
+exports.proxyResponse = proxyResponse;
 function simpleProxy(hostOrRequestHandler) {
     const agent = new http_1.Agent({ keepAlive: true });
     const firebaseDefaultsJSON = process.env.__FIREBASE_DEFAULTS__;
@@ -91,9 +121,8 @@ function simpleProxy(hostOrRequestHandler) {
             });
         }
         else {
-            await Promise.resolve(hostOrRequestHandler(originalReq, originalRes, next));
-            const proxiedRes = new http_1.ServerResponse(originalReq);
-            proxyResponse(originalRes, next)(proxiedRes);
+            const proxiedRes = proxyResponse(originalReq, originalRes, next);
+            await hostOrRequestHandler(originalReq, proxiedRes, next);
         }
     };
 }
@@ -153,12 +182,13 @@ function findDependency(name, options = {}) {
 exports.findDependency = findDependency;
 function relativeRequire(dir, mod) {
     try {
-        const path = require.resolve(mod, { paths: [dir] });
+        const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+        const path = requireFunc.resolve(mod, { paths: [dir] });
         if ((0, path_1.extname)(path) === ".mjs") {
             return dynamicImport((0, url_1.pathToFileURL)(path).toString());
         }
         else {
-            return require(path);
+            return requireFunc(path);
         }
     }
     catch (e) {

package/lib/functionsConfig.js

@@ -82,7 +82,7 @@ exports.setVariablesRecursive = setVariablesRecursive;
 async function materializeConfig(configName, output) {
     const materializeVariable = async function (varName) {
         const variable = await runtimeconfig.variables.get(varName);
-        const id = exports.varNameToIds(variable.name);
+        const id = varNameToIds(variable.name);
         const key = id.config + "." + id.variable.split("/").join(".");
         _.set(output, key, variable.text);
     };
@@ -106,7 +106,7 @@ async function materializeAll(projectId) {
         if (config.name.match(new RegExp("configs/firebase"))) {
             return;
         }
-        return exports.materializeConfig(config.name, output);
+        return materializeConfig(config.name, output);
     }));
     return output;
 }

package/lib/gcp/cloudbuild.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRepository = exports.getRepository = exports.createRepository = exports.fetchLinkableRepositories = exports.deleteConnection = exports.getConnection = exports.createConnection = void 0;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+const client = new apiv2_1.Client({
+    urlPrefix: api_1.cloudbuildOrigin,
+    auth: true,
+    apiVersion: "v2",
+});
+async function createConnection(projectId, location, connectionId) {
+    const res = await client.post(`projects/${projectId}/locations/${location}/connections`, { githubConfig: {} }, { queryParams: { connectionId } });
+    return res.body;
+}
+exports.createConnection = createConnection;
+async function getConnection(projectId, location, connectionId) {
+    const name = `projects/${projectId}/locations/${location}/connections/${connectionId}`;
+    const res = await client.get(name);
+    return res.body;
+}
+exports.getConnection = getConnection;
+async function deleteConnection(projectId, location, connectionId) {
+    const name = `projects/${projectId}/locations/${location}/connections/${connectionId}`;
+    const res = await client.delete(name);
+    return res.body;
+}
+exports.deleteConnection = deleteConnection;
+async function fetchLinkableRepositories(projectId, location, connectionId) {
+    const name = `projects/${projectId}/locations/${location}/connections/${connectionId}:fetchLinkableRepositories`;
+    const res = await client.get(name);
+    return res.body;
+}
+exports.fetchLinkableRepositories = fetchLinkableRepositories;
+async function createRepository(projectId, location, connectionId, repositoryId, remoteUri) {
+    const res = await client.post(`projects/${projectId}/locations/${location}/connections/${connectionId}/repositories`, { remoteUri }, { queryParams: { repositoryId } });
+    return res.body;
+}
+exports.createRepository = createRepository;
+async function getRepository(projectId, location, connectionId, repositoryId) {
+    const name = `projects/${projectId}/locations/${location}/connections/${connectionId}/repositories/${repositoryId}`;
+    const res = await client.get(name);
+    return res.body;
+}
+exports.getRepository = getRepository;
+async function deleteRepository(projectId, location, connectionId, repositoryId) {
+    const name = `projects/${projectId}/locations/${location}/connections/${connectionId}/repositories/${repositoryId}`;
+    const res = await client.delete(name);
+    return res.body;
+}
+exports.deleteRepository = deleteRepository;

package/lib/gcp/storage.js

@@ -4,17 +4,18 @@ exports.getServiceAccount = exports.listBuckets = exports.getBucket = exports.de
 const path = require("path");
 const api_1 = require("../api");
 const apiv2_1 = require("../apiv2");
-const logger_1 = require("../logger");
 const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projects_1 = require("../management/projects");
 async function getDefaultBucket(projectId) {
+    var _a;
     try {
-        const appengineClient = new apiv2_1.Client({ urlPrefix: api_1.appengineOrigin, apiVersion: "v1" });
-        const resp = await appengineClient.get(`/apps/${projectId}`);
-        if (resp.body.defaultBucket === "undefined") {
+        const metadata = await (0, projects_1.getFirebaseProject)(projectId);
+        if (!((_a = metadata.resources) === null || _a === void 0 ? void 0 : _a.storageBucket)) {
             logger_1.logger.debug("Default storage bucket is undefined.");
             throw new error_1.FirebaseError("Your project is being set up. Please wait a minute before deploying again.");
         }
-        return resp.body.defaultBucket;
+        return metadata.resources.storageBucket;
     }
     catch (err) {
         logger_1.logger.info("\n\nThere was an issue deploying your functions. Verify that your project has a Google App Engine instance setup at https://console.cloud.google.com/appengine and try again. If this issue persists, please contact support.");

package/lib/init/features/composer/repo.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateRepository = exports.getOrCreateConnection = exports.linkGitHubRepository = void 0;
+const api_1 = require("../../../api");
+const error_1 = require("../../../error");
+const gcb = require("../../../gcp/cloudbuild");
+const logger_1 = require("../../../logger");
+const poller = require("../../../operation-poller");
+const utils = require("../../../utils");
+const prompt_1 = require("../../../prompt");
+const gcbPollerOptions = {
+    apiOrigin: api_1.cloudbuildOrigin,
+    apiVersion: "v2",
+    masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
+};
+function extractRepoSlugFromURI(remoteUri) {
+    const match = /github.com\/(.+).git/.exec(remoteUri);
+    if (!match) {
+        return undefined;
+    }
+    return match[1];
+}
+function generateConnectionId(stackId) {
+    return `composer-${stackId}-conn`;
+}
+function generateRepositoryId() {
+    return `composer-repo`;
+}
+async function linkGitHubRepository(projectId, location, stackId) {
+    const connectionId = generateConnectionId(stackId);
+    await getOrCreateConnection(projectId, location, connectionId);
+    let remoteUri = await promptRepositoryURI(projectId, location, connectionId);
+    while (remoteUri === "") {
+        await utils.openInBrowser("https://github.com/apps/google-cloud-build/installations/new");
+        await (0, prompt_1.promptOnce)({
+            type: "input",
+            message: "Press any key once you have finished configuring your installation's access settings.",
+        });
+        remoteUri = await promptRepositoryURI(projectId, location, connectionId);
+    }
+    const repo = await getOrCreateRepository(projectId, location, connectionId, remoteUri);
+    logger_1.logger.info(`Successfully linked GitHub repository at remote URI ${remoteUri}.`);
+    return repo;
+}
+exports.linkGitHubRepository = linkGitHubRepository;
+async function promptRepositoryURI(projectId, location, connectionId) {
+    const resp = await gcb.fetchLinkableRepositories(projectId, location, connectionId);
+    if (!resp.repositories || resp.repositories.length === 0) {
+        throw new error_1.FirebaseError("The GitHub App does not have access to any repositories. Please configure " +
+            "your app installation permissions at https://github.com/settings/installations.");
+    }
+    const choices = resp.repositories.map((repo) => ({
+        name: extractRepoSlugFromURI(repo.remoteUri) || repo.remoteUri,
+        value: repo.remoteUri,
+    }));
+    choices.push({
+        name: "Missing a repo? Select this option to configure your installation's access settings",
+        value: "",
+    });
+    return await (0, prompt_1.promptOnce)({
+        type: "list",
+        message: "Which of the following repositories would you like to link?",
+        choices,
+    });
+}
+async function promptConnectionAuth(conn, projectId, location, connectionId) {
+    logger_1.logger.info(conn.installationState.message);
+    logger_1.logger.info(conn.installationState.actionUri);
+    await utils.openInBrowser(conn.installationState.actionUri);
+    await (0, prompt_1.promptOnce)({
+        type: "input",
+        message: "Press any key once you have authorized the app (Cloud Build) to access your GitHub repo.",
+    });
+    return await gcb.getConnection(projectId, location, connectionId);
+}
+async function getOrCreateConnection(projectId, location, connectionId) {
+    let conn;
+    try {
+        conn = await gcb.getConnection(projectId, location, connectionId);
+    }
+    catch (err) {
+        if (err.status === 404) {
+            const op = await gcb.createConnection(projectId, location, connectionId);
+            conn = await poller.pollOperation(Object.assign(Object.assign({}, gcbPollerOptions), { pollerName: `create-${location}-${connectionId}`, operationResourceName: op.name }));
+        }
+        else {
+            throw err;
+        }
+    }
+    while (conn.installationState.stage !== "COMPLETE") {
+        conn = await promptConnectionAuth(conn, projectId, location, connectionId);
+    }
+    return conn;
+}
+exports.getOrCreateConnection = getOrCreateConnection;
+async function getOrCreateRepository(projectId, location, connectionId, remoteUri) {
+    const repositoryId = generateRepositoryId();
+    if (!repositoryId) {
+        throw new error_1.FirebaseError(`Failed to generate repositoryId for URI "${remoteUri}".`);
+    }
+    let repo;
+    try {
+        repo = await gcb.getRepository(projectId, location, connectionId, repositoryId);
+        const repoSlug = extractRepoSlugFromURI(repo.remoteUri);
+        if (repoSlug) {
+            throw new error_1.FirebaseError(`${repoSlug} has already been linked.`);
+        }
+    }
+    catch (err) {
+        if (err.status === 404) {
+            const op = await gcb.createRepository(projectId, location, connectionId, repositoryId, remoteUri);
+            repo = await poller.pollOperation(Object.assign(Object.assign({}, gcbPollerOptions), { pollerName: `create-${location}-${connectionId}-${repositoryId}`, operationResourceName: op.name }));
+        }
+        else {
+            throw err;
+        }
+    }
+    return repo;
+}
+exports.getOrCreateRepository = getOrCreateRepository;

package/lib/init/features/frameworks/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_DEPLOY_METHODS = exports.DEFAULT_DEPLOY_METHOD = exports.ALLOWED_REGIONS = exports.DEFAULT_REGION = void 0;
+exports.DEFAULT_REGION = "us-central1";
+exports.ALLOWED_REGIONS = [{ name: "us-central1 (Iowa)", value: "us-central1" }];
+exports.DEFAULT_DEPLOY_METHOD = "github";
+exports.ALLOWED_DEPLOY_METHODS = [{ name: "Deploy using github", value: "github" }];

package/lib/init/features/frameworks/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doSetup = void 0;
+const clc = require("colorette");
+const utils = require("../../../utils");
+const logger_1 = require("../../../logger");
+const prompt_1 = require("../../../prompt");
+const constants_1 = require("./constants");
+async function doSetup(setup) {
+    setup.frameworks = {};
+    utils.logBullet("First we need a few details to create your service.");
+    await (0, prompt_1.promptOnce)({
+        name: "serviceName",
+        type: "input",
+        default: "acme-inc-web",
+        message: "Create a name for your service [6-32 characters]",
+    }, setup.frameworks);
+    await (0, prompt_1.promptOnce)({
+        name: "region",
+        type: "list",
+        default: constants_1.DEFAULT_REGION,
+        message: "Please select a region " +
+            `(${clc.yellow("info")}: Your region determines where your backend is located):\n`,
+        choices: constants_1.ALLOWED_REGIONS,
+    }, setup.frameworks);
+    utils.logSuccess(`Region set to ${setup.frameworks.region}.`);
+    logger_1.logger.info(clc.bold(`\n${clc.white("===")} Deploy Setup`));
+    await (0, prompt_1.promptOnce)({
+        name: "deployMethod",
+        type: "list",
+        default: constants_1.DEFAULT_DEPLOY_METHOD,
+        message: "How do you want to deploy",
+        choices: constants_1.ALLOWED_DEPLOY_METHODS,
+    }, setup.frameworks);
+}
+exports.doSetup = doSetup;

package/lib/init/features/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hostingGithub = exports.remoteconfig = exports.project = exports.extensions = exports.emulators = exports.storage = exports.hosting = exports.functions = exports.firestore = exports.database = exports.account = void 0;
+exports.frameworks = exports.hostingGithub = exports.remoteconfig = exports.project = exports.extensions = exports.emulators = exports.storage = exports.hosting = exports.functions = exports.firestore = exports.database = exports.account = void 0;
 var account_1 = require("./account");
 Object.defineProperty(exports, "account", { enumerable: true, get: function () { return account_1.doSetup; } });
 var database_1 = require("./database");
@@ -23,3 +23,5 @@ var remoteconfig_1 = require("./remoteconfig");
 Object.defineProperty(exports, "remoteconfig", { enumerable: true, get: function () { return remoteconfig_1.doSetup; } });
 var github_1 = require("./hosting/github");
 Object.defineProperty(exports, "hostingGithub", { enumerable: true, get: function () { return github_1.initGitHub; } });
+var frameworks_1 = require("./frameworks");
+Object.defineProperty(exports, "frameworks", { enumerable: true, get: function () { return frameworks_1.doSetup; } });

package/lib/init/index.js

@@ -6,6 +6,7 @@ const clc = require("colorette");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
 const features = require("./features");
+const experiments_1 = require("../experiments");
 const featureFns = new Map([
     ["account", features.account],
     ["database", features.database],
@@ -19,6 +20,9 @@ const featureFns = new Map([
     ["remoteconfig", features.remoteconfig],
     ["hosting:github", features.hostingGithub],
 ]);
+if ((0, experiments_1.isEnabled)("frameworks")) {
+    featureFns.set("frameworks", features.frameworks);
+}
 async function init(setup, config, options) {
     var _a;
     const nextFeature = (_a = setup.features) === null || _a === void 0 ? void 0 : _a.shift();

package/lib/management/projects.js

@@ -300,7 +300,11 @@ async function getFirebaseProject(projectId) {
         return res.body;
     }
     catch (err) {
-        logger_1.logger.debug(err.message);
+        let message = err.message;
+        if (err.original) {
+            message += ` (original: ${err.original.message})`;
+        }
+        logger_1.logger.debug(message);
         throw new error_1.FirebaseError(`Failed to get Firebase project ${projectId}. ` +
             "Please make sure the project exists and your account has permission to access it.", { exit: 2, original: err });
     }

package/lib/monospace/index.js

@@ -0,0 +1,82 @@
+"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

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

package/lib/requireAuth.js

@@ -10,6 +10,7 @@ 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) {
@@ -23,6 +24,13 @@ async function autoAuth(options, authScopes) {
     const client = getAuthClient({ scopes: authScopes, projectId: options.project });
     const token = await client.getAccessToken();
     token !== null ? apiv2.setAccessToken(token) : false;
+    if (!options.isVSCE && (0, monospace_1.isMonospaceEnv)()) {
+        await (0, monospace_1.selectProjectInMonospace)({
+            projectRoot: options.config.projectDir,
+            project: options.project,
+            isVSCE: options.isVSCE,
+        });
+    }
 }
 async function requireAuth(options) {
     api.setScopes([scopes.CLOUD_PLATFORM, scopes.FIREBASE_PLATFORM]);