firebase-tools 14.3.1 → 14.5.0

package/lib/mcp/tools/rules/validate_rules.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRulesTool = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../../tool.js");
+const util_js_1 = require("../../util.js");
+const rules_js_1 = require("../../../gcp/rules.js");
+const path_1 = require("path");
+function formatRulesetIssues(issues, rulesSource) {
+    const sourceLines = rulesSource.split("\n");
+    const formattedOutput = [];
+    for (const issue of issues) {
+        const { sourcePosition, description, severity } = issue;
+        let issueString = `${severity}: ${description} [Ln ${sourcePosition.line}, Col ${sourcePosition.column}]`;
+        if (sourcePosition.line) {
+            const lineIndex = sourcePosition.line - 1;
+            if (lineIndex >= 0 && lineIndex < sourceLines.length) {
+                const errorLine = sourceLines[lineIndex];
+                issueString += `\n\`\`\`\n${errorLine}`;
+                if (sourcePosition.column &&
+                    sourcePosition.currentOffset &&
+                    sourcePosition.endOffset &&
+                    sourcePosition.column > 0 &&
+                    sourcePosition.endOffset > sourcePosition.currentOffset) {
+                    const startColumnOnLine = sourcePosition.column - 1;
+                    const errorTokenLength = sourcePosition.endOffset - sourcePosition.currentOffset;
+                    if (startColumnOnLine >= 0 &&
+                        errorTokenLength > 0 &&
+                        startColumnOnLine <= errorLine.length) {
+                        const padding = " ".repeat(startColumnOnLine);
+                        const carets = "^".repeat(errorTokenLength);
+                        issueString += `\n${padding}${carets}\n\`\`\``;
+                    }
+                }
+            }
+        }
+        formattedOutput.push(issueString);
+    }
+    return formattedOutput.join("\n\n");
+}
+function validateRulesTool(productName) {
+    return (0, tool_js_1.tool)({
+        name: "validate_rules",
+        description: `Checks the provided ${productName} Rules source for syntax and validation errors. Provide EITHER the source code to validate OR a path to a source file.`,
+        inputSchema: zod_1.z.object({
+            source: zod_1.z
+                .string()
+                .optional()
+                .describe("the rules source code to check. provide either this OR a path"),
+            source_file: zod_1.z
+                .string()
+                .optional()
+                .describe("a file path, relative to the project root, to a file containing the rules source you want to validate. provide this OR source, not both"),
+        }),
+        annotations: {
+            title: `Validate ${productName} Rules`,
+            readOnlyHint: true,
+        },
+        _meta: {
+            requiresProject: true,
+            requiresAuth: true,
+        },
+    }, async ({ source, source_file }, { projectId, config, host }) => {
+        var _a, _b;
+        if (source && source_file) {
+            return (0, util_js_1.mcpError)("Must supply `source` or `source_file`, not both.");
+        }
+        let rulesSourceContent;
+        if (source_file) {
+            try {
+                const filePath = (0, path_1.resolve)(source_file, host.cachedProjectRoot);
+                if (filePath.includes("../"))
+                    return (0, util_js_1.mcpError)("Cannot read files outside of the project directory.");
+                rulesSourceContent = config.readProjectFile(source_file);
+            }
+            catch (e) {
+                return (0, util_js_1.mcpError)(`Failed to read source_file '${source_file}': ${e.message}`);
+            }
+        }
+        else if (source) {
+            rulesSourceContent = source;
+        }
+        else {
+            rulesSourceContent = "";
+        }
+        const result = await (0, rules_js_1.testRuleset)(projectId, [
+            { name: "test.rules", content: rulesSourceContent },
+        ]);
+        if ((_b = (_a = result.body) === null || _a === void 0 ? void 0 : _a.issues) === null || _b === void 0 ? void 0 : _b.length) {
+            const issues = result.body.issues;
+            let out = `Found ${issues.length} issues in rules source:\n\n`;
+            out += formatRulesetIssues(issues, rulesSourceContent);
+            return (0, util_js_1.toContent)(out);
+        }
+        return (0, util_js_1.toContent)("OK: No errors detected.");
+    });
+}
+exports.validateRulesTool = validateRulesTool;

package/lib/mcp/tools/storage/get_download_url.js

@@ -9,23 +9,26 @@ exports.get_object_download_url = (0, tool_js_1.tool)({
     name: "get_object_download_url",
     description: "Retrieves the download URL for an object in Firebase Storage.",
     inputSchema: zod_1.z.object({
-        bucket: zod_1.z.string().nullish().describe("The bucket name in Firebase Storage."),
-        objectPath: zod_1.z
+        bucket: zod_1.z
+            .string()
+            .optional()
+            .describe("The bucket name in Firebase Storage. If not provided, defaults to the project's default bucket (e.g., `{projectid}.firebasestorage.app`)."),
+        object_path: zod_1.z
             .string()
             .describe("The path to the object in Firebase storage without the bucket name attached"),
     }),
     annotations: {
-        title: "Get the download url for an obejct in Firebase Storage.",
+        title: "Get Storage Object Download URL",
         readOnlyHint: true,
     },
     _meta: {
         requiresProject: true,
         requiresAuth: true,
     },
-}, async ({ bucket, objectPath }, { projectId }) => {
+}, async ({ bucket, object_path }, { projectId }) => {
     if (!bucket) {
         bucket = `${projectId}.firebasestorage.app`;
     }
-    const downloadUrl = await (0, storage_js_1.getDownloadUrl)(bucket, objectPath);
+    const downloadUrl = await (0, storage_js_1.getDownloadUrl)(bucket, object_path);
     return (0, util_js_1.toContent)(downloadUrl);
 });

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

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.storageTools = void 0;
+const get_rules_1 = require("../rules/get_rules");
+const validate_rules_1 = require("../rules/validate_rules");
 const get_download_url_1 = require("./get_download_url");
-const get_rules_1 = require("./get_rules");
-exports.storageTools = [get_rules_1.get_rules, get_download_url_1.get_object_download_url];
+exports.storageTools = [
+    (0, get_rules_1.getRulesTool)("Storage", "firebase.storage"),
+    (0, validate_rules_1.validateRulesTool)("Storage"),
+    get_download_url_1.get_object_download_url,
+];

package/lib/mcp/types.js

@@ -1,4 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_FEATURES = void 0;
-exports.SERVER_FEATURES = ["firestore", "storage", "dataconnect", "auth"];
+exports.SERVER_FEATURES = [
+    "firestore",
+    "storage",
+    "dataconnect",
+    "auth",
+    "messaging",
+    "remoteconfig",
+    "crashlytics",
+    "apphosting",
+];

package/lib/mcp/util.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandExistsSync = exports.mcpError = exports.toContent = void 0;
+exports.cleanSchema = exports.checkFeatureActive = exports.commandExistsSync = exports.mcpError = exports.toContent = void 0;
 const child_process_1 = require("child_process");
 const js_yaml_1 = require("js-yaml");
 const os_1 = require("os");
+const api_1 = require("../api");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
 function toContent(data, options) {
     if (typeof data === "string")
         return { content: [{ type: "text", text: data }] };
@@ -17,8 +19,10 @@ function toContent(data, options) {
             text = (0, js_yaml_1.dump)(data);
             break;
     }
+    const prefix = (options === null || options === void 0 ? void 0 : options.contentPrefix) || "";
+    const suffix = (options === null || options === void 0 ? void 0 : options.contentSuffix) || "";
     return {
-        content: [{ type: "text", text }],
+        content: [{ type: "text", text: `${prefix}${text}${suffix}` }],
     };
 }
 exports.toContent = toContent;
@@ -50,3 +54,162 @@ function commandExistsSync(command) {
     }
 }
 exports.commandExistsSync = commandExistsSync;
+const SERVER_FEATURE_APIS = {
+    firestore: (0, api_1.firestoreOrigin)(),
+    storage: (0, api_1.storageOrigin)(),
+    dataconnect: (0, api_1.dataconnectOrigin)(),
+    auth: (0, api_1.authManagementOrigin)(),
+    messaging: (0, api_1.messagingApiOrigin)(),
+    remoteconfig: (0, api_1.remoteConfigApiOrigin)(),
+    crashlytics: (0, api_1.crashlyticsApiOrigin)(),
+    apphosting: (0, api_1.apphostingOrigin)(),
+};
+async function checkFeatureActive(feature, projectId, options) {
+    var _a;
+    if (feature in (((_a = options === null || options === void 0 ? void 0 : options.config) === null || _a === void 0 ? void 0 : _a.data) || {}))
+        return true;
+    try {
+        if (projectId)
+            return await (0, ensureApiEnabled_1.check)(projectId, SERVER_FEATURE_APIS[feature], "", true);
+    }
+    catch (e) {
+        return true;
+    }
+    return false;
+}
+exports.checkFeatureActive = checkFeatureActive;
+function deepClean(obj, isRootLevel = false) {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    const cleanedObj = Object.assign({}, obj);
+    if (cleanedObj.hasOwnProperty("$schema")) {
+        delete cleanedObj.$schema;
+    }
+    if (cleanedObj.hasOwnProperty("additionalProperties")) {
+        delete cleanedObj.additionalProperties;
+    }
+    if (cleanedObj.hasOwnProperty("type")) {
+        const currentType = cleanedObj.type;
+        if (Array.isArray(currentType)) {
+            let filteredTypes = currentType.filter((t) => t !== "null");
+            if (isRootLevel) {
+                filteredTypes = filteredTypes.filter((t) => t !== "array");
+            }
+            if (filteredTypes.length === 0) {
+                return null;
+            }
+            else if (filteredTypes.length === 1) {
+                cleanedObj.type = filteredTypes[0];
+            }
+            else {
+                delete cleanedObj.type;
+                cleanedObj.anyOf = filteredTypes
+                    .map((t) => {
+                    return deepClean({ type: t }, false);
+                })
+                    .filter((subSchema) => subSchema !== null);
+                if (cleanedObj.anyOf.length === 0) {
+                    return null;
+                }
+                if (cleanedObj.anyOf.length === 1) {
+                    const singleSchema = cleanedObj.anyOf[0];
+                    delete cleanedObj.anyOf;
+                    Object.assign(cleanedObj, singleSchema);
+                }
+            }
+        }
+        else if (typeof currentType === "string") {
+            if (currentType === "null") {
+                return null;
+            }
+            if (isRootLevel && currentType === "array") {
+                return null;
+            }
+        }
+    }
+    if (cleanedObj.hasOwnProperty("properties") &&
+        typeof cleanedObj.properties === "object" &&
+        cleanedObj.properties !== null) {
+        const newProperties = {};
+        for (const key in cleanedObj.properties) {
+            if (cleanedObj.properties.hasOwnProperty(key)) {
+                const cleanedPropertySchema = deepClean(cleanedObj.properties[key], false);
+                if (cleanedPropertySchema !== null) {
+                    newProperties[key] = cleanedPropertySchema;
+                }
+            }
+        }
+        if (Object.keys(newProperties).length === 0) {
+            delete cleanedObj.properties;
+        }
+        else {
+            cleanedObj.properties = newProperties;
+        }
+    }
+    if (cleanedObj.hasOwnProperty("items") &&
+        typeof cleanedObj.items === "object" &&
+        cleanedObj.items !== null) {
+        const cleanedItemsSchema = deepClean(cleanedObj.items, false);
+        if (cleanedItemsSchema === null) {
+            delete cleanedObj.items;
+        }
+        else {
+            cleanedObj.items = cleanedItemsSchema;
+        }
+    }
+    const defKeywords = ["$defs", "definitions"];
+    for (const keyword of defKeywords) {
+        if (cleanedObj.hasOwnProperty(keyword) &&
+            typeof cleanedObj[keyword] === "object" &&
+            cleanedObj[keyword] !== null) {
+            const newDefs = {};
+            for (const defKey in cleanedObj[keyword]) {
+                if (cleanedObj[keyword].hasOwnProperty(defKey)) {
+                    const cleanedDef = deepClean(cleanedObj[keyword][defKey], false);
+                    if (cleanedDef !== null) {
+                        newDefs[defKey] = cleanedDef;
+                    }
+                }
+            }
+            if (Object.keys(newDefs).length === 0) {
+                delete cleanedObj[keyword];
+            }
+            else {
+                cleanedObj[keyword] = newDefs;
+            }
+        }
+    }
+    const schemaArrayKeywords = ["anyOf", "allOf", "oneOf"];
+    for (const keyword of schemaArrayKeywords) {
+        if (cleanedObj.hasOwnProperty(keyword) && Array.isArray(cleanedObj[keyword])) {
+            const newSchemaArray = cleanedObj[keyword]
+                .map((subSchema) => deepClean(subSchema, false))
+                .filter((subSchema) => subSchema !== null);
+            if (newSchemaArray.length === 0) {
+                delete cleanedObj[keyword];
+            }
+            else {
+                cleanedObj[keyword] = newSchemaArray;
+            }
+        }
+    }
+    return cleanedObj;
+}
+function cleanSchema(schema) {
+    if (schema && schema.hasOwnProperty("type")) {
+        const topLevelType = schema.type;
+        if (topLevelType === "array") {
+            return {};
+        }
+        if (Array.isArray(topLevelType)) {
+            const filteredRootTypes = topLevelType.filter((t) => t !== "null" && t !== "array");
+            if (filteredRootTypes.length === 0 && topLevelType.includes("array")) {
+                return {};
+            }
+        }
+    }
+    const result = deepClean(schema, true);
+    return result === null ? {} : result;
+}
+exports.cleanSchema = cleanSchema;