backdot 1.6.1 → 1.8.0

package/README.md

@@ -10,7 +10,7 @@
 
 ```bash
 npm install -g backdot
-backdot --init
+backdot init
 ```
 
 This creates `~/.backdot.json` with sensible defaults and walks you through setup. Open the config file and set your repository URL and the files you want backed up:
@@ -26,13 +26,13 @@ This creates `~/.backdot.json` with sensible defaults and walks you through setu
 Run your first backup:
 
 ```bash
-backdot --backup
+backdot backup
 ```
 
 or configure the backport process to run automatically (daily at 2am)
 
 ```bash
-backdot --schedule
+backdot schedule
 ```
 
 ## Configuration
@@ -49,19 +49,25 @@ Prefix a pattern with `!` to exclude matching files:
 }
 ```
 
+## Encryption
+
+To encrypt files before they are pushed to the remote repo, add `"encrypt": true` to your config.
+
+On first backup you'll be prompted for a password and offered to save it to `~/.backdot.key` so that future backups do not prompt for a password.
+
 ## Commands
 
-| Command                          | Description                                    |
-| -------------------------------- | ---------------------------------------------- |
-| `--init`                         | Set up backdot for the first time              |
-| `--backup`                       | Run a backup now                               |
-| `--restore`                      | Restore latest backup from the configured repo |
-| `--restore <url>`                | Restore from a specific repo URL               |
-| `--restore [url] --commit <sha>` | Restore from a specific backup commit          |
-| `--history [url]`                | Browse and restore a previous backup           |
-| `--schedule`                     | Schedule automatic daily backup (Mac-only)     |
-| `--unschedule`                   | Unschedule the daily backup                    |
-| `--status`                       | Show schedule and resolved file list           |
+| Command                        | Description                                    |
+| ------------------------------ | ---------------------------------------------- |
+| `init`                         | Set up backdot for the first time              |
+| `backup`                       | Run a backup now                               |
+| `restore`                      | Restore latest backup from the configured repo |
+| `restore <url>`                | Restore from a specific repo URL               |
+| `restore [url] --commit <sha>` | Restore from a specific backup commit          |
+| `history [url]`                | Browse and restore a previous backup           |
+| `schedule`                     | Schedule automatic daily backup (Mac-only)     |
+| `unschedule`                   | Unschedule the daily backup                    |
+| `status`                       | Show schedule and resolved file list           |
 
 ## Development
 

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
-import { parseArgs } from "node:util";
+import cac from "cac";
 import chalk from "chalk";
 import { CONFIG_PATH } from "./config.js";
 import { backup } from "./commands/backup.js";
@@ -23,92 +23,48 @@ function getVersion() {
         return "unknown";
     }
 }
-function printHelp() {
-    console.log();
-    console.log("  Usage: backdot <command>");
-    console.log();
-    console.log("  Commands:");
-    console.log();
-    console.log("    --init                       Set up backdot for the first time");
-    console.log("    --backup                     Run a backup now");
-    console.log("    --restore [url]              Restore files from the backup repo");
-    console.log("    --restore [url] --commit <sha>  Restore from a specific backup commit");
-    console.log("    --restore [url] --yes (-y)      Accept defaults without prompting");
-    console.log("    --history [url]              Browse and restore a previous backup");
-    console.log("    --schedule                   Install daily backup schedule (macOS launchd)");
-    console.log("    --unschedule                 Remove the daily backup schedule");
-    console.log("    --status                     Show schedule and resolved files");
-    console.log("    --version                    Show version");
-    console.log();
-}
-async function main() {
-    let values;
-    let positionals;
-    try {
-        ({ values, positionals } = parseArgs({
-            args: process.argv.slice(2),
-            options: {
-                init: { type: "boolean" },
-                backup: { type: "boolean" },
-                restore: { type: "boolean" },
-                history: { type: "boolean" },
-                schedule: { type: "boolean" },
-                unschedule: { type: "boolean" },
-                status: { type: "boolean" },
-                version: { type: "boolean" },
-                help: { type: "boolean" },
-                commit: { type: "string" },
-                yes: { type: "boolean", short: "y" },
-            },
-            allowPositionals: true,
-            strict: true,
-        }));
-    }
-    catch (err) {
-        console.error(`\n  Error: ${errorMessage(err)}\n`);
-        printHelp();
-        process.exit(1);
+const cli = cac("backdot");
+cli.command("init", "Set up backdot for the first time").action(() => init());
+cli.command("backup", "Run a backup now").action(async () => {
+    await backup();
+});
+cli
+    .command("restore [url]", "Restore files")
+    .option("--commit <sha>", "Restore from a specific backup commit")
+    .option("-y, --yes", "Accept defaults without prompting")
+    .action(async (url, options) => {
+    await restore({ repoUrl: url, commit: options.commit, yes: !!options.yes });
+});
+cli
+    .command("history [url]", "List and restore a previous backup")
+    .action(async (url) => {
+    await history(url);
+});
+cli.command("schedule", "Schedule daily backup").action(() => schedule());
+cli.command("unschedule", "Unschedule the daily backup").action(() => unschedule());
+cli.command("status", "Show the status of the backup").action(async () => {
+    await status();
+});
+cli.command("", "").action(() => {
+    cli.outputHelp();
+    if (!fs.existsSync(CONFIG_PATH)) {
+        console.log(`  No config found. Run ${chalk.bold("backdot init")} to get started.\n`);
     }
+});
+// cac auto-adds a --help flag; remove its redundant section from help output
+cli.help((sections) => sections.filter((s) => !s.body?.includes("--help")));
+cli.version(getVersion());
+async function main() {
     try {
-        if (values.init) {
-            init();
-        }
-        else if (values.backup) {
-            await backup();
-        }
-        else if (values.schedule) {
-            schedule();
-        }
-        else if (values.unschedule) {
-            unschedule();
-        }
-        else if (values.status) {
-            await status();
-        }
-        else if (values.restore) {
-            await restore(positionals[0], values.commit, {
-                yes: !!values.yes,
-            });
-        }
-        else if (values.history) {
-            await history(positionals[0]);
-        }
-        else if (values.version) {
-            console.log(getVersion());
-        }
-        else {
-            printHelp();
-            if (!fs.existsSync(CONFIG_PATH)) {
-                console.log(`  No config found. Run ${chalk.bold("backdot --init")} to get started.`);
-                console.log();
-            }
-        }
+        cli.parse(process.argv, { run: false });
+        await cli.runMatchedCommand();
     }
     catch (err) {
         const msg = errorMessage(err);
         logger.error(msg);
         console.error(`\n  Error: ${msg}\n`);
-        if (!process.stdout.isTTY) {
+        const isRunningInBackground = !process.stdout.isTTY;
+        if (isRunningInBackground) {
             sendNotification("Backdot", `Backup failed: ${msg}`);
         }
         process.exit(1);

package/dist/commands/backup.js

@@ -1,17 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
 import ora from "ora";
 import { loadConfig, CONFIG_PATH } from "../config.js";
 import { resolveFiles } from "../resolveFiles.js";
-import { cleanStaging, copyToStaging, writeRepoReadme } from "../staging.js";
+import { cleanStaging, copyToStaging, writeRepoReadme, machineDir } from "../staging.js";
 import { gitPull, gitCommitAndPush } from "../git.js";
 import { logger } from "../log.js";
 import { pluralize } from "../utils.js";
+import { checkRepoVisibility } from "../repoVisibility.js";
+import { decrypt, deriveKey } from "../crypto/encryption.js";
+import { resolvePassword, offerToSaveKeyFile, confirmPassword, ENC_SUFFIX, } from "../crypto/password.js";
+function findEncryptedFile(dir) {
+    if (!fs.existsSync(dir)) {
+        return null;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const encryptedFile = findEncryptedFile(fullPath);
+            if (encryptedFile) {
+                return encryptedFile;
+            }
+        }
+        else if (entry.name.endsWith(ENC_SUFFIX)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
 export async function backup() {
     logger.info("Starting backup");
     const config = loadConfig();
     logger.info(`Repository: ${config.repository}`);
     logger.info(`Machine: ${config.machine}`);
-    const spinner = ora("Resolving files").start();
+    let password;
+    let derivedKey;
+    let passwordWasInteractive = false;
+    if (config.encrypt) {
+        const result = await resolvePassword();
+        password = result.password;
+        passwordWasInteractive = result.interactive;
+        derivedKey = deriveKey(password);
+    }
+    const spinner = ora("Checking repository visibility").start();
     try {
+        const visibility = await checkRepoVisibility(config.repository);
+        if (visibility === "public") {
+            spinner.fail("Backup refused — repository is public");
+            throw new Error(`Repository "${config.repository}" is publicly accessible.\n` +
+                "Backing up to a public repo would expose sensitive files.\n" +
+                "Make the repository private, then try again.");
+        }
+        spinner.text = "Resolving files";
         const userFiles = resolveFiles(config);
         logger.info(`Resolved ${pluralize(userFiles.length, "file")}`);
         if (userFiles.length === 0) {
@@ -21,10 +61,29 @@ export async function backup() {
         const files = [...userFiles, CONFIG_PATH];
         spinner.text = "Syncing with remote";
         await gitPull(config.repository);
+        if (derivedKey) {
+            const existingEncryptedFile = findEncryptedFile(machineDir(config.machine));
+            if (existingEncryptedFile) {
+                spinner.text = "Verifying encryption password";
+                const encryptedContent = fs.readFileSync(existingEncryptedFile);
+                try {
+                    decrypt(encryptedContent, derivedKey);
+                }
+                catch {
+                    spinner.fail("Backup failed");
+                    throw new Error("Password does not match the existing backup.");
+                }
+            }
+            else if (passwordWasInteractive) {
+                spinner.stop();
+                await confirmPassword(password);
+                spinner.start();
+            }
+        }
         spinner.text = `Copying ${pluralize(files.length, "file")} to staging`;
         cleanStaging(config.machine);
-        copyToStaging(files, config.machine);
-        writeRepoReadme(config.repository);
+        copyToStaging(files, config.machine, derivedKey);
+        writeRepoReadme(config.repository, config.encrypt);
         spinner.text = "Pushing to remote";
         const result = await gitCommitAndPush();
         const successMsg = result?.commitUrl
@@ -37,5 +96,8 @@ export async function backup() {
         spinner.fail("Backup failed");
         throw err;
     }
+    if (password) {
+        await offerToSaveKeyFile(password);
+    }
     logger.info("Backup complete");
 }

package/dist/commands/history.js

@@ -22,14 +22,17 @@ export async function history(repoUrl) {
         console.log("\n  No backup history found.\n");
         return;
     }
-    const selected = await select({
+    const selectedCommitHash = await select({
         message: "Select a backup to restore from:",
         loop: false,
-        choices: commits.map((c) => ({
-            name: `${c.hash.slice(0, 7)}  ${c.date.split("T")[0]}  ${c.message}`,
-            value: c.hash,
-        })),
+        choices: commits.map((commit) => {
+            const dateOnly = commit.date.split("T")[0];
+            return {
+                name: `${commit.hash.slice(0, 7)}  ${dateOnly}  ${commit.message}`,
+                value: commit.hash,
+            };
+        }),
     });
     console.log();
-    await restore(repoUrl, selected);
+    await restore({ repoUrl, commit: selectedCommitHash });
 }

package/dist/commands/init.js

@@ -17,7 +17,7 @@ function getMachineName() {
     }
     return os.hostname().replace(/\.(local|localdomain)$/, "");
 }
-const TEMPLATE = {
+const DEFAULT_CONFIG = {
     repository: "git@github.com:USERNAME/backdot-backup.git",
     machine: getMachineName(),
     paths: ["~/.zshrc", "~/.gitconfig"],
@@ -42,16 +42,17 @@ export function init() {
         console.log(`  ${chalk.yellow(`${CONFIG_PATH} already exists — skipping creation.`)}`);
     }
     else {
-        fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, null, 2) + "\n");
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
         console.log(`  Created ${CONFIG_PATH} with defaults.`);
     }
     console.log("  Open it and set your repository URL and files to back up.");
+    console.log(`  To encrypt backups, add ${chalk.bold('"encrypt": true')} to the config.`);
     console.log();
     // Step 3
     console.log(chalk.bold("  Step 3 — Run your first backup"));
     console.log();
-    console.log(`    ${chalk.bold("backdot --backup")}          Run a one-time backup`);
-    console.log(`    ${chalk.bold("backdot --schedule")}        Schedule daily backups (macOS)`);
-    console.log(`    ${chalk.bold("backdot --status")}          Check which files will be backed up`);
+    console.log(`    ${chalk.bold("backdot backup")}            Run a one-time backup`);
+    console.log(`    ${chalk.bold("backdot schedule")}          Schedule daily backups (macOS)`);
+    console.log(`    ${chalk.bold("backdot status")}            Check which files will be backed up`);
     console.log();
 }

package/dist/commands/restore.d.ts

@@ -1,5 +1,5 @@
-interface RestoreOptions {
+export declare function restore({ repoUrl, commit, yes, }?: {
+    repoUrl?: string;
+    commit?: string;
     yes?: boolean;
-}
-export declare function restore(repoUrl?: string, commit?: string, options?: RestoreOptions): Promise<void>;
-export {};
+}): Promise<void>;

package/dist/commands/restore.js

@@ -8,14 +8,16 @@ import { gitPull } from "../git.js";
 import { STAGING_DIR, machineDir } from "../staging.js";
 import { logger } from "../log.js";
 import { pluralize } from "../utils.js";
+import { decrypt, deriveKey } from "../crypto/encryption.js";
+import { resolvePassword, offerToSaveKeyFile, ENC_SUFFIX } from "../crypto/password.js";
 const HOME = os.homedir();
-function walkDir(dir) {
+function listFilesRecursively(dir) {
     return fs
         .readdirSync(dir, { withFileTypes: true })
         .filter((entry) => entry.name !== ".git")
         .flatMap((entry) => {
-        const full = path.join(dir, entry.name);
-        return entry.isDirectory() ? walkDir(full) : [full];
+        const fullPath = path.join(dir, entry.name);
+        return entry.isDirectory() ? listFilesRecursively(fullPath) : [fullPath];
     });
 }
 function listMachines() {
@@ -24,8 +26,8 @@ function listMachines() {
     }
     return fs
         .readdirSync(STAGING_DIR, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && e.name !== ".git")
-        .map((e) => e.name);
+        .filter((entry) => entry.isDirectory() && entry.name !== ".git")
+        .map((entry) => entry.name);
 }
 async function resolveRepoAndMachine(repoUrl, commit) {
     if (!repoUrl) {
@@ -58,7 +60,7 @@ async function resolveRepoAndMachine(repoUrl, commit) {
     }
     return { repository: repoUrl, machine };
 }
-export async function restore(repoUrl, commit, options = {}) {
+export async function restore({ repoUrl, commit, yes, } = {}) {
     logger.info("Starting restore");
     const { repository, machine } = await resolveRepoAndMachine(repoUrl, commit);
     const spinner = ora("Fetching latest backup").start();
@@ -85,61 +87,80 @@ export async function restore(repoUrl, commit, options = {}) {
         }
         return;
     }
-    const stagedFiles = walkDir(baseDir);
+    const stagedFiles = listFilesRecursively(baseDir);
     logger.info(`Found ${pluralize(stagedFiles.length, "file")} in backup repository`);
     if (stagedFiles.length === 0) {
         spinner.stop();
         console.log("No files found in backup repository.");
         return;
     }
-    const fileMappings = stagedFiles.map((src) => {
-        const rel = path.relative(baseDir, src);
-        return { src, dest: path.join(HOME, rel), rel };
+    const fileMappings = stagedFiles.map((stagedFilePath) => {
+        let relativePath = path.relative(baseDir, stagedFilePath);
+        if (relativePath.endsWith(ENC_SUFFIX)) {
+            relativePath = relativePath.slice(0, -ENC_SUFFIX.length);
+        }
+        return { src: stagedFilePath, dest: path.join(HOME, relativePath), rel: relativePath };
     });
-    const existing = fileMappings.filter((f) => fs.existsSync(f.dest));
-    const fresh = fileMappings.filter((f) => !fs.existsSync(f.dest));
-    logger.info(`${fresh.length} new, ${existing.length} already exist`);
+    const filesAlreadyOnDisk = fileMappings.filter((file) => fs.existsSync(file.dest));
+    const newFiles = fileMappings.filter((file) => !fs.existsSync(file.dest));
+    logger.info(`${newFiles.length} new, ${filesAlreadyOnDisk.length} already exist`);
     spinner.stop();
     console.log();
-    let toRestore;
-    if (options.yes) {
-        toRestore = fresh;
-        if (existing.length > 0) {
-            console.log(`  Skipped ${pluralize(existing.length, "existing file")}. Run without --yes to select them.`);
+    let filesToRestore;
+    if (yes) {
+        filesToRestore = newFiles;
+        if (filesAlreadyOnDisk.length > 0) {
+            console.log(`  Skipped ${pluralize(filesAlreadyOnDisk.length, "existing file")}. Run without --yes to select them.`);
             console.log();
         }
     }
     else {
         const choices = [];
-        if (fresh.length > 0) {
-            choices.push(new Separator(`── New files (${fresh.length}) ──`));
-            for (const f of fresh) {
-                choices.push({ name: f.rel, value: f, checked: true });
+        if (newFiles.length > 0) {
+            choices.push(new Separator(`── New files (${newFiles.length}) ──`));
+            for (const file of newFiles) {
+                choices.push({ name: file.rel, value: file, checked: true });
             }
         }
-        if (existing.length > 0) {
-            choices.push(new Separator(`── Existing files — will overwrite (${existing.length}) ──`));
-            for (const f of existing) {
-                choices.push({ name: f.rel, value: f, checked: false });
+        if (filesAlreadyOnDisk.length > 0) {
+            choices.push(new Separator(`── Existing files — will overwrite (${filesAlreadyOnDisk.length}) ──`));
+            for (const file of filesAlreadyOnDisk) {
+                choices.push({ name: file.rel, value: file, checked: false });
             }
         }
-        toRestore = await checkbox({
+        filesToRestore = await checkbox({
             message: "Select files to restore:",
             loop: false,
             choices,
         });
         console.log();
     }
-    if (toRestore.length === 0) {
+    if (filesToRestore.length === 0) {
         console.log("No files selected for restore.");
         return;
     }
-    const copySpinner = ora("Restoring files").start();
-    for (const { src, dest } of toRestore) {
+    let password;
+    const hasEncryptedFiles = filesToRestore.some(({ src }) => src.endsWith(ENC_SUFFIX));
+    if (hasEncryptedFiles) {
+        const result = await resolvePassword();
+        password = result.password;
+    }
+    const derivedKey = password ? deriveKey(password) : undefined;
+    const restoreSpinner = ora("Restoring files").start();
+    for (const { src, dest } of filesToRestore) {
         fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.copyFileSync(src, dest);
+        if (derivedKey && src.endsWith(ENC_SUFFIX)) {
+            const content = fs.readFileSync(src);
+            fs.writeFileSync(dest, decrypt(content, derivedKey));
+        }
+        else {
+            fs.copyFileSync(src, dest);
+        }
     }
-    copySpinner.succeed(`Restored ${pluralize(toRestore.length, "file")}`);
+    restoreSpinner.succeed(`Restored ${pluralize(filesToRestore.length, "file")}`);
     console.log();
-    logger.info(`Restored ${pluralize(toRestore.length, "file")}`);
+    if (password) {
+        await offerToSaveKeyFile(password);
+    }
+    logger.info(`Restored ${pluralize(filesToRestore.length, "file")}`);
 }

package/dist/commands/schedule.js

@@ -1,4 +1,8 @@
+import fs from "node:fs";
+import chalk from "chalk";
 import { setupLaunchd, uninstallLaunchd } from "../launchd.js";
+import { loadConfig } from "../config.js";
+import { KEY_FILE_PATH } from "../crypto/password.js";
 function requireMacOS() {
     if (process.platform !== "darwin") {
         throw new Error("Scheduling is only supported on macOS (launchd). Use cron or systemd on Linux.");
@@ -7,6 +11,16 @@ function requireMacOS() {
 export function schedule() {
     requireMacOS();
     setupLaunchd();
+    try {
+        const config = loadConfig();
+        if (config.encrypt && !fs.existsSync(KEY_FILE_PATH)) {
+            console.log(chalk.yellow(`  Encryption is enabled. Run ${chalk.bold("backdot backup")} once to create ~/.backdot.key,\n` +
+                `  or set ${chalk.bold("BACKDOT_PASSWORD")} in your environment.\n`));
+        }
+    }
+    catch {
+        // Config may not exist yet; ignore
+    }
 }
 export function unschedule() {
     requireMacOS();

package/dist/commands/status.js

@@ -6,17 +6,47 @@ import { resolveFiles } from "../resolveFiles.js";
 import { compareFiles } from "../staging.js";
 import { isScheduled } from "../launchd.js";
 import { pluralize } from "../utils.js";
-function tildePath(filePath) {
+import { checkRepoVisibility } from "../repoVisibility.js";
+import { deriveKey } from "../crypto/encryption.js";
+import { resolvePassword } from "../crypto/password.js";
+function abbreviateHomePath(filePath) {
     const home = os.homedir();
     return filePath.startsWith(home) ? "~" + filePath.slice(home.length) : filePath;
 }
+function formatVisibility(visibility) {
+    switch (visibility) {
+        case "public":
+            return chalk.red.bold("public (backup disabled)");
+        case "private":
+            return chalk.green("private");
+        case "unknown":
+            return chalk.yellow("unknown (could not verify)");
+    }
+}
 export async function status() {
     const scheduled = isScheduled();
     console.log();
-    console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : `not active  (run ${chalk.bold("backdot --schedule")} to enable)`}`);
+    console.log(`  Schedule:    ${scheduled ? "active (daily at 02:00)" : `not active  (run ${chalk.bold("backdot schedule")} to enable)`}`);
     const config = loadConfig();
-    console.log(`  Repo:      ${config.repository}`);
-    console.log(`  Machine:   ${config.machine}`);
+    console.log(`  Repo:        ${config.repository}`);
+    console.log(`  Machine:     ${config.machine}`);
+    if (config.encrypt) {
+        console.log(`  Encryption:  ${chalk.green("enabled")}`);
+    }
+    const visibilitySpinner = ora("Checking repository visibility").start();
+    const visibility = await checkRepoVisibility(config.repository);
+    visibilitySpinner.stop();
+    if (visibility !== "private") {
+        console.log(`  Visibility:  ${formatVisibility(visibility)}`);
+    }
+    if (visibility === "public") {
+        console.log();
+        console.log(chalk.red("  ⚠ Repository is public. Backup is disabled to prevent leaking sensitive files.\n" +
+            "    Make the repository private, then try again."));
+        console.log();
+        return;
+    }
+    const derivedKey = config.encrypt ? deriveKey((await resolvePassword()).password) : undefined;
     console.log();
     const spinner = ora("Resolving files").start();
     try {
@@ -28,7 +58,12 @@ export async function status() {
         }
         const files = [...userFiles, CONFIG_PATH];
         spinner.text = "Comparing with remote backup";
-        const { backedUp, modified, notBackedUp, error } = await compareFiles(files, config.machine, config.repository);
+        const { backedUp, modified, notBackedUp, error } = await compareFiles({
+            files,
+            machine: config.machine,
+            repository: config.repository,
+            derivedKey,
+        });
         spinner.stop();
         if (error) {
             console.log(chalk.yellow(`  Could not fetch status: ${error}`));
@@ -40,26 +75,26 @@ export async function status() {
         else {
             if (modified.length > 0) {
                 console.log(chalk.yellow(`  Modified since last backup (${modified.length}):`));
-                for (const f of modified) {
-                    console.log(`        ${tildePath(f)}`);
+                for (const filePath of modified) {
+                    console.log(`        ${abbreviateHomePath(filePath)}`);
                 }
                 console.log();
             }
             if (notBackedUp.length > 0) {
                 console.log(chalk.red(`  Not yet backed up (${notBackedUp.length}):`));
-                for (const f of notBackedUp) {
-                    console.log(`        ${tildePath(f)}`);
+                for (const filePath of notBackedUp) {
+                    console.log(`        ${abbreviateHomePath(filePath)}`);
                 }
                 console.log();
             }
             if (backedUp.length > 0) {
                 console.log(chalk.green(`  Backed up (${backedUp.length}):`));
-                for (const f of backedUp) {
-                    console.log(`        ${tildePath(f)}`);
+                for (const filePath of backedUp) {
+                    console.log(`        ${abbreviateHomePath(filePath)}`);
                 }
                 console.log();
             }
-            console.log(`  Run ${chalk.bold("backdot --backup")} to back up all changes.`);
+            console.log(`  Run ${chalk.bold("backdot backup")} to back up all changes.`);
         }
     }
     catch (err) {