clawon 0.1.9 → 0.1.10

package/README.md

@@ -22,6 +22,7 @@ Local backups are stored in `~/.clawon/backups/` as standard `.tar.gz` archives.
 npx clawon local backup
 npx clawon local backup --tag "before migration"
 npx clawon local backup --include-memory-db  # Include SQLite memory index
+npx clawon local backup --max-snapshots 10   # Keep only 10 most recent
 
 # List all local backups
 npx clawon local list
@@ -32,6 +33,27 @@ npx clawon local restore --pick 2       # Backup #2 from list
 npx clawon local restore --file path.tar.gz  # External file
 ```
 
+### Scheduled Backups
+
+Set up automatic backups via cron (macOS/Linux only).
+
+```bash
+# Schedule local backups every 12 hours (default)
+npx clawon local schedule on
+npx clawon local schedule on --every 6h --max-snapshots 10
+npx clawon local schedule on --include-memory-db
+
+# Disable local schedule
+npx clawon local schedule off
+
+# Schedule cloud backups (requires Hobby or Pro account)
+npx clawon schedule on
+npx clawon schedule off
+
+# Check schedule status
+npx clawon schedule status
+```
+
 ### Cloud Backups (requires account)
 
 Cloud backups sync your workspace to Clawon's servers for cross-machine access.
@@ -66,6 +88,7 @@ npx clawon activity                     # Recent events
 ```bash
 npx clawon discover    # Show exactly which files would be backed up
 npx clawon discover --include-memory-db  # Include SQLite memory index
+npx clawon schedule status  # Show active schedules
 npx clawon status      # Connection status and file count
 npx clawon logout      # Remove local credentials
 ```
@@ -83,6 +106,9 @@ Clawon uses an **allowlist** — only files matching these patterns are included
 | `workspace/canvas/**` | Canvas data |
 | `skills/**` | Top-level skills |
 | `agents/*/config.json` | Agent configurations |
+| `agents/*/models.json` | Model preferences |
+| `agents/*/agent/**` | Agent config data |
+| `cron/runs/*.jsonl` | Cron run logs |
 
 Run `npx clawon discover` to see the exact file list for your instance.
 
@@ -94,7 +120,9 @@ These are **always excluded**, even if they match an include pattern:
 |---------|-----|
 | `credentials/**` | API keys, tokens, auth files |
 | `openclaw.json` | May contain credentials |
-| `agents/*/sessions/**` | Ephemeral session data |
+| `agents/*/auth.json` | Authentication data |
+| `agents/*/auth-profiles.json` | Auth profiles |
+| `agents/*/sessions/**` | Chat history (large, use future `--include-sessions`) |
 | `memory/lancedb/**` | Vector database (binary, large) |
 | `memory/*.sqlite` | SQLite databases (use `--include-memory-db` to include) |
 | `*.lock`, `*.wal`, `*.shm` | Database lock files |

package/dist/index.js

@@ -5,6 +5,7 @@ import { Command } from "commander";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { execSync } from "child_process";
 import * as tar from "tar";
 var CONFIG_DIR = path.join(os.homedir(), ".clawon");
 var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
@@ -21,6 +22,15 @@ function writeConfig(cfg) {
   ensureDir(CONFIG_DIR);
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
 }
+function updateConfig(partial) {
+  const existing = readConfig() || {};
+  const merged = { ...existing, ...partial };
+  if (partial.schedule) {
+    merged.schedule = { ...existing.schedule, ...partial.schedule };
+  }
+  ensureDir(CONFIG_DIR);
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
+}
 async function api(baseUrl, endpoint, method, apiKey, body) {
   const res = await fetch(`${baseUrl}${endpoint}`, {
     method,
@@ -41,11 +51,16 @@ var INCLUDE_PATTERNS = [
   "workspace/skills/**",
   "workspace/canvas/**",
   "skills/**",
-  "agents/*/config.json"
+  "agents/*/config.json",
+  "agents/*/models.json",
+  "agents/*/agent/**",
+  "cron/runs/*.jsonl"
 ];
 var EXCLUDE_PATTERNS = [
   "credentials/**",
   "openclaw.json",
+  "agents/*/auth.json",
+  "agents/*/auth-profiles.json",
   "agents/*/sessions/**",
   "memory/lancedb/**",
   "memory/*.sqlite",
@@ -97,13 +112,14 @@ function discoverFiles(baseDir, includeMemoryDb = false) {
   walk(baseDir);
   return files;
 }
-async function createLocalArchive(files, openclawDir, outputPath, tag, includeMemoryDb) {
+async function createLocalArchive(files, openclawDir, outputPath, tag, includeMemoryDb, trigger) {
   const meta = {
     version: 2,
     created: (/* @__PURE__ */ new Date()).toISOString(),
     ...tag ? { tag } : {},
     file_count: files.length,
-    ...includeMemoryDb ? { include_memory_db: true } : {}
+    ...includeMemoryDb ? { include_memory_db: true } : {},
+    ...trigger ? { trigger } : {}
   };
   const metaPath = path.join(openclawDir, "_clawon_meta.json");
   fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
@@ -157,6 +173,67 @@ function trackCliEvent(distinctId, event, properties = {}) {
   }).catch(() => {
   });
 }
+var CRON_MARKER_LOCAL = "# clawon-schedule-local";
+var CRON_MARKER_CLOUD = "# clawon-schedule-cloud";
+var SCHEDULE_LOG = path.join(CONFIG_DIR, "schedule.log");
+var INTERVAL_CRON = {
+  "1h": "0 * * * *",
+  "6h": "0 */6 * * *",
+  "12h": "0 */12 * * *",
+  "24h": "0 0 * * *"
+};
+var VALID_INTERVALS = Object.keys(INTERVAL_CRON);
+function resolveCliCommand(args) {
+  const nodePath = process.execPath;
+  const cliEntry = path.resolve(import.meta.dirname, "index.js");
+  return `${nodePath} ${cliEntry} ${args}`;
+}
+function getCurrentCrontab() {
+  try {
+    return execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return "";
+  }
+}
+function setCrontab(content) {
+  const tmpFile = path.join(CONFIG_DIR, ".crontab-tmp");
+  ensureDir(CONFIG_DIR);
+  fs.writeFileSync(tmpFile, content);
+  try {
+    execSync(`crontab ${tmpFile}`, { encoding: "utf8" });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+function addCronEntry(marker, cronExpr, command) {
+  const current = getCurrentCrontab();
+  const filtered = current.split("\n").filter((line) => !line.includes(marker)).join("\n");
+  const entry = `${cronExpr} ${command} >> ${SCHEDULE_LOG} 2>&1 ${marker}`;
+  const updated = filtered.trim() ? `${filtered.trim()}
+${entry}
+` : `${entry}
+`;
+  setCrontab(updated);
+}
+function removeCronEntry(marker) {
+  const current = getCurrentCrontab();
+  const lines = current.split("\n");
+  const filtered = lines.filter((line) => !line.includes(marker));
+  if (filtered.length === lines.length) return false;
+  setCrontab(filtered.join("\n"));
+  return true;
+}
+function getCronEntry(marker) {
+  const current = getCurrentCrontab();
+  const line = current.split("\n").find((l) => l.includes(marker));
+  return line || null;
+}
+function assertNotWindows() {
+  if (process.platform === "win32") {
+    console.error("\u2717 Scheduled backups require cron (macOS/Linux). Windows is not supported yet.");
+    process.exit(1);
+  }
+}
 var program = new Command();
 program.name("clawon").description("Backup and restore your OpenClaw workspace").version("0.1.1");
 program.command("login").description("Connect to Clawon with your API key").requiredOption("--api-key <key>", "Your Clawon API key").option("--api-url <url>", "API base URL", "https://clawon.io").action(async (opts) => {
@@ -180,9 +257,9 @@ program.command("login").description("Connect to Clawon with your API key").requ
     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").action(async (opts) => {
+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("--scheduled", "Internal: triggered by cron (suppresses interactive output)").action(async (opts) => {
   if (opts.includeMemoryDb) {
-    console.error("\u2717 Memory DB backup requires a Pro account. Use `clawon local backup --include-memory-db` for local backups.");
+    console.error("\u2717 Memory DB cloud backup requires a Pro account. Use `clawon local backup --include-memory-db` for local backups.");
     process.exit(1);
   }
   const cfg = readConfig();
@@ -254,13 +331,18 @@ program.command("backup").description("Backup your OpenClaw workspace to the clo
     console.log(`  Snapshot ID: ${snapshotId}`);
     console.log(`  Files: ${files.length}`);
     console.log(`  Size: ${(totalSize / 1024).toFixed(1)} KB`);
-    trackCliEvent(cfg.profileId, "cloud_backup_created", {
+    trackCliEvent(cfg.profileId, opts.scheduled ? "scheduled_backup_created" : "cloud_backup_created", {
       file_count: files.length,
       total_bytes: totalSize,
-      include_memory_db: !!opts.includeMemoryDb
+      include_memory_db: !!opts.includeMemoryDb,
+      type: "cloud",
+      trigger: opts.scheduled ? "scheduled" : "manual"
     });
   } catch (e) {
     const msg = e.message;
+    if (opts.scheduled) {
+      trackCliEvent(cfg.profileId, "scheduled_backup_failed", { type: "cloud", error: msg });
+    }
     if (msg.includes("Snapshot limit")) {
       console.error("\n\u2717 Snapshot limit reached (2).");
       console.error("  Delete one first:  clawon delete <id>");
@@ -496,6 +578,69 @@ Total: ${files.length} files (${(totalSize / 1024).toFixed(1)} KB)`);
   const cfg = readConfig();
   trackCliEvent(cfg?.profileId || "anonymous", "cli_discover", { file_count: files.length, include_memory_db: !!opts.includeMemoryDb });
 });
+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) => {
+  assertNotWindows();
+  const cfg = readConfig();
+  trackCliEvent(cfg?.profileId || "anonymous", "schedule_enabled_attempted", {
+    type: "cloud",
+    interval_hours: parseInt(opts.every),
+    gated: true
+  });
+  console.error("\u2717 Scheduled cloud backups require a Hobby or Pro account. Use `clawon local schedule on` for local scheduled backups.");
+  process.exit(1);
+});
+schedule.command("off").description("Disable scheduled cloud backups").action(async () => {
+  assertNotWindows();
+  const removed = removeCronEntry(CRON_MARKER_CLOUD);
+  if (!removed) {
+    console.log("No cloud schedule was active.");
+    return;
+  }
+  updateConfig({
+    schedule: {
+      cloud: { enabled: false, intervalHours: 0 }
+    }
+  });
+  console.log("\u2713 Scheduled cloud backup disabled");
+  const cfg = readConfig();
+  trackCliEvent(cfg?.profileId || "anonymous", "schedule_disabled", { type: "cloud" });
+});
+schedule.command("status").description("Show schedule status").action(async () => {
+  const cfg = readConfig();
+  const localEntry = getCronEntry(CRON_MARKER_LOCAL);
+  const cloudEntry = getCronEntry(CRON_MARKER_CLOUD);
+  console.log("Schedule Status\n");
+  if (localEntry) {
+    const localCfg = cfg?.schedule?.local;
+    console.log("\u2713 Local schedule: active");
+    if (localCfg?.intervalHours) console.log(`  Interval: every ${localCfg.intervalHours}h`);
+    if (localCfg?.maxSnapshots) console.log(`  Max snapshots: ${localCfg.maxSnapshots}`);
+    if (localCfg?.includeMemoryDb) console.log(`  Memory DB: included`);
+    console.log(`  Cron: ${localEntry.trim()}`);
+  } else {
+    console.log("\u2717 Local schedule: inactive");
+    console.log("  Enable: clawon local schedule on");
+  }
+  console.log("");
+  if (cloudEntry) {
+    const cloudCfg = cfg?.schedule?.cloud;
+    console.log("\u2713 Cloud schedule: active");
+    if (cloudCfg?.intervalHours) console.log(`  Interval: every ${cloudCfg.intervalHours}h`);
+    console.log(`  Cron: ${cloudEntry.trim()}`);
+  } else {
+    console.log("\u2717 Cloud schedule: inactive");
+    console.log("  Enable: clawon schedule on (requires Hobby or Pro)");
+  }
+  console.log(`
+Log: ${SCHEDULE_LOG}`);
+  trackCliEvent(cfg?.profileId || "anonymous", "schedule_status_viewed", {
+    local_enabled: !!localEntry,
+    cloud_enabled: !!cloudEntry,
+    local_interval_hours: cfg?.schedule?.local?.intervalHours || null,
+    cloud_interval_hours: cfg?.schedule?.cloud?.intervalHours || null
+  });
+});
 program.command("files").description("List files in a backup").option("--snapshot <id>", "Snapshot ID (default: latest)").action(async (opts) => {
   const cfg = readConfig();
   if (!cfg) {
@@ -538,38 +683,129 @@ Total: ${files.length} files`);
   }
 });
 var local = program.command("local").description("Local backup and restore (no cloud required)");
-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").action(async (opts) => {
+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").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);
+  }
+  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.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
+  const command = resolveCliCommand(args);
+  addCronEntry(CRON_MARKER_LOCAL, cronExpr, command);
+  const maxSnapshots = opts.maxSnapshots ? parseInt(opts.maxSnapshots, 10) : null;
+  updateConfig({
+    schedule: {
+      local: {
+        enabled: true,
+        intervalHours: parseInt(interval),
+        ...maxSnapshots ? { maxSnapshots } : {},
+        ...opts.includeMemoryDb ? { includeMemoryDb: true } : {}
+      }
+    }
+  });
+  console.log(`\u2713 Scheduled local backup enabled`);
+  console.log(`  Interval: every ${interval}`);
+  if (maxSnapshots) console.log(`  Max snapshots: ${maxSnapshots}`);
+  if (opts.includeMemoryDb) console.log(`  Memory DB: included`);
+  console.log(`  Log: ${SCHEDULE_LOG}`);
+  const firstRunArgs = "local backup" + (opts.includeMemoryDb ? " --include-memory-db" : "") + (opts.maxSnapshots ? ` --max-snapshots ${opts.maxSnapshots}` : "");
+  console.log("\nRunning first backup now...\n");
+  try {
+    execSync(resolveCliCommand(firstRunArgs), { stdio: "inherit" });
+  } catch {
+    console.error("\u26A0 First backup failed \u2014 schedule is still active and will retry at next interval.");
+  }
+  trackCliEvent(cfg?.profileId || "anonymous", wasEnabled ? "schedule_updated" : "schedule_enabled", {
+    type: "local",
+    interval_hours: parseInt(interval),
+    max_snapshots: maxSnapshots,
+    include_memory_db: !!opts.includeMemoryDb
+  });
+});
+localSchedule.command("off").description("Disable scheduled local backups").action(async () => {
+  assertNotWindows();
+  const removed = removeCronEntry(CRON_MARKER_LOCAL);
+  if (!removed) {
+    console.log("No local schedule was active.");
+    return;
+  }
+  updateConfig({
+    schedule: {
+      local: { enabled: false, intervalHours: 0 }
+    }
+  });
+  console.log("\u2713 Scheduled local backup disabled");
+  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("--scheduled", "Internal: triggered by cron (suppresses interactive output)").option("--max-snapshots <n>", "Keep only the N most recent local backups").action(async (opts) => {
   if (!fs.existsSync(OPENCLAW_DIR)) {
     console.error(`\u2717 OpenClaw directory not found: ${OPENCLAW_DIR}`);
     process.exit(1);
   }
-  console.log("Discovering files...");
-  const files = discoverFiles(OPENCLAW_DIR, !!opts.includeMemoryDb);
-  if (files.length === 0) {
-    console.error("\u2717 No files found to backup");
+  try {
+    if (!opts.scheduled) console.log("Discovering files...");
+    const files = discoverFiles(OPENCLAW_DIR, !!opts.includeMemoryDb);
+    if (files.length === 0) {
+      console.error("\u2717 No files found to backup");
+      process.exit(1);
+    }
+    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    if (!opts.scheduled) console.log(`Found ${files.length} files (${(totalSize / 1024).toFixed(1)} KB)`);
+    ensureDir(BACKUPS_DIR);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "T").slice(0, 15);
+    const filename = `backup-${timestamp}.tar.gz`;
+    const filePath = path.join(BACKUPS_DIR, filename);
+    if (!opts.scheduled) console.log("Creating archive...");
+    await createLocalArchive(files, OPENCLAW_DIR, filePath, opts.tag, opts.includeMemoryDb, opts.scheduled ? "scheduled" : "manual");
+    const archiveSize = fs.statSync(filePath).size;
+    if (!opts.scheduled) {
+      console.log(`
+\u2713 Local backup saved!`);
+      console.log(`  File: ${filePath}`);
+      console.log(`  Files: ${files.length}`);
+      console.log(`  Size: ${(archiveSize / 1024).toFixed(1)} KB (compressed)`);
+      if (opts.tag) console.log(`  Tag: ${opts.tag}`);
+    }
+    const maxSnapshots = opts.maxSnapshots ? parseInt(opts.maxSnapshots, 10) : null;
+    let rotatedCount = 0;
+    if (maxSnapshots && maxSnapshots > 0) {
+      const allBackups = fs.readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".tar.gz")).sort().reverse();
+      if (allBackups.length > maxSnapshots) {
+        const toDelete = allBackups.slice(maxSnapshots);
+        for (const old of toDelete) {
+          fs.unlinkSync(path.join(BACKUPS_DIR, old));
+          rotatedCount++;
+        }
+        if (!opts.scheduled) {
+          console.log(`  Rotated: deleted ${rotatedCount} old backup(s)`);
+        }
+      }
+    }
+    const cfg = readConfig();
+    trackCliEvent(cfg?.profileId || "anonymous", opts.scheduled ? "scheduled_backup_created" : "local_backup_created", {
+      file_count: files.length,
+      total_bytes: totalSize,
+      include_memory_db: !!opts.includeMemoryDb,
+      type: "local",
+      trigger: opts.scheduled ? "scheduled" : "manual",
+      rotated_count: rotatedCount
+    });
+  } catch (e) {
+    const msg = e.message;
+    if (opts.scheduled) {
+      const cfg = readConfig();
+      trackCliEvent(cfg?.profileId || "anonymous", "scheduled_backup_failed", { type: "local", error: msg });
+    }
+    console.error(`
+\u2717 Local backup failed: ${msg}`);
     process.exit(1);
   }
-  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
-  console.log(`Found ${files.length} files (${(totalSize / 1024).toFixed(1)} KB)`);
-  ensureDir(BACKUPS_DIR);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "T").slice(0, 15);
-  const filename = `backup-${timestamp}.tar.gz`;
-  const filePath = path.join(BACKUPS_DIR, filename);
-  console.log("Creating archive...");
-  await createLocalArchive(files, OPENCLAW_DIR, filePath, opts.tag, opts.includeMemoryDb);
-  const archiveSize = fs.statSync(filePath).size;
-  console.log(`
-\u2713 Local backup saved!`);
-  console.log(`  File: ${filePath}`);
-  console.log(`  Files: ${files.length}`);
-  console.log(`  Size: ${(archiveSize / 1024).toFixed(1)} KB (compressed)`);
-  if (opts.tag) console.log(`  Tag: ${opts.tag}`);
-  const cfg = readConfig();
-  trackCliEvent(cfg?.profileId || "anonymous", "local_backup_created", {
-    file_count: files.length,
-    total_bytes: totalSize,
-    include_memory_db: !!opts.includeMemoryDb
-  });
 });
 local.command("list").description("List local backups").action(async () => {
   if (!fs.existsSync(BACKUPS_DIR)) {
@@ -681,6 +917,17 @@ program.command("status").description("Show current status").action(async () =>
   } else {
     console.log(`\u2717 OpenClaw not found: ${OPENCLAW_DIR}`);
   }
+  console.log("");
+  const localEntry = getCronEntry(CRON_MARKER_LOCAL);
+  const cloudEntry = getCronEntry(CRON_MARKER_CLOUD);
+  if (localEntry || cloudEntry) {
+    console.log("\u2713 Schedule active");
+    if (localEntry) console.log("  Local: " + (cfg?.schedule?.local?.intervalHours || "?") + "h interval");
+    if (cloudEntry) console.log("  Cloud: " + (cfg?.schedule?.cloud?.intervalHours || "?") + "h interval");
+  } else {
+    console.log("\u2717 No schedule configured");
+    console.log("  Run: clawon local schedule on");
+  }
   trackCliEvent(cfg?.profileId || "anonymous", "cli_status_viewed");
 });
 program.command("logout").description("Remove local credentials").action(() => {

package/package.json

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