parrot-blackbox 2.1.1 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.1.1",
+  "version": "2.2.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/urgent.js

@@ -103,8 +103,25 @@ export function buildUrgentBundle({ home = process.env.HOME } = {}) {
  */
 export async function runUrgentBackup(cfg = loadConfig(), state = loadState(), { onProgress } = {}) {
   const now = clock();
-  const id = iso(now);
-  journal('urgent', `start id=${id}`);
+
+  // ── Resume an interrupted upload ─────────────────────────────────────────
+  // If a previous urgent upload died mid-transfer (power cut / crash / Ctrl+C),
+  // a pending marker was persisted in state BEFORE any long work began. On the
+  // next run we REUSE that id so `planAndPlace` writes back into the SAME cloud
+  // directory — rclone copy is per-file idempotent, so already-uploaded files
+  // are skipped and only the remainder is transferred, then the manifest is
+  // rewritten once the last file lands. The bundle itself is regenerated (the
+  // staging dir is transient), which is fine because the sources are fixed.
+  const resumed = Boolean(state.urgentPending?.id);
+  const id = resumed ? state.urgentPending.id : iso(now);
+  if (!resumed) {
+    state.urgentPending = { id, since: iso(now) };
+    saveState(state); // persist the marker before any long work → crash-safe
+    journal('urgent', `start id=${id}`);
+  } else {
+    journal('urgent', `resume id=${id} (previous upload was interrupted)`);
+  }
+
   const bundle = buildUrgentBundle();
 
   const accounts = await refreshAccounts(cfg);
@@ -134,11 +151,16 @@ export async function runUrgentBackup(cfg = loadConfig(), state = loadState(), {
     totalSize: manifest.totalSize,
     entryCount: manifest.entries?.length || 0,
   };
+  // Only clear the pending marker once the upload FULLY landed (manifest is on
+  // the cloud + mirrored locally). If we crash before this line, the next run
+  // resumes the same id — re-copying is a no-op for finished files.
+  delete state.urgentPending;
   saveState(state);
   journal('urgent', `done id=${id} bytes=${manifest.totalSize}`);
 
   return {
     id,
+    resumed,
     manifest,
     sizeBytes: manifest.totalSize,
     skippedRepos: bundle.skippedRepos,

package/src/cli.js

@@ -423,7 +423,7 @@ const main = defineCommand({
         try {
           const r = await runUrgentBackup(undefined, undefined, { onProgress: progress });
           progress.stop();
-          console.log(`${pc.green('✔')} Urgent backup stored (${bytesHuman(r.sizeBytes)}). Restore with: \`parrot-blackbox restore urgent\`.`);
+          console.log(`${pc.green('✔')} Urgent backup ${r.resumed ? 'resumed & ' : ''}stored (${bytesHuman(r.sizeBytes)}). Restore with: \`parrot-blackbox restore urgent\`.`);
           if (r.skippedRepos?.length) console.log(pc.dim(`Skipped ${r.skippedRepos.length} git-tracked folder(s).`));
           if (r.missing?.length) console.log(pc.dim(`Source(s) not present, skipped: ${r.missing.join(', ')}.`));
         } catch (e) {

package/src/storage/allocator.js

@@ -65,7 +65,11 @@ export function walkFiles(localDir) {
  *      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).
+ *      placing the file. Accounts that are within ~0.5% of quota from each
+ *      other are treated as equally full, and the account EARLIEST in the
+ *      configured pool order wins the tie — so an all-empty pool fills in
+ *      account order (mega-1, mega-2, …) instead of chasing `rclone about`
+ *      usage noise.
  */
 export function chooseAccount(needed, accounts) {
   // Tier 0 = mega, Tier 1 = gdrive / everything else.
@@ -79,14 +83,26 @@ export function chooseAccount(needed, accounts) {
   const candidates = eligible.filter((a) => providerTier(a) === bestTier);
 
   // Water-fill within the chosen tier: minimise resulting used-percentage.
+  // SCORE_EPS absorbs `rclone about` usage noise — MEGA inconsistently reports
+  // a few bytes to tens-of-MiB of phantom usage on otherwise-empty accounts.
+  // As long as accounts are effectively equally full, files go onto the account
+  // EARLIEST in the configured pool order.
+  const SCORE_EPS = 0.005; // 0.5 percentage points of quota
   let best = null;
   let bestScore = Infinity;
-  for (const acc of candidates) {
+  let bestIdx = Infinity;
+  for (let i = 0; i < candidates.length; i++) {
+    const acc = candidates[i];
     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_EPS) {
       bestScore = score;
       best = acc;
+      bestIdx = i;
+    } else if (Math.abs(score - bestScore) <= SCORE_EPS && i < bestIdx) {
+      // Effectively a tie → the earlier account in the pool wins.
+      best = acc;
+      bestIdx = i;
     }
   }
   return best;

package/src/storage/archive.js

@@ -150,7 +150,7 @@ export async function restoreArtifact(manifest, destDir, { onProgress } = {}) {
       for (const entry of batch.entries) {
         const target = path.join(destDir, ...entry.rel.split('/'));
         const loc = entry.loc[0];
-        const r = await copyToFile(`${loc.remote}:${loc.path}`, target);
+        const r = await copyToFile(`${loc.remote}:${loc.path}`, target, { force: true });
         if (!r.ok) throw new Error(`download failed for ${entry.rel}: ${r.error}`);
         files += 1;
         bytes += entry.size;

package/src/storage/rclone.js

@@ -64,9 +64,10 @@ export async function copyDir(localDir, remotePath) {
 }
 
 /** Copy a single local file to an exact remote path. */
-export async function copyToFile(localFile, remotePath, { ignoreExisting = false } = {}) {
+export async function copyToFile(localFile, remotePath, { ignoreExisting = false, force = false } = {}) {
   const args = ['copyto', localFile, remotePath];
   if (ignoreExisting) args.push('--ignore-existing');
+  if (force) args.push('--ignore-times'); // overwrite even a "newer" destination
   const res = await rejectFalse(args);
   return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
 }
@@ -131,7 +132,12 @@ export async function downloadBatch(remotePath, localDir, filesFromPath) {
     '--files-from', filesFromPath,
     '--transfers=16',
     '--checkers=16',
-    '--fast-list'
+    '--fast-list',
+    // Restore MUST reproduce the artifact exactly. rclone's default skips a
+    // destination file whose mtime looks newer (exactly what fresh-install
+    // default files are), which silently leaves "conflicts" — your backed-up
+    // version never comes back. --ignore-times forces the overwrite.
+    '--ignore-times',
   ];
   const res = await rejectFalse(args);
   return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };