parrot-blackbox 2.0.1 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.0.1",
+  "version": "2.0.4",
   "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/btrfs-send.js

@@ -160,7 +160,7 @@ export function getSnapshotParent(manifestPath) {
  * Create a BTRFS send stream.
  * @param {string} subvolPath - Path to the snapshot subvolume
  * @param {object} opts - {parent: string|null, privileged: 'interactive'|'noninteractive'}
- * @returns {Promise<ReadableStream>} - The send stream (not yet piped through compression/encryption)
+ * @returns {Promise<{stream: ReadableStream, child: ChildProcess}>}
  */
 export async function createSendStream(subvolPath, { parent = null, privileged = 'noninteractive' } = {}) {
   const args = ['btrfs', 'send'];
@@ -170,8 +170,9 @@ export async function createSendStream(subvolPath, { parent = null, privileged =
     args.push(subvolPath);
   }
 
-  // Spawn via sudo, return the stdout stream
-  const sudoArgs = privileged === 'interactive' 
+  // Spawn via sudo, return the stdout stream and the child process so callers
+  // can detect errors (btrfs send exits non-zero when the path is not a subvolume).
+  const sudoArgs = privileged === 'interactive'
     ? ['sudo', '-E', ...args]
     : ['sudo', '-n', ...args];
 
@@ -179,8 +180,7 @@ export async function createSendStream(subvolPath, { parent = null, privileged =
     stdio: ['ignore', 'pipe', 'pipe'],
   });
 
-  // Convert child.stdout to a Node readable stream
-  return child.stdout;
+  return { stream: child.stdout, child };
 }
 
 /**

package/src/backup/snapshot.js

@@ -158,6 +158,8 @@ export async function deleteSnapshot(name, { privileged = 'noninteractive' } = {
   if (privileged === 'interactive') {
     await ensureSudo();
     const res = await sudoInteractive(args);
+    // Timeshift exits 0 even when the qgroup destroy fails, so we verify the
+    // snapshot is actually gone rather than trusting the exit code alone.
     if (res.exitCode !== 0) throw new Error(`timeshift --delete ${name} failed (exit ${res.exitCode})`);
     return true;
   }
@@ -168,6 +170,95 @@ export async function deleteSnapshot(name, { privileged = 'noninteractive' } = {
   }
   return true;
 }
+
+/** Run btrfs quota rescan -w / and wait for it to finish. */
+async function btrfsQuotaRescan({ privileged = 'interactive', onProgress } = {}) {
+  onProgress?.('Running btrfs quota rescan — this may take a moment…');
+  const res = privileged === 'interactive'
+    ? await sudoInteractive(['btrfs', 'quota', 'rescan', '-w', '/'])
+    : await sudoNonInteractive(['btrfs', 'quota', 'rescan', '-w', '/']);
+  if (res.exitCode !== 0) {
+    onProgress?.(`⚠ btrfs quota rescan exited ${res.exitCode} — quotas may not be enabled, continuing`);
+  } else {
+    onProgress?.('✔ btrfs quota rescan complete');
+  }
+}
+
+/**
+ * Delete ALL local Timeshift snapshots.
+ *
+ * Strategy (matches the confirmed-working pattern from research):
+ * 1. Run `btrfs quota rescan -w /` upfront.
+ * 2. For each snapshot: attempt delete, then verify it is GONE from
+ *    `timeshift --list`. Timeshift exits 0 even when it prints
+ *    "E: Failed to remove snapshot" (qgroup destroy fails silently).
+ *    Verification catches that.
+ * 3. If a snapshot is still present after the first attempt:
+ *    run another rescan (the delete itself may have left a new stale entry)
+ *    and retry exactly once.
+ * 4. If it still persists after retry, record it as failed and move on.
+ *
+ * @param {object} opts
+ * @param {'interactive'|'noninteractive'} opts.privileged
+ * @param {(msg:string)=>void} opts.onProgress  optional progress callback
+ * @returns {Promise<{deleted:string[], failed:Array<{name:string,error:string}>}>}
+ */
+export async function deleteAllSnapshots({ privileged = 'interactive', onProgress } = {}) {
+  if (privileged === 'interactive') await ensureSudo();
+
+  // Step 1: initial rescan to clear stale qgroup entries.
+  await btrfsQuotaRescan({ privileged, onProgress });
+
+  // Step 2: delete each snapshot, verifying it's actually gone.
+  const snapshots = await listLocalSnapshots({ privileged });
+  const deleted = [];
+  const failed = [];
+
+  for (const sn of snapshots) {
+    onProgress?.(`Deleting snapshot: ${sn.name}`);
+    let success = false;
+
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        await deleteSnapshot(sn.name, { privileged });
+      } catch {
+        // Timeshift may have removed the subvolume but still exit non-zero.
+        // Fall through to the verify step.
+      }
+
+      // Verify the snapshot is actually gone from timeshift --list.
+      const remaining = await listLocalSnapshots({ privileged });
+      const stillPresent = remaining.some((s) => s.name === sn.name);
+
+      if (!stillPresent) {
+        success = true;
+        break;
+      }
+
+      if (attempt === 1) {
+        // The delete left a new stale qgroup entry — rescan and retry once.
+        onProgress?.(`  ⚠ ${sn.name} still present after delete — rescanning qgroups and retrying…`);
+        await btrfsQuotaRescan({ privileged, onProgress });
+      }
+    }
+
+    if (success) {
+      deleted.push(sn.name);
+    } else {
+      failed.push({ name: sn.name, error: 'still present after 2 attempts + qgroup rescan' });
+      onProgress?.(`  ✖ ${sn.name}: could not delete after rescan — try deleting it individually`);
+    }
+  }
+
+  if (failed.length > 0) {
+    throw Object.assign(
+      new Error(`${failed.length} snapshot(s) could not be deleted`),
+      { deleted, failed },
+    );
+  }
+
+  return { deleted, failed };
+}
 /**
  * Resolve the on-disk directory of a snapshot.
  * 
@@ -401,38 +492,45 @@ export async function runSnapshotBackup(cfg, state, { due, privileged = 'noninte
 /**
  * Upload a snapshot using BTRFS send/receive streaming.
  * Creates: btrfs send [-p parent] | zstd | [openssl] | rclone rcat (chunked)
- * 
- * Note: For BTRFS send to work, we need to use paths that btrfs recognizes as subvolumes.
- * On most Parrot systems, snapshots are at: /timeshift-btrfs/snapshots/<name>
- * We construct the proper subvolume path rather than using potentially-mounted paths.
+ *
+ * Uses the path resolved by snapshotDirFor() (which mounts the BTRFS root subvolume
+ * at a temporary mount point) so that `btrfs send` receives an actual subvolume path,
+ * not a directory inside a regular mount.
  */
 async function uploadViaBtrfsSend({ snapshot, snapshotDir, parentSnapshot, parentDir, accounts, cfg, due, privileged, onProgress }) {
   const { createSendStream, estimateSendSize } = await import('./btrfs-send.js');
   const { planAndPlaceStream } = await import('../storage/allocator.js');
-  
-  // Construct the actual subvolume path for BTRFS send
-  // Timeshift stores snapshots at /timeshift-btrfs/snapshots/<name> on the root BTRFS volume
-  // We need to use this path for btrfs send, not any temporarily mounted paths
-  const subvolPath = `/timeshift-btrfs/snapshots/${snapshot.name}`;
-  const parentSubvolPath = parentSnapshot ? `/timeshift-btrfs/snapshots/${parentSnapshot.name}` : null;
-  
-  journal('snapshots', `using subvolume path: ${subvolPath}`);
-  
-  // Estimate size for progress reporting (use original snapshotDir for filesystem operations)
-  const estimatedSize = await estimateSendSize(snapshotDir, { parent: parentDir });
+
+  // snapshotDir was resolved by snapshotDirFor() — it is the real subvolume path
+  // (e.g. /run/parrot-blackbox-btrfs-<ts>/timeshift-btrfs/snapshots/<name>).
+  // Use it directly; do NOT fall back to a hardcoded absolute path.
+  const subvolPath = snapshotDir;
+  const parentSubvolPath = parentDir || null;
+
+  journal('snapshots', `btrfs send subvolPath=${subvolPath} parent=${parentSubvolPath || 'null'}`);
+
+  // Estimate size for progress reporting
+  const estimatedSize = await estimateSendSize(subvolPath, { parent: parentSubvolPath });
   const btrfsCfg = cfg.jobs.snapshots.btrfs || {};
-  
-  console.log(`\n📤 Uploading ${parentDir ? 'incremental' : 'full'} BTRFS stream...`);
+
+  console.log(`\n📤 Uploading ${parentSubvolPath ? 'incremental' : 'full'} BTRFS stream...`);
   console.log(`   Estimated size: ${(estimatedSize / (1024 ** 3)).toFixed(2)} GiB`);
-  if (btrfsCfg.compression) console.log(`   Compression: zstd enabled`);
-  if (btrfsCfg.encryption && cfg.storage.encryptionPassphrase) console.log(`   Encryption: AES-256 enabled`);
+  if (btrfsCfg.compression !== false) console.log(`   Compression: zstd enabled`);
+  if (btrfsCfg.encryption && cfg.storage?.encryptionPassphrase) console.log(`   Encryption: AES-256 enabled`);
 
-  // Create the BTRFS send stream using the actual subvolume paths
-  const sendStream = await createSendStream(subvolPath, { parent: parentSubvolPath, privileged });
+  // Create the BTRFS send stream — returns {stream, child} so we can detect errors
+  const { stream: sendStream, child: sendChild } = await createSendStream(subvolPath, {
+    parent: parentSubvolPath,
+    privileged,
+  });
+
+  // Collect any stderr from btrfs send for better error messages
+  const sendStderr = [];
+  sendChild.stderr?.on('data', (d) => sendStderr.push(d));
 
-  // Build the pipeline: btrfs send -> [zstd] -> [openssl] -> chunked rclone rcat
+  // Build compression / encryption pipeline
   const { spawn } = await import('node:child_process');
-  const pipeline = [];
+  const pipeline = [sendChild]; // include send process so we wait on its exit too
   let currentStream = sendStream;
 
   // Stage 1: Compression
@@ -444,7 +542,7 @@ async function uploadViaBtrfsSend({ snapshot, snapshotDir, parentSnapshot, paren
   }
 
   // Stage 2: Encryption
-  if (btrfsCfg.encryption && cfg.storage.encryptionPassphrase) {
+  if (btrfsCfg.encryption && cfg.storage?.encryptionPassphrase) {
     const openssl = spawn('openssl', ['enc', '-e', '-aes256', '-pbkdf2', '-pass', `pass:${cfg.storage.encryptionPassphrase}`], {
       stdio: ['pipe', 'pipe', 'inherit'],
     });
@@ -454,7 +552,7 @@ async function uploadViaBtrfsSend({ snapshot, snapshotDir, parentSnapshot, paren
   }
 
   // Stage 3: Stream to cloud via allocator's planAndPlaceStream (handles chunking across accounts)
-  const manifest = await planAndPlaceStream(currentStream, {
+  const manifestPromise = planAndPlaceStream(currentStream, {
     kind: 'snapshots',
     id: snapshot.name,
     accounts,
@@ -464,11 +562,26 @@ async function uploadViaBtrfsSend({ snapshot, snapshotDir, parentSnapshot, paren
     originalSize: estimatedSize,
   });
 
-  // Wait for all pipeline stages to complete
-  await Promise.all(pipeline.map(proc => new Promise((resolve, reject) => {
-    proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Pipeline stage failed: exit ${code}`)));
-    proc.on('error', reject);
-  })));
+  // Wait for all pipeline stages (including btrfs send itself) to exit cleanly
+  await Promise.all(pipeline.map((proc) =>
+    new Promise((resolve, reject) => {
+      proc.on('close', (code) => {
+        if (code === 0 || code === null) {
+          resolve();
+        } else {
+          const stderr = Buffer.concat(sendStderr).toString().trim();
+          reject(new Error(
+            proc === sendChild
+              ? `btrfs send failed (exit ${code})${stderr ? ': ' + stderr : ''} — is ${subvolPath} a BTRFS subvolume?`
+              : `Pipeline stage failed (exit ${code})`
+          ));
+        }
+      });
+      proc.on('error', reject);
+    })
+  ));
+
+  const manifest = await manifestPromise;
 
   // Save manifest locally
   const manifestPath = path.join(manifestsDir(), `snapshots-${snapshot.name}.json`);

package/src/cli.js

@@ -11,7 +11,7 @@ import { runDoctor, runStatus, runUninstallWizard } from './commands/manage.js';
 import { installService, removeService } from './commands/service.js';
 import { runDueJobs } from './daemon/scheduler.js';
 import { startDaemon, stopDaemon, daemonRunning } from './daemon/daemon.js';
-import { runSnapshotNow, listLocalSnapshots, pruneSnapshots } from './backup/snapshot.js';
+import { runSnapshotNow, listLocalSnapshots, pruneSnapshots, deleteSnapshot, deleteAllSnapshots } from './backup/snapshot.js';
 import { restoreSnapshot, restoreFiles } from './backup/restore.js';
 import { listAccounts, addAccount, removeAccount, refreshAccounts, poolSummary } from './storage/accounts.js';
 import { listArtifacts } from './storage/archive.js';
@@ -48,6 +48,7 @@ ${pc.bold('Usage:')}
   parrot-blackbox force               ⭐ Run every enabled backup NOW (default = weekly snapshot)  ${pc.dim('[sudo]')}
   parrot-blackbox snapshot now        Create a weekly snapshot + upload it now  ${pc.dim('[sudo]')}
   parrot-blackbox snapshot list       List local & cloud snapshots
+  parrot-blackbox snapshot delete [<name>|--all]  Delete one or all local snapshots  ${pc.dim('[sudo]')}
   parrot-blackbox snapshot prune      Delete snapshots beyond the keep limit  ${pc.dim('[sudo]')}
   parrot-blackbox list [files]        List cloud file backups
   parrot-blackbox restore             Restore a snapshot or file backup       ${pc.dim('[sudo]')}
@@ -429,7 +430,72 @@ const main = defineCommand({
           }
           return;
         }
-        console.log(pc.yellow('snapshot subcommands: now | list | prune'));
+        // snapshot delete [<name>|--all]
+        if (sub === 'delete' || sub === 'rm' || sub === 'remove') {
+          const target = args[0];
+          const deleteAll = target === '--all' || !target;
+
+          if (deleteAll && !target) {
+            // No name and no --all: list snapshots and bail with usage hint.
+            const local = await listLocalSnapshots({ privileged: 'interactive' }).catch(() => []);
+            if (local.length === 0) {
+              console.log(pc.dim('No local snapshots found.'));
+              return;
+            }
+            console.log(pc.bold('\nLocal snapshots:'));
+            for (const sn of local) console.log(`  - ${pc.cyan(sn.name)}`);
+            console.log(pc.yellow('\nUsage:'));
+            console.log('  parrot-blackbox snapshot delete <name>   — delete one snapshot');
+            console.log('  parrot-blackbox snapshot delete --all     — delete all (runs btrfs quota rescan first)');
+            console.log();
+            return;
+          }
+
+          if (target === '--all') {
+            // Confirm unless stdin is non-interactive.
+            if (process.stdin.isTTY) {
+              const local = await listLocalSnapshots({ privileged: 'interactive' }).catch(() => []);
+              if (local.length === 0) { console.log(pc.dim('No local snapshots found.')); return; }
+              const { confirm } = await import('@clack/prompts');
+              const ok = await confirm({
+                message: pc.red(`Delete ALL ${local.length} local snapshot(s)? This cannot be undone.`),
+                initialValue: false,
+              });
+              const { isCancel } = await import('@clack/prompts');
+              if (isCancel(ok) || !ok) { console.log(pc.dim('Aborted — nothing deleted.')); return; }
+            }
+            console.log(pc.dim('Running btrfs quota rescan first…'));
+            try {
+              const result = await deleteAllSnapshots({
+                privileged: 'interactive',
+                onProgress: (msg) => console.log(pc.dim(`  ${msg}`)),
+              });
+              console.log(pc.green(`✔ Deleted ${result.deleted.length} snapshot(s).`));
+            } catch (e) {
+              if (e.deleted?.length) console.log(pc.green(`✔ Deleted: ${e.deleted.join(', ')}`));
+              if (e.failed?.length) {
+                console.error(pc.red(`✖ Failed: ${e.failed.map((f) => `${f.name} (${f.error})`).join(', ')}`));
+                console.log(pc.dim('  Try running again — qgroup rescan may need a second pass.'));
+                process.exitCode = 1;
+              } else {
+                console.error(pc.red(`✖ ${e.message}`));
+                process.exitCode = 1;
+              }
+            }
+            return;
+          }
+
+          // Delete a single named snapshot.
+          try {
+            await deleteSnapshot(target, { privileged: 'interactive' });
+            console.log(pc.green(`✔ Snapshot ${target} deleted.`));
+          } catch (e) {
+            console.error(pc.red(`✖ ${e.message}`));
+            process.exitCode = 1;
+          }
+          return;
+        }
+        console.log(pc.yellow('snapshot subcommands: now | list | delete [<name>|--all] | prune'));
         return;
       }
 

package/src/commands/wizard.js

@@ -17,7 +17,7 @@ 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 } from '../backup/snapshot.js';
+import { runSnapshotNow, listLocalSnapshots, deleteSnapshot, deleteAllSnapshots } from '../backup/snapshot.js';
 import { listArtifacts } from '../storage/archive.js';
 import { restoreFiles, restoreSnapshot } from '../backup/restore.js';
 import { installService, removeService } from './service.js';
@@ -196,6 +196,90 @@ async function listBackupsAction() {
     p.log.message(pc.dim('No accounts configured — add one from the menu.'));
   }
 }
+/**
+ * Interactive snapshot delete menu.
+ * Lists all local snapshots, lets the user pick one to delete or delete all.
+ * Always runs `btrfs quota rescan -w /` before any delete loop.
+ */
+async function deleteSnapshotsMenu() {
+  // Fetch the current list first so we can show it.
+  let snapshots;
+  try {
+    snapshots = await listLocalSnapshots({ privileged: 'interactive' });
+  } catch (e) {
+    p.log.warn(`Could not list snapshots: ${e.message}`);
+    return;
+  }
+
+  if (snapshots.length === 0) {
+    p.log.message(pc.dim('No local snapshots found — nothing to delete.'));
+    return;
+  }
+
+  // Build option list: one entry per snapshot + Delete All + Back.
+  const options = [
+    ...snapshots.map((sn) => ({ value: sn.name, label: `🗑  ${pc.cyan(sn.name)}`, hint: 'delete this snapshot' })),
+    { value: '__all', label: `💣 Delete ALL snapshots  ${pc.dim(`(${snapshots.length} total)`)}`, hint: 'qgroup rescan + full wipe' },
+    { value: '__back', label: '← Back' },
+  ];
+
+  const pick = await p.select({
+    message: '🗑  Delete snapshots — pick one or delete all',
+    options,
+  });
+
+  if (p.isCancel(pick) || pick === '__back') return;
+
+  // ── Delete ALL ─────────────────────────────────────────────────────────────
+  if (pick === '__all') {
+    const confirm = await p.confirm({
+      message: pc.red(`Delete ALL ${snapshots.length} local snapshot(s)? This cannot be undone.`),
+      initialValue: false,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+      p.log.message(pc.dim('Cancelled — nothing was deleted.'));
+      return;
+    }
+
+    p.log.message(pc.dim('Running btrfs quota rescan first…'));
+    try {
+      const result = await deleteAllSnapshots({
+        privileged: 'interactive',
+        onProgress: (msg) => p.log.message(pc.dim(`  ${msg}`)),
+      });
+      p.log.success(`✔ Deleted ${result.deleted.length} snapshot(s).`);
+    } catch (e) {
+      // e.deleted / e.failed are attached by deleteAllSnapshots
+      if (e.deleted?.length) p.log.success(`✔ Deleted: ${e.deleted.join(', ')}`);
+      if (e.failed?.length) {
+        p.log.warn(`✖ Failed: ${e.failed.map((f) => `${f.name} (${f.error})`).join(', ')}`);
+        p.log.message(pc.dim('  Try running again — the qgroup rescan may need a second pass.'));
+      } else {
+        p.log.warn(`✖ ${e.message}`);
+      }
+    }
+    return;
+  }
+
+  // ── Delete ONE ─────────────────────────────────────────────────────────────
+  const confirm = await p.confirm({
+    message: pc.yellow(`Delete snapshot ${pc.bold(pick)}?`),
+    initialValue: false,
+  });
+  if (p.isCancel(confirm) || !confirm) {
+    p.log.message(pc.dim('Cancelled — nothing was deleted.'));
+    return;
+  }
+
+  try {
+    await deleteSnapshot(pick, { privileged: 'interactive' });
+    p.log.success(`✔ Snapshot ${pc.bold(pick)} deleted.`);
+  } catch (e) {
+    p.log.warn(`✖ ${e.message}`);
+    p.log.message(pc.dim('  If you see a qgroup error, try "Delete ALL" which runs btrfs quota rescan first.'));
+  }
+}
+
 /** Restore files or a system snapshot. */
 async function restoreMenu() {
   const accs = listAccounts();
@@ -323,6 +407,7 @@ export async function runWizard() {
         { value: 'backup', label: '💾 Run all backups', hint: 'snapshots + file backups' },
         { value: 'restore', label: '♻️  Restore backup', hint: 'files or system snapshot' },
         { value: 'list', label: '📋 List backups', hint: 'see what\'s saved' },
+        { value: 'delete', label: '🗑  Delete snapshots', hint: 'remove one or all local snapshots' },
         { value: 'add', label: '☁️  Add cloud account', hint: 'MEGA or Google Drive' },
         { value: 'accounts', label: '🗂  Manage storage', hint: 'pool, quotas, accounts' },
         { value: 'setup', label: '🚀 Guided setup', hint: 'first-time configuration' },
@@ -352,6 +437,7 @@ export async function runWizard() {
         case 'resume': await snapshotNowAction(); break;
         case 'backup': await backupNowAction(); break;
         case 'list': await listBackupsAction(); break;
+        case 'delete': await deleteSnapshotsMenu(); break;
         case 'restore': await restoreMenu(); break;
         case 'service': await serviceMenu(); break;
         case 'daemon': await daemonMenu(); break;