parrot-blackbox 1.0.16 → 1.1.0

package/package.json

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

@@ -11,7 +11,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execa, execaSync } from 'execa';
 import { loadConfig, loadState, saveState, journal, hasCommandSync } from '../core/store.js';
-import { timeshiftDir } from '../core/paths.js';
+import { timeshiftDir, stateDir, configFile, manifestsDir } from '../core/paths.js';
 import { iso, clock } from '../core/time.js';
 import { refreshAccounts } from '../storage/accounts.js';
 import { planAndPlace } from '../storage/allocator.js';
@@ -259,26 +259,31 @@ export function cleanupSnapshotMount(snapshot) {
 export async function runSnapshotBackup(cfg, state, { due, privileged = 'noninteractive', onProgress } = {}) {
   journal('snapshots', `start due=${due} privileged=${privileged}`);
   const accounts = await refreshAccounts(cfg);
+  
+  if (accounts.length === 0) {
+    throw new Error('no storage accounts configured — add one with `parrot-blackbox account add`');
+  }
 
-  // Resume logic: if the most recent local snapshot has no local manifest,
-  // it means its previous upload failed or was interrupted. We should resume it
-  // to avoid re-uploading everything to a new snapshot ID.
+  let created = null;
   const localSnaps = await listLocalSnapshots({ privileged });
-  const manifestLocalDir = process.env.PBB_MANIFESTS_DIR || path.join(process.env.PBB_STATE_DIR || '.', 'manifests');
   
-  let created = null;
-  // Look at snapshots from newest to oldest
+  // Look at snapshots from newest to oldest; find the most recent one that
+  // belongs to parrot-blackbox and has not been fully uploaded yet.
   for (let i = localSnaps.length - 1; i >= 0; i--) {
     const s = localSnaps[i];
     if (s.tags.includes('W') || (s.line && s.line.includes('parrot-blackbox'))) {
-      const manPath = path.join(manifestLocalDir, `snapshots-${s.name}.json`);
-      if (!fs.existsSync(manPath)) {
+      // Check for the manifest FILE on disk — this is the authoritative source.
+      // state.manifests (the in-memory JSON blob) may be empty on the first run
+      // or after a reinstall, so we cannot rely on it alone.
+      const manifestFile = path.join(manifestsDir(), `snapshots-${s.name}.json`);
+      const isUploaded = fs.existsSync(manifestFile);
+      if (!isUploaded) {
         created = s;
         journal('snapshots', `resuming upload for incomplete snapshot ${s.name}`);
+        console.log(`\n⏳ Resuming incomplete upload for snapshot ${s.name} (from tracker)...`);
         break;
       } else {
-        // The most recent parrot-blackbox snapshot is fully uploaded. We can break
-        // and create a new one.
+        // The most recent parrot-blackbox snapshot is fully uploaded — create a new one.
         break;
       }
     }
@@ -293,16 +298,21 @@ export async function runSnapshotBackup(cfg, state, { due, privileged = 'noninte
   let manifest;
   try {
     const bin = process.argv[1] || 'parrot-blackbox';
-    const outPath = path.join(process.env.PBB_STATE_DIR || '/tmp', `manifest-${created.name}.json`);
-    const baseArgs = [process.execPath, bin, '_internal_upload', dir, 'snapshots', created.name, cfg.storage.remoteRoot, String(cfg.storage.chunkSize), outPath];
-    const args = process.env.PBB_SUDO_DIRECT === '1' ? baseArgs : ['-E', ...baseArgs];
+    const outPath = path.join(stateDir(), `manifest-${created.name}.json`);
+    const envVars = {
+      HOME: process.env.HOME,
+      PBB_STATE_DIR: stateDir(),
+      PBB_CONFIG_FILE: configFile()
+    };
+    const cmdArgs = [process.execPath, bin, '_internal_upload', dir, 'snapshots', created.name, cfg.storage.remoteRoot, String(cfg.storage.chunkSize), outPath];
+    const args = process.env.PBB_SUDO_DIRECT === '1' ? cmdArgs : ['-E', ...cmdArgs];
     
     let res;
     if (privileged === 'interactive') {
       await ensureSudo();
-      res = await sudoInteractive(args);
+      res = await sudoInteractive(args, { env: envVars });
     } else {
-      res = await sudoNonInteractive(args);
+      res = await sudoNonInteractive(args, { env: envVars });
     }
     
     if (res.exitCode !== 0) {

package/src/commands/wizard.js

@@ -319,6 +319,7 @@ export async function runWizard() {
       message: 'What would you like to do?',
       options: [
         { value: 'snapshot', label: '📸 Create snapshot', hint: 'backup your system now' },
+        { value: 'resume', label: '⏳ Resume upload', hint: 'resume incomplete backup uploads' },
         { 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' },
@@ -348,6 +349,7 @@ export async function runWizard() {
         case 'accounts': await accountsMenu(); break;
         case 'tools': await runToolsCheck(); break;
         case 'snapshot': await snapshotNowAction(); break;
+        case 'resume': await snapshotNowAction(); break;
         case 'backup': await backupNowAction(); break;
         case 'list': await listBackupsAction(); break;
         case 'restore': await restoreMenu(); break;

package/src/storage/accounts.js

@@ -1,8 +1,10 @@
 /**
  * Storage accounts — the gitswitch-style account manager for the multi-cloud
  * pool. Each account maps to ONE rclone remote (one MEGA or Google Drive
- * login). 5 MEGA + 5 Drive accounts with ~20GiB / ~15GiB each ≈ 175GiB that the
- * allocator can spread backups across so we are never out of space.
+ * login). You can add any number of MEGA and/or Google Drive accounts — e.g.
+ * 2, 5, 11, or even 30 of each. MEGA accounts are always filled first; the
+ * allocator only spills over to Google Drive once every MEGA account is at
+ * capacity.
  */
 
 import crypto from 'node:crypto';

package/src/storage/allocator.js

@@ -3,13 +3,16 @@
  * (many MEGA + Google Drive logins) from ever running out of space.
  *
  * Strategy:
- *   1. Every file of an artifact is placed WHOLE on a single account when it
- *      fits. The account is chosen to minimise the resulting used-percentage
- *      (water-filling), then most free, then oldest — spreading wear.
+ *   0. MEGA accounts are always filled first. Google Drive accounts are only
+ *      used once every MEGA account is at capacity for the file being placed.
+ *   1. Within each provider tier, every file of an artifact is placed WHOLE on
+ *      a single account when it fits. The account is chosen to minimise the
+ *      resulting used-percentage (water-filling), then most free, then oldest —
+ *      spreading wear evenly across all accounts of the same type.
  *   2. If a single file is bigger than any one account's free space, it is
  *      split into byte-range chunks distributed across several accounts
- *      (first-fit over free space). A manifest records the exact ranges so
- *      restore reassembles the file byte-perfectly.
+ *      (first-fit over free space, MEGA-first). A manifest records the exact
+ *      ranges so restore reassembles the file byte-perfectly.
  * The manifest is written to the cloud (`<root>/<kind>/<id>/__MANIFEST__.json`)
  * AND mirrored locally, so restore works even from a wiped machine.
  */
@@ -52,15 +55,35 @@ export function walkFiles(localDir) {
   return out;
 }
 
-/** Choose the account that minimises its resulting used-percentage. */
+/**
+ * Choose the best account to store `needed` bytes.
+ *
+ * Priority:
+ *   1. MEGA accounts are always preferred over Google Drive.
+ *      Only when ALL MEGA accounts are full (or have insufficient free space)
+ *      will Google Drive accounts be used.
+ *   2. Within each provider tier the classic water-filling strategy applies:
+ *      pick the account that results in the lowest used-percentage after
+ *      placing the file (most headroom wins on ties).
+ */
 export function chooseAccount(needed, accounts) {
+  // Tier 0 = mega, Tier 1 = gdrive / everything else.
+  const providerTier = (acc) => (acc.provider === 'mega' ? 0 : 1);
+
+  // Find the lowest tier that has at least one account with enough free space.
+  const eligible = accounts.filter((a) => a.free >= needed);
+  if (eligible.length === 0) return null;
+
+  const bestTier = Math.min(...eligible.map(providerTier));
+  const candidates = eligible.filter((a) => providerTier(a) === bestTier);
+
+  // Water-fill within the chosen tier: minimise resulting used-percentage.
   let best = null;
   let bestScore = Infinity;
-  for (const acc of accounts) {
-    if (acc.free < needed) continue;
+  for (const acc of candidates) {
     const quota = acc.total || 0;
     const score = quota ? (acc.used + needed) / quota : needed;
-    if (score < bestScore || (score === bestScore && (acc.free > (best?.free ?? -1)))) {
+    if (score < bestScore || (score === bestScore && acc.free > (best?.free ?? -1))) {
       bestScore = score;
       best = acc;
     }

package/src/util/sudo.js

@@ -78,16 +78,16 @@ export function isSudoArmed() {
  * For daemon/non-interactive use, pass { interactive: false } — it will use
  * `sudo -n` and never hang on a prompt.
  */
-export async function sudoExec(args, { interactive = true, capture = false, timeout = 0 } = {}) {
+export async function sudoExec(args, { interactive = true, capture = false, timeout = 0, env = {} } = {}) {
   if (interactive && process.stdin.isTTY) {
     // Ensure the sudo timestamp is armed before running the command.
     await ensureSudo();
     if (capture) {
-      return sudoInteractiveCapture(args, { timeout });
+      return sudoInteractiveCapture(args, { timeout, env });
     }
-    return sudoInteractive(args, { timeout });
+    return sudoInteractive(args, { timeout, env });
   }
-  return sudoNonInteractive(args);
+  return sudoNonInteractive(args, { env });
 }
 
 /**
@@ -95,26 +95,26 @@ export async function sudoExec(args, { interactive = true, capture = false, time
  * Requires that ensureSudo() was called earlier in the session.
  * Falls back to non-interactive sudo; if that fails, falls back to direct execution.
  */
-export function sudoExecSync(args, { reject = false } = {}) {
+export function sudoExecSync(args, { reject = false, env = {} } = {}) {
   if (process.env.PBB_SUDO_DIRECT === '1') {
-    return execaSync(args[0], args.slice(1), { reject });
+    return execaSync(args[0], args.slice(1), { reject, env: { ...process.env, ...env } });
   }
   // Try with sudo (timestamp should be armed from earlier ensureSudo call)
   const full = ['sudo', '-n', ...args];
-  const res = execaSync(full[0], full.slice(1), { reject: false });
+  const res = execaSync(full[0], full.slice(1), { reject: false, env: { ...process.env, ...env } });
   if (res.exitCode === 0) return res;
   // If sudo -n fails, try sudo with inherited stdio (will prompt if TTY available)
   if (process.stdin?.isTTY) {
-    return execaSync('sudo', args, { reject, stdio: 'inherit' });
+    return execaSync('sudo', args, { reject, stdio: 'inherit', env: { ...process.env, ...env } });
   }
   // Last resort: try without sudo (some operations work unprivileged)
-  return execaSync(args[0], args.slice(1), { reject: false });
+  return execaSync(args[0], args.slice(1), { reject: false, env: { ...process.env, ...env } });
 }
 
 /** Interactive sudo baseline for injecting PBB_SUDO_DIRECT consistent with the rest. */
-export async function sudoInteractive(args, { timeout = 0 } = {}) {
+export async function sudoInteractive(args, { timeout = 0, env = {} } = {}) {
   const full = [...sudoPrefix(), ...args];
-  const res = await execa(full[0], full.slice(1), { stdio: 'inherit', reject: false, timeout });
+  const res = await execa(full[0], full.slice(1), { stdio: 'inherit', reject: false, timeout, env: { ...process.env, ...env } });
   if (res.exitCode !== 0) {
     throw new Error(`elevated command failed: ${args.join(' ')} (exit ${res.exitCode})`);
   }
@@ -126,9 +126,9 @@ export async function sudoInteractive(args, { timeout = 0 } = {}) {
  * the parser) while keeping stdin inherited so the password prompt stays
  * usable — like the real sudo, which reads passwords from /dev/tty.
  */
-export async function sudoInteractiveCapture(args, { timeout = 0 } = {}) {
+export async function sudoInteractiveCapture(args, { timeout = 0, env = {} } = {}) {
   const full = [...sudoPrefix(), ...args];
-  const res = await execa(full[0], full.slice(1), { stdin: 'inherit', reject: false, timeout });
+  const res = await execa(full[0], full.slice(1), { stdin: 'inherit', reject: false, timeout, env: { ...process.env, ...env } });
   if (res.exitCode !== 0) {
     throw new Error(`elevated command failed: ${args.join(' ')} (exit ${res.exitCode})`);
   }
@@ -136,9 +136,9 @@ export async function sudoInteractiveCapture(args, { timeout = 0 } = {}) {
 }
 
 /** Non-interactive sudo (daemon-safe). Returns execa result, never hangs. */
-export async function sudoNonInteractive(args) {
+export async function sudoNonInteractive(args, { env = {} } = {}) {
   const full = process.env.PBB_SUDO_DIRECT === '1' ? args : ['sudo', '-n', ...args];
-  const res = await execa(full[0], full.slice(1), { reject: false });
+  const res = await execa(full[0], full.slice(1), { reject: false, env: { ...process.env, ...env } });
   return res;
 }