firebase-tools 14.3.0 → 14.4.0

package/lib/init/features/remoteconfig.js

@@ -5,7 +5,6 @@ const prompt_1 = require("../../prompt");
 const fsutils = require("../../fsutils");
 const clc = require("colorette");
 async function doSetup(setup, config) {
-    setup.config.remoteconfig = {};
     const jsonFilePath = await (0, prompt_1.input)({
         message: "What file should be used for your Remote Config template?",
         default: "remoteconfig.template.json",
@@ -20,7 +19,9 @@ async function doSetup(setup, config) {
             return;
         }
     }
-    setup.config.remoteconfig.template = jsonFilePath;
+    setup.config.remoteconfig = {
+        template: jsonFilePath,
+    };
     config.writeProjectFile(setup.config.remoteconfig.template, "{}");
 }
 exports.doSetup = doSetup;

package/lib/init/index.js

@@ -1,45 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = void 0;
+exports.actuate = exports.init = void 0;
 const lodash_1 = require("lodash");
 const clc = require("colorette");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
 const features = require("./features");
-const featureFns = new Map([
-    ["account", features.account],
-    ["database", features.database],
-    ["firestore", features.firestore],
-    ["dataconnect", features.dataconnect],
-    ["dataconnect:sdk", features.dataconnectSdk],
-    ["functions", features.functions],
-    ["hosting", features.hosting],
-    ["storage", features.storage],
-    ["emulators", features.emulators],
-    ["extensions", features.extensions],
-    ["project", features.project],
-    ["remoteconfig", features.remoteconfig],
-    ["hosting:github", features.hostingGithub],
-    ["genkit", features.genkit],
-    ["apphosting", features.apphosting],
-]);
+const featuresList = [
+    { name: "account", doSetup: features.account },
+    {
+        name: "database",
+        askQuestions: features.databaseAskQuestions,
+        actuate: features.databaseActuate,
+    },
+    {
+        name: "firestore",
+        askQuestions: features.firestoreAskQuestions,
+        actuate: features.firestoreActuate,
+    },
+    {
+        name: "dataconnect",
+        askQuestions: features.dataconnectAskQuestions,
+        actuate: features.dataconnectActuate,
+        postSetup: features.dataconnectPostSetup,
+    },
+    { name: "dataconnect:sdk", doSetup: features.dataconnectSdk },
+    { name: "functions", doSetup: features.functions },
+    { name: "hosting", doSetup: features.hosting },
+    { name: "storage", doSetup: features.storage },
+    { name: "emulators", doSetup: features.emulators },
+    { name: "extensions", doSetup: features.extensions },
+    { name: "project", doSetup: features.project },
+    { name: "remoteconfig", doSetup: features.remoteconfig },
+    { name: "hosting:github", doSetup: features.hostingGithub },
+    { name: "genkit", doSetup: features.genkit },
+    { name: "apphosting", displayName: "App Hosting", doSetup: features.apphosting },
+];
+const featureMap = new Map(featuresList.map((feature) => [feature.name, feature]));
 async function init(setup, config, options) {
     var _a;
     const nextFeature = (_a = setup.features) === null || _a === void 0 ? void 0 : _a.shift();
     if (nextFeature) {
-        if (!featureFns.has(nextFeature)) {
+        const f = featureMap.get(nextFeature);
+        if (!f) {
             const availableFeatures = Object.keys(features)
                 .filter((f) => f !== "project")
                 .join(", ");
             throw new error_1.FirebaseError(`${clc.bold(nextFeature)} is not a valid feature. Must be one of ${availableFeatures}`);
         }
-        logger_1.logger.info(clc.bold(`\n${clc.white("===")} ${(0, lodash_1.capitalize)(nextFeature)} Setup`));
-        const fn = featureFns.get(nextFeature);
-        if (!fn) {
-            throw new error_1.FirebaseError(`We've lost the function to init ${nextFeature}`, { exit: 2 });
+        logger_1.logger.info(clc.bold(`\n${clc.white("===")} ${f.displayName || (0, lodash_1.capitalize)(nextFeature)} Setup`));
+        if (f.doSetup) {
+            await f.doSetup(setup, config, options);
+        }
+        else {
+            if (f.askQuestions) {
+                await f.askQuestions(setup, config, options);
+            }
+            if (f.actuate) {
+                await f.actuate(setup, config, options);
+            }
+        }
+        if (f.postSetup) {
+            await f.postSetup(setup, config, options);
         }
-        await fn(setup, config, options);
         return init(setup, config, options);
     }
 }
 exports.init = init;
+async function actuate(setup, config, options) {
+    var _a;
+    const nextFeature = (_a = setup.features) === null || _a === void 0 ? void 0 : _a.shift();
+    if (nextFeature) {
+        const f = lookupFeature(nextFeature);
+        logger_1.logger.info(clc.bold(`\n${clc.white("===")} ${(0, lodash_1.capitalize)(nextFeature)} Setup Actuation`));
+        if (f.doSetup) {
+            throw new error_1.FirebaseError(`The feature ${nextFeature} does not support actuate yet. Please run ${clc.bold("firebase init " + nextFeature)} instead.`);
+        }
+        else {
+            if (f.actuate) {
+                await f.actuate(setup, config, options);
+            }
+        }
+        return actuate(setup, config, options);
+    }
+}
+exports.actuate = actuate;
+function lookupFeature(feature) {
+    const f = featureMap.get(feature);
+    if (!f) {
+        const availableFeatures = Object.keys(features)
+            .filter((f) => f !== "project")
+            .join(", ");
+        throw new error_1.FirebaseError(`${clc.bold(feature)} is not a valid feature. Must be one of ${availableFeatures}`);
+    }
+    return f;
+}

package/lib/logger.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.silenceStdout = exports.logger = exports.vsceLogEmitter = void 0;
+exports.useConsoleLoggers = exports.useFileLogger = exports.logger = exports.tryStringify = exports.findAvailableLogFile = exports.vsceLogEmitter = void 0;
 const winston = require("winston");
-const vsCodeUtils_1 = require("./vsCodeUtils");
 const events_1 = require("events");
+const path = require("path");
+const fs = require("fs");
+const triple_beam_1 = require("triple-beam");
+const util_1 = require("util");
+const vsCodeUtils_1 = require("./vsCodeUtils");
 exports.vsceLogEmitter = new events_1.EventEmitter();
 function expandErrors(logger) {
     const oldLogFunc = logger.log.bind(logger);
@@ -45,6 +49,39 @@ function maybeUseVSCodeLogger(logger) {
     logger.log = vsceLogger;
     return logger;
 }
+function findAvailableLogFile() {
+    const candidates = ["firebase-debug.log"];
+    for (let i = 1; i < 10; i++) {
+        candidates.push(`firebase-debug.${i}.log`);
+    }
+    for (const c of candidates) {
+        const logFilename = path.join(process.cwd(), c);
+        try {
+            const fd = fs.openSync(logFilename, "r+");
+            fs.closeSync(fd);
+            return logFilename;
+        }
+        catch (e) {
+            if (e.code === "ENOENT") {
+                return logFilename;
+            }
+        }
+    }
+    throw new Error("Unable to obtain permissions for firebase-debug.log");
+}
+exports.findAvailableLogFile = findAvailableLogFile;
+function tryStringify(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch (_a) {
+        return value;
+    }
+}
+exports.tryStringify = tryStringify;
 const rawLogger = winston.createLogger();
 rawLogger.add(new winston.transports.Console({
     silent: true,
@@ -52,9 +89,36 @@ rawLogger.add(new winston.transports.Console({
 }));
 rawLogger.exitOnError = false;
 exports.logger = maybeUseVSCodeLogger(annotateDebugLines(expandErrors(rawLogger)));
-function silenceStdout() {
-    exports.logger = winston.createLogger({
-        silent: true,
-    });
+function useFileLogger(logFile) {
+    const logFileName = logFile !== null && logFile !== void 0 ? logFile : findAvailableLogFile();
+    exports.logger.add(new winston.transports.File({
+        level: "debug",
+        filename: logFileName,
+        format: winston.format.printf((info) => {
+            const segments = [info.message, ...(info[triple_beam_1.SPLAT] || [])].map(tryStringify);
+            return `[${info.level}] ${(0, util_1.stripVTControlCharacters)(segments.join(" "))}`;
+        }),
+    }));
+    return logFileName;
+}
+exports.useFileLogger = useFileLogger;
+function useConsoleLoggers() {
+    if (process.env.DEBUG) {
+        exports.logger.add(new winston.transports.Console({
+            level: "debug",
+            format: winston.format.printf((info) => {
+                const segments = [info.message, ...(info[triple_beam_1.SPLAT] || [])].map(tryStringify);
+                return `${(0, util_1.stripVTControlCharacters)(segments.join(" "))}`;
+            }),
+        }));
+    }
+    else if (process.env.IS_FIREBASE_CLI) {
+        exports.logger.add(new winston.transports.Console({
+            level: "info",
+            format: winston.format.printf((info) => [info.message, ...(info[triple_beam_1.SPLAT] || [])]
+                .filter((chunk) => typeof chunk === "string")
+                .join(" ")),
+        }));
+    }
 }
-exports.silenceStdout = silenceStdout;
+exports.useConsoleLoggers = useConsoleLoggers;

package/lib/management/projects.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProject = exports.getFirebaseProject = exports.listFirebaseProjects = exports.getAvailableCloudProjectPage = exports.getFirebaseProjectPage = exports.addFirebaseToCloudProject = exports.createCloudProject = exports.promptAvailableProjectId = exports.getOrPromptProject = exports.addFirebaseToCloudProjectAndLog = exports.createFirebaseProjectAndLog = exports.promptProjectCreation = exports.ProjectParentResourceType = void 0;
+exports.checkFirebaseEnabledForCloudProject = exports.getProject = exports.getFirebaseProject = exports.listFirebaseProjects = exports.getAvailableCloudProjectPage = exports.getFirebaseProjectPage = exports.addFirebaseToCloudProject = exports.createCloudProject = exports.promptAvailableProjectId = exports.getOrPromptProject = exports.addFirebaseToCloudProjectAndLog = exports.createFirebaseProjectAndLog = exports.promptProjectCreation = exports.ProjectParentResourceType = void 0;
 const clc = require("colorette");
 const ora = require("ora");
 const apiv2_1 = require("../apiv2");
@@ -336,8 +336,31 @@ async function getFirebaseProject(projectId) {
 }
 exports.getFirebaseProject = getFirebaseProject;
 async function getProject(projectId) {
-    await (0, ensureApiEnabled_1.ensure)(projectId, api.resourceManagerOrigin(), "firebase", true);
+    await (0, ensureApiEnabled_1.bestEffortEnsure)(projectId, api.resourceManagerOrigin(), "firebase", true);
     const response = await resourceManagerClient.get(`/projects/${projectId}`);
     return response.body;
 }
 exports.getProject = getProject;
+async function checkFirebaseEnabledForCloudProject(projectId) {
+    try {
+        const res = await firebaseAPIClient.request({
+            method: "GET",
+            path: `/projects/${projectId}`,
+            timeout: TIMEOUT_MILLIS,
+        });
+        return res.body;
+    }
+    catch (err) {
+        if ((0, error_1.getErrStatus)(err) === 404) {
+            return undefined;
+        }
+        let message = err.message;
+        if (err.original) {
+            message += ` (original: ${err.original.message})`;
+        }
+        logger_1.logger.debug(message);
+        throw new error_1.FirebaseError(`Failed to check if Firebase is enabled for project ${projectId}. ` +
+            "Please make sure the project exists and your account has permission to access it.", { exit: 2, original: err });
+    }
+}
+exports.checkFirebaseEnabledForCloudProject = checkFirebaseEnabledForCloudProject;

package/lib/mcp/errors.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mcpAuthError = exports.NO_PROJECT_ERROR = void 0;
 const util_1 = require("./util");
-exports.NO_PROJECT_ERROR = (0, util_1.mcpError)('No active project was found. Use the `set_firebase_directory` tool to set the project directory to an absolute folder location containing a firebase.json config file. Alternatively, change the MCP server config to add [...,"--dir","/absolute/path/to/project/directory"] in its command-line arguments.', "PRECONDITION_FAILED");
+exports.NO_PROJECT_ERROR = (0, util_1.mcpError)('No active project was found. Use the `firebase_update_environment` tool to set the project directory to an absolute folder location containing a firebase.json config file. Alternatively, change the MCP server config to add [...,"--dir","/absolute/path/to/project/directory"] in its command-line arguments.', "PRECONDITION_FAILED");
 function mcpAuthError() {
     const cmd = (0, util_1.commandExistsSync)("firebase") ? "firebase" : "npx -y firebase-tools";
     return (0, util_1.mcpError)(`The user is not currently logged into the Firebase CLI, which is required to use this tool. Please instruct the user to execute this shell command to sign in or to configure [Application Default Credentials][ADC] on their machine.

package/lib/mcp/index.js

@@ -5,110 +5,193 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const util_js_1 = require("./util.js");
+const types_js_2 = require("./types.js");
 const index_js_2 = require("./tools/index.js");
 const configstore_js_1 = require("../configstore.js");
-const index_js_3 = require("./tools/core/index.js");
 const command_js_1 = require("../command.js");
 const requireAuth_js_1 = require("../requireAuth.js");
 const projectUtils_js_1 = require("../projectUtils.js");
 const errors_js_1 = require("./errors.js");
 const track_js_1 = require("../track.js");
 const config_js_1 = require("../config.js");
-const SERVER_VERSION = "0.0.1";
-const PROJECT_ROOT_KEY = "mcp.projectRoot";
+const rc_js_1 = require("../rc.js");
+const hubClient_js_1 = require("../emulator/hubClient.js");
+const node_fs_1 = require("node:fs");
+const SERVER_VERSION = "0.1.0";
 const cmd = new command_js_1.Command("experimental:mcp").before(requireAuth_js_1.requireAuth);
 class FirebaseMcpServer {
     constructor(options) {
-        var _a, _b, _c;
+        this._ready = false;
+        this._readyPromises = [];
         this.activeFeatures = options.activeFeatures;
+        this.startupRoot = options.projectRoot || process.env.PROJECT_ROOT;
         this.server = new index_js_1.Server({ name: "firebase", version: SERVER_VERSION });
         this.server.registerCapabilities({ tools: { listChanged: true } });
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, this.mcpListTools.bind(this));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, this.mcpCallTool.bind(this));
-        this.projectRoot =
-            (_c = (_b = (_a = options.projectRoot) !== null && _a !== void 0 ? _a : configstore_js_1.configstore.get(PROJECT_ROOT_KEY)) !== null && _b !== void 0 ? _b : process.env.PROJECT_ROOT) !== null && _c !== void 0 ? _c : process.cwd();
-        if (options.projectRoot)
-            this.fixedRoot = true;
+        this.server.oninitialized = async () => {
+            var _a, _b;
+            const clientInfo = this.server.getClientVersion();
+            this.clientInfo = clientInfo;
+            if (clientInfo === null || clientInfo === void 0 ? void 0 : clientInfo.name) {
+                (0, track_js_1.trackGA4)("mcp_client_connected", {
+                    mcp_client_name: clientInfo.name,
+                    mcp_client_version: clientInfo.version,
+                });
+            }
+            if (!((_a = this.clientInfo) === null || _a === void 0 ? void 0 : _a.name))
+                this.clientInfo = { name: "<unknown-client>" };
+            this._ready = true;
+            while (this._readyPromises.length) {
+                (_b = this._readyPromises.pop()) === null || _b === void 0 ? void 0 : _b.resolve();
+            }
+        };
+        this.detectProjectRoot();
+        this.detectActiveFeatures();
     }
-    get availableTools() {
+    ready() {
+        if (this._ready)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this._readyPromises.push({ resolve: resolve, reject });
+        });
+    }
+    get clientConfigKey() {
         var _a;
-        const toolDefs = this.fixedRoot ? [] : [...index_js_3.coreTools];
-        const activeFeatures = ((_a = this.activeFeatures) === null || _a === void 0 ? void 0 : _a.length)
-            ? this.activeFeatures
-            : Object.keys(index_js_2.tools);
-        for (const key of activeFeatures || []) {
-            toolDefs.push(...index_js_2.tools[key]);
+        return `mcp.clientConfigs.${((_a = this.clientInfo) === null || _a === void 0 ? void 0 : _a.name) || "<unknown-client>"}:${this.startupRoot || process.cwd()}`;
+    }
+    getStoredClientConfig() {
+        return configstore_js_1.configstore.get(this.clientConfigKey) || {};
+    }
+    updateStoredClientConfig(update) {
+        const config = configstore_js_1.configstore.get(this.clientConfigKey) || {};
+        const newConfig = Object.assign(Object.assign({}, config), update);
+        configstore_js_1.configstore.set(this.clientConfigKey, newConfig);
+        return newConfig;
+    }
+    async detectProjectRoot() {
+        await this.ready();
+        if (this.cachedProjectRoot)
+            return this.cachedProjectRoot;
+        const storedRoot = this.getStoredClientConfig().projectRoot;
+        this.cachedProjectRoot = storedRoot || this.startupRoot || process.cwd();
+        return this.cachedProjectRoot;
+    }
+    async detectActiveFeatures() {
+        var _a;
+        if ((_a = this.detectedFeatures) === null || _a === void 0 ? void 0 : _a.length)
+            return this.detectedFeatures;
+        const options = await this.resolveOptions();
+        const projectId = await this.getProjectId();
+        const detected = await Promise.all(types_js_2.SERVER_FEATURES.map(async (f) => {
+            if (await (0, util_js_1.checkFeatureActive)(f, projectId, options))
+                return f;
+            return null;
+        }));
+        this.detectedFeatures = detected.filter((f) => !!f);
+        return this.detectedFeatures;
+    }
+    async getEmulatorHubClient() {
+        if (this.emulatorHubClient) {
+            return this.emulatorHubClient;
         }
-        return toolDefs;
+        const projectId = await this.getProjectId();
+        if (!projectId) {
+            return;
+        }
+        this.emulatorHubClient = new hubClient_js_1.EmulatorHubClient(projectId);
+        return this.emulatorHubClient;
+    }
+    get availableTools() {
+        var _a;
+        return (0, index_js_2.availableTools)(((_a = this.activeFeatures) === null || _a === void 0 ? void 0 : _a.length) ? this.activeFeatures : this.detectedFeatures);
     }
     getTool(name) {
         return this.availableTools.find((t) => t.mcp.name === name) || null;
     }
-    async mcpListTools() {
-        const hasActiveProject = !!(await this.getProjectId());
-        await (0, track_js_1.trackGA4)("mcp_list_tools", {});
-        return {
-            tools: this.availableTools.map((t) => t.mcp),
-            _meta: {
-                projectRoot: this.projectRoot,
-                projectDetected: hasActiveProject,
-                authenticated: await this.getAuthenticated(),
-                activeFeatures: this.activeFeatures,
-            },
-        };
-    }
     setProjectRoot(newRoot) {
-        if (newRoot === null) {
-            configstore_js_1.configstore.delete(PROJECT_ROOT_KEY);
-            this.projectRoot = process.env.PROJECT_ROOT || process.cwd();
-            void this.server.sendToolListChanged();
-            return;
-        }
-        configstore_js_1.configstore.set(PROJECT_ROOT_KEY, newRoot);
-        this.projectRoot = newRoot;
+        this.updateStoredClientConfig({ projectRoot: newRoot });
+        this.cachedProjectRoot = newRoot || undefined;
+        this.detectedFeatures = undefined;
         void this.server.sendToolListChanged();
     }
     async resolveOptions() {
-        const options = { cwd: this.projectRoot };
+        const options = { cwd: this.cachedProjectRoot, isMCP: true };
         await cmd.prepare(options);
         return options;
     }
     async getProjectId() {
         return (0, projectUtils_js_1.getProjectId)(await this.resolveOptions());
     }
-    async getAuthenticated() {
+    async getAuthenticatedUser() {
         try {
-            await (0, requireAuth_js_1.requireAuth)(await this.resolveOptions());
-            return true;
+            return await (0, requireAuth_js_1.requireAuth)(await this.resolveOptions());
         }
         catch (e) {
-            return false;
+            return null;
         }
     }
-    async mcpCallTool(request) {
+    async mcpListTools() {
         var _a, _b;
+        await Promise.all([this.detectActiveFeatures(), this.detectProjectRoot()]);
+        const hasActiveProject = !!(await this.getProjectId());
+        await (0, track_js_1.trackGA4)("mcp_list_tools", {
+            mcp_client_name: (_a = this.clientInfo) === null || _a === void 0 ? void 0 : _a.name,
+            mcp_client_version: (_b = this.clientInfo) === null || _b === void 0 ? void 0 : _b.version,
+        });
+        return {
+            tools: this.availableTools.map((t) => t.mcp),
+            _meta: {
+                projectRoot: this.cachedProjectRoot,
+                projectDetected: hasActiveProject,
+                authenticatedUser: await this.getAuthenticatedUser(),
+                activeFeatures: this.activeFeatures,
+                detectedFeatures: this.detectedFeatures,
+            },
+        };
+    }
+    async mcpCallTool(request) {
+        var _a, _b, _c, _d, _e, _f;
+        await this.detectProjectRoot();
         const toolName = request.params.name;
         const toolArgs = request.params.arguments;
         const tool = this.getTool(toolName);
         if (!tool)
             throw new Error(`Tool '${toolName}' could not be found.`);
         const projectId = await this.getProjectId();
-        if (((_a = tool.mcp._meta) === null || _a === void 0 ? void 0 : _a.requiresAuth) && !(await this.getAuthenticated()))
+        const accountEmail = await this.getAuthenticatedUser();
+        if (tool.mcp.name !== "firebase_update_environment" &&
+            (!this.cachedProjectRoot || !(0, node_fs_1.existsSync)(this.cachedProjectRoot)))
+            return (0, util_js_1.mcpError)(`The current project directory '${this.cachedProjectRoot || "<NO PROJECT DIRECTORY FOUND>"}' does not exist. Please use the 'update_firebase_environment' tool to target a different project directory.`);
+        if (((_a = tool.mcp._meta) === null || _a === void 0 ? void 0 : _a.requiresAuth) && !accountEmail)
             return (0, errors_js_1.mcpAuthError)();
         if (((_b = tool.mcp._meta) === null || _b === void 0 ? void 0 : _b.requiresProject) && !projectId)
             return errors_js_1.NO_PROJECT_ERROR;
+        const options = { projectDir: this.cachedProjectRoot, cwd: this.cachedProjectRoot };
+        const toolsCtx = {
+            projectId: projectId,
+            host: this,
+            config: config_js_1.Config.load(options, true) || new config_js_1.Config({}, options),
+            rc: (0, rc_js_1.loadRC)(options),
+            accountEmail,
+        };
         try {
-            const config = config_js_1.Config.load({ cwd: this.projectRoot });
-            const res = await tool.fn(toolArgs, {
-                projectId: await this.getProjectId(),
-                host: this,
-                config,
+            const res = await tool.fn(toolArgs, toolsCtx);
+            await (0, track_js_1.trackGA4)("mcp_tool_call", {
+                tool_name: toolName,
+                error: res.isError ? 1 : 0,
+                mcp_client_name: (_c = this.clientInfo) === null || _c === void 0 ? void 0 : _c.name,
+                mcp_client_version: (_d = this.clientInfo) === null || _d === void 0 ? void 0 : _d.version,
             });
-            await (0, track_js_1.trackGA4)("mcp_tool_call", { tool_name: toolName, error: res.isError ? 1 : 0 });
             return res;
         }
         catch (err) {
-            await (0, track_js_1.trackGA4)("mcp_tool_call", { tool_name: toolName, error: 1 });
+            await (0, track_js_1.trackGA4)("mcp_tool_call", {
+                tool_name: toolName,
+                error: 1,
+                mcp_client_name: (_e = this.clientInfo) === null || _e === void 0 ? void 0 : _e.name,
+                mcp_client_version: (_f = this.clientInfo) === null || _f === void 0 ? void 0 : _f.version,
+            });
             return (0, util_js_1.mcpError)(err);
         }
     }

package/lib/mcp/tools/auth/{disable_auth_user.js → disable_user.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disable_auth_user = void 0;
+exports.disable_user = void 0;
 const zod_1 = require("zod");
 const tool_js_1 = require("../../tool.js");
 const util_js_1 = require("../../util.js");
 const auth_js_1 = require("../../../gcp/auth.js");
-exports.disable_auth_user = (0, tool_js_1.tool)({
-    name: "disable_auth_user",
+exports.disable_user = (0, tool_js_1.tool)({
+    name: "disable_user",
     description: "Disables or enables a user based on a UID.",
     inputSchema: zod_1.z.object({
         uid: zod_1.z.string().describe("The localId or UID of the user to disable or enable"),

package/lib/mcp/tools/auth/get_user.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_user = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const auth_js_1 = require("../../../gcp/auth.js");
+exports.get_user = (0, tool_js_1.tool)({
+    name: "get_user",
+    description: "Retrieves a user based on an email address, phone number, or UID.",
+    inputSchema: zod_1.z.object({
+        email: zod_1.z
+            .string()
+            .optional()
+            .describe("The user's email address. At least one of email, phone_number, or uid must be provided."),
+        phone_number: zod_1.z
+            .string()
+            .optional()
+            .describe("The user's phone number. At least one of email, phone_number, or uid must be provided."),
+        uid: zod_1.z
+            .string()
+            .optional()
+            .describe("The user's UID. At least one of email, phone_number, or uid must be provided."),
+    }),
+    annotations: {
+        title: "Get Firebase Auth User",
+        readOnlyHint: true,
+    },
+    _meta: {
+        requiresAuth: true,
+        requiresProject: true,
+    },
+}, async ({ email, phone_number, uid }, { projectId }) => {
+    if (email === undefined && phone_number === undefined && uid === undefined) {
+        return (0, util_js_1.mcpError)(`No user identifier supplied in auth_get_user tool`);
+    }
+    return (0, util_js_1.toContent)(await (0, auth_js_1.findUser)(projectId, email, phone_number, uid));
+});

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

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authTools = void 0;
-const get_auth_user_js_1 = require("./get_auth_user.js");
-const disable_auth_user_js_1 = require("./disable_auth_user.js");
-const set_auth_claims_js_1 = require("./set_auth_claims.js");
+const get_user_js_1 = require("./get_user.js");
+const disable_user_js_1 = require("./disable_user.js");
+const set_claims_js_1 = require("./set_claims.js");
 const set_sms_region_policy_js_1 = require("./set_sms_region_policy.js");
+const list_users_js_1 = require("./list_users.js");
 exports.authTools = [
-    get_auth_user_js_1.get_auth_user,
-    disable_auth_user_js_1.disable_auth_user,
-    set_auth_claims_js_1.set_auth_claim,
+    get_user_js_1.get_user,
+    disable_user_js_1.disable_user,
+    list_users_js_1.list_users,
+    set_claims_js_1.set_claim,
     set_sms_region_policy_js_1.set_sms_region_policy,
 ];

package/lib/mcp/tools/auth/list_users.js

@@ -0,0 +1,47 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list_users = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const auth_js_1 = require("../../../gcp/auth.js");
+exports.list_users = (0, tool_js_1.tool)({
+    name: "list_users",
+    description: "Retrieves all users in the project up to the specified limit.",
+    inputSchema: zod_1.z.object({
+        limit: zod_1.z
+            .number()
+            .optional()
+            .default(100)
+            .describe("The number of users to return. Defaults to 100 if not supplied."),
+    }),
+    annotations: {
+        title: "List Firebase Users",
+        readOnlyHint: true,
+    },
+    _meta: {
+        requiresAuth: true,
+        requiresProject: true,
+    },
+}, async ({ limit } = {}, { projectId }) => {
+    if (!limit) {
+        limit = 100;
+    }
+    const users = await (0, auth_js_1.listUsers)(projectId, limit);
+    const usersPruned = users.map((user) => {
+        const { passwordHash, salt } = user, prunedUser = __rest(user, ["passwordHash", "salt"]);
+        return prunedUser;
+    });
+    return (0, util_js_1.toContent)(usersPruned);
+});