firebase-tools 14.2.0 → 14.2.2

package/lib/init/features/dataconnect/sdk.js

@@ -78,19 +78,21 @@ async function askQuestions(setup, config) {
     const newConnectorYaml = await generateSdkYaml(targetPlatform, connectorYaml, connectorInfo.directory, appDir);
     if (targetPlatform === types_1.Platform.WEB) {
         const unusedFrameworks = fileUtils_1.SUPPORTED_FRAMEWORKS.filter((framework) => { var _a; return !((_a = newConnectorYaml.generate) === null || _a === void 0 ? void 0 : _a.javascriptSdk[framework]); });
-        const hasFrameworkEnabled = unusedFrameworks.length < fileUtils_1.SUPPORTED_FRAMEWORKS.length;
         if (unusedFrameworks.length > 0) {
             const additionalFrameworks = await (0, prompt_1.prompt)(setup, [
                 {
                     type: "checkbox",
                     name: "fdcFrameworks",
-                    message: `Which ${hasFrameworkEnabled ? "additional " : ""}frameworks would you like to generate SDKs for? ` +
+                    message: `Which frameworks would you like to generate SDKs for? ` +
                         "Press Space to select features, then Enter to confirm your choices.",
-                    choices: unusedFrameworks.map((frameworkStr) => ({
-                        value: frameworkStr,
-                        name: frameworkStr,
-                        checked: false,
-                    })),
+                    choices: fileUtils_1.SUPPORTED_FRAMEWORKS.map((frameworkStr) => {
+                        var _a, _b;
+                        return ({
+                            value: frameworkStr,
+                            name: frameworkStr,
+                            checked: (_b = (_a = newConnectorYaml === null || newConnectorYaml === void 0 ? void 0 : newConnectorYaml.generate) === null || _a === void 0 ? void 0 : _a.javascriptSdk) === null || _b === void 0 ? void 0 : _b[frameworkStr],
+                        });
+                    }),
                 },
             ]);
             for (const framework of additionalFrameworks.fdcFrameworks) {

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

@@ -15,32 +15,43 @@ const logger_1 = require("../../../logger");
 const error_1 = require("../../../error");
 const utils_1 = require("../../../utils");
 const UNKNOWN_VERSION_TOO_HIGH = "2.0.0";
+const MIN_VERSION = "0.6.0";
 const LATEST_TEMPLATE = "1.0.0";
-async function getGenkitVersion() {
-    let genkitVersion;
-    let templateVersion = LATEST_TEMPLATE;
-    let useInit = false;
-    let stopInstall = false;
-    if (process.env.GENKIT_DEV_VERSION && typeof process.env.GENKIT_DEV_VERSION === "string") {
-        semver.parse(process.env.GENKIT_DEV_VERSION);
-        genkitVersion = process.env.GENKIT_DEV_VERSION;
-    }
-    else {
-        try {
-            genkitVersion = await (0, spawn_1.spawnWithOutput)("npm", ["view", "genkit", "version"]);
+async function getPackageVersion(packageName, envVariable) {
+    const envVal = process.env[envVariable];
+    if (envVal && typeof envVal === "string") {
+        if (semver.parse(envVal)) {
+            return envVal;
         }
-        catch (err) {
-            throw new error_1.FirebaseError("Unable to determine which genkit version to install.\n" +
-                `npm Error: ${(0, error_1.getErrMsg)(err)}\n\n` +
-                "For a possible workaround run\n  npm view genkit version\n" +
-                "and then set an environment variable:\n" +
-                "  export GENKIT_DEV_VERSION=<output from previous command>\n" +
-                "and run `firebase init genkit` again");
+        else {
+            throw new error_1.FirebaseError(`Invalid version string '${envVal}' specified in ${envVariable}`);
+        }
+    }
+    try {
+        const output = await (0, spawn_1.spawnWithOutput)("npm", ["view", packageName, "version"]);
+        if (!output) {
+            throw new error_1.FirebaseError(`Unable to determine ${packageName} version to install`);
         }
+        return output;
     }
-    if (!genkitVersion) {
-        throw new error_1.FirebaseError("Unable to determine genkit version to install");
+    catch (err) {
+        throw new error_1.FirebaseError(`Unable to determine which version of ${packageName} to install.\n` +
+            `npm Error: ${(0, error_1.getErrMsg)(err)}\n\n` +
+            "For a possible workaround run\n  npm view " +
+            packageName +
+            " version\n" +
+            "and then set an environment variable:\n" +
+            `  export ${envVariable}=<output from previous command>\n` +
+            "and run `firebase init genkit` again");
     }
+}
+async function getGenkitInfo() {
+    let templateVersion = LATEST_TEMPLATE;
+    let stopInstall = false;
+    const genkitVersion = await getPackageVersion("genkit", "GENKIT_DEV_VERSION");
+    const cliVersion = await getPackageVersion("genkit-cli", "GENKIT_CLI_DEV_VERSION");
+    const vertexVersion = await getPackageVersion("@genkit-ai/vertexai", "GENKIT_VERTEX_VERSION");
+    const googleAiVersion = await getPackageVersion("@genkit-ai/googleai", "GENKIT_GOOGLEAI_VERSION");
     if (semver.gte(genkitVersion, UNKNOWN_VERSION_TOO_HIGH)) {
         const continueInstall = await (0, prompt_1.confirm)({
             message: clc.yellow(`WARNING: The latest version of Genkit (${genkitVersion}) isn't supported by this\n` +
@@ -56,24 +67,32 @@ async function getGenkitVersion() {
     else if (semver.gte(genkitVersion, "1.0.0-rc.1")) {
         templateVersion = "1.0.0";
     }
-    else if (semver.gte(genkitVersion, "0.6.0")) {
+    else if (semver.gte(genkitVersion, MIN_VERSION)) {
         templateVersion = "0.9.0";
     }
     else {
-        templateVersion = "";
-        useInit = true;
-    }
-    return { genkitVersion, templateVersion, useInit, stopInstall };
+        throw new error_1.FirebaseError(`The requested version of Genkit (${genkitVersion}) is no ` +
+            `longer supported. Please specify a newer version.`);
+    }
+    return {
+        genkitVersion,
+        cliVersion,
+        vertexVersion,
+        googleAiVersion,
+        templateVersion,
+        stopInstall,
+    };
 }
-function showStartMessage(config, command) {
+function showStartMessage(setup, command) {
+    logger_1.logger.info();
     logger_1.logger.info("\nLogin to Google Cloud using:");
-    logger_1.logger.info(clc.bold(clc.green(`    gcloud auth application-default login --project ${config.options.project}\n`)));
+    logger_1.logger.info(clc.bold(clc.green(`    gcloud auth application-default login --project ${setup.projectId || "your-project-id"}\n`)));
     logger_1.logger.info("Then start the Genkit developer experience by running:");
     logger_1.logger.info(clc.bold(clc.green(`    ${command}`)));
 }
 async function doSetup(setup, config, options) {
     var _a;
-    const genkitInfo = await getGenkitVersion();
+    const genkitInfo = await getGenkitInfo();
     if (genkitInfo.stopInstall) {
         (0, utils_1.logLabeledWarning)("genkit", "Stopped Genkit initialization");
         return;
@@ -108,31 +127,16 @@ async function doSetup(setup, config, options) {
         },
     ])).choice;
     try {
-        (0, utils_1.logLabeledBullet)("genkit", `Installing Genkit CLI version ${genkitInfo.genkitVersion}`);
+        (0, utils_1.logLabeledBullet)("genkit", `Installing Genkit CLI version ${genkitInfo.cliVersion}`);
         if (installType === "globally") {
-            if (genkitInfo.useInit) {
-                await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", `genkit@${genkitInfo.genkitVersion}`], projectDir);
-                await (0, spawn_1.wrapSpawn)("genkit", ["init", "-p", "firebase"], projectDir);
-                logger_1.logger.info("Start the Genkit developer experience by running:");
-                logger_1.logger.info(`    cd ${setup.functions.source} && genkit start`);
-            }
-            else {
-                await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", `genkit-cli@${genkitInfo.genkitVersion}`], projectDir);
-                await genkitSetup(options, genkitInfo, projectDir);
-                showStartMessage(config, `cd ${setup.functions.source} && npm run genkit:start`);
-            }
+            await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", `genkit-cli@${genkitInfo.cliVersion}`], projectDir);
+            await genkitSetup(options, genkitInfo, projectDir);
+            showStartMessage(setup, `cd ${setup.functions.source} && npm run genkit:start`);
         }
         else {
-            if (genkitInfo.useInit) {
-                await (0, spawn_1.wrapSpawn)("npm", ["install", `genkit@${genkitInfo.genkitVersion}`, "--save-dev"], projectDir);
-                await (0, spawn_1.wrapSpawn)("npx", ["genkit", "init", "-p", "firebase"], projectDir);
-                showStartMessage(config, `cd ${setup.functions.source} && npx genkit start`);
-            }
-            else {
-                await (0, spawn_1.wrapSpawn)("npm", ["install", `genkit-cli@${genkitInfo.genkitVersion}`, "--save-dev"], projectDir);
-                await genkitSetup(options, genkitInfo, projectDir);
-                showStartMessage(config, `cd ${setup.functions.source} && npm run genkit:start`);
-            }
+            await (0, spawn_1.wrapSpawn)("npm", ["install", `genkit-cli@${genkitInfo.cliVersion}`, "--save-dev"], projectDir);
+            await genkitSetup(options, genkitInfo, projectDir);
+            showStartMessage(setup, `cd ${setup.functions.source} && npm run genkit:start`);
         }
     }
     catch (err) {
@@ -151,17 +155,17 @@ async function ensureVertexApiEnabled(options) {
     return await (0, ensureApiEnabled_1.ensure)(projectId, VERTEX_AI_URL, "aiplatform", silently);
 }
 exports.ensureVertexApiEnabled = ensureVertexApiEnabled;
-function getModelOptions(genkitVersion) {
+function getModelOptions(genkitInfo) {
     const modelOptions = {
         vertexai: {
             label: "Google Cloud Vertex AI",
             plugin: "@genkit-ai/vertexai",
-            package: `@genkit-ai/vertexai@${genkitVersion}`,
+            package: `@genkit-ai/vertexai@${genkitInfo.vertexVersion}`,
         },
         googleai: {
             label: "Google AI",
             plugin: "@genkit-ai/googleai",
-            package: `@genkit-ai/googleai@${genkitVersion}`,
+            package: `@genkit-ai/googleai@${genkitInfo.googleAiVersion}`,
         },
         none: { label: "None", plugin: undefined, package: undefined },
     };
@@ -208,7 +212,7 @@ function getBasePackages(genkitVersion) {
 const externalDevPackages = ["typescript", "tsx"];
 async function genkitSetup(options, genkitInfo, projectDir) {
     var _a, _b;
-    const modelOptions = getModelOptions(genkitInfo.genkitVersion);
+    const modelOptions = getModelOptions(genkitInfo);
     const supportedModels = Object.keys(modelOptions);
     const answer = await inquirer.prompt([
         {

package/lib/logger.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.vsceLogEmitter = void 0;
+exports.silenceStdout = exports.logger = exports.vsceLogEmitter = void 0;
 const winston = require("winston");
 const vsCodeUtils_1 = require("./vsCodeUtils");
 const events_1 = require("events");
@@ -46,6 +46,15 @@ function maybeUseVSCodeLogger(logger) {
     return logger;
 }
 const rawLogger = winston.createLogger();
-rawLogger.add(new winston.transports.Console({ silent: true }));
+rawLogger.add(new winston.transports.Console({
+    silent: true,
+    consoleWarnLevels: ["debug", "warn"],
+}));
 rawLogger.exitOnError = false;
 exports.logger = maybeUseVSCodeLogger(annotateDebugLines(expandErrors(rawLogger)));
+function silenceStdout() {
+    exports.logger = winston.createLogger({
+        silent: true,
+    });
+}
+exports.silenceStdout = silenceStdout;

package/lib/mcp/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+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");
+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.
+\`\`\`sh
+${cmd} login
+\`\`\`
+
+[ADC]: https://cloud.google.com/docs/authentication/application-default-credentials`);
+}
+exports.mcpAuthError = mcpAuthError;

package/lib/mcp/index.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseMcpServer = void 0;
+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 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 SERVER_VERSION = "0.0.1";
+const PROJECT_ROOT_KEY = "mcp.projectRoot";
+const cmd = new command_js_1.Command("experimental:mcp").before(requireAuth_js_1.requireAuth);
+class FirebaseMcpServer {
+    constructor(options) {
+        var _a, _b, _c;
+        this.activeFeatures = options.activeFeatures;
+        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;
+    }
+    get availableTools() {
+        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 toolDefs;
+    }
+    getTool(name) {
+        return this.availableTools.find((t) => t.mcp.name === name) || null;
+    }
+    async mcpListTools() {
+        const hasActiveProject = !!(await this.getProjectId());
+        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;
+        void this.server.sendToolListChanged();
+    }
+    async resolveOptions() {
+        const options = { cwd: this.projectRoot };
+        await cmd.prepare(options);
+        return options;
+    }
+    async getProjectId() {
+        return (0, projectUtils_js_1.getProjectId)(await this.resolveOptions());
+    }
+    async getAuthenticated() {
+        try {
+            await (0, requireAuth_js_1.requireAuth)(await this.resolveOptions());
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async mcpCallTool(request) {
+        var _a, _b;
+        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()))
+            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;
+        try {
+            return tool.fn(toolArgs, { projectId: await this.getProjectId(), host: this });
+        }
+        catch (err) {
+            return (0, util_js_1.mcpError)(err);
+        }
+    }
+    async start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+    }
+}
+exports.FirebaseMcpServer = FirebaseMcpServer;

package/lib/mcp/tool.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+function tool(options, fn) {
+    return {
+        mcp: Object.assign(Object.assign({}, options), { inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(options.inputSchema) }),
+        fn,
+    };
+}
+exports.tool = tool;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disable_auth_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",
+    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"),
+        disabled: zod_1.z.boolean().describe("true disables the user, false enables the user"),
+    }),
+    annotations: {
+        title: "Disable or enable a particular user",
+        destructiveHint: true,
+        idempotentHint: true,
+    },
+    _meta: {
+        requiresAuth: true,
+        requiresProject: true,
+    },
+}, async ({ uid, disabled }, { projectId }) => {
+    const res = await (0, auth_js_1.disableUser)(projectId, uid, disabled);
+    if (res) {
+        return (0, util_js_1.toContent)(`User ${uid} as been ${disabled ? "disabled" : "enabled"}`);
+    }
+    return (0, util_js_1.toContent)(`Failed to ${disabled ? "disable" : "enable"} user ${uid}`);
+});

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_auth_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_auth_user = (0, tool_js_1.tool)({
+    name: "get_auth_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(),
+        phoneNumber: zod_1.z.string().optional(),
+        uid: zod_1.z.string().optional(),
+    }),
+    annotations: {
+        title: "Get information about 1 user.",
+        readOnlyHint: true,
+    },
+    _meta: {
+        requiresAuth: true,
+        requiresProject: true,
+    },
+}, async ({ email, phoneNumber, uid }, { projectId }) => {
+    if (email === undefined && phoneNumber === undefined && uid === undefined) {
+        return (0, util_js_1.mcpError)(`No user identifier supplied in get_auth_user tool`);
+    }
+    return (0, util_js_1.toContent)(await (0, auth_js_1.findUser)(projectId, email, phoneNumber, uid));
+});

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

@@ -0,0 +1,7 @@
+"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");
+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];

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set_auth_claim = 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.set_auth_claim = (0, tool_js_1.tool)({
+    name: "set_auth_claims",
+    description: "Sets custom claims on a specific user's account. Use to create trusted values associated with a user e.g. marking them as an admin. Claims are limited in size and should be succinct in name and value.",
+    inputSchema: zod_1.z.object({
+        uid: zod_1.z.string().describe("the UID of the user to update"),
+        claim: zod_1.z.string().describe("the name (key) of the claim to update, e.g. 'admin'"),
+        value: zod_1.z
+            .union([
+            zod_1.z.string(),
+            zod_1.z.number(),
+            zod_1.z.boolean(),
+            zod_1.z.record(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()])),
+            zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()])),
+        ])
+            .describe("the value of the custom claim"),
+    }),
+    annotations: {
+        title: "Set custom Firebase Auth claim",
+        idempotentHint: true,
+    },
+    _meta: {
+        requiresAuth: true,
+        requiresProject: true,
+    },
+}, async ({ uid, claim, value }, { projectId }) => {
+    return (0, util_js_1.toContent)(await (0, auth_js_1.setCustomClaim)(projectId, uid, { [claim]: value }, { merge: true }));
+});

package/lib/mcp/tools/core/get_firebase_directory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_firebase_directory = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const detectProjectRoot_js_1 = require("../../../detectProjectRoot.js");
+exports.get_firebase_directory = (0, tool_js_1.tool)({
+    name: "get_firebase_directory",
+    description: "Gets the current Firebase project directory. If this has been set using the `set_firebase_directory` tool it will return that, otherwise it will look for a PROJECT_ROOT environment variable or the current working directory of the running Firebase MCP server.",
+    inputSchema: zod_1.z.object({}),
+    annotations: {
+        title: "Get Firebase Project Directory",
+        readOnlyHint: true,
+    },
+}, (_, { host }) => {
+    if (!(0, detectProjectRoot_js_1.detectProjectRoot)({ cwd: host.projectRoot }))
+        return Promise.resolve((0, util_js_1.mcpError)(`There is no detected 'firebase.json' in directory '${host.projectRoot}'. Please use the 'set_firebase_directory' tool to activate a Firebase project directory.`));
+    return Promise.resolve((0, util_js_1.toContent)(`The current Firebase project directory is '${host.projectRoot}'.`));
+});

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreTools = void 0;
+const get_firebase_directory_1 = require("./get_firebase_directory");
+const set_firebase_directory_1 = require("./set_firebase_directory");
+exports.coreTools = [get_firebase_directory_1.get_firebase_directory, set_firebase_directory_1.set_firebase_directory];

package/lib/mcp/tools/core/set_firebase_directory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set_firebase_directory = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.set_firebase_directory = (0, tool_js_1.tool)({
+    name: "set_firebase_directory",
+    description: "Sets the project directory for the Firebase MCP server to utilize for project detection and authentication. This should be a directory with a `firebase.json` file in it. This information is persisted between sessions.",
+    inputSchema: zod_1.z.object({
+        dir: zod_1.z
+            .string()
+            .nullable()
+            .describe("the absolute path of the directory. set to null to 'unset' the value and fall back to the working directory"),
+    }),
+    annotations: {
+        title: "Set Firebase Project Directory",
+        idempotentHint: true,
+    },
+}, ({ dir }, { host }) => {
+    if (dir === null) {
+        host.setProjectRoot(null);
+        return Promise.resolve((0, util_js_1.toContent)(`Firebase MCP project directory setting deleted. New project root is: ${host.projectRoot || "unset"}`));
+    }
+    if (!(0, fs_1.existsSync)(dir))
+        return Promise.resolve((0, util_js_1.mcpError)(`Directory '${dir}' does not exist.`));
+    if (!(0, fs_1.existsSync)((0, path_1.join)(dir, "firebase.json")))
+        return Promise.resolve((0, util_js_1.mcpError)(`Directory '${dir}' does not contain a 'firebase.json' file.`));
+    host.setProjectRoot(dir);
+    return Promise.resolve((0, util_js_1.toContent)(`Firebase MCP project directory set to '${dir}'.`));
+});

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataconnectTools = void 0;
+const list_dataconnect_services_js_1 = require("./list_dataconnect_services.js");
+exports.dataconnectTools = [list_dataconnect_services_js_1.list_dataconnect_services];

package/lib/mcp/tools/dataconnect/list_dataconnect_services.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list_dataconnect_services = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const client = require("../../../dataconnect/client");
+exports.list_dataconnect_services = (0, tool_js_1.tool)({
+    name: "list_dataconnect_services",
+    description: "List the Firebase Data Connect services available in the current project.",
+    inputSchema: zod_1.z.object({}),
+    annotations: {
+        title: "List the Firebase Data Connect Services that's available in the backend",
+        readOnlyHint: true,
+    },
+    _meta: {
+        requiresProject: true,
+        requiresAuth: true,
+    },
+}, async (_, { projectId }) => {
+    const services = await client.listAllServices(projectId);
+    return (0, util_js_1.toContent)(services, { format: "yaml" });
+});

package/lib/mcp/tools/firestore/converter.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firestoreDocumentToJson = void 0;
+const logger_1 = require("../../../logger");
+function firestoreValueToJson(firestoreValue) {
+    var _a, _b;
+    if ("nullValue" in firestoreValue)
+        return null;
+    if ("booleanValue" in firestoreValue)
+        return firestoreValue.booleanValue;
+    if ("integerValue" in firestoreValue) {
+        const num = Number(firestoreValue.integerValue);
+        if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+            return firestoreValue.integerValue;
+        }
+        return num;
+    }
+    if ("doubleValue" in firestoreValue)
+        return firestoreValue.doubleValue;
+    if ("timestampValue" in firestoreValue)
+        return { __type__: "Timestamp", value: firestoreValue.timestampValue };
+    if ("stringValue" in firestoreValue)
+        return firestoreValue.stringValue;
+    if ("bytesValue" in firestoreValue)
+        return firestoreValue.bytesValue;
+    if ("referenceValue" in firestoreValue)
+        return { __type__: "Reference", value: firestoreValue.referenceValue };
+    if ("geoPointValue" in firestoreValue)
+        return {
+            __type__: "GeoPoint",
+            value: [firestoreValue.geoPointValue.latitude, firestoreValue.geoPointValue.longitude],
+        };
+    if ("arrayValue" in firestoreValue)
+        return (_b = (_a = firestoreValue.arrayValue.values) === null || _a === void 0 ? void 0 : _a.map((v) => firestoreValueToJson(v))) !== null && _b !== void 0 ? _b : [];
+    if ("mapValue" in firestoreValue) {
+        const map = firestoreValue.mapValue.fields || {};
+        const obj = {};
+        for (const key of Object.keys(map)) {
+            obj[key] = firestoreValueToJson(map[key]);
+        }
+        return obj;
+    }
+    logger_1.logger.warn("Unhandled Firestore Value type encountered:", firestoreValue);
+    return undefined;
+}
+function firestoreDocumentToJson(firestoreDoc) {
+    const nameParts = firestoreDoc.name.split("/documents/");
+    const path = nameParts.length > 1 ? nameParts[nameParts.length - 1] : "";
+    const result = { __path__: path };
+    if (firestoreDoc.fields) {
+        for (const key of Object.keys(firestoreDoc.fields)) {
+            result[key] = firestoreValueToJson(firestoreDoc.fields[key]);
+        }
+    }
+    return result;
+}
+exports.firestoreDocumentToJson = firestoreDocumentToJson;