backdot 1.2.0 → 1.3.0

package/README.md

@@ -10,16 +10,17 @@
 
 ```bash
 npm install -g backdot
+backdot --init
 ```
 
-Create `~/.backdot.json` pointing to a private repo and the files you want backed up:
+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:
 
 ```json
 {
-  "repository": "git@github.com:USERNAME/dotfiles-backup.git",
+  "repository": "git@github.com:USERNAME/backdot-backup.git",
   "machine": "my-work-laptop",
-  "files.gitignored": ["~/my-project"],
-  "files.match": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config/config", "~/.npmrc"]
+  "gitignored": ["~/my-project"],
+  "paths": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config/config", "~/.npmrc"]
 }
 ```
 
@@ -31,15 +32,16 @@ backdot --backup
 
 ## Configuration
 
-| Key                | Description                                            |
-| ------------------ | ------------------------------------------------------ |
-| `files.gitignored` | Directories to scan for gitignored files               |
-| `files.match`      | Glob patterns matching individual files or directories |
+| Key          | Description                                            |
+| ------------ | ------------------------------------------------------ |
+| `gitignored` | Directories to scan for gitignored files               |
+| `paths`      | Glob patterns matching individual files or directories |
 
 ## 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) |

package/dist/cli.js

@@ -9,6 +9,7 @@ import { resolveFiles } from "./resolve.js";
 import { cleanStaging, copyToStaging, writeRepoReadme, compareFiles } from "./staging.js";
 import { gitPull, gitCommitAndPush } from "./git.js";
 import { restore } from "./restore.js";
+import { init } from "./init.js";
 import { setupLaunchd, uninstallLaunchd, isScheduled } from "./plist.js";
 import { logger } from "./log.js";
 function getVersion() {
@@ -28,7 +29,7 @@ async function backup() {
     logger.info(`Machine: ${config.machine}`);
     const spinner = ora("Resolving files").start();
     try {
-        const userFiles = resolveFiles(config.files);
+        const userFiles = resolveFiles(config);
         logger.info(`Resolved ${userFiles.length} file(s)`);
         if (userFiles.length === 0) {
             spinner.info("No files resolved, nothing to back up");
@@ -69,7 +70,7 @@ async function status() {
         console.log(`  Machine:   ${config.machine}`);
         console.log();
         const spinner = ora("Resolving files").start();
-        const userFiles = resolveFiles(config.files);
+        const userFiles = resolveFiles(config);
         if (userFiles.length === 0) {
             spinner.warn("No files resolved. Check your ~/.backdot.json entries.");
             console.log();
@@ -123,7 +124,10 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
     try {
-        if (command === "--backup") {
+        if (command === "--init") {
+            init();
+        }
+        else if (command === "--backup") {
             await backup();
         }
         else if (command === "--schedule") {
@@ -149,6 +153,7 @@ async function main() {
             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)");
@@ -161,6 +166,10 @@ async function main() {
                 console.log();
                 process.exit(1);
             }
+            else if (!fs.existsSync(CONFIG_PATH)) {
+                console.log(`  No config found. Run ${chalk.bold("backdot --init")} to get started.`);
+                console.log();
+            }
         }
     }
     catch (err) {

package/dist/config.d.ts

@@ -1,24 +1,12 @@
 import { z } from "zod";
 export declare const CONFIG_PATH: string;
 export declare function expandTilde(p: string): string;
-declare const ConfigSchema: z.ZodPipe<z.ZodObject<{
+declare const ConfigSchema: z.ZodObject<{
     repository: z.ZodString;
     machine: z.ZodString;
-    "files.gitignored": z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
-    "files.match": z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
-}, z.core.$strip>, z.ZodTransform<{
-    repository: string;
-    machine: string;
-    files: {
-        gitignored: string[];
-        match: string[];
-    };
-}, {
-    repository: string;
-    machine: string;
-    "files.gitignored": string[];
-    "files.match": string[];
-}>>;
+    gitignored: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
+    paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
+}, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 export declare function loadConfig(): Config;
 export {};

package/dist/config.js

@@ -14,23 +14,15 @@ const ConfigSchema = z
     .object({
     repository: z.string().min(1),
     machine: z.string().min(1),
-    "files.gitignored": pathList,
-    "files.match": pathList,
+    gitignored: pathList,
+    paths: pathList,
 })
-    .refine((c) => c["files.gitignored"].length > 0 || c["files.match"].length > 0, {
-    message: 'At least one of "files.gitignored" or "files.match" must be a non-empty array',
-})
-    .transform((c) => ({
-    repository: c.repository,
-    machine: c.machine,
-    files: {
-        gitignored: c["files.gitignored"],
-        match: c["files.match"],
-    },
-}));
+    .refine((c) => c.gitignored.length > 0 || c.paths.length > 0, {
+    message: 'At least one of "gitignored" or "paths" must be a non-empty array',
+});
 export function loadConfig() {
     if (!fs.existsSync(CONFIG_PATH)) {
-        throw new Error(`Config file not found: ${CONFIG_PATH}`);
+        throw new Error(`Config file not found: ${CONFIG_PATH}\n  Run "backdot --init" to create it.`);
     }
     let raw;
     try {

package/dist/git.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 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";
@@ -36,7 +37,15 @@ export async function gitCommitAndPush() {
     const date = new Date().toISOString().split("T")[0];
     const message = `Automated backup: ${date}`;
     await git.commit(message);
-    await git.push(["-u", "origin", "HEAD"]);
+    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();
+            await git.rebase([`origin/${branch}`]);
+        },
+    });
     logger.info(`Committed and pushed: ${message}`);
     const sha = await git.revparse(["HEAD"]);
     const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): void;

package/dist/init.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import chalk from "chalk";
+import { CONFIG_PATH } from "./config.js";
+const TEMPLATE = {
+    repository: "git@github.com:USERNAME/backdot-backup.git",
+    machine: os.hostname(),
+    gitignored: [],
+    paths: ["~/.zshrc", "~/.gitconfig"],
+};
+export function init() {
+    console.log();
+    console.log(chalk.bold("  Welcome to backdot!"));
+    console.log();
+    // Step 1
+    console.log(chalk.bold("  Step 1 — Create a private Git repository"));
+    console.log();
+    console.log("  If you don't have a backup repo yet, create one:");
+    console.log();
+    console.log(`    GitHub:    ${chalk.cyan("https://github.com/new?name=backdot-backup&visibility=private")}`);
+    console.log(`    GitLab:    ${chalk.cyan("https://gitlab.com/projects/new#blank_project")}`);
+    console.log(`    Bitbucket: ${chalk.cyan("https://bitbucket.org/repo/create")}`);
+    console.log();
+    // Step 2
+    console.log(chalk.bold(`  Step 2 — Edit ${CONFIG_PATH}`));
+    console.log();
+    if (fs.existsSync(CONFIG_PATH)) {
+        console.log(`  ${chalk.yellow(`${CONFIG_PATH} already exists — skipping creation.`)}`);
+    }
+    else {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, 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();
+    // 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();
+}

package/dist/resolve.d.ts

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

package/dist/resolve.js

@@ -37,15 +37,13 @@ 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(files) {
-    const allFiles = [];
-    for (const dirPath of files.gitignored) {
-        allFiles.push(...resolveGitignored(dirPath));
-    }
-    for (const pattern of files.match) {
-        allFiles.push(...resolveGlob(pattern));
-    }
-    const unique = [...new Set(allFiles)];
+export function resolveFiles(config) {
+    const unique = [
+        ...new Set([
+            ...config.gitignored.flatMap(resolveGitignored),
+            ...config.paths.flatMap(resolveGlob),
+        ]),
+    ];
     return unique.filter((filePath) => {
         try {
             fs.accessSync(filePath, fs.constants.R_OK);

package/dist/restore.js

@@ -9,19 +9,13 @@ import { STAGING_DIR, machineDir } from "./staging.js";
 import { logger } from "./log.js";
 const HOME = os.homedir();
 function walkDir(dir) {
-    const results = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name === ".git")
-            continue;
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.name !== ".git")
+        .flatMap((entry) => {
         const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...walkDir(full));
-        }
-        else {
-            results.push(full);
-        }
-    }
-    return results;
+        return entry.isDirectory() ? walkDir(full) : [full];
+    });
 }
 function listMachines() {
     if (!fs.existsSync(STAGING_DIR))

package/dist/staging.js

@@ -38,15 +38,17 @@ export function copyToStaging(files, machine) {
     }
     logger.info(`Copied ${copied} file(s) to staging`);
 }
+const allNotBackedUp = (files) => ({
+    backedUp: [],
+    modified: [],
+    notBackedUp: files,
+});
 export async function compareFiles(files, machine) {
-    const result = { backedUp: [], modified: [], notBackedUp: [] };
     if (files.length === 0)
-        return result;
+        return { backedUp: [], modified: [], notBackedUp: [] };
     const gitDir = path.join(STAGING_DIR, ".git");
-    if (!fs.existsSync(gitDir)) {
-        result.notBackedUp.push(...files);
-        return result;
-    }
+    if (!fs.existsSync(gitDir))
+        return allNotBackedUp(files);
     const git = simpleGit(STAGING_DIR);
     await git.fetch("origin");
     let branch;
@@ -54,27 +56,22 @@ export async function compareFiles(files, machine) {
         branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
     }
     catch {
-        result.notBackedUp.push(...files);
-        return result;
+        return allNotBackedUp(files);
     }
-    const committedHashes = new Map();
+    let committedHashes;
     try {
         const treeOutput = execFileSync("git", ["ls-tree", "-r", `origin/${branch}`, `${machine}/`], {
             encoding: "utf-8",
             cwd: STAGING_DIR,
         });
-        for (const line of treeOutput.split("\n")) {
-            if (!line)
-                continue;
-            const match = line.match(/^\d+ blob ([0-9a-f]+)\t(.+)$/);
-            if (match) {
-                committedHashes.set(match[2], match[1]);
-            }
-        }
+        committedHashes = new Map(treeOutput
+            .split("\n")
+            .map((line) => line.match(/^\d+ blob ([0-9a-f]+)\t(.+)$/))
+            .filter((m) => m !== null)
+            .map((m) => [m[2], m[1]]));
     }
     catch {
-        result.notBackedUp.push(...files);
-        return result;
+        return allNotBackedUp(files);
     }
     let sourceHashes;
     try {
@@ -84,24 +81,22 @@ export async function compareFiles(files, machine) {
         sourceHashes = hashOutput.trim().split("\n");
     }
     catch {
-        result.notBackedUp.push(...files);
-        return result;
+        return allNotBackedUp(files);
     }
-    for (let i = 0; i < files.length; i++) {
-        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(files[i], machine));
+    return files.reduce((acc, file, i) => {
+        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(file, machine));
         const committedHash = committedHashes.get(repoRelPath);
-        const sourceHash = sourceHashes[i];
         if (!committedHash) {
-            result.notBackedUp.push(files[i]);
+            acc.notBackedUp.push(file);
         }
-        else if (committedHash === sourceHash) {
-            result.backedUp.push(files[i]);
+        else if (committedHash === sourceHashes[i]) {
+            acc.backedUp.push(file);
         }
         else {
-            result.modified.push(files[i]);
+            acc.modified.push(file);
         }
-    }
-    return result;
+        return acc;
+    }, { backedUp: [], modified: [], notBackedUp: [] });
 }
 function repoReadme(repository) {
     return `# Backdot Backup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,8 @@
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
-    "test": "vitest run",
+    "test": "vitest run --exclude src/e2e.test.ts",
+    "test:e2e": "npm run build && vitest run src/e2e.test.ts",
     "test:watch": "vitest"
   },
   "dependencies": {
@@ -36,6 +37,7 @@
     "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
     "ora": "^9.3.0",
+    "p-retry": "^7.1.1",
     "simple-git": "^3.32.2",
     "winston": "^3.19.0",
     "zod": "^4.3.6"