backdot 1.8.0 → 1.8.1

package/dist/cli.js

@@ -16,8 +16,8 @@ import { sendNotification } from "./notify.js";
 function getVersion() {
     const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
     try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return pkg.version ?? "unknown";
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return packageJson.version ?? "unknown";
     }
     catch {
         return "unknown";

package/dist/commands/backup.js

@@ -8,6 +8,7 @@ import { gitPull, gitCommitAndPush } from "../git.js";
 import { logger } from "../log.js";
 import { pluralize } from "../utils.js";
 import { checkRepoVisibility } from "../repoVisibility.js";
+import { confirm } from "@inquirer/prompts";
 import { decrypt, deriveKey } from "../crypto/encryption.js";
 import { resolvePassword, offerToSaveKeyFile, confirmPassword, ENC_SUFFIX, } from "../crypto/password.js";
 function findEncryptedFile(dir) {
@@ -35,11 +36,12 @@ export async function backup() {
     logger.info(`Machine: ${config.machine}`);
     let password;
     let derivedKey;
-    let passwordWasInteractive = false;
     if (config.encrypt) {
         const result = await resolvePassword();
         password = result.password;
-        passwordWasInteractive = result.interactive;
+        if (result.source === "prompt") {
+            await confirmPassword(password);
+        }
         derivedKey = deriveKey(password);
     }
     const spinner = ora("Checking repository visibility").start();
@@ -70,15 +72,22 @@ export async function backup() {
                     decrypt(encryptedContent, derivedKey);
                 }
                 catch {
-                    spinner.fail("Backup failed");
-                    throw new Error("Password does not match the existing backup.");
+                    if (!process.stdin.isTTY) {
+                        spinner.fail("Backup failed");
+                        throw new Error("Password does not match the existing backup.\n" +
+                            "Run interactively to re-encrypt with a new password.");
+                    }
+                    spinner.stop();
+                    const shouldReEncrypt = await confirm({
+                        message: "Password does not match the existing backup. Re-encrypt all files with the new password?",
+                        default: false,
+                    });
+                    if (!shouldReEncrypt) {
+                        throw new Error("Backup aborted.");
+                    }
+                    spinner.start();
                 }
             }
-            else if (passwordWasInteractive) {
-                spinner.stop();
-                await confirmPassword(password);
-                spinner.start();
-            }
         }
         spinner.text = `Copying ${pluralize(files.length, "file")} to staging`;
         cleanStaging(config.machine);

package/dist/commands/restore.js

@@ -55,7 +55,7 @@ async function resolveRepoAndMachine(repoUrl, commit) {
         machine = await select({
             message: "Multiple machines found. Which one do you want to restore?",
             loop: false,
-            choices: machines.map((m) => ({ name: m, value: m })),
+            choices: machines.map((machine) => ({ name: machine, value: machine })),
         });
     }
     return { repository: repoUrl, machine };
@@ -64,7 +64,7 @@ export async function restore({ repoUrl, commit, yes, } = {}) {
     logger.info("Starting restore");
     const { repository, machine } = await resolveRepoAndMachine(repoUrl, commit);
     const spinner = ora("Fetching latest backup").start();
-    const baseDir = machineDir(machine);
+    const machineStagingDir = machineDir(machine);
     try {
         if (!repoUrl) {
             await gitPull(repository, commit);
@@ -75,31 +75,31 @@ export async function restore({ repoUrl, commit, yes, } = {}) {
         throw err;
     }
     spinner.text = "Resolving files";
-    if (!fs.existsSync(baseDir)) {
+    if (!fs.existsSync(machineStagingDir)) {
         spinner.stop();
-        const available = listMachines();
-        if (available.length > 0) {
+        const availableMachines = listMachines();
+        if (availableMachines.length > 0) {
             console.log(`\n  No backup found for machine "${machine}".`);
-            console.log(`  Available machines: ${available.join(", ")}\n`);
+            console.log(`  Available machines: ${availableMachines.join(", ")}\n`);
         }
         else {
             console.log(`\n  No backup found for machine "${machine}". The repository is empty.\n`);
         }
         return;
     }
-    const stagedFiles = listFilesRecursively(baseDir);
-    logger.info(`Found ${pluralize(stagedFiles.length, "file")} in backup repository`);
-    if (stagedFiles.length === 0) {
+    const backupFiles = listFilesRecursively(machineStagingDir);
+    logger.info(`Found ${pluralize(backupFiles.length, "file")} in backup repository`);
+    if (backupFiles.length === 0) {
         spinner.stop();
         console.log("No files found in backup repository.");
         return;
     }
-    const fileMappings = stagedFiles.map((stagedFilePath) => {
-        let relativePath = path.relative(baseDir, stagedFilePath);
+    const fileMappings = backupFiles.map((backupFilePath) => {
+        let relativePath = path.relative(machineStagingDir, backupFilePath);
         if (relativePath.endsWith(ENC_SUFFIX)) {
             relativePath = relativePath.slice(0, -ENC_SUFFIX.length);
         }
-        return { src: stagedFilePath, dest: path.join(HOME, relativePath), rel: relativePath };
+        return { src: backupFilePath, dest: path.join(HOME, relativePath), relativePath };
     });
     const filesAlreadyOnDisk = fileMappings.filter((file) => fs.existsSync(file.dest));
     const newFiles = fileMappings.filter((file) => !fs.existsSync(file.dest));
@@ -119,13 +119,13 @@ export async function restore({ repoUrl, commit, yes, } = {}) {
         if (newFiles.length > 0) {
             choices.push(new Separator(`── New files (${newFiles.length}) ──`));
             for (const file of newFiles) {
-                choices.push({ name: file.rel, value: file, checked: true });
+                choices.push({ name: file.relativePath, value: file, checked: true });
             }
         }
         if (filesAlreadyOnDisk.length > 0) {
             choices.push(new Separator(`── Existing files — will overwrite (${filesAlreadyOnDisk.length}) ──`));
             for (const file of filesAlreadyOnDisk) {
-                choices.push({ name: file.rel, value: file, checked: false });
+                choices.push({ name: file.relativePath, value: file, checked: false });
             }
         }
         filesToRestore = await checkbox({

package/dist/commands/schedule.js

@@ -14,7 +14,7 @@ export function schedule() {
     try {
         const config = loadConfig();
         if (config.encrypt && !fs.existsSync(KEY_FILE_PATH)) {
-            console.log(chalk.yellow(`  Encryption is enabled. Run ${chalk.bold("backdot backup")} once to create ~/.backdot.key,\n` +
+            console.log(chalk.yellow(`  Encryption is enabled. Run ${chalk.bold("backdot backup")} once to create ${KEY_FILE_PATH},\n` +
                 `  or set ${chalk.bold("BACKDOT_PASSWORD")} in your environment.\n`));
         }
     }

package/dist/commitUrl.js

@@ -1,20 +1,17 @@
+import { extractRepoPath } from "./utils.js";
 const PROVIDERS = {
     "github.com": (repoPath, sha) => `https://github.com/${repoPath}/commit/${sha}`,
     "gitlab.com": (repoPath, sha) => `https://gitlab.com/${repoPath}/-/commit/${sha}`,
     "bitbucket.org": (repoPath, sha) => `https://bitbucket.org/${repoPath}/commits/${sha}`,
 };
 export function getCommitUrl(remoteUrl, sha) {
-    for (const [host, buildUrl] of Object.entries(PROVIDERS)) {
-        const idx = remoteUrl.indexOf(host);
-        if (idx === -1) {
-            continue;
-        }
-        const separatorLength = 1; // skip the ":" (SSH) or "/" (HTTPS) after the hostname
-        let repoPath = remoteUrl.slice(idx + host.length + separatorLength).trim();
-        if (repoPath.endsWith(".git")) {
-            repoPath = repoPath.slice(0, -4);
-        }
-        return buildUrl(repoPath, sha);
+    const parsed = extractRepoPath(remoteUrl);
+    if (!parsed) {
+        return null;
     }
-    return null;
+    const buildUrl = PROVIDERS[parsed.host];
+    if (!buildUrl) {
+        return null;
+    }
+    return buildUrl(parsed.repoPath, sha);
 }

package/dist/config.js

@@ -32,14 +32,14 @@ export function loadConfig() {
     catch {
         throw new Error(`Failed to read config file: ${CONFIG_PATH}`);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(rawJson);
+        parsedJson = JSON.parse(rawJson);
     }
     catch {
         throw new Error(`Invalid JSON in config file: ${CONFIG_PATH}`);
     }
-    const result = ConfigSchema.safeParse(parsed);
+    const result = ConfigSchema.safeParse(parsedJson);
     if (!result.success) {
         const messages = result.error.issues.map((issue) => {
             const field = issue.path.length > 0 ? `"${issue.path.join(".")}"` : "config";

package/dist/crypto/encryption.d.ts

@@ -1,8 +1,9 @@
+/** An encryption key derived from the user's password via scrypt. */
 export interface DerivedKey {
-    password: string;
+    passwordHash: string;
     salt: Buffer;
     key: Buffer;
 }
-export declare function deriveKey(password: string, salt?: Buffer): DerivedKey;
+export declare function deriveKey(passwordHash: string, salt?: Buffer): DerivedKey;
 export declare function encrypt(plaintext: Buffer, derivedKey: DerivedKey): Buffer;
-export declare function decrypt(encrypted: Buffer, derivedKey: DerivedKey): Buffer;
+export declare function decrypt(encryptedPayload: Buffer, derivedKey: DerivedKey): Buffer;

package/dist/crypto/encryption.js

@@ -15,16 +15,16 @@ const SCRYPT_PARAMS = {
     maxmem: 128 * SCRYPT_N * SCRYPT_R * 2, // must exceed 128*N*r
 };
 const OVERHEAD = SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH;
-export function deriveKey(password, salt) {
+export function deriveKey(passwordHash, salt) {
     const resolvedSalt = salt ?? crypto.randomBytes(SALT_LENGTH);
-    const key = crypto.scryptSync(password, resolvedSalt, KEY_LENGTH, SCRYPT_PARAMS);
-    return { password, salt: resolvedSalt, key };
+    const key = crypto.scryptSync(passwordHash, resolvedSalt, KEY_LENGTH, SCRYPT_PARAMS);
+    return { passwordHash, salt: resolvedSalt, key };
 }
 function deriveKeyForSalt(derivedKey, salt) {
     if (derivedKey.salt.equals(salt)) {
         return derivedKey.key;
     }
-    return crypto.scryptSync(derivedKey.password, salt, KEY_LENGTH, SCRYPT_PARAMS);
+    return crypto.scryptSync(derivedKey.passwordHash, salt, KEY_LENGTH, SCRYPT_PARAMS);
 }
 export function encrypt(plaintext, derivedKey) {
     const iv = crypto.randomBytes(IV_LENGTH);
@@ -33,15 +33,18 @@ export function encrypt(plaintext, derivedKey) {
     const authTag = cipher.getAuthTag();
     return Buffer.concat([derivedKey.salt, iv, authTag, ciphertext]);
 }
-export function decrypt(encrypted, derivedKey) {
-    if (encrypted.length < OVERHEAD) {
+export function decrypt(encryptedPayload, derivedKey) {
+    if (encryptedPayload.length < OVERHEAD) {
         throw new Error("Data is too short to be encrypted content.");
     }
     let offset = 0;
-    const salt = encrypted.subarray(offset, (offset += SALT_LENGTH));
-    const iv = encrypted.subarray(offset, (offset += IV_LENGTH));
-    const authTag = encrypted.subarray(offset, (offset += AUTH_TAG_LENGTH));
-    const ciphertext = encrypted.subarray(offset);
+    const salt = encryptedPayload.subarray(offset, offset + SALT_LENGTH);
+    offset += SALT_LENGTH;
+    const iv = encryptedPayload.subarray(offset, offset + IV_LENGTH);
+    offset += IV_LENGTH;
+    const authTag = encryptedPayload.subarray(offset, offset + AUTH_TAG_LENGTH);
+    offset += AUTH_TAG_LENGTH;
+    const ciphertext = encryptedPayload.subarray(offset);
     const key = deriveKeyForSalt(derivedKey, salt);
     const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
     decipher.setAuthTag(authTag);

package/dist/crypto/password.d.ts

@@ -2,10 +2,11 @@ export declare const KEY_FILE_PATH: string;
 export declare const ENC_SUFFIX = ".encrypted";
 export declare function checkKeyFilePermissions(): void;
 export declare function saveKeyFile(password: string): void;
+export type PasswordSource = "env" | "file" | "prompt";
 export interface PasswordResult {
     password: string;
-    interactive: boolean;
+    source: PasswordSource;
 }
 export declare function resolvePassword(): Promise<PasswordResult>;
-export declare function confirmPassword(password: string): Promise<void>;
+export declare function confirmPassword(hashedPassword: string): Promise<void>;
 export declare function offerToSaveKeyFile(password: string): Promise<void>;

package/dist/crypto/password.js

@@ -1,9 +1,13 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { password as passwordPrompt, confirm } from "@inquirer/prompts";
 export const KEY_FILE_PATH = path.join(os.homedir(), ".backdot.key");
 export const ENC_SUFFIX = ".encrypted";
+function hashPassword(password) {
+    return crypto.createHash("sha256").update(password).digest("hex");
+}
 export function checkKeyFilePermissions() {
     if (process.platform === "win32") {
         return;
@@ -32,24 +36,24 @@ function readKeyFile() {
 export async function resolvePassword() {
     const envPassword = process.env.BACKDOT_PASSWORD;
     if (envPassword) {
-        return { password: envPassword, interactive: false };
+        return { password: hashPassword(envPassword), source: "env" };
     }
     const filePassword = readKeyFile();
     if (filePassword) {
-        return { password: filePassword, interactive: false };
+        return { password: filePassword, source: "file" };
     }
     if (!process.stdin.isTTY) {
-        throw new Error('Encryption is enabled but no password found.\n  Run "backdot backup" interactively to create ~/.backdot.key, or set BACKDOT_PASSWORD.');
+        throw new Error(`Encryption is enabled but no password found.\n  Run "backdot backup" interactively to create ${KEY_FILE_PATH}, or set BACKDOT_PASSWORD.`);
     }
     const enteredPassword = await passwordPrompt({ message: "Enter encryption password:" });
     if (!enteredPassword) {
         throw new Error("No password provided.");
     }
-    return { password: enteredPassword, interactive: true };
+    return { password: hashPassword(enteredPassword), source: "prompt" };
 }
-export async function confirmPassword(password) {
+export async function confirmPassword(hashedPassword) {
     const confirmedPassword = await passwordPrompt({ message: "Confirm password:" });
-    if (confirmedPassword !== password) {
+    if (hashPassword(confirmedPassword) !== hashedPassword) {
         throw new Error("Passwords do not match.");
     }
 }
@@ -64,7 +68,7 @@ export async function offerToSaveKeyFile(password) {
         return;
     }
     const save = await confirm({
-        message: "Save password to ~/.backdot.key for automated backups?",
+        message: `Save password to ${KEY_FILE_PATH} for automated backups?`,
         default: true,
     });
     if (save) {

package/dist/git.d.ts

@@ -11,7 +11,7 @@ interface FileChangeSummary {
 export declare function buildCommitMessage(changes: FileChangeSummary, maxLength?: 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 friendlyGitError(rawErrorMessage: 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<{

package/dist/git.js

@@ -57,8 +57,8 @@ export async function ensureRemoteUrl(repository) {
 export async function getCurrentBranch(git) {
     return (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
 }
-export function friendlyGitError(raw, repository) {
-    const normalizedMessage = raw.toLowerCase();
+export function friendlyGitError(rawErrorMessage, repository) {
+    const normalizedMessage = rawErrorMessage.toLowerCase();
     if (normalizedMessage.includes("not found") ||
         normalizedMessage.includes("does not exist") ||
         normalizedMessage.includes("does not appear to be a git repository")) {
@@ -73,7 +73,7 @@ export function friendlyGitError(raw, repository) {
         normalizedMessage.includes("connection timed out")) {
         return "Could not connect to remote host. Check your internet connection.";
     }
-    return raw;
+    return rawErrorMessage;
 }
 export function gitError(err, repository) {
     const raw = errorMessage(err);
@@ -116,8 +116,8 @@ export async function gitPull(repository, commit) {
 }
 export async function gitLog(limit = 20) {
     const git = simpleGit(STAGING_DIR);
-    const log = await git.log({ maxCount: limit });
-    return log.all.map((entry) => ({
+    const logResult = await git.log({ maxCount: limit });
+    return logResult.all.map((entry) => ({
         hash: entry.hash,
         date: entry.date,
         message: entry.message,
@@ -133,6 +133,7 @@ export async function gitCommitAndPush() {
     }
     const message = buildCommitMessage(status);
     await git.commit(message);
+    const remoteUrl = ((await git.remote(["get-url", "origin"])) ?? "").trim();
     try {
         await pRetry(async () => git.push(["-u", "origin", "HEAD"]), {
             retries: 5,
@@ -151,12 +152,10 @@ export async function gitCommitAndPush() {
         });
     }
     catch (err) {
-        const remoteUrl = ((await git.remote(["get-url", "origin"])) ?? "").trim();
         throw gitError(err, remoteUrl);
     }
     logger.info(`Committed and pushed: ${message}`);
     const commitHash = (await git.revparse(["HEAD"])).trim();
-    const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";
     const commitUrl = getCommitUrl(remoteUrl, commitHash);
     return { commitUrl };
 }

package/dist/launchd.js

@@ -5,8 +5,8 @@ import os from "node:os";
 import ora from "ora";
 import { logger } from "./log.js";
 import { errorMessage } from "./utils.js";
-function escapeXml(s) {
-    return s
+function escapeXml(text) {
+    return text
         .replace(/&/g, "&")
         .replace(/</g, "&lt;")
         .replace(/>/g, "&gt;")

package/dist/notify.js

@@ -8,12 +8,12 @@ export function sendNotification(title, message) {
     if (process.platform !== "darwin") {
         return;
     }
-    const escaped = escapeAppleScript(message);
-    const titleEscaped = escapeAppleScript(title);
+    const escapedMessage = escapeAppleScript(message);
+    const escapedTitle = escapeAppleScript(title);
     try {
         execFileSync("osascript", [
             "-e",
-            `display notification "${escaped}" with title "${titleEscaped}" subtitle "Scheduled backup failed"`,
+            `display notification "${escapedMessage}" with title "${escapedTitle}" subtitle "Scheduled backup failed"`,
         ], { stdio: "pipe" });
     }
     catch (err) {

package/dist/repoVisibility.js

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-const KNOWN_HOSTS = ["github.com", "gitlab.com", "bitbucket.org"];
+import { extractRepoPath } from "./utils.js";
 /**
  * Converts an SSH or HTTPS repo URL to a credential-free HTTPS URL
  * for known hosts. Returns `null` for unrecognized hosts.
@@ -9,18 +9,11 @@ const KNOWN_HOSTS = ["github.com", "gitlab.com", "bitbucket.org"];
  *   https://github.com/user/repo  → https://github.com/user/repo.git
  */
 export function toHttpsUrl(repository) {
-    for (const host of KNOWN_HOSTS) {
-        const idx = repository.indexOf(host);
-        if (idx === -1) {
-            continue;
-        }
-        let repoPath = repository.slice(idx + host.length + 1).trim();
-        if (!repoPath.endsWith(".git")) {
-            repoPath += ".git";
-        }
-        return `https://${host}/${repoPath}`;
+    const parsed = extractRepoPath(repository);
+    if (!parsed) {
+        return null;
     }
-    return null;
+    return `https://${parsed.host}/${parsed.repoPath}.git`;
 }
 /**
  * Checks whether `repository` is publicly readable by attempting an

package/dist/staging.js

@@ -93,7 +93,20 @@ export async function compareFiles(opts) {
         return failedComparisonResult(err);
     }
     if (derivedKey) {
-        return compareFilesEncrypted(files, machine, remoteBlobHashes, derivedKey);
+        return compareFilesToRemote(files, machine, remoteBlobHashes, ENC_SUFFIX, (file, remoteBlobHash) => {
+            try {
+                const blobContent = execFileSync("git", ["cat-file", "blob", remoteBlobHash], {
+                    cwd: STAGING_DIR,
+                    maxBuffer: 50 * 1024 * 1024,
+                });
+                const decrypted = decrypt(blobContent, derivedKey);
+                const localContent = fs.readFileSync(file);
+                return decrypted.equals(localContent);
+            }
+            catch {
+                return false;
+            }
+        });
     }
     let localFileHashes;
     try {
@@ -106,45 +119,23 @@ export async function compareFiles(opts) {
     catch (err) {
         return failedComparisonResult(err);
     }
-    return files.reduce((result, file, i) => {
-        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(file, machine));
-        const remoteBlobHash = remoteBlobHashes.get(repoRelPath);
-        if (!remoteBlobHash) {
-            result.notBackedUp.push(file);
-        }
-        else if (remoteBlobHash === localFileHashes[i]) {
-            result.backedUp.push(file);
-        }
-        else {
-            result.modified.push(file);
-        }
-        return result;
-    }, { backedUp: [], modified: [], notBackedUp: [] });
+    const localHashByFile = new Map(files.map((file, i) => [file, localFileHashes[i]]));
+    return compareFilesToRemote(files, machine, remoteBlobHashes, "", (file, remoteBlobHash) => {
+        return remoteBlobHash === localHashByFile.get(file);
+    });
 }
-function compareFilesEncrypted(files, machine, remoteBlobHashes, derivedKey) {
+function compareFilesToRemote(files, machine, remoteBlobHashes, pathSuffix, matchesRemote) {
     const result = { backedUp: [], modified: [], notBackedUp: [] };
     for (const file of files) {
-        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(file, machine)) + ENC_SUFFIX;
-        const remoteBlobHash = remoteBlobHashes.get(repoRelPath);
+        const repoRelativePath = path.relative(STAGING_DIR, getStagedPath(file, machine)) + pathSuffix;
+        const remoteBlobHash = remoteBlobHashes.get(repoRelativePath);
         if (!remoteBlobHash) {
             result.notBackedUp.push(file);
-            continue;
         }
-        try {
-            const blobContent = execFileSync("git", ["cat-file", "blob", remoteBlobHash], {
-                cwd: STAGING_DIR,
-                maxBuffer: 50 * 1024 * 1024,
-            });
-            const decrypted = decrypt(blobContent, derivedKey);
-            const localContent = fs.readFileSync(file);
-            if (decrypted.equals(localContent)) {
-                result.backedUp.push(file);
-            }
-            else {
-                result.modified.push(file);
-            }
+        else if (matchesRemote(file, remoteBlobHash)) {
+            result.backedUp.push(file);
         }
-        catch {
+        else {
             result.modified.push(file);
         }
     }

package/dist/utils.d.ts

@@ -1,3 +1,11 @@
 export declare function errorMessage(err: unknown): string;
+/**
+ * Extracts the repo path (e.g. "user/repo") from an SSH or HTTPS URL
+ * for known hosts. Returns `null` for unrecognized hosts.
+ */
+export declare function extractRepoPath(url: string): {
+    host: string;
+    repoPath: string;
+} | null;
 export declare function uniq<T>(items: T[]): T[];
 export declare function pluralize(count: number, word: string): string;

package/dist/utils.js

@@ -1,6 +1,26 @@
 export function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
+const KNOWN_HOSTS = ["github.com", "gitlab.com", "bitbucket.org"];
+/**
+ * Extracts the repo path (e.g. "user/repo") from an SSH or HTTPS URL
+ * for known hosts. Returns `null` for unrecognized hosts.
+ */
+export function extractRepoPath(url) {
+    for (const host of KNOWN_HOSTS) {
+        const idx = url.indexOf(host);
+        if (idx === -1) {
+            continue;
+        }
+        const separatorLength = 1; // skip ":" (SSH) or "/" (HTTPS) after hostname
+        let repoPath = url.slice(idx + host.length + separatorLength).trim();
+        if (repoPath.endsWith(".git")) {
+            repoPath = repoPath.slice(0, -4);
+        }
+        return { host, repoPath };
+    }
+    return null;
+}
 export function uniq(items) {
     return [...new Set(items)];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -26,18 +26,18 @@
   "scripts": {
     "build": "tsc",
     "build:watch": "tsc --watch",
-    "release": "./scripts/release.sh",
-    "start": "node dist/cli.js",
+    "fmt": "prettier --write src/",
+    "fmt:check": "prettier --check src/",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
-    "format": "prettier --write src/",
-    "format:check": "prettier --check src/",
+    "prepare": "husky",
+    "release": "./scripts/release.sh",
+    "start": "node dist/cli.js",
     "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"
+    "test:e2e": "npm run build && vitest run src/e2e.test.ts",
+    "test:integration": "vitest run src/git.integration.test.ts",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",