backdot 1.8.0 → 1.8.2

package/dist/launchd.js

@@ -5,8 +5,9 @@ import os from "node:os";
 import ora from "ora";
 import { logger } from "./log.js";
 import { errorMessage } from "./utils.js";
-function escapeXml(s) {
-    return s
+import { LOG_DIR, LAUNCHD_LOG_PATH } from "./paths.js";
+function escapeXml(text) {
+    return text
         .replace(/&/g, "&")
         .replace(/</g, "&lt;")
         .replace(/>/g, "&gt;")
@@ -22,7 +23,6 @@ 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">
@@ -45,9 +45,9 @@ function buildPlist() {
     <integer>0</integer>
   </dict>
   <key>StandardOutPath</key>
-  <string>${escapeXml(logPath)}</string>
+  <string>${escapeXml(LAUNCHD_LOG_PATH)}</string>
   <key>StandardErrorPath</key>
-  <string>${escapeXml(logPath)}</string>
+  <string>${escapeXml(LAUNCHD_LOG_PATH)}</string>
   <key>RunAtLoad</key>
   <false/>
 </dict>
@@ -72,9 +72,8 @@ export function setupLaunchd() {
     const spinner = ora("Installing schedule").start();
     const plistContent = buildPlist();
     const launchAgentsDir = path.dirname(PLIST_PATH);
-    if (!fs.existsSync(launchAgentsDir)) {
-        fs.mkdirSync(launchAgentsDir, { recursive: true });
-    }
+    fs.mkdirSync(launchAgentsDir, { recursive: true });
+    fs.mkdirSync(LOG_DIR, { recursive: true });
     try {
         execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
     }

package/dist/log.js

@@ -1,9 +1,6 @@
 import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
 import winston from "winston";
-const LOG_DIR = path.join(os.homedir(), ".backdot");
-const LOG_FILE = path.join(LOG_DIR, "backup.log");
+import { LOG_DIR, CLI_LOG_PATH } from "./paths.js";
 let _logger;
 function getLogger() {
     if (!_logger) {
@@ -11,7 +8,7 @@ function getLogger() {
         _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 })],
+            transports: [new winston.transports.File({ filename: CLI_LOG_PATH })],
         });
     }
     return _logger;

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/paths.d.ts

@@ -1,3 +1,9 @@
+export declare const CONFIG_PATH: string;
+export declare const KEY_FILE_PATH: string;
+export declare const POST_RESTORE_HOOK_PATH: string;
 export declare const STAGING_DIR: string;
 export declare const STAGING_GIT_DIR: string;
+export declare const LOG_DIR: string;
+export declare const CLI_LOG_PATH: string;
+export declare const LAUNCHD_LOG_PATH: string;
 export declare function machineDir(machine: string): string;

package/dist/paths.js

@@ -1,8 +1,15 @@
 import path from "node:path";
 import os from "node:os";
 const HOME = os.homedir();
-export const STAGING_DIR = path.join(HOME, ".backdot", "repo");
+const BACKDOT_DIR = path.join(HOME, ".backdot");
+export const CONFIG_PATH = path.join(BACKDOT_DIR, "config.json");
+export const KEY_FILE_PATH = path.join(BACKDOT_DIR, "encryption.key");
+export const POST_RESTORE_HOOK_PATH = path.join(BACKDOT_DIR, "post-restore");
+export const STAGING_DIR = path.join(BACKDOT_DIR, "repo");
 export const STAGING_GIT_DIR = path.join(STAGING_DIR, ".git");
+export const LOG_DIR = path.join(BACKDOT_DIR, "logs");
+export const CLI_LOG_PATH = path.join(LOG_DIR, "cli.log");
+export const LAUNCHD_LOG_PATH = path.join(LOG_DIR, "launchd.log");
 export function machineDir(machine) {
     return path.join(STAGING_DIR, machine);
 }

package/dist/postRestoreHook.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs the restored `~/.backdot/post-restore` script (a POSIX `sh` script) so a
+ * restored machine can provision itself. The caller decides when to invoke this
+ * (only when the hook was actually among the restored files). A non-zero exit is
+ * surfaced as an error — never swallowed — but files have already been restored.
+ */
+export declare function runPostRestoreHook(): void;

package/dist/postRestoreHook.js

@@ -0,0 +1,35 @@
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import { logger } from "./log.js";
+import { errorMessage } from "./utils.js";
+import { POST_RESTORE_HOOK_PATH } from "./paths.js";
+/**
+ * Runs the restored `~/.backdot/post-restore` script (a POSIX `sh` script) so a
+ * restored machine can provision itself. The caller decides when to invoke this
+ * (only when the hook was actually among the restored files). A non-zero exit is
+ * surfaced as an error — never swallowed — but files have already been restored.
+ */
+export function runPostRestoreHook() {
+    if (process.platform === "win32") {
+        console.log("  Post-restore hook found, but hooks are not supported on Windows. Skipping.\n");
+        logger.warn("Post-restore hook skipped (not supported on Windows)");
+        return;
+    }
+    console.log(`  Running post-restore hook (${POST_RESTORE_HOOK_PATH})…\n`);
+    logger.info("Running post-restore hook");
+    try {
+        execFileSync("/bin/sh", [POST_RESTORE_HOOK_PATH], {
+            cwd: os.homedir(),
+            stdio: "inherit",
+        });
+    }
+    catch (err) {
+        logger.error(`Post-restore hook failed: ${errorMessage(err)}`);
+        const exitCode = err.status;
+        const exitNote = typeof exitCode === "number" ? ` (exit code ${exitCode})` : "";
+        throw new Error(`Files were restored, but the post-restore hook failed${exitNote}.\n` +
+            `  Fix ${POST_RESTORE_HOOK_PATH} and re-run, or run it manually.`, { cause: err });
+    }
+    console.log();
+    logger.info("Post-restore hook completed");
+}

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
@@ -43,7 +36,12 @@ function execGitLsRemote(url) {
     return new Promise((resolve, reject) => {
         const child = execFile("git", ["-c", "credential.helper=", "ls-remote", "--quiet", url], {
             timeout: 10_000,
-            env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: "0",
+                GIT_ASKPASS: undefined,
+                SSH_ASKPASS: undefined,
+            },
         }, (error) => {
             if (error) {
                 reject(error);

package/dist/staging.d.ts

@@ -1,19 +1,33 @@
 import { STAGING_DIR, STAGING_GIT_DIR, machineDir } from "./paths.js";
 import { type DerivedKey } from "./crypto/encryption.js";
 export { STAGING_DIR, STAGING_GIT_DIR, machineDir };
+export declare const HOME_NAMESPACE = "home";
+export declare const ROOT_NAMESPACE = "root";
 export declare function getStagedPath(filePath: string, machine: string): string;
+export interface RestoreTarget {
+    /** Absolute path the file is restored to on this machine. */
+    destination: string;
+    /** Path shown in the restore picker (e.g. "~/.zshrc" or "/etc/hosts"). */
+    displayPath: string;
+}
+/**
+ * Inverse of getStagedPath: maps a path relative to the machine dir
+ * (e.g. "home/.zshrc" or "root/etc/hosts") back to its restore destination.
+ */
+export declare function getRestoreTarget(machineRelativePath: string): RestoreTarget;
 export declare function cleanStaging(machine: string): void;
 export declare function copyToStaging(files: string[], machine: string, derivedKey?: DerivedKey): void;
 export interface ComparisonResult {
     backedUp: string[];
     modified: string[];
     notBackedUp: string[];
+    remoteIsEmpty?: boolean;
     error?: string;
 }
 export declare function compareFiles(opts: {
     files: string[];
     machine: string;
     repository: string;
-    derivedKey?: DerivedKey;
+    resolveKey?: () => Promise<DerivedKey>;
 }): Promise<ComparisonResult>;
 export declare function writeRepoReadme(repository: string, encrypted?: boolean): void;

package/dist/staging.js

@@ -11,20 +11,44 @@ import { encrypt, decrypt } from "./crypto/encryption.js";
 import { KEY_FILE_PATH, ENC_SUFFIX } from "./crypto/password.js";
 export { STAGING_DIR, STAGING_GIT_DIR, machineDir };
 const HOME = os.homedir();
+// Backed-up files live under one of two namespaces inside the machine dir, which
+// keeps the layout lossless: HOME files restore relative to the restoring machine's
+// own home (portable across machines), while files elsewhere restore to their
+// original absolute path.
+export const HOME_NAMESPACE = "home";
+export const ROOT_NAMESPACE = "root";
+function isOutsideHome(filePath) {
+    const relativeToHome = path.relative(HOME, filePath);
+    return relativeToHome.startsWith("..") || path.isAbsolute(relativeToHome);
+}
 export function getStagedPath(filePath, machine) {
-    const relativePath = path.relative(HOME, filePath);
-    // Files outside HOME (e.g. /etc/foo) produce a relative path starting with "..",
-    // which would escape the machine dir. Use the absolute path minus the leading "/" instead.
-    const pathWithinMachineDir = relativePath.startsWith("..") ? filePath.slice(1) : relativePath;
+    const pathWithinMachineDir = isOutsideHome(filePath)
+        ? path.join(ROOT_NAMESPACE, filePath.slice(1)) // strip leading "/" so it stays inside the machine dir
+        : path.join(HOME_NAMESPACE, path.relative(HOME, filePath));
     return path.join(machineDir(machine), pathWithinMachineDir);
 }
+/**
+ * Inverse of getStagedPath: maps a path relative to the machine dir
+ * (e.g. "home/.zshrc" or "root/etc/hosts") back to its restore destination.
+ */
+export function getRestoreTarget(machineRelativePath) {
+    const [namespace, ...rest] = machineRelativePath.split(path.sep);
+    const subPath = rest.join(path.sep);
+    if (namespace === ROOT_NAMESPACE) {
+        const destination = path.join("/", subPath);
+        return { destination, displayPath: destination };
+    }
+    return { destination: path.join(HOME, subPath), displayPath: path.join("~", subPath) };
+}
 export function cleanStaging(machine) {
-    const machineStagingDir = machineDir(machine);
-    if (!fs.existsSync(machineStagingDir)) {
-        return;
+    // Remove only the backdot-managed namespaces so user-authored files in the
+    // machine dir (e.g. a hand-written README.md with restore notes) survive
+    // across backups. home/ and root/ are still fully rebuilt, so a backup
+    // remains a complete snapshot of the configured files.
+    for (const namespace of [HOME_NAMESPACE, ROOT_NAMESPACE]) {
+        fs.rmSync(path.join(machineDir(machine), namespace), { recursive: true, force: true });
     }
-    fs.rmSync(machineStagingDir, { recursive: true, force: true });
-    logger.info(`Cleaned staging directory for machine "${machine}"`);
+    logger.info(`Cleaned staging namespaces for machine "${machine}"`);
 }
 export function copyToStaging(files, machine, derivedKey) {
     const machineStagingDir = machineDir(machine);
@@ -54,13 +78,18 @@ export function copyToStaging(files, machine, derivedKey) {
 function failedComparisonResult(err) {
     return { backedUp: [], modified: [], notBackedUp: [], error: errorMessage(err) };
 }
+// This machine has no snapshot in the remote yet, so every file counts as "not
+// backed up". Lets `status` preview what a first backup would push instead of erroring.
+function emptyRemoteResult(files) {
+    return { backedUp: [], modified: [], notBackedUp: files, remoteIsEmpty: true };
+}
 export async function compareFiles(opts) {
-    const { files, machine, repository, derivedKey } = opts;
+    const { files, machine, repository, resolveKey } = opts;
     if (files.length === 0) {
         return { backedUp: [], modified: [], notBackedUp: [] };
     }
     if (!fs.existsSync(STAGING_GIT_DIR)) {
-        return failedComparisonResult(new Error('Backup repository not found. Run "backdot backup" first.'));
+        return emptyRemoteResult(files);
     }
     const git = simpleGit(STAGING_DIR);
     try {
@@ -92,8 +121,27 @@ export async function compareFiles(opts) {
     catch (err) {
         return failedComparisonResult(err);
     }
-    if (derivedKey) {
-        return compareFilesEncrypted(files, machine, remoteBlobHashes, derivedKey);
+    // Repo reachable but this machine has nothing backed up yet (empty repo, or it
+    // only holds other machines). Treat as a pre-backup preview.
+    if (remoteBlobHashes.size === 0) {
+        return emptyRemoteResult(files);
+    }
+    if (resolveKey) {
+        const derivedKey = await resolveKey();
+        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 +154,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);
         }
     }
@@ -161,9 +187,11 @@ ${encryptionNote}
 ## Restore
 
 \`\`\`bash
-npx backdot restore ${repository}
+npx backdot restore ${repository} --machine <machine>
 \`\`\`
 
+Each machine is a top-level directory here; replace \`<machine>\` with the one you want to restore. A machine may also contain its own \`README.md\` with extra, machine-specific restore steps — backdot preserves it across backups.
+
 For full documentation, configuration options, and scheduling, see the [official README](https://github.com/sorenlouv/backdot).
 `;
 }

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.2",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -26,42 +26,42 @@
   "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": "cd .. && husky",
+    "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",
+    "@inquirer/prompts": "^8.5.2",
     "cac": "^7.0.0",
     "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
-    "ora": "^9.3.0",
-    "p-retry": "^7.1.1",
-    "simple-git": "^3.32.2",
+    "ora": "^9.4.0",
+    "p-retry": "^8.0.0",
+    "simple-git": "^3.36.0",
     "winston": "^3.19.0",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=24"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^22.13.5",
-    "eslint": "^10.0.2",
+    "@types/node": "^25.9.3",
+    "esbuild": "^0.28.1",
+    "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
     "husky": "^9.1.7",
-    "prettier": "^3.8.1",
-    "typescript": "^5.7.3",
-    "typescript-eslint": "^8.56.1",
-    "vitest": "^4.0.18"
+    "prettier": "^3.8.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.61.0",
+    "vitest": "^4.1.8"
   }
 }

package/README.md

@@ -1,82 +0,0 @@
-<p align="center">
-  <img src="logo-small.png" alt="backdot" width="400" />
-</p>
-
-<h1 align="center">backdot</h1>
-
-<p align="center">Automated backup of important files (configs, dotfiles) to your own private Git repo.</p>
-
-## Getting started
-
-```bash
-npm install -g backdot
-backdot init
-```
-
-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/backdot-backup.git",
-  "machine": "my-work-laptop",
-  "paths": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config", "~/.npmrc"]
-}
-```
-
-Run your first backup:
-
-```bash
-backdot backup
-```
-
-or configure the backport process to run automatically (daily at 2am)
-
-```bash
-backdot schedule
-```
-
-## Configuration
-
-| Key     | Description                                            |
-| ------- | ------------------------------------------------------ |
-| `paths` | Glob patterns matching individual files or directories |
-
-Prefix a pattern with `!` to exclude matching files:
-
-```json
-{
-  "paths": ["~/.config/ghostty/**", "!~/.config/ghostty/crash-reports/**"]
-}
-```
-
-## Encryption
-
-To encrypt files before they are pushed to the remote repo, add `"encrypt": true` to your config.
-
-On first backup you'll be prompted for a password and offered to save it to `~/.backdot.key` so that future backups do not prompt for a password.
-
-## Commands
-
-| Command                        | Description                                    |
-| ------------------------------ | ---------------------------------------------- |
-| `init`                         | Set up backdot for the first time              |
-| `backup`                       | Run a backup now                               |
-| `restore`                      | Restore latest backup from the configured repo |
-| `restore <url>`                | Restore from a specific repo URL               |
-| `restore [url] --commit <sha>` | Restore from a specific backup commit          |
-| `history [url]`                | Browse and restore a previous backup           |
-| `schedule`                     | Schedule automatic daily backup (Mac-only)     |
-| `unschedule`                   | Unschedule the daily backup                    |
-| `status`                       | Show schedule and resolved file list           |
-
-## Development
-
-```bash
-npm install
-npm run build
-npm start
-```
-
-## License
-
-MIT

package/dist/crypto.d.ts

@@ -1,13 +0,0 @@
-export declare const KEY_FILE_PATH: string;
-export declare const ENC_SUFFIX = ".encrypted";
-export declare function encryptBuffer(plaintext: Buffer, password: string): Buffer;
-export declare function decryptBuffer(data: Buffer, password: string): Buffer;
-export declare function checkKeyFilePermissions(): void;
-export declare function saveKeyFile(password: string): void;
-export interface PasswordResult {
-    password: string;
-    interactive: boolean;
-}
-export declare function resolvePassword(): Promise<PasswordResult>;
-export declare function confirmPassword(password: string): Promise<void>;
-export declare function offerToSaveKeyFile(password: string): Promise<void>;