firebase-tools 15.9.0 → 15.9.2-ct-studioexport3.0

package/lib/appdistribution/distribution.js

@@ -39,7 +39,7 @@ async function upload(requests, appName, distribution) {
         utils.logSuccess(`View this release in the Firebase console: ${release.firebaseConsoleUri}`);
         utils.logSuccess(`Share this release with testers who have access: ${release.testingUri}`);
         utils.logSuccess(`Download the release binary (link expires in 1 hour): ${release.binaryDownloadUri}`);
-        return uploadResponse.release.name;
+        return uploadResponse.release;
     }
     catch (err) {
         if ((0, error_1.getErrStatus)(err) === 404) {

package/lib/appdistribution/options-parser-util.js

@@ -50,7 +50,14 @@ function getAppName(options) {
     }
     return toAppName(options.app);
 }
+const APP_ID_FORMAT = /^\d+:\d+:(android|ios|web):[a-fA-F0-9]+$/;
+function validateAppId(appId) {
+    if (!APP_ID_FORMAT.test(appId)) {
+        throw new error_1.FirebaseError(`Invalid Firebase app ID: ${appId}`);
+    }
+}
 function toAppName(appId) {
+    validateAppId(appId);
     return `projects/${appId.split(":")[1]}/apps/${appId}`;
 }
 function parseTestDevices(value, file = "") {

package/lib/apphosting/config.js

@@ -4,6 +4,7 @@ exports.APPHOSTING_YAML_FILE_REGEX = exports.APPHOSTING_LOCAL_YAML_FILE = export
 exports.discoverBackendRoot = discoverBackendRoot;
 exports.listAppHostingFilesInPath = listAppHostingFilesInPath;
 exports.load = load;
+exports.getAppHostingConfiguration = getAppHostingConfiguration;
 exports.store = store;
 exports.findEnv = findEnv;
 exports.upsertEnv = upsertEnv;
@@ -22,6 +23,7 @@ const yaml_1 = require("./yaml");
 const logger_1 = require("../logger");
 const csm = require("../gcp/secretManager");
 const error_1 = require("../error");
+const path_2 = require("path");
 exports.APPHOSTING_BASE_YAML_FILE = "apphosting.yaml";
 exports.APPHOSTING_EMULATORS_YAML_FILE = "apphosting.emulator.yaml";
 exports.APPHOSTING_LOCAL_YAML_FILE = "apphosting.local.yaml";
@@ -64,6 +66,28 @@ function load(yamlPath) {
     }
     return yaml.parseDocument(raw);
 }
+const dynamicDispatch = exports;
+async function getAppHostingConfiguration(backendDir) {
+    const appHostingConfigPaths = dynamicDispatch.listAppHostingFilesInPath(backendDir);
+    const fileNameToPathMap = Object.fromEntries(appHostingConfigPaths.map((path) => [(0, path_2.basename)(path), path]));
+    const output = yaml_1.AppHostingYamlConfig.empty();
+    const baseFilePath = fileNameToPathMap[exports.APPHOSTING_BASE_YAML_FILE];
+    const emulatorsFilePath = fileNameToPathMap[exports.APPHOSTING_EMULATORS_YAML_FILE];
+    const localFilePath = fileNameToPathMap[exports.APPHOSTING_LOCAL_YAML_FILE];
+    if (baseFilePath) {
+        const baseFile = await yaml_1.AppHostingYamlConfig.loadFromFile(baseFilePath);
+        output.merge(baseFile, false);
+    }
+    if (emulatorsFilePath) {
+        const emulatorsConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(emulatorsFilePath);
+        output.merge(emulatorsConfig, false);
+    }
+    if (localFilePath) {
+        const localYamlConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(localFilePath);
+        output.merge(localYamlConfig, true);
+    }
+    return output;
+}
 function store(yamlPath, document) {
     (0, fs_1.writeFileSync)(yamlPath, document.toString());
 }
@@ -94,7 +118,6 @@ function upsertEnv(document, env) {
     }
     envs.add(envYaml);
 }
-const dynamicDispatch = exports;
 async function maybeAddSecretToYaml(secretName, fileName = exports.APPHOSTING_BASE_YAML_FILE) {
     const backendRoot = dynamicDispatch.discoverBackendRoot(process.cwd());
     let path;

package/lib/commands/appdistribution-distribute.js

@@ -97,7 +97,7 @@ async function distribute(appName, distribution, testCases, testDevices, release
             }
         }
     }
-    const releaseName = await (0, distribution_1.upload)(requests, appName, distribution);
+    const release = await (0, distribution_1.upload)(requests, appName, distribution);
     if (aabInfo && !aabInfo.testCertificate) {
         aabInfo = await requests.getAabInfo(appName);
         if (aabInfo.testCertificate) {
@@ -110,17 +110,17 @@ async function distribute(appName, distribution, testCases, testDevices, release
                 `SHA-256 certificate fingerprint: ${aabInfo.testCertificate.hashSha256}`);
         }
     }
-    await requests.updateReleaseNotes(releaseName, releaseNotes);
-    await requests.distribute(releaseName, testers, groups);
+    await requests.updateReleaseNotes(release.name, releaseNotes);
+    await requests.distribute(release.name, testers, groups);
     if (testDevices.length) {
         utils.logBullet("starting automated test (note: this feature is in beta)");
         const releaseTestPromises = [];
         if (!testCases.length) {
-            releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential));
+            releaseTestPromises.push(requests.createReleaseTest(release.name, testDevices, undefined, loginCredential));
         }
         else {
             for (const testCaseId of testCases) {
-                releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential, `${appName}/testCases/${testCaseId}`));
+                releaseTestPromises.push(requests.createReleaseTest(release.name, testDevices, undefined, loginCredential, `${appName}/testCases/${testCaseId}`));
             }
         }
         const releaseTests = await Promise.all(releaseTestPromises);

package/lib/commands/apptesting.js

@@ -8,7 +8,6 @@ const clc = require("colorette");
 const parseTestFiles_1 = require("../apptesting/parseTestFiles");
 const ora = require("ora");
 const error_1 = require("../error");
-const marked_1 = require("marked");
 const client_1 = require("../appdistribution/client");
 const distribution_1 = require("../appdistribution/distribution");
 const options_parser_util_1 = require("../appdistribution/options-parser-util");
@@ -38,13 +37,13 @@ exports.command = new command_1.Command("apptesting:execute <release-binary-file
         throw new error_1.FirebaseError("No tests found");
     }
     const invokeSpinner = ora("Requesting test execution");
-    let testInvocations;
-    let releaseId;
+    let releaseTests;
+    let release;
     try {
         const client = new client_1.AppDistributionClient();
-        releaseId = await (0, distribution_1.upload)(client, appName, new distribution_1.Distribution(target));
+        release = await (0, distribution_1.upload)(client, appName, new distribution_1.Distribution(target));
         invokeSpinner.start();
-        testInvocations = await invokeTests(client, releaseId, tests, !testDevices.length ? defaultDevices : testDevices);
+        releaseTests = await invokeTests(client, release.name, tests, !testDevices.length ? defaultDevices : testDevices);
         invokeSpinner.text = "Test execution requested";
         invokeSpinner.succeed();
     }
@@ -52,22 +51,22 @@ exports.command = new command_1.Command("apptesting:execute <release-binary-file
         invokeSpinner.fail("Failed to request test execution");
         throw ex;
     }
-    logger_1.logger.info(clc.bold(`\n${clc.white("===")} Running ${pluralizeTests(testInvocations.length)}`));
-    logger_1.logger.info(await (0, marked_1.marked)(`View progress and results in the Firebase Console`));
+    logger_1.logger.info(clc.bold(`\n${clc.white("===")} Running ${pluralizeTests(releaseTests.length)}`));
+    logger_1.logger.info(`View progress and results in the Firebase Console:\n${release.firebaseConsoleUri}`);
 });
 function pluralizeTests(numTests) {
     return `${numTests} test${numTests === 1 ? "" : "s"}`;
 }
 async function invokeTests(client, releaseName, testDefs, devices) {
     try {
-        const testInvocations = [];
+        const releaseTests = [];
         for (const testDef of testDefs) {
             const aiInstructions = {
                 steps: testDef.testCase.steps,
             };
-            testInvocations.push(await client.createReleaseTest(releaseName, devices, aiInstructions, undefined, undefined, testDef.testCase.displayName));
+            releaseTests.push(await client.createReleaseTest(releaseName, devices, aiInstructions, undefined, undefined, testDef.testCase.displayName));
         }
-        return testInvocations;
+        return releaseTests;
     }
     catch (err) {
         throw new error_1.FirebaseError("Test invocation failed", { original: (0, error_1.getError)(err) });

package/lib/commands/dataconnect-sql-setup.js

@@ -8,7 +8,6 @@ const requireAuth_1 = require("../requireAuth");
 const requirePermissions_1 = require("../requirePermissions");
 const ensureApis_1 = require("../dataconnect/ensureApis");
 const permissionsSetup_1 = require("../gcp/cloudsql/permissionsSetup");
-const permissions_1 = require("../gcp/cloudsql/permissions");
 const schemaMigration_1 = require("../dataconnect/schemaMigration");
 const connect_1 = require("../gcp/cloudsql/connect");
 const load_1 = require("../dataconnect/load");
@@ -33,9 +32,9 @@ exports.command = new command_1.Command("dataconnect:sql:setup")
     if (!instanceId) {
         throw new error_1.FirebaseError("dataconnect.yaml is missing field schema.datasource.postgresql.cloudsql.instanceId");
     }
-    const { serviceName, instanceName, databaseId } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
-    await (0, schemaMigration_1.ensureServiceIsConnectedToCloudSql)(serviceName, instanceName, databaseId, true);
+    const { serviceName, instanceName, databaseId, schemaName } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
+    await (0, schemaMigration_1.ensureServiceIsConnectedToCloudSql)(serviceName, instanceName, databaseId, true, schemaName);
     await (0, connect_1.setupIAMUsers)(instanceId, options);
-    const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+    const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
     await (0, permissionsSetup_1.setupSQLPermissions)(instanceId, databaseId, schemaInfo, options);
 });

package/lib/commands/dataconnect-sql-shell.js

@@ -83,7 +83,7 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
     const projectId = (0, projectUtils_1.needProjectId)(options);
     await (0, ensureApis_1.ensureApis)(projectId);
     const serviceInfo = await (0, load_1.pickOneService)(projectId, options.config, options.service, options.location);
-    const { instanceId, databaseId } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
+    const { instanceId, databaseId, schemaName } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
     const { user: username } = await (0, connect_1.getIAMUser)(options);
     const instance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
     const connectionName = instance.connectionName;
@@ -104,6 +104,7 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
         database: databaseId,
     });
     const conn = await pool.connect();
+    await conn.query(`SET search_path TO "${schemaName}"`);
     logger_1.logger.info(`Logged in as ${username}`);
     logger_1.logger.info(clc.cyan("Welcome to Data Connect Cloud SQL Shell"));
     logger_1.logger.info(clc.gray("Type your your SQL query or '.exit' to quit, queries should end with ';' or add empty line to execute."));

package/lib/commands/index.js

@@ -247,18 +247,16 @@ function load(client) {
     client.dataconnect.compile = loadCommand("dataconnect-compile");
     client.dataconnect.sdk = {};
     client.dataconnect.sdk.generate = loadCommand("dataconnect-sdk-generate");
-    if (experiments.isEnabled("studioexport")) {
-        client.studio = {};
-        client.studio.export = loadCommand("studio-export");
-    }
+    client.studio = {};
+    client.studio.export = loadCommand("studio-export");
     client.target = loadCommand("target");
     client.target.apply = loadCommand("target-apply");
     client.target.clear = loadCommand("target-clear");
     client.target.remove = loadCommand("target-remove");
     client.use = loadCommand("use");
+    client.apptesting = {};
+    client.apptesting.execute = loadCommand("apptesting");
     if (experiments.isEnabled("apptesting")) {
-        client.apptesting = {};
-        client.apptesting.execute = loadCommand("apptesting");
         client.apptesting.wata = loadCommand("apptesting-wata");
     }
     const t1 = process.hrtime.bigint();

package/lib/commands/studio-export.js

@@ -5,17 +5,35 @@ const command_1 = require("../command");
 const logger_1 = require("../logger");
 const migrate_1 = require("../firebase_studio/migrate");
 const path = require("path");
-const experiments = require("../experiments");
 const error_1 = require("../error");
+const unzip_1 = require("../unzip");
+const fs = require("fs");
 exports.command = new command_1.Command("studio:export <path>")
-    .description("Bootstrap Firebase Studio apps for migration to Antigravity. Run on the unzipped folder from the Firebase Studio download.")
+    .description("Bootstrap Firebase Studio apps for migration to Antigravity. Run on the unzipped folder from the Firebase Studio download, or directly on the downloaded zip file.")
     .option("--no-start-agy", "skip starting the Antigravity IDE after migration")
     .action(async (exportPath, options) => {
-    experiments.assertEnabled("studioexport", "export Studio apps");
     if (!exportPath) {
         throw new error_1.FirebaseError("Must specify a path for migration.", { exit: 1 });
     }
-    const rootPath = path.resolve(exportPath);
-    logger_1.logger.info(`Exporting Studio apps from ${rootPath} to Antigravity...`);
+    let rootPath = path.resolve(exportPath);
+    if (fs.existsSync(rootPath) && fs.statSync(rootPath).isFile() && rootPath.endsWith(".zip")) {
+        logger_1.logger.info(`⏳ Unzipping ${rootPath}...`);
+        const parsedPath = path.parse(rootPath);
+        let extractDirName = parsedPath.name;
+        if (!extractDirName || extractDirName === ".") {
+            extractDirName = "studio-export";
+        }
+        const extractPath = path.join(parsedPath.dir, extractDirName);
+        await (0, unzip_1.unzip)(rootPath, extractPath);
+        const extractedItems = fs.readdirSync(extractPath);
+        if (extractedItems.length === 1 &&
+            fs.statSync(path.join(extractPath, extractedItems[0])).isDirectory()) {
+            rootPath = path.join(extractPath, extractedItems[0]);
+        }
+        else {
+            rootPath = extractPath;
+        }
+    }
+    logger_1.logger.info(`⏳ Exporting Studio apps from ${rootPath} to Antigravity...`);
     await (0, migrate_1.migrate)(rootPath, options);
 });

package/lib/dataconnect/schemaMigration.js

@@ -25,10 +25,10 @@ const errors = require("./errors");
 const provisionCloudSql_1 = require("./provisionCloudSql");
 const requireAuth_1 = require("../requireAuth");
 const cloudbilling_1 = require("../gcp/cloudbilling");
-async function setupSchemaIfNecessary(instanceId, databaseId, options) {
+async function setupSchemaIfNecessary(instanceId, databaseId, schemaName, options) {
     try {
         await (0, connect_1.setupIAMUsers)(instanceId, options);
-        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
         switch (schemaInfo.setupStatus) {
             case permissionsSetup_1.SchemaSetupStatus.BrownField:
             case permissionsSetup_1.SchemaSetupStatus.GreenField:
@@ -50,8 +50,8 @@ async function diffSchema(options, schema, schemaValidation) {
     let validationMode = schemaValidation ?? "STRICT";
     setSchemaValidationMode(schema, validationMode);
     displayStartSchemaDiff(validationMode);
-    const { serviceName, instanceName, databaseId, instanceId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
+    const { serviceName, instanceName, databaseId, instanceId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false, schemaName);
     let incompatible = undefined;
     try {
         await (0, client_1.upsertSchema)(schema, true);
@@ -114,8 +114,8 @@ async function migrateSchema(args) {
     setSchemaValidationMode(schema, validationMode);
     displayStartSchemaDiff(validationMode);
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
+    const { serviceName, instanceId, instanceName, databaseId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true, schemaName);
     const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
     if (existingInstance.state === "PENDING_CREATE") {
         if (stats) {
@@ -134,7 +134,7 @@ async function migrateSchema(args) {
         (0, utils_1.logLabeledWarning)("dataconnect", `Skip SQL schema migration because Cloud SQL is still being created`);
         return [];
     }
-    await setupSchemaIfNecessary(instanceId, databaseId, options);
+    await setupSchemaIfNecessary(instanceId, databaseId, schemaName, options);
     let diffs = [];
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
@@ -168,6 +168,7 @@ async function migrateSchema(args) {
                 options,
                 databaseId,
                 instanceId,
+                schemaName,
                 incompatibleSchemaError: incompatible,
                 choice: migrationMode,
             });
@@ -202,6 +203,7 @@ async function migrateSchema(args) {
                     options,
                     databaseId,
                     instanceId,
+                    schemaName,
                     incompatibleSchemaError: incompatible,
                     choice: migrationMode,
                 });
@@ -242,13 +244,13 @@ async function upsertSecondarySchema(args) {
 async function grantRoleToUserInSchema(options, schema) {
     const role = options.role;
     const email = options.email;
-    const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
-    const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, options);
+    const { serviceName, instanceId, instanceName, databaseId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false, schemaName);
+    const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, schemaName, options);
     if (schemaSetupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField && role === "owner") {
         throw new error_1.FirebaseError(`Owner rule isn't available in ${schemaSetupStatus} databases. If you would like Data Connect to manage and own your database schema, run 'firebase dataconnect:sql:setup'`);
     }
-    await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, role, email);
+    await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, role, email, schemaName);
 }
 function diffsEqual(x, y) {
     if (x.length !== y.length) {
@@ -280,11 +282,13 @@ function getIdentifiers(schema) {
         throw new error_1.FirebaseError("Data Connect schema must have a postgres datasource with a CloudSQL instance.");
     }
     const instanceId = instanceName.split("/").pop();
+    const schemaName = postgresDatasource?.postgresql?.schema || permissions_1.DEFAULT_SCHEMA;
     const serviceName = serviceNameFromSchema(schema);
     return {
         databaseId,
         instanceId,
         instanceName,
+        schemaName,
         serviceName,
     };
 }
@@ -299,7 +303,7 @@ function suggestedCommand(serviceName, invalidConnectorNames) {
     return `firebase deploy --only ${onlys}`;
 }
 async function handleIncompatibleSchemaError(args) {
-    const { incompatibleSchemaError, options, instanceId, databaseId, choice } = args;
+    const { incompatibleSchemaError, options, instanceId, databaseId, schemaName, choice } = args;
     const commandsToExecute = incompatibleSchemaError.diffs.filter((d) => {
         switch (choice) {
             case "all":
@@ -319,26 +323,29 @@ async function handleIncompatibleSchemaError(args) {
         Please ask a user with 'roles/cloudsql.admin' to apply the following commands.\n
         ${diffsToString(commandsToExecuteBySuperUser)}`);
         }
-        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
         if (schemaInfo.setupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField) {
             throw new error_1.FirebaseError(`Brownfield database are protected from SQL changes by Data Connect.\n` +
                 `You can use the SQL diff generated by 'firebase dataconnect:sql:diff' to assist you in applying the required changes to your CloudSQL database. Connector deployment will succeed when there is no required diff changes.\n` +
                 `If you would like Data Connect to manage your database schema, run 'firebase dataconnect:sql:setup'`);
         }
-        if (!(await (0, permissionsSetup_1.checkSQLRoleIsGranted)(options, instanceId, databaseId, (0, permissions_1.firebaseowner)(databaseId), (await (0, connect_1.getIAMUser)(options)).user))) {
+        if (!(await (0, permissionsSetup_1.checkSQLRoleIsGranted)(options, instanceId, databaseId, (0, permissions_1.firebaseowner)(databaseId, schemaName), (await (0, connect_1.getIAMUser)(options)).user))) {
             if (!userIsCSQLAdmin) {
                 throw new error_1.FirebaseError(`Command aborted. Only users granted firebaseowner SQL role can run migrations.`);
             }
             const account = (await (0, requireAuth_1.requireAuth)(options));
             (0, utils_1.logLabeledBullet)("dataconnect", `Granting firebaseowner role to myself ${account}...`);
-            await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, "owner", account);
+            await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, "owner", account, schemaName);
         }
         if (commandsToExecuteBySuperUser.length) {
             (0, utils_1.logLabeledBullet)("dataconnect", `Executing admin SQL commands as superuser...`);
             await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, commandsToExecuteBySuperUser.map((d) => d.sql), false);
         }
         if (commandsToExecuteByOwner.length) {
-            await (0, connect_1.executeSqlCmdsAsIamUser)(options, instanceId, databaseId, [`SET ROLE "${(0, permissions_1.firebaseowner)(databaseId)}"`, ...commandsToExecuteByOwner.map((d) => d.sql)], false);
+            await (0, connect_1.executeSqlCmdsAsIamUser)(options, instanceId, databaseId, [
+                `SET ROLE "${(0, permissions_1.firebaseowner)(databaseId, schemaName)}"`,
+                ...commandsToExecuteByOwner.map((d) => d.sql),
+            ], false);
             return incompatibleSchemaError.diffs;
         }
     }
@@ -421,7 +428,7 @@ function displayInvalidConnectors(invalidConnectors) {
     (0, utils_1.logLabeledWarning)("dataconnect", `The schema you are deploying is incompatible with the following existing connectors: ${clc.bold(connectorIds)}.`);
     (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and may break existing apps.`);
 }
-async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected) {
+async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected, schemaName) {
     let currentSchema = await (0, client_1.getSchema)(serviceName);
     let postgresql = currentSchema?.datasources?.find((d) => d.postgresql)?.postgresql;
     if (currentSchema?.reconciling &&
@@ -478,6 +485,7 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, dat
     try {
         postgresql.schemaValidation = "STRICT";
         postgresql.database = databaseId;
+        postgresql.schema = schemaName;
         postgresql.cloudSql = { instance: instanceName };
         await (0, client_1.upsertSchema)(currentSchema, false);
     }

package/lib/dataconnect/types.js

@@ -16,6 +16,7 @@ function toDatasource(projectId, locationId, ds) {
         return {
             postgresql: {
                 database: ds.postgresql.database,
+                schema: ds.postgresql.schema,
                 cloudSql: {
                     instance: `projects/${projectId}/locations/${locationId}/instances/${ds.postgresql.cloudSql.instanceId}`,
                 },

package/lib/deploy/functions/build.js

@@ -226,18 +226,33 @@ function toBackend(build, paramValues) {
             r.resolveInts(bkEndpoint, bdEndpoint, "timeoutSeconds", "maxInstances", "minInstances", "concurrency");
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "cpu", (0, functional_1.nullsafeVisitor)((cpu) => (cpu === "gcf_gen1" ? cpu : r.resolveInt(cpu))));
             if (bdEndpoint.vpc) {
-                bdEndpoint.vpc.connector = params.resolveString(bdEndpoint.vpc.connector, paramValues);
-                if (bdEndpoint.vpc.connector && !bdEndpoint.vpc.connector.includes("/")) {
-                    bdEndpoint.vpc.connector = `projects/${bdEndpoint.project}/locations/${region}/connectors/${bdEndpoint.vpc.connector}`;
+                bkEndpoint.vpc = {};
+                if (typeof bdEndpoint.vpc.connector !== "undefined" && bdEndpoint.vpc.connector !== null) {
+                    const connector = params.resolveString(bdEndpoint.vpc.connector, paramValues);
+                    bkEndpoint.vpc.connector =
+                        connector.includes("/") || connector === ""
+                            ? connector
+                            : `projects/${bdEndpoint.project}/locations/${region}/connectors/${connector}`;
                 }
-                bkEndpoint.vpc = { connector: bdEndpoint.vpc.connector };
                 if (bdEndpoint.vpc.egressSettings) {
-                    const egressSettings = r.resolveString(bdEndpoint.vpc.egressSettings);
-                    if (!backend.isValidEgressSetting(egressSettings)) {
-                        throw new error_1.FirebaseError(`Value "${egressSettings}" is an invalid ` +
-                            "egress setting. Valid values are PRIVATE_RANGES_ONLY and ALL_TRAFFIC");
+                    const egress = params.resolveString(bdEndpoint.vpc.egressSettings, paramValues);
+                    if (!backend.AllVpcEgressSettings.includes(egress)) {
+                        throw new error_1.FirebaseError(`Value "${egress}" is an invalid egress setting.`);
                     }
-                    bkEndpoint.vpc.egressSettings = egressSettings;
+                    bkEndpoint.vpc.egressSettings = egress;
+                }
+                if (bdEndpoint.vpc.networkInterfaces) {
+                    bkEndpoint.vpc.networkInterfaces = bdEndpoint.vpc.networkInterfaces.map((ni) => {
+                        const resolved = {};
+                        if (ni.network)
+                            resolved.network = params.resolveString(ni.network, paramValues);
+                        if (ni.subnetwork)
+                            resolved.subnetwork = params.resolveString(ni.subnetwork, paramValues);
+                        if (ni.tags) {
+                            resolved.tags = ni.tags.map((tag) => params.resolveString(tag, paramValues));
+                        }
+                        return resolved;
+                    });
                 }
             }
             else if (bdEndpoint.vpc === null) {

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -88,10 +88,16 @@ function assertBuildEndpoint(ep, id) {
     });
     if (ep.vpc) {
         (0, parsing_1.assertKeyTypes)(prefix + ".vpc", ep.vpc, {
-            connector: "string",
+            connector: "string?",
             egressSettings: (setting) => setting === null || build.AllVpcEgressSettings.includes(setting),
+            networkInterfaces: "array?",
         });
-        (0, parsing_1.requireKeys)(prefix + ".vpc", ep.vpc, "connector");
+        if (!ep.vpc.connector && !ep.vpc.networkInterfaces) {
+            throw new error_1.FirebaseError(`VPC settings on ${id} must specify either 'connector' or 'networkInterfaces'`);
+        }
+        if (ep.vpc.connector && ep.vpc.networkInterfaces) {
+            throw new error_1.FirebaseError(`VPC settings on ${id} cannot specify both 'connector' and 'networkInterfaces'`);
+        }
     }
     let triggerCount = 0;
     if (ep.httpsTrigger) {

package/lib/emulator/apphosting/config.js

@@ -1,27 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalAppHostingConfiguration = getLocalAppHostingConfiguration;
-const path_1 = require("path");
 const config_1 = require("../../apphosting/config");
-const yaml_1 = require("../../apphosting/yaml");
 async function getLocalAppHostingConfiguration(backendDir) {
-    const appHostingConfigPaths = (0, config_1.listAppHostingFilesInPath)(backendDir);
-    const fileNameToPathMap = Object.fromEntries(appHostingConfigPaths.map((path) => [(0, path_1.basename)(path), path]));
-    const output = yaml_1.AppHostingYamlConfig.empty();
-    const baseFilePath = fileNameToPathMap[config_1.APPHOSTING_BASE_YAML_FILE];
-    const emulatorsFilePath = fileNameToPathMap[config_1.APPHOSTING_EMULATORS_YAML_FILE];
-    const localFilePath = fileNameToPathMap[config_1.APPHOSTING_LOCAL_YAML_FILE];
-    if (baseFilePath) {
-        const baseFile = await yaml_1.AppHostingYamlConfig.loadFromFile(baseFilePath);
-        output.merge(baseFile, false);
-    }
-    if (emulatorsFilePath) {
-        const emulatorsConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(emulatorsFilePath);
-        output.merge(emulatorsConfig, false);
-    }
-    if (localFilePath) {
-        const localYamlConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(localFilePath);
-        output.merge(localYamlConfig, true);
-    }
-    return output;
+    return (0, config_1.getAppHostingConfiguration)(backendDir);
 }

package/lib/emulator/controller.js

@@ -753,7 +753,8 @@ async function exportEmulatorData(exportPath, options, initiatedBy) {
     }
     utils.logBullet(`Exporting data to: ${exportAbsPath}`);
     try {
-        await hubClient.postExport({ path: exportAbsPath, initiatedBy });
+        const targets = filterEmulatorTargets(options);
+        await hubClient.postExport({ path: exportAbsPath, initiatedBy, targets });
     }
     catch (e) {
         throw new error_1.FirebaseError("Export request failed, see emulator logs for more information.", {

package/lib/emulator/hub.js

@@ -71,11 +71,13 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
             }
             const path = req.body.path;
             const initiatedBy = req.body.initiatedBy || "unknown";
+            const targets = req.body.targets;
             utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${path}.`);
             try {
                 await new hubExport_1.HubExport(this.args.projectId, {
                     path,
                     initiatedBy,
+                    targets,
                 }).exportAll();
                 utils.logLabeledSuccess("emulators", "Export complete.");
                 res.status(200).send({

package/lib/emulator/hubExport.js

@@ -19,6 +19,7 @@ class HubExport {
         this.projectId = projectId;
         this.options = options;
         this.exportPath = options.path;
+        this.exportTargets = options.targets ?? [...types_1.IMPORT_EXPORT_EMULATORS];
         this.tmpDir = fs.mkdtempSync(`firebase-export-${new Date().getTime()}`);
     }
     static readMetadata(exportPath) {
@@ -36,14 +37,14 @@ class HubExport {
         }
     }
     async exportAll() {
-        const toExport = types_1.ALL_EMULATORS.filter(shouldExport);
+        const toExport = types_1.ALL_EMULATORS.filter(shouldExport).filter((e) => this.exportTargets.includes(e));
         if (toExport.length === 0) {
             throw new error_1.FirebaseError("No running emulators support import/export.");
         }
         const metadata = {
             version: hub_1.EmulatorHub.CLI_VERSION,
         };
-        if (shouldExport(types_1.Emulators.FIRESTORE)) {
+        if (shouldExport(types_1.Emulators.FIRESTORE) && toExport.includes(types_1.Emulators.FIRESTORE)) {
             metadata.firestore = {
                 version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.FIRESTORE).version,
                 path: "firestore_export",
@@ -51,28 +52,28 @@ class HubExport {
             };
             await this.exportFirestore(metadata);
         }
-        if (shouldExport(types_1.Emulators.DATABASE)) {
+        if (shouldExport(types_1.Emulators.DATABASE) && toExport.includes(types_1.Emulators.DATABASE)) {
             metadata.database = {
                 version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.DATABASE).version,
                 path: "database_export",
             };
             await this.exportDatabase(metadata);
         }
-        if (shouldExport(types_1.Emulators.AUTH)) {
+        if (shouldExport(types_1.Emulators.AUTH) && toExport.includes(types_1.Emulators.AUTH)) {
             metadata.auth = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "auth_export",
             };
             await this.exportAuth(metadata);
         }
-        if (shouldExport(types_1.Emulators.STORAGE)) {
+        if (shouldExport(types_1.Emulators.STORAGE) && toExport.includes(types_1.Emulators.STORAGE)) {
             metadata.storage = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "storage_export",
             };
             await this.exportStorage(metadata);
         }
-        if (shouldExport(types_1.Emulators.DATACONNECT)) {
+        if (shouldExport(types_1.Emulators.DATACONNECT) && toExport.includes(types_1.Emulators.DATACONNECT)) {
             metadata.dataconnect = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "dataconnect_export",

package/lib/experiments.js

@@ -104,6 +104,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
+    apphostinglocalbuilds: {
+        shortDescription: "Enable App Hosting local builds",
+        default: false,
+        public: false,
+    },
     dataconnect: {
         shortDescription: "Deprecated. Previosuly, enabled Data Connect related features.",
         fullDescription: "Deprecated. Previously, enabled Data Connect related features.",
@@ -133,8 +138,8 @@ exports.ALL_EXPERIMENTS = experiments({
     },
     fdcift: {
         shortDescription: "Enable instrumentless trial for Data Connect",
+        default: true,
         public: false,
-        default: false,
     },
     apptesting: {
         shortDescription: "Adds experimental App Testing feature",
@@ -145,11 +150,6 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
-    studioexport: {
-        shortDescription: "Enable the experimental studio:export command.",
-        default: false,
-        public: false,
-    },
 });
 function isValidExperiment(name) {
     return Object.keys(exports.ALL_EXPERIMENTS).includes(name);

package/lib/firebase_studio/migrate.js

@@ -7,13 +7,51 @@ const fs = require("fs/promises");
 const path = require("path");
 const child_process_1 = require("child_process");
 const logger_1 = require("../logger");
-const error_1 = require("../error");
 const prompt = require("../prompt");
 const apphosting = require("../gcp/apphosting");
 const utils = require("../utils");
 const templates_1 = require("../templates");
+const track = require("../track");
 const secrets_1 = require("../apphosting/secrets");
 const env = require("../functions/env");
+const error_1 = require("../error");
+async function detectAppType(rootPath) {
+    try {
+        await fs.access(path.join(rootPath, "pubspec.yaml"));
+        return "FLUTTER";
+    }
+    catch {
+    }
+    try {
+        await fs.access(path.join(rootPath, "angular.json"));
+        return "ANGULAR";
+    }
+    catch {
+    }
+    try {
+        const packageJsonPath = path.join(rootPath, "package.json");
+        const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContent);
+        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        if (deps.next) {
+            return "NEXT_JS";
+        }
+        if (deps["@angular/core"]) {
+            return "ANGULAR";
+        }
+    }
+    catch {
+    }
+    for (const configFile of ["next.config.js", "next.config.mjs"]) {
+        try {
+            await fs.access(path.join(rootPath, configFile));
+            return "NEXT_JS";
+        }
+        catch {
+        }
+    }
+    return "OTHER";
+}
 async function downloadGitHubDir(apiUrl, localPath) {
     const response = await fetch(apiUrl);
     if (!response.ok) {
@@ -45,6 +83,8 @@ async function extractMetadata(rootPath, overrideProjectId) {
     catch (err) {
         logger_1.logger.debug(`Could not read metadata.json at ${metadataPath}: ${err}`);
     }
+    logger_1.logger.debug(`overrideProjectId ${overrideProjectId}`);
+    logger_1.logger.debug(`metadata.projectId ${metadata.projectId}`);
     let projectId = overrideProjectId || metadata.projectId;
     if (!projectId) {
         try {
@@ -60,7 +100,7 @@ async function extractMetadata(rootPath, overrideProjectId) {
         logger_1.logger.info(`✅ Detected Firebase Project: ${projectId}`);
     }
     else {
-        logger_1.logger.info(`✅ Failed to determine the Firebase Project ID`);
+        logger_1.logger.info(`❌ Failed to determine the Firebase Project ID. You can set a project later with 'firebase use <project-id>' or by setting the '--project' flag.`);
     }
     let appName = "firebase-studio-export";
     let blueprintContent = "";
@@ -146,18 +186,30 @@ async function injectAgyContext(rootPath, projectId, appName) {
         logger_1.logger.debug(`Could not read or write startup workflow: ${err}`);
     }
 }
-async function assertSystemState(startAgy) {
-    if (startAgy === false) {
-        return;
-    }
-    try {
-        (0, child_process_1.execSync)("agy --version", { stdio: "ignore" });
-        logger_1.logger.info("✅ Antigravity IDE CLI (agy) detected");
+async function getAgyCommand(startAgy) {
+    if (!startAgy) {
+        return undefined;
+    }
+    const commands = ["agy", "antigravity"];
+    for (const cmd of commands) {
+        if (utils.commandExistsSync(cmd)) {
+            logger_1.logger.info(`✅ Antigravity IDE CLI (${cmd}) detected`);
+            return cmd;
+        }
     }
-    catch (err) {
-        const downloadLink = "https://antigravity.google/download";
-        throw new error_1.FirebaseError(`Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`, { exit: 1 });
+    if (process.platform === "darwin") {
+        const macPath = "/Applications/Antigravity.app/Contents/Resources/app/bin/agy";
+        try {
+            await fs.access(macPath);
+            logger_1.logger.info(`✅ Antigravity IDE CLI detected at ${macPath}`);
+            return macPath;
+        }
+        catch {
+        }
     }
+    const downloadLink = "https://antigravity.google/download";
+    logger_1.logger.info(`⚠️ Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
+    return undefined;
 }
 async function createFirebaseConfigs(rootPath, projectId) {
     if (!projectId) {
@@ -334,7 +386,8 @@ async function uploadSecrets(rootPath, projectId) {
     }
 }
 async function askToOpenAntigravity(rootPath, appName, startAgy) {
-    if (startAgy === false) {
+    const agyCommand = await getAgyCommand(startAgy);
+    if (!startAgy || !agyCommand) {
         logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
         return;
     }
@@ -345,7 +398,7 @@ async function askToOpenAntigravity(rootPath, appName, startAgy) {
     if (answer) {
         logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
         try {
-            const agyProcess = (0, child_process_1.spawn)("agy", ["."], {
+            const agyProcess = (0, child_process_1.spawn)(agyCommand, ["."], {
                 cwd: rootPath,
                 stdio: "ignore",
                 detached: true,
@@ -361,8 +414,14 @@ async function askToOpenAntigravity(rootPath, appName, startAgy) {
     }
 }
 async function migrate(rootPath, options = { startAgy: true }) {
+    if (process.platform === "win32") {
+        throw new error_1.FirebaseError("Firebase Studio migration is currently not supported on Windows.", {
+            exit: 1,
+        });
+    }
+    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...");
-    await assertSystemState(options.startAgy);
     const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
     await updateReadme(rootPath, blueprintContent, appName);
     await createFirebaseConfigs(rootPath, projectId);
@@ -374,5 +433,6 @@ async function migrate(rootPath, options = { startAgy: true }) {
     if (currentFolderName === "download") {
         logger_1.logger.info(`\n💡 Tip: You might 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.startAgy);
 }

package/lib/frameworks/next/constants.js

@@ -10,7 +10,12 @@ exports.PRERENDER_MANIFEST = "prerender-manifest.json";
 exports.ROUTES_MANIFEST = "routes-manifest.json";
 exports.APP_PATHS_MANIFEST = "app-paths-manifest.json";
 exports.SERVER_REFERENCE_MANIFEST = "server-reference-manifest.json";
-exports.CONFIG_FILES = ["next.config.js", "next.config.mjs"];
+exports.CONFIG_FILES = [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "next.config.mts",
+];
 exports.ESBUILD_VERSION = "^0.19.2";
 const WEBPACK_LAYERS_NAMES = {
     shared: "shared",

package/lib/frameworks/next/index.js

@@ -424,8 +424,12 @@ async function ɵcodegenFunctionsDirectory(sourceDir, destDir, target, context)
                 logLevel: "error",
                 external: productionDeps,
             };
-            if (configFile === "next.config.mjs") {
+            if (configFile === "next.config.mjs" || configFile === "next.config.mts") {
                 esbuildArgs.format = "esm";
+                esbuildArgs.outfile = (0, path_1.join)(destDir, "next.config.mjs");
+            }
+            else {
+                esbuildArgs.outfile = (0, path_1.join)(destDir, "next.config.js");
             }
             const bundle = await esbuild.build(esbuildArgs);
             if (bundle.errors && bundle.errors.length > 0) {

package/lib/gcp/cloudfunctionsv2.js

@@ -187,12 +187,22 @@ function functionFromEndpoint(endpoint) {
         return String(cpu);
     });
     if (endpoint.vpc) {
-        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnector", "connector");
-        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
+        if (endpoint.vpc.connector) {
+            gcfFunction.serviceConfig.vpcConnector = endpoint.vpc.connector;
+            gcfFunction.serviceConfig.vpcConnectorEgressSettings = endpoint.vpc.egressSettings || null;
+        }
+        else if (endpoint.vpc.networkInterfaces) {
+            gcfFunction.serviceConfig.directVpcNetworkInterface = endpoint.vpc.networkInterfaces;
+            gcfFunction.serviceConfig.directVpcEgress = endpoint.vpc.egressSettings
+                ? `VPC_EGRESS_${endpoint.vpc.egressSettings}`
+                : null;
+        }
     }
     else if (endpoint.vpc === null) {
         gcfFunction.serviceConfig.vpcConnector = null;
         gcfFunction.serviceConfig.vpcConnectorEgressSettings = null;
+        gcfFunction.serviceConfig.directVpcNetworkInterface = null;
+        gcfFunction.serviceConfig.directVpcEgress = null;
     }
     if (backend.isEventTriggered(endpoint)) {
         gcfFunction.eventTrigger = {
@@ -384,6 +394,17 @@ function endpointFromFunction(gcfFunction) {
             endpoint.vpc = { connector: gcfFunction.serviceConfig.vpcConnector };
             proto.renameIfPresent(endpoint.vpc, gcfFunction.serviceConfig, "egressSettings", "vpcConnectorEgressSettings");
         }
+        else if (gcfFunction.serviceConfig.directVpcNetworkInterface) {
+            endpoint.vpc = { networkInterfaces: gcfFunction.serviceConfig.directVpcNetworkInterface };
+            if (gcfFunction.serviceConfig.directVpcEgress) {
+                if (!gcfFunction.serviceConfig.directVpcEgress.startsWith("VPC_EGRESS_")) {
+                    throw new error_1.FirebaseError(`Unexpected VPC egress setting: ${gcfFunction.serviceConfig.directVpcEgress}`);
+                }
+                if (gcfFunction.serviceConfig.directVpcEgress !== "VPC_EGRESS_UNSPECIFIED") {
+                    endpoint.vpc.egressSettings = gcfFunction.serviceConfig.directVpcEgress.substring("VPC_EGRESS_".length);
+                }
+            }
+        }
         const serviceName = gcfFunction.serviceConfig.service;
         if (!serviceName) {
             logger_1.logger.debug("Got a v2 function without a service name." +

package/lib/gcp/cloudsql/permissionsSetup.js

@@ -125,9 +125,9 @@ async function setupSQLPermissions(instanceId, databaseId, schemaInfo, options,
 }
 async function greenFieldSchemaSetup(instanceId, databaseId, schema, options) {
     const revokes = [];
-    if (await checkSQLRoleIsGranted(options, instanceId, databaseId, "cloudsqlsuperuser", (0, permissions_1.firebaseowner)(databaseId))) {
+    if (await checkSQLRoleIsGranted(options, instanceId, databaseId, "cloudsqlsuperuser", (0, permissions_1.firebaseowner)(databaseId, schema))) {
         logger_1.logger.warn("Detected cloudsqlsuperuser was previously given to firebase owner, revoking to improve database security.");
-        revokes.push(`REVOKE "cloudsqlsuperuser" FROM "${(0, permissions_1.firebaseowner)(databaseId)}"`);
+        revokes.push(`REVOKE "cloudsqlsuperuser" FROM "${(0, permissions_1.firebaseowner)(databaseId, schema)}"`);
     }
     const user = (await (0, connect_1.getIAMUser)(options)).user;
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
@@ -222,10 +222,10 @@ async function brownfieldSqlSetup(instanceId, databaseId, schemaInfo, options, s
     ];
     await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, brownfieldSetupCmds, silent, true);
 }
-async function grantRoleTo(options, instanceId, databaseId, role, email) {
+async function grantRoleTo(options, instanceId, databaseId, role, email, schema = permissions_1.DEFAULT_SCHEMA) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const { user, mode } = (0, connect_2.toDatabaseUser)(email);
     await cloudSqlAdminClient.createUser(projectId, instanceId, mode, user);
-    const fdcSqlRole = exports.fdcSqlRoleMap[role](databaseId);
+    const fdcSqlRole = exports.fdcSqlRoleMap[role](databaseId, schema);
     await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, [`GRANT "${fdcSqlRole}" TO "${user}"`], false);
 }

package/lib/mcp/tools/apptesting/tests.js

@@ -58,8 +58,8 @@ exports.run_tests = (0, tool_1.tool)("apptesting", {
 }, async ({ appId, releaseBinaryFile, testDevices, testCase }) => {
     const devices = testDevices || defaultDevices;
     const client = new client_1.AppDistributionClient();
-    const releaseName = await (0, distribution_1.upload)(client, (0, options_parser_util_1.toAppName)(appId), new distribution_1.Distribution(releaseBinaryFile));
-    return (0, util_1.toContent)(await client.createReleaseTest(releaseName, devices, testCase));
+    const release = await (0, distribution_1.upload)(client, (0, options_parser_util_1.toAppName)(appId), new distribution_1.Distribution(releaseBinaryFile));
+    return (0, util_1.toContent)(await client.createReleaseTest(release.name, devices, testCase));
 });
 exports.check_status = (0, tool_1.tool)("apptesting", {
     name: "check_status",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "15.9.0",
+  "version": "15.9.2-ct-studioexport3.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "mcpName": "io.github.firebase/firebase-mcp",

package/schema/dataconnect-yaml.json

@@ -10,6 +10,10 @@
           "type": "string",
           "description": "The name of the PostgreSQL database."
         },
+        "schema": {
+          "type": "string",
+          "description": "The PostgreSQL schema name. Defaults to 'public' if not specified."
+        },
         "cloudSql": {
           "additionalProperties": false,
           "type": "object",

package/templates/firebase-studio-export/system_instructions_template.md

@@ -9,6 +9,17 @@ App Name: ${appName}
 
 # Migration Guidelines
 
-- Focus on ensuring zero-friction deployments to Firebase App Hosting.
-- Maintain the original intent defined in docs/blueprint.md.
-- Use Genkit for AI features as already configured in src/ai/.
+- `docs/blueprint.md` describes what this app was supposed to do when it was exported. Read it before making changes to the app.
+
+- Use Agent Skills to guide Firebase usage. If they are not available, install them by running `npx -y skills add  firebase/agent-skills --skill "*" -y`
+
+- When asked to deploy or publish the app, deploy to Firebase App Hosting using `firebase deploy`.
+If you run into issues, ensure `firebase.json` contains a valid `apphosting` block (with `backendId` and `rootDir`).
+DO NOT use `firebase apphosting:backends:create` or `firebase apphosting:rollouts:create`.
+DO NOT try to deploy to Firebase Hosting.
+
+- When asked to add AI features, use Genkit (as already configured in `src/ai/`).
+
+# Important
+
+Never display, log, or commit sensitive credentials, .env files, or service account keys.