backdot 1.5.0 → 1.6.1

package/README.md

@@ -51,14 +51,17 @@ Prefix a pattern with `!` to exclude matching files:
 
 ## Commands
 
-| Command        | Description                                            |
-| -------------- | ------------------------------------------------------ |
-| `--init`       | Set up backdot for the first time                      |
-| `--backup`     | Run a backup now                                       |
-| `--restore`    | Restore files to their original locations              |
-| `--schedule`   | Schedule automatic daily backup via launchd (Mac-only) |
-| `--unschedule` | Remove the daily schedule                              |
-| `--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,14 +1,17 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
+import { parseArgs } from "node:util";
 import chalk from "chalk";
 import { CONFIG_PATH } from "./config.js";
 import { backup } from "./commands/backup.js";
 import { status } from "./commands/status.js";
 import { schedule, unschedule } from "./commands/schedule.js";
 import { restore } from "./commands/restore.js";
+import { history } from "./commands/history.js";
 import { init } from "./commands/init.js";
 import { logger } from "./log.js";
+import { errorMessage } from "./utils.js";
 import { sendNotification } from "./notify.js";
 function getVersion() {
     const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
@@ -20,62 +23,89 @@ 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() {
-    const args = process.argv.slice(2);
-    const command = args[0];
+    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);
+    }
     try {
-        if (command === "--init") {
+        if (values.init) {
             init();
         }
-        else if (command === "--backup") {
+        else if (values.backup) {
             await backup();
         }
-        else if (command === "--schedule") {
+        else if (values.schedule) {
             schedule();
         }
-        else if (command === "--unschedule") {
+        else if (values.unschedule) {
             unschedule();
         }
-        else if (command === "--status") {
+        else if (values.status) {
             await status();
         }
-        else if (command === "--restore") {
-            const url = args[1];
-            if (url?.startsWith("--")) {
-                throw new Error(`Invalid repository URL: "${url}". Did you mean to pass a Git URL?`);
-            }
-            await restore(url);
+        else if (values.restore) {
+            await restore(positionals[0], values.commit, {
+                yes: !!values.yes,
+            });
+        }
+        else if (values.history) {
+            await history(positionals[0]);
         }
-        else if (command === "--version") {
+        else if (values.version) {
             console.log(getVersion());
         }
         else {
-            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("    --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();
-            if (command && command !== "--help") {
-                console.error(`  Unknown command: ${command}`);
-                console.log();
-                process.exit(1);
-            }
-            else if (!fs.existsSync(CONFIG_PATH)) {
+            printHelp();
+            if (!fs.existsSync(CONFIG_PATH)) {
                 console.log(`  No config found. Run ${chalk.bold("backdot --init")} to get started.`);
                 console.log();
             }
         }
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = errorMessage(err);
         logger.error(msg);
         console.error(`\n  Error: ${msg}\n`);
         if (!process.stdout.isTTY) {

package/dist/commands/backup.js

@@ -1,9 +1,10 @@
 import ora from "ora";
 import { loadConfig, CONFIG_PATH } from "../config.js";
-import { resolveFiles } from "../resolve.js";
+import { resolveFiles } from "../resolveFiles.js";
 import { cleanStaging, copyToStaging, writeRepoReadme } from "../staging.js";
 import { gitPull, gitCommitAndPush } from "../git.js";
 import { logger } from "../log.js";
+import { pluralize } from "../utils.js";
 export async function backup() {
     logger.info("Starting backup");
     const config = loadConfig();
@@ -12,7 +13,7 @@ export async function backup() {
     const spinner = ora("Resolving files").start();
     try {
         const userFiles = resolveFiles(config);
-        logger.info(`Resolved ${userFiles.length} file(s)`);
+        logger.info(`Resolved ${pluralize(userFiles.length, "file")}`);
         if (userFiles.length === 0) {
             spinner.info("No files resolved, nothing to back up");
             return;
@@ -20,7 +21,7 @@ export async function backup() {
         const files = [...userFiles, CONFIG_PATH];
         spinner.text = "Syncing with remote";
         await gitPull(config.repository);
-        spinner.text = `Copying ${files.length} file(s) to staging`;
+        spinner.text = `Copying ${pluralize(files.length, "file")} to staging`;
         cleanStaging(config.machine);
         copyToStaging(files, config.machine);
         writeRepoReadme(config.repository);

package/dist/commands/history.d.ts

@@ -0,0 +1 @@
+export declare function history(repoUrl?: string): Promise<void>;

package/dist/commands/history.js

@@ -0,0 +1,35 @@
+import ora from "ora";
+import { select } from "@inquirer/prompts";
+import { loadConfig } from "../config.js";
+import { gitPull, gitLog } from "../git.js";
+import { restore } from "./restore.js";
+import { logger } from "../log.js";
+export async function history(repoUrl) {
+    logger.info("Starting history");
+    const repository = repoUrl ?? loadConfig().repository;
+    const spinner = ora("Fetching backup history").start();
+    let commits;
+    try {
+        await gitPull(repository);
+        commits = await gitLog();
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch backup history");
+        throw err;
+    }
+    spinner.stop();
+    if (commits.length === 0) {
+        console.log("\n  No backup history found.\n");
+        return;
+    }
+    const selected = 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,
+        })),
+    });
+    console.log();
+    await restore(repoUrl, selected);
+}

package/dist/commands/init.js

@@ -1,10 +1,25 @@
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import chalk from "chalk";
 import { CONFIG_PATH } from "../config.js";
+function getMachineName() {
+    if (process.platform === "darwin") {
+        try {
+            return execFileSync("scutil", ["--get", "LocalHostName"], {
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+        }
+        catch {
+            // fall through
+        }
+    }
+    return os.hostname().replace(/\.(local|localdomain)$/, "");
+}
 const TEMPLATE = {
     repository: "git@github.com:USERNAME/backdot-backup.git",
-    machine: os.hostname(),
+    machine: getMachineName(),
     paths: ["~/.zshrc", "~/.gitconfig"],
 };
 export function init() {

package/dist/commands/restore.d.ts

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

package/dist/commands/restore.js

@@ -2,11 +2,12 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import ora from "ora";
-import { checkbox, select } from "@inquirer/prompts";
+import { checkbox, select, Separator } from "@inquirer/prompts";
 import { loadConfig } from "../config.js";
 import { gitPull } from "../git.js";
 import { STAGING_DIR, machineDir } from "../staging.js";
 import { logger } from "../log.js";
+import { pluralize } from "../utils.js";
 const HOME = os.homedir();
 function walkDir(dir) {
     return fs
@@ -18,20 +19,27 @@ function walkDir(dir) {
     });
 }
 function listMachines() {
-    if (!fs.existsSync(STAGING_DIR))
+    if (!fs.existsSync(STAGING_DIR)) {
         return [];
+    }
     return fs
         .readdirSync(STAGING_DIR, { withFileTypes: true })
         .filter((e) => e.isDirectory() && e.name !== ".git")
         .map((e) => e.name);
 }
-async function resolveRepoAndMachine(repoUrl) {
+async function resolveRepoAndMachine(repoUrl, commit) {
     if (!repoUrl) {
         const config = loadConfig();
         return { repository: config.repository, machine: config.machine };
     }
     const spinner = ora("Cloning backup repository").start();
-    await gitPull(repoUrl);
+    try {
+        await gitPull(repoUrl, commit);
+    }
+    catch (err) {
+        spinner.fail("Failed to clone backup repository");
+        throw err;
+    }
     spinner.stop();
     const machines = listMachines();
     if (machines.length === 0) {
@@ -44,18 +52,25 @@ async function resolveRepoAndMachine(repoUrl) {
     else {
         machine = await select({
             message: "Multiple machines found. Which one do you want to restore?",
+            loop: false,
             choices: machines.map((m) => ({ name: m, value: m })),
         });
     }
     return { repository: repoUrl, machine };
 }
-export async function restore(repoUrl) {
+export async function restore(repoUrl, commit, options = {}) {
     logger.info("Starting restore");
-    const { repository, machine } = await resolveRepoAndMachine(repoUrl);
+    const { repository, machine } = await resolveRepoAndMachine(repoUrl, commit);
     const spinner = ora("Fetching latest backup").start();
     const baseDir = machineDir(machine);
-    if (!repoUrl) {
-        await gitPull(repository);
+    try {
+        if (!repoUrl) {
+            await gitPull(repository, commit);
+        }
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch latest backup");
+        throw err;
     }
     spinner.text = "Resolving files";
     if (!fs.existsSync(baseDir)) {
@@ -71,7 +86,7 @@ export async function restore(repoUrl) {
         return;
     }
     const stagedFiles = walkDir(baseDir);
-    logger.info(`Found ${stagedFiles.length} file(s) in backup repository`);
+    logger.info(`Found ${pluralize(stagedFiles.length, "file")} in backup repository`);
     if (stagedFiles.length === 0) {
         spinner.stop();
         console.log("No files found in backup repository.");
@@ -86,25 +101,33 @@ export async function restore(repoUrl) {
     logger.info(`${fresh.length} new, ${existing.length} already exist`);
     spinner.stop();
     console.log();
-    if (fresh.length > 0) {
-        console.log(`${fresh.length} new file(s) to restore:`);
-        console.log();
-        for (const f of fresh) {
-            console.log(`  ${f.rel}`);
+    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.`);
+            console.log();
         }
-        console.log();
     }
-    let toRestore = fresh;
-    if (existing.length > 0) {
-        const selected = await checkbox({
-            message: `${existing.length} file(s) already exist. Select which to overwrite:`,
-            choices: existing.map((f) => ({
-                name: f.rel,
-                value: f,
-                checked: true,
-            })),
+    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 (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 });
+            }
+        }
+        toRestore = await checkbox({
+            message: "Select files to restore:",
+            loop: false,
+            choices,
         });
-        toRestore = [...fresh, ...selected];
         console.log();
     }
     if (toRestore.length === 0) {
@@ -116,7 +139,7 @@ export async function restore(repoUrl) {
         fs.mkdirSync(path.dirname(dest), { recursive: true });
         fs.copyFileSync(src, dest);
     }
-    copySpinner.succeed(`Restored ${toRestore.length} file(s)`);
+    copySpinner.succeed(`Restored ${pluralize(toRestore.length, "file")}`);
     console.log();
-    logger.info(`Restored ${toRestore.length} file(s)`);
+    logger.info(`Restored ${pluralize(toRestore.length, "file")}`);
 }

package/dist/commands/schedule.js

@@ -1,4 +1,4 @@
-import { setupLaunchd, uninstallLaunchd } from "../plist.js";
+import { setupLaunchd, uninstallLaunchd } from "../launchd.js";
 function requireMacOS() {
     if (process.platform !== "darwin") {
         throw new Error("Scheduling is only supported on macOS (launchd). Use cron or systemd on Linux.");

package/dist/commands/status.js

@@ -2,9 +2,10 @@ import os from "node:os";
 import chalk from "chalk";
 import ora from "ora";
 import { loadConfig, CONFIG_PATH } from "../config.js";
-import { resolveFiles } from "../resolve.js";
+import { resolveFiles } from "../resolveFiles.js";
 import { compareFiles } from "../staging.js";
-import { isScheduled } from "../plist.js";
+import { isScheduled } from "../launchd.js";
+import { pluralize } from "../utils.js";
 function tildePath(filePath) {
     const home = os.homedir();
     return filePath.startsWith(home) ? "~" + filePath.slice(home.length) : filePath;
@@ -12,7 +13,7 @@ function tildePath(filePath) {
 export async function status() {
     const scheduled = isScheduled();
     console.log();
-    console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : "not active"}`);
+    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}`);
@@ -27,14 +28,14 @@ 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);
+        const { backedUp, modified, notBackedUp, error } = await compareFiles(files, config.machine, config.repository);
         spinner.stop();
         if (error) {
             console.log(chalk.yellow(`  Could not fetch status: ${error}`));
             return;
         }
         if (modified.length === 0 && notBackedUp.length === 0) {
-            console.log(chalk.green(`  All ${files.length} file(s) are backed up ✓`));
+            console.log(chalk.green(`  All ${pluralize(files.length, "file")} are backed up ✓`));
         }
         else {
             if (modified.length > 0) {

package/dist/commitUrl.js

@@ -6,8 +6,9 @@ const PROVIDERS = {
 export function getCommitUrl(remoteUrl, sha) {
     for (const [host, buildUrl] of Object.entries(PROVIDERS)) {
         const idx = remoteUrl.indexOf(host);
-        if (idx === -1)
+        if (idx === -1) {
             continue;
+        }
         let repoPath = remoteUrl.slice(idx + host.length + 1).trim();
         if (repoPath.endsWith(".git")) {
             repoPath = repoPath.slice(0, -4);

package/dist/errorMessage.d.ts

@@ -0,0 +1 @@
+export declare function errorMessage(err: unknown): string;

package/dist/errorMessage.js

@@ -0,0 +1,3 @@
+export function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/git.d.ts

@@ -1,4 +1,25 @@
-export declare function gitPull(repository: string): Promise<void>;
+import { type SimpleGit } from "simple-git";
+interface FileChangeSummary {
+    created: string[];
+    deleted: string[];
+    modified: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+export declare function buildCommitMessage(changes: FileChangeSummary, maxLen?: number): string;
+export declare function ensureRemoteUrl(repository: string): Promise<void>;
+export declare function getCurrentBranch(git: SimpleGit): Promise<string>;
+export declare function friendlyGitError(raw: string, repository: string): string;
+export declare function gitError(err: unknown, repository: string): Error;
+export declare function gitPull(repository: string, commit?: string): Promise<void>;
+export declare function gitLog(limit?: number): Promise<Array<{
+    hash: string;
+    date: string;
+    message: string;
+}>>;
 export declare function gitCommitAndPush(): Promise<{
     commitUrl: string | null;
 } | null>;
+export {};

package/dist/git.js

@@ -3,29 +3,123 @@ import path from "node:path";
 import pRetry from "p-retry";
 import { simpleGit, CleanOptions } from "simple-git";
 import { logger } from "./log.js";
-import { STAGING_DIR } from "./staging.js";
+import { STAGING_DIR, STAGING_GIT_DIR } from "./paths.js";
 import { getCommitUrl } from "./commitUrl.js";
-export async function gitPull(repository) {
-    if (fs.existsSync(path.join(STAGING_DIR, ".git"))) {
-        const git = simpleGit(STAGING_DIR);
-        await git.fetch("origin");
-        const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
-        await git.reset(["--hard", `origin/${branch}`]);
-        await git.clean(CleanOptions.FORCE, ["-d"]);
-    }
-    else {
-        try {
-            await simpleGit().clone(repository, STAGING_DIR);
+import { errorMessage, pluralize, uniq } from "./utils.js";
+export function buildCommitMessage(changes, maxLen = 250) {
+    const unique = (paths) => uniq(paths.map((f) => path.basename(f)));
+    const removed = unique(changes.deleted);
+    const added = unique(changes.created);
+    const modified = unique([...changes.modified, ...changes.renamed.map((r) => r.to)]);
+    const categories = [
+        { label: "removed", files: removed },
+        { label: "added", files: added },
+        { label: "modified", files: modified },
+    ].filter((c) => c.files.length > 0);
+    if (categories.length === 0) {
+        return "backup"; // fallback commit message when no changes are categorized
+    }
+    function format(cat, listFiles) {
+        if (listFiles) {
+            return `${cat.label}: ${cat.files.join(", ")}`;
+        }
+        return `${cat.label}: ${pluralize(cat.files.length, "file")}`;
+    }
+    function build(listFlags) {
+        return categories.map((cat, i) => format(cat, listFlags[i])).join("; ");
+    }
+    const flags = categories.map(() => true);
+    let msg = build(flags);
+    if (msg.length <= maxLen) {
+        return msg;
+    }
+    for (const label of ["modified", "added", "removed"]) {
+        const idx = categories.findIndex((c) => c.label === label);
+        if (idx !== -1 && flags[idx]) {
+            flags[idx] = false;
+            msg = build(flags);
+            if (msg.length <= maxLen) {
+                return msg;
+            }
         }
-        catch {
-            fs.mkdirSync(STAGING_DIR, { recursive: true });
+    }
+    return msg.slice(0, maxLen - 3) + "...";
+}
+export async function ensureRemoteUrl(repository) {
+    const git = simpleGit(STAGING_DIR);
+    const currentUrl = (await git.remote(["get-url", "origin"]))?.trim();
+    if (currentUrl !== repository) {
+        await git.remote(["set-url", "origin", repository]);
+    }
+}
+export async function getCurrentBranch(git) {
+    return (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+}
+export function friendlyGitError(raw, repository) {
+    const msg = raw.toLowerCase();
+    if (msg.includes("not found") ||
+        msg.includes("does not exist") ||
+        msg.includes("does not appear to be a git repository")) {
+        return `Repository "${repository}" not found. Check the URL and that you have access.`;
+    }
+    if (msg.includes("authentication failed") || msg.includes("could not read username")) {
+        return `Authentication failed for "${repository}". Check your credentials or SSH key.`;
+    }
+    if (msg.includes("could not resolve host") ||
+        msg.includes("connection refused") ||
+        msg.includes("connection timed out")) {
+        return "Could not connect to remote host. Check your internet connection.";
+    }
+    return raw;
+}
+export function gitError(err, repository) {
+    const raw = errorMessage(err);
+    return new Error(friendlyGitError(raw, repository), { cause: err });
+}
+export async function gitPull(repository, commit) {
+    try {
+        if (fs.existsSync(STAGING_GIT_DIR)) {
             const git = simpleGit(STAGING_DIR);
-            await git.init();
-            await git.addRemote("origin", repository);
+            await ensureRemoteUrl(repository);
+            await git.fetch("origin");
+            const target = commit ?? `origin/${await getCurrentBranch(git)}`;
+            await git.reset(["--hard", target]);
+            await git.clean(CleanOptions.FORCE, ["-d"]);
+        }
+        else {
+            try {
+                await simpleGit().clone(repository, STAGING_DIR);
+            }
+            catch (err) {
+                if (!errorMessage(err).includes("empty repository")) {
+                    throw err;
+                }
+                fs.mkdirSync(STAGING_DIR, { recursive: true });
+                const git = simpleGit(STAGING_DIR);
+                await git.init();
+                await git.addRemote("origin", repository);
+            }
+            if (commit) {
+                const git = simpleGit(STAGING_DIR);
+                await git.reset(["--hard", commit]);
+                await git.clean(CleanOptions.FORCE, ["-d"]);
+            }
         }
     }
+    catch (err) {
+        throw gitError(err, repository);
+    }
     logger.info("Synced staging directory from remote");
 }
+export async function gitLog(limit = 20) {
+    const git = simpleGit(STAGING_DIR);
+    const log = await git.log({ maxCount: limit });
+    return log.all.map((entry) => ({
+        hash: entry.hash,
+        date: entry.date,
+        message: entry.message,
+    }));
+}
 export async function gitCommitAndPush() {
     const git = simpleGit(STAGING_DIR);
     await git.add(".");
@@ -34,24 +128,29 @@ export async function gitCommitAndPush() {
         logger.info("No changes to commit");
         return null;
     }
-    const date = new Date().toISOString().split("T")[0];
-    const message = `Automated backup: ${date}`;
+    const message = buildCommitMessage(status);
     await git.commit(message);
-    await pRetry(async () => git.push(["-u", "origin", "HEAD"]), {
-        retries: 5,
-        onFailedAttempt: async ({ attemptNumber, retriesLeft }) => {
-            logger.info(`Push failed (attempt ${attemptNumber}, ${retriesLeft} retries left), rebasing`);
-            await git.fetch("origin");
-            const branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
-            try {
-                await git.rebase([`origin/${branch}`]);
-            }
-            catch {
-                await git.rebase(["--abort"]);
-                throw new Error("Rebase conflict, aborting retry");
-            }
-        },
-    });
+    try {
+        await pRetry(async () => git.push(["-u", "origin", "HEAD"]), {
+            retries: 5,
+            onFailedAttempt: async ({ attemptNumber, retriesLeft }) => {
+                logger.info(`Push failed (attempt ${attemptNumber}, ${retriesLeft} retries left), rebasing`);
+                await git.fetch("origin");
+                const branch = await getCurrentBranch(git);
+                try {
+                    await git.rebase([`origin/${branch}`]);
+                }
+                catch {
+                    await git.rebase(["--abort"]);
+                    throw new Error("Rebase conflict, aborting retry");
+                }
+            },
+        });
+    }
+    catch (err) {
+        const remoteUrl = ((await git.remote(["get-url", "origin"])) ?? "").trim();
+        throw gitError(err, remoteUrl);
+    }
     logger.info(`Committed and pushed: ${message}`);
     const sha = (await git.revparse(["HEAD"])).trim();
     const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";

package/dist/launchd.d.ts

@@ -0,0 +1,3 @@
+export declare function isScheduled(): boolean;
+export declare function setupLaunchd(): void;
+export declare function uninstallLaunchd(): void;

package/dist/launchd.js

@@ -0,0 +1,112 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import ora from "ora";
+import { logger } from "./log.js";
+import { errorMessage } from "./utils.js";
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+const LABEL = "com.backdot.daemon";
+const PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+function getScriptPath() {
+    const currentDir = path.dirname(new URL(import.meta.url).pathname);
+    return path.resolve(currentDir, "cli.js");
+}
+function buildPlist() {
+    const nodePath = process.execPath;
+    const scriptPath = getScriptPath();
+    const workingDir = path.dirname(scriptPath);
+    const logPath = path.join(os.homedir(), ".backdot", "launchd.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(scriptPath)}</string>
+    <string>--backup</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(workingDir)}</string>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>2</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(logPath)}</string>
+  <key>RunAtLoad</key>
+  <false/>
+</dict>
+</plist>`;
+}
+export function isScheduled() {
+    if (!fs.existsSync(PLIST_PATH)) {
+        return false;
+    }
+    try {
+        const output = execFileSync("launchctl", ["list", LABEL], { encoding: "utf-8", stdio: "pipe" });
+        return output.includes(LABEL);
+    }
+    catch {
+        return false;
+    }
+}
+export function setupLaunchd() {
+    const spinner = ora("Installing schedule").start();
+    const plistContent = buildPlist();
+    const dir = path.dirname(PLIST_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    try {
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+    }
+    catch {
+        // Not loaded, that's fine
+    }
+    fs.writeFileSync(PLIST_PATH, plistContent);
+    logger.info(`Plist written to ${PLIST_PATH}`);
+    try {
+        execFileSync("launchctl", ["load", PLIST_PATH], { stdio: "pipe" });
+        spinner.succeed("Daily backup scheduled (02:00)");
+        console.log();
+        logger.info("Launchd job loaded");
+    }
+    catch (err) {
+        const msg = errorMessage(err);
+        spinner.fail(`Failed to load launchd job: ${msg}`);
+        console.log();
+        logger.error(`Failed to load launchd job: ${msg}`);
+        throw new Error(`Failed to load launchd job: ${msg}`, { cause: err });
+    }
+}
+export function uninstallLaunchd() {
+    const spinner = ora("Removing schedule").start();
+    try {
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+        logger.info("Launchd job unloaded");
+    }
+    catch {
+        logger.info("Launchd job was not loaded");
+    }
+    if (fs.existsSync(PLIST_PATH)) {
+        fs.unlinkSync(PLIST_PATH);
+        logger.info(`Plist removed: ${PLIST_PATH}`);
+    }
+    spinner.succeed("Schedule removed");
+    console.log();
+}

package/dist/log.d.ts

@@ -1,2 +1,6 @@
 import winston from "winston";
-export declare const logger: winston.Logger;
+export declare const logger: {
+    info: (message: string) => winston.Logger;
+    warn: (message: string) => winston.Logger;
+    error: (message: string) => winston.Logger;
+};

package/dist/log.js

@@ -3,10 +3,21 @@ import path from "node:path";
 import os from "node:os";
 import winston from "winston";
 const LOG_DIR = path.join(os.homedir(), ".backdot");
-fs.mkdirSync(LOG_DIR, { recursive: true });
 const LOG_FILE = path.join(LOG_DIR, "backup.log");
-export const logger = winston.createLogger({
-    level: "info",
-    format: winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message }) => `${timestamp} [${level}] ${message}`)),
-    transports: [new winston.transports.File({ filename: LOG_FILE })],
-});
+let _logger;
+function getLogger() {
+    if (!_logger) {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+        _logger = winston.createLogger({
+            level: "info",
+            format: winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message }) => `${timestamp} [${level}] ${message}`)),
+            transports: [new winston.transports.File({ filename: LOG_FILE })],
+        });
+    }
+    return _logger;
+}
+export const logger = {
+    info: (message) => getLogger().info(message),
+    warn: (message) => getLogger().warn(message),
+    error: (message) => getLogger().error(message),
+};

package/dist/notify.js

@@ -1,11 +1,13 @@
 import { execFileSync } from "node:child_process";
 import { logger } from "./log.js";
+import { errorMessage } from "./utils.js";
 function escapeAppleScript(str) {
     return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 export function sendNotification(title, message) {
-    if (process.platform !== "darwin")
+    if (process.platform !== "darwin") {
         return;
+    }
     const escaped = escapeAppleScript(message);
     const titleEscaped = escapeAppleScript(title);
     try {
@@ -15,7 +17,6 @@ export function sendNotification(title, message) {
         ], { stdio: "pipe" });
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`Failed to send notification: ${msg}`);
+        logger.warn(`Failed to send notification: ${errorMessage(err)}`);
     }
 }

package/dist/paths.d.ts

@@ -0,0 +1,3 @@
+export declare const STAGING_DIR: string;
+export declare const STAGING_GIT_DIR: string;
+export declare function machineDir(machine: string): string;

package/dist/paths.js

@@ -0,0 +1,8 @@
+import path from "node:path";
+import os from "node:os";
+const HOME = os.homedir();
+export const STAGING_DIR = path.join(HOME, ".backdot", "repo");
+export const STAGING_GIT_DIR = path.join(STAGING_DIR, ".git");
+export function machineDir(machine) {
+    return path.join(STAGING_DIR, machine);
+}

package/dist/plist.js

@@ -4,6 +4,14 @@ import path from "node:path";
 import os from "node:os";
 import ora from "ora";
 import { logger } from "./log.js";
+import { errorMessage } from "./utils.js";
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
 const LABEL = "com.backdot.daemon";
 const PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
 function getScriptPath() {
@@ -23,12 +31,12 @@ function buildPlist() {
   <string>${LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${nodePath}</string>
-    <string>${scriptPath}</string>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(scriptPath)}</string>
     <string>--backup</string>
   </array>
   <key>WorkingDirectory</key>
-  <string>${workingDir}</string>
+  <string>${escapeXml(workingDir)}</string>
   <key>StartCalendarInterval</key>
   <dict>
     <key>Hour</key>
@@ -37,9 +45,9 @@ function buildPlist() {
     <integer>0</integer>
   </dict>
   <key>StandardOutPath</key>
-  <string>${logPath}</string>
+  <string>${escapeXml(logPath)}</string>
   <key>StandardErrorPath</key>
-  <string>${logPath}</string>
+  <string>${escapeXml(logPath)}</string>
   <key>RunAtLoad</key>
   <false/>
 </dict>
@@ -79,7 +87,7 @@ export function setupLaunchd() {
         logger.info("Launchd job loaded");
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = errorMessage(err);
         spinner.fail(`Failed to load launchd job: ${msg}`);
         console.log();
         logger.error(`Failed to load launchd job: ${msg}`);

package/dist/resolve.js

@@ -1,14 +1,16 @@
 import fs from "node:fs";
 import fg from "fast-glob";
 import { logger } from "./log.js";
+import { errorMessage, uniq } from "./utils.js";
 function resolveGlobs(patterns) {
-    if (patterns.length === 0)
+    if (patterns.length === 0) {
         return [];
+    }
     try {
         return fg.sync(patterns, { absolute: true, dot: true, onlyFiles: true });
     }
-    catch {
-        logger.warn("Glob pattern resolution failed");
+    catch (err) {
+        logger.warn(`Glob pattern resolution failed: ${errorMessage(err)}`);
         return [];
     }
 }
@@ -18,7 +20,7 @@ const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
  * Skips entries that fail resolution and logs warnings.
  */
 export function resolveFiles(config) {
-    const unique = [...new Set(resolveGlobs(config.paths))];
+    const unique = uniq(resolveGlobs(config.paths));
     return unique.filter((filePath) => {
         try {
             fs.accessSync(filePath, fs.constants.R_OK);

package/dist/resolveFiles.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "./config.js";
+/**
+ * Resolve all file entries to absolute paths.
+ * Skips entries that fail resolution and logs warnings.
+ */
+export declare function resolveFiles(config: Config): string[];

package/dist/resolveFiles.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import fg from "fast-glob";
+import { logger } from "./log.js";
+import { errorMessage, uniq } from "./utils.js";
+function resolveGlobs(patterns) {
+    if (patterns.length === 0) {
+        return [];
+    }
+    try {
+        return fg.sync(patterns, { absolute: true, dot: true, onlyFiles: true });
+    }
+    catch (err) {
+        logger.warn(`Glob pattern resolution failed: ${errorMessage(err)}`);
+        return [];
+    }
+}
+const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+/**
+ * Resolve all file entries to absolute paths.
+ * Skips entries that fail resolution and logs warnings.
+ */
+export function resolveFiles(config) {
+    const unique = uniq(resolveGlobs(config.paths));
+    return unique.filter((filePath) => {
+        try {
+            fs.accessSync(filePath, fs.constants.R_OK);
+            const stat = fs.statSync(filePath);
+            if (!stat.isFile()) {
+                logger.warn(`Not a regular file, skipping: ${filePath}`);
+                return false;
+            }
+            if (stat.size > LARGE_FILE_THRESHOLD) {
+                const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+                logger.warn(`Large file (${sizeMB} MB), skipping: ${filePath}`);
+                return false;
+            }
+            return true;
+        }
+        catch {
+            logger.warn(`File not readable, skipping: ${filePath}`);
+            return false;
+        }
+    });
+}

package/dist/staging.d.ts

@@ -1,5 +1,5 @@
-export declare const STAGING_DIR: string;
-export declare function machineDir(machine: string): string;
+import { STAGING_DIR, STAGING_GIT_DIR, machineDir } from "./paths.js";
+export { STAGING_DIR, STAGING_GIT_DIR, machineDir };
 export declare function getStagedPath(filePath: string, machine: string): string;
 export declare function cleanStaging(machine: string): void;
 export declare function copyToStaging(files: string[], machine: string): void;
@@ -9,5 +9,5 @@ export interface ComparisonResult {
     notBackedUp: string[];
     error?: string;
 }
-export declare function compareFiles(files: string[], machine: string): Promise<ComparisonResult>;
+export declare function compareFiles(files: string[], machine: string, repository: string): Promise<ComparisonResult>;
 export declare function writeRepoReadme(repository: string): void;

package/dist/staging.js

@@ -4,11 +4,11 @@ import os from "node:os";
 import { execFileSync } from "node:child_process";
 import { simpleGit } from "simple-git";
 import { logger } from "./log.js";
+import { errorMessage, pluralize } from "./utils.js";
+import { ensureRemoteUrl, getCurrentBranch, gitError } from "./git.js";
+import { STAGING_DIR, STAGING_GIT_DIR, machineDir } from "./paths.js";
+export { STAGING_DIR, STAGING_GIT_DIR, machineDir };
 const HOME = os.homedir();
-export const STAGING_DIR = path.join(HOME, ".backdot", "repo");
-export function machineDir(machine) {
-    return path.join(STAGING_DIR, machine);
-}
 export function getStagedPath(filePath, machine) {
     const rel = path.relative(HOME, filePath);
     const destRel = rel.startsWith("..") ? filePath.slice(1) : rel;
@@ -16,8 +16,9 @@ export function getStagedPath(filePath, machine) {
 }
 export function cleanStaging(machine) {
     const dir = machineDir(machine);
-    if (!fs.existsSync(dir))
+    if (!fs.existsSync(dir)) {
         return;
+    }
     fs.rmSync(dir, { recursive: true, force: true });
     logger.info(`Cleaned staging directory for machine "${machine}"`);
 }
@@ -36,29 +37,29 @@ export function copyToStaging(files, machine) {
             logger.warn(`Failed to copy: ${filePath} -> ${dest}`);
         }
     }
-    logger.info(`Copied ${copied} file(s) to staging`);
+    logger.info(`Copied ${pluralize(copied, "file")} to staging`);
 }
 function failedComparisonResult(err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    return { backedUp: [], modified: [], notBackedUp: [], error: errorMessage };
+    return { backedUp: [], modified: [], notBackedUp: [], error: errorMessage(err) };
 }
-export async function compareFiles(files, machine) {
-    if (files.length === 0)
+export async function compareFiles(files, machine, repository) {
+    if (files.length === 0) {
         return { backedUp: [], modified: [], notBackedUp: [] };
-    const gitDir = path.join(STAGING_DIR, ".git");
-    if (!fs.existsSync(gitDir)) {
+    }
+    if (!fs.existsSync(STAGING_GIT_DIR)) {
         return failedComparisonResult(new Error("Backup repository not found. Run backdot --backup first."));
     }
     const git = simpleGit(STAGING_DIR);
     try {
+        await ensureRemoteUrl(repository);
         await git.fetch("origin");
     }
     catch (err) {
-        return failedComparisonResult(err);
+        return failedComparisonResult(gitError(err, repository));
     }
     let branch;
     try {
-        branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+        branch = await getCurrentBranch(git);
     }
     catch (err) {
         return failedComparisonResult(err);
@@ -80,8 +81,9 @@ export async function compareFiles(files, machine) {
     }
     let sourceHashes;
     try {
-        const hashOutput = execFileSync("git", ["hash-object", "--", ...files], {
+        const hashOutput = execFileSync("git", ["hash-object", "--stdin-paths"], {
             encoding: "utf-8",
+            input: files.join("\n") + "\n",
         });
         sourceHashes = hashOutput.trim().split("\n");
     }
@@ -106,7 +108,7 @@ export async function compareFiles(files, machine) {
 function repoReadme(repository) {
     return `# Backdot Backup
 
-This repository contains dotfiles backed up automatically using [backdot](https://github.com/sorenlouv/backdot).
+This repository contains files backed up automatically using [backdot](https://github.com/sorenlouv/backdot).
 
 ## Restore
 

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function errorMessage(err: unknown): string;
+export declare function uniq<T>(items: T[]): T[];
+export declare function pluralize(count: number, word: string): string;

package/dist/utils.js

@@ -0,0 +1,9 @@
+export function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function uniq(items) {
+    return [...new Set(items)];
+}
+export function pluralize(count, word) {
+    return `${count} ${word}${count !== 1 ? "s" : ""}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -32,8 +32,10 @@
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
-    "test": "vitest run --exclude src/e2e.test.ts",
+    "test": "vitest run --exclude src/e2e.test.ts --exclude src/git.integration.test.ts",
+    "test:integration": "vitest run src/git.integration.test.ts",
     "test:e2e": "npm run build && vitest run src/e2e.test.ts",
+    "test:all": "npm run build && vitest run",
     "test:watch": "vitest",
     "prepare": "husky"
   },