${_('updates.no_backups')}
`; + if (summaryEl) summaryEl.textContent = ''; return; } + + const totalBytes = backups.reduce((acc, b) => acc + (b.sizeBytes || 0), 0); + if (summaryEl) { + summaryEl.textContent = `${_('updates.total_size')}: ${formatBytes(totalBytes)} · ${backups.length} ${_('updates.backups_count')}`; + } let html = '${_('updates.no_backups')}
`; + if (summaryEl) summaryEl.textContent = ''; } } + + // Wire retention controls (idempotent — handles tab re-mount) + document.addEventListener('click', (ev) => { + const target = ev.target.closest('#backup-retention-save, #backup-prune-now'); + if (!target) return; + if (target.id === 'backup-retention-save') saveBackupRetention(); + else if (target.id === 'backup-prune-now') pruneBackupsNow(); + }); + + // Expose retention loader so tab activation can call it + window.loadBackupRetention = loadBackupRetention; })(); diff --git a/web-nodejs/routes/settings.routes.js b/web-nodejs/routes/settings.routes.js index 0b853cb7..be092141 100644 --- a/web-nodejs/routes/settings.routes.js +++ b/web-nodejs/routes/settings.routes.js @@ -679,4 +679,92 @@ router.post('/api/settings/updates/restore', requireAuth, requirePermission('ser } }); +/** + * DELETE /api/settings/updates/backups/:name - Delete a single pre-update backup + */ +router.delete('/api/settings/updates/backups/:name', requireAuth, requirePermission('server.config'), async (req, res) => { + try { + const name = req.params.name; + const result = updateService.deleteBackup(name); + await db.logAction(req.session?.userId, 'backup_deleted', `Deleted update backup: ${name}`, req.ip); + res.json({ success: true, data: result }); + } catch (err) { + console.error('Delete backup error:', err); + // 400 for validation errors, 500 for unexpected ones + const status = /invalid|not found|outside/i.test(err.message) ? 400 : 500; + res.status(status).json({ success: false, error: err.message }); + } +}); + +/** + * POST /api/settings/updates/backups/prune - Apply retention now + * Body: { keep: number } — keep N newest, delete the rest + */ +router.post('/api/settings/updates/backups/prune', requireAuth, requirePermission('server.config'), async (req, res) => { + try { + const keep = parseInt(req.body?.keep, 10); + if (!Number.isFinite(keep) || keep <= 0) { + return res.status(400).json({ success: false, error: 'keep must be a positive integer' }); + } + const result = updateService.pruneBackups(keep); + if (result.deleted.length) { + await db.logAction( + req.session?.userId, 'backup_pruned', + `Manual prune: kept ${keep}, deleted ${result.deleted.length} backup(s)`, + req.ip + ); + } + res.json({ success: true, data: result }); + } catch (err) { + console.error('Prune backups error:', err); + res.status(500).json({ success: false, error: err.message }); + } +}); + +/** + * GET /api/settings/backup/retention - Read current retention count + * Resolution: DB setting → env var BACKUP_RETENTION_COUNT → 0 (unlimited) + */ +router.get('/api/settings/backup/retention', requireAuth, requirePermission('server.config'), async (req, res) => { + try { + const dbVal = await db.getSetting('backup_retention_count'); + let count = 0; + let source = 'unset'; + if (dbVal !== null && dbVal !== undefined && dbVal !== '') { + const parsed = parseInt(dbVal, 10); + if (Number.isFinite(parsed)) { count = parsed; source = 'database'; } + } else if (process.env.BACKUP_RETENTION_COUNT) { + const parsed = parseInt(process.env.BACKUP_RETENTION_COUNT, 10); + if (Number.isFinite(parsed)) { count = parsed; source = 'environment'; } + } + res.json({ success: true, data: { count, source } }); + } catch (err) { + console.error('Get retention error:', err); + res.status(500).json({ success: false, error: req.t('errors.server_error') }); + } +}); + +/** + * PUT /api/settings/backup/retention - Update retention count + * Body: { count: number } — 0 means "keep all" + */ +router.put('/api/settings/backup/retention', requireAuth, requirePermission('server.config'), async (req, res) => { + try { + const count = parseInt(req.body?.count, 10); + if (!Number.isFinite(count) || count < 0 || count > 1000) { + return res.status(400).json({ success: false, error: 'count must be an integer between 0 and 1000' }); + } + await db.setSetting('backup_retention_count', String(count)); + await db.logAction( + req.session?.userId, 'backup_retention_changed', + `Backup retention set to ${count === 0 ? 'unlimited' : count}`, + req.ip + ); + res.json({ success: true, data: { count } }); + } catch (err) { + console.error('Set retention error:', err); + res.status(500).json({ success: false, error: req.t('errors.server_error') }); + } +}); + module.exports = router; diff --git a/web-nodejs/services/updateService.js b/web-nodejs/services/updateService.js index af2c2c67..3226922d 100644 --- a/web-nodejs/services/updateService.js +++ b/web-nodejs/services/updateService.js @@ -768,6 +768,31 @@ async function createPreUpdateBackup(allFiles) { files: allFiles.filter(f => f.component === 'console' && f.localPath).map(f => f.localPath) }, null, 2)); + // Auto-prune old backups based on retention setting. + // Resolution order: DB setting `backup_retention_count` → env var + // BACKUP_RETENTION_COUNT → 0 (keep all). Operator-controlled. + try { + let retention = 0; + try { + const db = require('./database'); + const dbVal = await db.getSetting('backup_retention_count'); + if (dbVal !== null && dbVal !== undefined && dbVal !== '') { + retention = parseInt(dbVal, 10); + } + } catch (_e) { /* DB unavailable — fall through to env */ } + if (!Number.isFinite(retention) || retention <= 0) { + retention = parseInt(process.env.BACKUP_RETENTION_COUNT, 10); + } + if (Number.isFinite(retention) && retention > 0) { + const pruneResult = pruneBackups(retention); + if (pruneResult.deleted.length) { + console.log(`[UPDATE] Pruned ${pruneResult.deleted.length} old backup(s) (retention=${retention})`); + } + } + } catch (err) { + console.warn(`[UPDATE] Auto-prune failed: ${err.message}`); + } + return { backupPath, backedUp }; } @@ -1033,6 +1058,28 @@ function restartService(serviceName) { } } +/** + * Recursively compute total size in bytes of a directory. + * Returns 0 on error so the UI can still render. + */ +function getDirectorySize(dirPath) { + let total = 0; + try { + const entries = fs.readdirSync(dirPath, { withFileTypes: true }); + for (const entry of entries) { + const full = path.join(dirPath, entry.name); + try { + if (entry.isDirectory()) { + total += getDirectorySize(full); + } else if (entry.isFile()) { + total += fs.statSync(full).size; + } + } catch (_e) { /* skip unreadable entry */ } + } + } catch (_e) { /* skip unreadable dir */ } + return total; +} + /** * List pre-update backups (newest first). */ @@ -1054,17 +1101,75 @@ function listBackups() { sha: (m.sha || '').slice(0, 7), timestamp: m.timestamp || '', filesBackedUp: m.filesBackedUp || 0, - fileCount: m.filesBackedUp || 0 + fileCount: m.filesBackedUp || 0, + sizeBytes: getDirectorySize(dir) }; }) .sort((a, b) => b.timestamp.localeCompare(a.timestamp)); } +/** + * Validate a backup directory name to prevent path traversal. + * Only allows the canonical `pre-update-{ISO-timestamp}` format. + */ +function isValidBackupName(name) { + return typeof name === 'string' && /^pre-update-[\d\-T]+$/.test(name); +} + +/** + * Recursively delete a directory. Refuses to delete anything outside + * BACKUP_DIR to defend against path-traversal bugs upstream. + */ +function deleteBackup(name) { + if (!isValidBackupName(name)) { + throw new Error('Invalid backup name'); + } + const target = path.resolve(BACKUP_DIR, name); + const root = path.resolve(BACKUP_DIR); + if (!target.startsWith(root + path.sep) && target !== root) { + throw new Error('Backup path is outside the backup directory'); + } + if (target === root) { + throw new Error('Refusing to delete the backup directory itself'); + } + if (!fs.existsSync(target)) { + throw new Error('Backup not found'); + } + fs.rmSync(target, { recursive: true, force: true }); + return { deleted: name }; +} + +/** + * Apply retention: keep the `keep` newest backups, delete older ones. + * keep <= 0 means "keep everything" (no-op). + */ +function pruneBackups(keep) { + const n = parseInt(keep, 10); + if (!Number.isFinite(n) || n <= 0) { + return { kept: -1, deleted: [] }; + } + const all = listBackups(); + if (all.length <= n) { + return { kept: n, deleted: [] }; + } + const toDelete = all.slice(n); + const deleted = []; + for (const b of toDelete) { + try { + deleteBackup(b.name); + deleted.push(b.name); + } catch (err) { + console.error(`[UPDATE] Failed to prune backup ${b.name}: ${err.message}`); + } + } + return { kept: n, deleted }; +} + /** * Restore console files from a pre-update backup and revert the SHA. */ function restoreFromBackup(backupName) { - if (!/^pre-update-[\d\-T]+$/.test(backupName)) throw new Error('Invalid backup name'); + if (!isValidBackupName(backupName)) throw new Error('Invalid backup name'); const backupPath = path.join(BACKUP_DIR, backupName); if (!fs.existsSync(backupPath)) throw new Error('Backup not found'); @@ -1096,6 +1201,8 @@ module.exports = { applyUpdate, restartService, listBackups, + deleteBackup, + pruneBackups, restoreFromBackup, getLocalVersion, getLocalSHA, diff --git a/web-nodejs/views/settings.ejs b/web-nodejs/views/settings.ejs index b262bd4a..cae15d48 100644 --- a/web-nodejs/views/settings.ejs +++ b/web-nodejs/views/settings.ejs @@ -753,6 +753,23 @@${_('updates.backups_desc')}
${_('common.loading')}