@tmlmobilidade/env-sync 20260304.1625.33

package/dist/index.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import { cancel, isCancel, multiselect, outro, spinner } from '@clack/prompts';
+import { ASCII_TMLMOBILIDADE } from '@tmlmobilidade/consts';
+import chalk from 'chalk';
+import { uploadArtifacts } from './artifacts/upload.service.js';
+import { parseArgs, showHelp } from './cli/commands.js';
+import { loadConfig } from './config/config-loader.js';
+import { syncMongoDB } from './mongodb/sync.service.js';
+import { syncStorageService } from './storage/sync.service.js';
+import { logger } from './utils/logger.js';
+/* * */
+export const renderTitle = () => {
+    let text = ASCII_TMLMOBILIDADE;
+    text = text.replace(/▓/g, chalk.dim(chalk.yellow('▓')));
+    text = text.replace(/ ▄▄▄ /g, chalk.yellow(' ▄▄▄ '));
+    text = text.replace(/ ▀▀▀ /g, chalk.yellow(' ▀▀▀ '));
+    text = text.replace(/▐▒▒▒▌/g, chalk.yellow('▐') + chalk.white('▒▒▒') + chalk.yellow('▌'));
+    console.log(text);
+};
+async function determineSyncTargets(options) {
+    // --backup-only: only dump the database, skip storage and restore
+    if (options.backupOnly) {
+        return {
+            backupOnly: true,
+            syncDb: true,
+            syncStorage: false,
+        };
+    }
+    // If only --upload-artifacts is provided, skip sync operations
+    if (options.uploadArtifacts && !options.dbOnly && !options.storageOnly) {
+        return {
+            backupOnly: false,
+            syncDb: false,
+            syncStorage: false,
+        };
+    }
+    // If flags are provided, use them (non-interactive mode)
+    if (options.dbOnly || options.storageOnly) {
+        return {
+            backupOnly: false,
+            syncDb: Boolean(options.dbOnly),
+            syncStorage: Boolean(options.storageOnly),
+        };
+    }
+    // Interactive mode: ask user what to sync
+    const syncOptions = await multiselect({
+        message: 'What would you like to do?',
+        options: [
+            {
+                hint: 'Dump MongoDB database only (no restore to staging)',
+                label: 'Backup only',
+                value: 'backup',
+            },
+            {
+                hint: 'Sync MongoDB database from production to staging',
+                label: 'Database',
+                value: 'database',
+            },
+            {
+                hint: 'Sync OCI storage files from production to staging',
+                label: 'Storage',
+                value: 'storage',
+            },
+        ],
+        required: true,
+    });
+    if (isCancel(syncOptions)) {
+        cancel('Operation cancelled');
+        process.exit(0);
+    }
+    const selected = syncOptions;
+    const isBackupOnly = selected.includes('backup');
+    return {
+        backupOnly: isBackupOnly,
+        syncDb: isBackupOnly || selected.includes('database'),
+        syncStorage: !isBackupOnly && selected.includes('storage'),
+    };
+}
+async function runStorageSync(config) {
+    const s = spinner();
+    s.start('Syncing storage...');
+    try {
+        await syncStorageService(config);
+        s.stop('Storage sync completed successfully');
+    }
+    catch (error) {
+        s.stop('Storage sync failed');
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function runDatabaseSync(config, options) {
+    const backupOnly = options.backupOnly || false;
+    const s = spinner();
+    s.start(backupOnly ? 'Backing up database...' : 'Syncing database...');
+    try {
+        await syncMongoDB(config, {
+            backupOnly,
+            skipCleanup: options.noCleanup || false,
+            useReplicaSet: options.replicaSet,
+        });
+        s.stop(backupOnly ? 'Database backup completed successfully' : 'Database sync completed successfully');
+    }
+    catch (error) {
+        s.stop(backupOnly ? 'Database backup failed' : 'Database sync failed');
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function runArtifactUpload(config) {
+    const s = spinner();
+    s.start('Uploading artifacts to OCI...');
+    try {
+        if (!config.artifacts.bucket) {
+            throw new Error('ARTIFACTS_BUCKET is not configured. Please set it in your .env file.');
+        }
+        await uploadArtifacts({
+            bucket: config.artifacts.bucket,
+            localPath: config.backupDir,
+            prefix: config.artifacts.prefix,
+            storageConfig: config.storage,
+        });
+        s.stop('Artifacts uploaded successfully');
+    }
+    catch (error) {
+        s.stop('Artifact upload failed');
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+    if (options.help) {
+        showHelp();
+        process.exit(0);
+    }
+    try {
+        renderTitle();
+        // Set verbose mode
+        if (options.verbose) {
+            logger.setVerbose(true);
+            logger.verbose('Verbose mode enabled');
+        }
+        // Load configuration
+        const config = loadConfig();
+        logger.verbose('Configuration loaded successfully');
+        const { backupOnly, syncDb, syncStorage } = await determineSyncTargets(options);
+        if (syncStorage) {
+            await runStorageSync(config);
+        }
+        if (syncDb) {
+            await runDatabaseSync(config, { ...options, backupOnly });
+        }
+        if (options.uploadArtifacts) {
+            await runArtifactUpload(config);
+        }
+        if (syncDb || syncStorage || options.uploadArtifacts) {
+            const message = backupOnly ? 'Database backup completed successfully!' : 'Environment sync completed successfully!';
+            outro(message);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+        else {
+            logger.error(String(error));
+        }
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    logger.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+});

package/dist/mongodb/dump.service.d.ts

@@ -0,0 +1,8 @@
+import type { MongoConfig } from '../config/config-loader.js';
+export interface DumpOptions {
+    config: MongoConfig;
+    excludeCollections?: string[];
+    outputPath: string;
+    useReplicaSet?: boolean;
+}
+export declare function dumpMongoDB(options: DumpOptions): Promise<void>;

package/dist/mongodb/dump.service.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync } from 'fs';
+import { execCommand } from '../utils/exec.js';
+import { logger } from '../utils/logger.js';
+export async function dumpMongoDB(options) {
+    const { config, excludeCollections = [], outputPath, useReplicaSet = false } = options;
+    // Ensure output directory exists
+    if (!existsSync(outputPath)) {
+        mkdirSync(outputPath, { recursive: true });
+    }
+    // Build mongodump command for full database dump
+    logger.info('Dumping production database...');
+    logger.verbose(`Output path: ${outputPath}`);
+    logger.verbose(`Host: ${config.host}`);
+    logger.verbose(`Database: ${config.database}`);
+    logger.verbose(`Auth database: ${config.authDatabase}`);
+    if (excludeCollections.length > 0) {
+        logger.verbose(`Excluding collections: ${excludeCollections.join(', ')}`);
+    }
+    let dumpCmd = `mongodump \
+		--host=${config.host} \
+		--username=${config.username} \
+		--password=${config.password} \
+		--authenticationDatabase=${config.authDatabase} \
+		--db=${config.database} \
+		--gzip \
+		--archive=${outputPath}\\production.dump`;
+    if (useReplicaSet) {
+        dumpCmd += ' --readPreference=secondary';
+        logger.verbose('Using replica set mode with secondary read preference');
+    }
+    // Add exclude collections if configured
+    for (const collection of excludeCollections) {
+        dumpCmd += ` --excludeCollection=${collection}`;
+    }
+    try {
+        await execCommand(dumpCmd);
+        logger.success('MongoDB dump completed successfully');
+    }
+    catch (error) {
+        logger.error(`Failed to dump MongoDB: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/mongodb/restore.service.d.ts

@@ -0,0 +1,6 @@
+import type { MongoConfig } from '../config/config-loader.js';
+export interface RestoreOptions {
+    config: MongoConfig;
+    dumpPath: string;
+}
+export declare function restoreMongoDB(options: RestoreOptions): Promise<void>;

package/dist/mongodb/restore.service.js

@@ -0,0 +1,28 @@
+import { execCommand } from '../utils/exec.js';
+import { logger } from '../utils/logger.js';
+export async function restoreMongoDB(options) {
+    const { config, dumpPath } = options;
+    logger.verbose(`Restore dump path: ${dumpPath}`);
+    logger.verbose(`Host: ${config.host}`);
+    logger.verbose(`Database: ${config.database}`);
+    logger.verbose(`Auth database: ${config.authDatabase}`);
+    // Full restore: drop existing database and restore
+    const restoreCmd = `mongorestore \
+		--host=${config.host} \
+		--username=${config.username} \
+		--password=${config.password} \
+		--authenticationDatabase=${config.authDatabase} \
+		--db=${config.database} \
+		--drop \
+		--gzip \
+		--numParallelCollections=4 \
+		--archive=${dumpPath}\\production.dump`;
+    try {
+        await execCommand(restoreCmd);
+        logger.success('MongoDB restore completed successfully');
+    }
+    catch (error) {
+        logger.error(`Failed to restore MongoDB: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/mongodb/sync.service.d.ts

@@ -0,0 +1,7 @@
+import type { SyncConfig } from '../config/config-loader.js';
+export interface MongoSyncOptions {
+    backupOnly?: boolean;
+    skipCleanup?: boolean;
+    useReplicaSet?: boolean;
+}
+export declare function syncMongoDB(config: SyncConfig, options?: MongoSyncOptions): Promise<void>;

package/dist/mongodb/sync.service.js

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync } from 'fs';
+import path from 'path';
+import { checkCommandAvailable } from '../utils/exec.js';
+import { logger } from '../utils/logger.js';
+import { saveBackupMetadata } from '../utils/metadata.js';
+import { dumpMongoDB } from './dump.service.js';
+import { restoreMongoDB } from './restore.service.js';
+export async function syncMongoDB(config, options = {}) {
+    const { backupOnly = false, skipCleanup = false, useReplicaSet } = options;
+    logger.info(backupOnly ? 'Starting MongoDB backup...' : 'Starting MongoDB sync...');
+    logger.verbose('Checking for MongoDB tools...');
+    if (!(await checkCommandAvailable('mongodump'))) {
+        throw new Error('mongodump not found. Please install MongoDB tools.');
+    }
+    logger.verbose('mongodump found');
+    if (!backupOnly) {
+        if (!(await checkCommandAvailable('mongorestore'))) {
+            throw new Error('mongorestore not found. Please install MongoDB tools.');
+        }
+        logger.verbose('mongorestore found');
+    }
+    // Determine backup type
+    const effectiveReplicaSet = useReplicaSet ?? false;
+    const backupType = effectiveReplicaSet ? 'mongodb_rs' : 'mongodb';
+    logger.verbose(`Backup type: ${backupType}`);
+    logger.verbose(`Replica set mode: ${effectiveReplicaSet ? 'enabled' : 'disabled'}`);
+    // Create backup directory
+    const backupTimestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').substring(0, 19);
+    const dumpPath = path.join(config.backupDir, `${backupType}_${backupTimestamp}`);
+    logger.verbose(`Backup directory: ${dumpPath}`);
+    if (!existsSync(dumpPath)) {
+        mkdirSync(dumpPath, { recursive: true });
+    }
+    // Dump production database
+    logger.info('Dumping production database...');
+    try {
+        await dumpMongoDB({
+            config: config.databaseProduction,
+            excludeCollections: config.excludeCollections,
+            outputPath: dumpPath,
+            useReplicaSet: effectiveReplicaSet,
+        });
+    }
+    catch (error) {
+        logger.error(`Failed to dump production database: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+    if (!backupOnly) {
+        logger.info('Restoring to staging database...');
+        try {
+            await restoreMongoDB({
+                config: config.databaseStaging,
+                dumpPath,
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to restore to staging database: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    logger.verbose('Saving backup metadata...');
+    saveBackupMetadata(config.backupDir, backupType, backupTimestamp);
+    logger.verbose(`Backup metadata saved: ${backupType}_last_backup=${backupTimestamp}`);
+    logger.success(backupOnly ? 'MongoDB backup completed successfully' : 'MongoDB sync completed successfully');
+    // Cleanup old backups
+    if (!skipCleanup) {
+        logger.verbose(`Starting cleanup (retention: ${config.backupRetentionDays} days)...`);
+        cleanupOldBackups(config.backupDir, config.backupRetentionDays);
+    }
+    else {
+        logger.verbose('Cleanup skipped (--no-cleanup flag)');
+    }
+}
+function cleanupOldBackups(backupDir, retentionDays) {
+    logger.info(`Cleaning up old backups (keeping last ${retentionDays} days)...`);
+    if (!existsSync(backupDir)) {
+        return;
+    }
+    const now = Date.now();
+    const maxAge = retentionDays * 24 * 60 * 60 * 1000; // Convert days to milliseconds
+    try {
+        const entries = readdirSync(backupDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === METADATA_FILE)
+                continue; // Don't delete metadata file
+            const entryPath = path.join(backupDir, entry.name);
+            const stats = statSync(entryPath);
+            const age = now - stats.mtimeMs;
+            if (age > maxAge) {
+                if (entry.isDirectory()) {
+                    rmSync(entryPath, { force: true, recursive: true });
+                    logger.info(`Deleted old backup directory: ${entry.name}`);
+                }
+                else {
+                    unlinkSync(entryPath);
+                    logger.info(`Deleted old backup file: ${entry.name}`);
+                }
+            }
+        }
+        logger.success('Cleanup completed');
+    }
+    catch (error) {
+        logger.warn(`Cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+const METADATA_FILE = '.backup_metadata';

package/dist/storage/rclone.service.d.ts

@@ -0,0 +1,2 @@
+import type { StorageConfig } from '../config/config-loader.js';
+export declare function syncStorage(config: StorageConfig): Promise<void>;

package/dist/storage/rclone.service.js

@@ -0,0 +1,78 @@
+import { rmSync, writeFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { checkCommandAvailable, execCommandStream } from '../utils/exec.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Build a temporary OCI CLI config file using the credentials from StorageConfig.
+ * This lets rclone use the "user_principal_auth" provider without needing ~/.oci/config.
+ *
+ * See: https://rclone.org/oracleobjectstorage/#authentication-providers
+ */
+function buildOciConfig(config, profileName) {
+    return [
+        `[${profileName}]`,
+        `user=${config.user}`,
+        `fingerprint=${config.fingerprint}`,
+        `key_file=${config.keyFile}`,
+        `tenancy=${config.tenancy}`,
+        `region=${config.region}`,
+        '',
+    ].join('\n');
+}
+/**
+ * Build the rclone backend config pointing at the temporary OCI config file.
+ * Uses the "user_principal_auth" provider so credentials come from that file.
+ */
+function buildRcloneConfig(config, ociConfigPath, profileName) {
+    return [
+        `[${config.remoteName}]`,
+        `type = ${config.type}`,
+        `namespace = ${config.namespace}`,
+        `compartment = ${config.compartment}`,
+        `region = ${config.region}`,
+        'provider = user_principal_auth',
+        `config_file = ${ociConfigPath}`,
+        `config_profile = ${profileName}`,
+        '',
+    ].join('\n');
+}
+export async function syncStorage(config) {
+    logger.info('Starting OCI file sync...');
+    // Check if rclone is available
+    if (!(await checkCommandAvailable('rclone'))) {
+        throw new Error('rclone not found. Please install rclone.');
+    }
+    // Prepare temporary OCI config (no need for ~/.oci/config)
+    logger.info('Building temporary OCI config...');
+    const profileName = 'Default';
+    const ociConfigFile = path.join(os.tmpdir(), `oci-env-sync-${Date.now()}.conf`);
+    const ociConfigContent = buildOciConfig(config, profileName);
+    writeFileSync(ociConfigFile, ociConfigContent);
+    // Build rclone config pointing at the temporary OCI config
+    logger.info('Building rclone config...');
+    const rcloneConfig = buildRcloneConfig(config, ociConfigFile, profileName);
+    const rcloneConfigFile = path.join(os.tmpdir(), `rclone-env-sync-${Date.now()}.conf`);
+    writeFileSync(rcloneConfigFile, rcloneConfig);
+    // Sync production to staging
+    logger.info('Syncing files from production to staging...');
+    // Use the configured remote name so that rclone talks to OCI Object Storage
+    // instead of treating source/dest as local filesystem paths.
+    const sourcePath = `${config.remoteName}:${config.source}`;
+    const destPath = `${config.remoteName}:${config.dest}`;
+    const baseCmd = `rclone sync "${sourcePath}" "${destPath}" --config ${rcloneConfigFile}`;
+    const verboseFlags = logger.isVerbose() ? ' --progress --verbose' : '';
+    const syncCmd = `${baseCmd}${verboseFlags}`;
+    try {
+        // Use streaming execution to show rclone progress in real-time
+        await execCommandStream(syncCmd);
+        logger.success('OCI file sync completed successfully');
+        // Remove the temporary OCI config file
+        rmSync(ociConfigFile);
+        rmSync(rcloneConfigFile);
+    }
+    catch (error) {
+        logger.error(`OCI file sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/storage/sync.service.d.ts

@@ -0,0 +1,2 @@
+import type { SyncConfig } from '../config/config-loader.js';
+export declare function syncStorageService(config: SyncConfig): Promise<void>;

package/dist/storage/sync.service.js

@@ -0,0 +1,11 @@
+import { logger } from '../utils/logger.js';
+import { syncStorage } from './rclone.service.js';
+export async function syncStorageService(config) {
+    try {
+        await syncStorage(config.storage);
+    }
+    catch (error) {
+        logger.error(`Storage sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/utils/exec.d.ts

@@ -0,0 +1,12 @@
+export interface ExecOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+}
+export interface ExecResult {
+    stderr: string;
+    stdout: string;
+}
+export declare function execCommand(command: string, options?: ExecOptions): Promise<ExecResult>;
+export declare function execCommandStream(command: string, options?: ExecOptions): Promise<void>;
+export declare function checkCommandAvailable(command: string): Promise<boolean>;

package/dist/utils/exec.js

@@ -0,0 +1,114 @@
+import { exec as execCallback, spawn } from 'child_process';
+import { promisify } from 'util';
+import { logger } from './logger.js';
+const exec = promisify(execCallback);
+export async function execCommand(command, options = {}) {
+    // Mask sensitive information in verbose output
+    const maskedCommand = command.replace(/--password=([^\s]+)/g, '--password=***');
+    logger.verbose(`Executing: ${maskedCommand}`);
+    try {
+        const result = await exec(command, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            timeout: options.timeout || 0,
+        });
+        if (logger.isVerbose()) {
+            if (result.stdout) {
+                logger.verbose(`Stdout: ${result.stdout.toString().trim()}`);
+            }
+            if (result.stderr) {
+                logger.verbose(`Stderr: ${result.stderr.toString().trim()}`);
+            }
+        }
+        return {
+            stderr: result.stderr.toString(),
+            stdout: result.stdout.toString(),
+        };
+    }
+    catch (error) {
+        const execError = error;
+        throw new Error(`Command failed: ${command}\nExit code: ${execError.code || 'unknown'}\nStderr: ${execError.stderr || 'none'}\nStdout: ${execError.stdout || 'none'}`);
+    }
+}
+export async function execCommandStream(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        // Mask sensitive information in verbose output
+        const maskedCommand = command.replace(/--password=([^\s]+)/g, '--password=***');
+        logger.verbose(`Executing: ${maskedCommand}`);
+        // Parse command properly handling quoted strings
+        // This avoids the deprecation warning from using shell: true with arguments
+        const parts = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        let escaped = false;
+        for (const char of command) {
+            if (escaped) {
+                current += char;
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if ((char === '"' || char === '\'') && !escaped) {
+                if (!inQuotes) {
+                    inQuotes = true;
+                    quoteChar = char;
+                }
+                else if (char === quoteChar) {
+                    inQuotes = false;
+                    quoteChar = '';
+                }
+                else {
+                    current += char;
+                }
+            }
+            else if (char === ' ' && !inQuotes) {
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            parts.push(current);
+        }
+        if (parts.length === 0) {
+            reject(new Error(`Invalid command: ${command}`));
+            return;
+        }
+        const cmd = parts[0];
+        const args = parts.slice(1);
+        const childProcess = spawn(cmd, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            shell: false,
+            stdio: 'inherit', // This allows rclone's progress output to be displayed in real-time
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with exit code ${code}: ${command}`));
+            }
+        });
+        childProcess.on('error', (error) => {
+            reject(new Error(`Command failed: ${command}\nError: ${error.message}`));
+        });
+    });
+}
+export async function checkCommandAvailable(command) {
+    try {
+        await execCommand(`which ${command}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+export declare const logger: {
+    clearPreviousLine(): void;
+    error(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    isVerbose(): boolean;
+    log(...args: unknown[]): void;
+    setVerbose(enabled: boolean): void;
+    success(...args: unknown[]): void;
+    verbose(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+let verboseMode = false;
+function getTimestamp() {
+    return new Date().toISOString().replace('T', ' ').substring(0, 19);
+}
+export const logger = {
+    clearPreviousLine() {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+    },
+    error(...args) {
+        console.error(chalk.red(`[ERROR]`), ...args);
+    },
+    info(...args) {
+        console.log(chalk.green(`[${getTimestamp()}]`), ...args);
+    },
+    isVerbose() {
+        return verboseMode;
+    },
+    log(...args) {
+        console.log(...args);
+    },
+    setVerbose(enabled) {
+        verboseMode = enabled;
+    },
+    success(...args) {
+        console.log(chalk.green(`[${getTimestamp()}]`), ...args);
+    },
+    verbose(...args) {
+        if (verboseMode) {
+            console.log(chalk.dim(`[VERBOSE]`), ...args);
+        }
+    },
+    warn(...args) {
+        console.log(chalk.yellow(`[WARNING]`), ...args);
+    },
+};

package/dist/utils/metadata.d.ts

@@ -0,0 +1,6 @@
+export interface BackupMetadata {
+    timestamp: string;
+}
+export declare function getMetadataFilePath(backupDir: string): string;
+export declare function saveBackupMetadata(backupDir: string, backupType: string, timestamp: string): void;
+export declare function loadBackupMetadata(backupDir: string, backupType: string): BackupMetadata | null;