firebase-tools 15.18.0 → 15.19.1

package/lib/emulator/downloadableEmulatorInfo.json

@@ -44,46 +44,46 @@
         }
     },
     "pubsub": {
-        "version": "0.8.31",
-        "expectedSize": 52942385,
-        "expectedChecksum": "04a85aa9873222e9b7a430c6c49cfd9e",
-        "expectedChecksumSHA256": "b474e7d3200f5a8b5f7f467ee3b087c94b939e7d41527e935296a7bcabdbea9a",
-        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.31.zip",
-        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.31.zip",
-        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.31/pubsub-emulator/bin/cloud-pubsub-emulator"
+        "version": "0.8.32",
+        "expectedSize": 52942305,
+        "expectedChecksum": "b47a3698985bff5f6aedec04fad9354e",
+        "expectedChecksumSHA256": "476d6492718210837f13e64b5b9f54335469381827bad25eda62e36572e47a82",
+        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.32.zip",
+        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.32.zip",
+        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.32/pubsub-emulator/bin/cloud-pubsub-emulator"
     },
     "dataconnect": {
         "darwin": {
-            "version": "3.4.8",
-            "expectedSize": 32398304,
-            "expectedChecksum": "fee47f6867b5aa939ab667fb801b9807",
-            "expectedChecksumSHA256": "0586ffa3614f9231932ee50fb424ee4385100188aac40de91289c705d36ceb67",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-amd64-v3.4.8",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.8"
+            "version": "3.4.10",
+            "expectedSize": 32439760,
+            "expectedChecksum": "c3609b01993c1f66d340eda59fa31467",
+            "expectedChecksumSHA256": "257419922a81b4856b1ce7c1ac0684b4690a380072fe132d1960070f7d00941a",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-amd64-v3.4.10",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.10"
         },
         "darwin_arm64": {
-            "version": "3.4.8",
-            "expectedSize": 30537682,
-            "expectedChecksum": "f4ccfe080736fb0a35d60841cf439eab",
-            "expectedChecksumSHA256": "d3efdafa7c82f843b1cca7ae2b2404235fa9c918b892806ce4a9910e6907318f",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-arm64-v3.4.8",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.8"
+            "version": "3.4.10",
+            "expectedSize": 30571186,
+            "expectedChecksum": "fd17de6fb356a5e0c1c67ae7f4adfa08",
+            "expectedChecksumSHA256": "9c6da9eea98ee85b16b6e0c5075d1c757aaa252526470fbe63cfb915e3585361",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-arm64-v3.4.10",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.10"
         },
         "win32": {
-            "version": "3.4.8",
-            "expectedSize": 32438272,
-            "expectedChecksum": "5850b1887b23c351d83b32142bac6858",
-            "expectedChecksumSHA256": "d9c2ed151a5d0a9c0530f442f92b3434fe98469e5e6fee230628ba81e9a1540d",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-amd64-v3.4.8",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.8.exe"
+            "version": "3.4.10",
+            "expectedSize": 32479744,
+            "expectedChecksum": "3ed78e5d74da96e89f385a64fa6151fc",
+            "expectedChecksumSHA256": "bc4bb887b5adbba5b916fa41a091f544aac70f35d5209c483fac90f89abb2c93",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-amd64-v3.4.10",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.10.exe"
         },
         "linux": {
-            "version": "3.4.8",
-            "expectedSize": 31555768,
-            "expectedChecksum": "c6b43a325a0e3559d7bc325591dda14f",
-            "expectedChecksumSHA256": "f1809b93e985e497da8ed0a23c049b28f9ff4482b021c9f86af6b8c1a6949fef",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-amd64-v3.4.8",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.8"
+            "version": "3.4.10",
+            "expectedSize": 31592632,
+            "expectedChecksum": "a003103017717ddc4ea9967d5820ea51",
+            "expectedChecksumSHA256": "50b22fdaf7bf1c30b5f331ef07a7f19c51309ca9c9897be426e86254e02b514c",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-amd64-v3.4.10",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.10"
         }
     }
 }

package/lib/experiments.js

@@ -127,9 +127,9 @@ exports.ALL_EXPERIMENTS = experiments({
         public: false,
     },
     abiu: {
-        shortDescription: "Enable App Hosting ABIU and runtime selection",
-        default: false,
-        public: false,
+        shortDescription: "Enable Automatic Base Image Updates (ABIU) and runtime selection for App Hosting",
+        default: true,
+        public: true,
     },
     dataconnect: {
         shortDescription: "Deprecated. Previosuly, enabled SQL Connect related features.",
@@ -182,6 +182,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
+    crashlyticsWeb: {
+        shortDescription: "Enable the ability to upload source maps for web apps to Crashlytics.",
+        default: false,
+        public: true,
+    },
 });
 function isValidExperiment(name) {
     return Object.keys(exports.ALL_EXPERIMENTS).includes(name);

package/lib/firebase_studio/migrate.js

@@ -242,6 +242,14 @@ async function injectAntigravityContext(rootPath, projectId, appName, nonInterac
         global: installLocation === "global",
         background: false,
         agentName: "gemini-cli",
+        skillPackage: "firebase/agent-skills",
+    });
+    await (0, agentSkills_1.installAgentSkills)({
+        cwd: rootPath,
+        global: installLocation === "global",
+        background: false,
+        agentName: "gemini-cli",
+        skillPackage: "genkit-ai/skills",
     });
     const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
     const systemInstructions = systemInstructionsTemplate.replace("${appName}", appName);

package/lib/gcp/cloudsql/connect.js

@@ -58,38 +58,62 @@ async function execute(sqlStatements, opts) {
             : cloud_sql_connector_1.IpAddressTypes.PRIVATE,
         authType: authType,
     };
-    const pool = new pg.Pool({
-        ...(await connector.getOptions(connectionOpts)),
-        password: opts.password,
-        user: opts.username,
-        database: opts.databaseId,
-    });
-    const cleanUpFn = async () => {
-        conn.release();
-        await pool.end();
-        connector.close();
-    };
-    const conn = await pool.connect();
+    let pool;
+    let conn;
     const results = [];
-    logFn(`Logged in as ${opts.username}`);
-    if (opts.transaction) {
-        sqlStatements.unshift("BEGIN;");
-        sqlStatements.push("COMMIT;");
+    try {
+        pool = new pg.Pool({
+            ...(await connector.getOptions(connectionOpts)),
+            password: opts.password,
+            user: opts.username,
+            database: opts.databaseId,
+        });
+        pool.on("error", (err) => {
+            logger_1.logger.debug("[cloudsql] pool error (ignored during teardown):", err);
+        });
+        conn = await pool.connect();
+        logFn(`Logged in as ${opts.username}`);
+        if (opts.transaction) {
+            sqlStatements.unshift("BEGIN;");
+            sqlStatements.push("COMMIT;");
+        }
+        for (const s of sqlStatements) {
+            logFn(`> ${s}`);
+            try {
+                results.push(await conn.query(s));
+            }
+            catch (err) {
+                logFn(`Rolling back transaction due to error ${err}}`);
+                await conn.query("ROLLBACK;");
+                throw new error_1.FirebaseError(`Error executing SQL statement: ${s}: ${err}`);
+            }
+        }
+        logFn(``);
     }
-    for (const s of sqlStatements) {
-        logFn(`> ${s}`);
+    finally {
+        if (conn) {
+            try {
+                conn.release();
+            }
+            catch (err) {
+                logger_1.logger.debug("[cloudsql] error releasing connection during cleanup:", err);
+            }
+        }
+        if (pool) {
+            try {
+                await pool.end();
+            }
+            catch (err) {
+                logger_1.logger.debug("[cloudsql] error ending pool during cleanup:", err);
+            }
+        }
         try {
-            results.push(await conn.query(s));
+            connector.close();
         }
         catch (err) {
-            logFn(`Rolling back transaction due to error ${err}}`);
-            await conn.query("ROLLBACK;");
-            await cleanUpFn();
-            throw new error_1.FirebaseError(`Error executing ${err}`);
+            logger_1.logger.debug("[cloudsql] error closing connector during cleanup:", err);
         }
     }
-    await cleanUpFn();
-    logFn(``);
     return results;
 }
 async function executeSqlCmdsAsIamUser(options, instanceId, databaseId, cmds, silent = false, transaction = false) {

package/lib/gemini/fdcExperience.js

@@ -7,41 +7,186 @@ exports.extractCodeBlock = extractCodeBlock;
 const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
 const error_1 = require("../error");
-const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.cloudAiCompanionOrigin)(), auth: true });
-const SCHEMA_GENERATOR_EXPERIENCE = "/appeco/firebase/fdc-schema-generator";
-const OPERATION_GENERATION_EXPERIENCE = "/appeco/firebase/fdc-query-generator";
-const FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME = "type.googleapis.com/google.cloud.cloudaicompanion.v1main.FirebaseChatRequestContext";
+const logger_1 = require("../logger");
+const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.dataconnectOrigin)(), auth: true });
 exports.PROMPT_GENERATE_CONNECTOR = "Create 4 operations for an app using the instance schema with proper authentication.";
 exports.PROMPT_GENERATE_SEED_DATA = "Create a mutation to populate the database with some seed data.";
-async function generateSchema(prompt, project, chatHistory = []) {
-    const res = await apiClient.post(`/v1beta/projects/${project}/locations/global/instances/default:completeTask`, {
-        input: { messages: [...chatHistory, { content: prompt, author: "USER" }] },
-        experienceContext: {
-            experience: SCHEMA_GENERATOR_EXPERIENCE,
-        },
+function logCurl(method, path, body) {
+    const url = `${(0, api_1.dataconnectOrigin)()}${path}`;
+    const headers = [
+        '-H "Content-Type: application/json"',
+        '-H "Authorization: Bearer $(gcloud auth print-access-token)"',
+    ].join(" ");
+    const curl = `curl -X ${method} "${url}" ${headers} -d '${JSON.stringify(body)}'`;
+    logger_1.logger.debug(`[Agent Service] Reusable cURL command:\\n${curl}`);
+}
+async function generateSchema(prompt, project, location, onStatus) {
+    const path = `/v1/projects/${project}/locations/${location}/services/-:generateSchema`;
+    const body = {
+        name: `projects/${project}/locations/${location}/services/-`,
+        prompt,
+    };
+    logCurl("POST", path, body);
+    const res = await apiClient.request({
+        method: "POST",
+        path,
+        body,
+        responseType: "stream",
+        resolveOnHTTPError: true,
+    });
+    if (res.status >= 400) {
+        const errorText = await readStream(res.body);
+        throw new error_1.FirebaseError(`Failed to generate schema. Status: ${res.status}, Message: ${errorText}`);
+    }
+    return consumeStream(res.body, onStatus);
+}
+async function generateOperation(prompt, service, project, schemas, onStatus) {
+    let location = "us-central1";
+    let serviceId = service;
+    if (service.startsWith("projects/")) {
+        const parts = service.split("/");
+        project = parts[1];
+        location = parts[3];
+        serviceId = parts[5];
+    }
+    if (schemas && schemas.length > 0) {
+        serviceId = "-";
+    }
+    const path = `/v1/projects/${project}/locations/${location}/services/${serviceId}:generateQuery`;
+    const body = {
+        name: `projects/${project}/locations/${location}/services/${serviceId}`,
+        prompt,
+        schemas,
+    };
+    logCurl("POST", path, body);
+    const res = await apiClient.request({
+        method: "POST",
+        path,
+        body,
+        responseType: "stream",
+        resolveOnHTTPError: true,
     });
-    return extractCodeBlock(res.body.output.messages[0].content);
+    if (res.status >= 400) {
+        const errorText = await readStream(res.body);
+        throw new error_1.FirebaseError(`Failed to generate operation. Status: ${res.status}, Message: ${errorText}`);
+    }
+    return consumeStream(res.body, onStatus);
 }
-async function generateOperation(prompt, service, project, chatHistory = []) {
-    const res = await apiClient.post(`/v1beta/projects/${project}/locations/global/instances/default:completeTask`, {
-        input: { messages: [...chatHistory, { content: prompt, author: "USER" }] },
-        experienceContext: {
-            experience: OPERATION_GENERATION_EXPERIENCE,
-        },
-        clientContext: {
-            additionalContext: {
-                "@type": FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME,
-                fdcInfo: { fdcServiceName: service, requiresQuery: true },
-            },
-        },
+async function readStream(stream) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        stream.on("data", (chunk) => {
+            data += chunk.toString();
+        });
+        stream.on("end", () => {
+            resolve(data);
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+async function consumeStream(stream, onStatus) {
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let fullText = "";
+        stream.on("data", (chunk) => {
+            const text = chunk.toString();
+            fullText += text;
+            buffer += text;
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.substring(0, newlineIndex).trim();
+                buffer = buffer.substring(newlineIndex + 1);
+                if (line) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.status && onStatus) {
+                            onStatus(obj.status);
+                        }
+                    }
+                    catch (err) {
+                    }
+                }
+            }
+        });
+        stream.on("end", () => {
+            try {
+                const response = JSON.parse(fullText);
+                if (Array.isArray(response)) {
+                    let code = "";
+                    for (const item of response) {
+                        if (item.status && onStatus) {
+                            onStatus(item.status);
+                        }
+                        if (item.part?.textChunk?.text) {
+                            code += item.part.textChunk.text;
+                        }
+                        if (item.part?.codeChunk?.code) {
+                            code += item.part.codeChunk.code;
+                        }
+                    }
+                    if (code) {
+                        resolve(extractCodeBlock(code));
+                    }
+                    else {
+                        resolve(fullText);
+                    }
+                }
+                else {
+                    const resObj = response;
+                    if (resObj.part?.codeChunk?.code) {
+                        resolve(extractCodeBlock(resObj.part.codeChunk.code));
+                    }
+                    else if (resObj.part?.textChunk?.text) {
+                        resolve(extractCodeBlock(resObj.part.textChunk.text));
+                    }
+                    else {
+                        resolve(fullText);
+                    }
+                }
+            }
+            catch (e) {
+                const lines = fullText.trim().split("\n");
+                let code = "";
+                for (const line of lines) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.part?.codeChunk?.code) {
+                            code += obj.part.codeChunk.code;
+                        }
+                        else if (obj.part?.textChunk?.text) {
+                            code += obj.part.textChunk.text;
+                        }
+                        if (obj.status && onStatus) {
+                            onStatus(obj.status);
+                        }
+                    }
+                    catch (err) {
+                        logger_1.logger.error("Failed to parse FSQL Generate response: ", err);
+                    }
+                }
+                if (code) {
+                    resolve(extractCodeBlock(code));
+                }
+                else {
+                    resolve(fullText);
+                }
+            }
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
     });
-    return extractCodeBlock(res.body.output.messages[0].content);
 }
 function extractCodeBlock(text) {
     const regex = /```(?:[a-z]+\n)?([\s\S]*?)```/m;
-    const match = text.match(regex);
+    const match = regex.exec(text);
     if (match && match[1]) {
         return match[1].trim();
     }
-    throw new error_1.FirebaseError(`No code block found in the generated response: ${text}`);
+    if (!text.includes("{")) {
+        logger_1.logger.warn("[Agent Service] Response seems to be plain text, no GraphQL code block found.");
+    }
+    return text.trim();
 }

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

@@ -79,7 +79,6 @@ async function askQuestions(setup, config, options) {
             });
             if (wantToGenerate) {
                 configstore_1.configstore.set("gemini", true);
-                await (0, ensureApis_1.ensureGIFApiTos)(setup.projectId);
                 info.appDescription = await (0, prompt_1.input)({
                     message: `Describe your app idea:`,
                     validate: async (s) => {
@@ -168,25 +167,59 @@ async function actuateWithInfo(setup, config, info, options) {
         return await writeFiles(config, info, templateServiceInfo, options);
     }
     const serviceAlreadyExists = !(await (0, client_1.createService)(projectId, info.locationId, info.serviceId));
-    const schemaGql = await (0, utils_1.promiseWithSpinner)(() => (0, fdcExperience_1.generateSchema)(info.appDescription, projectId), "Generating the SQL Connect Schema...");
+    const schemaGql = await (0, utils_1.promiseWithSpinner)(() => (0, fdcExperience_1.generateSchema)(info.appDescription, projectId, info.locationId), "Generating the SQL Connect Schema...");
     const schemaFiles = [{ path: "schema.gql", content: schemaGql }];
     if (serviceAlreadyExists) {
         (0, utils_1.logLabeledError)("dataconnect", `SQL Connect Service ${serviceName} already exists. Skip saving them...`);
         info.flow += "_save_gemini_service_already_exists";
         return await writeFiles(config, info, { schemaGql: schemaFiles, connectors: [] }, options);
     }
+    const schemas = [
+        {
+            name: `${serviceName}/schemas/${types_1.MAIN_SCHEMA_ID}`,
+            datasources: [],
+            source: {
+                files: schemaFiles,
+            },
+        },
+    ];
+    let operationGql = "";
+    let seedDataGql = "";
+    let genOperationsSuccess = false;
+    let genOperationsError = null;
     await (0, utils_1.promiseWithSpinner)(async () => {
-        const [saveSchemaGql, waitForCloudSQLProvision] = schemasDeploySequence(projectId, info, schemaFiles, info.shouldProvisionCSQL);
-        await (0, client_1.upsertSchema)(saveSchemaGql);
-        if (waitForCloudSQLProvision) {
-            void (0, client_1.upsertSchema)(waitForCloudSQLProvision);
+        const deployPromise = (async () => {
+            const [saveSchemaGql, waitForCloudSQLProvision] = schemasDeploySequence(projectId, info, schemaFiles, info.shouldProvisionCSQL);
+            await (0, client_1.upsertSchema)(saveSchemaGql);
+            if (waitForCloudSQLProvision) {
+                void (0, client_1.upsertSchema)(waitForCloudSQLProvision);
+            }
+        })();
+        const opPromise = (async () => {
+            try {
+                const [op, seed] = await Promise.all([
+                    (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_CONNECTOR, serviceName, projectId, schemas),
+                    (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_SEED_DATA, serviceName, projectId, schemas),
+                ]);
+                return { op, seed, success: true };
+            }
+            catch (err) {
+                (0, utils_1.logLabeledError)("dataconnect", `Deployment failed: ${err instanceof Error ? err.message : String(err)}`);
+                return { success: false, error: err };
+            }
+        })();
+        const [, opResult] = await Promise.all([deployPromise, opPromise]);
+        if (opResult.success && opResult.op && opResult.seed) {
+            operationGql = opResult.op;
+            seedDataGql = opResult.seed;
+            genOperationsSuccess = true;
         }
-    }, "Saving the SQL Connect Schema...");
-    try {
-        const [operationGql, seedDataGql] = await (0, utils_1.promiseWithSpinner)(() => Promise.all([
-            (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_CONNECTOR, serviceName, projectId),
-            (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_SEED_DATA, serviceName, projectId),
-        ]), "Generating the SQL Connect Operations...");
+        else {
+            (0, utils_1.logLabeledError)("dataconnect", `Operation Generation failed...`);
+            genOperationsError = opResult.error;
+        }
+    }, "Saving the SQL Connect Schema and generating operations...");
+    if (genOperationsSuccess) {
         const connectors = [
             {
                 id: "example",
@@ -202,11 +235,12 @@ async function actuateWithInfo(setup, config, info, options) {
         info.flow += "_save_gemini";
         await writeFiles(config, info, { schemaGql: schemaFiles, connectors: connectors, seedDataGql: seedDataGql }, options);
     }
-    catch (err) {
-        (0, utils_1.logLabeledError)("dataconnect", `Operation Generation failed...`);
+    else {
         info.flow += "_save_gemini_operation_error";
         await writeFiles(config, info, { schemaGql: schemaFiles, connectors: [] }, options);
-        throw err;
+    }
+    if (genOperationsError) {
+        throw genOperationsError;
     }
 }
 function schemasDeploySequence(projectId, info, schemaFiles, linkToCloudSql) {