From 9c0ca9718bafa6010432f4c0e1b81717b91c80b9 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Tue, 24 Jun 2025 23:19:43 +0000
Subject: [PATCH] feat: Add global dataDir for emulator persistence

Implements a global `emulators.dataDir` setting in `firebase.json` to allow users to easily persist and re-load emulator data across sessions.

Key changes:
- Added `emulators.dataDir` to `firebase.json` schema.
- Updated `firebase init emulators` to prompt for `dataDir` configuration.
- Added `--ephemeral` flag to `emulators:start` and `emulators:exec` to ignore `dataDir` for a single run.
- Emulators now automatically import data from `dataDir` on startup if it exists and contains valid export metadata.
- Emulators now automatically export data to `dataDir` on clean shutdown if `dataDir` is configured (and not overridden by `--export-on-exit` flag).
- Handled deprecation of `emulators.dataconnect.dataDir`, preferring the global `emulators.dataDir` with warnings.
- Added unit tests for the new functionality.
---
 npm-shrinkwrap.json                 |   1 +
 schema/firebase-config.json         |   3 +
 src/command.ts                      |  15 ++++
 src/commands/emulators-exec.ts      |   1 +
 src/commands/emulators-start.ts     |   1 +
 src/config.spec.ts                  |  48 +++++++++-
 src/config.ts                       |  30 +++++++
 src/emulator/commandUtils.spec.ts   |  48 ++++++++++
 src/emulator/commandUtils.ts        |   6 ++
 src/emulator/controller.spec.ts     | 130 +++++++++++++++++++++++++++-
 src/emulator/controller.ts          |  66 ++++++++++++--
 src/firebaseConfig.ts               |   1 +
 src/init/features/emulators.spec.ts |  70 +++++++++++++++
 src/init/features/emulators.ts      |  16 ++++
 14 files changed, 427 insertions(+), 9 deletions(-)
 create mode 100644 src/init/features/emulators.spec.ts

diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json
index 36b7394c2c9..9314ea3bdd0 100644
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
@@ -20508,6 +20508,7 @@
       "resolved": "https://registry.npmjs.org/typescript-json-schema/-/typescript-json-schema-0.65.1.tgz",
       "integrity": "sha512-tuGH7ff2jPaUYi6as3lHyHcKpSmXIqN7/mu50x3HlYn0EHzLpmt3nplZ7EuhUkO0eqDRc9GqWNkfjgBPIS9kxg==",
       "dev": true,
+      "license": "BSD-3-Clause",
       "dependencies": {
         "@types/json-schema": "^7.0.9",
         "@types/node": "^18.11.9",
diff --git a/schema/firebase-config.json b/schema/firebase-config.json
index 546d045af00..2e1bdc141e1 100644
--- a/schema/firebase-config.json
+++ b/schema/firebase-config.json
@@ -1194,6 +1194,9 @@
                     },
                     "type": "object"
                 },
+                "dataDir": {
+                    "type": "string"
+                },
                 "database": {
                     "additionalProperties": false,
                     "properties": {
diff --git a/src/command.ts b/src/command.ts
index 325654c7953..221822e261c 100644
--- a/src/command.ts
+++ b/src/command.ts
@@ -89,6 +89,21 @@ export class Command {
     return this;
   }
 
+  // TODO: refactor this to be a private method and ensure all commands that need it call it.
+  // TODO: add a test for this.
+  /**
+   * Adds the --ephemeral flag to the command.
+   * @return The command, for chaining.
+   */
+  withEphemeral(): Command {
+    this.option(
+      "--ephemeral",
+      "ignore emulators.dataDir and start with a clean state",
+      false, // Default value if the flag is not present
+    );
+    return this;
+  }
+
   /**
    * Sets up --force flag for the command.
    *
diff --git a/src/commands/emulators-exec.ts b/src/commands/emulators-exec.ts
index dadd455bd3a..e11ca60930f 100644
--- a/src/commands/emulators-exec.ts
+++ b/src/commands/emulators-exec.ts
@@ -8,6 +8,7 @@ export const command = new Command("emulators:exec <script>")
   .description(
     "start the local Firebase emulators, run a test script, then shut down the emulators",
   )
+  .withEphemeral()
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
diff --git a/src/commands/emulators-start.ts b/src/commands/emulators-start.ts
index 6ddc4f3d135..1b877c55b87 100644
--- a/src/commands/emulators-start.ts
+++ b/src/commands/emulators-start.ts
@@ -20,6 +20,7 @@ export const command = new Command("emulators:start")
   .before(commandUtils.setExportOnExitOptions)
   .before(commandUtils.beforeEmulatorCommand)
   .description("start the local Firebase emulators")
+  .withEphemeral()
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
diff --git a/src/config.spec.ts b/src/config.spec.ts
index e07a249536e..01e6e3325e0 100644
--- a/src/config.spec.ts
+++ b/src/config.spec.ts
@@ -6,8 +6,21 @@ import { FIREBASE_JSON_PATH as VALID_CONFIG_PATH } from "./test/fixtures/valid-c
 import { FIXTURE_DIR as SIMPLE_CONFIG_DIR } from "./test/fixtures/config-imports";
 import { FIXTURE_DIR as DUP_TOP_LEVEL_CONFIG_DIR } from "./test/fixtures/dup-top-level";
 
+import * as sinon from "sinon";
+import * as utils from "./utils";
+
 describe("Config", () => {
-  describe("#load", () => {
+  let logWarningStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    logWarningStub = sinon.stub(utils, "logWarning");
+  });
+
+  afterEach(() => {
+    logWarningStub.restore();
+  });
+
+  describe("#constructor", () => {
     it("should load a cjson file when configPath is specified", () => {
       const cwd = __dirname;
       const config = Config.load({
@@ -19,6 +32,39 @@ describe("Config", () => {
         expect(config.get("database.rules")).to.eq("config/security-rules.json");
       }
     });
+
+    it("should handle emulators.dataDir and emulators.dataconnect.dataDir correctly", () => {
+      // Scenario 1: Only emulators.dataDir is present
+      let config = new Config({ emulators: { dataDir: "global_data" } }, {});
+      expect(config.get("emulators.dataDir")).to.equal("global_data");
+      expect(logWarningStub.called).to.be.false;
+
+      // Scenario 2: Only emulators.dataconnect.dataDir is present
+      logWarningStub.resetHistory();
+      config = new Config({ emulators: { dataconnect: { dataDir: "dc_data" } } }, {});
+      expect(config.get("emulators.dataDir")).to.equal("dc_data");
+      expect(config.get("emulators.dataconnect.dataDir")).to.be.undefined;
+      expect(logWarningStub.calledOnceWith("emulators.dataconnect.dataDir is deprecated. Please move your dataDir setting to emulators.dataDir.")).to.be.true;
+
+      // Scenario 3: Both are present
+      logWarningStub.resetHistory();
+      config = new Config({ emulators: { dataDir: "global_data", dataconnect: { dataDir: "dc_data" } } }, {});
+      expect(config.get("emulators.dataDir")).to.equal("global_data");
+      expect(config.get("emulators.dataconnect.dataDir")).to.be.undefined;
+      expect(logWarningStub.calledOnceWith("emulators.dataconnect.dataDir is deprecated and will be ignored. Use emulators.dataDir instead.")).to.be.true;
+
+      // Scenario 4: Neither is present
+      logWarningStub.resetHistory();
+      config = new Config({ emulators: {} }, {});
+      expect(config.get("emulators.dataDir")).to.be.undefined;
+      expect(logWarningStub.called).to.be.false;
+
+      // Scenario 5: emulators object is not present
+      logWarningStub.resetHistory();
+      config = new Config({}, {});
+      expect(config.get("emulators.dataDir")).to.be.undefined;
+      expect(logWarningStub.called).to.be.false;
+    });
   });
 
   describe("#path", () => {
diff --git a/src/config.ts b/src/config.ts
index ab7cd7e188d..00c45c4cb27 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -103,6 +103,36 @@ export class Config {
           "Please remove 'dataconnect.location' from 'firebase.json' and add it as top level field to 'dataconnect.yaml' instead ",
       );
     }
+
+    // Handle emulators.dataDir and emulators.dataconnect.dataDir
+    const emulatorsDataDir = _.get(this.data, "emulators.dataDir");
+    const dataconnectDataDir = _.get(this.data, "emulators.dataconnect.dataDir");
+
+    if (emulatorsDataDir && dataconnectDataDir) {
+      utils.logWarning(
+        "emulators.dataconnect.dataDir is deprecated and will be ignored. Use emulators.dataDir instead.",
+      );
+      // emulators.dataDir takes precedence, remove dataconnect.dataDir from internal representation
+      if (_.has(this.data, "emulators.dataconnect.dataDir")) {
+        delete this.data.emulators.dataconnect.dataDir;
+      }
+      if (_.has(this._src, "emulators.dataconnect.dataDir")) {
+        delete this._src.emulators.dataconnect.dataDir;
+      }
+    } else if (dataconnectDataDir) {
+      utils.logWarning(
+        "emulators.dataconnect.dataDir is deprecated. Please move your dataDir setting to emulators.dataDir.",
+      );
+      // Use dataconnect.dataDir if emulators.dataDir is not set
+      _.set(this.data, "emulators.dataDir", dataconnectDataDir);
+      // Remove dataconnect.dataDir from internal representation after copying its value
+      if (_.has(this.data, "emulators.dataconnect.dataDir")) {
+        delete this.data.emulators.dataconnect.dataDir;
+      }
+      if (_.has(this._src, "emulators.dataconnect.dataDir")) {
+        delete this._src.emulators.dataconnect.dataDir;
+      }
+    }
   }
 
   materialize(target: string) {
diff --git a/src/emulator/commandUtils.spec.ts b/src/emulator/commandUtils.spec.ts
index 0fb8da2f04b..c2b5fc885ed 100644
--- a/src/emulator/commandUtils.spec.ts
+++ b/src/emulator/commandUtils.spec.ts
@@ -5,7 +5,20 @@ import { EXPORT_ON_EXIT_USAGE_ERROR, EXPORT_ON_EXIT_CWD_DANGER } from "./command
 import * as path from "path";
 import * as sinon from "sinon";
 
+import { Config } from "../config";
+import * as utils from "../utils";
+
 describe("commandUtils", () => {
+  let logLabeledBulletStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    logLabeledBulletStub = sinon.stub(utils, "logLabeledBullet");
+  });
+
+  afterEach(() => {
+    logLabeledBulletStub.restore();
+  });
+
   const testSetExportOnExitOptions = (options: any): any => {
     commandUtils.setExportOnExitOptions(options);
     return options;
@@ -120,4 +133,39 @@ describe("commandUtils", () => {
       }).someUnrelatedOption,
     ).to.eql("isHere");
   });
+
+  describe("beforeEmulatorCommand", () => {
+    it("should unset dataDir if --ephemeral is true and dataDir is set", async () => {
+      const options = {
+        ephemeral: true,
+        config: new Config({ emulators: { dataDir: "./emulator_data" } }, {}),
+        project: "test-project",
+      };
+      await commandUtils.beforeEmulatorCommand(options);
+      expect(options.config.get("emulators.dataDir")).to.be.undefined;
+      expect(logLabeledBulletStub.calledOnceWith("emulators", "Ignoring dataDir due to --ephemeral flag.")).to.be.true;
+    });
+
+    it("should not modify dataDir if --ephemeral is false", async () => {
+      const options = {
+        ephemeral: false,
+        config: new Config({ emulators: { dataDir: "./emulator_data" } }, {}),
+        project: "test-project",
+      };
+      await commandUtils.beforeEmulatorCommand(options);
+      expect(options.config.get("emulators.dataDir")).to.equal("./emulator_data");
+      expect(logLabeledBulletStub.called).to.be.false;
+    });
+
+    it("should not modify dataDir if --ephemeral is true but dataDir is not set", async () => {
+      const options = {
+        ephemeral: true,
+        config: new Config({ emulators: {} }, {}),
+        project: "test-project",
+      };
+      await commandUtils.beforeEmulatorCommand(options);
+      expect(options.config.get("emulators.dataDir")).to.be.undefined;
+      expect(logLabeledBulletStub.called).to.be.false;
+    });
+  });
 });
diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index 6db837ce66a..e8562d9b7bf 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -181,6 +181,12 @@ export async function beforeEmulatorCommand(options: any): Promise<any> {
   } else {
     await requireConfig(options);
   }
+
+  // Handle --ephemeral flag
+  if (options.ephemeral && options.config?.emulators?.dataDir) {
+    delete options.config.emulators.dataDir;
+    utils.logLabeledBullet("emulators", "Ignoring dataDir due to --ephemeral flag.");
+  }
 }
 
 /**
diff --git a/src/emulator/controller.spec.ts b/src/emulator/controller.spec.ts
index a56f7ba5945..94c36c7f0ec 100644
--- a/src/emulator/controller.spec.ts
+++ b/src/emulator/controller.spec.ts
@@ -1,15 +1,141 @@
-import { Emulators } from "./types";
+import { Emulators, EmulatorInfo, ExportMetadata } from "./types";
 import { EmulatorRegistry } from "./registry";
 import { expect } from "chai";
+import * as sinon from "sinon";
+import * as fs from "fs-extra";
+import * as controller from "./controller";
+import { Config } from "../config";
 import { FakeEmulator } from "./testing/fakeEmulator";
+import * as utils from "../utils";
+import { EmulatorHub } from "./hub";
 
 describe("EmulatorController", () => {
+  let fsExistsSyncStub: sinon.SinonStub;
+  let fsLstatSyncStub: sinon.SinonStub;
+  let fsReaddirSyncStub: sinon.SinonStub;
+  let findExportMetadataStub: sinon.SinonStub;
+  let exportEmulatorDataStub: sinon.SinonStub;
+  let logBulletStub: sinon.SinonStub;
+  let logLabeledStub: sinon.SinonStub;
+  let hubGetInstanceStub: sinon.SinonStub;
+
+
+  beforeEach(() => {
+    fsExistsSyncStub = sinon.stub(fs, "existsSync");
+    fsLstatSyncStub = sinon.stub(fs, "lstatSync");
+    fsReaddirSyncStub = sinon.stub(fs, "readdirSync");
+    findExportMetadataStub = sinon.stub(controller, "findExportMetadata" as any);
+    exportEmulatorDataStub = sinon.stub(controller, "exportEmulatorData" as any);
+    logBulletStub = sinon.stub(utils, "logBullet");
+    logLabeledStub = sinon.stub(utils, "logLabeled"); // For hubLogger.logLabeled
+
+    // Stub EmulatorRegistry.get(Emulators.HUB) to return a mock hub instance
+    // so that hubLogger doesn't throw an error.
+    const mockHubInstance = sinon.createStubInstance(EmulatorHub);
+    hubGetInstanceStub = sinon.stub(EmulatorRegistry, "get").withArgs(Emulators.HUB).returns(mockHubInstance as any);
+
+  });
+
   afterEach(async () => {
     await EmulatorRegistry.stopAll();
+    sinon.restore();
+  });
+
+  describe("startAll", () => {
+    const baseOptions = () => ({
+      project: "test-project",
+      only: "firestore", // Assume at least one emulator is always being started
+      config: new Config({ firestore: {}, emulators: {} }, {}),
+      targets: [Emulators.FIRESTORE], // Added to satisfy filterEmulatorTargets
+    });
+
+    it("should attempt to import from dataDir if set and valid", async () => {
+      const opts = baseOptions();
+      opts.config = new Config({ firestore: {}, emulators: { dataDir: "./emulator_data_dir" } }, {});
+      fsExistsSyncStub.withArgs(sinon.match.string).returns(true);
+      fsLstatSyncStub.returns({ isDirectory: () => true } as fs.Stats);
+      const mockMetadata: ExportMetadata = { version: "1.0", firestore: { version: "prod", path: "./", metadata_file: "f.json"} };
+      findExportMetadataStub.resolves(mockMetadata);
+
+      // Stubbing minimum required for startAll to proceed without erroring out on other parts
+      sinon.stub(controller, "shouldStart" as any).returns(true);
+      sinon.stub(controller, "getListenConfig" as any).returns({ host: "localhost", port: 8080, portFixed: true });
+      sinon.stub(controller, "resolveHostAndAssignPorts" as any).resolves({ firestore: [{address: "localhost", port: 8080, family: "ipv4"}]});
+      sinon.stub(EmulatorRegistry, "start").resolves();
+      sinon.stub(fsConfig, "getFirestoreConfig" as any).returns([{rules: "firestore.rules"}]);
+
+
+      await controller.startAll(opts);
+
+      expect(findExportMetadataStub.calledWith(sinon.match("emulator_data_dir"))).to.be.true;
+      // Further assertions would check if this metadata was passed to individual emulator imports
+    });
+
+    it("should use --import path if dataDir is not set or invalid, and --import is set", async () => {
+      const opts = baseOptions();
+      opts.config = new Config({ firestore: {}, emulators: {} }, {}); // No dataDir
+      (opts as any).import = "./import_dir";
+
+      fsExistsSyncStub.withArgs(sinon.match("import_dir")).returns(true);
+      fsLstatSyncStub.withArgs(sinon.match("import_dir")).returns({ isDirectory: () => true } as fs.Stats);
+      const mockMetadata: ExportMetadata = { version: "1.0", firestore: { version: "prod", path: "./", metadata_file: "f.json"} };
+      findExportMetadataStub.withArgs(sinon.match("import_dir")).resolves(mockMetadata);
+
+      sinon.stub(controller, "shouldStart" as any).returns(true);
+      sinon.stub(controller, "getListenConfig" as any).returns({ host: "localhost", port: 8080, portFixed: true });
+      sinon.stub(controller, "resolveHostAndAssignPorts" as any).resolves({ firestore: [{address: "localhost", port: 8080, family: "ipv4"}]});
+      sinon.stub(EmulatorRegistry, "start").resolves();
+      sinon.stub(fsConfig, "getFirestoreConfig" as any).returns([{rules: "firestore.rules"}]);
+
+      await controller.startAll(opts);
+
+      expect(findExportMetadataStub.calledWith(sinon.match("import_dir"))).to.be.true;
+    });
+  });
+
+  describe("exportOnExit", () => {
+    it("should export to dataDir if set and --export-on-exit is not used", async () => {
+      const options = {
+        project: "test-project",
+        config: new Config({ emulators: { dataDir: "./emulator_data_dir" } }, {}),
+      };
+      exportEmulatorDataStub.resolves();
+
+      await controller.exportOnExit(options);
+
+      expect(exportEmulatorDataStub.calledOnceWith("./emulator_data_dir", options, "datadir_exit")).to.be.true;
+      expect(logBulletStub.calledWith(sinon.match("Automatically exporting data to global dataDir: \"./emulator_data_dir\""))).to.be.true;
+    });
+
+    it("should use --export-on-exit path if provided, even if dataDir is set", async () => {
+      const options = {
+        project: "test-project",
+        config: new Config({ emulators: { dataDir: "./emulator_data_dir" } }, {}),
+        exportOnExit: "./explicit_export_dir",
+      };
+      exportEmulatorDataStub.resolves();
+
+      await controller.exportOnExit(options);
+
+      expect(exportEmulatorDataStub.calledOnceWith("./explicit_export_dir", options, "exit")).to.be.true;
+    });
+
+    it("should do nothing if neither dataDir nor --export-on-exit is set", async () => {
+      const options = {
+        project: "test-project",
+        config: new Config({ emulators: {} }, {}),
+      };
+
+      await controller.exportOnExit(options);
+
+      expect(exportEmulatorDataStub.called).to.be.false;
+    });
   });
 
+  // Previous tests for start and stop can remain here
   it("should start and stop an emulator", async () => {
     const name = Emulators.FUNCTIONS;
+    hubGetInstanceStub.restore() // remove hub stub for this specific test if it interferes
 
     expect(EmulatorRegistry.isRunning(name)).to.be.false;
 
@@ -19,4 +145,4 @@ describe("EmulatorController", () => {
     expect(EmulatorRegistry.isRunning(name)).to.be.true;
     expect(EmulatorRegistry.getInfo(name)!.port).to.eql(fake.getInfo().port);
   });
-}).timeout(2000);
+}).timeout(5000); // Increased timeout for async operations
diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 684bd60e8cb..4028819ffe9 100755
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -76,8 +76,26 @@ const START_LOGGING_EMULATOR = utils.envOverride(
  */
 export async function exportOnExit(options: Options): Promise<void> {
   // Note: options.exportOnExit is coerced to a string before this point in commandUtils.ts#setExportOnExitOptions
-  const exportOnExitDir = options.exportOnExit as string;
+  const globalDataDir = options.config?.emulators?.dataDir as string | undefined;
+  const exportOnExitDir = options.exportOnExit as string | undefined;
+
+  if (globalDataDir && !exportOnExitDir) {
+    // If global dataDir is set and --export-on-exit is NOT used, export to global dataDir.
+    try {
+      utils.logBullet(
+        `Automatically exporting data to global dataDir: "${globalDataDir}" ` +
+          "please wait for the export to finish...",
+      );
+      await exportEmulatorData(globalDataDir, options, /* initiatedBy= */ "datadir_exit");
+    } catch (e: unknown) {
+      utils.logWarning(`${e}`);
+      utils.logWarning(`Automatic export to "${globalDataDir}" failed, going to exit now...`);
+    }
+    return; // Prioritize global dataDir if no specific exportOnExitDir is given.
+  }
+
   if (exportOnExitDir) {
+    // If --export-on-exit IS used, it takes precedence.
     try {
       utils.logBullet(
         `Automatically exporting data using ${FLAG_EXPORT_ON_EXIT_NAME} "${exportOnExitDir}" ` +
@@ -474,12 +492,41 @@ export async function startAll(
   let exportMetadata: ExportMetadata = {
     version: "unknown",
   };
-  if (options.import) {
+  const globalDataDir = options.config?.emulators?.dataDir as string | undefined;
+
+  if (globalDataDir) {
+    const dataDirPath = path.resolve(globalDataDir);
+    if (fs.existsSync(dataDirPath) && fs.lstatSync(dataDirPath).isDirectory()) {
+      const foundGlobalMetadata = findExportMetadata(dataDirPath);
+      if (foundGlobalMetadata) {
+        hubLogger.logLabeled("BULLET", "emulators", `Importing data from global dataDir: ${dataDirPath}`);
+        exportMetadata = foundGlobalMetadata;
+        void trackEmulator("emulator_import", {
+          initiated_by: "datadir_start",
+          emulator_name: Emulators.HUB,
+        });
+      } else {
+        // If dataDir exists but is empty or not a valid export, don't warn, just proceed.
+        // It might be intended for export only on the first run.
+        hubLogger.logLabeled("DEBUG", "emulators", `Global dataDir ${dataDirPath} is empty or not a valid export, skipping import from dataDir.`);
+      }
+    } else if (options.import) {
+      // dataDir is set but doesn't exist, but options.import is also set.
+      // Warn that dataDir will be created on exit, but for now, options.import will be used.
+       hubLogger.logLabeled("INFO", "emulators", `Global dataDir ${dataDirPath} does not exist. It will be created on export. Current import is from --import flag.`);
+    }
+  }
+
+  // --import flag takes precedence if dataDir did not yield metadata or if --import is explicitly used.
+  // However, if dataDir yielded metadata, it has already populated exportMetadata.
+  // This logic handles the case where dataDir is not set, or is empty, and --import is used.
+  if (options.import && exportMetadata.version === "unknown") {
     utils.assertIsString(options.import);
     const importDir = path.resolve(options.import);
-    const foundMetadata = findExportMetadata(importDir);
-    if (foundMetadata) {
-      exportMetadata = foundMetadata;
+    const foundImportFlagMetadata = findExportMetadata(importDir);
+    if (foundImportFlagMetadata) {
+      hubLogger.logLabeled("BULLET", "emulators", `Importing data from --import directory: ${importDir}`);
+      exportMetadata = foundImportFlagMetadata;
       void trackEmulator("emulator_import", {
         initiated_by: "start",
         emulator_name: Emulators.HUB,
@@ -488,11 +535,18 @@ export async function startAll(
       hubLogger.logLabeled(
         "WARN",
         "emulators",
-        `Could not find import/export metadata file, ${clc.bold("skipping data import!")}`,
+        `Could not find import/export metadata file in --import directory ${importDir}, ${clc.bold(
+          "skipping data import!",
+        )}`,
       );
     }
+  } else if (options.import && exportMetadata.version !== "unknown" && globalDataDir) {
+    // This case means globalDataDir provided metadata, and --import was also used.
+    // globalDataDir's metadata already took precedence. Log this clearly.
+    hubLogger.logLabeled("INFO", "emulators", `Global dataDir (${globalDataDir}) provided import data, --import flag (${options.import}) was ignored for initial import.`);
   }
 
+
   // TODO: turn this into hostingConfig.extract or hostingConfig.hostingConfig
   // once those branches merge
   const hostingConfig = options.config.get("hosting");
diff --git a/src/firebaseConfig.ts b/src/firebaseConfig.ts
index b0c46bee651..c5eed5dcbc1 100644
--- a/src/firebaseConfig.ts
+++ b/src/firebaseConfig.ts
@@ -252,6 +252,7 @@ export type EmulatorsConfig = {
     host?: string;
     port?: number;
   };
+  dataDir?: string;
 };
 
 export type ExtensionsConfig = Record<string, string>;
diff --git a/src/init/features/emulators.spec.ts b/src/init/features/emulators.spec.ts
new file mode 100644
index 00000000000..d9d6152009b
--- /dev/null
+++ b/src/init/features/emulators.spec.ts
@@ -0,0 +1,70 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import * as prompt from "../../prompt"; // Adjust path as needed
+import { doSetup } from "./emulators"; // Adjust path as needed
+import { Config } from "../../config"; // Adjust path as needed
+import { Emulators } from "../../emulator/types";
+
+describe("Emulators Init Feature", () => {
+  let confirmStub: sinon.SinonStub;
+  let inputStub: sinon.SinonStub;
+  let checkboxStub: sinon.SinonStub;
+  let setup: any;
+  let config: Config;
+
+  beforeEach(() => {
+    confirmStub = sinon.stub(prompt, "confirm");
+    inputStub = sinon.stub(prompt, "input");
+    checkboxStub = sinon.stub(prompt, "checkbox");
+
+    config = new Config({}, {}); // Basic config
+    setup = {
+      config: { emulators: {} }, // Ensure emulators property exists
+      rcfile: {},
+    };
+  });
+
+  afterEach(() => {
+    confirmStub.restore();
+    inputStub.restore();
+    checkboxStub.restore();
+  });
+
+  it("should ask for dataDir and set it in config if user confirms", async () => {
+    checkboxStub.resolves([Emulators.FIRESTORE]); // Simulate selecting at least one emulator
+    confirmStub.withArgs(sinon.match("Would you like to automatically save emulator data")).resolves(true);
+    inputStub.withArgs(sinon.match("What directory would you like to save your emulator data to?")).resolves("./my_emulator_data");
+    confirmStub.withArgs(sinon.match("Would you like to enable the Emulator UI?")).resolves(false); // Skip UI prompt
+    confirmStub.withArgs(sinon.match("Would you like to download the emulators now?")).resolves(false); // Skip download prompt
+
+    await doSetup(setup, config);
+
+    expect(setup.config.emulators.dataDir).to.equal("./my_emulator_data");
+    expect(confirmStub.calledWith(sinon.match("Would you like to automatically save emulator data"))).to.be.true;
+    expect(inputStub.calledWith(sinon.match("What directory would you like to save your emulator data to?"))).to.be.true;
+  });
+
+  it("should not ask for dataDir path if user declines data persistence", async () => {
+    checkboxStub.resolves([Emulators.FIRESTORE]);
+    confirmStub.withArgs(sinon.match("Would you like to automatically save emulator data")).resolves(false);
+    confirmStub.withArgs(sinon.match("Would you like to enable the Emulator UI?")).resolves(false);
+    confirmStub.withArgs(sinon.match("Would you like to download the emulators now?")).resolves(false);
+
+    await doSetup(setup, config);
+
+    expect(setup.config.emulators.dataDir).to.be.undefined;
+    expect(confirmStub.calledWith(sinon.match("Would you like to automatically save emulator data"))).to.be.true;
+    expect(inputStub.calledWith(sinon.match("What directory would you like to save your emulator data to?"))).to.be.false;
+  });
+
+   it("should not ask for dataDir if no emulators are selected", async () => {
+    checkboxStub.resolves([]); // No emulators selected
+    // No need to stub other confirms/inputs as the function should exit early or skip these.
+
+    await doSetup(setup, config);
+
+    expect(setup.config.emulators.dataDir).to.be.undefined;
+    expect(confirmStub.calledWith(sinon.match("Would you like to automatically save emulator data"))).to.be.false;
+    expect(inputStub.calledWith(sinon.match("What directory would you like to save your emulator data to?"))).to.be.false;
+  });
+});
diff --git a/src/init/features/emulators.ts b/src/init/features/emulators.ts
index f7ba12f12d2..4fb05c67470 100644
--- a/src/init/features/emulators.ts
+++ b/src/init/features/emulators.ts
@@ -66,6 +66,22 @@ export async function doSetup(setup: Setup, config: Config) {
     }
   }
 
+  // Prompt for global dataDir
+  if (selections.emulators.length > 0) {
+    const persistData = await confirm({
+      message: "Would you like to automatically save emulator data between runs?",
+      default: true, // Default to Yes
+    });
+
+    if (persistData) {
+      const dataDir = await input({
+        message: "What directory would you like to save your emulator data to?",
+        default: "./emulatorData",
+      });
+      setup.config.emulators.dataDir = dataDir;
+    }
+  }
+
   if (selections.emulators.length) {
     const uiDesc = Constants.description(Emulators.UI);
     if (setup.config.emulators.ui && setup.config.emulators.ui.enabled !== false) {