parrot-blackbox 2.0.7 → 2.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.0.7",
+  "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/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, makeProgressRenderer } 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,20 @@ async function backupNowAction() {
 /** Create + upload a snapshot immediately. */
 async function snapshotNowAction() {
   try {
-    const progress = makeProgressRenderer();
+    // 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)}).`);
@@ -235,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) {
@@ -265,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) {
@@ -401,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: [
@@ -446,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/util/misc.js

@@ -129,22 +129,23 @@ export function makeProgressRenderer() {
   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);
+  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}` : '';
 
-    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}`;
+      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) {
@@ -160,5 +161,61 @@ export function makeProgressRenderer() {
     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;
 }