parrot-blackbox 2.0.5 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Crash-proof, multi-cloud backup & recovery automation for Parrot OS. Daily/weekly off-disk backups with automatic catch-up, smart storage across many MEGA + Google Drive accounts, Timeshift snapshot backups and one-command restore.",
   "type": "module",
   "main": "src/cli.js",

package/src/backup/snapshot.js

@@ -259,6 +259,31 @@ export async function deleteAllSnapshots({ privileged = 'interactive', onProgres
 
   return { deleted, failed };
 }
+/**
+ * A module-level registry of all temporary BTRFS mounts created during this
+ * process lifetime, so we can unmount them all at exit even if the snapshot
+ * object that originally held the reference was garbage-collected.
+ */
+const _activeTempMounts = new Set();
+
+/**
+ * Unmount and remove all temporary BTRFS mount points created by this process.
+ * Called on process exit and also by cleanupSnapshotMount.
+ */
+function _cleanupAllTempMounts() {
+  for (const mp of _activeTempMounts) {
+    try { sudoExecSync(['umount', mp]); } catch { /* best effort */ }
+    try { sudoExecSync(['rmdir', mp]); } catch { /* best effort */ }
+    _activeTempMounts.delete(mp);
+  }
+}
+
+// Register a process exit handler so stale mounts are always cleaned up,
+// even if the snapshot object holding _tempMount was discarded before cleanup.
+process.on('exit', _cleanupAllTempMounts);
+// Also handle abnormal exits so the mount isn't left behind after Ctrl+C
+// (SIGINT/SIGTERM handlers in cli.js call process.exit(), which fires 'exit').
+
 /**
  * Resolve the on-disk directory of a snapshot.
  * 
@@ -270,6 +295,11 @@ export async function deleteAllSnapshots({ privileged = 'interactive', onProgres
  * 2. Check static paths (rsync mode)
  * 3. Mount the BTRFS root subvolume ourselves to access snapshots persistently
  * 4. Fall back to triggering timeshift --list
+ *
+ * IMPORTANT: the mount point is registered in _activeTempMounts so that
+ * _cleanupAllTempMounts() can release it on process exit even if the snapshot
+ * object is later discarded (e.g. after a resume-upload path that builds a new
+ * snapshot object from just the name).
  */
 export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {}) {
   if (snapshot.dir && fs.existsSync(snapshot.dir)) return snapshot.dir;
@@ -301,6 +331,9 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
       const mountResult = sudoExecSync(['mount', '-o', 'subvolid=5', device, mountPoint]);
       
       if (mountResult.exitCode === 0) {
+        // Register in the global set so it is always cleaned up on exit.
+        _activeTempMounts.add(mountPoint);
+
         // Search for the snapshot in the mounted root subvolume
         const searchPaths = [
           `${mountPoint}/timeshift-btrfs/snapshots/${snapshot.name}`,
@@ -311,12 +344,13 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
         const found = searchPaths.find((p) => fs.existsSync(p));
         
         if (found) {
-          // Store the mount point for cleanup later
+          // Store the mount point on the snapshot object for explicit early cleanup.
           snapshot._tempMount = mountPoint;
           return found;
         }
         
-        // Unmount if we didn't find anything
+        // Unmount immediately if we didn't find anything useful.
+        _activeTempMounts.delete(mountPoint);
         sudoExecSync(['umount', mountPoint]);
         sudoExecSync(['rmdir', mountPoint]);
       }
@@ -332,13 +366,15 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
 /** Cleanup temporary BTRFS mount if one was created */
 export function cleanupSnapshotMount(snapshot) {
   if (snapshot && snapshot._tempMount) {
+    const mp = snapshot._tempMount;
     try {
-      sudoExecSync(['umount', snapshot._tempMount]);
-      sudoExecSync(['rmdir', snapshot._tempMount]);
-      delete snapshot._tempMount;
+      sudoExecSync(['umount', mp]);
+      sudoExecSync(['rmdir', mp]);
     } catch {
       /* best effort */
     }
+    _activeTempMounts.delete(mp);
+    delete snapshot._tempMount;
   }
 }
 
@@ -523,11 +559,30 @@ export async function runSnapshotBackup(cfg, state, { due, privileged = 'noninte
  * `btrfs send` always receives a real subvolume, never a plain directory.
  */
 async function uploadViaBtrfsSend({ snapshot, subvolPath, parentSnapshot, parentSubvolPath, accounts, cfg, due, privileged, onProgress }) {
-  const { createSendStream, estimateSendSize, isValidBtrfsStreamManifest } = await import('./btrfs-send.js');
+  const { createSendStream, estimateSendSize, isValidBtrfsStreamManifest, isSubvolumeReadOnly, setSubvolumeReadOnly } = await import('./btrfs-send.js');
   const { planAndPlaceStream } = await import('../storage/allocator.js');
 
   if (!subvolPath) throw new Error('no BTRFS subvolume path for snapshot upload');
 
+  // ── RO guard ──────────────────────────────────────────────────────────────
+  // btrfs send requires the subvolume to be read-only (ro=true). Timeshift
+  // always creates snapshots as RO, but when they are accessed via a
+  // subvolid=5 bind-mount the kernel may report the inner @ subvolume as
+  // rw=false (writable) depending on mount flags. Detect and fix this before
+  // handing the path to btrfs send, otherwise the send exits 1 with
+  // "subvolume … is not read-only".
+  const isRO = await isSubvolumeReadOnly(subvolPath, { privileged });
+  if (!isRO) {
+    journal('snapshots', `subvolume ${subvolPath} is not read-only — setting ro=true before send`);
+    try {
+      await setSubvolumeReadOnly(subvolPath, true, { privileged });
+      journal('snapshots', `set ${subvolPath} read-only OK`);
+    } catch (e) {
+      throw new Error(`btrfs send requires a read-only subvolume but ${subvolPath} is writable and could not be set read-only: ${e.message}`);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+
   journal('snapshots', `btrfs send subvolPath=${subvolPath} parent=${parentSubvolPath || 'null'}`);
 
   // Estimate size for progress reporting

package/src/cli.js

@@ -2,6 +2,8 @@ import { defineCommand, runMain } from 'citty';
 import pc from 'picocolors';
 import * as p from '@clack/prompts';
 import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
 import { runSetup } from './commands/setup.js';
 import { runWizard } from './commands/wizard.js';
 import { runRepair } from './commands/manage.js';
@@ -17,7 +19,7 @@ import { listAccounts, addAccount, removeAccount, refreshAccounts, poolSummary }
 import { listArtifacts } from './storage/archive.js';
 import { loadConfig, loadState, saveConfig } from './core/store.js';
 import { configFile, stateDir } from './core/paths.js';
-import { bytesHuman } from './util/misc.js';
+import { bytesHuman, makeProgressRenderer } from './util/misc.js';
 import { isOnline } from './util/network.js';
 
 const require = createRequire(import.meta.url);
@@ -386,7 +388,9 @@ const main = defineCommand({
       case 'force':
       case 'backup': {
         // Runs every ENABLED job right now (default = the weekly snapshot).
-        const res = await runDueJobs({ force: true, privileged: 'interactive' });
+        const progress = makeProgressRenderer();
+        const res = await runDueJobs({ force: true, privileged: 'interactive', onProgress: progress });
+        progress.stop();
         const report = res.report || [];
         if (report.length === 0) console.log(pc.dim('No enabled backup jobs — run `parrot-blackbox` to set up the schedule.'));
         for (const r of report) {
@@ -408,7 +412,9 @@ const main = defineCommand({
         const [sub, ...args] = rest;
         if (sub === 'now' || sub === 'create' || sub === 'force') {
           try {
-            const r = await runSnapshotNow();
+            const progress = makeProgressRenderer();
+            const r = await runSnapshotNow(undefined, undefined, { onProgress: progress });
+            progress.stop();
             console.log(`${pc.green('✔')} Snapshot ${r.snapshot} created & uploaded (${bytesHuman(r.manifest.totalSize)}).`);
             if (r.pruned?.length) console.log(pc.dim(`Pruned: ${r.pruned.join(', ')}`));
           } catch (e) {
@@ -667,7 +673,7 @@ const main = defineCommand({
             });
           }
           s.stop('✔ Upload complete');
-          import('node:fs').then(fs => fs.writeFileSync(outPath, JSON.stringify(manifest)));
+          fs.writeFileSync(outPath, JSON.stringify(manifest));
           process.exitCode = 0;
         } catch (e) {
           s.stop('✖ Upload failed');
@@ -677,16 +683,12 @@ const main = defineCommand({
           // If we are running as root via sudo, rclone might have refreshed OAuth tokens
           // and rewritten rclone.conf as root:root. Restore ownership to the real user.
           if (process.getuid && process.getuid() === 0 && process.env.SUDO_UID && process.env.SUDO_GID) {
-            import('node:fs').then(fs => {
-              import('node:path').then(path => {
-                const confPath = path.join(process.env.HOME, '.config', 'rclone', 'rclone.conf');
-                if (fs.existsSync(confPath)) {
-                  try {
-                    fs.chownSync(confPath, parseInt(process.env.SUDO_UID, 10), parseInt(process.env.SUDO_GID, 10));
-                  } catch { /* best effort */ }
-                }
-              });
-            });
+            const confPath = path.join(process.env.HOME, '.config', 'rclone', 'rclone.conf');
+            if (fs.existsSync(confPath)) {
+              try {
+                fs.chownSync(confPath, parseInt(process.env.SUDO_UID, 10), parseInt(process.env.SUDO_GID, 10));
+              } catch { /* best effort */ }
+            }
           }
         }
         return;
@@ -702,4 +704,11 @@ const main = defineCommand({
         process.exitCode = 1;
     }
   },
-});runMain(main);
+});
+
+runMain(main).then(() => {
+  // Force the process to exit cleanly regardless of any open file descriptors or
+  // kernel mounts left by subvolid=5 bind-mounts created in snapshotDirFor.
+  // process.on('exit') in snapshot.js will unmount them before we terminate.
+  process.exit(process.exitCode ?? 0);
+});

package/src/commands/wizard.js

@@ -24,7 +24,7 @@ import { installService, removeService } from './service.js';
 import { startDaemon, stopDaemon, daemonRunning } from '../daemon/daemon.js';
 import { runDoctor, runStatus, runUninstallWizard } from './manage.js';
 import { runSetup } from './setup.js';
-import { bytesHuman } from '../util/misc.js';
+import { bytesHuman, makeProgressRenderer } from '../util/misc.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
@@ -163,7 +163,9 @@ async function backupNowAction() {
 /** Create + upload a snapshot immediately. */
 async function snapshotNowAction() {
   try {
-    const r = await runSnapshotNow();
+    const progress = makeProgressRenderer();
+    const r = await runSnapshotNow(undefined, undefined, { onProgress: progress });
+    progress.stop();
     p.log.success(`✔ Snapshot ${r.snapshot} created & uploaded (${bytesHuman(r.manifest?.totalSize ?? 0)}).`);
     if (r.pruned?.length) p.log.message(pc.dim(`Pruned: ${r.pruned.join(', ')}`));
   } catch (e) {

package/src/storage/allocator.js

@@ -269,6 +269,12 @@ export async function planAndPlaceStream(btrfsStream, { kind, id, accounts, remo
   let locs = [];
   let currentStart = 0;
   let target = getNextAccountAndPath();
+
+  // Speed tracking
+  let speedBytesWindow = 0;
+  let speedWindowStart = Date.now();
+  let currentSpeedMBs = 0;
+  const SPEED_WINDOW_MS = 1500; // recalculate speed every 1.5 s
   
   currentChild = spawn(process.env.PBB_RCLONE || 'rclone', ['rcat', `${target.remote}:${target.path}`]);
   let childFailed = false;
@@ -287,6 +293,7 @@ export async function planAndPlaceStream(btrfsStream, { kind, id, accounts, remo
       
       currentBytesInChunk += toWrite;
       totalBytes += toWrite;
+      speedBytesWindow += toWrite;
       offset += toWrite;
       
       if (!canContinue) {
@@ -309,7 +316,24 @@ export async function planAndPlaceStream(btrfsStream, { kind, id, accounts, remo
         currentChild.on('exit', (code) => { if (code !== 0) childFailed = true; });
       }
     }
-    if (onProgress) onProgress({ done: totalBytes, total: originalSize, text: `uploading stream: ${(totalBytes / (1024**2)).toFixed(1)} MB` });
+
+    // Recalculate speed on each chunk and emit progress
+    if (onProgress) {
+      const now = Date.now();
+      const elapsed = now - speedWindowStart;
+      if (elapsed >= SPEED_WINDOW_MS) {
+        currentSpeedMBs = (speedBytesWindow / (1024 * 1024)) / (elapsed / 1000);
+        speedBytesWindow = 0;
+        speedWindowStart = now;
+      }
+      onProgress({
+        done: totalBytes,
+        total: originalSize,
+        speedMBs: currentSpeedMBs,
+        remote: target.remote,
+        text: `uploading stream: ${(totalBytes / (1024 ** 2)).toFixed(1)} MB`,
+      });
+    }
   }
   
   if (currentChild) {

package/src/util/misc.js

@@ -111,4 +111,54 @@ export function shellQuote(s) {
 
 export function pad2(n) {
   return String(n).padStart(2, '0');
+}
+
+/**
+ * Returns an onProgress handler that renders a live, in-place progress bar
+ * with percentage, MB transferred, and upload speed.
+ *
+ * Expected event shape:
+ *   { done: number (bytes), total: number (bytes or 0), speedMBs?: number, remote?: string }
+ *
+ * Call renderer.stop() when done to advance to the next line.
+ *
+ * When `total` is 0 (stream size unknown) we display bytes + speed only.
+ */
+export function makeProgressRenderer() {
+  const isTTY = process.stdout.isTTY;
+  const BAR_WIDTH = 25;
+  let lastLine = '';
+
+  function render({ done = 0, total = 0, speedMBs = 0, remote = '' } = {}) {
+    const doneMB = done / (1024 * 1024);
+    const totalMB = total / (1024 * 1024);
+    const speedStr = speedMBs > 0 ? `  ${speedMBs.toFixed(1)} MB/s` : '';
+    const destStr  = remote ? `  → ${remote}` : '';
+
+    let line;
+    if (total > 0) {
+      const pct    = Math.min(100, Math.round((done / total) * 100));
+      const filled = Math.round((pct / 100) * BAR_WIDTH);
+      const bar    = '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
+      line = `  [${bar}] ${String(pct).padStart(3)}%  ${doneMB.toFixed(1)} MB / ${totalMB.toFixed(1)} MB${speedStr}${destStr}`;
+    } else {
+      line = `  ⬆  ${doneMB.toFixed(1)} MB streamed${speedStr}${destStr}`;
+    }
+
+    if (isTTY) {
+      process.stdout.write(`\r${line}\x1b[K`);
+    } else if (line !== lastLine) {
+      // Non-TTY (piped / daemon log): only emit when something changes to
+      // avoid flooding the journal with thousands of identical lines.
+      process.stdout.write(line + '\n');
+    }
+    lastLine = line;
+  }
+
+  render.stop = function stop() {
+    if (isTTY && lastLine) process.stdout.write('\n');
+    lastLine = '';
+  };
+
+  return render;
 }