firebase-tools 15.10.1 → 15.12.0

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");
@@ -16,7 +17,8 @@ const secrets_1 = require("../apphosting/secrets");
 const env = require("../functions/env");
 const error_1 = require("../error");
 const os = require("os");
-async function setupAntigravityMcpServer(rootPath, appType) {
+const agentSkills_1 = require("../agentSkills");
+async function setupAntigravityMcpServer(rootPath, appType, nonInteractive) {
     const mcpConfigDir = path.join(os.homedir(), ".gemini", "antigravity");
     const mcpConfigPath = path.join(mcpConfigDir, "mcp_config.json");
     let mcpConfig = { mcpServers: {} };
@@ -38,12 +40,24 @@ 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,
+                    nonInteractive,
+                });
+                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 +65,19 @@ 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,
+                        nonInteractive,
+                    });
+                    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.");
@@ -71,8 +92,7 @@ async function setupAntigravityMcpServer(rootPath, appType) {
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        utils.logWarning(`Could not configure Antigravity MCP server: ${message}`);
+        utils.logWarning(`Could not configure Antigravity MCP server: ${(0, error_1.getErrMsg)(err)}`);
     }
 }
 async function detectAppType(rootPath) {
@@ -200,7 +220,7 @@ async function updateReadme(rootPath, framework) {
     await fs.writeFile(readmePath, newReadme);
     logger_1.logger.info("✅ Updated README.md with project details and origin info");
 }
-async function injectAntigravityContext(rootPath, projectId, appName) {
+async function injectAntigravityContext(rootPath, projectId, appName, nonInteractive) {
     const agentDir = path.join(rootPath, ".agents");
     const rulesDir = path.join(agentDir, "rules");
     const workflowsDir = path.join(agentDir, "workflows");
@@ -208,24 +228,21 @@ async function injectAntigravityContext(rootPath, projectId, appName) {
     await fs.mkdir(rulesDir, { recursive: true });
     await fs.mkdir(workflowsDir, { recursive: true });
     await fs.mkdir(skillsDir, { recursive: true });
-    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"], {
-            cwd: rootPath,
-            stdio: "ignore",
-            shell: process.platform === "win32",
-        });
-        if (result.error) {
-            throw result.error;
-        }
-        if (result.status !== 0) {
-            throw new Error(`npx skills add exited with code ${result.status}`);
-        }
-        logger_1.logger.info(`✅ Added Antigravity skills`);
-    }
-    catch (err) {
-        utils.logWarning(`Could not add Antigravity skills, skipping. ${err}`);
-    }
+    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: nonInteractive || process.env.NODE_ENV === "test",
+    });
+    await (0, agentSkills_1.installAgentSkills)({
+        cwd: rootPath,
+        global: installLocation === "global",
+        background: false,
+        agentName: "gemini-cli",
+    });
     const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
     const systemInstructions = systemInstructionsTemplate.replace("${appName}", appName);
     await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
@@ -236,8 +253,7 @@ async function injectAntigravityContext(rootPath, projectId, appName) {
         logger_1.logger.info("✅ Created Antigravity startup workflow");
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not read or write startup workflow: ${message}`);
+        logger_1.logger.debug(`Could not read or write startup workflow: ${(0, error_1.getErrMsg)(err)}`);
     }
 }
 async function getAgyCommand(startAgy) {
@@ -275,7 +291,7 @@ async function getAgyCommand(startAgy) {
     logger_1.logger.info(`⚠️ Antigravity IDE not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
     return undefined;
 }
-async function createFirebaseConfigs(rootPath, projectId) {
+async function createFirebaseConfigs(rootPath, projectId, nonInteractive) {
     if (!projectId) {
         return;
     }
@@ -310,7 +326,7 @@ async function createFirebaseConfigs(rootPath, projectId) {
                 const confirmBackend = await prompt.confirm({
                     message: `Would you like to use the App Hosting backend "${selectedBackendId}"?`,
                     default: true,
-                    nonInteractive: process.env.NODE_ENV === "test",
+                    nonInteractive: nonInteractive || process.env.NODE_ENV === "test",
                 });
                 if (confirmBackend) {
                     backendId = selectedBackendId;
@@ -335,8 +351,7 @@ async function createFirebaseConfigs(rootPath, projectId) {
             }
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${message}`);
+            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${(0, error_1.getErrMsg)(err)}`);
         }
         const firebaseJson = {
             apphosting: {
@@ -392,8 +407,7 @@ async function writeAntigravityConfigs(rootPath, framework) {
         settings = JSON.parse(settingsContent);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not read ${settingsPath}: ${message}`);
+        logger_1.logger.debug(`Could not read ${settingsPath}: ${(0, error_1.getErrMsg)(err)}`);
     }
     const cleanSettings = {};
     for (const [key, value] of Object.entries(settings)) {
@@ -456,8 +470,7 @@ async function cleanupUnusedFiles(rootPath) {
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not remove ${docsDir}: ${message}`);
+        logger_1.logger.debug(`Could not remove ${docsDir}: ${(0, error_1.getErrMsg)(err)}`);
     }
     const modifiedPath = path.join(rootPath, ".modified");
     try {
@@ -465,8 +478,7 @@ async function cleanupUnusedFiles(rootPath) {
         logger_1.logger.info("✅ Cleaned up .modified");
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${message}`);
+        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${(0, error_1.getErrMsg)(err)}`);
     }
     const mcpJsonPath = path.join(rootPath, ".idx", "mcp.json");
     try {
@@ -474,8 +486,7 @@ async function cleanupUnusedFiles(rootPath) {
         logger_1.logger.info("✅ Cleaned up .idx/mcp.json");
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not delete ${mcpJsonPath}: ${message}`);
+        logger_1.logger.debug(`Could not delete ${mcpJsonPath}: ${(0, error_1.getErrMsg)(err)}`);
     }
 }
 async function upgradeGenkitVersion(rootPath) {
@@ -484,29 +495,30 @@ 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) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_1.logger.debug(`Could not upgrade Genkit version: ${message}`);
+        logger_1.logger.debug(`Could not upgrade Genkit version: ${(0, error_1.getErrMsg)(err)}`);
     }
 }
 async function uploadSecrets(rootPath, projectId) {
@@ -534,11 +546,10 @@ async function uploadSecrets(rootPath, projectId) {
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${message}`);
+        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${(0, error_1.getErrMsg)(err)}`);
     }
 }
-async function askToOpenAntigravity(rootPath, appName, startAntigravity) {
+async function askToOpenAntigravity(rootPath, appName, startAntigravity, nonInteractive) {
     const agyCommand = await getAgyCommand(startAntigravity);
     logger_1.logger.info(`\n🎉 Your Firebase Studio project "${appName}" is now ready for Antigravity!`);
     logger_1.logger.info("Antigravity is Google's agentic IDE, where you can collaborate with AI agents to build, test, and deploy your application.");
@@ -552,6 +563,7 @@ async function askToOpenAntigravity(rootPath, appName, startAntigravity) {
     const answer = await prompt.confirm({
         message: "Would you like to open it in Antigravity now?",
         default: true,
+        nonInteractive,
     });
     if (answer) {
         logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
@@ -586,24 +598,25 @@ async function checkDirectoryExists(dir) {
 async function migrate(rootPath, options = { startAntigravity: true }) {
     await checkDirectoryExists(rootPath);
     const appType = await detectAppType(rootPath);
-    void track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "started" });
+    await 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}`);
     }
     await updateReadme(rootPath, appType);
-    await createFirebaseConfigs(rootPath, projectId);
+    await createFirebaseConfigs(rootPath, projectId, options.nonInteractive);
     await uploadSecrets(rootPath, projectId);
     await upgradeGenkitVersion(rootPath);
-    await injectAntigravityContext(rootPath, projectId, appName);
+    await injectAntigravityContext(rootPath, projectId, appName, options.nonInteractive);
     await writeAntigravityConfigs(rootPath, appType);
-    await setupAntigravityMcpServer(rootPath, appType);
+    await setupAntigravityMcpServer(rootPath, appType, options.nonInteractive);
     await cleanupUnusedFiles(rootPath);
     const currentFolderName = path.basename(rootPath);
     if (currentFolderName === "download") {
         logger_1.logger.info(`\n💡 Tip: You may want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
     }
     await track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "success" });
-    await askToOpenAntigravity(rootPath, appName, options.startAntigravity);
+    await askToOpenAntigravity(rootPath, appName, options.startAntigravity, options.nonInteractive);
 }

package/lib/functions/iac/export.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInternalIac = getInternalIac;
+const runtimes = require("../../deploy/functions/runtimes");
+const supported = require("../../deploy/functions/runtimes/supported");
+const functionsConfig = require("../../functionsConfig");
+const functionsEnv = require("../../functions/env");
+const logger_1 = require("../../logger");
+const yaml = require("js-yaml");
+const projectUtils_1 = require("../../projectUtils");
+const error_1 = require("../../error");
+async function getInternalIac(options, codebase) {
+    if (!codebase.source) {
+        throw new error_1.FirebaseError("Cannot export a codebase with no source");
+    }
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
+    const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
+    const delegateContext = {
+        projectId,
+        sourceDir: options.config.path(codebase.source),
+        projectDir: options.config.projectDir,
+        runtime: codebase.runtime,
+    };
+    const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
+    logger_1.logger.debug(`Validating ${runtimeDelegate.language} source`);
+    supported.guardVersionSupport(runtimeDelegate.runtime);
+    await runtimeDelegate.validate();
+    logger_1.logger.debug(`Building ${runtimeDelegate.language} source`);
+    await runtimeDelegate.build();
+    logger_1.logger.debug(`Discovering ${runtimeDelegate.language} source`);
+    const build = await runtimeDelegate.discoverBuild({}, firebaseEnvs);
+    return {
+        "functions.yaml": yaml.dump(build),
+    };
+}

package/lib/functions/iac/terraform.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expr = expr;
+exports.copyField = copyField;
+exports.renameField = renameField;
+exports.serviceAccount = serviceAccount;
+exports.serializeValue = serializeValue;
+exports.blockToString = blockToString;
+const utils = require("../../utils");
+const error_1 = require("../../error");
+function expr(string) {
+    return { "@type": "HCLExpression", value: string };
+}
+function copyField(attributes, source, field, transform = (v) => v) {
+    renameField(attributes, source, utils.toLowerSnakeCase(field), field, transform);
+}
+function renameField(attributes, source, attributeField, sourceField, transform = (v) => v) {
+    const val = source[sourceField];
+    if (val === undefined) {
+        return;
+    }
+    attributes[attributeField] = val === null ? null : transform(val);
+}
+function serviceAccount(sa) {
+    if (sa.endsWith("@")) {
+        return `${sa}\${var.project}.iam.gserviceaccount.com`;
+    }
+    return sa;
+}
+function serializeValue(value, indentation = 0) {
+    if (typeof value === "string") {
+        value = value.replace(/{{ *params\.PROJECT_ID *}}/g, "${var.project}");
+        if (value.includes("{{ ")) {
+            throw new error_1.FirebaseError("Generalized parameterized fields are not supported in terraform yet");
+        }
+        return JSON.stringify(value);
+    }
+    else if (typeof value === "number" || typeof value === "boolean") {
+        return value.toString();
+    }
+    else if (value === null || value === undefined) {
+        return "null";
+    }
+    else if (Array.isArray(value)) {
+        if (value.some((e) => e !== null &&
+            typeof e === "object" &&
+            (Array.isArray(e) || e["@type"] !== "HCLExpression"))) {
+            return `[\n${value.map((v) => "  ".repeat(indentation + 1) + serializeValue(v, indentation + 1)).join(",\n")}\n${"  ".repeat(indentation)}]`;
+        }
+        return `[${value.map((v) => serializeValue(v)).join(", ")}]`;
+    }
+    else if (typeof value === "object") {
+        if (value["@type"] === "HCLExpression") {
+            return value.value;
+        }
+        const entries = Object.entries(value).map(([k, v]) => `${"  ".repeat(indentation + 1)}${k} = ${serializeValue(v, indentation + 1)}`);
+        return `{\n${entries.join("\n")}\n${"  ".repeat(indentation)}}`;
+    }
+    throw new error_1.FirebaseError(`Unsupported terraform value type ${typeof value}`, { exit: 1 });
+}
+const PREFIX_ARGUMENTS = new Set(["count", "for_each", "provider"]);
+const SUFFIX_ARGUMENTS = new Set(["lifecycle", "depends_on"]);
+const NON_BLOCK_PARAMETERS = {
+    google_cloudfunctions_function: new Set([
+        "name",
+        "runtime",
+        "description",
+        "available_memory_mb",
+        "timeout",
+        "entry_point",
+        "source_archive_bucket",
+        "source_archive_object",
+        "trigger_http",
+        "environment_variables",
+        "vpc_connector",
+        "service_account_email",
+        "max_instances",
+        "min_instances",
+        "project",
+        "region",
+    ]),
+    google_cloudfunctions2_function: new Set(["name", "location", "description", "project"]),
+    google_cloud_scheduler_job: new Set([
+        "name",
+        "description",
+        "schedule",
+        "time_zone",
+        "paused",
+        "attempt_deadline",
+        "region",
+        "project",
+    ]),
+    google_cloud_tasks_queue: new Set(["name", "location", "desired_state", "project"]),
+    google_eventarc_trigger: new Set(["name", "location", "project", "service_account"]),
+    google_pubsub_topic: new Set([
+        "name",
+        "project",
+        "labels",
+        "kms_key_name",
+        "message_retention_duration",
+    ]),
+    google_pubsub_subscription: new Set([
+        "name",
+        "topic",
+        "project",
+        "labels",
+        "ack_deadline_seconds",
+        "message_retention_duration",
+        "retain_acked_messages",
+        "enable_message_ordering",
+        "filter",
+    ]),
+};
+function serializeResourceAttributes(attributes, resourceType, indentation = 0) {
+    const nonBlockParams = NON_BLOCK_PARAMETERS[resourceType] || new Set();
+    const prefixGroup = [];
+    const nonBlockGroup = [];
+    const blockGroup = [];
+    const suffixGroup = [];
+    for (const [k, v] of Object.entries(attributes)) {
+        const serialized = `${"  ".repeat(indentation + 1)}${k} = ${serializeValue(v, indentation + 1)}`;
+        if (PREFIX_ARGUMENTS.has(k)) {
+            prefixGroup.push(serialized);
+        }
+        else if (nonBlockParams.has(k)) {
+            nonBlockGroup.push(serialized);
+        }
+        else if (SUFFIX_ARGUMENTS.has(k)) {
+            suffixGroup.push(serialized);
+        }
+        else {
+            blockGroup.push(serialized);
+        }
+    }
+    const nonemptyGroups = [prefixGroup, nonBlockGroup, blockGroup, suffixGroup].filter((g) => g.length > 0);
+    const joinedGroups = nonemptyGroups.map((g) => g.join("\n")).join("\n\n");
+    return `{\n${joinedGroups}\n${"  ".repeat(indentation)}}`;
+}
+function blockToString(block, indentation = 0) {
+    const labels = (block.labels || []).map((l) => `"${l}"`).join(" ");
+    if (block.type === "resource" && block.labels?.length) {
+        const resourceType = block.labels[0];
+        return `${"  ".repeat(indentation)}${block.type} ${labels ? labels + " " : ""}${serializeResourceAttributes(block.attributes, resourceType, indentation)}`;
+    }
+    return `${"  ".repeat(indentation)}${block.type} ${labels ? labels + " " : ""}${serializeValue(block.attributes, indentation)}`;
+}

package/lib/gcp/ailogic.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = exports.AI_LOGIC_TRIGGERS_TO_EVENTS = exports.AI_LOGIC_EVENTS_TO_TRIGGER = exports.API_VERSION = void 0;
+exports.createTrigger = createTrigger;
+exports.getTrigger = getTrigger;
+exports.updateTrigger = updateTrigger;
+exports.deleteTrigger = deleteTrigger;
+exports.listTriggers = listTriggers;
+exports.upsertBlockingFunction = upsertBlockingFunction;
+exports.deleteBlockingFunction = deleteBlockingFunction;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+const ailogic_1 = require("../deploy/functions/services/ailogic");
+exports.API_VERSION = "v1beta";
+exports.AI_LOGIC_EVENTS_TO_TRIGGER = {
+    [ailogic_1.AI_LOGIC_BEFORE_GENERATE_CONTENT]: "before-generate-content",
+    [ailogic_1.AI_LOGIC_AFTER_GENERATE_CONTENT]: "after-generate-content",
+};
+exports.AI_LOGIC_TRIGGERS_TO_EVENTS = {
+    "before-generate-content": ailogic_1.AI_LOGIC_BEFORE_GENERATE_CONTENT,
+    "after-generate-content": ailogic_1.AI_LOGIC_AFTER_GENERATE_CONTENT,
+};
+exports.client = new apiv2_1.Client({
+    urlPrefix: (0, api_1.aiLogicProxyOrigin)(),
+    auth: true,
+    apiVersion: exports.API_VERSION,
+});
+async function createTrigger(projectId, location, triggerId, trigger, validateOnly = false) {
+    const parent = `projects/${projectId}/locations/${location}`;
+    const res = await exports.client.post(`${parent}/triggers`, trigger, {
+        queryParams: {
+            triggerId,
+            validateOnly: validateOnly ? "true" : "false",
+        },
+    });
+    return res.body;
+}
+async function getTrigger(projectId, location, triggerId) {
+    const name = `projects/${projectId}/locations/${location}/triggers/${triggerId}`;
+    const res = await exports.client.get(name);
+    return res.body;
+}
+async function updateTrigger(projectId, location, triggerId, trigger, updateMask, allowMissing = false, validateOnly = false) {
+    const name = `projects/${projectId}/locations/${location}/triggers/${triggerId}`;
+    const queryParams = {
+        allowMissing: allowMissing ? "true" : "false",
+        validateOnly: validateOnly ? "true" : "false",
+    };
+    if (updateMask && updateMask.length > 0) {
+        queryParams.updateMask = updateMask.join(",");
+    }
+    const res = await exports.client.patch(name, trigger, { queryParams });
+    return res.body;
+}
+async function deleteTrigger(projectId, location, triggerId, allowMissing = false, validateOnly = false, etag) {
+    const name = `projects/${projectId}/locations/${location}/triggers/${triggerId}`;
+    const queryParams = {
+        allowMissing: allowMissing ? "true" : "false",
+        validateOnly: validateOnly ? "true" : "false",
+    };
+    if (etag) {
+        queryParams.etag = etag;
+    }
+    await exports.client.delete(name, { queryParams });
+}
+async function listTriggers(projectId, location, filter) {
+    const parent = `projects/${projectId}/locations/${location}`;
+    let pageToken;
+    const triggers = [];
+    do {
+        const queryParams = pageToken ? { pageToken } : {};
+        if (filter) {
+            queryParams.filter = filter;
+        }
+        const res = await exports.client.get(`${parent}/triggers`, { queryParams });
+        if (res.body.triggers) {
+            triggers.push(...res.body.triggers);
+        }
+        pageToken = res.body.nextPageToken;
+    } while (pageToken);
+    return triggers;
+}
+async function upsertBlockingFunction(endpoint) {
+    const eventType = endpoint.blockingTrigger.eventType;
+    const triggerId = exports.AI_LOGIC_EVENTS_TO_TRIGGER[eventType];
+    const location = endpoint.blockingTrigger.options?.regionalWebhook ? endpoint.region : "global";
+    const triggerBody = {
+        cloudFunction: {
+            id: endpoint.id,
+            locationId: endpoint.region,
+        },
+    };
+    try {
+        return await createTrigger(endpoint.project, location, triggerId, triggerBody);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "status" in err && err.status === 409) {
+            return await updateTrigger(endpoint.project, location, triggerId, triggerBody);
+        }
+        throw err;
+    }
+}
+async function deleteBlockingFunction(endpoint) {
+    const eventType = endpoint.blockingTrigger.eventType;
+    const triggerId = exports.AI_LOGIC_EVENTS_TO_TRIGGER[eventType];
+    const location = endpoint.blockingTrigger.options?.regionalWebhook ? endpoint.region : "global";
+    await deleteTrigger(endpoint.project, location, triggerId, true);
+}

package/lib/gcp/cloudfunctionsv2.js

@@ -21,6 +21,8 @@ const utils = require("../utils");
 const projectConfig = require("../functions/projectConfig");
 const constants_1 = require("../functions/constants");
 const cloudfunctions_1 = require("./cloudfunctions");
+const ailogic_1 = require("./ailogic");
+const ailogic_2 = require("../deploy/functions/services/ailogic");
 const k8s_1 = require("./k8s");
 exports.API_VERSION = "v2";
 const DEFAULT_MAX_INSTANCE_COUNT = 100;
@@ -263,6 +265,13 @@ function functionFromEndpoint(endpoint) {
     else if (backend.isDataConnectGraphqlTriggered(endpoint)) {
         gcfFunction.labels = { ...gcfFunction.labels, "deployment-fdcgraphql": "true" };
     }
+    else if ((0, ailogic_2.isAILogicEvent)(endpoint)) {
+        gcfFunction.labels = {
+            ...gcfFunction.labels,
+            "ailogic-event-type": ailogic_1.AI_LOGIC_EVENTS_TO_TRIGGER[endpoint.blockingTrigger.eventType],
+            "ailogic-locality": endpoint.blockingTrigger.options?.regionalWebhook ? "regional" : "global",
+        };
+    }
     else if (backend.isBlockingTriggered(endpoint)) {
         gcfFunction.labels = {
             ...gcfFunction.labels,
@@ -310,6 +319,21 @@ function endpointFromFunction(gcfFunction) {
             dataConnectGraphqlTrigger: {},
         };
     }
+    else if (gcfFunction.labels?.["ailogic-event-type"]) {
+        const triggerType = gcfFunction.labels["ailogic-event-type"];
+        const eventType = ailogic_1.AI_LOGIC_TRIGGERS_TO_EVENTS[triggerType];
+        if (!eventType) {
+            throw new error_1.FirebaseError(`Unrecognized ailogic-event-type label: ${triggerType}`);
+        }
+        trigger = {
+            blockingTrigger: {
+                eventType,
+                options: {
+                    regionalWebhook: gcfFunction.labels["ailogic-locality"] === "regional",
+                },
+            },
+        };
+    }
     else if (gcfFunction.labels?.[constants_1.BLOCKING_LABEL]) {
         trigger = {
             blockingTrigger: {