@fastybird/smart-panel-backend 0.12.0-alpha.0 → 1.0.0-beta.2

package/dist/modules/system/services/backup.service.js

@@ -0,0 +1,630 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupService = exports.BackupArchiveError = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const typeorm_1 = require("typeorm");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const typeorm_2 = require("@nestjs/typeorm");
+const logger_1 = require("../../../common/logger");
+const config_utils_1 = require("../../../common/utils/config.utils");
+const config_constants_1 = require("../../config/config.constants");
+const system_constants_1 = require("../system.constants");
+const backup_contribution_registry_service_1 = require("./backup-contribution-registry.service");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../../../../../../package.json'), 'utf-8'));
+const MAX_BACKUPS = 5;
+class BackupArchiveError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BackupArchiveError';
+    }
+}
+exports.BackupArchiveError = BackupArchiveError;
+const ALLOWED_CONTRIBUTION_TYPES = ['file', 'directory'];
+const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function parseStoredMetadata(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        throw new BackupArchiveError('Invalid backup archive: metadata is not an object');
+    }
+    const candidate = raw;
+    const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+    if (!isNonEmptyString(candidate.id) ||
+        !isNonEmptyString(candidate.name) ||
+        !isNonEmptyString(candidate.version) ||
+        !isNonEmptyString(candidate.createdAt)) {
+        throw new BackupArchiveError('Invalid backup archive: metadata is missing required fields');
+    }
+    if (!UUID_V4_REGEX.test(candidate.id)) {
+        throw new BackupArchiveError('Invalid backup archive: metadata.id is not a valid UUIDv4');
+    }
+    if (!Array.isArray(candidate.contributions)) {
+        throw new BackupArchiveError('Invalid backup archive: metadata.contributions is not an array');
+    }
+    const contributions = candidate.contributions.map((entry, index) => {
+        if (typeof entry !== 'object' || entry === null) {
+            throw new BackupArchiveError(`Invalid backup archive: metadata.contributions[${index}] is not an object`);
+        }
+        const contribution = entry;
+        if (typeof contribution.source !== 'string' ||
+            typeof contribution.label !== 'string' ||
+            typeof contribution.type !== 'string') {
+            throw new BackupArchiveError(`Invalid backup archive: metadata.contributions[${index}] is missing required fields`);
+        }
+        if (!ALLOWED_CONTRIBUTION_TYPES.includes(contribution.type)) {
+            throw new BackupArchiveError(`Invalid backup archive: metadata.contributions[${index}].type must be "file" or "directory"`);
+        }
+        return {
+            source: contribution.source,
+            label: contribution.label,
+            type: contribution.type,
+        };
+    });
+    return {
+        id: candidate.id,
+        name: candidate.name,
+        version: candidate.version,
+        createdAt: candidate.createdAt,
+        contributions,
+    };
+}
+let BackupService = class BackupService {
+    constructor(configService, contributionRegistry, eventEmitter, dataSource) {
+        this.configService = configService;
+        this.contributionRegistry = contributionRegistry;
+        this.eventEmitter = eventEmitter;
+        this.dataSource = dataSource;
+        this.logger = (0, logger_1.createExtensionLogger)(system_constants_1.SYSTEM_MODULE_NAME, 'BackupService');
+        const dbDir = (0, config_utils_1.getEnvValue)(this.configService, 'FB_DB_PATH', (0, path_1.resolve)(__dirname, '../../../../../../var/db'));
+        this.dbPath = (0, path_1.join)(dbDir, 'database.sqlite');
+        const dataDir = (0, config_utils_1.getEnvValue)(this.configService, 'FB_DATA_DIR', (0, path_1.resolve)(__dirname, '../../../../../../var'));
+        this.backupsDir = (0, path_1.join)(dataDir, 'backups');
+    }
+    ensureBackupsDir() {
+        if (!(0, fs_1.existsSync)(this.backupsDir)) {
+            (0, fs_1.mkdirSync)(this.backupsDir, { recursive: true });
+            this.logger.debug(`Created backups directory: ${this.backupsDir}`);
+        }
+    }
+    async create(name) {
+        this.ensureBackupsDir();
+        const id = (0, uuid_1.v4)();
+        const trimmedName = name?.trim() ?? '';
+        const backupName = trimmedName.length > 0 ? trimmedName : `backup-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+        const tempDir = (0, path_1.join)(this.backupsDir, `temp-${id}`);
+        const tarPath = (0, path_1.join)(this.backupsDir, `${id}.tar.gz`);
+        let sidecarPath = null;
+        let fullMetadata;
+        this.logger.debug(`Creating backup id=${id} name=${backupName}`);
+        try {
+            (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+            if ((0, fs_1.existsSync)(this.dbPath)) {
+                const backupDbPath = (0, path_1.join)(tempDir, 'database.sqlite');
+                try {
+                    const escapedBackupPath = backupDbPath.replace(/'/g, "''");
+                    await execFileAsync('sqlite3', [this.dbPath, `.backup '${escapedBackupPath}'`]);
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.code !== 'ENOENT') {
+                        throw error;
+                    }
+                    this.logger.warn('sqlite3 CLI not found — falling back to copyFileSync (unsafe under concurrent writes)');
+                    (0, fs_1.copyFileSync)(this.dbPath, backupDbPath);
+                }
+                this.logger.debug('Database snapshot created for backup');
+            }
+            else {
+                this.logger.warn(`Database file not found at ${this.dbPath}, skipping`);
+            }
+            const contributions = this.contributionRegistry.getContributions();
+            const includedContributions = [];
+            for (const contribution of contributions) {
+                if (!(0, fs_1.existsSync)(contribution.path)) {
+                    if (contribution.optional) {
+                        this.logger.debug(`Optional contribution not found, skipping: ${contribution.path}`);
+                        continue;
+                    }
+                    throw new Error(`Required backup contribution is missing: ${contribution.label} (${contribution.source}) at ${contribution.path}`);
+                }
+                const safeSource = contribution.source.replace(/[^a-zA-Z0-9_-]/g, '_');
+                const safeLabel = (contribution.label || 'default').replace(/[^a-zA-Z0-9_-]/g, '_') || 'default';
+                const contributionDir = (0, path_1.join)(tempDir, 'contributions', safeSource, safeLabel);
+                (0, fs_1.mkdirSync)(contributionDir, { recursive: true });
+                if (contribution.type === 'file') {
+                    const fileName = (contribution.path.split('/').pop() || 'file').replace(/[^a-zA-Z0-9._-]/g, '_');
+                    (0, fs_1.copyFileSync)(contribution.path, (0, path_1.join)(contributionDir, fileName));
+                }
+                else {
+                    const dirName = (contribution.path.split('/').pop() || 'dir').replace(/[^a-zA-Z0-9._-]/g, '_');
+                    const sourceRoot = contribution.path;
+                    const excludeSet = new Set(contribution.exclude ?? []);
+                    (0, fs_1.cpSync)(contribution.path, (0, path_1.join)(contributionDir, dirName), {
+                        recursive: true,
+                        filter: (src) => {
+                            if (excludeSet.size === 0 || src === sourceRoot) {
+                                return true;
+                            }
+                            const rel = (0, path_1.relative)(sourceRoot, src);
+                            const firstSegment = rel.split(path_1.sep)[0];
+                            return !excludeSet.has(firstSegment);
+                        },
+                    });
+                }
+                includedContributions.push({
+                    source: contribution.source,
+                    label: contribution.label,
+                    type: contribution.type,
+                });
+                this.logger.debug(`Copied contribution: ${contribution.label} from ${contribution.source}`);
+            }
+            const metadata = {
+                id,
+                name: backupName,
+                version: packageJson.version,
+                createdAt: new Date().toISOString(),
+                contributions: includedContributions,
+            };
+            (0, fs_1.writeFileSync)((0, path_1.join)(tempDir, 'metadata.json'), JSON.stringify(metadata, null, 2));
+            await execFileAsync('tar', ['-czf', tarPath, '-C', tempDir, '.']);
+            const stats = (0, fs_1.statSync)(tarPath);
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            this.writeMetadataSidecar(id, metadata);
+            sidecarPath = this.getMetadataSidecarPath(id);
+            fullMetadata = {
+                ...metadata,
+                sizeBytes: stats.size,
+            };
+            this.logger.log(`Backup created successfully: id=${id}, size=${stats.size} bytes`);
+        }
+        catch (error) {
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            if ((0, fs_1.existsSync)(tarPath)) {
+                (0, fs_1.rmSync)(tarPath, { force: true });
+            }
+            if (sidecarPath && (0, fs_1.existsSync)(sidecarPath)) {
+                (0, fs_1.rmSync)(sidecarPath, { force: true });
+            }
+            throw error;
+        }
+        try {
+            await this.cleanupOldBackups(id);
+        }
+        catch (error) {
+            const err = error;
+            this.logger.warn(`Retention sweep failed after creating backup ${id}: ${err.message}`);
+        }
+        return fullMetadata;
+    }
+    async list() {
+        if (!(0, fs_1.existsSync)(this.backupsDir)) {
+            return [];
+        }
+        const files = (0, fs_1.readdirSync)(this.backupsDir).filter((f) => f.endsWith('.tar.gz') && !f.startsWith('upload-'));
+        const backups = [];
+        for (const file of files) {
+            const id = file.replace('.tar.gz', '');
+            try {
+                const metadata = await this.getMetadata(id);
+                if (metadata) {
+                    backups.push(metadata);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to read metadata from backup ${file}`, { error });
+            }
+        }
+        backups.sort((a, b) => this.getCreatedAtMs(b.createdAt) - this.getCreatedAtMs(a.createdAt));
+        return backups;
+    }
+    getCreatedAtMs(createdAt) {
+        const ms = new Date(createdAt).getTime();
+        return Number.isFinite(ms) ? ms : 0;
+    }
+    getBackupPath(id) {
+        return (0, path_1.join)(this.backupsDir, `${id}.tar.gz`);
+    }
+    delete(id) {
+        const tarPath = this.getBackupPath(id);
+        if (!(0, fs_1.existsSync)(tarPath)) {
+            throw new Error(`Backup not found: ${id}`);
+        }
+        (0, fs_1.rmSync)(tarPath, { force: true });
+        const sidecarPath = this.getMetadataSidecarPath(id);
+        if ((0, fs_1.existsSync)(sidecarPath)) {
+            (0, fs_1.rmSync)(sidecarPath, { force: true });
+        }
+        this.logger.log(`Backup deleted: id=${id}`);
+    }
+    async prepareRestore(id) {
+        const tarPath = this.getBackupPath(id);
+        if (!(0, fs_1.existsSync)(tarPath)) {
+            throw new Error(`Backup not found: ${id}`);
+        }
+        const tempDir = (0, path_1.join)(this.backupsDir, `restore-${id}-${(0, uuid_1.v4)()}`);
+        try {
+            (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+            const workingArchive = (0, path_1.join)(tempDir, 'archive.tar.gz');
+            this.pinArchive(tarPath, workingArchive);
+            await this.validateArchiveSafety(workingArchive);
+            await execFileAsync('tar', [
+                '--no-same-owner',
+                '--no-same-permissions',
+                '-xzf',
+                workingArchive,
+                '-C',
+                tempDir,
+                './metadata.json',
+            ]);
+            const metadataPath = (0, path_1.join)(tempDir, 'metadata.json');
+            if (!(0, fs_1.existsSync)(metadataPath)) {
+                throw new BackupArchiveError('Invalid backup: metadata.json not found');
+            }
+            const storedMetadata = parseStoredMetadata(JSON.parse(this.readExtractedFileSafely(metadataPath)));
+            if (storedMetadata.id !== id) {
+                throw new BackupArchiveError(`Invalid backup archive ${id}: metadata.id "${storedMetadata.id}" does not match filename`);
+            }
+            return {
+                metadata: {
+                    ...storedMetadata,
+                    sizeBytes: (0, fs_1.statSync)(workingArchive).size,
+                },
+                workingArchive,
+                tempDir,
+            };
+        }
+        catch (error) {
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async restore(prepared) {
+        const { workingArchive, tempDir, metadata } = prepared;
+        this.logger.log(`Restoring backup id=${metadata.id}`);
+        let pointOfNoReturn = false;
+        try {
+            await execFileAsync('tar', ['--no-same-owner', '--no-same-permissions', '-xzf', workingArchive, '-C', tempDir]);
+            if (metadata.contributions && metadata.contributions.length > 0) {
+                const registrations = this.contributionRegistry.getRegistrations();
+                const contributionKey = (source, label) => `${source}\u0000${label}`;
+                const registrationByKey = new Map(registrations.map((r) => [contributionKey(r.source, r.label), r]));
+                const staticPass = [];
+                const lazyPass = [];
+                for (const contribution of metadata.contributions) {
+                    const registration = registrationByKey.get(contributionKey(contribution.source, contribution.label));
+                    if (registration && typeof registration.path === 'function') {
+                        lazyPass.push(contribution);
+                    }
+                    else {
+                        staticPass.push(contribution);
+                    }
+                }
+                const restoreContribution = (contribution) => {
+                    const registration = registrationByKey.get(contributionKey(contribution.source, contribution.label));
+                    if (!registration) {
+                        this.logger.warn(`Skipping unregistered contribution: ${contribution.source} (${contribution.label})`);
+                        return;
+                    }
+                    const safeSource = contribution.source.replace(/[^a-zA-Z0-9_-]/g, '_');
+                    const safeLabel = (contribution.label || 'default').replace(/[^a-zA-Z0-9_-]/g, '_') || 'default';
+                    const contributionDir = (0, path_1.join)(tempDir, 'contributions', safeSource, safeLabel);
+                    if (!(0, fs_1.existsSync)(contributionDir)) {
+                        throw new BackupArchiveError(`Invalid backup: contribution ${contribution.label} not present in archive`);
+                    }
+                    const entries = (0, fs_1.readdirSync)(contributionDir);
+                    if (entries.length !== 1) {
+                        throw new BackupArchiveError(`Invalid backup: contribution ${contribution.label} has unexpected archive layout (${entries.length} entries)`);
+                    }
+                    const sourcePath = (0, path_1.join)(contributionDir, entries[0]);
+                    const targetPath = typeof registration.path === 'function' ? registration.path() : registration.path;
+                    const targetDir = (0, path_1.resolve)(targetPath, '..');
+                    if (!(0, fs_1.existsSync)(targetDir)) {
+                        (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+                    }
+                    pointOfNoReturn = true;
+                    if (registration.type === 'directory') {
+                        const excludeSet = new Set(registration.exclude ?? []);
+                        if (excludeSet.size === 0) {
+                            if ((0, fs_1.existsSync)(targetPath)) {
+                                (0, fs_1.rmSync)(targetPath, { recursive: true, force: true });
+                            }
+                            (0, fs_1.cpSync)(sourcePath, targetPath, { recursive: true });
+                        }
+                        else {
+                            (0, fs_1.mkdirSync)(targetPath, { recursive: true });
+                            for (const entry of (0, fs_1.readdirSync)(targetPath)) {
+                                if (excludeSet.has(entry)) {
+                                    continue;
+                                }
+                                (0, fs_1.rmSync)((0, path_1.join)(targetPath, entry), { recursive: true, force: true });
+                            }
+                            for (const entry of (0, fs_1.readdirSync)(sourcePath)) {
+                                if (excludeSet.has(entry)) {
+                                    this.logger.warn(`Skipping excluded entry "${entry}" found in archive for contribution ${contribution.label}`);
+                                    continue;
+                                }
+                                (0, fs_1.cpSync)((0, path_1.join)(sourcePath, entry), (0, path_1.join)(targetPath, entry), { recursive: true });
+                            }
+                        }
+                    }
+                    else {
+                        (0, fs_1.copyFileSync)(sourcePath, targetPath);
+                    }
+                    this.logger.debug(`Restored contribution: ${contribution.label} to ${targetPath}`);
+                };
+                for (const contribution of staticPass) {
+                    restoreContribution(contribution);
+                }
+                if (lazyPass.length > 0) {
+                    this.eventEmitter.emit(config_constants_1.EventType.CONFIG_RELOAD);
+                    for (const contribution of lazyPass) {
+                        restoreContribution(contribution);
+                    }
+                }
+            }
+            const backupDbPath = (0, path_1.join)(tempDir, 'database.sqlite');
+            if ((0, fs_1.existsSync)(backupDbPath)) {
+                pointOfNoReturn = true;
+                if (this.dataSource.isInitialized) {
+                    await this.dataSource.destroy();
+                }
+                const dbDir = (0, path_1.resolve)(this.dbPath, '..');
+                if (!(0, fs_1.existsSync)(dbDir)) {
+                    (0, fs_1.mkdirSync)(dbDir, { recursive: true });
+                }
+                (0, fs_1.copyFileSync)(backupDbPath, this.dbPath);
+                const walPath = `${this.dbPath}-wal`;
+                const shmPath = `${this.dbPath}-shm`;
+                if ((0, fs_1.existsSync)(walPath)) {
+                    (0, fs_1.rmSync)(walPath, { force: true });
+                }
+                if ((0, fs_1.existsSync)(shmPath)) {
+                    (0, fs_1.rmSync)(shmPath, { force: true });
+                }
+                this.logger.log('Database restored from backup');
+            }
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            this.logger.log(`Backup restored successfully: id=${metadata.id}. Ready for process restart.`);
+        }
+        catch (error) {
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            if (pointOfNoReturn) {
+                this.logger.error(`Backup restore failed after mutating live state: ${error.message}. Exiting for restart.`, error.stack);
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    async getMetadata(id) {
+        const tarPath = this.getBackupPath(id);
+        if (!(0, fs_1.existsSync)(tarPath)) {
+            return null;
+        }
+        const stats = (0, fs_1.statSync)(tarPath);
+        const sidecar = this.readMetadataSidecar(id);
+        if (sidecar) {
+            if (sidecar.id !== id) {
+                throw new BackupArchiveError(`Invalid backup sidecar for ${id}: metadata.id "${sidecar.id}" does not match filename`);
+            }
+            return { ...sidecar, sizeBytes: stats.size };
+        }
+        const tempDir = (0, path_1.join)(this.backupsDir, `meta-${id}`);
+        try {
+            (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+            const workingArchive = (0, path_1.join)(tempDir, 'archive.tar.gz');
+            this.pinArchive(tarPath, workingArchive);
+            await this.validateArchiveSafety(workingArchive);
+            await execFileAsync('tar', [
+                '--no-same-owner',
+                '--no-same-permissions',
+                '-xzf',
+                workingArchive,
+                '-C',
+                tempDir,
+                './metadata.json',
+            ]);
+            const metadataPath = (0, path_1.join)(tempDir, 'metadata.json');
+            if (!(0, fs_1.existsSync)(metadataPath)) {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+                return null;
+            }
+            const metadata = parseStoredMetadata(JSON.parse(this.readExtractedFileSafely(metadataPath)));
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            if (metadata.id !== id) {
+                throw new BackupArchiveError(`Invalid backup archive ${id}: metadata.id "${metadata.id}" does not match filename`);
+            }
+            try {
+                this.writeMetadataSidecar(id, metadata);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to cache metadata sidecar for backup ${id}`, { error });
+            }
+            return {
+                ...metadata,
+                sizeBytes: stats.size,
+            };
+        }
+        catch (error) {
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            if (error instanceof BackupArchiveError) {
+                throw error;
+            }
+            this.logger.warn(`Failed to extract metadata from backup ${id}`, { error });
+            return null;
+        }
+    }
+    pinArchive(sourcePath, destPath) {
+        try {
+            (0, fs_1.linkSync)(sourcePath, destPath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== 'EXDEV') {
+                throw error;
+            }
+            (0, fs_1.copyFileSync)(sourcePath, destPath);
+        }
+    }
+    async validateArchiveSafety(archivePath) {
+        const [{ stdout: tarPaths }, { stdout: tarVerbose }] = await Promise.all([
+            execFileAsync('tar', ['-tzf', archivePath]),
+            execFileAsync('tar', ['-tvzf', archivePath]),
+        ]);
+        const paths = tarPaths.split('\n').filter((line) => line.length > 0);
+        const verboseLines = tarVerbose.split('\n').filter((line) => line.length > 0);
+        if (paths.length !== verboseLines.length) {
+            throw new BackupArchiveError('Invalid backup: archive listing is inconsistent');
+        }
+        for (let i = 0; i < paths.length; i++) {
+            const entryPath = paths[i];
+            if (entryPath.startsWith('/') || entryPath.split('/').some((segment) => segment === '..')) {
+                throw new BackupArchiveError('Invalid backup: archive contains path traversal entries');
+            }
+            const fileType = verboseLines[i][0];
+            if (fileType !== '-' && fileType !== 'd') {
+                throw new BackupArchiveError(`Invalid backup: archive contains disallowed entry type "${fileType}"`);
+            }
+        }
+    }
+    readExtractedFileSafely(filePath) {
+        if ((0, fs_1.lstatSync)(filePath).isSymbolicLink()) {
+            throw new BackupArchiveError('Invalid backup archive: extracted entry is a symlink');
+        }
+        return (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    getMetadataSidecarPath(id) {
+        return (0, path_1.join)(this.backupsDir, `${id}.json`);
+    }
+    writeMetadataSidecar(id, metadata) {
+        (0, fs_1.writeFileSync)(this.getMetadataSidecarPath(id), JSON.stringify(metadata, null, 2));
+    }
+    readMetadataSidecar(id) {
+        const sidecarPath = this.getMetadataSidecarPath(id);
+        if (!(0, fs_1.existsSync)(sidecarPath)) {
+            return null;
+        }
+        try {
+            return parseStoredMetadata(JSON.parse((0, fs_1.readFileSync)(sidecarPath, 'utf-8')));
+        }
+        catch (error) {
+            this.logger.warn(`Failed to read metadata sidecar for backup ${id}`, { error });
+            return null;
+        }
+    }
+    async saveUploadedBackup(buffer, _originalFilename) {
+        this.ensureBackupsDir();
+        const tempId = (0, uuid_1.v4)();
+        const tempTarPath = (0, path_1.join)(this.backupsDir, `upload-${tempId}.tar.gz`);
+        const tempDir = (0, path_1.join)(this.backupsDir, `upload-meta-${tempId}`);
+        let finalPath = null;
+        let sidecarPath = null;
+        let savedMetadata;
+        let savedId;
+        try {
+            (0, fs_1.writeFileSync)(tempTarPath, buffer);
+            (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+            await this.validateArchiveSafety(tempTarPath);
+            await execFileAsync('tar', [
+                '--no-same-owner',
+                '--no-same-permissions',
+                '-xzf',
+                tempTarPath,
+                '-C',
+                tempDir,
+                './metadata.json',
+            ]);
+            const metadataPath = (0, path_1.join)(tempDir, 'metadata.json');
+            if (!(0, fs_1.existsSync)(metadataPath)) {
+                throw new BackupArchiveError('Invalid backup archive: metadata.json not found');
+            }
+            const metadata = parseStoredMetadata(JSON.parse(this.readExtractedFileSafely(metadataPath)));
+            if (!Number.isFinite(new Date(metadata.createdAt).getTime())) {
+                throw new BackupArchiveError('Invalid backup archive: metadata.createdAt is not a valid ISO date');
+            }
+            finalPath = this.getBackupPath(metadata.id);
+            if ((0, fs_1.existsSync)(finalPath)) {
+                throw new BackupArchiveError(`Backup with id=${metadata.id} already exists — refusing to overwrite`);
+            }
+            (0, fs_1.copyFileSync)(tempTarPath, finalPath);
+            (0, fs_1.rmSync)(tempTarPath, { force: true });
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            const stats = (0, fs_1.statSync)(finalPath);
+            this.logger.log(`Uploaded backup saved: id=${metadata.id}, size=${stats.size} bytes`);
+            this.writeMetadataSidecar(metadata.id, metadata);
+            sidecarPath = this.getMetadataSidecarPath(metadata.id);
+            savedId = metadata.id;
+            savedMetadata = {
+                ...metadata,
+                sizeBytes: stats.size,
+            };
+        }
+        catch (error) {
+            if ((0, fs_1.existsSync)(tempTarPath)) {
+                (0, fs_1.rmSync)(tempTarPath, { force: true });
+            }
+            (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            if (finalPath && (0, fs_1.existsSync)(finalPath)) {
+                (0, fs_1.rmSync)(finalPath, { force: true });
+            }
+            if (sidecarPath && (0, fs_1.existsSync)(sidecarPath)) {
+                (0, fs_1.rmSync)(sidecarPath, { force: true });
+            }
+            throw error;
+        }
+        try {
+            await this.cleanupOldBackups(savedId);
+        }
+        catch (error) {
+            const err = error;
+            this.logger.warn(`Retention sweep failed after uploading backup ${savedId}: ${err.message}`);
+        }
+        return savedMetadata;
+    }
+    async cleanupOldBackups(preserveId) {
+        const backups = await this.list();
+        if (backups.length <= MAX_BACKUPS) {
+            return;
+        }
+        const candidates = backups
+            .filter((backup) => backup.id !== preserveId)
+            .sort((a, b) => this.getCreatedAtMs(a.createdAt) - this.getCreatedAtMs(b.createdAt));
+        const excessCount = backups.length - MAX_BACKUPS;
+        const toRemove = candidates.slice(0, excessCount);
+        for (const backup of toRemove) {
+            try {
+                this.delete(backup.id);
+                this.logger.debug(`Cleaned up old backup: id=${backup.id}`);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to cleanup old backup: id=${backup.id}`, { error });
+            }
+        }
+    }
+};
+exports.BackupService = BackupService;
+exports.BackupService = BackupService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, typeorm_2.InjectDataSource)()),
+    __metadata("design:paramtypes", [config_1.ConfigService,
+        backup_contribution_registry_service_1.BackupContributionRegistry,
+        event_emitter_1.EventEmitter2,
+        typeorm_1.DataSource])
+], BackupService);
+//# sourceMappingURL=backup.service.js.map