parrot-blackbox 1.0.18 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "1.0.18",
+  "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/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;
     }