parrot-blackbox 1.0.14 → 1.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "parrot-blackbox",
-  "version": "1.0.14",
-  "description": "parrot-blackbox — 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.",
+  "version": "1.0.16",
+  "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",
   "bin": {

package/src/backup/restore.js

@@ -19,7 +19,7 @@ import { stateDir, timeshiftDir } from '../core/paths.js';
 import { refreshAccounts } from '../storage/accounts.js';
 import { discoverManifest, restoreArtifact } from '../storage/archive.js';
 import { listLocalSnapshots } from './snapshot.js';
-import { sudoInteractive } from '../util/sudo.js';
+import { ensureSudo, sudoInteractive } from '../util/sudo.js';
 import { bytesHuman } from '../util/misc.js';
 
 /** Restore a file backup generation into a writable local directory. */
@@ -67,6 +67,7 @@ export async function restoreSnapshot({ id, accounts, cfg, toDir, confirm = fals
 
   // Run the actual restore (interactive sudo → the password prompt is visible).
   console.log(`\nRestoring snapshot ${id} over the current system…\n`);
+  await ensureSudo();
   const res = await sudoInteractive(['timeshift', '--restore', '--snapshot', id, '--yes']);
   if (res.exitCode !== 0) throw new Error(`timeshift --restore failed (exit ${res.exitCode})`);
   journal('restore', `snapshot id=${id} RESTORED`);
@@ -79,6 +80,7 @@ async function placeIntoTimeshift(id, tmpRoot, cfg, privileged) {
   const base = determineSnapshotBase();
   const target = path.join(base, id);
   const cmd = `mkdir -p ${shq(base)} && rm -rf ${shq(target)} && cp -a ${shq(tmpRoot)}/. ${shq(target)}/ && chown -R root:root ${shq(target)}`;
+  await ensureSudo();
   const res = await sudoInteractive(['bash', '-c', cmd]);
   if (res.exitCode !== 0) throw new Error(`could not move snapshot into ${base} (exit ${res.exitCode})`);
   return target;

package/src/backup/snapshot.js

@@ -17,7 +17,7 @@ import { refreshAccounts } from '../storage/accounts.js';
 import { planAndPlace } from '../storage/allocator.js';
 import { listArtifacts, removeArtifact } from '../storage/archive.js';
 import { planPrune } from './retention.js';
-import { sudoInteractive, sudoNonInteractive, sudoInteractiveCapture } from '../util/sudo.js';
+import { sudoInteractive, sudoNonInteractive, sudoInteractiveCapture, sudoExecSync, ensureSudo } from '../util/sudo.js';
 
 export class SudoDeferredError extends Error {
   constructor() {
@@ -96,6 +96,7 @@ function findPathInLine(line) {
 async function runTimeshiftList({ privileged = 'noninteractive' } = {}) {
   if (privileged === 'interactive') {
     try {
+      await ensureSudo();
       const res = await sudoInteractiveCapture(['timeshift', '--list']);
       return (res.exitCode === 0 ? res.stdout : res.stdout || res.stderr) || '';
     } catch {
@@ -124,6 +125,7 @@ export async function createSnapshot({ comment, privileged = 'noninteractive' }
 
   let createOut = '';
   if (privileged === 'interactive') {
+    await ensureSudo();
     const res = await sudoInteractiveCapture(args);
     if (res.exitCode !== 0) throw new Error(`timeshift --create failed (exit ${res.exitCode})`);
     createOut = `${res.stdout || ''} ${res.stderr || ''}`;
@@ -154,6 +156,7 @@ export async function createSnapshot({ comment, privileged = 'noninteractive' }
 export async function deleteSnapshot(name, { privileged = 'noninteractive' } = {}) {
   const args = ['timeshift', '--delete', '--snapshot', name];
   if (privileged === 'interactive') {
+    await ensureSudo();
     const res = await sudoInteractive(args);
     if (res.exitCode !== 0) throw new Error(`timeshift --delete ${name} failed (exit ${res.exitCode})`);
     return true;
@@ -201,15 +204,10 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
     
     if (device && deviceResult.exitCode === 0) {
       // Create temporary mount point
-      const mkdirCmd = privileged === 'interactive' ? ['sudo', 'mkdir', '-p', mountPoint] : ['sudo', '-n', 'mkdir', '-p', mountPoint];
-      execaSync(mkdirCmd[0], mkdirCmd.slice(1), { reject: false });
+      sudoExecSync(['mkdir', '-p', mountPoint]);
       
       // Mount BTRFS root subvolume (subvolid=5 contains all subvolumes including snapshots)
-      const mountCmd = privileged === 'interactive' 
-        ? ['sudo', 'mount', '-o', 'subvolid=5', device, mountPoint]
-        : ['sudo', '-n', 'mount', '-o', 'subvolid=5', device, mountPoint];
-      
-      const mountResult = execaSync(mountCmd[0], mountCmd.slice(1), { reject: false, timeout: 5000 });
+      const mountResult = sudoExecSync(['mount', '-o', 'subvolid=5', device, mountPoint]);
       
       if (mountResult.exitCode === 0) {
         // Search for the snapshot in the mounted root subvolume
@@ -228,9 +226,8 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
         }
         
         // Unmount if we didn't find anything
-        const umountCmd = privileged === 'interactive' ? ['sudo', 'umount', mountPoint] : ['sudo', '-n', 'umount', mountPoint];
-        execaSync(umountCmd[0], umountCmd.slice(1), { reject: false });
-        execaSync('sudo', ['-n', 'rmdir', mountPoint], { reject: false });
+        sudoExecSync(['umount', mountPoint]);
+        sudoExecSync(['rmdir', mountPoint]);
       }
     }
   } catch {
@@ -245,8 +242,8 @@ export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {})
 export function cleanupSnapshotMount(snapshot) {
   if (snapshot._tempMount) {
     try {
-      execaSync('sudo', ['-n', 'umount', snapshot._tempMount], { reject: false });
-      execaSync('sudo', ['-n', 'rmdir', snapshot._tempMount], { reject: false });
+      sudoExecSync(['umount', snapshot._tempMount]);
+      sudoExecSync(['rmdir', snapshot._tempMount]);
       delete snapshot._tempMount;
     } catch {
       /* best effort */
@@ -302,6 +299,7 @@ export async function runSnapshotBackup(cfg, state, { due, privileged = 'noninte
     
     let res;
     if (privileged === 'interactive') {
+      await ensureSudo();
       res = await sudoInteractive(args);
     } else {
       res = await sudoNonInteractive(args);

package/src/cli.js

@@ -97,7 +97,7 @@ async function snapshotList() {
   const accs = listAccounts();
   console.log(`${pc.bold('\nLocal snapshots (Timeshift):')}`);
   try {
-    const local = await listLocalSnapshots({ privileged: 'noninteractive' });
+    const local = await listLocalSnapshots({ privileged: process.stdin.isTTY ? 'interactive' : 'noninteractive' });
     if (local.length === 0) console.log(`  ${pc.dim('none')}`);
     for (const s of local) console.log(`  - ${pc.cyan(s.name)}  ${pc.dim(s.tags)}`);
   } catch (e) {
@@ -379,7 +379,7 @@ const main = defineCommand({
         return runSelfUpdate({ force: process.argv.includes('--force') });
 
       case 'run':
-        process.exitCode = await invokeRun('noninteractive');
+        process.exitCode = await invokeRun(process.stdin.isTTY ? 'interactive' : 'noninteractive');
         return;
 
       case 'force':
@@ -538,6 +538,21 @@ const main = defineCommand({
           s.stop('✖ Upload failed');
           console.error(`_internal_upload failed: ${e.message}`);
           process.exitCode = 1;
+        } finally {
+          // If we are running as root via sudo, rclone might have refreshed OAuth tokens
+          // and rewritten rclone.conf as root:root. Restore ownership to the real user.
+          if (process.getuid && process.getuid() === 0 && process.env.SUDO_UID && process.env.SUDO_GID) {
+            import('node:fs').then(fs => {
+              import('node:path').then(path => {
+                const confPath = path.join(process.env.HOME, '.config', 'rclone', 'rclone.conf');
+                if (fs.existsSync(confPath)) {
+                  try {
+                    fs.chownSync(confPath, parseInt(process.env.SUDO_UID, 10), parseInt(process.env.SUDO_GID, 10));
+                  } catch { /* best effort */ }
+                }
+              });
+            });
+          }
         }
         return;
       }

package/src/commands/setup.js

@@ -9,6 +9,7 @@ import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { execa } from 'execa';
 import { loadConfig, journal, hasCommandSync } from '../core/store.js';
+import { ensureSudo, sudoInteractive } from '../util/sudo.js';
 import { listAccounts, refreshAccounts, poolSummary } from '../storage/accounts.js';
 import { installService } from './service.js';
 import { runDueJobs } from '../daemon/scheduler.js';
@@ -58,7 +59,8 @@ async function ensureSystemTools() {
     s.stop('');
     try {
       const args = pm === 'pacman' ? ['-S', '--noconfirm', tool.pkg] : [pm, 'install', '-y', tool.pkg];
-      const res = await execa('sudo', args, { stdio: 'inherit', reject: false });
+      await ensureSudo();
+      const res = await sudoInteractive([pm, ...args.slice(1)]);
       if (res.exitCode === 0 && hasCommandSync(tool.bin)) {
         p.log.success(`${pc.cyan(tool.bin)} installed.`);
         installed.push(tool.bin);

package/src/commands/tools.js

@@ -8,6 +8,7 @@ import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { execa } from 'execa';
 import { hasCommandSync } from '../core/store.js';
+import { ensureSudo, sudoInteractive } from '../util/sudo.js';
 
 export const REQUIRED = [
   { bin: 'rclone', pkg: 'rclone', why: 'talks to MEGA / Google Drive (cloud storage)' },
@@ -59,7 +60,8 @@ export async function ensureSystemTools() {
     s.stop(''); // release the terminal first so the sudo password prompt is usable
     try {
       const args = pm === 'pacman' ? ['-S', '--noconfirm', tool.pkg] : [pm, 'install', '-y', tool.pkg];
-      const res = await execa('sudo', args, { stdio: 'inherit', reject: false });
+      await ensureSudo();
+      const res = await sudoInteractive([pm, ...args.slice(1)]);
       if (res.exitCode === 0 && hasCommandSync(tool.bin)) {
         p.log.success(`${pc.cyan(tool.bin)} installed.`);
         installed.push(tool.bin);

package/src/lib/self.js

@@ -8,6 +8,7 @@
 import { execa } from 'execa';
 import pc from 'picocolors';
 import { createRequire } from 'node:module';
+import { ensureSudo, sudoInteractive } from '../util/sudo.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
@@ -66,9 +67,18 @@ export async function promptSelfUpdate() {
 
   // Release the terminal so npm's progress & any prompts are visible/interruptible.
   console.log();
-  const res = await execa('npm', ['install', '-g', `${NPM_NAME}@latest`], { stdio: 'inherit', reject: false });
+  let res = await execa('npm', ['install', '-g', `${NPM_NAME}@latest`], { stdio: 'inherit', reject: false });
   if (res.exitCode !== 0) {
-    p.log.warn('Update failed. You can retry with: npm install -g ' + NPM_NAME + '@latest');
+    p.log.warn('Update failed. Attempting again with sudo...');
+    try {
+      await ensureSudo();
+      res = await sudoInteractive(['npm', 'install', '-g', `${NPM_NAME}@latest`]);
+    } catch {
+      // Fall through to error
+    }
+  }
+  if (res.exitCode !== 0) {
+    p.log.warn('Update failed. You can retry with: sudo npm install -g ' + NPM_NAME + '@latest');
     return false;
   }
   p.log.success(`Updated to v${latest}. ` + 'Run `parrot-blackbox` again to use the new version.');
@@ -99,9 +109,18 @@ export async function runSelfUpdate({ force = false } = {}) {
   const want = await p.confirm({ message: `Update parrot-blackbox to v${latest} now?`, initialValue: true });
   if (p.isCancel(want) || !want) { p.log.message(pc.dim('Update skipped.')); return false; }
   console.log();
-  const res = await execa('npm', ['install', '-g', `${NPM_NAME}@latest`], { stdio: 'inherit', reject: false });
+  let res = await execa('npm', ['install', '-g', `${NPM_NAME}@latest`], { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) {
+    p.log.warn('Update failed. Attempting again with sudo...');
+    try {
+      await ensureSudo();
+      res = await sudoInteractive(['npm', 'install', '-g', `${NPM_NAME}@latest`]);
+    } catch {
+      // Fall through to error
+    }
+  }
   if (res.exitCode !== 0) {
-    p.log.warn('Update failed. You can retry with: npm install -g ' + NPM_NAME + '@latest');
+    p.log.warn('Update failed. You can retry with: sudo npm install -g ' + NPM_NAME + '@latest');
     return false;
   }
   p.log.success(`Updated to v${latest}. Restart parrot-blackbox to use the new version.`);
@@ -112,7 +131,16 @@ export async function runSelfUpdate({ force = false } = {}) {
 export async function selfUninstall() {
   const p = await import('@clack/prompts');
   console.log();
-  const res = await execa('npm', ['uninstall', '-g', NPM_NAME], { stdio: 'inherit', reject: false });
+  let res = await execa('npm', ['uninstall', '-g', NPM_NAME], { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) {
+    p.log.warn('Uninstall failed. Attempting again with sudo...');
+    try {
+      await ensureSudo();
+      res = await sudoInteractive(['npm', 'uninstall', '-g', NPM_NAME]);
+    } catch {
+      // Fall through to error
+    }
+  }
   if (res.exitCode === 0) {
     p.log.success(`${NPM_NAME} removed. The parrot-blackbox command is no longer available.`);
     return true;

package/src/util/sudo.js

@@ -1,23 +1,116 @@
 /**
  * Privileged execution.
  *
- *  - `sudoInteractive`  — runs `sudo <args>` with the terminal inherited so the
+ *  - `ensureSudo`          — prompts the user for their sudo password once,
+ *    arming the sudo timestamp so all subsequent calls in the same session
+ *    work without re-prompting (unless the timestamp expires after ~15 min).
+ *    Call this EARLY (e.g. at wizard launch, before any privileged menu item).
+ *  - `sudoExec`            — the ONE wrapper every caller should use. It picks
+ *    interactive vs non-interactive automatically based on TTY, and pre-prompts
+ *    for the password if the timestamp has lapsed.
+ *  - `sudoInteractive`     — runs `sudo <args>` with the terminal inherited so the
  *    password prompt is visible and Ctrl+C works (the gitswitch/theamify/
  *    warp-wizard pattern: callers stop any spinner FIRST).
- *  - `sudoNonInteractive` — runs `sudo -n <args>`; used by the background daemon
- *    so it can *never* hang waiting on a password. When the sudo timestamp has
- *    lapsed the job is deferred and retried later; a single interactive
- *    `parrot-blackbox snapshot now` (or any sudo use on the box) re-arms it.
+ *  - `sudoInteractiveCapture` — same but captures stdout (for `timeshift --list`).
+ *  - `sudoNonInteractive`  — runs `sudo -n <args>`; used by the background daemon
+ *    so it can *never* hang waiting on a password.
  *
  * PBB_SUDO_DIRECT=1 (used by unit tests) bypasses sudo entirely.
  */
 
-import { execa } from 'execa';
+import { execa, execaSync } from 'execa';
 
 function sudoPrefix() {
   return process.env.PBB_SUDO_DIRECT === '1' ? [] : ['sudo'];
 }
 
+/**
+ * Prompt the user for their sudo password (if needed) to arm the sudo
+ * timestamp for this session. This is a no-op when:
+ *  - already root (UID 0)
+ *  - PBB_SUDO_DIRECT=1 (test mode)
+ *  - sudo timestamp is already valid
+ *
+ * Safe to call multiple times — it checks `sudo -n true` first, and only
+ * prompts when the timestamp has actually lapsed.
+ */
+export async function ensureSudo() {
+  if (process.env.PBB_SUDO_DIRECT === '1') return true;
+  if (process.getuid && process.getuid() === 0) return true;
+
+  // Check if sudo timestamp is already valid (no prompt needed).
+  const check = await execa('sudo', ['-n', 'true'], { reject: false });
+  if (check.exitCode === 0) return true;
+
+  // Timestamp lapsed — prompt the user for their password.
+  // stdio: 'inherit' keeps the terminal so the user can type the password.
+  console.log('\n🔐 Root privileges required — please enter your sudo password:\n');
+  const res = await execa('sudo', ['-v'], { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) {
+    throw new Error('sudo authentication failed — cannot continue without root privileges');
+  }
+  return true;
+}
+
+/**
+ * Synchronous version of ensureSudo for use in sync code paths.
+ * Returns true if sudo is available (timestamp valid or we're root).
+ * Does NOT prompt — use ensureSudo() for that.
+ */
+export function isSudoArmed() {
+  if (process.env.PBB_SUDO_DIRECT === '1') return true;
+  if (process.getuid && process.getuid() === 0) return true;
+  try {
+    const res = execaSync('sudo', ['-n', 'true'], { reject: false });
+    return res.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Smart sudo wrapper — the preferred entry point for ALL privileged calls
+ * from interactive (TTY) code paths. It:
+ *  1. Checks if sudo is armed
+ *  2. If not, prompts the user for password (if TTY)
+ *  3. Then runs the command with sudo
+ *
+ * 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 } = {}) {
+  if (interactive && process.stdin.isTTY) {
+    // Ensure the sudo timestamp is armed before running the command.
+    await ensureSudo();
+    if (capture) {
+      return sudoInteractiveCapture(args, { timeout });
+    }
+    return sudoInteractive(args, { timeout });
+  }
+  return sudoNonInteractive(args);
+}
+
+/**
+ * Synchronous sudo execution for code paths that MUST be sync (e.g. snapshotDirFor).
+ * 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 } = {}) {
+  if (process.env.PBB_SUDO_DIRECT === '1') {
+    return execaSync(args[0], args.slice(1), { reject });
+  }
+  // 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 });
+  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' });
+  }
+  // Last resort: try without sudo (some operations work unprivileged)
+  return execaSync(args[0], args.slice(1), { reject: false });
+}
+
 /** Interactive sudo baseline for injecting PBB_SUDO_DIRECT consistent with the rest. */
 export async function sudoInteractive(args, { timeout = 0 } = {}) {
   const full = [...sudoPrefix(), ...args];