parrot-blackbox 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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';
@@ -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 } from '../util/sudo.js';
+import { sudoInteractive, sudoNonInteractive, sudoInteractiveCapture } from '../util/sudo.js';
 
 export class SudoDeferredError extends Error {
   constructor() {
@@ -26,22 +26,39 @@ export class SudoDeferredError extends Error {
 }
 
 /**
- * Parse `timeshift --list` output into snapshots.
+ * Parse `timeshift --list` output into snapshots. Tolerant of the table format
+ * used by Timeshift 22.x/23.x/24.x (leading "Num" column + header rows) AND the
+ * older plain format:
+ *
+ *   Next run: daily at 22:00
+ *   Num     Name                            Tags                Description
+ *   0   2026-08-31 16:00:01  W  2026-08-31_16-00-01  parrot-blackbox
+ *
  * @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);
+    // Optional leading Num column; date TIME tags NAME [description…]
+    const 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) continue;
     const [, date, time, tags, dirOrSize, detail] = m;
-    const name = `${date}_${time.replace(/:/g, '-')}`;
+    // 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(dirOrSize)
+      ? dirOrSize
+      : `${date}_${time.replace(/:/g, '-')}`;
     const dir = findPathInLine(line);
     out.push({ name, date, time, tags, dir, line: `${date} ${time} ${tags} ${dirOrSize}${detail ? ` ${detail}` : ''}` });
   }
   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) || [];
@@ -50,18 +67,33 @@ function findPathInLine(line) {
     null;
 }
 
-/** `timeshift --list` works WITHOUT root — run it directly (no sudo hang risk). */
-async function runTimeshiftList() {
+/**
+ * `timeshift --list` needs admin on most installs — run it with sudo.
+ * Interactive: capture stdout while keeping stdin (so the sudo password
+ * prompt works). Non-interactive: `sudo -n`, falling back to a direct call
+ * for the few builds that allow unprivileged listing.
+ */
+async function runTimeshiftList({ privileged = 'noninteractive' } = {}) {
+  if (privileged === 'interactive') {
+    try {
+      const res = await sudoInteractiveCapture(['timeshift', '--list']);
+      return (res.exitCode === 0 ? res.stdout : res.stdout || res.stderr) || '';
+    } catch {
+      return '';
+    }
+  }
   try {
-    const res = await execa('timeshift', ['--list'], { reject: false });
-    return (res.exitCode === 0 ? res.stdout : res.stdout || res.stderr) || '';
+    const res = await sudoNonInteractive(['timeshift', '--list']);
+    if (res.exitCode === 0) return res.stdout || '';
+    const direct = await execa('timeshift', ['--list'], { reject: false });
+    return (direct.exitCode === 0 ? direct.stdout : direct.stdout || direct.stderr) || '';
   } catch {
     return '';
   }
 }
 
 export async function listLocalSnapshots({ privileged = 'noninteractive' } = {}) {
-  const text = await runTimeshiftList();
+  const text = await runTimeshiftList({ privileged });
   return parseTimeshiftList(text);
 }
 
@@ -70,18 +102,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 || ''}`;
+  }
+
+  // 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() };
   }
 
-  // Find which snapshot appeared.
+  // 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');
@@ -103,15 +145,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/manage.js

@@ -185,14 +185,29 @@ export async function runRepair({ auto = false } = {}) {
   // 3. Service
   try {
     const { serviceFile, daemonLogFile } = await import('../core/paths.js');
-    const { serviceBackend } = await import('./service.js');
+    const { serviceBackend, installService } = await import('./service.js');
     const fsMod = await import('node:fs');
-    if (serviceBackend() === 'systemd' && !fsMod.existsSync(serviceFile())) {
-      const backend = await installService();
-      p.log.success(`Always-on service re-installed via ${backend}.`);
-      fixed.push('service');
+    if (serviceBackend() === 'systemd') {
+      // The ExecStart line must reference a REAL absolute path; the v1.0.4 unit
+      // wrote `node parrot-blackbox daemon foreground` (bare name) which crashed
+      // with "Cannot find module '/home/artkins/parrot-blackbox'".
+      let unitOk = false;
+      try {
+        const unit = fsMod.readFileSync(serviceFile(), 'utf8');
+        const execLine = unit.split('\n').find((l) => l.startsWith('ExecStart=')) || '';
+        unitOk = fsMod.existsSync(serviceFile()) && /ExecStart=\S+/.test(execLine) && /\//.test(execLine);
+      } catch {
+        unitOk = false;
+      }
+      if (!unitOk) {
+        const backend = await installService();
+        p.log.success(`Always-on service re-written via ${backend}.`);
+        fixed.push('service');
+      } else {
+        p.log.success('Service OK.');
+      }
     } else {
-      p.log.success('Service OK.');
+      p.log.success('Service backend OK.');
     }
   } catch (e) {
     p.log.warn(`Service check failed: ${e.message}`);

package/src/commands/service.js

@@ -7,6 +7,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { execa } from 'execa';
 import { serviceFile, daemonLogFile } from '../core/paths.js';
 import { loadConfig, journal, hasCommandSync } from '../core/store.js';
@@ -15,6 +16,8 @@ function findCliBin() {
   // npm-installed global binary (preferred) or our own bin entry.
   const candidates = [
     process.env.PBB_BIN,
+    // This module lives in src/commands/ → ../../bin/parrot-blackbox.js
+    path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'bin', 'parrot-blackbox.js'),
     path.join(path.dirname(process.argv[1] || ''), 'parrot-blackbox.js'),
   ];
   return candidates.find((c) => c && fs.existsSync(c)) || 'parrot-blackbox';

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;
 }