parrot-blackbox 1.0.0 → 1.0.1

package/README.md

@@ -61,48 +61,93 @@ sudo apt install rclone timeshift git curl
 
 ---
 
-## Install
+## Install (streamlined)
 
 ```bash
 npm install -g parrot-blackbox
 ```
 
-Run the setup wizard:
+Run the setup wizard — it does the whole install for you:
 
 ```bash
 parrot-blackbox
 ```
 
-**The wizard first checks your system and auto-installs anything needed** for
-snapshot backup + restore (`rclone`, `timeshift`, `git`, `curl` — it detects
-your package manager and runs the install with an interactive sudo prompt,
-the gitswitch/theamify way). Then it walks you through: authorizing your
-MEGA / Drive accounts in `rclone config` → registering each remote as an
-account → installing the always-on service → an optional first snapshot.
+**What the wizard does, start to finish:**
+1. **Checks + auto-installs** `rclone`, `timeshift`, `git`, `curl` (interactive
+   sudo prompt, the gitswitch/theamify way).
+2. **Adds your cloud accounts for you** — pick MEGA or Google Drive and enter
+   your email/password; parrot-blackbox creates the rclone remote and registers
+   it in the pool. No raw 68-option `rclone config` menu needed.
+3. Confirms the **schedule** (snapshot every Saturday 22:00).
+4. Installs the **always-on service** (systemd / cron).
+5. Offers to run your **first snapshot** right away.
 
 ---
 
 ## Quick start (the important bit)
 
 ```bash
-# 1. Install, then run the wizard (installs missing tools for you):
+# 1. Install + run the wizard (installs tools, adds accounts, first snapshot):
 npm install -g parrot-blackbox
 parrot-blackbox
 
-# 2. Create your rclone remotes (one per MEGA / Drive account) if not done:
-rclone config
+# 2. If you have MORE MEGA / Drive accounts, add them the same guided way:
+parrot-blackbox remote add mega          # prompts for email/password
+parrot-blackbox remote add gdrive        # opens browser OAuth
+parrot-blackbox remote list              # see remotes + pool registration
 
-# 3. Add them to the pool (repeat for every account):
-parrot-blackbox account add mega mega-account-1
-parrot-blackbox account add gdrive my-drive-1
-parrot-blackbox account list          # see the whole pool + quota
-
-# 4. Force your FIRST snapshot backup right now (do this before a fresh
-#    install — it captures the whole system and uploads it to the cloud):
+# 3. Force your FIRST snapshot backup right now (or again later — it captures
+#    the whole system and uploads it to the cloud):
 parrot-blackbox force
 ```
 
 `parrot-blackbox status` shows the pool, network state, daemon state, last run
+and pending backups.
+
+---
+
+## Managing cloud accounts (rclone remotes)
+
+Every MEGA / Google Drive login becomes one rclone remote = one pool account.
+`parrot-blackbox` manages them for you — you never need to use the raw rclone
+menu except for advanced edits.
+
+**Add** (guided — creates the remote AND saves it in the pool):
+```bash
+parrot-blackbox remote add mega            # prompts: name, email, password, 2FA (optional)
+parrot-blackbox remote add gdrive          # opens browser OAuth for Google
+parrot-blackbox remote add mega mega-1     # or pass the name directly
+# non-interactive (CI): PBB_MEGA_USER=me@x.com PBB_MEGA_PASS=secret parrot-blackbox remote add mega
+```
+
+**List** (which remotes exist + are registered):
+```bash
+parrot-blackbox remote list
+parrot-blackbox account list               # pool usage & free space
+```
+
+**Edit / rename** any remote (advanced, full rclone editor):
+```bash
+parrot-blackbox remote config              # pick the remote → e) Edit, r) Rename, c) Copy
+```
+
+**Delete** a remote entirely (removes the rclone entry AND its pool account):
+```bash
+parrot-blackbox remote remove <name>
+```
+
+**Already configured rclone remotes?** (e.g. an old `mega:` you created long
+ago) — register them into the pool without recreating:
+```bash
+parrot-blackbox account add mega mega      # provider + existing remote name
+parrot-blackbox account list
+```
+
+rclone stores secrets encrypted in `~/.config/rclone/rclone.conf`; parrot-blackbox
+only ever stores the **remote name + provider + optional quota**, never your
+passwords, and the allocator's manifests are safe to share.
+
 ---
 
 ## Commands
@@ -119,10 +164,14 @@ parrot-blackbox force
 | `parrot-blackbox restore` | Interactive restore wizard `[sudo]` |
 | `parrot-blackbox restore files <id> <dir>` | Recover a file backup into a folder |
 | `parrot-blackbox restore snapshot <id> --yes` | Overwrite the whole system from a cloud snapshot `[sudo]` |
-| `parrot-blackbox account add <mega\|gdrive> <remote>` | Add an account to the pool |
+| `parrot-blackbox account add <mega\|gdrive> <remote>` | Register an existing rclone remote into the pool |
 | `parrot-blackbox account list` | Pool summary + per-account quota |
-| `parrot-blackbox account remove <id>` | Remove an account |
+| `parrot-blackbox account remove <id>` | Remove an account from the pool |
 | `parrot-blackbox account quota <id> <GiB>` | Override an account's quota |
+| `parrot-blackbox remote add <mega\|gdrive> [name]` | ⭐ Add a cloud account (guided — sets up rclone FOR you) |
+| `parrot-blackbox remote list` | Show rclone remotes + pool registration |
+| `parrot-blackbox remote remove <name>` | Delete a remote (rclone + pool) |
+| `parrot-blackbox remote config` | Open the full rclone config editor (advanced) |
 | `parrot-blackbox daemon start\|stop\|status` | Background automation |
 | `parrot-blackbox schedule install\|remove` | systemd / cron always-on setup |
 | `parrot-blackbox doctor` | Full diagnostics |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parrot-blackbox",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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",
@@ -55,4 +55,4 @@
     "execa": "^8.0.1",
     "picocolors": "^1.1.1"
   }
-}
+}

package/src/cli.js

@@ -3,6 +3,7 @@ import pc from 'picocolors';
 import * as p from '@clack/prompts';
 import { createRequire } from 'node:module';
 import { runSetup } from './commands/setup.js';
+import { guidedRemoteAdd, deleteRemote, registerRemotesAsAccounts, remoteStatus } from './commands/remote.js';
 import { runDoctor, runStatus, runUninstallWizard } from './commands/manage.js';
 import { installService, removeService } from './commands/service.js';
 import { runDueJobs } from './daemon/scheduler.js';
@@ -43,10 +44,14 @@ ${pc.bold('Usage:')}
   parrot-blackbox snapshot prune      Delete snapshots beyond the keep limit  ${pc.dim('[sudo]')}
   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
+  parrot-blackbox account add         Add a MEGA / Google Drive account (remote must already exist)
   parrot-blackbox account list        Show the storage pool & usage
   parrot-blackbox account remove <id> Remove an account from the pool
   parrot-blackbox account quota <id> <GiB>  Override an account quota
+  parrot-blackbox remote add <mega|gdrive> [name]  ⭐ Add a cloud account (sets up rclone FOR you)
+  parrot-blackbox remote list         Show rclone remotes + pool status
+  parrot-blackbox remote remove <name>  Delete a remote AND drop it from the pool
+  parrot-blackbox remote config       Open the full rclone config editor (advanced)
   parrot-blackbox daemon start|stop|status   Background automation
   parrot-blackbox schedule install|remove    systemd / cron always-on setup
   parrot-blackbox doctor              Full diagnostics
@@ -250,6 +255,77 @@ async function accountCommands(rest) {
   }
 }
 
+/** Manage rclone remotes (the cloud logins) + their pool registration. */
+async function remoteCommands(rest) {
+  const [sub, ...args] = rest;
+  switch (sub) {
+    case 'list':
+    case 'ls': {
+      const statuses = await remoteStatus();
+      if (statuses.length === 0) {
+        console.log(pc.yellow('\nNo rclone remotes configured yet. Add one with: parrot-blackbox remote add <mega|gdrive>\n'));
+        return;
+      }
+      console.log(`\n${pc.bold('rclone remotes:')}`);
+      for (const s of statuses) {
+        console.log(`  - ${pc.bold(s.name)}${s.registered ? pc.green('  ✔ registered in pool') : pc.dim(`  not registered (provider: ${s.provider})`)}`);
+      }
+      console.log();
+      return;
+    }
+    case 'add': {
+      const provider = args[0];
+      if (provider && !['mega', 'gdrive'].includes(provider)) {
+        console.log(pc.yellow('provider must be mega or gdrive'));
+        return;
+      }
+      let res;
+      if (!provider) {
+        // Interactive provider pick.
+        const choice = await p.select({
+          message: 'Provider?',
+          options: [
+            { value: 'mega', label: 'MEGA (20 GB free tier)' },
+            { value: 'gdrive', label: 'Google Drive (10 GB free tier)' },
+          ],
+        });
+        if (p.isCancel(choice)) return;
+        res = await guidedRemoteAdd({ provider: choice, name: args[1], userArg: process.env.PBB_MEGA_USER || args[2], passArg: process.env.PBB_MEGA_PASS });
+      } else {
+        res = await guidedRemoteAdd({ provider, name: args[1], userArg: process.env.PBB_MEGA_USER || args[2], passArg: process.env.PBB_MEGA_PASS });
+      }
+      if (res.ok) console.log(pc.green(`✔ Added ${pc.bold(res.name)} (${res.provider}) — connected & registered.`));
+      else if (res.cancelled) console.log(pc.dim('Cancelled — nothing changed.'));
+      else console.log(pc.red(`✖ ${res.error}`));
+      return;
+    }
+    case 'remove':
+    case 'rm': {
+      if (!args[0]) { console.log(pc.yellow('Usage: parrot-blackbox remote remove <remote-name>')); return; }
+      try {
+        await deleteRemote(args[0]);
+        console.log(pc.green(`✔ Removed remote ${args[0]} (rclone config + pool).`));
+      } catch (e) {
+        console.log(pc.red(`✖ ${e.message}`));
+      }
+      return;
+    }
+    case 'config':
+      console.log(pc.dim('Opening rclone config — pick a remote, then e) Edit, d) Delete, r) Rename, c) Copy.'));
+      await import('execa').then(({ execa }) => execa('rclone', ['config'], { stdio: 'inherit' }));
+      return;
+    case 'register': {
+      // Hook so the wizard's multiselect is also reachable standalone.
+      console.log(pc.dim('Registering existing remotes into the pool…'));
+      if (!process.stdin.isTTY) console.log(pc.yellow('No interactive terminal — use `parrot-blackbox account add <provider> <remote>` instead.'));
+      else registerRemotesAsAccounts();
+      return;
+    }
+    default:
+      console.log(pc.yellow('remote subcommands: add <mega|gdrive> [name] | list | remove <name> | config | register'));
+  }
+}
+
 function writeConfigQuiet(cfg) {
   saveConfig(cfg);
 }
@@ -349,6 +425,10 @@ const main = defineCommand({
       case 'accounts':
         return accountCommands(rest);
 
+      case 'remote':
+      case 'remotes':
+        return remoteCommands(rest);
+
       case 'daemon': {
         const [sub] = rest;
         if (sub === 'start') {

package/src/commands/remote.js

@@ -0,0 +1,137 @@
+/**
+ * Remote (cloud account) management — the streamlined path that creates the
+ * rclone remote FOR you (no 68-option rclone menu) and registers it in the
+ * parrot-blackbox pool in one step.
+ *
+ *   - `remote add`   → `rclone config create` / `reconnect`, then `addAccount`
+ *   - `remote list`  → rclone remotes + which are registered
+ *   - `remote remove` → `rclone config delete` + drop from the pool
+ *   - `remote config` → the full manual rclone config editor (advanced)
+ */
+
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { execa } from 'execa';
+import { listRemotes } from '../storage/rclone.js';
+import { addAccount, removeAccount, listAccounts } from '../storage/accounts.js';
+
+/** Create a MEGA remote non-interactively (password obscured, OAuth-free). */
+export async function createMegaRemote({ name, user, pass, twofa = '' }) {
+  const obscured = await execa('rclone', ['obscure', pass], { reject: false });
+  if (obscured.exitCode !== 0) throw new Error('could not obscure the MEGA password');
+  const enc = obscured.stdout.trim();
+  const args = ['config', 'create', name, 'mega', 'user', user, 'pass', enc, 'use_https', 'true'];
+  if (twofa) args.push('2fa', twofa);
+  const res = await execa('rclone', args, { reject: false });
+  if (res.exitCode !== 0) throw new Error(`rclone config create failed: ${res.stderr?.trim()}`);
+  return true;
+}
+
+/** Create a Google Drive remote non-interactively, then trigger the OAuth browser flow. */
+export async function createGdriveRemote(name) {
+  const c = await execa('rclone', ['config', 'create', name, 'drive', 'scope', 'drive'], { reject: false });
+  if (c.exitCode !== 0) throw new Error(`rclone config create failed: ${c.stderr?.trim()}`);
+  p.log.step('Open the browser to authorize Google Drive when it appears…');
+  const r = await execa('rclone', ['config', 'reconnect', `${name}:`], { stdio: 'inherit', reject: false });
+  if (r.exitCode !== 0) throw new Error(`Google Drive authorization failed: ${r.stderr?.trim()}`);
+  return true;
+}
+
+/** Delete an rclone remote and drop it from the pool. */
+export async function deleteRemote(name) {
+  const res = await execa('rclone', ['config', 'delete', name], { reject: false });
+  if (res.exitCode !== 0) {
+    throw new Error(`rclone config delete failed: ${res.stderr?.trim()}`);
+  }
+  removeAccount(name);
+  return true;
+}
+
+/**
+ * Guided account add (used by `remote add` and the wizard).
+ * When stdin is not a TTY, reads credentials from args/env so it can be scripted.
+ */
+export async function guidedRemoteAdd({ provider, name, userArg, passArg }) {
+  if (!['mega', 'gdrive'].includes(provider)) {
+    return { ok: false, cancelled: false, error: `unknown provider "${provider}" — use mega or gdrive` };
+  }
+  if (!name) {
+    const existing = listAccounts().length;
+    const n = provider === 'mega' ? `mega-${existing + 1}` : `gdrive-${existing + 1}`;
+    name = process.stdin.isTTY ? await p.text({ message: `rclone remote name (${provider}):`, initialValue: n }) : n;
+    if (p.isCancel(name)) return { ok: false, cancelled: true };
+  }
+
+  if (provider === 'mega') {
+    const user = userArg || (process.stdin.isTTY ? await p.text({ message: 'MEGA account email:', initialValue: '' }) : process.env.PBB_MEGA_USER);
+    if (!user) return { ok: false, cancelled: false, error: 'a MEGA email is required (pass it as an argument or run interactively)' };
+    if (p.isCancel(user)) return { ok: false, cancelled: true };
+    const pass = passArg || (process.stdin.isTTY ? await p.password({ message: 'MEGA password:' }) : process.env.PBB_MEGA_PASS);
+    if (!pass) return { ok: false, cancelled: false, error: 'a MEGA password is required' };
+    if (p.isCancel(pass)) return { ok: false, cancelled: true };
+    let twofa = process.env.PBB_MEGA_2FA || '';
+    if (!twofa && process.stdin.isTTY) {
+      const t = await p.text({ message: 'MEGA 2FA code (leave empty if none):', initialValue: '' });
+      if (p.isCancel(t)) return { ok: false, cancelled: true };
+      twofa = t || '';
+    }
+    await createMegaRemote({ name, user, pass, twofa });
+  } else {
+    await createGdriveRemote(name);
+  }
+
+  const res = await addAccount({ provider, remote: name });
+  if (!res.ok) {
+    // Remote exists in rclone but could not be registered — say why (e.g. dup).
+    return { ok: false, cancelled: false, error: res.error };
+  }
+  return { ok: true, cancelled: false, name, provider };
+}
+
+/** Register rclone remotes that already exist as pool accounts (wizard multiselect). */
+export async function registerRemotesAsAccounts() {
+  const remotes = await listRemotes();
+  if (remotes.length === 0) {
+    p.log.warn('No rclone remotes found yet. Create one with `parrot-blackbox remote add`, `rclone config`, then re-run setup.');
+    return;
+  }
+  const existing = new Set(listAccounts().map((a) => a.remote));
+  const candidates = remotes.filter((r) => !existing.has(r));
+  if (candidates.length === 0) {
+    p.log.message(pc.dim('All existing remotes are already registered in the pool.'));
+    return;
+  }
+  const toAdd = await p.multiselect({
+    message: 'Select remotes to add to the backup pool:',
+    options: candidates.map((r) => ({ value: r, label: r })),
+    required: false,
+  });
+  if (p.isCancel(toAdd) || toAdd.length === 0) {
+    p.log.message(pc.dim('No remotes added.'));
+    return;
+  }
+  for (const remote of toAdd) {
+    const provider = await p.select({
+      message: `Provider for "${remote}"?`,
+      options: [
+        { value: 'mega', label: 'MEGA (20 GB free tier)' },
+        { value: 'gdrive', label: 'Google Drive (10 GB free tier)' },
+      ],
+    });
+    if (p.isCancel(provider)) continue;
+    const res = await addAccount({ provider, remote });
+    if (res.ok) p.log.success(`Added ${pc.cyan(remote)} (${provider}).`);
+    else p.log.warn(res.error);
+  }
+}
+
+/** Remotes we know about + registration status. */
+export async function remoteStatus() {
+  const remotes = await listRemotes();
+  const accounts = listAccounts();
+  return remotes.map((r) => ({
+    name: r,
+    provider: accounts.find((a) => a.remote === r)?.provider || '—',
+    registered: accounts.some((a) => a.remote === r),
+  }));
+}

package/src/commands/setup.js

@@ -1,19 +1,20 @@
 /**
  * Interactive setup wizard (default command, like gitswitch/theamify).
- * Walks: dependency check + AUTO-INSTALL → rclone remotes (accounts) →
- * schedule overview → always-on service install → optional first backup.
+ * Walks: tools check + AUTO-INSTALL → storage pool (guided MEGA/Drive remote
+ * creation, no raw 68-option rclone menus) → schedule → always-on service →
+ * optional first snapshot.
  */
 
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { execa } from 'execa';
 import { loadConfig, journal, hasCommandSync } from '../core/store.js';
-import { listRemotes } from '../storage/rclone.js';
-import { addAccount, listAccounts, refreshAccounts, poolSummary } from '../storage/accounts.js';
+import { listAccounts, refreshAccounts, poolSummary } from '../storage/accounts.js';
 import { installService } from './service.js';
 import { runDueJobs } from '../daemon/scheduler.js';
 import { isOnline } from '../util/network.js';
 import { bytesHuman } from '../util/misc.js';
+import { guidedRemoteAdd, registerRemotesAsAccounts } from './remote.js';
 
 const REQUIRED = [
   { bin: 'rclone', pkg: 'rclone', why: 'talks to MEGA / Google Drive (cloud storage)' },
@@ -28,12 +29,7 @@ function detectPackageManager() {
   return order.find((name) => hasCommandSync(name)) || null;
 }
 
-/**
- * Auto-install the tools the system needs for snapshot backup & restore.
- * Prompts per missing tool, then runs the package-manager install with an
- * interactive sudo prompt (spinner released first, Ctrl+C safe).
- * @returns {Promise<string[]>} tools that were freshly installed
- */
+/** Auto-install the tools needed for snapshot backup & restore (theamify-style). */
 async function ensureSystemTools() {
   const missing = REQUIRED.filter((t) => !hasCommandSync(t.bin));
   if (missing.length === 0) return [];
@@ -59,7 +55,6 @@ async function ensureSystemTools() {
     p.log.step(`Installing ${pc.cyan(tool.bin)}…`);
     const s = p.spinner();
     s.start(`Installing ${tool.bin}…`);
-    // Release the spinner FIRST so the sudo password prompt is visible & interruptible.
     s.stop('');
     try {
       const args = pm === 'pacman' ? ['-S', '--noconfirm', tool.pkg] : [pm, 'install', '-y', tool.pkg];
@@ -77,58 +72,55 @@ async function ensureSystemTools() {
   }
   return installed;
 }
-export async function runSetup() {
-  p.intro(pc.bgYellow(pc.black(' parrot-blackbox setup ')));
 
-  // 1. Dependencies — check the system and INSTALL anything needed for the
-  //    snapshot to be created, uploaded and (later) RESTORED.
-  p.note('Checking & installing the tools needed for snapshot backup + restore…', 'Step 1/5 — tools');
-  const missing = REQUIRED.filter((t) => !hasCommandSync(t.bin));
-  if (missing.length === 0) {
-    p.log.success(`All tools present: ${REQUIRED.map((r) => r.bin).join(', ')}`);
-  } else {
-    const installed = await ensureSystemTools();
-    const stillMissing = REQUIRED.filter((t) => !hasCommandSync(t.bin));
-    if (installed.length) p.log.success(`Installed: ${installed.join(', ')}`);
-    if (stillMissing.length) {
-      p.log.warn(`Still missing: ${stillMissing.map((m) => m.bin).join(', ')}`);
-    } else {
-      p.log.success(`All required tools now present: ${REQUIRED.map((r) => r.bin).join(', ')}`);
-    }
-  }
-  if (!hasCommandSync('timeshift')) {
-    p.log.message(pc.dim('Timeshift missing = snapshot backup & restore are unavailable. Run `parrot-blackbox` again after installing it.'));
-  }
-
-  // 2. Accounts
-  p.note('Accounts are rclone remotes — one per MEGA or Google Drive login.', 'Step 2/5 — storage pool');
+/** Wizard step: connect cloud accounts (guided or manual). */
+async function storagePoolStep() {
   const existing = listAccounts();
-  const needMore = await p.confirm({
+  p.note(
+    'One MEGA or Google Drive login = one rclone remote = one pool account.',
+    'Step 2/5 — storage pool',
+  );
+  const action = await p.select({
     message: existing.length
-      ? `You already have ${existing.length} account(s). Add or authorize another cloud login?`
-      : 'No accounts yet — add a MEGA or Google Drive account now?',
-    initialValue: true,
+      ? `You already have ${existing.length} account(s). What next?`
+      : 'No accounts yet — how do you want to add your first cloud account?',
+    options: [
+      { value: 'guided', label: 'Add a cloud account (guided — parrot-blackbox sets up rclone for you)', hint: 'recommended' },
+      { value: 'manual', label: 'Configure rclone myself, then register the remote' },
+      existing.length ? { value: 'skip', label: 'Skip — accounts look fine' } : { value: 'skip', label: 'Skip for now' },
+    ],
   });
-  if (p.isCancel(needMore)) { p.cancel('Aborted.'); process.exit(0); }
-
-  if (needMore) {
-    const want = await p.select({
-      message: 'How do you want to add the account?',
-      options: [
-        { value: 'wizard', label: 'Run `rclone config` (recommended — handles MEGA + Google OAuth)', hint: 'authenticates in your browser' },
-        { value: 'manual', label: 'I already created the rclone remote myself' },
-      ],
-    });
-    if (p.isCancel(want)) { p.cancel('Aborted.'); process.exit(0); }
+  if (p.isCancel(action)) { p.cancel('Aborted.'); process.exit(0); }
 
-    if (want === 'wizard') {
-      p.log.step('Starting rclone config — follow its prompts, then come back.');
-      await execa('rclone', ['config'], { stdio: 'inherit' });
+  if (action === 'guided') {
+    const wantMore = true;
+    while (wantMore) {
+      const provider = await p.select({
+        message: 'Which provider?',
+        options: [
+          { value: 'mega', label: 'MEGA (20 GB free tier)' },
+          { value: 'gdrive', label: 'Google Drive (10 GB free tier)' },
+        ],
+      });
+      if (p.isCancel(provider)) break;
+      const res = await guidedRemoteAdd({ provider });
+      if (res.ok) p.log.success(`✔ ${pc.bold(res.name)} (${res.provider}) added to the pool.`);
+      else if (res.error) p.log.warn(res.error);
+      if (res.cancelled) break;
+      const another = await p.confirm({ message: 'Add another account?', initialValue: true });
+      if (p.isCancel(another) || !another) break;
     }
-    await registerAccountsFlow();
+  } else if (action === 'manual') {
+    p.log.step('Starting rclone config — choose 39 (Mega) or 24 (Google Drive). Then come back.');
+    await execa('rclone', ['config'], { stdio: 'inherit' });
+    await registerRemotesAsAccounts();
+  } else {
+    p.log.message(pc.dim('Carrying on with the accounts you have.'));
   }
+}
 
-  // 3. Schedule overview — snapshot ONLY by default (storage-conscious).
+/** Wizard step: schedule overview. */
+async function scheduleStep() {
   const cfg = loadConfig();
   p.note(
     `   Snapshot backup: ${pc.bold('every Saturday at 22:00')} (keep ${cfg.jobs.snapshots.keep}, local + cloud)\n` +
@@ -136,8 +128,10 @@ export async function runSetup() {
     `   Missed backups : caught up automatically in order when WiFi returns`,
     'Step 3/5 — schedule',
   );
+}
 
-  // 4. Always-on service
+/** Wizard step: install the always-on service. */
+async function serviceStep() {
   const install = await p.confirm({
     message: 'Install the always-on background service (systemd / cron fallback)?',
     initialValue: true,
@@ -148,47 +142,16 @@ export async function runSetup() {
     p.log.success(`Always-on service installed via ${pc.cyan(backend)}.`);
     p.log.message(pc.dim('It survives reboots — a missed Saturday 22:00 run fires as soon as the machine is back online.'));
   }
+}
 
-  // 5. First snapshot now?
+/** Wizard step: first snapshot now? */
+async function firstBackupStep() {
   const first = await p.confirm({
     message: 'Run the FIRST snapshot backup right now? (recommended before a fresh install)',
     initialValue: true,
   });
   if (p.isCancel(first)) { p.cancel('Aborted.'); process.exit(0); }
   if (first) {
-/** Register discovered rclone remotes as accounts (multi-select). */
-async function registerAccountsFlow() {
-  const remotes = await listRemotes();
-  if (remotes.length === 0) {
-    p.log.warn('No rclone remotes found yet. Create one with `rclone config` or re-run setup.');
-    return;
-  }
-  const toAdd = await p.multiselect({
-    message: 'Select which rclone remotes to add to the backup pool (one per account):',
-    options: remotes.map((r) => ({ value: r, label: r })),
-    required: false,
-  });
-  if (p.isCancel(toAdd) || toAdd.length === 0) {
-    p.log.message(pc.dim('No accounts added.'));
-    return;
-  }
-  for (const remote of toAdd) {
-    const provider = await p.select({
-      message: `Provider for "${remote}"?`,
-      options: [
-        { value: 'mega', label: 'MEGA (20 GB free tier)' },
-        { value: 'gdrive', label: 'Google Drive (10 GB free tier)' },
-      ],
-    });
-    if (p.isCancel(provider)) continue;
-    const res = await addAccount({ provider, remote });
-    if (res.ok) p.log.success(`Added ${pc.cyan(remote)} (${provider}).`);
-    else p.log.warn(res.error);
-  }
-  const accounts = await refreshAccounts();
-  p.log.success(poolSummary(accounts).text);
-  journal('setup', `accounts registered: ${accounts.map((a) => a.remote).join(',')}`);
-}
     if (!(await isOnline())) {
       p.log.warn('Offline right now — the backup stays pending and will run automatically when online.');
     } else {
@@ -209,6 +172,35 @@ async function registerAccountsFlow() {
       }
     }
   }
+}
+
+export async function runSetup() {
+  p.intro(pc.bgYellow(pc.black(' parrot-blackbox setup ')));
+
+  // 1. Dependencies — check the system and INSTALL anything missing.
+  p.note('Checking & installing the tools needed for snapshot backup + restore…', 'Step 1/5 — tools');
+  const missing = REQUIRED.filter((t) => !hasCommandSync(t.bin));
+  if (missing.length === 0) {
+    p.log.success(`All tools present: ${REQUIRED.map((r) => r.bin).join(', ')}`);
+  } else {
+    const installed = await ensureSystemTools();
+    const stillMissing = REQUIRED.filter((t) => !hasCommandSync(t.bin));
+    if (installed.length) p.log.success(`Installed: ${installed.join(', ')}`);
+    p.log[stillMissing.length ? 'warn' : 'success'](stillMissing.length
+      ? `Still missing: ${stillMissing.map((m) => m.bin).join(', ')}`
+      : `All required tools now present: ${REQUIRED.map((r) => r.bin).join(', ')}`);
+  }
 
-  p.outro(pc.green('Setup complete. Run `parrot-blackbox status` to see everything, or `parrot-blackbox help` for all commands.'));
-}
+  // 2. Storage pool (guided remote creation or manual registration).
+  await storagePoolStep();
+  const accs = await refreshAccounts();
+  if (accs.length) p.log.success(poolSummary(accs).text);
+
+  // 3–5. Schedule, service, first backup.
+  await scheduleStep();
+  await serviceStep();
+  await firstBackupStep();
+
+  journal('setup', 'wizard completed');
+  p.outro(pc.green('Setup complete. Run `parrot-blackbox status` next, and `parrot-blackbox remote list` to manage accounts.'));
+}