backdot 1.1.0 → 1.2.0

package/README.md

@@ -1,6 +1,10 @@
-# backdot
+<p align="center">
+  <img src="logo-small.png" alt="backdot" width="400" />
+</p>
 
-Back up dotfiles and gitignored files to a private Git repo — on demand or on a daily schedule.
+<h1 align="center">backdot</h1>
+
+<p align="center">Automated backup of important files (configs, dotfiles, gitignored files) to your own private Git repo.</p>
 
 ## Getting started
 

package/dist/cli.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
+import chalk from "chalk";
 import ora from "ora";
 import { loadConfig, CONFIG_PATH } from "./config.js";
 import { resolveFiles } from "./resolve.js";
-import { cleanStaging, copyToStaging, writeRepoReadme } from "./staging.js";
+import { cleanStaging, copyToStaging, writeRepoReadme, compareFiles } from "./staging.js";
 import { gitPull, gitCommitAndPush } from "./git.js";
 import { restore } from "./restore.js";
 import { setupLaunchd, uninstallLaunchd, isScheduled } from "./plist.js";
@@ -38,10 +40,13 @@ async function backup() {
         spinner.text = `Copying ${files.length} file(s) to staging`;
         cleanStaging(config.machine);
         copyToStaging(files, config.machine);
-        writeRepoReadme();
+        writeRepoReadme(config.repository);
         spinner.text = "Pushing to remote";
-        await gitCommitAndPush();
-        spinner.succeed("Backup complete");
+        const result = await gitCommitAndPush();
+        const successMsg = result?.commitUrl
+            ? `Backup complete → ${result.commitUrl}`
+            : "Backup complete";
+        spinner.succeed(successMsg);
         console.log();
     }
     catch (err) {
@@ -50,7 +55,11 @@ async function backup() {
     }
     logger.info("Backup complete");
 }
-function status() {
+function tildePath(filePath) {
+    const home = os.homedir();
+    return filePath.startsWith(home) ? "~" + filePath.slice(home.length) : filePath;
+}
+async function status() {
     const scheduled = isScheduled();
     console.log();
     console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : "not active"}`);
@@ -63,15 +72,39 @@ function status() {
         const userFiles = resolveFiles(config.files);
         if (userFiles.length === 0) {
             spinner.warn("No files resolved. Check your ~/.backdot.json entries.");
+            console.log();
+            return;
+        }
+        const files = [...userFiles, CONFIG_PATH];
+        spinner.text = "Comparing with remote backup";
+        const { backedUp, modified, notBackedUp } = await compareFiles(files, config.machine);
+        spinner.stop();
+        if (modified.length === 0 && notBackedUp.length === 0) {
+            console.log(chalk.green(`  All ${files.length} file(s) are backed up ✓`));
         }
         else {
-            const files = [...userFiles, CONFIG_PATH];
-            spinner.stop();
-            console.log(`${files.length} file(s) resolved:`);
-            console.log();
-            for (const file of files) {
-                console.log(`  ${file}`);
+            if (modified.length > 0) {
+                console.log(chalk.yellow(`  Modified since last backup (${modified.length}):`));
+                for (const f of modified) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
+            }
+            if (notBackedUp.length > 0) {
+                console.log(chalk.red(`  Not yet backed up (${notBackedUp.length}):`));
+                for (const f of notBackedUp) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
+            }
+            if (backedUp.length > 0) {
+                console.log(chalk.green(`  Backed up (${backedUp.length}):`));
+                for (const f of backedUp) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
             }
+            console.log(`  Run ${chalk.bold("backdot --backup")} to back up all changes.`);
         }
     }
     catch (err) {
@@ -102,10 +135,10 @@ async function main() {
             uninstallLaunchd();
         }
         else if (command === "--status") {
-            status();
+            await status();
         }
         else if (command === "--restore") {
-            await restore();
+            await restore(args[1]);
         }
         else if (command === "--version") {
             console.log(getVersion());
@@ -117,7 +150,7 @@ async function main() {
             console.log("  Commands:");
             console.log();
             console.log("    --backup       Run a backup now");
-            console.log("    --restore      Restore files from the backup repo");
+            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");

package/dist/commitUrl.d.ts

@@ -0,0 +1 @@
+export declare function getCommitUrl(remoteUrl: string, sha: string): string | null;

package/dist/commitUrl.js

@@ -0,0 +1,18 @@
+const PROVIDERS = {
+    "github.com": (p, sha) => `https://github.com/${p}/commit/${sha}`,
+    "gitlab.com": (p, sha) => `https://gitlab.com/${p}/-/commit/${sha}`,
+    "bitbucket.org": (p, sha) => `https://bitbucket.org/${p}/commits/${sha}`,
+};
+export function getCommitUrl(remoteUrl, sha) {
+    for (const [host, buildUrl] of Object.entries(PROVIDERS)) {
+        const idx = remoteUrl.indexOf(host);
+        if (idx === -1)
+            continue;
+        let repoPath = remoteUrl.slice(idx + host.length + 1).trim();
+        if (repoPath.endsWith(".git")) {
+            repoPath = repoPath.slice(0, -4);
+        }
+        return buildUrl(repoPath, sha);
+    }
+    return null;
+}

package/dist/git.d.ts

@@ -1,2 +1,4 @@
 export declare function gitPull(repository: string): Promise<void>;
-export declare function gitCommitAndPush(): Promise<void>;
+export declare function gitCommitAndPush(): Promise<{
+    commitUrl: string | null;
+} | null>;

package/dist/git.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { simpleGit, CleanOptions } from "simple-git";
 import { logger } from "./log.js";
 import { STAGING_DIR } from "./staging.js";
+import { getCommitUrl } from "./commitUrl.js";
 export async function gitPull(repository) {
     if (fs.existsSync(path.join(STAGING_DIR, ".git"))) {
         const git = simpleGit(STAGING_DIR);
@@ -30,11 +31,15 @@ export async function gitCommitAndPush() {
     const status = await git.status();
     if (status.isClean()) {
         logger.info("No changes to commit");
-        return;
+        return null;
     }
     const date = new Date().toISOString().split("T")[0];
     const message = `Automated backup: ${date}`;
     await git.commit(message);
     await git.push(["-u", "origin", "HEAD"]);
     logger.info(`Committed and pushed: ${message}`);
+    const sha = await git.revparse(["HEAD"]);
+    const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";
+    const commitUrl = getCommitUrl(remoteUrl, sha);
+    return { commitUrl };
 }

package/dist/restore.d.ts

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

package/dist/restore.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import ora from "ora";
-import { checkbox } from "@inquirer/prompts";
+import { checkbox, select } from "@inquirer/prompts";
 import { loadConfig } from "./config.js";
 import { gitPull } from "./git.js";
 import { STAGING_DIR, machineDir } from "./staging.js";
@@ -31,22 +31,48 @@ function listMachines() {
         .filter((e) => e.isDirectory() && e.name !== ".git")
         .map((e) => e.name);
 }
-export async function restore() {
+async function resolveRepoAndMachine(repoUrl) {
+    if (!repoUrl) {
+        const config = loadConfig();
+        return { repository: config.repository, machine: config.machine };
+    }
+    const spinner = ora("Cloning backup repository").start();
+    await gitPull(repoUrl);
+    spinner.stop();
+    const machines = listMachines();
+    if (machines.length === 0) {
+        throw new Error("The backup repository is empty (no machine directories found).");
+    }
+    let machine;
+    if (machines.length === 1) {
+        machine = machines[0];
+    }
+    else {
+        machine = await select({
+            message: "Multiple machines found. Which one do you want to restore?",
+            choices: machines.map((m) => ({ name: m, value: m })),
+        });
+    }
+    return { repository: repoUrl, machine };
+}
+export async function restore(repoUrl) {
     logger.info("Starting restore");
-    const config = loadConfig();
-    const baseDir = machineDir(config.machine);
+    const { repository, machine } = await resolveRepoAndMachine(repoUrl);
     const spinner = ora("Fetching latest backup").start();
-    await gitPull(config.repository);
+    const baseDir = machineDir(machine);
+    if (!repoUrl) {
+        await gitPull(repository);
+    }
     spinner.text = "Resolving files";
     if (!fs.existsSync(baseDir)) {
         spinner.stop();
         const available = listMachines();
         if (available.length > 0) {
-            console.log(`\n  No backup found for machine "${config.machine}".`);
+            console.log(`\n  No backup found for machine "${machine}".`);
             console.log(`  Available machines: ${available.join(", ")}\n`);
         }
         else {
-            console.log(`\n  No backup found for machine "${config.machine}". The repository is empty.\n`);
+            console.log(`\n  No backup found for machine "${machine}". The repository is empty.\n`);
         }
         return;
     }

package/dist/staging.d.ts

@@ -1,5 +1,12 @@
 export declare const STAGING_DIR: string;
 export declare function machineDir(machine: string): string;
+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;
-export declare function writeRepoReadme(): void;
+export interface ComparisonResult {
+    backedUp: string[];
+    modified: string[];
+    notBackedUp: string[];
+}
+export declare function compareFiles(files: string[], machine: string): Promise<ComparisonResult>;
+export declare function writeRepoReadme(repository: string): void;

package/dist/staging.js

@@ -1,12 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { execFileSync } from "node:child_process";
+import { simpleGit } from "simple-git";
 import { logger } from "./log.js";
 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;
+    return path.join(machineDir(machine), destRel);
+}
 export function cleanStaging(machine) {
     const dir = machineDir(machine);
     if (!fs.existsSync(dir))
@@ -19,9 +26,7 @@ export function copyToStaging(files, machine) {
     fs.mkdirSync(dir, { recursive: true });
     let copied = 0;
     for (const filePath of files) {
-        const rel = path.relative(HOME, filePath);
-        const destRel = rel.startsWith("..") ? filePath.slice(1) : rel;
-        const dest = path.join(dir, destRel);
+        const dest = getStagedPath(filePath, machine);
         try {
             fs.mkdirSync(path.dirname(dest), { recursive: true });
             fs.copyFileSync(filePath, dest);
@@ -33,27 +38,86 @@ export function copyToStaging(files, machine) {
     }
     logger.info(`Copied ${copied} file(s) to staging`);
 }
-const REPO_README = `# Dotfiles Backup
+export async function compareFiles(files, machine) {
+    const result = { backedUp: [], modified: [], notBackedUp: [] };
+    if (files.length === 0)
+        return result;
+    const gitDir = path.join(STAGING_DIR, ".git");
+    if (!fs.existsSync(gitDir)) {
+        result.notBackedUp.push(...files);
+        return result;
+    }
+    const git = simpleGit(STAGING_DIR);
+    await git.fetch("origin");
+    let branch;
+    try {
+        branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    }
+    catch {
+        result.notBackedUp.push(...files);
+        return result;
+    }
+    const committedHashes = new Map();
+    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]);
+            }
+        }
+    }
+    catch {
+        result.notBackedUp.push(...files);
+        return result;
+    }
+    let sourceHashes;
+    try {
+        const hashOutput = execFileSync("git", ["hash-object", "--", ...files], {
+            encoding: "utf-8",
+        });
+        sourceHashes = hashOutput.trim().split("\n");
+    }
+    catch {
+        result.notBackedUp.push(...files);
+        return result;
+    }
+    for (let i = 0; i < files.length; i++) {
+        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(files[i], machine));
+        const committedHash = committedHashes.get(repoRelPath);
+        const sourceHash = sourceHashes[i];
+        if (!committedHash) {
+            result.notBackedUp.push(files[i]);
+        }
+        else if (committedHash === sourceHash) {
+            result.backedUp.push(files[i]);
+        }
+        else {
+            result.modified.push(files[i]);
+        }
+    }
+    return result;
+}
+function repoReadme(repository) {
+    return `# Backdot Backup
 
 This repository contains dotfiles backed up automatically using [backdot](https://github.com/sorenlouv/backdot).
 
-## Quick start
-
-Install backdot:
+## Restore
 
 \`\`\`bash
-npm install -g backdot
-\`\`\`
-
-Restore files from this backup:
-
-\`\`\`bash
-backdot --restore
+npx backdot --restore ${repository}
 \`\`\`
 
 For full documentation, configuration options, and scheduling, see the [official README](https://github.com/sorenlouv/backdot).
 `;
-export function writeRepoReadme() {
-    fs.writeFileSync(path.join(STAGING_DIR, "README.md"), REPO_README);
+}
+export function writeRepoReadme(repository) {
+    fs.writeFileSync(path.join(STAGING_DIR, "README.md"), repoReadme(repository));
     logger.info("Wrote README.md to staging directory");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -21,6 +21,8 @@
   ],
   "scripts": {
     "build": "tsc",
+    "build:watch": "tsc --watch",
+    "release": "./scripts/release.sh",
     "start": "node dist/cli.js",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
@@ -31,6 +33,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
     "ora": "^9.3.0",
     "simple-git": "^3.32.2",