clawon 0.1.18 → 0.1.19

package/README.md

@@ -24,13 +24,15 @@ npx clawon local backup --tag "before migration"
 npx clawon local backup --include-memory-db  # Include SQLite memory index
 npx clawon local backup --include-sessions   # Include chat history
 npx clawon local backup --include-secrets    # Include credentials and auth files
+npx clawon local backup --encrypt            # Encrypt with AES-256-GCM
+npx clawon local backup --include-secrets --encrypt  # Encrypted with secrets
 npx clawon local backup --no-secret-scan     # Skip secret scanning
 npx clawon local backup --max-snapshots 10   # Keep only 10 most recent
 
 # List all local backups
 npx clawon local list
 
-# Restore
+# Restore (detects encryption automatically)
 npx clawon local restore                # Latest backup
 npx clawon local restore --pick 2       # Backup #2 from list
 npx clawon local restore --file path.tar.gz  # External file
@@ -47,12 +49,15 @@ npx clawon local schedule on --every 6h --max-snapshots 10
 npx clawon local schedule on --include-memory-db
 npx clawon local schedule on --include-sessions
 npx clawon local schedule on --include-secrets
+npx clawon local schedule on --encrypt       # Requires CLAWON_ENCRYPT_PASSPHRASE env var
 
 # Disable local schedule
 npx clawon local schedule off
 
 # Schedule cloud backups (requires Hobby or Pro account)
 npx clawon schedule on
+npx clawon schedule on --encrypt             # Encrypted cloud backups
+npx clawon schedule on --encrypt --include-secrets  # With secrets
 npx clawon schedule off
 
 # Check schedule status
@@ -96,11 +101,13 @@ npx clawon backup --dry-run             # Preview without uploading
 npx clawon backup --include-memory-db   # Requires Hobby or Pro
 npx clawon backup --include-sessions    # Requires Hobby or Pro
 npx clawon backup --no-secret-scan      # Skip secret scanning
+npx clawon backup --encrypt             # Encrypt before uploading
+npx clawon backup --include-secrets --encrypt  # Secrets + encryption
 
 # List cloud backups
 npx clawon list
 
-# Restore from cloud
+# Restore from cloud (decrypts automatically if encrypted)
 npx clawon restore
 npx clawon restore --snapshot <id>      # Specific snapshot
 npx clawon restore --dry-run            # Preview without extracting
@@ -160,7 +167,7 @@ These are **always excluded**, even if they match an include pattern:
 | `*.lock`, `*.wal`, `*.shm` | Database lock files |
 | `node_modules/**` | Dependencies |
 
-**Credentials are excluded by default.** The `credentials/` directory, `openclaw.json`, and agent auth files are excluded unless you use `--include-secrets` (local backups only). You can verify what gets included by running `npx clawon discover` (or `npx clawon discover --include-secrets`) before any backup.
+**Credentials are excluded by default.** The `credentials/` directory, `openclaw.json`, and agent auth files are excluded unless you use `--include-secrets`. For local backups, `--include-secrets` works standalone. For cloud backups, it requires `--encrypt`. Verify what gets included by running `npx clawon discover --include-secrets`.
 
 ## Secret Scanning
 
@@ -181,9 +188,42 @@ npx clawon local backup --no-secret-scan  # Disable scanning for a backup
 npx clawon backup --no-secret-scan        # Same for cloud backups
 ```
 
+## Encryption
+
+The `--encrypt` flag encrypts backups with **AES-256-GCM** using a passphrase you provide. Available for both local and cloud backups.
+
+```bash
+# Local encrypted backup
+npx clawon local backup --encrypt
+
+# Cloud encrypted backup
+npx clawon backup --encrypt
+
+# Cloud backup with secrets (requires --encrypt)
+npx clawon backup --include-secrets --encrypt
+
+# Scheduled encrypted backups (requires env var)
+export CLAWON_ENCRYPT_PASSPHRASE=your-passphrase
+npx clawon local schedule on --encrypt
+npx clawon schedule on --encrypt
+```
+
+**Key derivation:** PBKDF2 with 100,000 iterations, SHA-512, 16-byte random salt → 256-bit key.
+
+**Local format:** encrypted archives use `.tar.gz.enc` extension with a binary header:
+```
+[4B "CLWN"][1B version=1][16B salt][12B IV][...ciphertext...][16B authTag]
+```
+
+**Cloud format:** each file is encrypted individually before upload. Salt is stored in the manifest, per-file IVs are recorded at confirm time.
+
+**Restore:** encryption is detected automatically — you'll be prompted for the passphrase.
+
+> **Warning:** there is no passphrase recovery. If you forget your passphrase, encrypted backups cannot be decrypted. Store your passphrase securely.
+
 ## Archive Format
 
-Local backups are standard gzip-compressed tar archives (`.tar.gz`). You can inspect and extract them with standard tools:
+Local backups are standard gzip-compressed tar archives (`.tar.gz`). Encrypted backups use `.tar.gz.enc`. You can inspect unencrypted archives with standard tools:
 
 ```bash
 # List contents
@@ -205,7 +245,7 @@ Each archive contains:
 | | Local | Cloud |
 |---|---|---|
 | **Location** | `~/.clawon/backups/` | Clawon servers (Supabase Storage) |
-| **Format** | `.tar.gz` | Individual files with signed URLs |
+| **Format** | `.tar.gz` (or `.tar.gz.enc` if encrypted) | Individual files with signed URLs |
 | **Limit** | Unlimited | 2 snapshots (Starter), more on paid plans |
 | **Account required** | No | Yes |
 | **Cross-machine** | No (manual file transfer) | Yes |

package/dist/index.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import fs2 from "fs";
 import path2 from "path";
 import os from "os";
-import readline from "readline";
+import readline2 from "readline";
 import { execSync } from "child_process";
 import * as tar from "tar";
 
@@ -4647,6 +4647,126 @@ function formatFindings(findings) {
   return lines.join("\n");
 }
 
+// src/crypto.ts
+import crypto from "crypto";
+import readline from "readline";
+var ENC_HEADER = Buffer.from("CLWN");
+var ENC_VERSION = 1;
+var PBKDF2_ITERATIONS = 1e5;
+var PBKDF2_DIGEST = "sha512";
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+var KEY_LENGTH = 32;
+var AUTH_TAG_LENGTH = 16;
+function deriveKey(passphrase, salt) {
+  return crypto.pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+}
+function encryptBuffer(plaintext, key) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return { ciphertext: encrypted, iv, authTag };
+}
+function decryptBuffer(ciphertext, key, iv, authTag) {
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function encryptFile(plaintext, passphrase) {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const { ciphertext, iv, authTag } = encryptBuffer(plaintext, key);
+  const header = Buffer.alloc(5);
+  ENC_HEADER.copy(header, 0);
+  header.writeUInt8(ENC_VERSION, 4);
+  const encrypted = Buffer.concat([header, salt, iv, ciphertext, authTag]);
+  return { encrypted, salt };
+}
+function decryptFile(encrypted, passphrase) {
+  if (encrypted.length < 5 + SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH) {
+    throw new Error("Invalid encrypted file: too short");
+  }
+  const magic = encrypted.subarray(0, 4);
+  if (!magic.equals(ENC_HEADER)) {
+    throw new Error("Invalid encrypted file: bad magic header");
+  }
+  const version = encrypted.readUInt8(4);
+  if (version !== ENC_VERSION) {
+    throw new Error(`Unsupported encryption version: ${version}`);
+  }
+  let offset = 5;
+  const salt = encrypted.subarray(offset, offset + SALT_LENGTH);
+  offset += SALT_LENGTH;
+  const iv = encrypted.subarray(offset, offset + IV_LENGTH);
+  offset += IV_LENGTH;
+  const authTag = encrypted.subarray(encrypted.length - AUTH_TAG_LENGTH);
+  const ciphertext = encrypted.subarray(offset, encrypted.length - AUTH_TAG_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  try {
+    return decryptBuffer(ciphertext, key, iv, authTag);
+  } catch {
+    throw new Error("Decryption failed \u2014 wrong passphrase?");
+  }
+}
+function encryptCloudFile(plaintext, key) {
+  const { ciphertext, iv, authTag } = encryptBuffer(plaintext, key);
+  return {
+    encrypted: Buffer.concat([ciphertext, authTag]),
+    iv: iv.toString("hex")
+  };
+}
+function decryptCloudFile(encrypted, key, ivHex) {
+  const iv = Buffer.from(ivHex, "hex");
+  const authTag = encrypted.subarray(encrypted.length - AUTH_TAG_LENGTH);
+  const ciphertext = encrypted.subarray(0, encrypted.length - AUTH_TAG_LENGTH);
+  try {
+    return decryptBuffer(ciphertext, key, iv, authTag);
+  } catch {
+    throw new Error("Decryption failed \u2014 wrong passphrase?");
+  }
+}
+function isEncryptedArchive(filePath) {
+  return filePath.endsWith(".tar.gz.enc");
+}
+async function getPassphrase(scheduled, action) {
+  const envPassphrase = process.env.CLAWON_ENCRYPT_PASSPHRASE;
+  if (scheduled) {
+    if (!envPassphrase) {
+      throw new Error("CLAWON_ENCRYPT_PASSPHRASE environment variable is required for scheduled encrypted backups.");
+    }
+    return envPassphrase;
+  }
+  if (envPassphrase) return envPassphrase;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const askHidden = (prompt) => {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        resolve(answer);
+      });
+    });
+  };
+  const passphrase = await askHidden(`Enter ${action === "encrypt" ? "encryption" : "decryption"} passphrase: `);
+  if (!passphrase) {
+    rl.close();
+    throw new Error("Passphrase cannot be empty.");
+  }
+  if (action === "encrypt") {
+    const confirm = await askHidden("Confirm passphrase: ");
+    rl.close();
+    if (passphrase !== confirm) {
+      throw new Error("Passphrases do not match.");
+    }
+  } else {
+    rl.close();
+  }
+  return passphrase;
+}
+function generateSalt() {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  return { salt, saltHex: salt.toString("hex") };
+}
+
 // src/index.ts
 var CONFIG_DIR = path2.join(os.homedir(), ".clawon");
 var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
@@ -4775,7 +4895,7 @@ function discoverFiles(baseDir, includeMemoryDb = false, includeSessions = false
   walk(baseDir);
   return files;
 }
-async function createLocalArchive(files, openclawDir, outputPath, tag, includeMemoryDb, includeSessions, includeSecrets, trigger) {
+async function createLocalArchive(files, openclawDir, outputPath, tag, includeMemoryDb, includeSessions, includeSecrets, trigger, encrypted) {
   const meta = {
     version: 2,
     created: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4784,6 +4904,7 @@ async function createLocalArchive(files, openclawDir, outputPath, tag, includeMe
     ...includeMemoryDb ? { include_memory_db: true } : {},
     ...includeSessions ? { include_sessions: true } : {},
     ...includeSecrets ? { include_secrets: true } : {},
+    ...encrypted ? { encrypted: true } : {},
     ...trigger ? { trigger } : {}
   };
   const metaPath = path2.join(openclawDir, "_clawon_meta.json");
@@ -4845,7 +4966,7 @@ async function promptSecretAction(findings) {
   console.log(`  [a] Abort backup`);
   console.log(`  [i] Ignore warnings and backup all files`);
   console.log("");
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question("  Choice (s/a/i): ", (answer) => {
       rl.close();
@@ -4953,9 +5074,11 @@ program.command("login").description("Connect to Clawon with your API key").opti
     process.exit(1);
   }
 });
-program.command("backup").description("Backup your OpenClaw workspace to the cloud").option("--dry-run", "Show what would be backed up without uploading").option("--tag <label>", "Add a label to this backup").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").option("--scheduled", "Internal: triggered by cron (suppresses interactive output)").option("--no-secret-scan", "Skip secret scanning before backup").action(async (opts) => {
-  if (opts.includeSecrets) {
-    console.error("--include-secrets is not supported for cloud backups yet. Use local backups, or wait for --encrypt support.");
+program.command("backup").description("Backup your OpenClaw workspace to the cloud").option("--dry-run", "Show what would be backed up without uploading").option("--tag <label>", "Add a label to this backup").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").option("--encrypt", "Encrypt files with AES-256-GCM before uploading").option("--scheduled", "Internal: triggered by cron (suppresses interactive output)").option("--no-secret-scan", "Skip secret scanning before backup").action(async (opts) => {
+  if (opts.includeSecrets && !opts.encrypt) {
+    console.error("\u2717 --include-secrets requires --encrypt for cloud backups.");
+    console.error("  Use: clawon backup --include-secrets --encrypt");
+    console.error("  Or use local backups: clawon local backup --include-secrets");
     process.exit(1);
   }
   const cfg = readConfig();
@@ -4973,7 +5096,7 @@ program.command("backup").description("Backup your OpenClaw workspace to the clo
     process.exit(1);
   }
   console.log("Discovering files...");
-  let files = discoverFiles(OPENCLAW_DIR, !!opts.includeMemoryDb, !!opts.includeSessions);
+  let files = discoverFiles(OPENCLAW_DIR, !!opts.includeMemoryDb, !!opts.includeSessions, !!(opts.includeSecrets && opts.encrypt));
   if (files.length === 0) {
     console.error("\u2717 No files found to backup");
     process.exit(1);
@@ -5026,6 +5149,15 @@ program.command("backup").description("Backup your OpenClaw workspace to the clo
     return;
   }
   try {
+    let encryptionKey = null;
+    let encryptionSaltHex = null;
+    if (opts.encrypt) {
+      const passphrase = await getPassphrase(!!opts.scheduled, "encrypt");
+      const { salt, saltHex } = generateSalt();
+      encryptionKey = deriveKey(passphrase, salt);
+      encryptionSaltHex = saltHex;
+      console.log("Encryption enabled (AES-256-GCM)");
+    }
     console.log("\nCreating backup...");
     const { snapshotId, uploadUrls } = await api(
       cfg.apiBaseUrl,
@@ -5036,14 +5168,21 @@ program.command("backup").description("Backup your OpenClaw workspace to the clo
         profileId: cfg.profileId,
         workspaceId: cfg.workspaceId,
         files: files.map((f) => ({ path: f.path, size: f.size })),
-        ...opts.tag ? { tag: opts.tag } : {}
+        ...opts.tag ? { tag: opts.tag } : {},
+        ...encryptionSaltHex ? { encryption: { method: "aes-256-gcm", salt: encryptionSaltHex } } : {}
       }
     );
     console.log(`Uploading ${files.length} files...`);
     let uploaded = 0;
+    const fileIvs = {};
     for (const file of files) {
       const fullPath = path2.join(OPENCLAW_DIR, file.path);
-      const content = fs2.readFileSync(fullPath);
+      let content = fs2.readFileSync(fullPath);
+      if (encryptionKey) {
+        const { encrypted, iv } = encryptCloudFile(content, encryptionKey);
+        content = encrypted;
+        fileIvs[file.path] = iv;
+      }
       const uploadRes = await fetch(uploadUrls[file.path], {
         method: "PUT",
         headers: { "content-type": "application/octet-stream" },
@@ -5059,17 +5198,21 @@ program.command("backup").description("Backup your OpenClaw workspace to the clo
     console.log("");
     await api(cfg.apiBaseUrl, "/api/v1/backups/confirm", "POST", cfg.apiKey, {
       snapshotId,
-      profileId: cfg.profileId
+      profileId: cfg.profileId,
+      ...Object.keys(fileIvs).length > 0 ? { fileIvs } : {}
     });
     console.log("\n\u2713 Backup complete!");
     console.log(`  Snapshot ID: ${snapshotId}`);
     console.log(`  Files: ${files.length}`);
     console.log(`  Size: ${(totalSize / 1024).toFixed(1)} KB`);
+    if (opts.encrypt) console.log(`  Encrypted: yes (AES-256-GCM)`);
     trackCliEvent(cfg.profileId, opts.scheduled ? "scheduled_backup_created" : "cloud_backup_created", {
       file_count: files.length,
       total_bytes: totalSize,
       include_memory_db: !!opts.includeMemoryDb,
       include_sessions: !!opts.includeSessions,
+      include_secrets: !!opts.includeSecrets,
+      encrypted: !!opts.encrypt,
       type: "cloud",
       workspace_slug: cfg.workspaceSlug,
       trigger: opts.scheduled ? "scheduled" : "manual",
@@ -5103,7 +5246,7 @@ program.command("restore").description("Restore your OpenClaw workspace from the
   }
   try {
     console.log("Fetching backup...");
-    const { snapshot, files, downloadUrls } = await api(
+    const { snapshot, files, downloadUrls, encryption } = await api(
       cfg.apiBaseUrl,
       "/api/v1/backups/download",
       "POST",
@@ -5117,11 +5260,19 @@ program.command("restore").description("Restore your OpenClaw workspace from the
     console.log(`Found backup from ${new Date(snapshot.created_at).toLocaleString()}`);
     console.log(`  Files: ${files.length}`);
     console.log(`  Size: ${(totalSize / 1024).toFixed(1)} KB`);
+    if (encryption) console.log(`  Encrypted: yes (${encryption.method})`);
     if (opts.dryRun) {
       console.log("\n[Dry run] Files that would be restored:");
       files.forEach((f) => console.log(`  ${f.path}`));
       return;
     }
+    let encryptionKey = null;
+    if (encryption) {
+      console.log("\nBackup is encrypted. Decrypting...");
+      const passphrase = await getPassphrase(false, "decrypt");
+      const salt = Buffer.from(encryption.salt, "hex");
+      encryptionKey = deriveKey(passphrase, salt);
+    }
     console.log("\nDownloading files...");
     let downloaded = 0;
     for (const file of files) {
@@ -5129,7 +5280,10 @@ program.command("restore").description("Restore your OpenClaw workspace from the
       if (!res.ok) {
         throw new Error(`Failed to download ${file.path}: ${res.status}`);
       }
-      const content = Buffer.from(await res.arrayBuffer());
+      let content = Buffer.from(await res.arrayBuffer());
+      if (encryptionKey && file.iv) {
+        content = decryptCloudFile(content, encryptionKey, file.iv);
+      }
       const targetPath = path2.join(OPENCLAW_DIR, file.path);
       ensureDir(path2.dirname(targetPath));
       fs2.writeFileSync(targetPath, content);
@@ -5334,7 +5488,7 @@ Total: ${files.length} files (${(totalSize / 1024).toFixed(1)} KB)`);
   trackCliEvent(cfg?.profileId || "anonymous", "cli_discover", { file_count: files.length, include_memory_db: !!opts.includeMemoryDb, include_sessions: !!opts.includeSessions, include_secrets: !!opts.includeSecrets });
 });
 var schedule = program.command("schedule").description("Manage scheduled cloud backups");
-schedule.command("on").description("Enable scheduled cloud backups via cron").option("--every <interval>", "Backup interval: 1h, 6h, 12h, 24h", "12h").action(async (opts) => {
+schedule.command("on").description("Enable scheduled cloud backups via cron").option("--every <interval>", "Backup interval: 1h, 6h, 12h, 24h", "12h").option("--encrypt", "Encrypt backups with AES-256-GCM").option("--include-secrets", "Include credentials and auth files (requires --encrypt)").action(async (opts) => {
   assertNotWindows();
   const cfg = readConfig();
   if (!cfg) {
@@ -5346,6 +5500,16 @@ schedule.command("on").description("Enable scheduled cloud backups via cron").op
     console.error(`\u2717 Invalid interval: ${interval}. Valid options: ${VALID_INTERVALS.join(", ")}`);
     process.exit(1);
   }
+  if (opts.includeSecrets && !opts.encrypt) {
+    console.error("\u2717 --include-secrets requires --encrypt for cloud backups.");
+    console.error("  Use: clawon schedule on --include-secrets --encrypt");
+    process.exit(1);
+  }
+  if (opts.encrypt && !process.env.CLAWON_ENCRYPT_PASSPHRASE) {
+    console.error("\u2717 --encrypt requires the CLAWON_ENCRYPT_PASSPHRASE environment variable for scheduled backups.");
+    console.error("  Set it in your shell profile (~/.bashrc, ~/.zshrc) so cron can access it.");
+    process.exit(1);
+  }
   try {
     const data = await api(
       cfg.apiBaseUrl || "https://clawon.io",
@@ -5365,22 +5529,29 @@ schedule.command("on").description("Enable scheduled cloud backups via cron").op
     process.exit(1);
   }
   const cronExpr = INTERVAL_CRON[interval];
-  const command = resolveCliCommand(`backup --scheduled`);
+  const scheduledArgs = "backup --scheduled" + (opts.encrypt ? " --encrypt" : "") + (opts.includeSecrets ? " --include-secrets" : "");
+  const command = resolveCliCommand(scheduledArgs);
   addCronEntry(CRON_MARKER_CLOUD, cronExpr, command);
   updateConfig({
     schedule: {
       cloud: {
         enabled: true,
-        intervalHours: parseInt(interval)
+        intervalHours: parseInt(interval),
+        ...opts.encrypt ? { encrypt: true } : {},
+        ...opts.includeSecrets ? { includeSecrets: true } : {}
       }
     }
   });
   console.log(`\u2713 Scheduled cloud backup enabled`);
   console.log(`  Interval: every ${interval}`);
+  if (opts.encrypt) console.log(`  Encryption: enabled (AES-256-GCM)`);
+  if (opts.includeSecrets) console.log(`  Secrets: included`);
   console.log(`  Log: ${SCHEDULE_LOG}`);
   trackCliEvent(cfg.profileId, "schedule_enabled", {
     type: "cloud",
-    interval_hours: parseInt(interval)
+    interval_hours: parseInt(interval),
+    encrypt: !!opts.encrypt,
+    include_secrets: !!opts.includeSecrets
   });
 });
 schedule.command("off").description("Disable scheduled cloud backups").action(async () => {
@@ -5411,6 +5582,8 @@ schedule.command("status").description("Show schedule status").action(async () =
     if (localCfg?.maxSnapshots) console.log(`  Max snapshots: ${localCfg.maxSnapshots}`);
     if (localCfg?.includeMemoryDb) console.log(`  Memory DB: included`);
     if (localCfg?.includeSessions) console.log(`  Sessions: included`);
+    if (localCfg?.includeSecrets) console.log(`  Secrets: included`);
+    if (localCfg?.encrypt) console.log(`  Encryption: enabled`);
     console.log(`  Cron: ${localEntry.trim()}`);
   } else {
     console.log("\u2717 Local schedule: inactive");
@@ -5421,6 +5594,8 @@ schedule.command("status").description("Show schedule status").action(async () =
     const cloudCfg = cfg?.schedule?.cloud;
     console.log("\u2713 Cloud schedule: active");
     if (cloudCfg?.intervalHours) console.log(`  Interval: every ${cloudCfg.intervalHours}h`);
+    if (cloudCfg?.encrypt) console.log(`  Encryption: enabled`);
+    if (cloudCfg?.includeSecrets) console.log(`  Secrets: included`);
     console.log(`  Cron: ${cloudEntry.trim()}`);
   } else {
     console.log("\u2717 Cloud schedule: inactive");
@@ -5478,17 +5653,22 @@ Total: ${files.length} files`);
 });
 var local = program.command("local").description("Local backup and restore (no cloud required)");
 var localSchedule = local.command("schedule").description("Manage scheduled local backups");
-localSchedule.command("on").description("Enable scheduled local backups via cron").option("--every <interval>", "Backup interval: 1h, 6h, 12h, 24h", "12h").option("--max-snapshots <n>", "Keep only the N most recent local backups").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").action(async (opts) => {
+localSchedule.command("on").description("Enable scheduled local backups via cron").option("--every <interval>", "Backup interval: 1h, 6h, 12h, 24h", "12h").option("--max-snapshots <n>", "Keep only the N most recent local backups").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").option("--encrypt", "Encrypt backups with AES-256-GCM").action(async (opts) => {
   assertNotWindows();
   const interval = opts.every;
   if (!VALID_INTERVALS.includes(interval)) {
     console.error(`\u2717 Invalid interval: ${interval}. Valid options: ${VALID_INTERVALS.join(", ")}`);
     process.exit(1);
   }
+  if (opts.encrypt && !process.env.CLAWON_ENCRYPT_PASSPHRASE) {
+    console.error("\u2717 --encrypt requires the CLAWON_ENCRYPT_PASSPHRASE environment variable for scheduled backups.");
+    console.error("  Set it in your shell profile (~/.bashrc, ~/.zshrc) so cron can access it.");
+    process.exit(1);
+  }
   const cfg = readConfig();
   const wasEnabled = cfg?.schedule?.local?.enabled;
   const cronExpr = INTERVAL_CRON[interval];
-  const args = "local backup --scheduled" + (opts.includeMemoryDb ? " --include-memory-db" : "") + (opts.includeSessions ? " --include-sessions" : "") + (opts.includeSecrets ? " --include-secrets" : "") + (opts.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
+  const args = "local backup --scheduled" + (opts.includeMemoryDb ? " --include-memory-db" : "") + (opts.includeSessions ? " --include-sessions" : "") + (opts.includeSecrets ? " --include-secrets" : "") + (opts.encrypt ? " --encrypt" : "") + (opts.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
   const command = resolveCliCommand(args);
   addCronEntry(CRON_MARKER_LOCAL, cronExpr, command);
   const maxSnapshots = opts.maxSnapshots ? parseInt(opts.maxSnapshots, 10) : null;
@@ -5500,7 +5680,8 @@ localSchedule.command("on").description("Enable scheduled local backups via cron
         ...maxSnapshots ? { maxSnapshots } : {},
         ...opts.includeMemoryDb ? { includeMemoryDb: true } : {},
         ...opts.includeSessions ? { includeSessions: true } : {},
-        ...opts.includeSecrets ? { includeSecrets: true } : {}
+        ...opts.includeSecrets ? { includeSecrets: true } : {},
+        ...opts.encrypt ? { encrypt: true } : {}
       }
     }
   });
@@ -5510,8 +5691,9 @@ localSchedule.command("on").description("Enable scheduled local backups via cron
   if (opts.includeMemoryDb) console.log(`  Memory DB: included`);
   if (opts.includeSessions) console.log(`  Sessions: included`);
   if (opts.includeSecrets) console.log(`  Secrets: included`);
+  if (opts.encrypt) console.log(`  Encryption: enabled (AES-256-GCM)`);
   console.log(`  Log: ${SCHEDULE_LOG}`);
-  const firstRunArgs = "local backup" + (opts.includeMemoryDb ? " --include-memory-db" : "") + (opts.includeSessions ? " --include-sessions" : "") + (opts.includeSecrets ? " --include-secrets" : "") + (opts.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
+  const firstRunArgs = "local backup" + (opts.includeMemoryDb ? " --include-memory-db" : "") + (opts.includeSessions ? " --include-sessions" : "") + (opts.includeSecrets ? " --include-secrets" : "") + (opts.encrypt ? " --encrypt" : "") + (opts.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
   console.log("\nRunning first backup now...\n");
   try {
     execSync(resolveCliCommand(firstRunArgs), { stdio: "inherit" });
@@ -5524,7 +5706,8 @@ localSchedule.command("on").description("Enable scheduled local backups via cron
     max_snapshots: maxSnapshots,
     include_memory_db: !!opts.includeMemoryDb,
     include_sessions: !!opts.includeSessions,
-    include_secrets: !!opts.includeSecrets
+    include_secrets: !!opts.includeSecrets,
+    encrypt: !!opts.encrypt
   });
 });
 localSchedule.command("off").description("Disable scheduled local backups").action(async () => {
@@ -5543,7 +5726,7 @@ localSchedule.command("off").description("Disable scheduled local backups").acti
   const cfg = readConfig();
   trackCliEvent(cfg?.profileId || "anonymous", "schedule_disabled", { type: "local" });
 });
-local.command("backup").description("Save a local backup of your OpenClaw workspace").option("--tag <label>", "Add a label to this backup").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").option("--scheduled", "Internal: triggered by cron (suppresses interactive output)").option("--no-secret-scan", "Skip secret scanning before backup").option("--max-snapshots <n>", "Keep only the N most recent local backups").action(async (opts) => {
+local.command("backup").description("Save a local backup of your OpenClaw workspace").option("--tag <label>", "Add a label to this backup").option("--include-memory-db", "Include SQLite memory index").option("--include-sessions", "Include chat history (sessions)").option("--include-secrets", "Include credentials and auth files in backup").option("--encrypt", "Encrypt the backup with AES-256-GCM").option("--scheduled", "Internal: triggered by cron (suppresses interactive output)").option("--no-secret-scan", "Skip secret scanning before backup").option("--max-snapshots <n>", "Keep only the N most recent local backups").action(async (opts) => {
   if (!fs2.existsSync(OPENCLAW_DIR)) {
     console.error(`\u2717 OpenClaw directory not found: ${OPENCLAW_DIR}`);
     process.exit(1);
@@ -5556,7 +5739,7 @@ local.command("backup").description("Save a local backup of your OpenClaw worksp
       process.exit(1);
     }
     if (opts.includeSecrets && !opts.scheduled) {
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
       const confirmed = await new Promise((resolve) => {
         rl.question("\u26A0  --include-secrets will back up API keys, tokens, and auth files. Continue? [y/N] ", (answer) => {
           rl.close();
@@ -5607,20 +5790,31 @@ local.command("backup").description("Save a local backup of your OpenClaw worksp
     const filename = `backup-${timestamp}.tar.gz`;
     const filePath = path2.join(BACKUPS_DIR, filename);
     if (!opts.scheduled) console.log("Creating archive...");
-    await createLocalArchive(files, OPENCLAW_DIR, filePath, opts.tag, opts.includeMemoryDb, opts.includeSessions, opts.includeSecrets, opts.scheduled ? "scheduled" : "manual");
-    const archiveSize = fs2.statSync(filePath).size;
+    await createLocalArchive(files, OPENCLAW_DIR, filePath, opts.tag, opts.includeMemoryDb, opts.includeSessions, opts.includeSecrets, opts.scheduled ? "scheduled" : "manual", opts.encrypt);
+    let finalPath = filePath;
+    if (opts.encrypt) {
+      const passphrase = await getPassphrase(!!opts.scheduled, "encrypt");
+      if (!opts.scheduled) console.log("Encrypting archive...");
+      const plaintext = fs2.readFileSync(filePath);
+      const { encrypted } = encryptFile(plaintext, passphrase);
+      finalPath = filePath + ".enc";
+      fs2.writeFileSync(finalPath, encrypted);
+      fs2.unlinkSync(filePath);
+    }
+    const archiveSize = fs2.statSync(finalPath).size;
     if (!opts.scheduled) {
       console.log(`
 \u2713 Local backup saved!`);
-      console.log(`  File: ${filePath}`);
+      console.log(`  File: ${finalPath}`);
       console.log(`  Files: ${files.length}`);
-      console.log(`  Size: ${(archiveSize / 1024).toFixed(1)} KB (compressed)`);
+      console.log(`  Size: ${(archiveSize / 1024).toFixed(1)} KB (compressed${opts.encrypt ? " + encrypted" : ""})`);
       if (opts.tag) console.log(`  Tag: ${opts.tag}`);
+      if (opts.encrypt) console.log(`  Encrypted: yes (AES-256-GCM)`);
     }
     const maxSnapshots = opts.maxSnapshots ? parseInt(opts.maxSnapshots, 10) : null;
     let rotatedCount = 0;
     if (maxSnapshots && maxSnapshots > 0) {
-      const allBackups = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz")).sort().reverse();
+      const allBackups = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".tar.gz.enc")).sort().reverse();
       if (allBackups.length > maxSnapshots) {
         const toDelete = allBackups.slice(maxSnapshots);
         for (const old of toDelete) {
@@ -5639,6 +5833,7 @@ local.command("backup").description("Save a local backup of your OpenClaw worksp
       include_memory_db: !!opts.includeMemoryDb,
       include_sessions: !!opts.includeSessions,
       include_secrets: !!opts.includeSecrets,
+      encrypted: !!opts.encrypt,
       type: "local",
       trigger: opts.scheduled ? "scheduled" : "manual",
       rotated_count: rotatedCount,
@@ -5662,7 +5857,7 @@ local.command("list").description("List local backups").action(async () => {
     console.log("No local backups yet. Run: clawon local backup");
     return;
   }
-  const entries = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz")).sort().reverse();
+  const entries = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".tar.gz.enc")).sort().reverse();
   if (entries.length === 0) {
     console.log("No local backups yet. Run: clawon local backup");
     return;
@@ -5672,17 +5867,26 @@ local.command("list").description("List local backups").action(async () => {
   console.log("\u2500".repeat(120));
   for (let i = 0; i < entries.length; i++) {
     const filePath = path2.join(BACKUPS_DIR, entries[i]);
-    try {
-      const meta = await readArchiveMeta(filePath);
-      const date = new Date(meta.created).toLocaleString();
+    const encrypted = isEncryptedArchive(filePath);
+    if (encrypted) {
       const archiveSize = fs2.statSync(filePath).size;
       const sizeStr = `${(archiveSize / 1024).toFixed(1)} KB`;
-      const tagStr = (meta.tag || "").padEnd(20);
       console.log(
-        `${String(i + 1).padStart(2)} | ${date.padEnd(25)} | ${String(meta.file_count).padEnd(5)} | ${sizeStr.padEnd(10)} | ${tagStr} | ${filePath}`
+        `${String(i + 1).padStart(2)} | [encrypted]               | ???   | ${sizeStr.padEnd(10)} | [encrypted]          | ${filePath}`
       );
-    } catch {
-      console.log(`${String(i + 1).padStart(2)} | ${entries[i].padEnd(25)} | ???   | ???        |                      | ${filePath}`);
+    } else {
+      try {
+        const meta = await readArchiveMeta(filePath);
+        const date = new Date(meta.created).toLocaleString();
+        const archiveSize = fs2.statSync(filePath).size;
+        const sizeStr = `${(archiveSize / 1024).toFixed(1)} KB`;
+        const tagStr = (meta.tag || "").padEnd(20);
+        console.log(
+          `${String(i + 1).padStart(2)} | ${date.padEnd(25)} | ${String(meta.file_count).padEnd(5)} | ${sizeStr.padEnd(10)} | ${tagStr} | ${filePath}`
+        );
+      } catch {
+        console.log(`${String(i + 1).padStart(2)} | ${entries[i].padEnd(25)} | ???   | ???        |                      | ${filePath}`);
+      }
     }
   }
   console.log(`
@@ -5708,7 +5912,7 @@ local.command("restore").description("Restore from a local backup").option("--fi
       console.error("\u2717 No local backups found. Run: clawon local backup");
       process.exit(1);
     }
-    const entries = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz")).sort().reverse();
+    const entries = fs2.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".tar.gz.enc")).sort().reverse();
     if (entries.length === 0) {
       console.error("\u2717 No local backups found. Run: clawon local backup");
       process.exit(1);
@@ -5725,13 +5929,24 @@ local.command("restore").description("Restore from a local backup").option("--fi
     }
   }
   console.log(`Restoring from: ${archivePath}`);
+  let actualArchivePath = archivePath;
+  const encrypted = isEncryptedArchive(archivePath);
+  const tempDecryptedPath = path2.join(path2.dirname(archivePath), ".restore-tmp.tar.gz");
   try {
-    const meta = await readArchiveMeta(archivePath);
+    if (encrypted) {
+      console.log("Archive is encrypted. Decrypting...");
+      const passphrase = await getPassphrase(false, "decrypt");
+      const encryptedData = fs2.readFileSync(archivePath);
+      const decrypted = decryptFile(encryptedData, passphrase);
+      fs2.writeFileSync(tempDecryptedPath, decrypted);
+      actualArchivePath = tempDecryptedPath;
+    }
+    const meta = await readArchiveMeta(actualArchivePath);
     console.log(`Backup date: ${new Date(meta.created).toLocaleString()}`);
     console.log(`Files: ${meta.file_count}`);
     if (meta.tag) console.log(`Tag: ${meta.tag}`);
     console.log("\nExtracting...");
-    await extractLocalArchive(archivePath, OPENCLAW_DIR);
+    await extractLocalArchive(actualArchivePath, OPENCLAW_DIR);
     console.log(`
 \u2713 Restore complete!`);
     console.log(`  Restored to: ${OPENCLAW_DIR}`);
@@ -5739,12 +5954,17 @@ local.command("restore").description("Restore from a local backup").option("--fi
     const cfg = readConfig();
     trackCliEvent(cfg?.profileId || "anonymous", "local_backup_restored", {
       file_count: meta.file_count,
-      source: opts.file ? "file" : "local"
+      source: opts.file ? "file" : "local",
+      encrypted
     });
   } catch (e) {
     console.error(`
 \u2717 Restore failed: ${e.message}`);
     process.exit(1);
+  } finally {
+    if (encrypted && fs2.existsSync(tempDecryptedPath)) {
+      fs2.unlinkSync(tempDecryptedPath);
+    }
   }
 });
 var workspaces = program.command("workspaces").description("Manage workspaces");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawon",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Backup and restore your OpenClaw workspace",
   "type": "module",
   "bin": {