parrot-blackbox 1.0.16 → 1.0.18

package/package.json

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