parrot-blackbox 2.0.6 → 2.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.0.6",
+  "version": "2.0.9",
   "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

@@ -10,6 +10,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execa, execaSync } from 'execa';
+import pc from 'picocolors';
 import { loadConfig, loadState, saveState, journal, hasCommandSync } from '../core/store.js';
 import { timeshiftDir, stateDir, configFile, manifestsDir } from '../core/paths.js';
 import { iso, clock } from '../core/time.js';
@@ -589,6 +590,15 @@ async function uploadViaBtrfsSend({ snapshot, subvolPath, parentSnapshot, parent
   const estimatedSize = await estimateSendSize(subvolPath, { parent: parentSubvolPath });
   const btrfsCfg = cfg.jobs.snapshots.btrfs || {};
 
+  // A missing parent means this is the unavoidable FULL baseline: `btrfs send -p`
+  // needs the parent subvolume to exist on disk, so there is no smaller option.
+  // Say so loudly BEFORE the upload starts — the wizard also confirmation-gates it.
+  if (!parentSubvolPath) {
+    console.log(pc.yellow('⚠  No parent snapshot available — this is a FULL baseline upload of the entire system subvolume.'));
+    console.log(pc.yellow(`   Estimated ${(estimatedSize / (1024 ** 3)).toFixed(1)} GiB raw — on a typical uplink this can take hours.`));
+    console.log(pc.yellow('   Once a snapshot is fully uploaded and kept, subsequent backups become small increments.'));
+  }
+
   console.log(`\n📤 Uploading ${parentSubvolPath ? 'incremental' : 'full'} BTRFS stream...`);
   console.log(`   Estimated size: ${(estimatedSize / (1024 ** 3)).toFixed(2)} GiB`);
   if (btrfsCfg.compression !== false) console.log(`   Compression: zstd enabled`);
@@ -834,6 +844,38 @@ export async function runSnapshotNow(cfg = loadConfig(), state = loadState(), op
   return runSnapshotBackup(cfg, state, { due, privileged: 'interactive', ...opts });
 }
 
+/**
+ * Decide whether the NEXT snapshot upload would be a small incremental (a
+ * fully-uploaded parent snapshot still exists on disk) or a FULL baseline send.
+ *
+ * Lightweight probe — it only lists local snapshots and reads local manifests;
+ * it never creates anything.  The wizard uses this to warn and confirm BEFORE
+ * a multi-hour full baseline upload is kicked off.
+ *
+ * @param {object} opts
+ * @param {object} [opts.cfg]                  config object (defaults to on-disk config)
+ * @param {'interactive'|'noninteractive'} [opts.privileged]
+ * @param {Array|null} [opts.localSnaps]         injectable snapshot list (tests)
+ * @param {string|null} [opts.manifestsDirOverride]  injectable manifests dir (tests)
+ * @returns {Promise<{full: boolean, parent: string|null, reason: string|null}>}
+ */
+export async function nextSnapshotUploadMode({ cfg = loadConfig(), privileged = 'noninteractive', localSnaps = null, manifestsDirOverride = null } = {}) {
+  const btrfsCfg = cfg?.jobs?.snapshots?.btrfs || {};
+  if (btrfsCfg.enabled === false || process.env.PBB_DISABLE_BTRFS) {
+    return { full: false, parent: null, reason: 'BTRFS streaming disabled — file-copy mode in use' };
+  }
+  if (btrfsCfg.incremental === false) {
+    return { full: false, parent: null, reason: 'incremental uploads disabled in config (full sends are intentional)' };
+  }
+
+  const snaps = localSnaps ?? (await listLocalSnapshots({ privileged }).catch(() => []));
+  const { findLastUploadedSnapshot } = await import('./btrfs-send.js');
+  const parent = findLastUploadedSnapshot(manifestsDirOverride || manifestsDir(), snaps);
+  return parent
+    ? { full: false, parent, reason: null }
+    : { full: true, parent: null, reason: 'no fully-uploaded parent snapshot on disk' };
+}
+
 export function timeshiftAvailable() {
   return hasCommandSync('timeshift');
 }

package/src/cli.js

@@ -19,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);
@@ -388,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) {
@@ -410,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) {

package/src/commands/manage.js

@@ -231,6 +231,7 @@ export async function runRepair({ auto = false } = {}) {
   }
 
   // 5. Optional npm reinstall (repair a broken CLI install)
+  let updated = false;
   if (!auto) {
     const want = await p.confirm({
       message: 'Reinstall parrot-blackbox from npm to repair the executable?',
@@ -239,10 +240,11 @@ export async function runRepair({ auto = false } = {}) {
     if (!p.isCancel(want) && want) {
       const { runSelfUpdate } = await import('../lib/self.js');
       p.log.step('Reinstalling from npm…');
-      const did = await runSelfUpdate({ force: true });
-      if (did) fixed.push('npm');
+      updated = await runSelfUpdate({ force: true });
+      if (updated) fixed.push('npm');
     }
   }
 
   p.outro(pc.green(fixed.length ? `Repair complete — fixed: ${fixed.join(', ')}.` : 'Nothing to repair — everything looks healthy.'));
+  return { updated };
 }

package/src/commands/wizard.js

@@ -17,18 +17,22 @@ import { guidedRemoteAdd } from './remote.js';
 import { listAccounts, refreshAccounts, poolSummary, addAccount, removeAccount } from '../storage/accounts.js';
 import { loadConfig, saveConfig } from '../core/store.js';
 import { runDueJobs } from '../daemon/scheduler.js';
-import { runSnapshotNow, listLocalSnapshots, deleteSnapshot, deleteAllSnapshots } from '../backup/snapshot.js';
+import { runSnapshotNow, listLocalSnapshots, deleteSnapshot, deleteAllSnapshots, nextSnapshotUploadMode } from '../backup/snapshot.js';
 import { listArtifacts } from '../storage/archive.js';
 import { restoreFiles, restoreSnapshot } from '../backup/restore.js';
 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, makeClackProgressRenderer } from '../util/misc.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 
+/** Set once a self-update happened inside THIS process — the wizard then
+ *  warns that it is still running the OLD code until restarted. */
+let updatedInSession = false;
+
 async function importSelf() {
   return import('../lib/self.js');
 }
@@ -38,7 +42,7 @@ async function autoUpdateCheck() {
   const { checkForUpdate, promptSelfUpdate } = await importSelf();
   try {
     const { outdated } = await checkForUpdate();
-    if (outdated) await promptSelfUpdate();
+    if (outdated && await promptSelfUpdate()) updatedInSession = true;
   } catch {
     /* offline / npm missing — never block the wizard on the update check */
   }
@@ -139,10 +143,23 @@ async function accountsMenu() {
 
 /** Run every enabled backup right now. */
 async function backupNowAction() {
-  const s = p.spinner();
-  s.start('Running backup…');
-  s.stop('');
-  const res = await runDueJobs({ force: true, privileged: 'interactive' });
+  p.log.message(pc.dim('Running backup…'));
+  const cfg = loadConfig();
+  // Warn BEFORE a FULL baseline snapshot upload (10s of GiB, hours long) is
+  // accidentally started from "Run all backups".
+  if (cfg.jobs?.snapshots?.enabled !== false) {
+    const mode = await nextSnapshotUploadMode({ cfg, privileged: 'interactive' });
+    if (mode.full) {
+      const ok = await p.confirm({
+        message: pc.red('⚠ No previous snapshot found — the snapshot backup will be a FULL baseline upload of the ENTIRE system (10s of GiB, can take hours). Continue?'),
+        initialValue: false,
+      });
+      if (p.isCancel(ok) || !ok) { p.log.message(pc.dim('Aborted — nothing was uploaded.')); return; }
+    }
+  }
+  const progress = makeClackProgressRenderer(p);
+  const res = await runDueJobs({ force: true, privileged: 'interactive', onProgress: progress });
+  progress.stop();
   const report = res.report || [];
   if (report.length === 0) { p.log.message(pc.dim('No enabled backup jobs.')); return; }
   for (const r of report) {
@@ -163,7 +180,22 @@ async function backupNowAction() {
 /** Create + upload a snapshot immediately. */
 async function snapshotNowAction() {
   try {
-    const r = await runSnapshotNow();
+    // A full baseline sends the ENTIRE system subvolume (10s of GiB, hours).
+    // Confirm BEFORE creating the snapshot so the user can back out cheaply.
+    const mode = await nextSnapshotUploadMode({ cfg: loadConfig(), privileged: 'interactive' });
+    if (mode.full) {
+      const ok = await p.confirm({
+        message: pc.red('⚠ No previous snapshot found — this will be a FULL baseline upload of the ENTIRE system (10s of GiB, can take hours). Continue?'),
+        initialValue: false,
+      });
+      if (p.isCancel(ok) || !ok) { p.log.message(pc.dim('Aborted — nothing was uploaded.')); return; }
+    } else if (mode.parent) {
+      p.log.message(pc.dim(`Incremental upload (parent: ${mode.parent}).`));
+    }
+
+    const progress = makeClackProgressRenderer(p);
+    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) {
@@ -233,7 +265,8 @@ async function deleteSnapshotsMenu() {
   // ── Delete ALL ─────────────────────────────────────────────────────────────
   if (pick === '__all') {
     const confirm = await p.confirm({
-      message: pc.red(`Delete ALL ${snapshots.length} local snapshot(s)? This cannot be undone.`),
+      message: pc.red(`Delete ALL ${snapshots.length} local snapshot(s)? This cannot be undone.`) +
+        pc.yellow(' No parent snapshot will remain — the NEXT backup becomes a FULL baseline upload of the entire system (10s of GiB, can take hours).'),
       initialValue: false,
     });
     if (p.isCancel(confirm) || !confirm) {
@@ -263,7 +296,8 @@ async function deleteSnapshotsMenu() {
 
   // ── Delete ONE ─────────────────────────────────────────────────────────────
   const confirm = await p.confirm({
-    message: pc.yellow(`Delete snapshot ${pc.bold(pick)}?`),
+    message: pc.yellow(`Delete snapshot ${pc.bold(pick)}?`) +
+      (snapshots.length === 1 ? pc.yellow(' This is the last snapshot — the next backup will be a FULL baseline upload.') : ''),
     initialValue: false,
   });
   if (p.isCancel(confirm) || !confirm) {
@@ -399,6 +433,14 @@ export async function runWizard() {
   await autoUpdateCheck();
 
   for (;;) {
+    // After an in-session self-update THIS process is still running the loaded
+    // (old) code — that's exactly the trap that makes uploads look silent in a
+    // stale session. Remind once per update so the user restarts.
+    if (updatedInSession) {
+      p.log.warn(`⚠ Updated earlier this session — this process still runs the OLD v${pkg.version} code. Exit and re-run \`parrot-blackbox\` to use the new version.`);
+      updatedInSession = false;
+    }
+
     const action = await p.select({
       message: 'What would you like to do?',
       options: [
@@ -444,8 +486,8 @@ export async function runWizard() {
         case 'setup': await runSetup(); break;
         case 'status': await runStatus(); break;
         case 'doctor': await runDoctor(); break;
-        case 'repair': { const { runRepair } = await import('./manage.js'); await runRepair(); break; }
-        case 'update': { const { runSelfUpdate } = await import('../lib/self.js'); await runSelfUpdate(); break; }
+        case 'repair': { const { runRepair } = await import('./manage.js'); const res = await runRepair(); if (res?.updated) updatedInSession = true; break; }
+        case 'update': { const { runSelfUpdate } = await import('../lib/self.js'); if (await runSelfUpdate()) updatedInSession = true; break; }
         case 'uninstall': await runUninstallWizard(); p.outro('parrot-blackbox removed — cloud backups are safe.'); return;
         default: break;
       }

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,111 @@ 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 buildLine({ 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}` : '';
+
+    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);
+      return `  [${bar}] ${String(pct).padStart(3)}%  ${doneMB.toFixed(1)} MB / ${totalMB.toFixed(1)} MB${speedStr}${destStr}`;
+    }
+    return `  ⬆  ${doneMB.toFixed(1)} MB streamed${speedStr}${destStr}`;
+  }
+
+  function render(evt = {}) {
+    const line = buildLine(evt);
+    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;
+}
+
+/**
+ * A @clack/prompts-aware progress renderer.
+ *
+ * Inside the clack wizard the terminal is managed by clack's ANSI cursor
+ * tracking — raw `\r` writes get clobbered.  This variant throttles output
+ * to at most one `p.log.message()` call per second so clack can handle
+ * rendering, and the bar stays readable.
+ *
+ * Usage:
+ *   import * as p from '@clack/prompts';
+ *   const progress = makeClackProgressRenderer(p);
+ *   await runSnapshotNow(undefined, undefined, { onProgress: progress });
+ *   progress.stop();
+ *
+ * Expected event shape: same as makeProgressRenderer().
+ */
+export function makeClackProgressRenderer(p) {
+  const BAR_WIDTH = 20;
+  const THROTTLE_MS = 800; // max one clack log line per 800 ms
+  let lastEmitAt = 0;
+  let lastLine = '';
+
+  function buildLine({ 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}` : '';
+
+    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);
+      return `[${bar}] ${String(pct).padStart(3)}%  ${doneMB.toFixed(1)} / ${totalMB.toFixed(1)} MB${speedStr}${destStr}`;
+    }
+    return `⬆  ${doneMB.toFixed(1)} MB streamed${speedStr}${destStr}`;
+  }
+
+  function render(evt = {}) {
+    const now  = Date.now();
+    const line = buildLine(evt);
+    if (line === lastLine) return;           // nothing changed
+    if (now - lastEmitAt < THROTTLE_MS) return; // too soon
+    lastEmitAt = now;
+    lastLine   = line;
+    p.log.message(line);
+  }
+
+  render.stop = function stop() {
+    // emit the final state unconditionally so the user sees 100% or final MB
+    if (lastLine) p.log.message(lastLine);
+    lastLine = '';
+  };
+
+  return render;
 }