backdot 1.6.0 → 1.6.1

package/dist/cli.js

@@ -11,6 +11,7 @@ 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");
@@ -64,8 +65,7 @@ async function main() {
         }));
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`\n  Error: ${msg}\n`);
+        console.error(`\n  Error: ${errorMessage(err)}\n`);
         printHelp();
         process.exit(1);
     }
@@ -105,7 +105,7 @@ async function main() {
         }
     }
     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.js

@@ -8,8 +8,15 @@ export async function history(repoUrl) {
     logger.info("Starting history");
     const repository = repoUrl ?? loadConfig().repository;
     const spinner = ora("Fetching backup history").start();
-    await gitPull(repository);
-    const commits = await gitLog();
+    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");

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.js

@@ -7,6 +7,7 @@ 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,8 +19,9 @@ 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")
@@ -31,7 +33,13 @@ async function resolveRepoAndMachine(repoUrl, commit) {
         return { repository: config.repository, machine: config.machine };
     }
     const spinner = ora("Cloning backup repository").start();
-    await gitPull(repoUrl, commit);
+    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) {
@@ -55,8 +63,14 @@ export async function restore(repoUrl, commit, options = {}) {
     const { repository, machine } = await resolveRepoAndMachine(repoUrl, commit);
     const spinner = ora("Fetching latest backup").start();
     const baseDir = machineDir(machine);
-    if (!repoUrl) {
-        await gitPull(repository, commit);
+    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)) {
@@ -72,7 +86,7 @@ export async function restore(repoUrl, commit, options = {}) {
         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.");
@@ -90,6 +104,10 @@ export async function restore(repoUrl, commit, options = {}) {
     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();
+        }
     }
     else {
         const choices = [];
@@ -121,7 +139,7 @@ export async function restore(repoUrl, commit, options = {}) {
         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,3 +1,4 @@
+import { type SimpleGit } from "simple-git";
 interface FileChangeSummary {
     created: string[];
     deleted: string[];
@@ -8,6 +9,10 @@ interface FileChangeSummary {
     }>;
 }
 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;

package/dist/git.js

@@ -3,10 +3,11 @@ 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";
+import { errorMessage, pluralize, uniq } from "./utils.js";
 export function buildCommitMessage(changes, maxLen = 250) {
-    const unique = (paths) => [...new Set(paths.map((f) => path.basename(f)))];
+    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)]);
@@ -16,56 +17,97 @@ export function buildCommitMessage(changes, maxLen = 250) {
         { label: "modified", files: modified },
     ].filter((c) => c.files.length > 0);
     if (categories.length === 0) {
-        return "backup";
+        return "backup"; // fallback commit message when no changes are categorized
     }
     function format(cat, listFiles) {
         if (listFiles) {
             return `${cat.label}: ${cat.files.join(", ")}`;
         }
-        const n = cat.files.length;
-        return `${cat.label}: ${n} file${n !== 1 ? "s" : ""}`;
+        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)
+    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)
+            if (msg.length <= maxLen) {
                 return msg;
+            }
         }
     }
     return msg.slice(0, maxLen - 3) + "...";
 }
-export async function gitPull(repository, commit) {
-    if (fs.existsSync(path.join(STAGING_DIR, ".git"))) {
-        const git = simpleGit(STAGING_DIR);
-        await git.fetch("origin");
-        const target = commit ?? `origin/${await git.revparse(["--abbrev-ref", "HEAD"])}`;
-        await git.reset(["--hard", target]);
-        await git.clean(CleanOptions.FORCE, ["-d"]);
+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]);
     }
-    else {
-        try {
-            await simpleGit().clone(repository, STAGING_DIR);
-        }
-        catch {
-            fs.mkdirSync(STAGING_DIR, { recursive: true });
-            const git = simpleGit(STAGING_DIR);
-            await git.init();
-            await git.addRemote("origin", repository);
-        }
-        if (commit) {
+}
+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.reset(["--hard", commit]);
+            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");
 }
@@ -88,21 +130,27 @@ export async function gitCommitAndPush() {
     }
     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.6.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"
   },