parrot-blackbox 2.0.9 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "2.0.9",
+  "version": "2.1.1",
   "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/git-exclude.js

@@ -49,7 +49,21 @@ export function collectFiles(sources, { exclude = [], home = process.env.HOME }
 
   for (const src of sources) {
     const abs = expandPath(src, home);
-    if (!fs.existsSync(abs)) {
+    let st;
+    try {
+      st = fs.statSync(abs); // throws → source is missing
+    } catch {
+      missing.push(src);
+      continue;
+    }
+
+    // A bare FILE source (e.g. `~/.gitconfig`) is backed up verbatim.
+    if (st.isFile()) {
+      files.push({ abs, rel: path.basename(abs) || 'file' });
+      continue;
+    }
+    // Sockets / FIFOs / devices aren't copyable as sources — skip cleanly.
+    if (!st.isDirectory()) {
       missing.push(src);
       continue;
     }
@@ -91,9 +105,10 @@ export function collectFiles(sources, { exclude = [], home = process.env.HOME }
           continue;
         }
         walk(eAbs, rel, sourceRoot);
-      } else {
+      } else if (st.isFile()) {
         files.push({ abs: eAbs, rel });
       }
+      // sockets / FIFOs / devices can't be copied — silently skipped.
     }
   }
 

package/src/backup/restore.js

@@ -22,16 +22,15 @@ import { listLocalSnapshots } from './snapshot.js';
 import { ensureSudo, sudoInteractive } from '../util/sudo.js';
 import { bytesHuman } from '../util/misc.js';
 
-/** Restore a file backup generation into a writable local directory. */
-export async function restoreFiles({ id, toDir, accounts, cfg, onProgress }) {
-  const found = await discoverManifest('files', id, accounts, cfg.storage.remoteRoot);
+/** Restore a file-backup generation (or an urgent backup) into a writable local directory. */
+export async function restoreFiles({ id, toDir, accounts, cfg, kind = 'files', onProgress }) {
+  const found = await discoverManifest(kind, id, accounts, cfg.storage.remoteRoot);
   if (!found) {
-    // Fall back to scanning every account for the artifact id.
-    throw new Error(`no file backup found for id "${id}" — check with \`parrot-blackbox list\``);
+    throw new Error(`no ${kind} backup found for id "${id}" — check with \`parrot-blackbox list\``);
   }
   fs.mkdirSync(toDir, { recursive: true });
   const res = await restoreArtifact(found.manifest, toDir, { onProgress });
-  journal('restore', `files id=${id} -> ${toDir} files=${res.files} bytes=${res.bytes}`);
+  journal('restore', `${kind} id=${id} -> ${toDir} files=${res.files} bytes=${res.bytes}`);
   return { id, toDir, ...res, manifest: found.manifest };
 }
 

package/src/backup/urgent.js

@@ -0,0 +1,147 @@
+/**
+ * The URGENT backup — a fast, one-off rescue artifact for a fresh install.
+ *
+ * It bundles the user's real working files (Desktop / Downloads / Documents /
+ * Music / Pictures / Programming / Videos / Learning) PLUS the tooling needed
+ * to be productive on day one:
+ *   - VS Codium data profile + extensions (+ shared storage / user config)
+ *   - gitswitch bookkeeping + the SSH keys it manages + git config
+ *
+ * Design notes (why this is intentionally NOT the daily files job):
+ *   - It uses its own fixed source list, so it never depends on the user's
+ *     config having the right sources enabled.
+ *   - It still honours the golden rule: git-tracked trees are skipped (GitHub
+ *     already owns them) and the lean exclude list drops bloat (node_modules,
+ *     caches, session noise).
+ *   - It uploads through the same smart storage pool under a DISTINCT kind
+ *     ('urgent') so it is never confused with — or pruned by — scheduled
+ *     backups, and is cleanly restorable via the existing restore flow.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig, loadState, saveState, journal } from '../core/store.js';
+import { stagingDir } from '../core/paths.js';
+import { iso, clock } from '../core/time.js';
+import { refreshAccounts } from '../storage/accounts.js';
+import { planAndPlace } from '../storage/allocator.js';
+import { collectFiles, stageFiles, sumFiles } from './git-exclude.js';
+
+/** Cloud artifact kind (a distinct bucket from 'files' / 'snapshots'). */
+export const KIND = 'urgent';
+
+/** Everything the urgent backup takes from the home directory. */
+export const URGENT_SOURCES = [
+  // Working files
+  '~/Desktop',
+  '~/Downloads',
+  '~/Documents',
+  '~/Learning',
+  '~/Music',
+  '~/Pictures',
+  '~/Programming',
+  '~/Videos',
+  // VS Codium — data profile + extensions + shared storage + user config
+  '~/.vscode-oss',
+  '~/.vscode-oss-shared',
+  '~/.config/VSCodium/User',
+  // gitswitch — accounts/SSH bookkeeping, the SSH keys it manages, git config
+  '~/.gitswitch',
+  '~/.ssh',
+  '~/.gitconfig',
+];
+
+/** Lean exclude list — git repos + bloat are out, real files are in. */
+export const URGENT_EXCLUDE = [
+  '**/.cache/**',
+  '**/.git/**',
+  '**/node_modules/**',
+  '**/__pycache__/**',
+  '**/*.tmp',
+  '**/*.swp',
+  '**/*.log',
+  '**/lost+found/**',
+  // VS Codium cache / session noise — the profile is what matters, not caches.
+  '**/Cache/**',
+  '**/CachedData/**',
+  '**/CachedExtensionVSIXs/**',
+  '**/GPUCache/**',
+  '**/blob_storage/**',
+  '**/Code Cache/**',
+  '**/Crashpad/**',
+  '**/Service Worker/**',
+  '**/WebStorage/**',
+  '**/Local Storage/**',
+  '**/Session Storage/**',
+];
+
+/**
+ * Collect + stage the urgent sources into a fresh bundle dir.
+ * @returns {{dir:string, files:Array, sizeBytes:number, skippedRepos:string[], missing:string[], skipped:number}}
+ */
+export function buildUrgentBundle({ home = process.env.HOME } = {}) {
+  const col = collectFiles(URGENT_SOURCES, { exclude: URGENT_EXCLUDE, home });
+  const dir = path.join(stagingDir(), `urgent-${Date.now()}-${process.pid}`);
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(dir, { recursive: true });
+  stageFiles(col.files, dir);
+  return {
+    dir,
+    files: col.files,
+    sizeBytes: sumFiles(col.files),
+    skippedRepos: col.skippedRepos,
+    missing: col.missing,
+    skipped: col.skipped,
+  };
+}
+
+/**
+ * Run one URGENT backup generation — bundle → stage → upload to the pool.
+ * Unlike scheduled backups this does NOT run retention, so the rescue artifact
+ * is never auto-deleted.
+ * @returns {Promise<{id:string, manifest:object, sizeBytes:number, skippedRepos:string[], missing:string[]}>}
+ */
+export async function runUrgentBackup(cfg = loadConfig(), state = loadState(), { onProgress } = {}) {
+  const now = clock();
+  const id = iso(now);
+  journal('urgent', `start id=${id}`);
+  const bundle = buildUrgentBundle();
+
+  const accounts = await refreshAccounts(cfg);
+  if (!accounts.length) {
+    fs.rmSync(bundle.dir, { recursive: true, force: true });
+    throw new Error('No cloud accounts configured — run `parrot-blackbox account add` (or Guided Setup) first.');
+  }
+
+  let manifest;
+  try {
+    manifest = await planAndPlace(bundle.dir, {
+      kind: KIND,
+      id,
+      accounts,
+      remoteRoot: cfg.storage.remoteRoot,
+      chunkSize: cfg.storage.chunkSize,
+      onProgress,
+    });
+  } finally {
+    fs.rmSync(bundle.dir, { recursive: true, force: true });
+  }
+
+  state.manifests[`${KIND}-${manifest.id}`] = {
+    kind: KIND,
+    id: manifest.id,
+    createdAt: manifest.createdAt,
+    totalSize: manifest.totalSize,
+    entryCount: manifest.entries?.length || 0,
+  };
+  saveState(state);
+  journal('urgent', `done id=${id} bytes=${manifest.totalSize}`);
+
+  return {
+    id,
+    manifest,
+    sizeBytes: manifest.totalSize,
+    skippedRepos: bundle.skippedRepos,
+    missing: bundle.missing,
+  };
+}

package/src/cli.js

@@ -14,6 +14,7 @@ import { installService, removeService } from './commands/service.js';
 import { runDueJobs } from './daemon/scheduler.js';
 import { startDaemon, stopDaemon, daemonRunning } from './daemon/daemon.js';
 import { runSnapshotNow, listLocalSnapshots, pruneSnapshots, deleteSnapshot, deleteAllSnapshots } from './backup/snapshot.js';
+import { runUrgentBackup } from './backup/urgent.js';
 import { restoreSnapshot, restoreFiles } from './backup/restore.js';
 import { listAccounts, addAccount, removeAccount, refreshAccounts, poolSummary } from './storage/accounts.js';
 import { listArtifacts } from './storage/archive.js';
@@ -52,6 +53,7 @@ ${pc.bold('Usage:')}
   parrot-blackbox snapshot list       List local & cloud snapshots
   parrot-blackbox snapshot delete [<name>|--all]  Delete one or all local snapshots  ${pc.dim('[sudo]')}
   parrot-blackbox snapshot prune      Delete snapshots beyond the keep limit  ${pc.dim('[sudo]')}
+  parrot-blackbox urgent              ⚡ One-off rescue backup: working files + VS Codium + gitswitch/SSH data
   parrot-blackbox list [files]        List cloud file backups
   parrot-blackbox restore             Restore a snapshot or file backup       ${pc.dim('[sudo]')}
   parrot-blackbox account add         Add a MEGA / Google Drive account (remote must already exist)
@@ -132,6 +134,12 @@ async function listFiles() {
   for (const a of artifacts) {
     console.log(`  - ${pc.cyan(a.id)}  ${bytesHuman(a.totalSize)}  ${pc.dim(a.account)}`);
   }
+  const urgent = await listArtifacts('urgent', accs, cfg.storage.remoteRoot);
+  console.log(`\n${pc.bold('Cloud urgent backups:')}`);
+  if (urgent.length === 0) console.log(`  ${pc.dim('none yet — run `parrot-blackbox urgent`')}`);
+  for (const a of urgent) {
+    console.log(`  - ${pc.cyan(a.id)}  ${bytesHuman(a.totalSize)}  ${pc.dim(a.account)}`);
+  }
   console.log();
 }
 
@@ -162,13 +170,14 @@ async function restoreFlow(rest) {
     options: [
       { value: 'snapshot', label: 'System snapshot (Timeshift) — overwrites the whole system', hint: '[sudo]' },
       { value: 'files', label: 'File backup — recover fonts/images/docs into a folder' },
+      { value: 'urgent', label: 'Urgent backup — user files + tool profiles (fresh install)' },
     ],
   }));
   if (p.isCancel(kind)) return;
 
-  if (kind === 'files') {
-    const artifacts = await listArtifacts('files', accs, cfg.storage.remoteRoot);
-    if (artifacts.length === 0) { p.log.warn('No file backups found.'); return; }
+  if (kind === 'files' || kind === 'urgent') {
+    const artifacts = await listArtifacts(kind, accs, cfg.storage.remoteRoot);
+    if (artifacts.length === 0) { p.log.warn(`No ${kind === 'urgent' ? 'urgent' : 'file'} backups found.`); return; }
     const id = rest[1] || (await p.select({
       message: 'Pick a backup generation:',
       options: artifacts.map((a) => ({ value: a.id, label: `${a.id}  (${bytesHuman(a.totalSize)})` })),
@@ -181,7 +190,7 @@ async function restoreFlow(rest) {
     const s = p.spinner();
     s.start('Restoring…');
     try {
-      const res = await restoreFiles({ id, toDir, accounts: accs, cfg });
+      const res = await restoreFiles({ id, toDir, accounts: accs, cfg, kind });
       s.stop(`✔ Restored ${res.files} file(s), ${bytesHuman(res.bytes)} into ${toDir}`);
     } catch (e) {
       s.stop('✖ Restore failed.');
@@ -408,6 +417,23 @@ const main = defineCommand({
         return;
       }
 
+      case 'urgent': {
+        // One-off rescue backup — working files + VS Codium + gitswitch/SSH data.
+        const progress = makeProgressRenderer();
+        try {
+          const r = await runUrgentBackup(undefined, undefined, { onProgress: progress });
+          progress.stop();
+          console.log(`${pc.green('✔')} Urgent backup stored (${bytesHuman(r.sizeBytes)}). Restore with: \`parrot-blackbox restore urgent\`.`);
+          if (r.skippedRepos?.length) console.log(pc.dim(`Skipped ${r.skippedRepos.length} git-tracked folder(s).`));
+          if (r.missing?.length) console.log(pc.dim(`Source(s) not present, skipped: ${r.missing.join(', ')}.`));
+        } catch (e) {
+          progress.stop();
+          console.error(pc.red(`✖ ${e.message}`));
+          process.exitCode = 1;
+        }
+        return;
+      }
+
       case 'snapshot': {
         const [sub, ...args] = rest;
         if (sub === 'now' || sub === 'create' || sub === 'force') {

package/src/commands/wizard.js

@@ -18,6 +18,7 @@ import { listAccounts, refreshAccounts, poolSummary, addAccount, removeAccount }
 import { loadConfig, saveConfig } from '../core/store.js';
 import { runDueJobs } from '../daemon/scheduler.js';
 import { runSnapshotNow, listLocalSnapshots, deleteSnapshot, deleteAllSnapshots, nextSnapshotUploadMode } from '../backup/snapshot.js';
+import { runUrgentBackup } from '../backup/urgent.js';
 import { listArtifacts } from '../storage/archive.js';
 import { restoreFiles, restoreSnapshot } from '../backup/restore.js';
 import { installService, removeService } from './service.js';
@@ -177,6 +178,33 @@ async function backupNowAction() {
   }
 }
 
+/** One-off rescue backup: working files + VS Codium + gitswitch/SSH data (fast, for a fresh install). */
+async function urgentBackupAction() {
+  const cfg = loadConfig();
+  if (!listAccounts().length) { p.log.warn('No cloud accounts configured — add one from the menu first.'); return; }
+  const { URGENT_SOURCES } = await import('../backup/urgent.js');
+  const names = URGENT_SOURCES.map((s) => s.replace(/^~\//, ''));
+  const ok = await p.confirm({
+    message: pc.bold(`⚡ Urgent backup: ${names.length} sources`) +
+      pc.dim(` — ${names.join(', ')}.`) +
+      pc.dim('\nGit-tracked folders are skipped (already on GitHub); only real files + tool profiles are stored. Continue?'),
+    initialValue: true,
+  });
+  if (p.isCancel(ok) || !ok) { p.log.message(pc.dim('Cancelled — nothing was backed up.')); return; }
+
+  const progress = makeClackProgressRenderer(p);
+  try {
+    const r = await runUrgentBackup(cfg, undefined, { onProgress: progress });
+    p.log.success(`✔ Urgent backup stored (${bytesHuman(r.sizeBytes)}). Restore later via: Restore backup → Urgent backup.`);
+    if (r.skippedRepos?.length) p.log.message(pc.dim(`Skipped ${r.skippedRepos.length} git-tracked folder(s).`));
+    if (r.missing?.length) p.log.message(pc.dim(`Source(s) not present, skipped: ${r.missing.join(', ')}.`));
+  } catch (e) {
+    p.log.warn(`✖ ${e.message}`);
+  } finally {
+    progress.stop();
+  }
+}
+
 /** Create + upload a snapshot immediately. */
 async function snapshotNowAction() {
   try {
@@ -224,6 +252,10 @@ async function listBackupsAction() {
     const files = await listArtifacts('files', accs, cfg.storage.remoteRoot);
     if (!files.length) p.log.message(pc.dim('  none'));
     for (const f of files) p.log.message(`  - ${pc.cyan(f.id)}  ${bytesHuman(f.totalSize)}`);
+    p.log.message(pc.bold('Cloud urgent backups:'));
+    const urgent = await listArtifacts('urgent', accs, cfg.storage.remoteRoot);
+    if (!urgent.length) p.log.message(pc.dim('  none'));
+    for (const u of urgent) p.log.message(`  - ${pc.cyan(u.id)}  ${bytesHuman(u.totalSize)}`);
   } else {
     p.log.message(pc.dim('No accounts configured — add one from the menu.'));
   }
@@ -314,7 +346,27 @@ async function deleteSnapshotsMenu() {
   }
 }
 
-/** Restore files or a system snapshot. */
+/** Restore a file-like artifact ('files' or 'urgent') into a fresh directory. */
+async function restoreFileLike(kind, accs, cfg) {
+  const artifacts = await listArtifacts(kind, accs, cfg.storage.remoteRoot);
+  if (!artifacts.length) { p.log.warn(`No ${kind === 'urgent' ? 'urgent' : 'file'} backups found.`); return; }
+  const id = await p.select({
+    message: 'Pick a backup to restore:',
+    options: artifacts.map((a) => ({ value: a.id, label: `${a.id}  (${bytesHuman(a.totalSize)})` })).concat([{ value: '__back', label: '← Back' }]),
+  });
+  if (p.isCancel(id) || id === '__back') return;
+  const toDir = await p.text({ message: 'Restore into which directory?', initialValue: `./restored-${id}` });
+  if (p.isCancel(toDir) || !toDir) return;
+  fs.mkdirSync(toDir, { recursive: true });
+  try {
+    const res = await restoreFiles({ id, toDir, accounts: accs, cfg, kind });
+    p.log.success(`✔ Restored ${res.files} file(s), ${bytesHuman(res.bytes)} into ${toDir}`);
+  } catch (e) {
+    p.log.warn(`✖ ${e.message}`);
+  }
+}
+
+/** Restore files / urgent backup / system snapshot. */
 async function restoreMenu() {
   const accs = listAccounts();
   if (!accs.length) { p.log.warn('No cloud accounts configured yet.'); return; }
@@ -323,29 +375,15 @@ async function restoreMenu() {
     message: '♻️  Restore backup',
     options: [
       { value: 'files', label: '📄 Files', hint: 'recover documents, images, etc.' },
+      { value: 'urgent', label: '⚡ Urgent backup', hint: 'user files + tool profiles (fresh install)' },
       { value: 'snapshot', label: '💽 System snapshot', hint: 'full system restore [sudo]' },
       { value: 'back', label: '← Back' },
     ],
   });
   if (p.isCancel(kind) || kind === 'back') return;
 
-  if (kind === 'files') {
-    const artifacts = await listArtifacts('files', accs, cfg.storage.remoteRoot);
-    if (!artifacts.length) { p.log.warn('No file backups found.'); return; }
-    const id = await p.select({
-      message: 'Pick a backup generation:',
-      options: artifacts.map((a) => ({ value: a.id, label: `${a.id}  (${bytesHuman(a.totalSize)})` })).concat([{ value: '__back', label: '← Back' }]),
-    });
-    if (p.isCancel(id) || id === '__back') return;
-    const toDir = await p.text({ message: 'Restore into which directory?', initialValue: `./restored-${id}` });
-    if (p.isCancel(toDir) || !toDir) return;
-    fs.mkdirSync(toDir, { recursive: true });
-    try {
-      const res = await restoreFiles({ id, toDir, accounts: accs, cfg });
-      p.log.success(`✔ Restored ${res.files} file(s), ${bytesHuman(res.bytes)} into ${toDir}`);
-    } catch (e) {
-      p.log.warn(`✖ ${e.message}`);
-    }
+  if (kind === 'files' || kind === 'urgent') {
+    await restoreFileLike(kind, accs, cfg);
     return;
   }
 
@@ -445,6 +483,7 @@ export async function runWizard() {
       message: 'What would you like to do?',
       options: [
         { value: 'snapshot', label: '📸 Create snapshot', hint: 'backup your system now' },
+        { value: 'urgent', label: '⚡ Urgent backup', hint: 'files + tool profiles, fast — rescue for a fresh install' },
         { 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' },
@@ -476,6 +515,7 @@ export async function runWizard() {
         case 'accounts': await accountsMenu(); break;
         case 'tools': await runToolsCheck(); break;
         case 'snapshot': await snapshotNowAction(); break;
+        case 'urgent': await urgentBackupAction(); break;
         case 'resume': await snapshotNowAction(); break;
         case 'backup': await backupNowAction(); break;
         case 'list': await listBackupsAction(); break;

package/src/storage/allocator.js

@@ -122,12 +122,12 @@ export async function planAndPlace(localDir, { kind, id, accounts, remoteRoot, c
     entries: [],
   };
 
-  const report = (done, text) => {
-    if (typeof onProgress === 'function') onProgress({ done, total: files.length, text });
+  const emit = (done, text, remote) => {
+    if (typeof onProgress === 'function') onProgress({ done, total: totalSize, text, remote });
   };
 
   // PASS 1: Planning
-  report(0, 'planning allocations...');
+  emit(0, 'planning allocations...');
   const batches = new Map(); // account.remote -> array of relative paths
   const splits = []; // files that need splitting
 
@@ -162,24 +162,30 @@ export async function planAndPlace(localDir, { kind, id, accounts, remoteRoot, c
 
   // PASS 2: Batch Uploading (Sequential accounts, but parallel files inside rclone)
   const batchDir = process.env.PBB_STATE_DIR || '/tmp';
-  let placed = 0;
-  
+  const fileSizes = new Map(files.map((f) => [f.rel, f.size]));
+  const batchBytes = (rels) => rels.reduce((s, r) => s + (fileSizes.get(r) ?? 0), 0);
+  let placedBytes = 0;
+
   for (const [remote, batch] of batches.entries()) {
     if (batch.files.length === 0) continue;
     const batchPath = path.join(batchDir, `batch-${remote.replace(/[^a-z0-9]/gi, '_')}-${Date.now()}.txt`);
     fs.writeFileSync(batchPath, batch.files.join('\n') + '\n');
-    
+
     // Ensure the remote directory exists to prevent "directory not found" errors
     // when rclone tries to list the destination for --files-from checking.
     await mkdirRemote(`${remote}:${basePath}`);
-    
-    report(placed, `uploading batch of ${batch.files.length} files to ${remote}...`);
-    const res = await copyBatch(localDir, `${remote}:${basePath}`, batchPath);
+
+    const thisBatchBytes = batchBytes(batch.files);
+    const label = `uploading ${batch.files.length} file(s) → ${remote}`;
+    emit(placedBytes, label, remote);
+    const res = await copyBatch(localDir, `${remote}:${basePath}`, batchPath, {
+      onProgress: (p) => emit(placedBytes + p.done, label, remote),
+    });
     if (!res.ok) throw new Error(`batch upload failed to ${remote}: ${res.error}`);
-    
+
     fs.unlinkSync(batchPath);
-    placed += batch.files.length;
-    report(placed, `placed ${placed}/${files.length}`);
+    placedBytes += thisBatchBytes;
+    emit(placedBytes, `uploaded ${bytesHuman(placedBytes)}`, remote);
   }
 
   // PASS 3: Split large files
@@ -189,27 +195,27 @@ export async function planAndPlace(localDir, { kind, id, accounts, remoteRoot, c
     const locs = [];
     let start = 0;
     let partIndex = 0;
-    
-    report(placed, `splitting huge file ${rel}...`);
+
+    emit(placedBytes, `splitting huge file ${rel}...`);
     while (start < entry.size) {
       const len = Math.min(chunkSize, entry.size - start);
       const acc = chooseAccount(len, pool);
       if (!acc) throw outOfSpace();
-      
+
       const partAbs = await makePartFile(entry, start, len);
       const partPath = `${destPath}.part-${String(partIndex).padStart(4, '0')}`;
-      
+
       const res = await copyToFile(partAbs, `${acc.remote}:${partPath}`);
       if (!res.ok) throw new Error(`upload failed for ${rel} part on ${acc.remote}: ${res.error}`);
-      
+
       consume(acc, len);
       locs.push({ remote: acc.remote, path: partPath, start, end: start + len, size: len });
       start += len;
       partIndex += 1;
+      placedBytes += len;
+      emit(placedBytes, `uploaded ${bytesHuman(placedBytes)}`, acc.remote);
     }
     manifest.entries.push({ rel, type: 'file', size: entry.size, split: true, loc: locs });
-    placed += 1;
-    report(placed, `placed ${placed}/${files.length}`);
   }
 
   // Manifest: cloud + local mirror.

package/src/storage/rclone.js

@@ -71,19 +71,59 @@ export async function copyToFile(localFile, remotePath, { ignoreExisting = false
   return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
 }
 
-/** Copy a batch of files using --files-from. */
-export async function copyBatch(localDir, remotePath, filesFromPath) {
+/** Copy a batch of files using --files-from. When `onProgress` is supplied we
+ *  ask rclone for live transfer stats and parse its `Transferred: X / Y` frames
+ *  so the caller receives byte-level progress as `{ done, total }` (bytes). */
+export async function copyBatch(localDir, remotePath, filesFromPath, { onProgress } = {}) {
   const args = [
     'copy', localDir, remotePath,
     '--files-from', filesFromPath,
     '--transfers=16',
     '--checkers=16',
-    '--fast-list'
+    '--fast-list',
   ];
-  const res = await rejectFalse(args);
+  if (typeof onProgress === 'function') {
+    // rclone emits periodic frames even when stdout is not a TTY (pipelines).
+    args.push('--progress', '--stats=1s');
+  }
+  const child = rejectFalse(args);
+  if (typeof onProgress === 'function') {
+    await consumeProgress(child, onProgress);
+  }
+  const res = await child;
   return { ok: res.exitCode === 0, exitCode: res.exitCode, error: res.stderr?.trim() };
 }
 
+/** Consume rclone's --progress stdout, emitting parsed byte counts per frame. */
+async function consumeProgress(child, onProgress) {
+  let buf = '';
+  for await (const chunk of child.stdout) {
+    buf += chunk;
+    const frames = buf.split(/[\r\n]+/);
+    buf = frames.pop(); // keep a partial trailing frame for the next chunk
+    for (const frame of frames) {
+      const p = parseTransferFrame(frame);
+      if (p) onProgress(p);
+    }
+  }
+  const tail = parseTransferFrame(buf);
+  if (tail) onProgress(tail);
+}
+
+/**
+ * Extract the BYTE `Transferred: <done> / <total>` from an rclone progress
+ * frame. This deliberately requires a size unit (KiB/MiB/GiB/…) so the separate
+ * FILE-count `Transferred: 3 / 5` line is never mistaken for bytes.
+ * @returns {{done:number,total:number}|null}
+ */
+export function parseTransferFrame(frame) {
+  const m = /\bTransferred:\s+([\d.]+\s*(?:[kmgt]i?)?b)\s*\/\s*([\d.]+\s*(?:[kmgt]i?)?b)/i.exec(frame);
+  if (!m) return null;
+  const done = parseBytes(m[1]);
+  const total = parseBytes(m[2]);
+  return done !== null && total !== null ? { done, total } : null;
+}
+
 /** Download a batch of files using --files-from (reverse of copyBatch). */
 export async function downloadBatch(remotePath, localDir, filesFromPath) {
   const args = [