@snorreks/firestack 0.0.1

package/main.js

@@ -0,0 +1,1661 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { Command as Command9 } from "commander";
+
+// src/lib/commands/build.ts
+import { readdir, readFile, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { cwd, exit } from "node:process";
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/lib/utils/build_utils.ts
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { build } from "esbuild";
+
+// src/lib/utils/logger.ts
+import chalk from "chalk";
+var LogSeverityPriority = /* @__PURE__ */ ((LogSeverityPriority2) => {
+  LogSeverityPriority2[LogSeverityPriority2["silent"] = 0] = "silent";
+  LogSeverityPriority2[LogSeverityPriority2["debug"] = 1] = "debug";
+  LogSeverityPriority2[LogSeverityPriority2["info"] = 2] = "info";
+  LogSeverityPriority2[LogSeverityPriority2["warn"] = 4] = "warn";
+  LogSeverityPriority2[LogSeverityPriority2["error"] = 5] = "error";
+  return LogSeverityPriority2;
+})(LogSeverityPriority || {});
+var LoggerService = class {
+  currentLogSeverity = "info";
+  setLogSeverity(options) {
+    if (options.silent) {
+      this.currentLogSeverity = "silent";
+      return;
+    }
+    if (options.verbose) {
+      this.currentLogSeverity = "debug";
+      return;
+    }
+  }
+  write(entry, ...data) {
+    if (!this.currentLogSeverity) {
+      return;
+    }
+    const { logType, message, severity } = entry;
+    const currentLogSeverityPriority = this.toLogSeverityPriority(this.currentLogSeverity);
+    const entryLogSeverityPriority = this.toLogSeverityPriority(severity || "info");
+    if (currentLogSeverityPriority > entryLogSeverityPriority) {
+      return;
+    }
+    const log = console[logType || "log"];
+    if (typeof message !== "undefined") {
+      log(message, ...data);
+    } else {
+      log(...data);
+    }
+  }
+  debug(...args) {
+    this.write(
+      {
+        logType: "debug",
+        severity: "debug"
+      },
+      ...args
+    );
+  }
+  info(...args) {
+    this.write(
+      {
+        logType: "info",
+        severity: "info"
+      },
+      ...args
+    );
+  }
+  warn(...args) {
+    this.write(
+      {
+        logType: "warn",
+        severity: "warn"
+      },
+      chalk.yellow(args.join(" "))
+    );
+  }
+  error(...args) {
+    this.write(
+      {
+        logType: "error",
+        severity: "error"
+      },
+      chalk.red(args.join(" "))
+    );
+  }
+  log(...args) {
+    this.write(
+      {
+        logType: "log",
+        severity: "info"
+      },
+      ...args
+    );
+  }
+  toLogSeverityPriority(severity) {
+    return LogSeverityPriority[severity];
+  }
+};
+var LoggerFactory = class _LoggerFactory {
+  static logger = new LoggerService();
+  static getLogger() {
+    return _LoggerFactory.logger;
+  }
+};
+var logger = LoggerFactory.getLogger();
+
+// src/lib/utils/build_utils.ts
+async function buildFunction(options) {
+  const { inputFile, outputFile, minify, sourcemap } = options;
+  const outDir = dirname(outputFile);
+  await mkdir(outDir, { recursive: true });
+  const banner = {
+    js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);`
+  };
+  try {
+    await build({
+      entryPoints: [inputFile],
+      outfile: outputFile,
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      // external: ['firebase-functions', 'firebase-admin'],
+      minify,
+      sourcemap,
+      banner,
+      loader: {
+        ".ts": "ts",
+        ".tsx": "tsx"
+      }
+    });
+  } catch (error) {
+    logger.error("buildFunction", {
+      error,
+      options
+    });
+    throw error;
+  }
+}
+
+// src/lib/commands/build.ts
+function cwdDir() {
+  return cwd();
+}
+function exitCode(code) {
+  return exit(code);
+}
+async function readDir(path) {
+  const entries = await readdir(path, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    isDirectory: () => entry.isDirectory(),
+    isFile: () => entry.isFile()
+  }));
+}
+var buildCommand = new Command("build").description("Builds all functions using esbuild.").option("-o, --output-directory <outputDirectory>", "The output directory.", "dist").option("-c, --config <config>", "Path to the package.json config file.").option(
+  "--functionsDirectory <functionsDirectory>",
+  "The directory where the functions are located."
+).action(async (options) => {
+  console.log(chalk2.bold.green("Starting build with esbuild..."));
+  console.log("Options:", options);
+  const functionsDirectory = options.functionsDirectory || "src/controllers";
+  const functionsPath = join(cwdDir(), functionsDirectory);
+  const functionFiles = await findFunctions(functionsPath);
+  if (functionFiles.length === 0) {
+    console.log(chalk2.yellow("No functions found to build."));
+    return;
+  }
+  console.log(chalk2.bold.cyan(`Found ${functionFiles.length} functions to build.`));
+  for (const funcPath of functionFiles) {
+    const functionName = basename(funcPath).replace(/\.(ts|tsx|js)$/, "");
+    const functionOutputDir = join(cwdDir(), options.outputDirectory, functionName);
+    const outputFile = join(functionOutputDir, "src", "index.js");
+    const configPath = options.config ? join(cwdDir(), options.config) : void 0;
+    console.log(`Building function: ${chalk2.bold.yellow(functionName)}`);
+    console.log(`Output file: ${outputFile}`);
+    if (configPath) {
+      console.log(`Using config file: ${configPath}`);
+    }
+    try {
+      await buildFunction({
+        inputFile: funcPath,
+        outputFile,
+        configPath
+      });
+      console.log(chalk2.green(`Successfully built ${functionName}.`));
+    } catch (error) {
+      console.error(chalk2.red(`Failed to build ${functionName}:`));
+      console.error(error);
+      exitCode(1);
+    }
+  }
+  console.log(chalk2.bold.green("Build complete!"));
+});
+async function findFunctions(dir) {
+  const functions2 = [];
+  try {
+    const entries = await readDir(dir);
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        functions2.push(...await findFunctions(path));
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+        const name = entry.name;
+        if (name.endsWith(".test.ts") || name.endsWith(".spec.ts") || name.endsWith(".test.js") || name.endsWith(".spec.js") || name.endsWith("_test.ts") || name.endsWith("_test.js")) {
+          continue;
+        }
+        functions2.push(path);
+      }
+    }
+  } catch {
+  }
+  return functions2;
+}
+
+// src/lib/commands/delete.ts
+import { Command as Command3 } from "commander";
+
+// src/lib/node-shim.ts
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, watch } from "node:fs";
+import { mkdir as mkdirProm, readdir as readdir2, readFile as readFile2, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { cwd as cwd2, exit as exit2 } from "node:process";
+async function readTextFile(path) {
+  return readFile2(path, "utf-8");
+}
+async function writeTextFile(path, contents) {
+  const dir = dirname2(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  await writeFile3(path, contents, "utf-8");
+}
+async function mkdir3(path, options) {
+  await mkdirProm(path, { recursive: options?.recursive ?? false });
+}
+function cwdDir2() {
+  return cwd2();
+}
+function exitCode2(code) {
+  return exit2(code);
+}
+async function readDir2(path) {
+  const entries = await readdir2(path, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    isDirectory: () => entry.isDirectory(),
+    isFile: () => entry.isFile()
+  }));
+}
+async function remove(path, options) {
+  await rm(path, { recursive: options?.recursive ?? false, force: true });
+}
+var Command2 = class {
+  cmd;
+  args = [];
+  opts = {};
+  constructor(cmd, options) {
+    this.cmd = cmd;
+    if (options?.args) this.args = options.args;
+    if (options?.cwd) this.opts.cwd = options.cwd;
+    if (options?.env) this.opts.env = options.env;
+    if (options?.stdout) this.opts.stdout = options.stdout;
+    if (options?.stderr) this.opts.stderr = options.stderr;
+  }
+  async output() {
+    return new Promise((resolve) => {
+      const child = spawn(this.cmd, this.args, {
+        cwd: this.opts.cwd,
+        env: { ...process.env, ...this.opts.env }
+      });
+      let stdout = Buffer.alloc(0);
+      let stderr = Buffer.alloc(0);
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
+          stdout = Buffer.concat([stdout, Buffer.from(data)]);
+        });
+      }
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
+          stderr = Buffer.concat([stderr, Buffer.from(data)]);
+        });
+      }
+      child.on("close", (code) => {
+        resolve({ code: code ?? 0, stdout, stderr });
+      });
+    });
+  }
+  spawn() {
+    const child = spawn(this.cmd, this.args, {
+      cwd: this.opts.cwd,
+      env: { ...process.env, ...this.opts.env },
+      stdio: ["ignore", this.opts.stdout ?? "inherit", this.opts.stderr ?? "inherit"]
+    });
+    return {
+      status: new Promise((resolve) => {
+        child.on("close", (code) => {
+          resolve({ code: code ?? 0, success: code === 0 });
+        });
+      })
+    };
+  }
+};
+
+// src/lib/commands/delete/utils/delete_functions.ts
+import { execa } from "execa";
+async function deleteFunctions(options, functionNames) {
+  try {
+    await executeFirebaseFunctionsDelete(options, functionNames);
+  } catch (error) {
+    logger.error("deleteFunctions", error);
+    throw error;
+  }
+}
+async function executeFirebaseFunctionsDelete(options, functionNames) {
+  logger.info(`Deleting functions: ${functionNames.join(", ")}...`);
+  try {
+    await execa(
+      "firebase",
+      ["functions:delete", ...functionNames, "--project", options.projectId, "--force"],
+      {
+        stdio: "inherit"
+      }
+    );
+  } catch (error) {
+    logger.error("Failed to delete functions:");
+    logger.error(error.message);
+    exitCode2(1);
+  }
+}
+
+// src/lib/commands/delete/utils/read_functions.ts
+import { basename as basename2, join as join3 } from "node:path";
+import client from "firebase-tools";
+
+// src/lib/commands/deploy/utils/find_functions.ts
+import { join as join2 } from "node:path";
+async function findFunctions2(dir) {
+  const functions2 = [];
+  try {
+    const entries = await readDir2(dir);
+    for (const entry of entries) {
+      const path = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        functions2.push(...await findFunctions2(path));
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+        const name = entry.name;
+        if (name.endsWith(".test.ts") || name.endsWith(".spec.ts") || name.endsWith(".test.js") || name.endsWith(".spec.js") || name.endsWith("_test.ts") || name.endsWith("_test.js")) {
+          continue;
+        }
+        functions2.push(path);
+      }
+    }
+  } catch {
+  }
+  return functions2;
+}
+
+// src/lib/commands/delete/utils/read_functions.ts
+async function getLocalFunctionNames(options) {
+  try {
+    const functionsPath = join3(process.cwd(), options.functionsDirectory);
+    const localFunctionFiles = await findFunctions2(functionsPath);
+    const localFunctionNames = localFunctionFiles.map(
+      (file) => basename2(file).replace(/\.(ts|tsx|js)$/, "")
+    );
+    logger.debug("localFunctionNames", localFunctionNames);
+    return localFunctionNames;
+  } catch (error) {
+    logger.error("getLocalFunctionNames", error);
+    throw error;
+  }
+}
+async function getOnlineFunctionNames(options) {
+  try {
+    const onlineFunctions = await client.functions.list({
+      project: options.projectId
+    });
+    const onlineFunctionNames = onlineFunctions.map(
+      (functionData) => functionData.id
+    );
+    logger.debug("onlineFunctionNames", onlineFunctionNames);
+    return onlineFunctionNames;
+  } catch (error) {
+    logger.error("getOnlineFunctionNames", error);
+    throw error;
+  }
+}
+async function getUnusedFunctionNames(options) {
+  try {
+    const [localFunctionNames, onlineFunctionNames] = await Promise.all([
+      getLocalFunctionNames(options),
+      getOnlineFunctionNames(options)
+    ]);
+    const unusedFunctionNames = onlineFunctionNames.filter(
+      (onlineFunctionName) => !localFunctionNames.includes(onlineFunctionName)
+    );
+    return unusedFunctionNames;
+  } catch (error) {
+    logger.error("getUnusedFunctionNames", error);
+    throw error;
+  }
+}
+
+// src/lib/commands/deploy/utils/options.ts
+import { join as join4 } from "node:path";
+async function getOptions(cliOptions) {
+  const configPath = join4(cwdDir2(), "firestack.json");
+  let config = {};
+  try {
+    const configContent = await readTextFile(configPath);
+    config = JSON.parse(configContent);
+    logger.debug(`Using configuration from ${configPath}`);
+  } catch (e) {
+    const error = e;
+    if (error.code === "ENOENT") {
+      logger.debug("firestack.json not found, using command-line options.");
+    } else {
+      logger.error(`Failed to read firestack.json at ${configPath}: ${error.message}`);
+      exitCode2(1);
+    }
+  }
+  const options = {
+    ...cliOptions,
+    functionsDirectory: cliOptions.functionsDirectory || config.functionsDirectory || "src/controllers",
+    rulesDirectory: cliOptions.rulesDirectory || config.rulesDirectory || "src/rules",
+    scriptsDirectory: cliOptions.scriptsDirectory || config.scriptsDirectory || "scripts",
+    initScript: cliOptions.initScript || config.initScript || "init.ts",
+    region: cliOptions.region || config.region,
+    nodeVersion: cliOptions.nodeVersion || config.nodeVersion || "20",
+    projectId: cliOptions.projectId || config.flavors?.[cliOptions.flavor]
+  };
+  logger.setLogSeverity(options);
+  logger.debug("Starting deployment...");
+  logger.debug("Options:", options);
+  return options;
+}
+
+// src/lib/commands/delete.ts
+var deleteCommand = new Command3("delete").description("Deletes all unused Firebase functions.").option("--flavor <flavor>", "The flavor to use for deletion.", "development").option("--dry-run", "Show the deletion commands without executing them.").option("--verbose", "Whether to run the command with verbose logging.").option("--projectId <projectId>", "The Firebase project ID to delete from.").option("--all", "Delete all functions in the project.").action(async (cliOptions) => {
+  const options = await getOptions(cliOptions);
+  if (!options.projectId) {
+    logger.error(
+      "Project ID not found. Please provide it using --projectId option or in firestack.json."
+    );
+    exitCode2(1);
+  }
+  const functionsToDelete = cliOptions.all ? await getOnlineFunctionNames(options) : await getUnusedFunctionNames(options);
+  logger.info("Functions to delete:", functionsToDelete);
+  if (functionsToDelete.length > 0) {
+    if (cliOptions.dryRun) {
+      logger.info("Dry run: skipping deletion.");
+    } else {
+      await deleteFunctions(options, functionsToDelete);
+      logger.info("Deletion complete.");
+    }
+  } else {
+    logger.info("No unused functions found.");
+  }
+});
+
+// src/lib/commands/deploy/index.ts
+import { basename as basename4, join as join10 } from "node:path";
+import { cwd as cwd3, exit as exit3 } from "node:process";
+import { Command as Command4 } from "commander";
+
+// src/lib/utils/run-functions.ts
+var runFunctions = async (functions2, concurrency = 5) => {
+  const results = [];
+  let i = 0;
+  while (i < functions2.length) {
+    const chunk = functions2.slice(i, i + concurrency);
+    i += concurrency;
+    results.push(...await Promise.all(chunk.map((fn) => fn())));
+  }
+  return results;
+};
+
+// src/lib/commands/deploy/utils/environment.ts
+import { join as join5 } from "node:path";
+async function getEnvironment(flavor) {
+  const envPath = join5(cwdDir2(), `.env.${flavor}`);
+  try {
+    const envContent = await readTextFile(envPath);
+    return envContent.split("\n").reduce(
+      (acc, line) => {
+        const [key, ...rest] = line.split("=");
+        const value = rest.join("=");
+        if (key && value && !key.startsWith("FIREBASE_SERVICE_ACCOUNT")) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {}
+    );
+  } catch (e) {
+    const error = e;
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw e;
+  }
+}
+
+// src/lib/commands/deploy/utils/process_function.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync } from "node:fs";
+import { join as join9 } from "node:path";
+
+// src/lib/utils/checksum.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
+import { join as join6 } from "node:path";
+var algorithm = "md5";
+var encoding = "hex";
+var checksumsFolderName = ".checksums";
+var checksumsFolderPath = (options) => join6(options.outputDirectory, checksumsFolderName, options.flavor);
+var checkForChanges = async (deployFunction) => {
+  try {
+    const { environment, outputRoot } = deployFunction;
+    const newCode = readFileSync(join6(outputRoot, "src/index.js"), "utf-8");
+    const environmentString = environment ? Object.entries(environment).map(([key, value]) => `${key}=${value}`).join("") : "";
+    const cachedChecksum = deployFunction.checksum ?? await getCachedChecksum(deployFunction);
+    const newChecksum = generateChecksum(newCode + environmentString);
+    if (!deployFunction.force && cachedChecksum && cachedChecksum === newChecksum) {
+      console.log(
+        `%c${deployFunction.functionName} has not changed, skipping deployment`,
+        "color: green"
+      );
+      return void 0;
+    }
+    deployFunction.checksum = newChecksum;
+    return deployFunction;
+  } catch (error) {
+    console.warn(
+      `%cError checking for local changes with ${deployFunction.functionName}.`,
+      "color: yellow"
+    );
+    console.debug(error);
+    return deployFunction;
+  }
+};
+var generateChecksum = (code) => {
+  const hash = createHash(algorithm);
+  hash.update(code);
+  return hash.digest(encoding);
+};
+var getCachedChecksum = async ({
+  outputDirectory,
+  functionName,
+  flavor
+}) => {
+  try {
+    const checksumFileName = `${functionName}.${algorithm}`;
+    const checksumPath = join6(checksumsFolderPath({ outputDirectory, flavor }), checksumFileName);
+    if (existsSync2(checksumPath)) {
+      return readFileSync(checksumPath, "utf-8");
+    }
+    return void 0;
+  } catch (error) {
+    console.debug(error);
+    return;
+  }
+};
+var cacheChecksumLocal = async ({
+  outputDirectory,
+  checksum,
+  flavor,
+  functionName
+}) => {
+  try {
+    if (!checksum) {
+      return;
+    }
+    const checksumFileName = `${functionName}.${algorithm}`;
+    const folderPath = checksumsFolderPath({ outputDirectory, flavor });
+    mkdirSync2(folderPath, { recursive: true });
+    writeFileSync(join6(folderPath, checksumFileName), checksum);
+  } catch (error) {
+    console.debug(error);
+  }
+};
+
+// src/lib/utils/common.ts
+import { dirname as dirname3 } from "node:path";
+async function findProjectRoot() {
+  let current = cwdDir2();
+  while (true) {
+    const entries = await readDir2(current);
+    for (const entry of entries) {
+      if (entry.isFile() && (entry.name === "firestack.json" || entry.name === "package.json")) {
+        return current;
+      }
+    }
+    const parent = dirname3(current);
+    if (parent === current) {
+      throw new Error("Could not find project root. Make sure you are in a firestack project.");
+    }
+    current = parent;
+  }
+}
+
+// src/lib/utils/firebase_utils.ts
+function createFirebaseConfig(nodeVersion) {
+  const firebaseJsonContent = {
+    functions: {
+      source: "src",
+      runtime: `nodejs${nodeVersion}`
+    }
+  };
+  return JSON.stringify(firebaseJsonContent, null, 2);
+}
+function createPackageJson(nodeVersion) {
+  const packageJsonContent = {
+    type: "module",
+    main: "index.js",
+    engines: {
+      node: nodeVersion
+    }
+  };
+  return JSON.stringify(packageJsonContent, null, 2);
+}
+function toDotEnvironmentCode(environment) {
+  return Object.entries(environment).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+
+// src/lib/utils/function_naming.ts
+import { relative } from "node:path";
+function deriveFunctionName(funcPath, controllersPath) {
+  const relativePath = relative(controllersPath, funcPath);
+  const parts = relativePath.replace(/\\/g, "/").split("/");
+  const fileName = parts[parts.length - 1].replace(/\.(ts|tsx|js)$/, "");
+  const pathParts = parts.slice(1, -1);
+  const nameParts = pathParts.filter((part) => !part.startsWith("[")).concat(fileName);
+  return nameParts.join("_");
+}
+function extractDocumentPath(funcPath, controllersPath) {
+  const relativePath = relative(controllersPath, funcPath);
+  const parts = relativePath.replace(/\\/g, "/").split("/");
+  if (parts[0] !== "firestore") {
+    return void 0;
+  }
+  const pathParts = parts.slice(1, -1);
+  const documentPath = pathParts.map((part) => {
+    if (part.startsWith("[") && part.endsWith("]")) {
+      return `{${part.slice(1, -1)}}`;
+    }
+    return part;
+  }).join("/");
+  return documentPath || void 0;
+}
+function extractDatabaseRef(funcPath, controllersPath) {
+  const relativePath = relative(controllersPath, funcPath);
+  const parts = relativePath.replace(/\\/g, "/").split("/");
+  if (parts[0] !== "database") {
+    return void 0;
+  }
+  const pathParts = parts.slice(1, -1);
+  const refPath = `/${pathParts.map((part) => {
+    if (part.startsWith("[") && part.endsWith("]")) {
+      return `{${part.slice(1, -1)}}`;
+    }
+    return part;
+  }).join("/")}`;
+  return refPath;
+}
+
+// src/lib/utils/read-compiled-file.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+var getEnvironmentNeeded = async (outputRoot, environment) => {
+  try {
+    if (!environment) {
+      return;
+    }
+    const outputPath = join7(outputRoot, "src/index.js");
+    const code = readFileSync2(outputPath, "utf-8");
+    return Object.fromEntries(Object.entries(environment).filter(([key]) => code.includes(key)));
+  } catch (error) {
+    console.error("getEnvironmentKeysNeeded", error);
+    return;
+  }
+};
+
+// src/lib/commands/deploy/utils/create_deploy_index.ts
+import { join as join8, relative as relative2 } from "node:path";
+import {
+  createSourceFile,
+  forEachChild,
+  isCallExpression,
+  isExportAssignment,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isStringLiteral,
+  ScriptTarget,
+  SyntaxKind
+} from "typescript";
+
+// src/lib/constants/function-types.ts
+var firestoreFunctions = [
+  "onCreated",
+  "onUpdated",
+  "onDeleted",
+  "onWritten",
+  "onDocumentCreated",
+  "onDocumentUpdated",
+  "onDocumentDeleted",
+  "onDocumentWritten"
+];
+var databaseFunctions = [
+  "onValueCreated",
+  "onValueDeleted",
+  "onValueUpdated",
+  "onValueWritten"
+];
+var storageFunctions = [
+  "onObjectArchived",
+  "onObjectDeleted",
+  "onObjectFinalized",
+  "onObjectMetadataUpdated"
+];
+var authFunctions = [
+  "onAuthCreate",
+  "onAuthDelete",
+  "beforeAuthCreate",
+  "beforeAuthSignIn"
+];
+var schedulerFunctions = ["onSchedule"];
+var httpsFunctions = ["onCall", "onRequest"];
+var functions = [
+  ...authFunctions,
+  ...databaseFunctions,
+  ...firestoreFunctions,
+  ...storageFunctions,
+  ...schedulerFunctions,
+  ...httpsFunctions
+];
+
+// src/lib/commands/deploy/utils/create_deploy_index.ts
+async function createTemporaryIndexFunctionFile(buildFunctionData) {
+  logger.debug("Creating temporary index file", buildFunctionData);
+  const code = await toDeployIndexCode(buildFunctionData);
+  if (!code) {
+    return buildFunctionData.funcPath;
+  }
+  const temporaryFilePath = getTemporaryFilePath(
+    buildFunctionData.temporaryDirectory,
+    buildFunctionData.functionName
+  );
+  await writeTextFile(temporaryFilePath, code);
+  return temporaryFilePath;
+}
+var getTemporaryFilePath = (temporaryDirectory, functionName) => join8(temporaryDirectory, `${functionName}.ts`);
+async function toDeployIndexCode(buildFunctionData) {
+  const { functionName, funcPath, temporaryDirectory } = buildFunctionData;
+  const fileContent = await readTextFile(funcPath);
+  const sourceFile = createSourceFile(funcPath, fileContent, ScriptTarget.ESNext, true);
+  let deployFunction;
+  let options = {};
+  forEachChild(sourceFile, (node) => {
+    if (isExportAssignment(node) && isCallExpression(node.expression) && isIdentifier(node.expression.expression)) {
+      const escapedText = node.expression.expression.escapedText;
+      if (isDeployFunction(escapedText)) {
+        deployFunction = escapedText;
+        const optionsNode = node.expression.arguments[1];
+        if (optionsNode && isObjectLiteralExpression(optionsNode)) {
+          options = parseOptions(optionsNode);
+        }
+      }
+    }
+  });
+  if (!deployFunction) {
+    logger.debug(`No deploy function type found in ${funcPath}`);
+    return void 0;
+  }
+  const rootFunctionBuilder = toRootFunction(deployFunction);
+  const functionCodeType = toFunctionCodeType(deployFunction);
+  const importPath = `${relative2(temporaryDirectory, funcPath).replaceAll("\\", "/").replace(/\.(ts|js)$/, "")}.ts`;
+  logger.debug("Generated importPath:", importPath);
+  if (rootFunctionBuilder === "firestore") {
+    const documentPath = extractDocumentPath(funcPath, buildFunctionData.controllersPath);
+    if (documentPath) {
+      options.document = documentPath;
+    }
+  } else if (rootFunctionBuilder === "database") {
+    const refPath = extractDatabaseRef(funcPath, buildFunctionData.controllersPath);
+    if (refPath) {
+      options.ref = refPath;
+    }
+  }
+  const optionsCode = toOptionsCode(options);
+  const fileCode = `
+import { ${functionCodeType} } from 'firebase-functions/${rootFunctionBuilder}';
+import functionStart from '${importPath}';
+
+export const ${functionName} = ${functionCodeType}(${optionsCode}, functionStart);
+`;
+  return fileCode;
+}
+var isDeployFunction = (functionName) => {
+  return functions.includes(functionName);
+};
+var parseOptions = (optionsNode) => {
+  const options = {};
+  optionsNode.properties.forEach((prop) => {
+    if (isPropertyAssignment(prop) && prop.name) {
+      const key = prop.name.getText();
+      const value = getInitializerValue(prop.initializer);
+      if (value !== void 0) {
+        options[key] = value;
+      }
+    }
+  });
+  return options;
+};
+var getInitializerValue = (initializer) => {
+  if (isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  if (initializer.kind === SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (initializer.kind === SyntaxKind.NumericLiteral) {
+    return Number(initializer.getText());
+  }
+  if (isObjectLiteralExpression(initializer)) {
+    return parseOptions(initializer);
+  }
+  logger.warn(`Unsupported initializer kind: ${SyntaxKind[initializer.kind]}`);
+  return void 0;
+};
+var toRootFunction = (deployFunction) => {
+  switch (deployFunction) {
+    case "onCreated":
+    case "onUpdated":
+    case "onDeleted":
+    case "onWritten":
+    case "onDocumentCreated":
+    case "onDocumentUpdated":
+    case "onDocumentDeleted":
+    case "onDocumentWritten":
+      return "firestore";
+    case "onValueCreated":
+    case "onValueUpdated":
+    case "onValueDeleted":
+    case "onValueWritten":
+      return "database";
+    case "onCall":
+    case "onRequest":
+      return "https";
+    case "onSchedule":
+      return "scheduler";
+    case "onObjectArchived":
+    case "onObjectDeleted":
+    case "onObjectFinalized":
+    case "onObjectMetadataUpdated":
+      return "storage";
+    case "onAuthDelete":
+    case "onAuthCreate":
+    case "beforeAuthCreate":
+    case "beforeAuthSignIn":
+      return "auth";
+    default:
+      throw new Error("Invalid function type");
+  }
+};
+var toFunctionCodeType = (deployFunction) => {
+  switch (deployFunction) {
+    case "onCall":
+      return "onCall";
+    case "onRequest":
+      return "onRequest";
+    case "onCreated":
+    case "onDocumentCreated":
+      return "onDocumentCreated";
+    case "onDeleted":
+    case "onDocumentDeleted":
+      return "onDocumentDeleted";
+    case "onUpdated":
+    case "onDocumentUpdated":
+      return "onDocumentUpdated";
+    case "onWritten":
+    case "onDocumentWritten":
+      return "onDocumentWritten";
+    case "onSchedule":
+      return "onSchedule";
+    case "onObjectArchived":
+      return "onObjectArchived";
+    case "onObjectDeleted":
+      return "onObjectDeleted";
+    case "onObjectFinalized":
+      return "onObjectFinalized";
+    case "onObjectMetadataUpdated":
+      return "onObjectMetadataUpdated";
+    case "onValueCreated":
+      return "onValueCreated";
+    case "onValueDeleted":
+      return "onValueDeleted";
+    case "onValueUpdated":
+      return "onValueUpdated";
+    case "onValueWritten":
+      return "onValueWritten";
+    case "onAuthCreate":
+      return "onCreate";
+    case "onAuthDelete":
+      return "onDelete";
+    case "beforeAuthCreate":
+      return "beforeCreate";
+    case "beforeAuthSignIn":
+      return "beforeSignIn";
+    default:
+      throw new Error(`Unknown function type: ${deployFunction}`);
+  }
+};
+var toOptionsCode = (options) => {
+  let optionsCode = "{";
+  for (const [key, value] of Object.entries(options)) {
+    if (Array.isArray(value)) {
+      optionsCode += `'${key}': [${value.map((v) => `${typeof v === "string" ? `'${v}'` : v}`).join(",")}],`;
+      continue;
+    }
+    if (typeof value === "object") {
+      optionsCode += `'${key}': ${toOptionsCode(value)},`;
+      continue;
+    }
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      continue;
+    }
+    optionsCode += `'${key}': ${typeof value === "string" ? `'${value}'` : value},`;
+  }
+  optionsCode += "}";
+  return optionsCode;
+};
+
+// src/lib/commands/deploy/utils/process_function.ts
+async function processFunction(funcPath, options, environment, controllersPath) {
+  const functionName = deriveFunctionName(funcPath, controllersPath);
+  logger.info(`
+Processing function: ${functionName}`);
+  const outputDir = join9(cwdDir2(), "dist", functionName);
+  const temporaryDir = join9(cwdDir2(), "tmp", functionName);
+  await mkdir3(join9(outputDir, "src"), { recursive: true });
+  await mkdir3(temporaryDir, { recursive: true });
+  await writeTextFile(join9(outputDir, "firebase.json"), createFirebaseConfig(options.nodeVersion));
+  await writeTextFile(
+    join9(outputDir, "src", "package.json"),
+    createPackageJson(options.nodeVersion)
+  );
+  const outputFile = join9(outputDir, "src", "index.js");
+  logger.debug(`Building ${funcPath} to ${outputFile}...`);
+  try {
+    const inputFile = await createTemporaryIndexFunctionFile({
+      funcPath,
+      functionName,
+      temporaryDirectory: temporaryDir,
+      controllersPath
+    });
+    logger.debug("Temporary input file content:", await readTextFile(inputFile));
+    const projectRoot = await findProjectRoot();
+    await buildFunction({
+      inputFile,
+      outputFile,
+      configPath: join9(projectRoot, "package.json"),
+      minify: options.minify,
+      sourcemap: options.sourcemap
+    });
+    logger.debug(`Successfully built ${functionName}.`);
+  } catch (buildError) {
+    logger.error(`Failed to build ${functionName}: ${buildError.message}`);
+    return { functionName, status: "failed" };
+  } finally {
+    if (!options.debug) {
+      await remove(temporaryDir, { recursive: true });
+    }
+  }
+  const envNeeded = await getEnvironmentNeeded(outputDir, environment);
+  if (envNeeded) {
+    const envCode = toDotEnvironmentCode(envNeeded);
+    await writeTextFile(join9(outputDir, ".env"), envCode);
+  }
+  const deployFunctionData = await checkForChanges({
+    functionName,
+    outputRoot: outputDir,
+    flavor: options.flavor,
+    force: options.force,
+    outputDirectory: join9(cwdDir2(), "dist"),
+    environment: envNeeded
+  });
+  if (!deployFunctionData) {
+    return { functionName, status: "skipped" };
+  }
+  if (!options.dryRun) {
+    logger.debug("Copying shared dependencies...");
+    try {
+      const dependenciesDir = join9(cwdDir2(), "tmp", "dependencies");
+      const outputNodeModules = join9(outputDir, "node_modules");
+      await remove(outputNodeModules, { recursive: true });
+      if (existsSync3(join9(dependenciesDir, "node_modules"))) {
+        copyDirRecursive(join9(dependenciesDir, "node_modules"), outputNodeModules);
+      }
+      if (existsSync3(join9(dependenciesDir, "package.json"))) {
+        copyFileSync(join9(dependenciesDir, "package.json"), join9(outputDir, "src", "package.json"));
+      }
+    } catch (error) {
+      logger.error("Failed to copy shared dependencies:", error);
+      return { functionName, status: "failed" };
+    }
+    logger.debug("Installing dependencies...");
+    const npmInstall = new Command2("npm", {
+      args: ["install"],
+      cwd: join9(outputDir, "src")
+    });
+    const { code: npmCode, stderr: npmStderr } = await npmInstall.output();
+    if (npmCode !== 0) {
+      logger.error("Failed to install dependencies:");
+      logger.error(new TextDecoder().decode(npmStderr));
+      return { functionName, status: "failed" };
+    }
+    logger.debug("Dependencies installed successfully.");
+  }
+  const deployArgs = [
+    "deploy",
+    "--only",
+    `functions:${functionName}`,
+    "--project",
+    options.projectId
+  ];
+  if (options.force) {
+    deployArgs.push("--force");
+  }
+  logger.debug(`> firebase ${deployArgs.join(" ")}`);
+  if (!options.dryRun) {
+    try {
+      const command = new Command2("firebase", {
+        args: deployArgs,
+        cwd: outputDir
+      });
+      const { success } = await command.spawn().status;
+      if (success) {
+        logger.info(`Successfully deployed ${functionName}.`);
+        await cacheChecksumLocal(deployFunctionData);
+        return { functionName, status: "deployed" };
+      }
+      logger.error(`Failed to deploy ${functionName}.`);
+      return { functionName, status: "failed" };
+    } catch (deployError) {
+      logger.error(`Failed to deploy ${functionName}: ${deployError.message}`);
+      return { functionName, status: "failed" };
+    }
+  } else {
+    logger.info(`Dry run: skipped deployment of ${functionName}.`);
+    return { functionName, status: "dry-run" };
+  }
+}
+function copyDirRecursive(src, dest) {
+  mkdirSync3(dest, { recursive: true });
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join9(src, entry.name);
+    const destPath = join9(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/lib/commands/deploy/utils/retry_failed_functions.ts
+async function retryFailedFunctions(failedFunctions, functionFiles, options, environment, controllersPath) {
+  if (failedFunctions.length > 0 && options.retryAmount && options.retryAmount > 0) {
+    logger.warn(`
+Retrying ${failedFunctions.length} failed functions...`);
+    for (let i = 0; i < options.retryAmount; i++) {
+      logger.warn(`Retry attempt ${i + 1}/${options.retryAmount}`);
+      const retryFiles = functionFiles.filter((file) => {
+        const functionName = deriveFunctionName(file, controllersPath);
+        return failedFunctions.some((f) => f.functionName === functionName);
+      });
+      const retryResults = (await runFunctions(
+        retryFiles.map(
+          (path) => () => processFunction(path, options, environment, controllersPath)
+        ),
+        options.concurrency
+      )).filter((r) => r);
+      const newlyFailed = retryResults.filter((r) => r?.status === "failed");
+      if (newlyFailed.length === 0) {
+        logger.info("All failed functions deployed successfully on retry.");
+        return [];
+      }
+      failedFunctions = newlyFailed;
+    }
+  }
+  return failedFunctions;
+}
+
+// src/lib/commands/deploy/index.ts
+function cwdDir3() {
+  return cwd3();
+}
+function exitCode3(code) {
+  return exit3(code);
+}
+var deployCommand = new Command4("deploy").description("Builds and deploys all Firebase functions.").option("--flavor <flavor>", "The flavor to use for deployment.", "development").option("--dry-run", "Show the deployment commands without executing them.").option("--force", "Force deploy all functions, even if no files changed.").option("--verbose", "Whether to run the command with verbose logging.").option("--only <only>", "Only deploy the given function names separated by comma.").option("--region <region>", "The default region to deploy the functions to.").option("--concurrency <concurrency>", "The number of functions to deploy in parallel.", "5").option("--retryAmount <retryAmount>", "The amount of times to retry a failed deployment.", "0").option("--minify", "Will minify the functions.", true).option("--sourcemap", "Whether to generate sourcemaps.", true).option(
+  "--functionsDirectory <functionsDirectory>",
+  "The directory where the functions are located."
+).option("--projectId <projectId>", "The Firebase project ID to deploy to.").option("--node-version <nodeVersion>", "The Node.js version to use for the functions.").option("--debug", "Enable debug mode (keeps temporary files).").action(async (cliOptions) => {
+  const options = await getOptions(cliOptions);
+  if (!options.projectId) {
+    logger.error(
+      "Project ID not found. Please provide it using --projectId option or in firestack.json."
+    );
+    exitCode3(1);
+  }
+  const functionsPath = join10(cwdDir3(), options.functionsDirectory);
+  let functionFiles = await findFunctions2(functionsPath);
+  if (options.only) {
+    const onlyFunctions = options.only.split(",").map((f) => f.trim());
+    functionFiles = functionFiles.filter((file) => {
+      const functionName = basename4(file).replace(/\.(ts|tsx|js)$/, "");
+      return onlyFunctions.includes(functionName);
+    });
+  }
+  if (functionFiles.length === 0) {
+    logger.warn("No functions found to deploy.");
+    return;
+  }
+  logger.info(`Found ${functionFiles.length} functions to deploy.`);
+  const environment = await getEnvironment(options.flavor);
+  const results = (await runFunctions(
+    functionFiles.map(
+      (path) => () => processFunction(path, options, environment, functionsPath)
+    ),
+    options.concurrency
+  )).filter((r) => r);
+  let failedFunctions = results.filter((r) => r?.status === "failed");
+  failedFunctions = await retryFailedFunctions(
+    failedFunctions,
+    functionFiles,
+    options,
+    environment,
+    functionsPath
+  );
+  if (failedFunctions.length > 0) {
+    logger.error(`
+Deployment failed for ${failedFunctions.length} functions.`);
+    exitCode3(1);
+  }
+  logger.info("\nDeployment process complete!");
+});
+
+// src/lib/commands/emulate.ts
+import { existsSync as existsSync4, watch as watch2 } from "node:fs";
+import { mkdir as mkdir4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename5, join as join11, relative as relative3 } from "node:path";
+import { Command as Command5 } from "commander";
+import { execa as execa2 } from "execa";
+async function runInitScript(scriptsDirectory, initScript, projectId) {
+  const initScriptPath = join11(process.cwd(), scriptsDirectory, initScript);
+  if (!existsSync4(initScriptPath)) {
+    logger.info(`Init script not found at ${initScriptPath}, skipping.`);
+    return;
+  }
+  logger.info(`Running init script: ${initScript}`);
+  try {
+    await execa2("bun", ["run", initScriptPath], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        FIREBASE_PROJECT_ID: projectId,
+        GCLOUD_PROJECT: projectId
+      },
+      stdio: "inherit"
+    });
+    logger.info("Init script completed successfully.");
+  } catch (error) {
+    logger.error(`Failed to run init script: ${error.message}`);
+    throw error;
+  }
+}
+async function buildEmulatorFunctions(functionFiles, outputDir, options, controllersPath) {
+  const projectRoot = await findProjectRoot();
+  const tempDir = join11(process.cwd(), "tmp", "emulator");
+  await mkdir4(tempDir, { recursive: true });
+  await mkdir4(join11(outputDir, "src"), { recursive: true });
+  const exports = [];
+  for (const funcFile of functionFiles) {
+    const funcName = deriveFunctionName(funcFile, controllersPath);
+    const generatedFile = await createTemporaryIndexFunctionFile({
+      funcPath: funcFile,
+      functionName: funcName,
+      temporaryDirectory: tempDir,
+      controllersPath
+    });
+    if (generatedFile !== funcFile) {
+      const relativePath = relative3(tempDir, generatedFile).replace(/\\/g, "/");
+      const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+      exports.push(`export * from '${importPath}';`);
+    }
+  }
+  const combinedIndexContent = `${exports.join("\n")}
+`;
+  const tempIndexPath = join11(tempDir, "index.ts");
+  await writeFile4(tempIndexPath, combinedIndexContent);
+  logger.debug("Generated combined index file:", combinedIndexContent);
+  await buildFunction({
+    inputFile: tempIndexPath,
+    outputFile: join11(outputDir, "src", "index.js"),
+    configPath: join11(projectRoot, "package.json"),
+    minify: options.minify,
+    sourcemap: options.sourcemap
+  });
+  const packageJson = {
+    name: "functions",
+    type: "module",
+    main: "index.js",
+    engines: { node: `${options.nodeVersion || "20"}` }
+  };
+  await writeFile4(join11(outputDir, "src", "package.json"), JSON.stringify(packageJson, null, 2));
+  logger.info("Installing dependencies...");
+  try {
+    await execa2("npm", ["install"], {
+      cwd: join11(outputDir, "src"),
+      stdio: "inherit"
+    });
+  } catch (error) {
+    throw new Error("Failed to install dependencies");
+  }
+  logger.info("Dependencies installed.");
+  if (!options.debug) {
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function generateFirebaseJson(outputDir, options) {
+  const firebaseConfig = {
+    functions: [
+      {
+        source: "src",
+        codebase: "default",
+        runtime: `nodejs${options.nodeVersion || "20"}`
+      }
+    ],
+    emulators: {
+      functions: { port: 5001 },
+      firestore: { port: 8080 },
+      ui: { enabled: true, port: 4e3 },
+      singleProjectMode: true
+    }
+  };
+  if (options.firestoreRules && existsSync4(options.firestoreRules)) {
+    firebaseConfig.firestore = {
+      rules: options.firestoreRules
+    };
+  }
+  if (options.storageRules && existsSync4(options.storageRules)) {
+    firebaseConfig.storage = {
+      rules: options.storageRules
+    };
+  }
+  await writeFile4(join11(outputDir, "firebase.json"), JSON.stringify(firebaseConfig, null, 2));
+}
+async function watchAndRebuild(functionsPath, functionFiles, outputDir, options, controllersPath) {
+  logger.info("Watching for file changes...");
+  const watcher = watch2(functionsPath, { recursive: true });
+  watcher.on("change", async (_eventType, filename) => {
+    if (filename && typeof filename === "string" && (filename.endsWith(".ts") || filename.endsWith(".tsx"))) {
+      logger.info(`File changed: ${basename5(filename)}, rebuilding...`);
+      try {
+        await buildEmulatorFunctions(functionFiles, outputDir, options, controllersPath);
+        logger.info("Rebuild complete.");
+      } catch (error) {
+        logger.error(`Rebuild failed: ${error.message}`);
+      }
+    }
+  });
+}
+var emulateCommand = new Command5("emulate").description("Starts the Firebase emulator with live reload.").option("--flavor <flavor>", "The flavor to use for emulation.", "development").option("--verbose", "Whether to run the command with verbose logging.").option("--debug", "Enable debug mode (keeps temporary files).").option("--projectId <projectId>", "The Firebase project ID to emulate.").option(
+  "--only <only>",
+  'Only start the emulator for the given services (e.g., "functions,firestore").',
+  "functions,firestore"
+).option(
+  "--firestoreRules <firestoreRules>",
+  "Path to the Firestore rules file.",
+  "firestore.rules"
+).option("--storageRules <storageRules>", "Path to the Storage rules file.", "storage.rules").option("--watch", "Enable file watching for live reload.", true).option("--no-watch", "Disable file watching.").option("--init", "Run init script before starting emulators.", true).option("--no-init", "Skip running init script.").option("--minify", "Will minify the functions.", false).option("--no-minify", "Do not minify the functions.").option("--sourcemap", "Whether to generate sourcemaps.", true).option("--no-sourcemap", "Do not generate sourcemaps.").option(
+  "--functionsDirectory <functionsDirectory>",
+  "The directory where the functions are located."
+).option("--node-version <nodeVersion>", "The Node.js version to use for the functions.").action(async (cliOptions) => {
+  const options = await getOptions(cliOptions);
+  if (!options.projectId) {
+    logger.error(
+      "Project ID not found. Please provide it using --projectId option or in firestack.json."
+    );
+    process.exit(1);
+  }
+  if (cliOptions.init !== false) {
+    try {
+      await runInitScript(
+        options.scriptsDirectory || "scripts",
+        options.initScript || "init.ts",
+        options.projectId
+      );
+    } catch (error) {
+      logger.error("Failed to run init script, continuing without initialization...");
+    }
+  }
+  const functionsPath = join11(process.cwd(), options.functionsDirectory);
+  const functionFiles = await findFunctions2(functionsPath);
+  if (functionFiles.length === 0) {
+    logger.warn("No functions found to emulate.");
+    return;
+  }
+  logger.info(`Found ${functionFiles.length} functions to build.`);
+  const outputDir = join11(process.cwd(), "dist", "emulator");
+  await mkdir4(outputDir, { recursive: true });
+  logger.info("Building functions for emulator...");
+  await buildEmulatorFunctions(functionFiles, outputDir, options, functionsPath);
+  logger.info("Build complete.");
+  await generateFirebaseJson(outputDir, options);
+  const commandArgs = ["emulators:start", "--project", options.projectId];
+  if (cliOptions.only) {
+    commandArgs.push("--only", cliOptions.only);
+  }
+  logger.info("Starting Firebase emulator...");
+  logger.debug(`> firebase ${commandArgs.join(" ")}`);
+  const emulatorProcess = execa2("firebase", commandArgs, {
+    cwd: outputDir,
+    stdio: "inherit"
+  });
+  if (cliOptions.watch) {
+    watchAndRebuild(functionsPath, functionFiles, outputDir, options, functionsPath);
+  }
+  await emulatorProcess;
+});
+
+// src/lib/commands/logs.ts
+import { Command as Command6 } from "commander";
+import { execa as execa3 } from "execa";
+var logsCommand = new Command6("logs").description("View logs from Firebase Cloud Functions.").option("--flavor <flavor>", "The flavor to use for logs.", "development").option("--verbose", "Whether to run the command with verbose logging.").option("--projectId <projectId>", "The Firebase project ID.").option("--only <only>", "Only show logs for specific function(s).").option("-n, --lines <lines>", "Number of log lines to fetch.", "50").option("--since <since>", 'Only show logs after this time (e.g., "1h", "30m").').option("--open", "Open logs in web browser.").action(async (cliOptions) => {
+  const options = await getOptions(cliOptions);
+  if (!options.projectId) {
+    logger.error(
+      "Project ID not found. Please provide it using --projectId option or in firestack.json."
+    );
+    process.exit(1);
+  }
+  const commandArgs = ["functions:log", "--project", options.projectId];
+  if (cliOptions.only) {
+    commandArgs.push("--only", cliOptions.only);
+  }
+  if (cliOptions.lines) {
+    commandArgs.push("--lines", cliOptions.lines);
+  }
+  if (cliOptions.since) {
+    commandArgs.push("--since", cliOptions.since);
+  }
+  if (cliOptions.open) {
+    commandArgs.push("--open");
+  }
+  logger.info(`Fetching logs for project: ${options.projectId}`);
+  logger.debug(`> firebase ${commandArgs.join(" ")}`);
+  await execa3("firebase", commandArgs, {
+    stdio: "inherit"
+  });
+});
+
+// src/lib/commands/rules.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join13 } from "node:path";
+import { Command as Command7 } from "commander";
+import { execa as execa4 } from "execa";
+
+// src/lib/commands/rules/utils/rule_files.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+async function findRuleFiles(rulesDirectory) {
+  const rules = [];
+  const rulesPath = join12(cwdDir2(), rulesDirectory);
+  try {
+    const entries = await readdir3(rulesPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const name = entry.name.toLowerCase();
+        if (name.startsWith("firestore.") && name.endsWith(".rules")) {
+          rules.push({
+            name: entry.name,
+            type: "firestore",
+            path: join12(rulesPath, entry.name)
+          });
+        } else if (name.startsWith("storage.") && name.endsWith(".rules")) {
+          rules.push({
+            name: entry.name,
+            type: "storage",
+            path: join12(rulesPath, entry.name)
+          });
+        } else if (name === "firestore.indexes.json") {
+          rules.push({
+            name: entry.name,
+            type: "firestoreIndexes",
+            path: join12(rulesPath, entry.name)
+          });
+        }
+      }
+    }
+  } catch {
+    logger.debug(`Rules directory ${rulesPath} not found`);
+  }
+  return rules;
+}
+
+// src/lib/commands/rules.ts
+var rulesCommand = new Command7("rules").description("Deploys Firestore, Storage rules, and indexes.").option("--flavor <flavor>", "The flavor to use for deployment.", "development").option("--verbose", "Whether to run the command with verbose logging.").option("--projectId <projectId>", "The Firebase project ID to deploy to.").option("--only <only>", 'Only deploy the specified components (e.g., "firestore,storage").').action(async (cliOptions) => {
+  const options = await getOptions(cliOptions);
+  if (!options.projectId) {
+    logger.error(
+      "Project ID not found. Please provide it using --projectId option or in firestack.json."
+    );
+    exitCode2(1);
+  }
+  const rulesDir = join13(cwdDir2(), options.rulesDirectory || "src/rules");
+  const ruleFiles = await findRuleFiles(options.rulesDirectory || "src/rules");
+  if (ruleFiles.length === 0) {
+    logger.warn("No rule or index files found to deploy.");
+    return;
+  }
+  logger.info(`Found ${ruleFiles.length} rule/index file(s) to deploy.`);
+  const tempDir = join13(cwdDir2(), "dist", "rules-deploy");
+  await mkdir3(join13(tempDir), { recursive: true });
+  const firebaseConfig = {};
+  for (const rule of ruleFiles) {
+    if (rule.type === "firestore") {
+      firebaseConfig.firestore = { rules: rule.name };
+    } else if (rule.type === "storage") {
+      firebaseConfig.storage = { rules: rule.name };
+    } else if (rule.type === "firestoreIndexes") {
+      firebaseConfig.firestore = {
+        ...firebaseConfig.firestore,
+        indexes: rule.name
+      };
+    }
+  }
+  const hasFirestore = ruleFiles.some(
+    (r) => r.type === "firestore" || r.type === "firestoreIndexes"
+  );
+  const hasStorage = ruleFiles.some((r) => r.type === "storage");
+  if (!hasFirestore && !hasStorage) {
+    logger.warn("No firestore or storage rules found to deploy.");
+    return;
+  }
+  writeFileSync2(join13(tempDir, "firebase.json"), JSON.stringify(firebaseConfig, null, 2));
+  for (const rule of ruleFiles) {
+    const sourcePath = join13(cwdDir2(), options.rulesDirectory || "src/rules", rule.name);
+    const destPath = join13(tempDir, rule.name);
+    if (existsSync5(sourcePath)) {
+      copyFileSync2(sourcePath, destPath);
+      logger.debug(`Copied ${rule.name} to ${tempDir}`);
+    }
+  }
+  const deployTargets = [];
+  if (hasFirestore) deployTargets.push("firestore");
+  if (hasStorage) deployTargets.push("storage");
+  const commandArgs = [
+    "deploy",
+    "--only",
+    deployTargets.join(","),
+    "--project",
+    options.projectId
+  ];
+  logger.info(`Deploying: ${deployTargets.join(", ")}`);
+  logger.debug(`> firebase ${commandArgs.join(" ")}`);
+  try {
+    await execa4("firebase", commandArgs, {
+      cwd: tempDir,
+      stdio: "inherit"
+    });
+    logger.info("Rules and indexes deployed successfully.");
+  } catch {
+    logger.error("Failed to deploy rules.");
+    exitCode2(1);
+  }
+});
+
+// src/lib/commands/scripts.ts
+import { join as join15 } from "node:path";
+import { Command as Command8 } from "commander";
+import { execa as execa5 } from "execa";
+import prompts from "prompts";
+
+// src/lib/utils/env.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+import { join as join14 } from "node:path";
+async function getScriptEnvironment(flavor) {
+  const envPath = join14(process.cwd(), `.env.${flavor}`);
+  try {
+    if (!existsSync6(envPath)) {
+      logger.debug(`.env.${flavor} file not found, continuing without it.`);
+      return {};
+    }
+    const envContent = readFileSync4(envPath, "utf-8");
+    const env = {};
+    let currentKey = "";
+    let currentValue = "";
+    for (const line of envContent.split("\n")) {
+      const match = line.match(/^([A-Za-z0-9_]+)=(.*)$/);
+      if (match) {
+        if (currentKey) {
+          env[currentKey] = currentValue;
+        }
+        currentKey = match[1];
+        currentValue = match[2];
+      } else {
+        currentValue += `
+${line}`;
+      }
+    }
+    if (currentKey) {
+      env[currentKey] = currentValue;
+    }
+    return env;
+  } catch (e) {
+    const error = e;
+    if (error.code === "ENOENT") {
+      logger.warn(`No .env.${flavor} file found, continuing without it.`);
+      return {};
+    }
+    throw e;
+  }
+}
+
+// src/lib/commands/scripts.ts
+async function getOptions2(cliOptions) {
+  const configPath = join15(cwdDir2(), "firestack.json");
+  let config = {};
+  try {
+    const configContent = await readTextFile(configPath);
+    config = JSON.parse(configContent);
+    logger.debug(`Using configuration from ${configPath}`);
+  } catch (e) {
+    const error = e;
+    if (error.code === "ENOENT") {
+      logger.debug("firestack.json not found, using command-line options.");
+    } else {
+      logger.error(`Failed to read firestack.json at ${configPath}: ${error.message}`);
+      exitCode2(1);
+    }
+  }
+  const options = {
+    ...cliOptions,
+    scriptsDirectory: cliOptions.scriptsDirectory || config.scriptsDirectory || "scripts"
+  };
+  logger.setLogSeverity(cliOptions);
+  logger.debug("Starting script command...");
+  logger.debug("Options:", options);
+  logger.debug("Current working directory:", cwdDir2());
+  logger.debug("Scripts directory:", options.scriptsDirectory);
+  return options;
+}
+async function findScripts(dir) {
+  const scripts = [];
+  try {
+    const entries = await readDir2(dir);
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".ts") && entry.name !== "init.ts") {
+        scripts.push(entry.name.replace(".ts", ""));
+      }
+    }
+  } catch {
+    logger.debug(`Scripts directory ${dir} not found`);
+  }
+  return scripts;
+}
+async function runScript(scriptName, options, projectRoot) {
+  const scriptsPath = join15(cwdDir2(), options.scriptsDirectory);
+  const scriptPath = join15(scriptsPath, `${scriptName}.ts`);
+  const packageJsonPath = join15(projectRoot, "package.json");
+  logger.debug("Script details:");
+  logger.debug("  scriptsPath:", scriptsPath);
+  logger.debug("  scriptPath:", scriptPath);
+  logger.debug("  packageJsonPath:", packageJsonPath);
+  const env = await getScriptEnvironment(options.flavor);
+  logger.debug(`Running command: bun run "${scriptPath}"`);
+  try {
+    await execa5("bun", ["run", scriptPath], {
+      cwd: cwdDir2(),
+      env: { ...process.env, ...env },
+      stdio: "inherit"
+    });
+    logger.info("\n\u2705 Script finished successfully!");
+  } catch (error) {
+    const err = error;
+    logger.error(`
+\u274C Error running script. Exit code: ${err.exitCode ?? "unknown"}`);
+    if (err.cause) {
+      logger.error(`Cause: ${err.cause.message}`);
+    }
+    exitCode2(err.exitCode ?? 1);
+  }
+}
+var scriptsCommand = new Command8("scripts").description("Run a script from the scripts directory.").option("--flavor <flavor>", "The flavor to use.", "development").option("--verbose", "Enable verbose logging.").option("--silent", "Disable logging.").argument("[scriptName]", "The name of the script to run.").action(async (scriptName, cliOptions) => {
+  const options = await getOptions2(cliOptions);
+  const scriptsPath = join15(cwdDir2(), options.scriptsDirectory);
+  let selectedScriptName;
+  if (scriptName) {
+    selectedScriptName = scriptName;
+  } else {
+    const scriptFiles = await findScripts(scriptsPath);
+    if (scriptFiles.length === 0) {
+      logger.warn("No scripts found.");
+      return;
+    }
+    if (scriptFiles.length === 1) {
+      selectedScriptName = scriptFiles[0];
+      logger.info(`Running single script: ${selectedScriptName}`);
+    } else {
+      const response = await prompts({
+        type: "select",
+        name: "script",
+        message: "Please select a script to run:",
+        choices: scriptFiles.map((script) => ({ title: script, value: script }))
+      });
+      if (!response.script) {
+        logger.warn("No script selected. Exiting.");
+        return;
+      }
+      selectedScriptName = response.script;
+    }
+  }
+  const projectRoot = await findProjectRoot();
+  await runScript(selectedScriptName, options, projectRoot);
+});
+
+// src/main.ts
+var program = new Command9();
+program.name("firestack").version("1.0.0").description("CLI for building and deploying Firebase Cloud Functions.");
+program.addCommand(buildCommand);
+program.addCommand(deployCommand);
+program.addCommand(scriptsCommand);
+program.addCommand(deleteCommand);
+program.addCommand(emulateCommand);
+program.addCommand(rulesCommand);
+program.addCommand(logsCommand);
+program.parse(process.argv);
+/**
+ * @file This file contains a function for running multiple functions in parallel.
+ * @license MIT
+ */
+/**
+ * @file Utilities for deriving function names and document paths from file paths.
+ * @license MIT
+ */