firebase-tools 14.4.0 → 14.5.0

package/lib/mcp/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFeatureActive = 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");
@@ -62,6 +62,7 @@ const SERVER_FEATURE_APIS = {
     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;
@@ -77,3 +78,138 @@ async function checkFeatureActive(feature, projectId, options) {
     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;

package/lib/mcp/util.test.js

@@ -0,0 +1,468 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const util_1 = require("./util");
+const testCases = [
+    {
+        desc: "should remove $schema property",
+        input: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: { name: { type: "string" } },
+        },
+        expected: {
+            type: "object",
+            properties: { name: { type: "string" } },
+        },
+    },
+    {
+        desc: "should remove additionalProperties field",
+        input: {
+            type: "object",
+            properties: { name: { type: "string" } },
+            additionalProperties: false,
+        },
+        expected: {
+            type: "object",
+            properties: { name: { type: "string" } },
+        },
+    },
+    {
+        desc: "should remove additionalProperties from nested objects",
+        input: {
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: { id: { type: "number" } },
+                    additionalProperties: true,
+                },
+                meta: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            additionalProperties: false,
+        },
+        expected: {
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: { id: { type: "number" } },
+                },
+                meta: {
+                    type: "object",
+                },
+            },
+        },
+    },
+    {
+        desc: "should remove top-level array type (string)",
+        input: { type: "array", items: { type: "string" } },
+        expected: {},
+    },
+    {
+        desc: "should remove top-level array type (array of types including array)",
+        input: { type: ["array", "string"], items: { type: "string" } },
+        expected: { type: "string", items: { type: "string" } },
+    },
+    {
+        desc: "should remove top-level array type (array of types including array and null)",
+        input: { type: ["array", "null"], items: { type: "string" } },
+        expected: {},
+    },
+    {
+        desc: "should remove top-level null type",
+        input: { type: "null" },
+        expected: {},
+    },
+    {
+        desc: "should KEEP array type in properties",
+        input: {
+            type: "object",
+            properties: {
+                tags: { type: "array", items: { type: "string" } },
+                name: { type: "string" },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                tags: { type: "array", items: { type: "string" } },
+                name: { type: "string" },
+            },
+        },
+    },
+    {
+        desc: "should remove null type from properties",
+        input: {
+            type: "object",
+            properties: {
+                optionalField: { type: "null" },
+                name: { type: "string" },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: { name: { type: "string" } },
+        },
+    },
+    {
+        desc: "should convert type: ['string', 'null', 'array'] to anyOf: [{type: 'string'}, {type: 'array'}] in properties",
+        input: {
+            type: "object",
+            properties: {
+                mixed: { type: ["string", "null", "array"] },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                mixed: { anyOf: [{ type: "string" }, { type: "array" }] },
+            },
+        },
+    },
+    {
+        desc: "should convert type: ['string', 'number', 'null', 'array'] to anyOf in properties",
+        input: {
+            type: "object",
+            properties: {
+                mixed: { type: ["string", "number", "null", "array"] },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                mixed: { anyOf: [{ type: "string" }, { type: "number" }, { type: "array" }] },
+            },
+        },
+    },
+    {
+        desc: "should simplify type: ['string', 'null'] to type: 'string' in properties",
+        input: {
+            type: "object",
+            properties: {
+                simpleMixed: { type: ["string", "null"] },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                simpleMixed: { type: "string" },
+            },
+        },
+    },
+    {
+        desc: "should remove property if its type array becomes empty after filtering (e.g. only null)",
+        input: {
+            type: "object",
+            properties: {
+                onlyNull: { type: ["null"] },
+                name: { type: "string" },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: { name: { type: "string" } },
+        },
+    },
+    {
+        desc: "should keep property if its type array contains only 'array' (not root) and simplify",
+        input: {
+            type: "object",
+            properties: {
+                onlyArray: { type: ["array", "null"] },
+                name: { type: "string" },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                onlyArray: { type: "array" },
+                name: { type: "string" },
+            },
+        },
+    },
+    {
+        desc: "should handle nested objects and clean them (arrays kept in nested, type arrays become anyOf or simplified)",
+        input: {
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: {
+                        id: { type: "number" },
+                        tags: { type: "array", items: { type: "string" } },
+                        status: { type: ["string", "integer", "null"] },
+                        maybeName: { type: ["string", "null"] },
+                    },
+                },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                user: {
+                    type: "object",
+                    properties: {
+                        id: { type: "number" },
+                        tags: { type: "array", items: { type: "string" } },
+                        status: { anyOf: [{ type: "string" }, { type: "integer" }] },
+                        maybeName: { type: "string" },
+                    },
+                },
+            },
+        },
+    },
+    {
+        desc: "should remove items if its schema becomes null",
+        input: {
+            type: "object",
+            properties: {
+                someObjectWithItems: {
+                    type: "object",
+                    items: { type: "null" },
+                },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                someObjectWithItems: {
+                    type: "object",
+                },
+            },
+        },
+    },
+    {
+        desc: "should clean definitions ($defs), convert type arrays to anyOf/simplified",
+        input: {
+            type: "object",
+            properties: {
+                myDef: { $ref: "#/$defs/invalidDef" },
+                myValidDef: { $ref: "#/$defs/validDefWithArray" },
+                myComplexDef: { $ref: "#/$defs/complexDef" },
+            },
+            $defs: {
+                invalidDef: { type: "null" },
+                validDef: { type: "string" },
+                validDefWithArray: { type: "array", items: { type: "number" } },
+                complexDef: { type: ["boolean", "string", "null"] },
+            },
+        },
+        expected: {
+            type: "object",
+            properties: {
+                myDef: { $ref: "#/$defs/invalidDef" },
+                myValidDef: { $ref: "#/$defs/validDefWithArray" },
+                myComplexDef: { $ref: "#/$defs/complexDef" },
+            },
+            $defs: {
+                validDef: { type: "string" },
+                validDefWithArray: { type: "array", items: { type: "number" } },
+                complexDef: { anyOf: [{ type: "boolean" }, { type: "string" }] },
+            },
+        },
+    },
+    {
+        desc: "should remove $defs if all definitions become invalid (e.g. all null)",
+        input: {
+            type: "object",
+            $defs: {
+                invalidDef1: { type: "null" },
+                invalidDef2: { type: "null" },
+            },
+        },
+        expected: {
+            type: "object",
+        },
+    },
+    {
+        desc: "should clean schema arrays (anyOf, allOf, oneOf), keep nested arrays, convert internal type arrays",
+        input: {
+            anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "number" } },
+                { type: "null" },
+                { type: ["integer", "boolean", "null"] },
+            ],
+            allOf: [{ type: "number" }],
+            oneOf: [{ type: "boolean" }, { type: ["null", "array"] }],
+        },
+        expected: {
+            anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "number" } },
+                { anyOf: [{ type: "integer" }, { type: "boolean" }] },
+            ],
+            allOf: [{ type: "number" }],
+            oneOf: [{ type: "boolean" }, { type: "array" }],
+        },
+    },
+    {
+        desc: "should remove schema array keywords if their arrays become empty (e.g. all null)",
+        input: {
+            anyOf: [{ type: "null" }, { type: "null" }],
+            description: "test",
+        },
+        expected: {
+            description: "test",
+        },
+    },
+    {
+        desc: "should return an empty object if the entire schema is just { type: 'array' }",
+        input: { type: "array" },
+        expected: {},
+    },
+    {
+        desc: "should return an empty object if the entire schema is just { type: 'null' }",
+        input: { type: "null" },
+        expected: {},
+    },
+    {
+        desc: "should return an empty object if the entire schema is { type: ['null', 'array'] }",
+        input: { type: ["null", "array"] },
+        expected: {},
+    },
+    {
+        desc: "should not modify a schema that is already clean (with nested array and anyOf)",
+        input: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "integer" },
+                scores: { type: "array", items: { type: "number" } },
+                choice: { anyOf: [{ type: "string" }, { type: "boolean" }] },
+            },
+            required: ["name"],
+        },
+        expected: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "integer" },
+                scores: { type: "array", items: { type: "number" } },
+                choice: { anyOf: [{ type: "string" }, { type: "boolean" }] },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        desc: "should handle deeply nested structures with various cleaning needs (arrays kept if not root, type arrays to anyOf)",
+        input: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: "Complex Test",
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                validProp: { type: "string" },
+                propToBeKept: { type: "array", items: { type: "number" } },
+                objectWithMixedTypes: {
+                    type: "object",
+                    additionalProperties: true,
+                    properties: {
+                        subPropString: { type: "string" },
+                        subPropNull: { type: "null" },
+                        subPropArrayType: { type: ["integer", "null", "array", "string"] },
+                    },
+                },
+                anotherArrayProp: { type: "array", items: { type: "boolean" } },
+            },
+            $defs: {
+                reusableInvalid: { type: "null" },
+                reusableValid: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                    properties: {
+                        detail: { type: "string" },
+                        unwantedList: { type: "array", items: { type: "string" } },
+                        statusOptions: { type: ["number", "string", "null"] },
+                    },
+                },
+                toBeEmptyDef: { type: "null" },
+            },
+            anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "object" } },
+                { $ref: "#/$defs/reusableInvalid" },
+                { type: ["boolean", "null", "integer"] },
+            ],
+        },
+        expected: {
+            title: "Complex Test",
+            type: "object",
+            properties: {
+                validProp: { type: "string" },
+                propToBeKept: { type: "array", items: { type: "number" } },
+                objectWithMixedTypes: {
+                    type: "object",
+                    properties: {
+                        subPropString: { type: "string" },
+                        subPropArrayType: {
+                            anyOf: [{ type: "integer" }, { type: "array" }, { type: "string" }],
+                        },
+                    },
+                },
+                anotherArrayProp: { type: "array", items: { type: "boolean" } },
+            },
+            $defs: {
+                reusableValid: {
+                    type: "object",
+                    properties: {
+                        detail: { type: "string" },
+                        unwantedList: { type: "array", items: { type: "string" } },
+                        statusOptions: { anyOf: [{ type: "number" }, { type: "string" }] },
+                    },
+                },
+            },
+            anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "object" } },
+                { anyOf: [{ type: "boolean" }, { type: "integer" }] },
+            ],
+        },
+    },
+    {
+        desc: "should remove properties if properties object becomes empty (all null)",
+        input: {
+            type: "object",
+            properties: {
+                field1: { type: "null" },
+                field2: { type: "null" },
+            },
+        },
+        expected: {
+            type: "object",
+        },
+    },
+    {
+        desc: "top level schema with type: ['string', 'array'] should become type: 'string'",
+        input: {
+            type: ["string", "array"],
+            description: "Test",
+        },
+        expected: {
+            type: "string",
+            description: "Test",
+        },
+    },
+    {
+        desc: "top level schema with type: ['string', 'number', 'array'] should become anyOf: [{type: string}, {type: number}]",
+        input: {
+            type: ["string", "number", "array"],
+            description: "Test AnyOf Root",
+        },
+        expected: {
+            anyOf: [{ type: "string" }, { type: "number" }],
+            description: "Test AnyOf Root",
+        },
+    },
+];
+describe("cleanSchema", () => {
+    testCases.forEach((tc) => {
+        it(tc.desc, () => {
+            (0, chai_1.expect)((0, util_1.cleanSchema)(tc.input)).to.deep.equal(tc.expected);
+        });
+    });
+});

package/lib/prompt.js

@@ -70,7 +70,7 @@ async function number(opts) {
             return value;
         }
     }
-    return (await inquirer.number(Object.assign(Object.assign({}, opts), { required: true })));
+    return await inquirer.number(Object.assign({ required: true }, opts));
 }
 exports.number = number;
 async function password(opts) {

package/lib/track.js

@@ -25,7 +25,7 @@ exports.GA4_PROPERTIES = {
     },
 };
 function usageEnabled() {
-    return !!process.env.IS_FIREBASE_CLI && !!configstore_1.configstore.get("usage");
+    return ((!!process.env.IS_FIREBASE_CLI || !!process.env.IS_FIREBASE_MCP) && !!configstore_1.configstore.get("usage"));
 }
 exports.usageEnabled = usageEnabled;
 const GA4_USER_PROPS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "14.4.0",
+  "version": "14.5.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {

package/schema/connector-yaml.json

@@ -90,6 +90,18 @@
           ],
           "description": "Configuration for a generated Javascript SDK"
         },
+        "dartSdk": {
+          "oneOf": [
+            { "$ref": "#/definitions/dartSdk" },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/dartSdk"
+              }
+            }
+          ],
+          "description": "Configuration for a generated Dart SDK"
+        },
         "kotlinSdk": {
           "oneOf": [
             { "$ref": "#/definitions/kotlinSdk" },