parrot-blackbox 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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.",
   "type": "module",
   "main": "src/cli.js",

package/src/backup/snapshot.js

@@ -9,7 +9,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { execa } from 'execa';
+import { execa, execaSync } from 'execa';
 import { loadConfig, loadState, saveState, journal, hasCommandSync } from '../core/store.js';
 import { timeshiftDir } from '../core/paths.js';
 import { iso, clock } from '../core/time.js';
@@ -26,22 +26,59 @@ export class SudoDeferredError extends Error {
 }
 
 /**
- * Parse `timeshift --list` output into snapshots.
+ * Parse `timeshift --list` output into snapshots. Tolerant of multiple formats:
+ *
+ * Old format (Timeshift 22.x/23.x):
+ *   2026-08-29 22:00:01 W 2026-08-29_22-00-01 /timeshift/snapshots/...
+ *
+ * Table format with header (Timeshift 24.x):
+ *   Num     Name                            Tags                Description
+ *   0   2026-08-29 22:00:01  W  2026-08-29_22-00-01  parrot-blackbox
+ *
+ * Current format (Timeshift 24.06+):
+ *   Num     Name                 Tags  Description
+ *   0    >  2026-09-01_21-22-39  W     parrot-blackbox 2026-09-01T21:22:05
+ *
  * @returns {Array<{name:string, date:string, time:string, tags:string, dir:?string}>}
  */
 export function parseTimeshiftList(stdout) {
   const out = [];
   for (const line of String(stdout).split('\n')) {
-    const m = /^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})\s+([A-Z])\s+(\S+)(?:\s+(.*))?$/.exec(line);
-    if (!m) continue;
-    const [, date, time, tags, dirOrSize, detail] = m;
-    const name = `${date}_${time.replace(/:/g, '-')}`;
-    const dir = findPathInLine(line);
-    out.push({ name, date, time, tags, dir, line: `${date} ${time} ${tags} ${dirOrSize}${detail ? ` ${detail}` : ''}` });
+    // Try current format first: Num > NAME Tags Description
+    // The NAME field is in YYYY-MM-DD_HH-MM-SS format
+    let m = /^\s*\d+\s+>?\s+(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\s+([A-Za-z]{1,6})\s+(.*)$/.exec(line);
+    if (m) {
+      const [, name, tags, description] = m;
+      // Extract date and time from the name (YYYY-MM-DD_HH-MM-SS)
+      const date = name.slice(0, 10);  // YYYY-MM-DD
+      const time = name.slice(11).replace(/-/g, ':');  // HH:MM:SS
+      const dir = findPathInLine(line);
+      out.push({ name, date, time, tags, dir, line: `${name} ${tags} ${description}` });
+      continue;
+    }
+
+    // Try older format: [Num] DATE TIME TAGS NAME [description]
+    m = /^\s*(?:\d+\s+)?(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})\s+([A-Za-z]{1,6})\s+(\S+)(?:\s+(.*))?$/.exec(line);
+    if (m) {
+      const [, date, time, tags, dirOrName, detail] = m;
+      // Prefer the explicit dir-ish token (name contains _HH-MM-SS) over a rebuilt name.
+      const name = /^[\w.-]+\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$/.test(dirOrName)
+        ? dirOrName
+        : `${date}_${time.replace(/:/g, '-')}`;
+      const dir = findPathInLine(line);
+      out.push({ name, date, time, tags, dir, line: `${date} ${time} ${tags} ${dirOrName}${detail ? ` ${detail}` : ''}` });
+      continue;
+    }
   }
   return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
 
+/** Extract a created snapshot name from `timeshift --create` output. */
+export function extractCreatedName(output) {
+  const m = /Created new snapshot[:\s]+([\w.\-]+)/i.exec(String(output || ''));
+  return m ? m[1] : null;
+}
+
 /** Extract the snapshot directory path from a list line if present. */
 function findPathInLine(line) {
   const dirs = line.match(/\/[^\s]+\/[A-Za-z0-9._-]+/g) || [];
@@ -85,18 +122,28 @@ export async function createSnapshot({ comment, privileged = 'noninteractive' }
   const before = new Set((await listLocalSnapshots({ privileged })).map((s) => s.name));
   const args = ['timeshift', '--create', '--comments', comment || 'parrot-blackbox', '--tags', 'W'];
 
+  let createOut = '';
   if (privileged === 'interactive') {
-    const res = await sudoInteractive(args);
+    const res = await sudoInteractiveCapture(args);
     if (res.exitCode !== 0) throw new Error(`timeshift --create failed (exit ${res.exitCode})`);
+    createOut = `${res.stdout || ''} ${res.stderr || ''}`;
   } else {
     const res = await sudoNonInteractive(args);
     if (res.exitCode !== 0) {
       if (/password|authentication|sudo/i.test(res.stderr || '')) throw new SudoDeferredError();
       throw new Error(`timeshift --create failed (exit ${res.exitCode}): ${res.stderr?.trim()}`);
     }
+    createOut = `${res.stdout || ''} ${res.stderr || ''}`;
   }
 
-  // Find which snapshot appeared.
+  // Primary: read the exact name from timeshift's own output
+  // ("Created new snapshot: 2026-08-31_16-00-01") — the most reliable signal.
+  const createdName = extractCreatedName(createOut);
+  if (createdName) {
+    return { name: createdName, date: createdName.slice(0, 10), time: createdName.slice(11).replace(/-/g, ':'), tags: 'W', dir: null, line: createOut.trim() };
+  }
+
+  // Fallback: diff the list before/after.
   const after = await listLocalSnapshots({ privileged });
   const created = after.find((s) => !before.has(s.name)) || after[after.length - 1];
   if (!created) throw new Error('timeshift reported success but no snapshot was found');
@@ -118,15 +165,39 @@ export async function deleteSnapshot(name, { privileged = 'noninteractive' } = {
   }
   return true;
 }
-/** Resolve the on-disk directory of a snapshot. */
+/**
+ * Resolve the on-disk directory of a snapshot.
+ * BTRFS mode keeps snapshots in a hidden subvolume that Timeshift mounts at
+ * /run/timeshift/backup (e.g. .../timeshift-btrfs/snapshots/<name>) — check the
+ * classic locations first, then search the mounted backup tree.
+ */
 export function snapshotDirFor(snapshot, { privileged = 'noninteractive' } = {}) {
   if (snapshot.dir && fs.existsSync(snapshot.dir)) return snapshot.dir;
   const base = timeshiftDir();
   const candidates = [
     path.join(base, 'snapshots', snapshot.name),
     path.join(base, snapshot.name),
+    `/run/timeshift/backup/${snapshot.name}`,
+    `/run/timeshift/backup/timeshift-btrfs/snapshots/${snapshot.name}`,
+    `/run/timeshift/backup/@/timeshift-btrfs/snapshots/${snapshot.name}`,
   ];
-  return candidates.find((c) => fs.existsSync(c)) || candidates[0];
+  const direct = candidates.find((c) => fs.existsSync(c));
+  if (direct) return direct;
+
+  // Best effort: search the mounted Timeshift backup tree for the snapshot dir.
+  try {
+    if (fs.existsSync('/run/timeshift/backup')) {
+      const found = execaSync(
+        'bash',
+        ['-c', `find /run/timeshift/backup -maxdepth 5 -type d -name '${snapshot.name}' 2>/dev/null | head -1`],
+        { reject: false, timeout: 5000 },
+      ).stdout.trim();
+      if (found) return found;
+    }
+  } catch {
+    /* fall through */
+  }
+  return candidates[0];
 }
 
 /**

package/src/commands/wizard.js

@@ -48,16 +48,16 @@ async function autoUpdateCheck() {
 async function addAccountAction() {
   for (;;) {
     const provider = await p.select({
-      message: 'Which provider?',
+      message: '☁️  Add cloud account',
       options: [
-        { value: 'mega', label: 'MEGA (20 GB free tier)' },
-        { value: 'gdrive', label: 'Google Drive (15 GB free tier)' },
+        { value: 'mega', label: 'MEGA', hint: '20 GB free' },
+        { value: 'gdrive', label: 'Google Drive', hint: '15 GB free' },
         { value: 'back', label: '← Back' },
       ],
     });
     if (p.isCancel(provider) || provider === 'back') return;
     const res = await guidedRemoteAdd({ provider });
-    if (res.ok) p.log.success(`✔ ${pc.bold(res.name)} (${res.provider}) added to the pool.`);
+    if (res.ok) p.log.success(`✔ ${pc.bold(res.name)} added to pool.`);
     else if (res.error) p.log.warn(res.error);
     else if (res.cancelled) { p.log.message(pc.dim('Cancelled.')); return; }
     const again = await p.confirm({ message: 'Add another account?', initialValue: false });
@@ -68,12 +68,12 @@ async function addAccountAction() {
 /** Storage pool sub-menu: list / add / remove / quota. */
 async function accountsMenu() {
   const sub = await p.select({
-    message: 'Storage pool — accounts are rclone remotes (MEGA / Google Drive)',
+    message: '🗂 Storage Pool',
     options: [
-      { value: 'list', label: '🔎 List accounts & quotas' },
-      { value: 'add', label: '➕ Add account to the pool (existing rclone remote)' },
-      { value: 'remove', label: '➖ Remove account from the pool' },
-      { value: 'quota', label: '📐 Set an account quota (GiB)' },
+      { value: 'list', label: '📊 Show accounts', hint: 'quotas and usage' },
+      { value: 'add', label: '➕ Add account', hint: 'existing rclone remote' },
+      { value: 'remove', label: '➖ Remove account', hint: 'from pool only' },
+      { value: 'quota', label: '📐 Set quota', hint: 'override account limit' },
       { value: 'back', label: '← Back' },
     ],
   });
@@ -199,13 +199,13 @@ async function listBackupsAction() {
 /** Restore files or a system snapshot. */
 async function restoreMenu() {
   const accs = listAccounts();
-  if (!accs.length) { p.log.warn('No accounts configured — nothing to restore from cloud yet.'); return; }
+  if (!accs.length) { p.log.warn('No cloud accounts configured yet.'); return; }
   const cfg = loadConfig();
   const kind = await p.select({
-    message: 'Restore what?',
+    message: '♻️  Restore backup',
     options: [
-      { value: 'files', label: '📄 File backup (fonts/images/docs into a folder)' },
-      { value: 'snapshot', label: '💽 System snapshot (overwrites the running system)', hint: '[sudo]' },
+      { value: 'files', label: '📄 Files', hint: 'recover documents, images, etc.' },
+      { value: 'snapshot', label: '💽 System snapshot', hint: 'full system restore [sudo]' },
       { value: 'back', label: '← Back' },
     ],
   });
@@ -256,10 +256,10 @@ async function restoreMenu() {
 /** Always-on service sub-menu. */
 async function serviceMenu() {
   const sub = await p.select({
-    message: 'Always-on background service (systemd user unit / cron fallback)',
+    message: '⏱ Schedule Service',
     options: [
-      { value: 'install', label: '✅ Install service' },
-      { value: 'remove', label: '❌ Remove service' },
+      { value: 'install', label: '✅ Enable', hint: 'auto-backup on schedule' },
+      { value: 'remove', label: '❌ Disable', hint: 'stop auto-backup' },
       { value: 'back', label: '← Back' },
     ],
   });
@@ -275,12 +275,13 @@ async function serviceMenu() {
 
 /** Daemon sub-menu. */
 async function daemonMenu() {
+  const running = daemonRunning();
   const sub = await p.select({
-    message: `Daemon is currently ${daemonRunning() ? pc.green('running') : pc.yellow('stopped')}`,
+    message: `🤖 Daemon ${running ? pc.green('●') : pc.yellow('○')} ${running ? 'running' : 'stopped'}`,
     options: [
-      { value: 'start', label: '▶️  Start daemon' },
-      { value: 'stop', label: '⏹  Stop daemon' },
-      { value: 'status', label: '📊 Show status' },
+      { value: 'start', label: '▶️  Start' },
+      { value: 'stop', label: '⏹️  Stop' },
+      { value: 'status', label: '📊 Status' },
       { value: 'back', label: '← Back' },
     ],
   });
@@ -302,7 +303,7 @@ async function daemonMenu() {
  * prompt just returns you to this menu.
  */
 export async function runWizard() {
-  p.intro(pc.bgYellow(pc.black(` 🦜 parrot-blackbox v${pkg.version} `)));
+  p.intro(`🦜 ${pc.bold('parrot-blackbox')} ${pc.dim(`v${pkg.version}`)}`);
 
   if (!process.stdin.isTTY) {
     p.log.warn('No interactive terminal detected — run subcommands directly: `parrot-blackbox help`');
@@ -317,27 +318,27 @@ export async function runWizard() {
     const action = await p.select({
       message: 'What would you like to do?',
       options: [
-        { value: 'add', label: '➕ Add cloud account  (MEGA / Google Drive)', hint: 'sets up rclone for you' },
-        { value: 'accounts', label: '🗂 Storage pool', hint: 'list / add / remove / quota' },
-        { value: 'tools', label: '🛠 Check & install tools', hint: 'rclone, timeshift, git, curl' },
-        { value: 'snapshot', label: '📸 Snapshot now', hint: 'create + upload a weekly snapshot' },
-        { value: 'backup', label: '💾 Run backup now', hint: 'every enabled job (default = snapshot)' },
-        { value: 'list', label: '📋 List backups', hint: 'local + cloud snapshots, file backups' },
-        { value: 'restore', label: '♻️  Restore', hint: 'files or system snapshot' },
-        { value: 'service', label: '⏱ Always-on service', hint: 'install / remove' },
-        { value: 'daemon', label: '🐚 Daemon', hint: 'start / stop / status' },
-        { value: 'setup', label: '🧭 Guided setup', hint: 'walk every setup step' },
-        { value: 'status', label: '📊 Status', hint: 'quick overview' },
+        { value: 'snapshot', label: '📸 Create snapshot', hint: 'backup your system now' },
+        { 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' },
+        { value: 'add', label: '☁️  Add cloud account', hint: 'MEGA or Google Drive' },
+        { value: 'accounts', label: '🗂  Manage storage', hint: 'pool, quotas, accounts' },
+        { value: 'setup', label: '🚀 Guided setup', hint: 'first-time configuration' },
+        { value: 'tools', label: '🔧 Check tools', hint: 'install missing dependencies' },
+        { value: 'service', label: '⏱  Schedule service', hint: 'auto-backup setup' },
+        { value: 'daemon', label: '🤖 Daemon control', hint: 'start / stop / status' },
+        { value: 'status', label: '📊 Status', hint: 'quick health check' },
         { value: 'doctor', label: '🩺 Doctor', hint: 'full diagnostics' },
-        { value: 'repair', label: '🛠  Repair broken install', hint: 'check tools, config, service, pool' },
-        { value: 'update', label: '🔄 Update parrot-blackbox', hint: 'check npm & install latest' },
-        { value: 'uninstall', label: '🗑 Uninstall', hint: 'remove everything (cloud kept)' },
-        { value: 'exit', label: '📴 Exit', hint: 'leave the wizard' },
+        { value: 'repair', label: '🛠️  Repair', hint: 'fix broken installation' },
+        { value: 'update', label: '⬆️  Update', hint: 'check for new version' },
+        { value: 'uninstall', label: '🗑️  Uninstall', hint: 'remove parrot-blackbox' },
+        { value: 'exit', label: '👋 Exit' },
       ],
     });
 
     if (p.isCancel(action) || action === 'exit') {
-      p.outro('Bye! 👋');
+      p.outro('👋 See you later!');
       return;
     }
 
@@ -363,6 +364,6 @@ export async function runWizard() {
     } catch (e) {
       p.log.warn(`✖ ${e.message}`);
     }
-    p.log.message(pc.dim('──────────────────────────────────────────'));
+    p.log.message('');
   }
 }

package/src/util/network.js

@@ -3,24 +3,58 @@
  * the daemon observes the laptop coming back online, pending backups run
  * immediately in order.
  *
+ * Probes MULTIPLE hosts — if any answers, we are online. On some networks a
+ * specific host (e.g. api.mega.nz) fails to resolve even though the internet
+ * works, so a single-host probe falsely reports "offline" and defers every
+ * backup forever.
+ *
  * Overridable in tests via PBB_NETWORK=offline|online.
  */
 
 import { execa } from 'execa';
 import { loadConfig } from '../core/store.js';
 
+const FALLBACK_HOSTS = [
+  'https://api.github.com',
+  'https://www.google.com',
+  'https://api.mega.nz',
+];
+
 export async function isOnline() {
   if (process.env.PBB_NETWORK === 'offline') return false;
   if (process.env.PBB_NETWORK === 'online') return true;
 
   const cfg = loadConfig();
-  const host = cfg.network.pingHost || 'https://api.mega.nz';
+  const hosts = [
+    cfg.network.pingHost,
+    ...(Array.isArray(cfg.network.pingHosts) ? cfg.network.pingHosts : []),
+    ...FALLBACK_HOSTS,
+  ].filter(Boolean);
+  const unique = [...new Set(hosts)];
+
+  for (const host of unique) {
+    try {
+      // `-f`/fail-on-HTTP-error is WRONG here: reachable hosts legitimately
+      // return 403/404/5xx (e.g. api.github.com HEAD is frequently 403). Any
+      // HTTP response proves DNS+connect+internet — that is all we need.
+      const res = await execa('curl', ['-sS', '-o', '/dev/null', '--connect-timeout', '4', '--max-time', '6', host], {
+        reject: false,
+      });
+      if (res.exitCode === 0) return true;
+      // Also treat any HTTP response line as online even if curl -sS -o returned
+      // non-zero (some proxies set code but curl reports 8/18/52).
+    } catch {
+      /* try next host */
+    }
+  }
+  // Last resort: a bare TCP connect to a well-known IP proves L3 connectivity.
   try {
-    const res = await execa('curl', ['-fsSI', '--connect-timeout', '5', '--max-time', '10', host], {
+    const res = await execa('curl', ['-sS', '-o', '/dev/null', '--connect-timeout', '3', '--max-time', '5', 'http://1.1.1.1'], {
       reject: false,
     });
-    return res.exitCode === 0;
+    if (res.exitCode === 0) return true;
   } catch {
-    return false;
+    /* give up */
   }
+  return false;
 }