firebase-tools 15.10.1 → 15.11.0

package/lib/emulator/functionsEmulator.js

@@ -35,6 +35,8 @@ const v1_1 = require("../functions/events/v1");
 const build_1 = require("../deploy/functions/build");
 const env_1 = require("./env");
 const python_1 = require("../functions/python");
+const supported_1 = require("../deploy/functions/runtimes/supported");
+const dart_1 = require("../deploy/functions/runtimes/dart");
 const EVENT_INVOKE_GA4 = "functions_invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class IPCConn {
@@ -83,6 +85,7 @@ class FunctionsEmulator {
         this.staticBackends = [];
         this.dynamicBackends = [];
         this.watchers = [];
+        this.watchCleanups = [];
         this.debugMode = false;
         this.staticBackends = args.emulatableBackends;
         emulatorLogger_1.EmulatorLogger.setVerbosity(this.args.verbosity ? emulatorLogger_1.Verbosity[this.args.verbosity] : emulatorLogger_1.Verbosity["DEBUG"]);
@@ -208,7 +211,7 @@ class FunctionsEmulator {
     async sendRequest(trigger, body) {
         const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
         const pool = this.workerPools[record.backend.codebase];
-        if (!pool.readyForWork(trigger.id)) {
+        if (!pool.readyForWork(trigger.id, record.backend.runtime)) {
             try {
                 await this.startRuntime(record.backend, trigger);
             }
@@ -217,7 +220,7 @@ class FunctionsEmulator {
                 return;
             }
         }
-        const worker = pool.getIdleWorker(trigger.id);
+        const worker = pool.getIdleWorker(trigger.id, record.backend.runtime);
         if (this.debugMode) {
             await worker.sendDebugMsg({
                 functionTarget: trigger.entryPoint,
@@ -229,10 +232,13 @@ class FunctionsEmulator {
             "Content-Type": "application/json",
             "Content-Length": `${reqBody.length}`,
         };
+        const isDart = (0, supported_1.isLanguageRuntime)(record.backend.runtime, "dart");
+        const path = isDart ? `/${trigger.entryPoint}` : `/`;
         return new Promise((resolve, reject) => {
             const req = http.request({
                 ...worker.runtime.conn.httpReqOpts(),
-                path: `/`,
+                method: "POST",
+                path: path,
                 headers: headers,
             }, resolve);
             req.on("error", reject);
@@ -264,23 +270,43 @@ class FunctionsEmulator {
     async connect() {
         for (const backend of this.staticBackends) {
             this.logger.logLabeled("BULLET", "functions", `Watching "${backend.functionsDir}" for Cloud Functions...`);
-            const watcher = chokidar.watch(backend.functionsDir, {
-                ignored: [
-                    /.+?[\\\/]node_modules[\\\/].+?/,
-                    /(^|[\/\\])\../,
-                    /.+\.log/,
-                    /.+?[\\\/]venv[\\\/].+?/,
-                    ...(backend.ignore?.map((i) => `**/${i}`) ?? []),
-                ],
-                persistent: true,
-            });
-            this.watchers.push(watcher);
-            const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
-            watcher.on("change", (filePath) => {
-                this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
-                return debouncedLoadTriggers();
-            });
             await this.loadTriggers(backend, true);
+            const isDart = (0, supported_1.isLanguageRuntime)(backend.runtime, "dart");
+            if (isDart) {
+                const runtimeDelegateContext = {
+                    projectId: this.args.projectId,
+                    projectDir: this.args.projectDir,
+                    sourceDir: backend.functionsDir,
+                    runtime: backend.runtime,
+                };
+                const delegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
+                this.logger.logLabeled("BULLET", "functions", `Starting build_runner watch for Dart functions...`);
+                const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
+                const cleanup = await delegate.watch(() => {
+                    this.logger.log("DEBUG", "build_runner rebuilt, reloading triggers");
+                    debouncedLoadTriggers();
+                });
+                this.watchCleanups.push(cleanup);
+                this.logger.logLabeled("SUCCESS", "functions", `build_runner initial build completed`);
+            }
+            else {
+                const watcher = chokidar.watch(backend.functionsDir, {
+                    ignored: [
+                        /(^|[\/\\])\../,
+                        /.+\.log/,
+                        /.+?[\\\/]node_modules[\\\/].+?/,
+                        /.+?[\\\/]venv[\\\/].+?/,
+                        ...(backend.ignore?.map((i) => `**/${i}`) ?? []),
+                    ],
+                    persistent: true,
+                });
+                this.watchers.push(watcher);
+                const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
+                watcher.on("change", (filePath) => {
+                    this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
+                    return debouncedLoadTriggers();
+                });
+            }
         }
         await this.performPostLoadOperations();
         return;
@@ -300,6 +326,10 @@ class FunctionsEmulator {
             await watcher.close();
         }
         this.watchers = [];
+        for (const cleanup of this.watchCleanups) {
+            await cleanup();
+        }
+        this.watchCleanups = [];
         if (this.destroyServer) {
             await this.destroyServer();
         }
@@ -1098,13 +1128,52 @@ class FunctionsEmulator {
             conn: new TCPConn("127.0.0.1", port),
         };
     }
+    async startDart(backend, envs) {
+        if (this.debugMode) {
+            this.logger.log("WARN", "--inspect-functions not supported for Dart functions. Ignored.");
+        }
+        const port = await portfinder.getPortPromise({
+            port: 8081 + (0, utils_1.randomInt)(0, 1000),
+        });
+        const args = ["run", "--no-serve-devtools", dart_1.DART_ENTRY_POINT];
+        const dartEnvs = { ...envs };
+        delete dartEnvs.FUNCTION_TARGET;
+        delete dartEnvs.FUNCTION_SIGNATURE_TYPE;
+        const bin = backend.bin || "dart";
+        logger_1.logger.debug(`Starting Dart runtime with args: ${args.join(" ")} on port ${port}`);
+        const childProcess = spawn(bin, args, {
+            cwd: backend.functionsDir,
+            env: {
+                ...process.env,
+                ...dartEnvs,
+                HOST: "127.0.0.1",
+                PORT: port.toString(),
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        childProcess.stdout?.on("data", (chunk) => {
+            this.logger.log("DEBUG", `[dart] ${chunk.toString("utf8")}`);
+        });
+        childProcess.stderr?.on("data", (chunk) => {
+            this.logger.log("DEBUG", `[dart] ${chunk.toString("utf8")}`);
+        });
+        return {
+            process: childProcess,
+            events: new events_1.EventEmitter(),
+            cwd: backend.functionsDir,
+            conn: new TCPConn("127.0.0.1", port),
+        };
+    }
     async startRuntime(backend, trigger) {
         const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
         const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
         let runtime;
-        if (backend.runtime.startsWith("python")) {
+        if ((0, supported_1.isLanguageRuntime)(backend.runtime, "python")) {
             runtime = await this.startPython(backend, { ...runtimeEnv, ...secretEnvs });
         }
+        else if ((0, supported_1.isLanguageRuntime)(backend.runtime, "dart")) {
+            runtime = await this.startDart(backend, { ...runtimeEnv, ...secretEnvs });
+        }
         else {
             runtime = await this.startNode(backend, { ...runtimeEnv, ...secretEnvs });
         }
@@ -1113,7 +1182,7 @@ class FunctionsEmulator {
             ref: backend.extensionVersion?.ref,
         };
         const pool = this.workerPools[backend.codebase];
-        const worker = pool.addWorker(trigger, runtime, extensionLogInfo);
+        const worker = pool.addWorker(trigger, runtime, extensionLogInfo, backend.runtime);
         await worker.waitForSocketReady();
         return worker;
     }
@@ -1172,10 +1241,20 @@ class FunctionsEmulator {
         });
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
-        const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${req.params.trigger_name}\/?`), "/");
+        let path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${req.params.trigger_name}\/?`), "/");
+        const isDart = (0, supported_1.isLanguageRuntime)(record.backend.runtime, "dart");
+        if (isDart) {
+            const isBackgroundRoute = req.url.startsWith("/functions/projects/");
+            if (isBackgroundRoute || path === "/") {
+                path = `/${trigger.entryPoint}`;
+            }
+            else {
+                path = `/${trigger.entryPoint}${path}`;
+            }
+        }
         this.logger.log("DEBUG", `[functions] Got req.url=${req.url}, mapping to path=${path}`);
         const pool = this.workerPools[record.backend.codebase];
-        if (!pool.readyForWork(trigger.id)) {
+        if (!pool.readyForWork(trigger.id, record.backend.runtime)) {
             try {
                 await this.startRuntime(record.backend, trigger);
             }
@@ -1196,7 +1275,7 @@ class FunctionsEmulator {
             method,
             path,
             headers: req.headers,
-        }, res, reqBody, debugBundle);
+        }, res, reqBody, debugBundle, record.backend.runtime);
     }
 }
 exports.FunctionsEmulator = FunctionsEmulator;

package/lib/emulator/functionsRuntimeWorker.js

@@ -8,6 +8,7 @@ const events_1 = require("events");
 const emulatorLogger_1 = require("./emulatorLogger");
 const error_1 = require("../error");
 const discovery_1 = require("../deploy/functions/runtimes/discovery");
+const supported_1 = require("../deploy/functions/runtimes/supported");
 var RuntimeWorkerState;
 (function (RuntimeWorkerState) {
     RuntimeWorkerState["CREATED"] = "CREATED";
@@ -226,13 +227,14 @@ class RuntimeWorkerPool {
         this.mode = mode;
         this.workers = new Map();
     }
-    getKey(triggerId) {
+    getKey(triggerId, runtime) {
         if (this.mode === types_1.FunctionsExecutionMode.SEQUENTIAL) {
             return "~shared~";
         }
-        else {
-            return triggerId || "~diagnostic~";
+        if ((0, supported_1.isLanguageRuntime)(runtime, "dart")) {
+            return "~dart-shared~";
         }
+        return triggerId || "~diagnostic~";
     }
     refresh() {
         for (const arr of this.workers.values()) {
@@ -261,13 +263,13 @@ class RuntimeWorkerPool {
             });
         }
     }
-    readyForWork(triggerId) {
-        const idleWorker = this.getIdleWorker(triggerId);
+    readyForWork(triggerId, runtime) {
+        const idleWorker = this.getIdleWorker(triggerId, runtime);
         return !!idleWorker;
     }
-    async submitRequest(triggerId, req, resp, body, debug) {
+    async submitRequest(triggerId, req, resp, body, debug, runtime) {
         this.log(`submitRequest(triggerId=${triggerId})`);
-        const worker = this.getIdleWorker(triggerId);
+        const worker = this.getIdleWorker(triggerId, runtime);
         if (!worker) {
             throw new error_1.FirebaseError("Internal Error: can't call submitRequest without checking for idle workers");
         }
@@ -276,11 +278,11 @@ class RuntimeWorkerPool {
         }
         return worker.request(req, resp, body, !!debug);
     }
-    getIdleWorker(triggerId) {
+    getIdleWorker(triggerId, runtime) {
         this.cleanUpWorkers();
-        const triggerWorkers = this.getTriggerWorkers(triggerId);
+        const triggerWorkers = this.getTriggerWorkers(triggerId, runtime);
         if (!triggerWorkers.length) {
-            this.setTriggerWorkers(triggerId, []);
+            this.setTriggerWorkers(triggerId, [], runtime);
             return;
         }
         for (const worker of triggerWorkers) {
@@ -290,21 +292,22 @@ class RuntimeWorkerPool {
         }
         return;
     }
-    addWorker(trigger, runtime, extensionLogInfo) {
-        this.log(`addWorker(${this.getKey(trigger?.id)})`);
+    addWorker(trigger, runtime, extensionLogInfo, runtimeType) {
+        const key = this.getKey(trigger?.id, runtimeType);
+        this.log(`addWorker(${key})`);
         const disableTimeout = !trigger?.id || this.mode === types_1.FunctionsExecutionMode.SEQUENTIAL;
         const worker = new RuntimeWorker(trigger?.id, runtime, extensionLogInfo, disableTimeout ? undefined : trigger?.timeoutSeconds);
-        const keyWorkers = this.getTriggerWorkers(trigger?.id);
+        const keyWorkers = this.getTriggerWorkers(trigger?.id, runtimeType);
         keyWorkers.push(worker);
-        this.setTriggerWorkers(trigger?.id, keyWorkers);
+        this.setTriggerWorkers(trigger?.id, keyWorkers, runtimeType);
         this.log(`Adding worker with key ${worker.triggerKey}, total=${keyWorkers.length}`);
         return worker;
     }
-    getTriggerWorkers(triggerId) {
-        return this.workers.get(this.getKey(triggerId)) || [];
+    getTriggerWorkers(triggerId, runtime) {
+        return this.workers.get(this.getKey(triggerId, runtime)) || [];
     }
-    setTriggerWorkers(triggerId, workers) {
-        this.workers.set(this.getKey(triggerId), workers);
+    setTriggerWorkers(triggerId, workers, runtime) {
+        this.workers.set(this.getKey(triggerId, runtime), workers);
     }
     cleanUpWorkers() {
         for (const [key, keyWorkers] of this.workers.entries()) {

package/lib/firebase_studio/migrate.js

@@ -6,6 +6,7 @@ exports.migrate = migrate;
 const fs = require("fs/promises");
 const path = require("path");
 const child_process_1 = require("child_process");
+const semver = require("semver");
 const logger_1 = require("../logger");
 const prompt = require("../prompt");
 const apphosting = require("../gcp/apphosting");
@@ -38,12 +39,23 @@ async function setupAntigravityMcpServer(rootPath, appType) {
         }
         let updated = false;
         if (!mcpConfig.mcpServers["firebase"]) {
-            mcpConfig.mcpServers["firebase"] = {
-                command: "npx",
-                args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
-            };
-            updated = true;
-            logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+            if (utils.commandExistsSync("npx")) {
+                const confirmFirebase = await prompt.confirm({
+                    message: "Would you like to enable the Firebase MCP server for Antigravity?",
+                    default: true,
+                });
+                if (confirmFirebase) {
+                    mcpConfig.mcpServers["firebase"] = {
+                        command: "npx",
+                        args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
+                    };
+                    updated = true;
+                    logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+                }
+            }
+            else {
+                logger_1.logger.info("ℹ️ npx not found on PATH, skipping Firebase MCP server configuration.");
+            }
         }
         else {
             logger_1.logger.info("ℹ️ Firebase MCP server already configured in Antigravity, skipping.");
@@ -51,12 +63,18 @@ async function setupAntigravityMcpServer(rootPath, appType) {
         if (appType === "FLUTTER") {
             if (utils.commandExistsSync("dart")) {
                 if (!mcpConfig.mcpServers["dart"]) {
-                    mcpConfig.mcpServers["dart"] = {
-                        command: "dart",
-                        args: ["mcp-server"],
-                    };
-                    updated = true;
-                    logger_1.logger.info(`✅ Configured Dart MCP server in ${mcpConfigPath}`);
+                    const confirmDart = await prompt.confirm({
+                        message: "Would you like to enable the Dart MCP server for Antigravity?",
+                        default: true,
+                    });
+                    if (confirmDart) {
+                        mcpConfig.mcpServers["dart"] = {
+                            command: "dart",
+                            args: ["mcp-server"],
+                        };
+                        updated = true;
+                        logger_1.logger.info(`✅ Configured Dart MCP server in ${mcpConfigPath}`);
+                    }
                 }
                 else {
                     logger_1.logger.info("ℹ️ Dart MCP server already configured in Antigravity, skipping.");
@@ -208,9 +226,32 @@ async function injectAntigravityContext(rootPath, projectId, appName) {
     await fs.mkdir(rulesDir, { recursive: true });
     await fs.mkdir(workflowsDir, { recursive: true });
     await fs.mkdir(skillsDir, { recursive: true });
+    const installLocation = await prompt.select({
+        message: "Where would you like to install Firebase project skills?",
+        choices: [
+            { name: "Locally in the project", value: "local" },
+            { name: "Globally for all projects", value: "global" },
+        ],
+        default: "local",
+        nonInteractive: process.env.NODE_ENV === "test",
+    });
     logger_1.logger.info("⏳ Adding Antigravity skills...");
     try {
-        const result = (0, child_process_1.spawnSync)("npx", ["-y", "skills", "add", "firebase/agent-skills", "-a", "antigravity", "--skill", "*", "-y"], {
+        const args = [
+            "-y",
+            "skills",
+            "add",
+            "firebase/agent-skills",
+            "-a",
+            "gemini-cli",
+            "--skill",
+            "*",
+            "-y",
+        ];
+        if (installLocation === "global") {
+            args.push("-g");
+        }
+        const result = (0, child_process_1.spawnSync)("npx", args, {
             cwd: rootPath,
             stdio: "ignore",
             shell: process.platform === "win32",
@@ -484,24 +525,26 @@ async function upgradeGenkitVersion(rootPath) {
         const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
         const packageJson = JSON.parse(packageJsonContent);
         let modified = false;
-        const upgradeDeps = (deps) => {
-            if (!deps) {
+        const targetVersion = "1.29.0";
+        const checkAndUpgrade = (deps) => {
+            if (!deps || !deps["genkit-cli"]) {
                 return;
             }
-            for (const [name, version] of Object.entries(deps)) {
-                if (name === "genkit" || name === "genkit-cli" || name.startsWith("@genkit-ai/")) {
-                    if (version !== "1.29") {
-                        deps[name] = "1.29";
-                        modified = true;
-                    }
-                }
+            const currentVersion = deps["genkit-cli"];
+            if (currentVersion.startsWith("^")) {
+                return;
+            }
+            const coerced = semver.coerce(currentVersion);
+            if (coerced && semver.lt(coerced, targetVersion)) {
+                deps["genkit-cli"] = "^1.29";
+                modified = true;
             }
         };
-        upgradeDeps(packageJson.dependencies);
-        upgradeDeps(packageJson.devDependencies);
+        checkAndUpgrade(packageJson.dependencies);
+        checkAndUpgrade(packageJson.devDependencies);
         if (modified) {
             await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
-            logger_1.logger.info("✅ Upgraded Genkit version to 1.29 in package.json");
+            logger_1.logger.info("✅ Upgraded genkit-cli version to 1.29 in package.json");
         }
     }
     catch (err) {
@@ -588,6 +631,7 @@ async function migrate(rootPath, options = { startAntigravity: true }) {
     const appType = await detectAppType(rootPath);
     void track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "started" });
     logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
+    logger_1.logger.info("\nFile any bugs at https://github.com/firebase/firebase-tools/issues");
     const { projectId, appName } = await extractMetadata(rootPath, options.project);
     if (appType) {
         logger_1.logger.info(`✅ Detected framework: ${appType}`);

package/lib/init/features/functions/dart.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const spawn = require("cross-spawn");
+const prompt_1 = require("../../../prompt");
+const supported_1 = require("../../../deploy/functions/runtimes/supported");
+const templates_1 = require("../../../templates");
+const PUBSPEC_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/pubspec.yaml");
+const MAIN_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/server.dart");
+const GITIGNORE_TEMPLATE = (0, templates_1.readTemplateSync)("init/functions/dart/_gitignore");
+async function setup(setup, config) {
+    await config.askWriteProjectFile(`${setup.functions.source}/pubspec.yaml`, PUBSPEC_TEMPLATE);
+    await config.askWriteProjectFile(`${setup.functions.source}/.gitignore`, GITIGNORE_TEMPLATE);
+    await config.askWriteProjectFile(`${setup.functions.source}/bin/server.dart`, MAIN_TEMPLATE);
+    config.set("functions.runtime", (0, supported_1.latest)("dart"));
+    config.set("functions.ignore", [".dart_tool", "build"]);
+    const install = await (0, prompt_1.confirm)({
+        message: "Do you want to install dependencies now?",
+        default: true,
+    });
+    if (install) {
+        const installProcess = spawn("dart", ["pub", "get"], {
+            cwd: config.path(setup.functions.source),
+            stdio: ["inherit", "inherit", "inherit"],
+        });
+        await new Promise((resolve, reject) => {
+            installProcess.on("exit", resolve);
+            installProcess.on("error", reject);
+        });
+    }
+}

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

@@ -144,6 +144,10 @@ async function languageSetup(setup) {
             value: "python",
         });
     }
+    choices.push({
+        name: "Dart",
+        value: "dart",
+    });
     const language = await (0, prompt_1.select)({
         message: "What language would you like to use to write Cloud Functions?",
         default: "javascript",
@@ -173,6 +177,16 @@ async function languageSetup(setup) {
             cbconfig.ignore = ["venv", ".git", "firebase-debug.log", "firebase-debug.*.log", "*.local"];
             cbconfig.runtime = supported.latest("python");
             break;
+        case "dart":
+            cbconfig.ignore = [
+                ".dart_tool",
+                ".git",
+                "firebase-debug.log",
+                "firebase-debug.*.log",
+                "*.local",
+            ];
+            cbconfig.runtime = supported.latest("dart");
+            break;
     }
     setup.functions.languageChoice = language;
 }