firebase-tools 13.24.2 → 13.25.0

package/lib/auth.js

@@ -138,11 +138,13 @@ function open(url) {
     });
 }
 function invalidCredentialError() {
-    return new error_1.FirebaseError("Authentication Error: Your credentials are no longer valid. Please run " +
+    const message = "Authentication Error: Your credentials are no longer valid. Please run " +
         clc.bold("firebase login --reauth") +
         "\n\n" +
         "For CI servers and headless environments, generate a new token with " +
-        clc.bold("firebase login:ci"), { exit: 1 });
+        clc.bold("firebase login:ci");
+    logger_1.logger.error(message);
+    return new error_1.FirebaseError(message, { exit: 1 });
 }
 const FIFTEEN_MINUTES_IN_MS = 15 * 60 * 1000;
 const SCOPES = [

package/lib/emulator/controller.js

@@ -47,6 +47,7 @@ const fileUtils_1 = require("../dataconnect/fileUtils");
 const tasksEmulator_1 = require("./tasksEmulator");
 const apphosting_1 = require("./apphosting");
 const webhook_1 = require("../dataconnect/webhook");
+const api_1 = require("../api");
 const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
 async function exportOnExit(options) {
     const exportOnExitDir = options.exportOnExit;
@@ -264,7 +265,7 @@ async function startAll(options, showUI = true, runningTestScript = false) {
                     portFixed: !!wsPortConfig,
                 };
             }
-            if (emulator === types_1.Emulators.DATACONNECT) {
+            if (emulator === types_1.Emulators.DATACONNECT && !(0, api_1.dataConnectLocalConnString)()) {
                 const pglitePortConfig = (_f = (_e = options.config.src.emulators) === null || _e === void 0 ? void 0 : _e.dataconnect) === null || _f === void 0 ? void 0 : _f.postgresPort;
                 listenConfig["dataconnect.postgres"] = {
                     host: config.host,

package/lib/emulator/dataconnectEmulator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataConnectEmulatorClient = exports.DataConnectEmulator = exports.dataConnectEmulatorEvents = void 0;
 const childProcess = require("child_process");
 const events_1 = require("events");
+const clc = require("colorette");
 const api_1 = require("../api");
 const constants_1 = require("./constants");
 const downloadableEmulators_1 = require("./downloadableEmulators");
@@ -26,26 +27,23 @@ class DataConnectEmulator {
         this.emulatorClient = new DataConnectEmulatorClient();
     }
     async start() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         let resolvedConfigDir;
         try {
             resolvedConfigDir = this.args.config.path(this.args.configDir);
             const info = await DataConnectEmulator.build({ configDir: resolvedConfigDir });
             if ((0, types_2.requiresVector)(info.metadata)) {
                 if (constants_1.Constants.isDemoProject(this.args.projectId)) {
-                    this.logger.logLabeled("WARN", "Data Connect", "Detected a 'demo-' project, but vector embeddings require a real project. Operations that use vector_embed will fail.");
+                    this.logger.logLabeled("WARN", "dataconnect", "Detected a 'demo-' project, but vector embeddings require a real project. Operations that use vector_embed will fail.");
                 }
                 else {
-                    this.logger.logLabeled("WARN", "Data Connect", "Operations that use vector_embed will make calls to production Vertex AI");
+                    this.logger.logLabeled("WARN", "dataconnect", "Operations that use vector_embed will make calls to production Vertex AI");
                 }
             }
         }
         catch (err) {
             this.logger.log("DEBUG", `'fdc build' failed with error: ${err.message}`);
         }
-        const info = await (0, load_1.load)(this.args.projectId, this.args.config, this.args.configDir);
-        const dbId = ((_a = info.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.database) || "postgres";
-        const serviceId = info.dataConnectYaml.serviceId;
         await (0, downloadableEmulators_1.start)(types_1.Emulators.DATACONNECT, {
             auto_download: this.args.auto_download,
             listen: (0, portUtils_1.listenSpecsToString)(this.args.listen),
@@ -55,11 +53,14 @@ class DataConnectEmulator {
         });
         this.usingExistingEmulator = false;
         if (this.args.autoconnectToPostgres) {
+            const info = await (0, load_1.load)(this.args.projectId, this.args.config, this.args.configDir);
+            const dbId = ((_a = info.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.database) || "postgres";
+            const serviceId = info.dataConnectYaml.serviceId;
             const pgPort = (_b = this.args.postgresListen) === null || _b === void 0 ? void 0 : _b[0].port;
             const pgHost = (_c = this.args.postgresListen) === null || _c === void 0 ? void 0 : _c[0].address;
             let connStr = (0, api_1.dataConnectLocalConnString)();
-            if ((0, api_1.dataConnectLocalConnString)()) {
-                this.logger.logLabeled("INFO", "Data Connect", `FIREBASE_DATACONNECT_POSTGRESQL_STRING is set to ${(0, api_1.dataConnectLocalConnString)()} - using that instead of starting a new database`);
+            if (connStr) {
+                this.logger.logLabeled("INFO", "dataconnect", `FIREBASE_DATACONNECT_POSTGRESQL_STRING is set to ${clc.bold(connStr)} - using that instead of starting a new database`);
             }
             else if (pgHost && pgPort) {
                 const pgServer = new pgliteServer_1.PostgresServer(dbId, "postgres");
@@ -71,11 +72,11 @@ class DataConnectEmulator {
                         this.logger.logLabeled("ERROR", "Data Connect", `${err}`);
                     }
                     else {
-                        this.logger.logLabeled("ERROR", "Data Connect", `Postgres threw an unexpected error, shutting down the Data Connect emulator: ${err}`);
+                        this.logger.logLabeled("ERROR", "dataconnect", `Postgres threw an unexpected error, shutting down the Data Connect emulator: ${err}`);
                     }
                     void (0, controller_1.cleanShutdown)();
                 });
-                this.logger.logLabeled("INFO", "Data Connect", `Started up Postgres server, listening on ${(_d = server.address()) === null || _d === void 0 ? void 0 : _d.toString()}`);
+                this.logger.logLabeled("INFO", "dataconnect", `Started up Postgres server, listening on ${JSON.stringify(server.address())}`);
             }
             await this.connectToPostgres(new URL(connStr), dbId, serviceId);
         }
@@ -84,14 +85,14 @@ class DataConnectEmulator {
     async connect() {
         const emuInfo = await this.emulatorClient.getInfo();
         if (!emuInfo) {
-            this.logger.logLabeled("ERROR", "Data Connect", "Could not connect to Data Connect emulator. Check dataconnect-debug.log for more details.");
+            this.logger.logLabeled("ERROR", "dataconnect", "Could not connect to Data Connect emulator. Check dataconnect-debug.log for more details.");
             return Promise.reject();
         }
         return Promise.resolve();
     }
     async stop() {
         if (this.usingExistingEmulator) {
-            this.logger.logLabeled("INFO", "Data Connect", "Skipping cleanup of Data Connect emulator, as it was not started by this process.");
+            this.logger.logLabeled("INFO", "dataconnect", "Skipping cleanup of Data Connect emulator, as it was not started by this process.");
             return;
         }
         return (0, downloadableEmulators_1.stop)(types_1.Emulators.DATACONNECT);

package/lib/emulator/downloadableEmulators.js

@@ -48,20 +48,20 @@ const EMULATOR_UPDATE_DETAILS = {
     },
     dataconnect: process.platform === "darwin"
         ? {
-            version: "1.6.1",
-            expectedSize: 25309952,
-            expectedChecksum: "826692eb4ed9cf11becb595c386eb7bf",
+            version: "1.7.0",
+            expectedSize: 25350912,
+            expectedChecksum: "1479411a52b689a990179c7f674362b6",
         }
         : process.platform === "win32"
             ? {
-                version: "1.6.1",
-                expectedSize: 25737728,
-                expectedChecksum: "1e87a3a1f95d7b21cebf18f551619167",
+                version: "1.7.0",
+                expectedSize: 25783808,
+                expectedChecksum: "fef62bf25e816aa4ba250e80050f0125",
             }
             : {
-                version: "1.6.1",
-                expectedSize: 25223320,
-                expectedChecksum: "b13218419fcaaa3ad22005ce8378412d",
+                version: "1.7.0",
+                expectedSize: 25272472,
+                expectedChecksum: "24d873457787546ca6f2470fe9ec3edd",
             },
 };
 exports.DownloadDetails = {

package/lib/emulator/emulatorLogger.js

@@ -210,6 +210,9 @@ You can probably fix this by running "npm install ${systemLog.data.name}@latest"
             case "BULLET":
                 utils.logLabeledBullet(label, text, "info", mergedData);
                 break;
+            case "INFO":
+                utils.logLabeledBullet(label, text, "info", mergedData);
+                break;
             case "SUCCESS":
                 utils.logLabeledSuccess(label, text, "info", mergedData);
                 break;

package/lib/emulator/tasksEmulator.js

@@ -116,7 +116,10 @@ class TasksEmulator {
             const locationId = req.params.location_id;
             const queueName = req.params.queue_name;
             if (!this.validateQueueId(queueName)) {
-                res.status(400).send("Invalid Queue ID");
+                res.status(400).json({
+                    error: "Queue ID must start with a letter followed by up to 62 letters, numbers, " +
+                        "hyphens, or underscores and must end with a letter or a number",
+                });
                 return;
             }
             const key = `queue:${projectId}-${locationId}-${queueName}`;
@@ -139,7 +142,7 @@ class TasksEmulator {
                 defaultUri: body.defaultUri,
             };
             if (taskQueueConfig.rateLimits.maxConcurrentDispatches > 5000) {
-                res.status(400).send("cannot set maxConcurrentDispatches to a value over 5000");
+                res.status(400).json({ error: "cannot set maxConcurrentDispatches to a value over 5000" });
                 return;
             }
             this.controller.createQueue(key, taskQueueConfig);

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

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptWriteMode = exports.isPackageJson = exports.isTsConfig = exports.genkitSetup = exports.ensureVertexApiEnabled = exports.doSetup = void 0;
+const fs = require("fs");
+const inquirer = require("inquirer");
+const path = require("path");
+const semver = require("semver");
+const clc = require("colorette");
+const child_process_1 = require("child_process");
+const functions_1 = require("../functions");
+const prompt_1 = require("../../../prompt");
+const spawn_1 = require("../../spawn");
+const projectUtils_1 = require("../../../projectUtils");
+const ensureApiEnabled_1 = require("../../../ensureApiEnabled");
+const logger_1 = require("../../../logger");
+const error_1 = require("../../../error");
+const utils_1 = require("../../../utils");
+const types_1 = require("../../../extensions/types");
+async function getGenkitVersion() {
+    let genkitVersion;
+    let templateVersion = "0.9.0";
+    let useInit = false;
+    let stopInstall = false;
+    if (process.env.GENKIT_DEV_VERSION && typeof process.env.GENKIT_DEV_VERSION === "string") {
+        semver.parse(process.env.GENKIT_DEV_VERSION);
+        genkitVersion = process.env.GENKIT_DEV_VERSION;
+    }
+    else {
+        genkitVersion = (0, child_process_1.execFileSync)("npm", ["view", "genkit", "version"]).toString();
+    }
+    if (!genkitVersion) {
+        throw new error_1.FirebaseError("Unable to determine genkit version to install");
+    }
+    if (semver.gte(genkitVersion, "1.0.0")) {
+        const continueInstall = await (0, prompt_1.confirm)({
+            message: clc.yellow(`WARNING: The latest version of Genkit (${genkitVersion}) isn't supported by this\n` +
+                "version of firebase-tools. You can proceed, but the provided sample code may\n" +
+                "not work with the latest library. You can also try updating firebase-tools with\n" +
+                "npm install -g firebase-tools@latest, and then running this command again.\n\n") + "Proceed with installing the latest version of Genkit?",
+            default: false,
+        });
+        if (!continueInstall) {
+            stopInstall = true;
+        }
+    }
+    else if (semver.gte(genkitVersion, "0.6.0")) {
+    }
+    else {
+        templateVersion = "";
+        useInit = true;
+    }
+    return { genkitVersion, templateVersion, useInit, stopInstall };
+}
+async function doSetup(setup, config, options) {
+    var _a;
+    const genkitInfo = await getGenkitVersion();
+    if (genkitInfo.stopInstall) {
+        (0, utils_1.logLabeledWarning)("genkit", "Stopped Genkit initialization");
+        return;
+    }
+    if (((_a = setup.functions) === null || _a === void 0 ? void 0 : _a.languageChoice) !== "typescript") {
+        const continueFunctions = await (0, prompt_1.confirm)({
+            message: "Genkit's Firebase integration uses Cloud Functions for Firebase with TypeScript.\nInitialize Functions to continue?",
+            default: true,
+        });
+        if (!continueFunctions) {
+            (0, utils_1.logLabeledWarning)("genkit", "Stopped Genkit initialization");
+            return;
+        }
+        setup.languageOverride = "typescript";
+        await (0, functions_1.doSetup)(setup, config, options);
+        delete setup.languageOverride;
+        logger_1.logger.info();
+    }
+    if (!setup.functions) {
+        throw new error_1.FirebaseError("Failed to initialize Genkit prerequisite: Firebase functions");
+    }
+    const projectDir = `${config.projectDir}/${setup.functions.source}`;
+    const installType = (await inquirer.prompt([
+        {
+            name: "choice",
+            type: "list",
+            message: "Install the Genkit CLI globally or locally in this project?",
+            choices: [
+                { name: "Globally", value: "globally" },
+                { name: "Just this project", value: "project" },
+            ],
+        },
+    ])).choice;
+    try {
+        (0, utils_1.logLabeledBullet)("genkit", `Installing Genkit CLI version ${genkitInfo.genkitVersion}`);
+        if (installType === "globally") {
+            if (genkitInfo.useInit) {
+                await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", `genkit@${genkitInfo.genkitVersion}`], projectDir);
+                await (0, spawn_1.wrapSpawn)("genkit", ["init", "-p", "firebase"], projectDir);
+                logger_1.logger.info("Start the Genkit developer experience by running:");
+                logger_1.logger.info(`    cd ${setup.functions.source} && genkit start`);
+            }
+            else {
+                await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", `genkit-cli@${genkitInfo.genkitVersion}`], projectDir);
+                await genkitSetup(options, genkitInfo, projectDir);
+                logger_1.logger.info("Start the Genkit developer experience by running:");
+                logger_1.logger.info(`    cd ${setup.functions.source} && npm run genkit:start`);
+            }
+        }
+        else {
+            if (genkitInfo.useInit) {
+                await (0, spawn_1.wrapSpawn)("npm", ["install", `genkit@${genkitInfo.genkitVersion}`, "--save-dev"], projectDir);
+                await (0, spawn_1.wrapSpawn)("npx", ["genkit", "init", "-p", "firebase"], projectDir);
+                logger_1.logger.info("Start the Genkit developer experience by running:");
+                logger_1.logger.info(`    cd ${setup.functions.source} && npx genkit start`);
+            }
+            else {
+                await (0, spawn_1.wrapSpawn)("npm", ["install", `genkit-cli@${genkitInfo.genkitVersion}`, "--save-dev"], projectDir);
+                await genkitSetup(options, genkitInfo, projectDir);
+                logger_1.logger.info("Start the Genkit developer experience by running:");
+                logger_1.logger.info();
+                logger_1.logger.info(clc.bold(clc.green(`    cd ${setup.functions.source} && npm run genkit:start`)));
+            }
+        }
+    }
+    catch (err) {
+        (0, utils_1.logLabeledError)("genkit", `Genkit initialization failed: ${(0, error_1.getErrMsg)(err)}`);
+        return;
+    }
+}
+exports.doSetup = doSetup;
+async function ensureVertexApiEnabled(options) {
+    const VERTEX_AI_URL = "https://aiplatform.googleapis.com";
+    const projectId = (0, projectUtils_1.getProjectId)(options);
+    if (!projectId) {
+        return;
+    }
+    const silently = typeof options.markdown === "boolean" && options.markdown;
+    return await (0, ensureApiEnabled_1.ensure)(projectId, VERTEX_AI_URL, "aiplatform", silently);
+}
+exports.ensureVertexApiEnabled = ensureVertexApiEnabled;
+function getModelOptions(genkitVersion) {
+    const modelOptions = {
+        vertexai: {
+            label: "Google Cloud Vertex AI",
+            plugin: "@genkit-ai/vertexai",
+            package: `@genkit-ai/vertexai@${genkitVersion}`,
+        },
+        googleai: {
+            label: "Google AI",
+            plugin: "@genkit-ai/googleai",
+            package: `@genkit-ai/googleai@${genkitVersion}`,
+        },
+        none: { label: "None", plugin: undefined, package: undefined },
+    };
+    return modelOptions;
+}
+const pluginToInfo = {
+    "@genkit-ai/firebase": {
+        imports: "firebase",
+        init: `
+    // Load the Firebase plugin, which provides integrations with several
+    // Firebase services.
+    firebase()`.trimStart(),
+    },
+    "@genkit-ai/vertexai": {
+        imports: "vertexAI",
+        modelImportComment: `
+// Import models from the Vertex AI plugin. The Vertex AI API provides access to
+// several generative models. Here, we import Gemini 1.5 Flash.`.trimStart(),
+        init: `
+    // Load the Vertex AI plugin. You can optionally specify your project ID
+    // by passing in a config object; if you don't, the Vertex AI plugin uses
+    // the value from the GCLOUD_PROJECT environment variable.
+    vertexAI({location: "us-central1"})`.trimStart(),
+        model: "gemini15Flash",
+    },
+    "@genkit-ai/googleai": {
+        imports: "googleAI",
+        modelImportComment: `
+// Import models from the Google AI plugin. The Google AI API provides access to
+// several generative models. Here, we import Gemini 1.5 Flash.`.trimStart(),
+        init: `
+    // Load the Google AI plugin. You can optionally specify your API key
+    // by passing in a config object; if you don't, the Google AI plugin uses
+    // the value from the GOOGLE_GENAI_API_KEY environment variable, which is
+    // the recommended practice.
+    googleAI()`.trimStart(),
+        model: "gemini15Flash",
+    },
+};
+function getBasePackages(genkitVersion) {
+    const basePackages = ["express", `genkit@${genkitVersion}`];
+    return basePackages;
+}
+const externalDevPackages = ["typescript", "tsx"];
+async function genkitSetup(options, genkitInfo, projectDir) {
+    var _a, _b;
+    const modelOptions = getModelOptions(genkitInfo.genkitVersion);
+    const supportedModels = Object.keys(modelOptions);
+    const answer = await inquirer.prompt([
+        {
+            type: "list",
+            name: "model",
+            message: "Select a model provider:",
+            choices: supportedModels.map((model) => ({
+                name: modelOptions[model].label,
+                value: model,
+            })),
+        },
+    ]);
+    const model = answer.model;
+    if (model === "vertexai") {
+        await ensureVertexApiEnabled(options);
+    }
+    const plugins = [];
+    const pluginPackages = [];
+    pluginPackages.push(`@genkit-ai/firebase@${genkitInfo.genkitVersion}`);
+    if ((_a = modelOptions[model]) === null || _a === void 0 ? void 0 : _a.plugin) {
+        plugins.push(modelOptions[model].plugin || "");
+    }
+    if ((_b = modelOptions[model]) === null || _b === void 0 ? void 0 : _b.package) {
+        pluginPackages.push(modelOptions[model].package || "");
+    }
+    const packages = [...getBasePackages(genkitInfo.genkitVersion)];
+    packages.push(...pluginPackages);
+    await installNpmPackages(projectDir, packages, externalDevPackages);
+    if (!fs.existsSync(path.join(projectDir, "src"))) {
+        fs.mkdirSync(path.join(projectDir, "src"));
+    }
+    await updateTsConfig(options.nonInteractive || false, projectDir);
+    await updatePackageJson(options.nonInteractive || false, projectDir);
+    if (options.nonInteractive ||
+        (await (0, prompt_1.confirm)({
+            message: "Would you like to generate a sample flow?",
+            default: true,
+        }))) {
+        generateSampleFile(modelOptions[model].plugin, plugins, projectDir, genkitInfo.templateVersion);
+    }
+}
+exports.genkitSetup = genkitSetup;
+const isTsConfig = (value) => {
+    if (!(0, types_1.isObject)(value) || (value.compilerOptions && !(0, types_1.isObject)(value.compilerOptions))) {
+        return false;
+    }
+    return true;
+};
+exports.isTsConfig = isTsConfig;
+async function updateTsConfig(nonInteractive, projectDir) {
+    const tsConfigPath = path.join(projectDir, "tsconfig.json");
+    let existingTsConfig = undefined;
+    if (fs.existsSync(tsConfigPath)) {
+        const parsed = JSON.parse(fs.readFileSync(tsConfigPath, "utf-8"));
+        if (!(0, exports.isTsConfig)(parsed)) {
+            throw new error_1.FirebaseError("Unable to parse existing tsconfig.json");
+        }
+        existingTsConfig = parsed;
+    }
+    let choice = "overwrite";
+    if (!nonInteractive && existingTsConfig) {
+        choice = await promptWriteMode("Would you like to update your tsconfig.json with suggested settings?");
+    }
+    const tsConfig = {
+        compileOnSave: true,
+        include: ["src"],
+        compilerOptions: {
+            module: "commonjs",
+            noImplicitReturns: true,
+            outDir: "lib",
+            sourceMap: true,
+            strict: true,
+            target: "es2017",
+            skipLibCheck: true,
+            esModuleInterop: true,
+        },
+    };
+    (0, utils_1.logLabeledBullet)("genkit", "Updating tsconfig.json");
+    let newTsConfig = {};
+    switch (choice) {
+        case "overwrite":
+            newTsConfig = Object.assign(Object.assign(Object.assign({}, existingTsConfig), tsConfig), { compilerOptions: Object.assign(Object.assign({}, existingTsConfig === null || existingTsConfig === void 0 ? void 0 : existingTsConfig.compilerOptions), tsConfig.compilerOptions) });
+            break;
+        case "merge":
+            newTsConfig = Object.assign(Object.assign(Object.assign({}, tsConfig), existingTsConfig), { compilerOptions: Object.assign(Object.assign({}, tsConfig.compilerOptions), existingTsConfig === null || existingTsConfig === void 0 ? void 0 : existingTsConfig.compilerOptions) });
+            break;
+        case "keep":
+            (0, utils_1.logLabeledWarning)("genkit", "Skipped updating tsconfig.json");
+            return;
+    }
+    try {
+        fs.writeFileSync(tsConfigPath, JSON.stringify(newTsConfig, null, 2));
+        (0, utils_1.logLabeledSuccess)("genkit", "Successfully updated tsconfig.json");
+    }
+    catch (err) {
+        (0, utils_1.logLabeledError)("genkit", `Failed to update tsconfig.json: ${(0, error_1.getErrMsg)(err)}`);
+        process.exit(1);
+    }
+}
+async function installNpmPackages(projectDir, packages, devPackages) {
+    (0, utils_1.logLabeledBullet)("genkit", "Installing NPM packages for genkit");
+    try {
+        if (packages.length) {
+            await (0, spawn_1.wrapSpawn)("npm", ["install", ...packages, "--save"], projectDir);
+        }
+        if (devPackages === null || devPackages === void 0 ? void 0 : devPackages.length) {
+            await (0, spawn_1.wrapSpawn)("npm", ["install", ...devPackages, "--save-dev"], projectDir);
+        }
+        (0, utils_1.logLabeledSuccess)("genkit", "Successfully installed NPM packages");
+    }
+    catch (err) {
+        (0, utils_1.logLabeledError)("genkit", `Failed to install NPM packages: ${(0, error_1.getErrMsg)(err)}`);
+        process.exit(1);
+    }
+}
+function generateSampleFile(modelPlugin, configPlugins, projectDir, templateVersion) {
+    let modelImport = "";
+    if (modelPlugin && pluginToInfo[modelPlugin].model) {
+        const modelInfo = pluginToInfo[modelPlugin].model || "";
+        modelImport = "\n" + generateImportStatement(modelInfo, modelPlugin) + "\n";
+    }
+    let modelImportComment = "";
+    if (modelPlugin && pluginToInfo[modelPlugin].modelImportComment) {
+        const comment = pluginToInfo[modelPlugin].modelImportComment || "";
+        modelImportComment = `\n${comment}`;
+    }
+    const commentedModelImport = `${modelImportComment}${modelImport}`;
+    const templatePath = path.join(__dirname, `../../../../templates/genkit/firebase.${templateVersion}.template`);
+    const template = fs.readFileSync(templatePath, "utf8");
+    const sample = renderConfig(configPlugins, template
+        .replace("$GENKIT_MODEL_IMPORT\n", commentedModelImport)
+        .replace("$GENKIT_MODEL", modelPlugin
+        ? pluginToInfo[modelPlugin].model || pluginToInfo[modelPlugin].modelStr || ""
+        : "'' /* TODO: Set a model. */"));
+    (0, utils_1.logLabeledBullet)("genkit", "Generating sample file");
+    try {
+        const samplePath = "src/genkit-sample.ts";
+        fs.writeFileSync(path.join(projectDir, samplePath), sample, "utf8");
+        (0, utils_1.logLabeledSuccess)("genkit", `Successfully generated sample file (${samplePath})`);
+    }
+    catch (err) {
+        (0, utils_1.logLabeledError)("genkit", `Failed to generate sample file: ${(0, error_1.getErrMsg)(err)}`);
+        process.exit(1);
+    }
+}
+const isPackageJson = (value) => {
+    if (!(0, types_1.isObject)(value) || (value.scripts && !(0, types_1.isObject)(value.scripts))) {
+        return false;
+    }
+    return true;
+};
+exports.isPackageJson = isPackageJson;
+async function updatePackageJson(nonInteractive, projectDir) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new error_1.FirebaseError("Failed to find package.json.");
+    }
+    const existingPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    if (!(0, exports.isPackageJson)(existingPackageJson)) {
+        throw new error_1.FirebaseError("Unable to parse existing package.json file");
+    }
+    const choice = nonInteractive
+        ? "overwrite"
+        : await promptWriteMode("Would you like to update your package.json with suggested settings?");
+    const packageJson = {
+        main: "lib/index.js",
+        scripts: {
+            "genkit:start": "genkit start -- tsx --watch src/genkit-sample.ts",
+        },
+    };
+    (0, utils_1.logLabeledBullet)("genkit", "Updating package.json");
+    let newPackageJson = {};
+    switch (choice) {
+        case "overwrite":
+            newPackageJson = Object.assign(Object.assign(Object.assign({}, existingPackageJson), packageJson), { scripts: Object.assign(Object.assign({}, existingPackageJson.scripts), packageJson.scripts) });
+            break;
+        case "merge":
+            newPackageJson = Object.assign(Object.assign(Object.assign({}, packageJson), existingPackageJson), { main: packageJson.main, scripts: Object.assign(Object.assign({}, packageJson.scripts), existingPackageJson.scripts) });
+            break;
+        case "keep":
+            (0, utils_1.logLabeledWarning)("genkit", "Skipped updating package.json");
+            return;
+    }
+    try {
+        fs.writeFileSync(packageJsonPath, JSON.stringify(newPackageJson, null, 2));
+        (0, utils_1.logLabeledSuccess)("genkit", "Successfully updated package.json");
+    }
+    catch (err) {
+        (0, utils_1.logLabeledError)("genkit", `Failed to update package.json: ${(0, error_1.getErrMsg)(err)}`);
+        process.exit(1);
+    }
+}
+function renderConfig(pluginNames, template) {
+    const imports = pluginNames
+        .map((pluginName) => generateImportStatement(pluginToInfo[pluginName].imports, pluginName))
+        .join("\n");
+    const plugins = pluginNames.map((pluginName) => `    ${pluginToInfo[pluginName].init},`).join("\n") ||
+        "    /* Add your plugins here. */";
+    return template
+        .replace("$GENKIT_CONFIG_IMPORTS", imports)
+        .replace("$GENKIT_CONFIG_PLUGINS", plugins);
+}
+function generateImportStatement(imports, name) {
+    return `import {${imports}} from "${name}";`;
+}
+async function promptWriteMode(message, defaultOption = "merge") {
+    const answer = await inquirer.prompt([
+        {
+            type: "list",
+            name: "option",
+            message,
+            choices: [
+                { name: "Set if unset", value: "merge" },
+                { name: "Overwrite", value: "overwrite" },
+                { name: "Keep unchanged", value: "keep" },
+            ],
+            default: defaultOption,
+        },
+    ]);
+    return answer.option;
+}
+exports.promptWriteMode = promptWriteMode;

package/package.json

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

package/templates/genkit/firebase.0.9.0.template

@@ -0,0 +1,57 @@
+// Import the Genkit core libraries and plugins.
+import {genkit, z} from "genkit";
+$GENKIT_CONFIG_IMPORTS
+$GENKIT_MODEL_IMPORT
+
+// From the Firebase plugin, import the functions needed to deploy flows using
+// Cloud Functions.
+import {firebaseAuth} from "@genkit-ai/firebase/auth";
+import {onFlow} from "@genkit-ai/firebase/functions";
+
+const ai = genkit({
+  plugins: [
+$GENKIT_CONFIG_PLUGINS
+  ],
+});
+
+// Define a simple flow that prompts an LLM to generate menu suggestions.
+export const menuSuggestionFlow = onFlow(
+  ai,
+  {
+    name: "menuSuggestionFlow",
+    inputSchema: z.string(),
+    outputSchema: z.string(),
+    authPolicy: firebaseAuth((user) => {
+      // By default, the firebaseAuth policy requires that all requests have an
+      // `Authorization: Bearer` header containing the user's Firebase
+      // Authentication ID token. All other requests are rejected with error
+      // 403. If your app client uses the Cloud Functions for Firebase callable
+      // functions feature, the library automatically attaches this header to
+      // requests.
+
+      // You should also set additional policy requirements as appropriate for
+      // your app. For example:
+      // if (!user.email_verified) {
+      //   throw new Error("Verified email required to run flow");
+      // }
+    }),
+  },
+  async (subject) => {
+    // Construct a request and send it to the model API.
+    const prompt =
+      `Suggest an item for the menu of a ${subject} themed restaurant`;
+    const llmResponse = await ai.generate({
+      model: $GENKIT_MODEL,
+      prompt: prompt,
+      config: {
+        temperature: 1,
+      },
+    });
+
+    // Handle the response from the model API. In this sample, we just
+    // convert it to a string, but more complicated flows might coerce the
+    // response into structured output or chain the response into another
+    // LLM call, etc.
+    return llmResponse.text;
+  }
+);

package/lib/init/features/genkit.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.doSetup = void 0;
-const logger_1 = require("../../logger");
-const functions_1 = require("./functions");
-const prompt_1 = require("../../prompt");
-const spawn_1 = require("../spawn");
-async function doSetup(setup, config, options) {
-    var _a;
-    if (((_a = setup.functions) === null || _a === void 0 ? void 0 : _a.languageChoice) !== "typescript") {
-        const continueFunctions = await (0, prompt_1.promptOnce)({
-            type: "confirm",
-            message: "Genkit's Firebase integration uses Cloud Functions for Firebase with TypeScript. Initialize Functions to continue?",
-            default: true,
-        });
-        if (!continueFunctions) {
-            logger_1.logger.info("Stopped Genkit initialization");
-            return;
-        }
-        setup.languageOverride = "typescript";
-        await (0, functions_1.doSetup)(setup, config, options);
-        delete setup.languageOverride;
-        logger_1.logger.info();
-    }
-    const projectDir = `${config.projectDir}/${setup.functions.source}`;
-    const installType = await (0, prompt_1.promptOnce)({
-        type: "list",
-        message: "Install the Genkit CLI globally or locally in this project?",
-        choices: [
-            { name: "Globally", value: "globally" },
-            { name: "Just this project", value: "project" },
-        ],
-    });
-    try {
-        logger_1.logger.info("Installing Genkit CLI");
-        if (installType === "globally") {
-            await (0, spawn_1.wrapSpawn)("npm", ["install", "-g", "genkit"], projectDir);
-            await (0, spawn_1.wrapSpawn)("genkit", ["init", "-p", "firebase"], projectDir);
-            logger_1.logger.info("Start the Genkit developer experience by running:");
-            logger_1.logger.info(`    cd ${setup.functions.source} && genkit start`);
-        }
-        else {
-            await (0, spawn_1.wrapSpawn)("npm", ["install", "genkit", "--save-dev"], projectDir);
-            await (0, spawn_1.wrapSpawn)("npx", ["genkit", "init", "-p", "firebase"], projectDir);
-            logger_1.logger.info("Start the Genkit developer experience by running:");
-            logger_1.logger.info(`    cd ${setup.functions.source} && npx genkit start`);
-        }
-    }
-    catch (e) {
-        logger_1.logger.error("Genkit initialization failed...");
-        return;
-    }
-}
-exports.doSetup = doSetup;