firevault 0.1.1-beta.3 → 0.2.0-beta.1

package/dist/commands/init.js

@@ -1,7 +1,8 @@
 import { Command } from "commander";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { appendFileSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import path from "node:path";
 import { GitError, hasWorkingTreeChanges, initGitRepository, isInsideGitRepository, } from "../git/git.js";
 import { detectFirebaseProjectCandidates, uniqueProjectIds, } from "../init/detectFirebaseProject.js";
 import { detectServiceAccountPaths } from "../init/detectServiceAccount.js";
@@ -12,6 +13,8 @@ const defaultConfig = {
     outputDir: "firestore-backups",
     collections: ["users"],
 };
+const workspaceDirName = ".firevault";
+const configFileName = "config.json";
 function validateConfig(config) {
     if (config.projectId.trim() === "") {
         throw new Error("Firebase project ID is required.");
@@ -49,13 +52,13 @@ function printServiceAccountGuidance(projectId, serviceAccountPath) {
     console.log(serviceAccountPath);
     console.log("");
 }
-function printMissingServiceAccountInfo(serviceAccountPath) {
+function printMissingServiceAccountInfo(serviceAccountPath, serviceAccountDisplayPath) {
     if (existsSync(serviceAccountPath)) {
         return;
     }
-    console.log(`Service account file does not exist yet: ${serviceAccountPath}`);
+    console.log(`Service account file does not exist yet: ${serviceAccountDisplayPath}`);
     console.log("That is expected before downloading the Firebase Admin SDK key.");
-    console.log(`Save the downloaded JSON key at: ${serviceAccountPath}`);
+    console.log(`Save the downloaded JSON key at: ${serviceAccountDisplayPath}`);
     console.log("");
 }
 function gitignorePathFor(filePath) {
@@ -133,9 +136,9 @@ function parseSelectedCollections(inputValue, detectedCollections) {
     }
     return [...new Set(selectedCollections)];
 }
-async function promptForCollectionListing(rl, projectId, serviceAccountPath) {
+async function promptForCollectionListing(rl, projectId, serviceAccountPath, serviceAccountDisplayPath) {
     if (!existsSync(serviceAccountPath)) {
-        console.log(`Service account file is not present, so collection detection is skipped: ${serviceAccountPath}`);
+        console.log(`Service account file is not present, so collection detection is skipped: ${serviceAccountDisplayPath}`);
         console.log("");
         return undefined;
     }
@@ -175,9 +178,9 @@ async function promptForCollectionListing(rl, projectId, serviceAccountPath) {
     }
     return parseSelectedCollections(selected, detectedCollections);
 }
-async function promptForConfig(options, rl) {
+async function promptForConfig(options, workspaceRoot, rl) {
     const projectCandidates = detectFirebaseProjectCandidates();
-    const serviceAccountPaths = detectServiceAccountPaths();
+    const serviceAccountPaths = detectServiceAccountPaths(process.cwd(), workspaceRoot);
     if (options.yes) {
         return {
             ...defaultConfig,
@@ -189,11 +192,13 @@ async function promptForConfig(options, rl) {
     }
     const projectId = await promptForProjectId(rl, projectCandidates);
     if (projectId !== "") {
-        printServiceAccountGuidance(projectId, defaultConfig.serviceAccountPath);
+        printServiceAccountGuidance(projectId, path.join(workspaceDirName, defaultConfig.serviceAccountPath.replace(/^\.\//, "")));
     }
     const serviceAccountPath = await promptForServiceAccountPath(rl, serviceAccountPaths);
     const outputDir = (await rl.question(`Output directory (${defaultConfig.outputDir}): `)).trim() || defaultConfig.outputDir;
-    const detectedCollections = await promptForCollectionListing(rl, projectId, serviceAccountPath);
+    const serviceAccountAbsolutePath = path.resolve(workspaceRoot, serviceAccountPath);
+    const serviceAccountDisplayPath = path.relative(process.cwd(), serviceAccountAbsolutePath);
+    const detectedCollections = await promptForCollectionListing(rl, projectId, serviceAccountAbsolutePath, serviceAccountDisplayPath);
     const collectionsInput = detectedCollections
         ? detectedCollections.join(",")
         : (await rl.question("Collections, comma-separated: ")).trim();
@@ -211,13 +216,12 @@ async function promptForGitInit(options, rl) {
     if (!rl) {
         throw new Error("Prompt interface is required for interactive init.");
     }
-    const answer = (await rl.question("This directory is not a Git repository. Run git init? (Y/n): "))
+    const answer = (await rl.question("Initialize Git inside .firevault? (Y/n): "))
         .trim()
         .toLowerCase();
     return answer === "" || answer === "y" || answer === "yes";
 }
-function ensureGitignoreEntries(entries) {
-    const gitignorePath = ".gitignore";
+function ensureGitignoreEntries(gitignorePath, entries) {
     const existing = existsSync(gitignorePath)
         ? readFileSync(gitignorePath, "utf-8")
         : "";
@@ -236,45 +240,61 @@ export async function runInit(options) {
     console.log("Firevault");
     console.log("Undo button for Firestore.");
     console.log("");
-    const configPath = "firevault.config.json";
-    const alreadyInGitRepository = isInsideGitRepository();
+    const appRoot = process.cwd();
+    const workspaceRoot = path.join(appRoot, workspaceDirName);
+    const configPath = path.join(workspaceRoot, configFileName);
+    const parentIsGitRepository = isInsideGitRepository(appRoot);
+    const workspaceIsGitRepository = isInsideGitRepository(workspaceRoot);
     const rl = options.yes ? undefined : createInterface({ input, output });
     try {
-        if (alreadyInGitRepository && hasWorkingTreeChanges() && !options.force) {
+        if (parentIsGitRepository && hasWorkingTreeChanges(appRoot) && !options.force) {
             throw new Error("Git working tree has changes. Commit, stash, or rerun with --force before init writes files.");
         }
         if (existsSync(configPath) && !options.force) {
-            throw new Error("firevault.config.json already exists. Rerun with --force to overwrite it.");
+            throw new Error(".firevault/config.json already exists. Rerun with --force to overwrite it.");
         }
-        const shouldInitGit = alreadyInGitRepository
+        const shouldInitGit = workspaceIsGitRepository
             ? false
             : await promptForGitInit(options, rl);
-        const config = await promptForConfig(options, rl);
+        const config = await promptForConfig(options, workspaceRoot, rl);
         config.collections = config.collections.map((collection) => collection.trim());
         validateConfig(config);
+        const serviceAccountAbsolutePath = path.resolve(workspaceRoot, config.serviceAccountPath);
+        const serviceAccountDisplayPath = path.relative(appRoot, serviceAccountAbsolutePath);
         if (options.yes) {
-            printServiceAccountGuidance(config.projectId, config.serviceAccountPath);
+            printServiceAccountGuidance(config.projectId, serviceAccountDisplayPath);
         }
-        printMissingServiceAccountInfo(config.serviceAccountPath);
+        printMissingServiceAccountInfo(serviceAccountAbsolutePath, serviceAccountDisplayPath);
+        mkdirSync(workspaceRoot, { recursive: true });
         if (shouldInitGit) {
-            initGitRepository();
-            console.log("Initialized Git repository.");
+            initGitRepository(workspaceRoot);
+            console.log("Initialized Git repository in .firevault.");
         }
         if (existsSync(configPath) && options.force) {
-            console.log("Warning: overwriting existing firevault.config.json.");
+            console.log("Warning: overwriting existing .firevault/config.json.");
         }
         writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
-        ensureGitignoreEntries([
-            "serviceAccountKey.json",
+        ensureGitignoreEntries(path.join(workspaceRoot, ".gitignore"), [
             gitignorePathFor(config.serviceAccountPath),
-            "firestore-backups/",
             "firestore-debug.log",
+            ".env",
+            ".env.*",
         ]);
-        console.log("Created firevault.config.json.");
-        console.log("Updated .gitignore safety entries.");
+        if (parentIsGitRepository) {
+            const parentIgnoreEntries = [".firevault/"];
+            const serviceAccountInAppRepo = path.relative(appRoot, serviceAccountAbsolutePath);
+            if (!serviceAccountInAppRepo.startsWith("..") &&
+                !gitignorePathFor(serviceAccountInAppRepo).startsWith(".firevault/")) {
+                parentIgnoreEntries.push(gitignorePathFor(serviceAccountInAppRepo));
+            }
+            ensureGitignoreEntries(path.join(appRoot, ".gitignore"), parentIgnoreEntries);
+            console.log("Updated parent .gitignore safety entries.");
+        }
+        console.log("Created .firevault/config.json.");
+        console.log("Updated .firevault/.gitignore safety entries.");
         console.log("");
         console.log("Next steps:");
-        console.log(`1. Save your service account key at ${config.serviceAccountPath}`);
+        console.log(`1. Save your service account key at ${serviceAccountDisplayPath}`);
         console.log("2. Run `firevault snapshot`");
         console.log("3. Run `firevault changes`");
         console.log("4. Run `firevault restore-preview <path> --from <commit>` before a real restore");

package/dist/commands/restoreFirestore.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { Command } from "commander";
-import { ConfigError, loadConfig } from "../config/loadConfig.js";
+import { ConfigError, loadConfig, resolveWorkspacePath } from "../config/loadConfig.js";
 import { FirestoreError, writeDocument } from "../firestore/writeDocument.js";
 import { GitError, assertInsideGitRepository, showFileAtCommit, } from "../git/git.js";
 import { normalizeDocumentPath, normalizeSlashes, } from "../paths/backupPaths.js";
@@ -65,12 +65,13 @@ export async function runRestoreFirestore(inputPath, options) {
     }
     const config = loadConfig();
     const target = getFirestoreTarget(inputPath, config.outputDir);
-    assertInsideGitRepository();
-    const restoredContent = showFileAtCommit(options.from, target.backupPath);
+    assertInsideGitRepository(config.workspaceRoot);
+    const restoredContent = showFileAtCommit(options.from, target.backupPath, config.workspaceRoot);
     const restoredData = parseRestoreJson(restoredContent, target.backupPath);
-    const currentExists = existsSync(target.backupPath);
+    const targetFilePath = resolveWorkspacePath(config.workspaceRoot, target.backupPath);
+    const currentExists = existsSync(targetFilePath);
     const currentContent = currentExists
-        ? readFileSync(target.backupPath, "utf-8")
+        ? readFileSync(targetFilePath, "utf-8")
         : undefined;
     const diff = buildLineDiff(currentContent, restoredContent);
     printFirestorePreview(target, options.from, currentExists, diff);

package/dist/commands/restoreLocal.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { Command } from "commander";
-import { ConfigError, loadConfig } from "../config/loadConfig.js";
+import { ConfigError, loadConfig, resolveWorkspacePath } from "../config/loadConfig.js";
 import { GitError, assertInsideGitRepository, showFileAtCommit, } from "../git/git.js";
 import { normalizeDocumentPath } from "../paths/backupPaths.js";
 import { buildLineDiff, printRestorePreview } from "./restorePreview.js";
@@ -14,14 +14,15 @@ export function runRestoreLocal(inputPath, options) {
     }
     const config = loadConfig();
     const targetPath = normalizeDocumentPath(inputPath, config.outputDir);
-    assertInsideGitRepository();
-    const restoredContent = showFileAtCommit(options.from, targetPath);
-    const currentExists = existsSync(targetPath);
-    const currentContent = currentExists ? readFileSync(targetPath, "utf-8") : undefined;
+    assertInsideGitRepository(config.workspaceRoot);
+    const restoredContent = showFileAtCommit(options.from, targetPath, config.workspaceRoot);
+    const targetFilePath = resolveWorkspacePath(config.workspaceRoot, targetPath);
+    const currentExists = existsSync(targetFilePath);
+    const currentContent = currentExists ? readFileSync(targetFilePath, "utf-8") : undefined;
     const diff = buildLineDiff(currentContent, restoredContent);
     printRestorePreview(targetPath, options.from, currentExists, diff);
-    mkdirSync(path.dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, restoredContent);
+    mkdirSync(path.dirname(targetFilePath), { recursive: true });
+    writeFileSync(targetFilePath, restoredContent);
     console.log("");
     console.log(`Restored local backup file: ${targetPath}`);
 }

package/dist/commands/restorePreview.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { Command } from "commander";
-import { ConfigError, loadConfig } from "../config/loadConfig.js";
+import { ConfigError, loadConfig, resolveWorkspacePath } from "../config/loadConfig.js";
 import { GitError, assertInsideGitRepository, showFileAtCommit, } from "../git/git.js";
 import { normalizeDocumentPath } from "../paths/backupPaths.js";
 function normalizeJson(content) {
@@ -76,10 +76,11 @@ export function runRestorePreview(inputPath, options) {
     }
     const config = loadConfig();
     const targetPath = normalizeDocumentPath(inputPath, config.outputDir);
-    assertInsideGitRepository();
-    const restoredContent = showFileAtCommit(options.from, targetPath);
-    const currentExists = existsSync(targetPath);
-    const currentContent = currentExists ? readFileSync(targetPath, "utf-8") : undefined;
+    assertInsideGitRepository(config.workspaceRoot);
+    const restoredContent = showFileAtCommit(options.from, targetPath, config.workspaceRoot);
+    const targetFilePath = resolveWorkspacePath(config.workspaceRoot, targetPath);
+    const currentExists = existsSync(targetFilePath);
+    const currentContent = currentExists ? readFileSync(targetFilePath, "utf-8") : undefined;
     const diff = buildLineDiff(currentContent, restoredContent);
     printRestorePreview(targetPath, options.from, currentExists, diff);
 }

package/dist/commands/setupGithubAction.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { ConfigError, loadConfig } from "../config/loadConfig.js";
+const workflowRelativePath = ".github/workflows/firevault-snapshot.yml";
+const secretName = "FIREVAULT_SERVICE_ACCOUNT_JSON";
+function normalizeWorkflowPath(configPath) {
+    const normalized = configPath.replaceAll("\\", "/").replace(/^\.\//, "");
+    if (normalized === "" ||
+        normalized.startsWith("/") ||
+        normalized.startsWith("../") ||
+        normalized.includes("/../")) {
+        throw new ConfigError("Cannot generate GitHub Actions workflow: serviceAccountPath must stay inside .firevault.");
+    }
+    return normalized;
+}
+function workflowYaml(serviceAccountPath) {
+    const actionServiceAccountPath = `.firevault/${serviceAccountPath}`;
+    return `name: Firevault snapshot
+
+on:
+  schedule:
+    - cron: "0 3 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  snapshot:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out recovery repository
+        uses: actions/checkout@v4
+        with:
+          path: .firevault
+          fetch-depth: 0
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install Firevault
+        run: npm install -g firevault@next
+
+      - name: Write Firebase service account
+        env:
+          ${secretName}: \${{ secrets.${secretName} }}
+        run: |
+          mkdir -p "$(dirname "${actionServiceAccountPath}")"
+          printf '%s' "$${secretName}" > "${actionServiceAccountPath}"
+
+      - name: Configure Git author
+        working-directory: .firevault
+        run: |
+          git config user.name "firevault"
+          git config user.email "firevault@users.noreply.github.com"
+
+      - name: Run snapshot
+        run: firevault snapshot
+
+      - name: Push backup commit
+        working-directory: .firevault
+        run: |
+          branch="$(git rev-parse --abbrev-ref HEAD)"
+
+          if git rev-parse --verify "origin/$branch" >/dev/null 2>&1; then
+            commits_to_push="$(git rev-list --count "origin/$branch..HEAD")"
+
+            if [ "$commits_to_push" = "0" ]; then
+              echo "No new backup commit to push."
+              exit 0
+            fi
+          fi
+
+          git push origin "HEAD:$branch"
+
+      - name: Remove service account file
+        if: always()
+        run: rm -f "${actionServiceAccountPath}"
+`;
+}
+export function runSetupGithubAction(options) {
+    const config = loadConfig();
+    const serviceAccountPath = normalizeWorkflowPath(config.serviceAccountPath);
+    const workflowPath = path.join(config.workspaceRoot, workflowRelativePath);
+    if (existsSync(workflowPath) && !options.force) {
+        throw new ConfigError(`${path.join(".firevault", workflowRelativePath)} already exists. Rerun with --force to overwrite it.`);
+    }
+    mkdirSync(path.dirname(workflowPath), { recursive: true });
+    writeFileSync(workflowPath, workflowYaml(serviceAccountPath));
+    console.log("Created:");
+    console.log(path.join(".firevault", workflowRelativePath));
+    console.log("");
+    console.log("Next steps:");
+    console.log("1. Push the .firevault repo to GitHub");
+    console.log("2. Create GitHub secret:");
+    console.log(`   ${secretName}`);
+    console.log("3. Add your Firebase service account JSON as the secret value");
+    console.log("4. Review and commit the workflow file yourself");
+    console.log("5. Run the workflow manually once before relying on the schedule");
+}
+export const setupGithubActionCommand = new Command("setup-github-action")
+    .description("Create a local GitHub Actions workflow for scheduled Firevault snapshots")
+    .option("--force", "Overwrite an existing Firevault snapshot workflow")
+    .action((options) => {
+    try {
+        runSetupGithubAction(options);
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            console.error(error.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+});

package/dist/commands/status.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { ConfigError, findWorkspaceRoot, loadConfig } from "../config/loadConfig.js";
+import { getAheadBehind, getCurrentBranch, getLatestCommitDate, getRemoteUrl, hasChangesUnder, hasWorkingTreeChanges, isInsideGitRepository, } from "../git/git.js";
+function relativeDisplayPath(targetPath) {
+    const relativePath = path.relative(process.cwd(), targetPath);
+    if (relativePath === "") {
+        return ".";
+    }
+    return relativePath.startsWith("..") ? targetPath : relativePath || ".";
+}
+function workflowStatus(workspaceRoot) {
+    const workflowPath = path.join(workspaceRoot, ".github", "workflows", "firevault-snapshot.yml");
+    if (!existsSync(workflowPath)) {
+        return "not configured";
+    }
+    try {
+        const workflow = readFileSync(workflowPath, "utf-8");
+        if (workflow.includes("schedule:") && workflow.includes("cron:")) {
+            return "configured";
+        }
+        return "present, schedule missing";
+    }
+    catch {
+        return "present, unreadable";
+    }
+}
+function printMissingWorkspace() {
+    console.log("Firevault status");
+    console.log("");
+    console.log("Workspace:");
+    console.log("  Path: not found");
+    console.log("  Config: missing");
+    console.log("");
+    console.log("Next step:");
+    console.log("  Run `firevault init`");
+    process.exitCode = 1;
+}
+function formatRemoteSync(sync) {
+    if (!sync) {
+        return "unknown";
+    }
+    return `ahead ${sync.ahead}, behind ${sync.behind}`;
+}
+export function runStatus() {
+    const workspaceRoot = findWorkspaceRoot();
+    if (!workspaceRoot) {
+        printMissingWorkspace();
+        return;
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            console.log("Firevault status");
+            console.log("");
+            console.log("Workspace:");
+            console.log(`  Path: ${relativeDisplayPath(workspaceRoot)}`);
+            console.log("  Config: invalid");
+            console.log("");
+            console.log(`Error: ${error.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+    const gitRepositoryExists = isInsideGitRepository(config.workspaceRoot);
+    const outputDirExists = existsSync(config.outputDirPath);
+    const workingTreeDirty = gitRepositoryExists
+        ? hasWorkingTreeChanges(config.workspaceRoot)
+        : undefined;
+    const backupChanges = gitRepositoryExists
+        ? hasChangesUnder(config.outputDir, config.workspaceRoot)
+        : undefined;
+    const latestSnapshot = gitRepositoryExists
+        ? getLatestCommitDate(config.outputDir, config.workspaceRoot)
+        : undefined;
+    const branch = gitRepositoryExists
+        ? getCurrentBranch(config.workspaceRoot)
+        : undefined;
+    const remoteOrigin = gitRepositoryExists
+        ? getRemoteUrl("origin", config.workspaceRoot)
+        : undefined;
+    const remoteSync = gitRepositoryExists && remoteOrigin
+        ? getAheadBehind(config.workspaceRoot)
+        : undefined;
+    console.log("Firevault status");
+    console.log("");
+    console.log("Workspace:");
+    console.log(`  Path: ${relativeDisplayPath(config.workspaceRoot)}`);
+    console.log("  Config: OK");
+    console.log("");
+    console.log("Firestore:");
+    console.log(`  Project: ${config.projectId}`);
+    console.log(`  Collections configured: ${config.collections.length}`);
+    console.log("");
+    console.log("Backups:");
+    console.log(`  Output directory: ${config.outputDir}`);
+    console.log(`  Output exists: ${outputDirExists ? "yes" : "no"}`);
+    console.log(`  Last snapshot: ${latestSnapshot ?? "none"}`);
+    console.log(`  Uncommitted backup changes: ${backupChanges === undefined ? "unknown" : backupChanges ? "yes" : "none"}`);
+    console.log("");
+    console.log("Git:");
+    console.log(`  Repository: ${gitRepositoryExists ? "OK" : "missing"}`);
+    if (gitRepositoryExists) {
+        console.log(`  Branch: ${branch ?? "unknown"}`);
+        console.log(`  Working tree: ${workingTreeDirty ? "dirty" : "clean"}`);
+        console.log(`  Remote origin: ${remoteOrigin ? "configured" : "not configured"}`);
+        if (remoteOrigin) {
+            console.log(`  Remote sync: ${formatRemoteSync(remoteSync)}`);
+        }
+    }
+    console.log("");
+    console.log("Automation:");
+    console.log(`  GitHub Actions workflow: ${workflowStatus(config.workspaceRoot)}`);
+}
+export const statusCommand = new Command("status")
+    .description("Show local Firevault recovery health")
+    .action(() => {
+    runStatus();
+});

package/dist/config/loadConfig.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
 export class ConfigError extends Error {
     constructor(message) {
         super(message);
@@ -11,7 +12,7 @@ function isRecord(value) {
 function requireString(config, field) {
     const value = config[field];
     if (typeof value !== "string" || value.trim() === "") {
-        throw new ConfigError(`Invalid firevault.config.json: "${field}" is required and must be a string.`);
+        throw new ConfigError(`Invalid .firevault/config.json: "${field}" is required and must be a string.`);
     }
     return value;
 }
@@ -20,15 +21,36 @@ function requireStringArray(config, field) {
     if (!Array.isArray(value) ||
         value.length === 0 ||
         value.some((item) => typeof item !== "string" || item.trim() === "")) {
-        throw new ConfigError(`Invalid firevault.config.json: "${field}" is required and must include at least one collection name.`);
+        throw new ConfigError(`Invalid .firevault/config.json: "${field}" is required and must include at least one collection name.`);
     }
     return value;
 }
+export function findWorkspaceRoot(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(currentDir, ".firevault", "config.json");
+        if (existsSync(candidate)) {
+            return path.join(currentDir, ".firevault");
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir) {
+            return undefined;
+        }
+        currentDir = parent;
+    }
+}
+function normalizeConfigPath(value) {
+    return value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+export function resolveWorkspacePath(workspaceRoot, configPath) {
+    return path.resolve(workspaceRoot, configPath);
+}
 export function loadConfig() {
-    const configPath = "firevault.config.json";
-    if (!existsSync(configPath)) {
-        throw new ConfigError("Missing firevault.config.json. Run `firevault init` first.");
+    const workspaceRoot = findWorkspaceRoot();
+    if (!workspaceRoot) {
+        throw new ConfigError("Missing .firevault/config.json. Run `firevault init` first.");
     }
+    const configPath = path.join(workspaceRoot, "config.json");
     let parsed;
     try {
         const raw = readFileSync(configPath, "utf-8");
@@ -36,18 +58,24 @@ export function loadConfig() {
     }
     catch (error) {
         if (error instanceof SyntaxError) {
-            throw new ConfigError("Invalid firevault.config.json: file is not valid JSON.");
+            throw new ConfigError("Invalid .firevault/config.json: file is not valid JSON.");
         }
         throw error;
     }
     if (!isRecord(parsed)) {
-        throw new ConfigError("Invalid firevault.config.json: expected a JSON object.");
+        throw new ConfigError("Invalid .firevault/config.json: expected a JSON object.");
     }
     const config = {
         projectId: requireString(parsed, "projectId"),
-        serviceAccountPath: requireString(parsed, "serviceAccountPath"),
-        outputDir: requireString(parsed, "outputDir"),
+        serviceAccountPath: normalizeConfigPath(requireString(parsed, "serviceAccountPath")),
+        outputDir: normalizeConfigPath(requireString(parsed, "outputDir")),
         collections: requireStringArray(parsed, "collections"),
+        workspaceRoot,
+        configPath,
+        serviceAccountPathAbsolute: "",
+        outputDirPath: "",
     };
+    config.serviceAccountPathAbsolute = resolveWorkspacePath(workspaceRoot, config.serviceAccountPath);
+    config.outputDirPath = resolveWorkspacePath(workspaceRoot, config.outputDir);
     return config;
 }

package/dist/firestore/firebase.js

@@ -15,10 +15,10 @@ export function getFirestore() {
                 initialized = true;
                 return admin.firestore();
             }
-            if (!existsSync(config.serviceAccountPath)) {
+            if (!existsSync(config.serviceAccountPathAbsolute)) {
                 throw new ConfigError(`Service account file not found: ${config.serviceAccountPath}`);
             }
-            serviceAccount = JSON.parse(readFileSync(config.serviceAccountPath, "utf-8"));
+            serviceAccount = JSON.parse(readFileSync(config.serviceAccountPathAbsolute, "utf-8"));
             admin.initializeApp({
                 credential: admin.credential.cert(serviceAccount),
                 projectId: config.projectId,