backup-claw 1.0.1

package/README.md

@@ -0,0 +1,47 @@
+# BackupClaw 🦞
+
+**Privacy-first, zero-knowledge backup tool for OpenClaw bots.**
+
+BackupClaw allow you to securely encrypt and archive your OpenClaw bot's memory and configuration without the data ever leaving your machine (unless you explicitly push it to our encrypted cloud).
+
+[Visit BackupClaw.com](http://backupclaw.com) for more details.
+
+## Installation
+
+```bash
+npm install -g backup-claw
+```
+
+## Usage
+
+### 1. Local Backup
+Navigate to your OpenClaw bot directory and run:
+
+```bash
+backup-claw backup
+```
+
+You will be prompted to set a **password**.
+> **IMPORTANT:** We do not store this password. If you lose it, your backup is unrecoverable.
+
+### 2. Restore
+To restore a backup file:
+
+```bash
+backup-claw restore -f my-backup.enc -d /path/to/restore
+```
+
+### Automation (Bots)
+You can run BackupClaw non-interactively by setting the `BACKUP_PASSWORD` environment variable.
+
+```bash
+export BACKUP_PASSWORD="my-super-secret-password"
+backup-claw backup -d .openclaw
+```
+
+## Cloud Backup (Pro)
+Support for encrypted cloud storage is coming soon.
+Visit our [website](http://backupclaw.com) to upgrade.
+
+## License
+MIT

package/backup-claw.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const pipe = promisify(pipeline);
+
+const program = require('commander');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const tar = require('tar');
+
+const ALGORITHM = 'aes-256-ctr';
+const DEFAULT_DIR = path.join(os.homedir(), '.openclaw');
+
+console.log(chalk.red(`
+  ____  _            _				  ________
+ |  _ \\| |          | |				 /  ____| |
+ | |_) | | __ _  ___| | ___   _ _ __    |  |    | | __ ___      __
+ |  _ <| |/ _\` |/ __| |/ / | | | '_ \\   |  |    | |/ _\` \\ \\ /\\ / /
+ | |_) | | (_| | (__|   <| |_| | |_) |  |  |____| | (_| |\\ V  V / 
+ |____/|_|\\__,_|\\___|_|\\_\\\\__,_| .__/    \\______|_|\\__,_| \\_/\\_/  
+        						| |                               
+						        |_|                               
+`));
+console.log(chalk.gray('  Privacy-First Backup for OpenClaw Bots\n'));
+
+// --- Utils ---
+
+function deriveKey(password, salt) {
+    return crypto.scryptSync(password, salt, 32);
+}
+
+// --- Commands ---
+
+program
+    .version('1.0.0')
+    .description('Secure backup tool for OpenClaw');
+
+program
+    .command('backup')
+    .description('Encrypt and backup your OpenClaw bot')
+    .option('-d, --dir <path>', 'Path to .openclaw directory', DEFAULT_DIR)
+    .option('-o, --output <path>', 'Output file path', './backup-claw.enc')
+    .action(async (cmd) => {
+        try {
+            if (!fs.existsSync(cmd.dir)) {
+                console.error(chalk.red(`Error: Directory not found at ${cmd.dir}`));
+                process.exit(1);
+            }
+
+            let answers;
+            if (process.env.BACKUP_PASSWORD) {
+                console.log(chalk.yellow('Using password from environment variable BACKUP_PASSWORD'));
+                answers = {
+                    password: process.env.BACKUP_PASSWORD,
+                    confirm: process.env.BACKUP_PASSWORD
+                };
+            } else {
+                answers = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'password',
+                        message: 'Set a strong password for this backup:',
+                        mask: '*',
+                        validate: (input) => input.length > 0
+                    },
+                    {
+                        type: 'password',
+                        name: 'confirm',
+                        message: 'Confirm password:',
+                        mask: '*',
+                        validate: (input, answers) => input === answers.password || 'Passwords do not match'
+                    }
+                ]);
+            }
+
+            const spinner = ora('Preparing backup...').start();
+
+            const salt = crypto.randomBytes(16);
+            const iv = crypto.randomBytes(16);
+            const key = deriveKey(answers.password, salt);
+            const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+
+            const output = fs.createWriteStream(cmd.output);
+
+            // Header: Salt (16) + IV (16)
+            output.write(salt);
+            output.write(iv);
+
+            const sourceDir = path.dirname(cmd.dir);
+            const folderName = path.basename(cmd.dir);
+
+            spinner.text = 'Compressing and Encrypting...';
+
+            await pipe(
+                tar.c({
+                    gzip: true,
+                    cwd: sourceDir
+                }, [folderName]),
+                cipher,
+                output
+            );
+
+            spinner.succeed(chalk.green('Backup successful!'));
+            console.log(chalk.white(`\nFile saved to: ${chalk.bold(path.resolve(cmd.output))}`));
+            console.log(chalk.yellow(`IMPORTANT: Do not lose your password. We cannot recover it.`));
+
+            // Stub for analytics
+            // trackEvent('backup_success', { size: fs.statSync(cmd.output).size });
+
+        } catch (err) {
+            if (spinner) spinner.fail('Backup failed');
+            console.error(err);
+        }
+    });
+
+program
+    .command('restore')
+    .description('Restore from an encrypted backup')
+    .requiredOption('-f, --file <path>', 'Path to backup file')
+    .option('-d, --dest <path>', 'Restore destination directory', os.homedir())
+    .action(async (cmd) => {
+        let spinner;
+        try {
+            if (!fs.existsSync(cmd.file)) {
+                console.error(chalk.red(`Error: File not found at ${cmd.file}`));
+                process.exit(1);
+            }
+
+            let answers;
+            if (process.env.BACKUP_PASSWORD) {
+                console.log(chalk.yellow('Using password from environment variable BACKUP_PASSWORD'));
+                answers = { password: process.env.BACKUP_PASSWORD };
+            } else {
+                answers = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'password',
+                        message: 'Enter backup password:',
+                        mask: '*'
+                    }
+                ]);
+            }
+
+            spinner = ora('Reading backup file...').start();
+
+            // We need to read the header (salt+iv) first.
+            // Since we are streaming, we can't just slice the stream easily without packages.
+            // For MVP simplicity and robustness, using fs.readSync for header is safe 
+            // as long as we stream the rest.
+
+            const fd = fs.openSync(cmd.file, 'r');
+            const header = Buffer.alloc(32); // 16 salt + 16 iv
+            fs.readSync(fd, header, 0, 32, 0);
+            fs.closeSync(fd);
+
+            const salt = header.slice(0, 16);
+            const iv = header.slice(16, 32);
+
+            // Create read stream starting AFTER the header
+            const input = fs.createReadStream(cmd.file, { start: 32 });
+
+            spinner.text = 'Deriving key...';
+            const key = deriveKey(answers.password, salt);
+            const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+
+            spinner.text = 'Decrypting and Extracting...';
+
+            if (!fs.existsSync(cmd.dest)) {
+                fs.mkdirSync(cmd.dest, { recursive: true });
+            }
+
+            await pipe(
+                input,
+                decipher,
+                tar.x({
+                    cwd: cmd.dest
+                })
+            );
+
+            spinner.succeed(chalk.green('Restore successful!'));
+            console.log(chalk.white(`Files restored to: ${chalk.bold(cmd.dest)}`));
+
+        } catch (err) {
+            if (spinner) spinner.fail('Restore failed');
+            console.error(chalk.red('Error: ' + err.message));
+            if (err.message.includes('bad decrypt') || err.code === 'ERR_OSSL_EVP_BAD_DECRYPT') {
+                console.error(chalk.red('Most likely cause: Incorrect password.'));
+            }
+        }
+    });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "backup-claw",
+  "version": "1.0.1",
+  "description": "Secure, local backup tool for OpenClaw bots",
+  "main": "backup-claw.js",
+  "bin": {
+    "backup-claw": "./backup-claw.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "backup": "node backup-claw.js backup",
+    "restore": "node backup-claw.js restore"
+  },
+  "keywords": [
+    "backup",
+    "openclaw",
+    "security",
+    "cli"
+  ],
+  "author": "BackupClaw Team",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "tar": "^6.2.0"
+  }
+}