parrot-blackbox 1.0.0

package/src/storage/rclone.js

@@ -0,0 +1,106 @@
+/**
+ * Minimal rclone wrapper. Deliberately thin: every call goes through the
+ * `rclone` binary (works for MEGA and Google Drive alike, and is trivially
+ * stubbed inside the sandbox tests).
+ */
+
+import { execa, execaSync } from 'execa';
+import { parseBytes } from '../util/misc.js';
+
+const RCLONE = process.env.PBB_RCLONE || 'rclone';
+
+function rejectFalse(args, opts = {}) {
+  return execa(RCLONE, args, { reject: false, ...opts });
+}
+
+export async function hasRclone() {
+  try {
+    const res = await execa('bash', ['-c', `command -v ${RCLONE}`], { reject: false });
+    return Boolean(res.stdout.trim());
+  } catch {
+    return false;
+  }
+}
+
+/** `rclone about remote:` → {total, used, free} bytes (nulls when unknown). */
+export async function aboutRemote(remote) {
+  const res = await rejectFalse(['about', ...remote.split(' '), '--json']);
+  if (res.exitCode !== 0) {
+    return { total: null, used: null, free: null, error: res.stderr?.trim() || `exit ${res.exitCode}` };
+  }
+  try {
+    const j = JSON.parse(res.stdout);
+    const toNum = (v) => (typeof v === 'number' ? v : parseBytes(v));
+    return { total: toNum(j.total), used: toNum(j.used), free: toNum(j.free) };
+  } catch {
+    return { total: null, used: null, free: null, error: 'unparsable about output' };
+  }
+}
+
+/** List remote names. */
+export async function listRemotes() {
+  const res = await rejectFalse(['listremotes']);
+  return res.stdout.split('\n').map((l) => l.trim().replace(/:$/, '')).filter(Boolean);
+}
+
+/** Recursive JSON listing of a remote path. */
+export async function lsjson(remotePath, { recursive = true } = {}) {
+  const args = ['lsjson', remotePath];
+  if (recursive) args.push('--recursive');
+  args.push('--json');
+  const res = await rejectFalse(args);
+  if (res.exitCode !== 0) return { ok: false, entries: [], error: res.stderr?.trim() };
+  try {
+    return { ok: true, entries: JSON.parse(res.stdout), error: null };
+  } catch {
+    return { ok: false, entries: [], error: 'unparsable lsjson output' };
+  }
+}
+
+/** Copy a local dir tree into `remote:path` (path created implicitly). */
+export async function copyDir(localDir, remotePath) {
+  const res = await rejectFalse(['copy', localDir, remotePath]);
+  return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
+}
+
+/** Copy a single local file to an exact remote path. */
+export async function copyToFile(localFile, remotePath, { ignoreExisting = false } = {}) {
+  const args = ['copyto', localFile, remotePath];
+  if (ignoreExisting) args.push('--ignore-existing');
+  const res = await rejectFalse(args);
+  return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
+}
+
+/** Create a remote directory. */
+export async function mkdirRemote(remotePath) {
+  const res = await rejectFalse(['mkdir', remotePath]);
+  return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
+}
+
+/** Permanently delete a remote path. */
+export async function purge(remotePath) {
+  const res = await rejectFalse(['purge', remotePath]);
+  return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
+}
+
+/** Fetch a small remote file's contents. */
+export async function catRemote(remotePath) {
+  const res = await rejectFalse(['cat', remotePath]);
+  return { ok: res.exitCode === 0, stdout: res.stdout, error: res.stderr?.trim() };
+}
+
+/** Number of files (recursive) under a remote path; -1 on error. */
+export async function remoteFileCount(remotePath) {
+  const res = await lsjson(remotePath, { recursive: true });
+  if (!res.ok) return -1;
+  return res.entries.filter((e) => !e.IsDir).length;
+}
+
+export function rcloneVersion() {
+  try {
+    const res = execaSync(RCLONE, ['version'], { reject: false });
+    return (res.stdout || res.stderr || '').trim();
+  } catch {
+    return null;
+  }
+}

package/src/util/misc.js

@@ -0,0 +1,114 @@
+/** Small shared utilities: deep merge, sizes, glob-to-regexp, hashing. */
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** Recursive deep merge (later objects win). Arrays are replaced wholesale. */
+export default function deepMerge(base, override) {
+  if (Array.isArray(base) || Array.isArray(override)) {
+    return override === undefined ? base : override;
+  }
+  if (isPlainObj(base) && isPlainObj(override)) {
+    const out = { ...base };
+    for (const key of Object.keys(override)) {
+      out[key] = deepMerge(base[key], override[key]);
+    }
+    return out;
+  }
+  return override === undefined ? base : override;
+}
+
+function isPlainObj(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+export function bytesHuman(n) {
+  if (n === null || n === undefined) return '?';
+  const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+  let v = Number(n);
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  return `${v.toFixed(v >= 10 || i === 0 ? 0 : 1)} ${units[i]}`;
+}
+
+/** Parse `1.5 GiB`, `2048`, `3.2G` → integer bytes. */
+export function parseBytes(str) {
+  if (typeof str === 'number') return str;
+  const m = /^\s*([\d.]+)\s*([kmgt]?i?b?)\s*$/i.exec(String(str ?? ''));
+  if (!m) return null;
+  const mult = { b: 1, kb: 1024, kib: 1024, mb: 1024 ** 2, mib: 1024 ** 2, gb: 1024 ** 3, gib: 1024 ** 3, tb: 1024 ** 4, tib: 1024 ** 4, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 }[m[2].toLowerCase()] ?? 1;
+  return Math.round(parseFloat(m[1]) * mult);
+}
+
+/** sha256 of a file. */
+export async function sha256File(file) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    const s = fs.createReadStream(file);
+    s.on('error', reject);
+    s.on('data', (c) => h.update(c));
+    s.on('end', () => resolve(h.digest('hex')));
+  });
+}
+
+/** Translate a small glob subset to RegExp. Supports **, *, ?, {a,b}. */
+export function globToRegExp(pattern) {
+  let src = String(pattern).replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  src = src.replace(/\*\*/g, '@@DOUBLESTAR@@');
+  src = src.replace(/\*/g, '[^/]*');
+  src = src.replace(/\?/g, '[^/]');
+  src = src.replace(/@@DOUBLESTAR@@/g, '.*');
+  src = src.replace(/{([^}]+)}/g, (_, body) => `(${body.split(',').map((x) => x.trim().replace(/[.+^${}()|[\]\\]/g, '\\$&')).join('|')})`);
+  return new RegExp(`^${src}$`);
+}
+
+/** Does POSIX-ish relative path match any pattern? */
+export function matchesAny(relPath, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  const p = relPath.replace(/\\/g, '/');
+  return patterns.some((pat) => {
+    const rx = globToRegExp(String(pat));
+    return rx.test(p) || rx.test(p + '/');
+  });
+}
+
+/** Recursive byte size of a directory (breaks symlink loops). */
+export function dirSize(dir) {
+  const seen = new Set();
+  function walk(d) {
+    let total = 0;
+    for (const ent of fs.readdirSync(d, { withFileTypes: true })) {
+      const abs = path.join(d, ent.name);
+      let real;
+      try {
+        real = fs.realpathSync(abs);
+      } catch {
+        continue;
+      }
+      if (seen.has(real)) continue;
+      seen.add(real);
+      try {
+        if (ent.isSymbolicLink()) continue;
+        if (ent.isDirectory()) total += walk(abs);
+        else total += fs.statSync(abs).size;
+      } catch {
+        /* skip unreadable */
+      }
+    }
+    return total;
+  }
+  return walk(dir);
+}
+
+/** Safe backtick shell-escape for a single path. */
+export function shellQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+export function pad2(n) {
+  return String(n).padStart(2, '0');
+}

package/src/util/network.js

@@ -0,0 +1,26 @@
+/**
+ * Connectivity check. The offline/online edge is what triggers catch-up: when
+ * the daemon observes the laptop coming back online, pending backups run
+ * immediately in order.
+ *
+ * Overridable in tests via PBB_NETWORK=offline|online.
+ */
+
+import { execa } from 'execa';
+import { loadConfig } from '../core/store.js';
+
+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';
+  try {
+    const res = await execa('curl', ['-fsSI', '--connect-timeout', '5', '--max-time', '10', host], {
+      reject: false,
+    });
+    return res.exitCode === 0;
+  } catch {
+    return false;
+  }
+}

package/src/util/sudo.js

@@ -0,0 +1,56 @@
+/**
+ * Privileged execution.
+ *
+ *  - `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.
+ *
+ * PBB_SUDO_DIRECT=1 (used by unit tests) bypasses sudo entirely.
+ */
+
+import { execa } from 'execa';
+
+function sudoPrefix() {
+  return process.env.PBB_SUDO_DIRECT === '1' ? [] : ['sudo'];
+}
+
+/** Interactive sudo baseline for injecting PBB_SUDO_DIRECT consistent with the rest. */
+export async function sudoInteractive(args, { timeout = 0 } = {}) {
+  const full = [...sudoPrefix(), ...args];
+  const res = await execa(full[0], full.slice(1), { stdio: 'inherit', reject: false, timeout });
+  if (res.exitCode !== 0) {
+    throw new Error(`elevated command failed: ${args.join(' ')} (exit ${res.exitCode})`);
+  }
+  return res;
+}
+
+/**
+ * Interactive sudo that CAPTURES stdout (needed for `timeshift --list` to feed
+ * 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 } = {}) {
+  const full = [...sudoPrefix(), ...args];
+  const res = await execa(full[0], full.slice(1), { stdin: 'inherit', reject: false, timeout });
+  if (res.exitCode !== 0) {
+    throw new Error(`elevated command failed: ${args.join(' ')} (exit ${res.exitCode})`);
+  }
+  return res;
+}
+
+/** Non-interactive sudo (daemon-safe). Returns execa result, never hangs. */
+export async function sudoNonInteractive(args) {
+  const full = process.env.PBB_SUDO_DIRECT === '1' ? args : ['sudo', '-n', ...args];
+  const res = await execa(full[0], full.slice(1), { reject: false });
+  return res;
+}
+
+/** Can the current process currently run privileged commands without a prompt? */
+export async function sudoAvailable() {
+  const res = await sudoNonInteractive(['true']);
+  return res.exitCode === 0;
+}