clawkeep 0.1.0

package/src/commands/snap.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function snap(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = opts.quiet ? null : ora('Backing up...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      spinner?.fail('Not initialized. Run `clawkeep init` first.');
+      process.exit(1);
+    }
+
+    const result = await claw.snap(opts.message || null);
+
+    if (!result) {
+      if (spinner) spinner.info(chalk.dim('Nothing changed.'));
+      return;
+    }
+
+    const hash = chalk.yellow(result.hash.substring(0, 8));
+    const ins = chalk.green('+' + result.summary.insertions);
+    const del = chalk.red('-' + result.summary.deletions);
+    const count = result.summary.changed;
+
+    if (spinner) {
+      spinner.succeed(`${hash} ${chalk.dim(result.message)}`);
+      console.log(`  ${ins} ${del} across ${count} file(s)`);
+      
+      // Show changed files (up to 5)
+      if (result.files && result.files.length <= 5) {
+        for (const f of result.files) {
+          const icon = f.status === '?' ? chalk.green('+') : chalk.yellow('~');
+          console.log(`  ${icon} ${chalk.dim(f.path)}`);
+        }
+      }
+    } else if (opts.quiet) {
+      // Machine-readable output
+      console.log(result.hash.substring(0, 8));
+    }
+  } catch (err) {
+    spinner?.fail('Backup failed');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+};

package/src/commands/status.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const chalk = require('chalk');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function status(opts) {
+  const dir = path.resolve(opts.dir || '.');
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      console.log('');
+      console.log(chalk.yellow('  ClawKeep is not initialized here.'));
+      console.log(chalk.dim('  Run `clawkeep init` to start tracking.'));
+      console.log('');
+      return;
+    }
+
+    const config = claw.loadConfig();
+    const gitStatus = await claw.status();
+    const stats = await claw.getStats();
+
+    console.log('');
+    console.log(chalk.bold('  ClawKeep Status'));
+    console.log('');
+
+    // Stats
+    console.log(chalk.dim('  ── Stats ──────────────────────'));
+    console.log(`  Backups:     ${chalk.white(stats.totalSnaps)}`);
+    console.log(`  Files:       ${chalk.white(stats.trackedFiles)}`);
+    console.log(`  Tracking:    ${stats.daysTracked > 0 ? chalk.white(stats.daysTracked + ' day(s)') : chalk.dim('today')}`);
+
+    if (stats.lastSnap) {
+      const ago = _timeAgo(new Date(stats.lastSnap));
+      console.log(`  Last backup: ${chalk.dim(ago)}`);
+    }
+
+    // Current state
+    console.log('');
+    console.log(chalk.dim('  ── Changes ────────────────────'));
+    if (gitStatus.clean) {
+      console.log(`  ${chalk.green('●')} Clean — no pending changes`);
+    } else {
+      console.log(`  ${chalk.yellow('●')} ${gitStatus.total} file(s) changed since last backup`);
+
+      const show = gitStatus.files.slice(0, 8);
+      for (const f of show) {
+        let icon, color;
+        if (f.working_dir === '?' || f.index === '?') {
+          icon = '+'; color = chalk.green;
+        } else if (f.working_dir === 'D' || f.index === 'D') {
+          icon = '-'; color = chalk.red;
+        } else {
+          icon = '~'; color = chalk.yellow;
+        }
+        console.log(`    ${color(icon)} ${chalk.dim(f.path)}`);
+      }
+      if (gitStatus.files.length > 8) {
+        console.log(chalk.dim(`    ... and ${gitStatus.files.length - 8} more`));
+      }
+    }
+
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};
+
+function _timeAgo(date) {
+  const now = new Date();
+  const diffMs = now - date;
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 30) return `${diffDays}d ago`;
+  return date.toISOString().substring(0, 10);
+}

package/src/commands/ui.js

@@ -0,0 +1,334 @@
+'use strict';
+
+const http = require('http');
+const crypto = require('crypto');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const os = require('os');
+const ClawGit = require('../core/git');
+const BackupManager = require('../core/backup');
+
+const PID_FILE = '.clawkeep/ui.pid';
+const TOKEN_FILE = '.clawkeep/ui.token';
+const UI_DIR = path.join(__dirname, '../../ui');
+
+const MIME = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+};
+
+module.exports = async function ui(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const port = parseInt(opts.port) || 3333;
+
+  if (opts.stop) return stopDaemon(dir);
+
+  const claw = new ClawGit(dir);
+  if (!(await claw.isInitialized())) {
+    console.error(chalk.red('Not initialized. Run `clawkeep init` first.'));
+    process.exit(1);
+  }
+
+  // Auth token
+  const tokenPath = path.join(dir, TOKEN_FILE);
+  let token;
+  if (fs.existsSync(tokenPath)) {
+    token = fs.readFileSync(tokenPath, 'utf8').trim();
+  } else {
+    token = crypto.randomBytes(16).toString('hex');
+    fs.writeFileSync(tokenPath, token);
+  }
+
+  if (opts.daemon) return startDaemon(dir, port, opts);
+  startServer(claw, dir, port, token, opts);
+};
+
+function startDaemon(dir, port, opts) {
+  const pidPath = path.join(dir, PID_FILE);
+  if (fs.existsSync(pidPath)) {
+    const oldPid = parseInt(fs.readFileSync(pidPath, 'utf8'));
+    try { process.kill(oldPid, 0); console.log(chalk.yellow(`  Already running (PID ${oldPid}).`)); return; }
+    catch { fs.unlinkSync(pidPath); }
+  }
+
+  const binPath = path.join(__dirname, '../../bin/clawkeep.js');
+  const child = spawn(process.execPath, [binPath, 'ui', '--port', String(port), '-d', dir], {
+    detached: true, stdio: 'ignore',
+    env: { ...process.env, CLAWKEEP_DAEMON: '1' },
+  });
+  child.unref();
+  fs.writeFileSync(pidPath, String(child.pid));
+
+  const tokenPath = path.join(dir, TOKEN_FILE);
+  const token = fs.readFileSync(tokenPath, 'utf8').trim();
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🐾 ClawKeep Dashboard (background)'));
+  console.log(`  ${chalk.dim('URL')}   http://localhost:${port}/?token=${token}`);
+  console.log(`  ${chalk.dim('Stop')}  clawkeep ui --stop`);
+  console.log('');
+}
+
+function stopDaemon(dir) {
+  const pidPath = path.join(dir, PID_FILE);
+  if (!fs.existsSync(pidPath)) { console.log(chalk.dim('  No daemon running.')); return; }
+  const pid = parseInt(fs.readFileSync(pidPath, 'utf8'));
+  try { process.kill(pid, 'SIGTERM'); console.log(chalk.green(`  ✓ Stopped (PID ${pid})`)); }
+  catch { console.log(chalk.dim('  Already stopped.')); }
+  try { fs.unlinkSync(pidPath); } catch {}
+}
+
+function startServer(claw, dir, port, token, opts) {
+  function auth(req) {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    return (url.searchParams.get('token') || req.headers['x-clawkeep-token']) === token;
+  }
+
+  const apiHandlers = {
+    'status': async () => {
+      const config = claw.loadConfig();
+      const stats = await claw.getStats();
+      const gitStatus = await claw.status();
+      return { config, stats, gitStatus };
+    },
+    'log': async (p) => await claw.log(parseInt(p.get('limit')) || 50),
+    'diff': async () => ({ diff: await claw.diff(false) }),
+    'snap': async (p) => (await claw.snap(p.get('message') || null)) || { message: 'No changes' },
+    'restore': async (p) => {
+      const hash = p.get('hash');
+      if (!hash) return { error: 'hash required' };
+      await claw.restore(hash, false);
+      return { ok: true, message: 'Restored to ' + hash.substring(0, 7) };
+    },
+    'compare': async (p) => {
+      const from = p.get('from'), to = p.get('to');
+      if (!from || !to) return { error: 'from and to required' };
+      return { diff: await claw.diffBetween(from, to) };
+    },
+    'files': async (p) => listFiles(dir, p.get('path') || '.'),
+    'file': async (p) => readFile(dir, p.get('path')),
+    'commit': async (p) => await claw.showCommit(p.get('hash') || 'HEAD'),
+    'commit/diff': async (p) => ({ diff: await claw.commitDiff(p.get('hash') || 'HEAD') }),
+    'file-history': async (p) => await claw.fileHistory(p.get('path') || '.'),
+    'files-at': async (p) => await claw.listFilesAtCommit(p.get('hash') || 'HEAD', p.get('path') || ''),
+    'file-at': async (p) => await claw.showFileAtCommit(p.get('hash') || 'HEAD', p.get('path')),
+    'backup/status': async () => {
+      const bm = new BackupManager(claw);
+      return bm.getConfig();
+    },
+    'backup/set-target': async (p) => {
+      const bm = new BackupManager(claw);
+      const type = p.get('type');
+      const options = JSON.parse(p.get('options') || '{}');
+      return await bm.setTarget(type, options);
+    },
+    'backup/sync': async (p) => {
+      const bm = new BackupManager(claw);
+      const password = p.get('password') || process.env.CLAWKEEP_PASSWORD || null;
+      return await bm.sync(password);
+    },
+    'backup/test': async () => {
+      const bm = new BackupManager(claw);
+      return await bm.test();
+    },
+    'backup/set-password': async (p) => {
+      const bm = new BackupManager(claw);
+      const password = p.get('password');
+      if (!password) return { error: 'password required' };
+      bm.setPassword(password);
+      return { ok: true };
+    },
+    'backup/has-password': async () => {
+      const bm = new BackupManager(claw);
+      return { set: bm.hasPassword() };
+    },
+    'backup/sync-status': async (p) => {
+      const bm = new BackupManager(claw);
+      const password = p.get('password') || process.env.CLAWKEEP_PASSWORD || null;
+      return await bm.getSyncStatus(password);
+    },
+    'backup/compact': async (p) => {
+      const bm = new BackupManager(claw);
+      const password = p.get('password') || process.env.CLAWKEEP_PASSWORD || null;
+      return await bm.compact(password);
+    },
+    'backup/watch-status': async () => {
+      const watchPid = path.join(dir, '.clawkeep/watch.pid');
+      if (!fs.existsSync(watchPid)) return { running: false };
+      const pid = parseInt(fs.readFileSync(watchPid, 'utf8'));
+      try { process.kill(pid, 0); return { running: true, pid }; }
+      catch { return { running: false }; }
+    },
+    'backup/repo-size': async () => {
+      return { size: claw.getRepoSize() };
+    },
+  };
+
+  // Special handler for export (streams file, not JSON)
+  const handleExport = async (params, req, res) => {
+    const password = params.get('password');
+    if (!password) {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({ error: 'password required' }));
+      return;
+    }
+    try {
+      const { exportEncrypted } = require('../core/crypto');
+      const tmpPath = path.join(os.tmpdir(), `clawkeep-export-${Date.now()}.enc`);
+      await exportEncrypted(dir, tmpPath, password);
+      res.setHeader('Content-Disposition', 'attachment; filename="backup.clawkeep.enc"');
+      res.setHeader('Content-Type', 'application/octet-stream');
+      const stream = fs.createReadStream(tmpPath);
+      stream.pipe(res);
+      stream.on('end', () => { setTimeout(() => { try { fs.unlinkSync(tmpPath); } catch {} }, 10000); });
+    } catch (err) {
+      res.setHeader('Content-Type', 'application/json');
+      res.statusCode = 500;
+      res.end(JSON.stringify({ error: err.message }));
+    }
+  };
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+
+    // Allow static assets without auth (CSS, JS, images)
+    const isStatic = /\.(css|js|png|svg|ico|woff2?)$/i.test(url.pathname);
+
+    if (!isStatic && !auth(req)) {
+      res.setHeader('Content-Type', 'text/html');
+      res.end(authPage());
+      return;
+    }
+
+    // API (requires auth)
+    if (url.pathname.startsWith('/api/')) {
+      if (!auth(req)) {
+        res.statusCode = 401;
+        res.end('{"error":"unauthorized"}');
+        return;
+      }
+      const route = url.pathname.replace('/api/', '');
+      // Special routes that handle their own response
+      if (route === 'backup/export') {
+        return handleExport(url.searchParams, req, res);
+      }
+      res.setHeader('Content-Type', 'application/json');
+      try {
+        const handler = apiHandlers[route];
+        if (handler) {
+          res.end(JSON.stringify(await handler(url.searchParams)));
+        } else {
+          res.statusCode = 404;
+          res.end('{"error":"not found"}');
+        }
+      } catch (err) {
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // Static files from ui/
+    let filePath = url.pathname === '/' ? '/index.html' : url.pathname;
+    const fullPath = path.join(UI_DIR, filePath);
+
+    // Security: no directory traversal
+    if (!fullPath.startsWith(UI_DIR)) {
+      res.statusCode = 403;
+      res.end('Forbidden');
+      return;
+    }
+
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+      const ext = path.extname(fullPath);
+      res.setHeader('Content-Type', MIME[ext] || 'text/plain');
+      // Append token to inline requests
+      let content = fs.readFileSync(fullPath);
+      res.end(content);
+    } else {
+      // Fallback to index.html for SPA
+      res.setHeader('Content-Type', 'text/html');
+      res.end(fs.readFileSync(path.join(UI_DIR, 'index.html')));
+    }
+  });
+
+  const host = opts.host || '0.0.0.0';
+  server.listen(port, host, () => {
+    const pidPath = path.join(dir, PID_FILE);
+    fs.writeFileSync(pidPath, String(process.pid));
+
+    if (!process.env.CLAWKEEP_DAEMON) {
+      console.log('');
+      console.log(chalk.bold.cyan('  🐾 ClawKeep Dashboard'));
+      console.log('');
+      console.log(`  ${chalk.dim('URL')}     ${chalk.white(`http://localhost:${port}/?token=${token}`)}`);
+      console.log(`  ${chalk.dim('Auth')}    ${chalk.green('✓ token required')}`);
+      console.log('');
+      console.log(chalk.dim('  Ctrl+C to stop · --daemon to run in background'));
+      console.log('');
+    }
+  });
+
+  const cleanup = () => {
+    try { fs.unlinkSync(path.join(dir, PID_FILE)); } catch {}
+    server.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}
+
+function listFiles(baseDir, subdir) {
+  const fullPath = path.resolve(baseDir, subdir);
+  if (!fullPath.startsWith(path.resolve(baseDir))) return { error: 'Access denied' };
+  if (!fs.existsSync(fullPath)) return { error: 'Not found' };
+
+  return fs.readdirSync(fullPath, { withFileTypes: true })
+    .filter(e => !e.name.startsWith('.git') && e.name !== 'node_modules' && e.name !== '.clawkeep')
+    .map(e => ({
+      name: e.name,
+      type: e.isDirectory() ? 'dir' : 'file',
+      path: path.join(subdir, e.name).replace(/\\/g, '/'),
+      size: e.isFile() ? fs.statSync(path.join(fullPath, e.name)).size : null,
+    }))
+    .sort((a, b) => a.type !== b.type ? (a.type === 'dir' ? -1 : 1) : a.name.localeCompare(b.name));
+}
+
+function readFile(baseDir, filePath) {
+  if (!filePath) return { error: 'path required' };
+  const fullPath = path.resolve(baseDir, filePath);
+  if (!fullPath.startsWith(path.resolve(baseDir))) return { error: 'Access denied' };
+  if (!fs.existsSync(fullPath)) return { error: 'Not found' };
+
+  const stats = fs.statSync(fullPath);
+  if (stats.size > 512 * 1024) return { error: 'File too large', size: stats.size };
+
+  const ext = path.extname(filePath).toLowerCase();
+  const binary = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.db', '.enc', '.gz', '.zip', '.tar'].includes(ext);
+  if (binary) return { path: filePath, size: stats.size, binary: true, content: null };
+
+  return { path: filePath, size: stats.size, binary: false, content: fs.readFileSync(fullPath, 'utf8') };
+}
+
+function authPage() {
+  return `<!DOCTYPE html><html><head><meta charset="UTF-8"><title>ClawKeep</title>
+<style>*{margin:0;padding:0;box-sizing:border-box}body{background:#06080c;color:#f1f5f9;font-family:-apple-system,system-ui,sans-serif;display:flex;justify-content:center;align-items:center;min-height:100vh}
+.card{text-align:center;padding:40px;border:1px solid #1e2a3a;border-radius:12px;background:#111820;width:340px}
+h1{font-size:18px;margin-bottom:4px;font-weight:600}h1 span{color:#38bdf8}
+p{color:#6b7b8e;font-size:12px;margin-bottom:20px}
+input{background:#0c1017;border:1px solid #1e2a3a;color:#f1f5f9;padding:9px 14px;border-radius:6px;width:100%;font-size:13px;margin-bottom:10px}
+input:focus{outline:none;border-color:#38bdf8}
+button{background:#38bdf8;color:#06080c;border:none;padding:9px;border-radius:6px;font-weight:600;cursor:pointer;width:100%;font-size:13px}
+button:hover{filter:brightness(1.1)}</style></head>
+<body><div class="card"><h1>🐾 <span>ClawKeep</span></h1><p>Enter your access token</p>
+<form onsubmit="event.preventDefault();location.href='/?token='+document.getElementById('t').value">
+<input id="t" type="password" placeholder="Token" autofocus>
+<button type="submit">Open Dashboard</button></form></div></body></html>`;
+}

package/src/commands/watch.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const chokidar = require('chokidar');
+const ClawGit = require('../core/git');
+const BackupManager = require('../core/backup');
+
+const PID_FILE = '.clawkeep/watch.pid';
+
+module.exports = async function watch(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const interval = parseInt(opts.interval) || 5000;
+  const autoPush = opts.push || false;
+  const quiet = opts.quiet || false;
+
+  if (opts.stop) return stopDaemon(dir);
+
+  const claw = new ClawGit(dir);
+
+  if (!(await claw.isInitialized())) {
+    console.error(chalk.red('Not initialized. Run `clawkeep init` first.'));
+    process.exit(1);
+  }
+
+  if (opts.daemon) return startDaemon(dir, interval, opts);
+  startWatcher(claw, dir, interval, autoPush, quiet);
+};
+
+function startDaemon(dir, interval, opts) {
+  const pidPath = path.join(dir, PID_FILE);
+  if (fs.existsSync(pidPath)) {
+    const oldPid = parseInt(fs.readFileSync(pidPath, 'utf8'));
+    try { process.kill(oldPid, 0); console.log(chalk.yellow(`  Already running (PID ${oldPid}).`)); return; }
+    catch { fs.unlinkSync(pidPath); }
+  }
+
+  const args = ['watch', '--interval', String(interval), '-d', dir];
+  if (opts.push) args.push('--push');
+  args.push('-q');
+
+  const binPath = path.join(__dirname, '../../bin/clawkeep.js');
+  const child = spawn(process.execPath, [binPath, ...args], {
+    detached: true, stdio: 'ignore',
+    env: { ...process.env, CLAWKEEP_WATCH_DAEMON: '1' },
+  });
+  child.unref();
+  fs.writeFileSync(pidPath, String(child.pid));
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🐾 ClawKeep watching (background)'));
+  console.log(`  ${chalk.dim('PID')}       ${child.pid}`);
+  console.log(`  ${chalk.dim('Dir')}       ${dir}`);
+  console.log(`  ${chalk.dim('Interval')}  ${interval}ms`);
+  console.log(`  ${chalk.dim('Stop')}      clawkeep watch --stop`);
+  console.log('');
+}
+
+function stopDaemon(dir) {
+  const pidPath = path.join(dir, PID_FILE);
+  if (!fs.existsSync(pidPath)) { console.log(chalk.dim('  No watcher running.')); return; }
+  const pid = parseInt(fs.readFileSync(pidPath, 'utf8'));
+  try { process.kill(pid, 'SIGTERM'); console.log(chalk.green(`  ✓ Watcher stopped (PID ${pid})`)); }
+  catch { console.log(chalk.dim('  Already stopped.')); }
+  try { fs.unlinkSync(pidPath); } catch {}
+}
+
+function startWatcher(claw, dir, interval, autoPush, quiet) {
+  const config = claw.loadConfig();
+  const pidPath = path.join(dir, PID_FILE);
+
+  // Write PID file
+  fs.writeFileSync(pidPath, String(process.pid));
+
+  if (!quiet) {
+    console.log('');
+    console.log(chalk.bold.cyan('  🐾 ClawKeep watching...'));
+    console.log('');
+    console.log(`  ${chalk.dim('Directory')}   ${dir}`);
+    console.log(`  ${chalk.dim('Debounce')}    ${interval}ms`);
+    console.log(`  ${chalk.dim('Auto-push')}   ${autoPush ? chalk.green('on') : chalk.dim('off')}`);
+    console.log('');
+    console.log(chalk.dim('  Waiting for changes... (Ctrl+C to stop · --daemon to run in background)'));
+    console.log('');
+  }
+
+  let debounceTimer = null;
+  let changedFiles = new Set();
+  let snapCount = 0;
+
+  // Load .clawkeepignore patterns for chokidar + hardcoded essentials
+  const clawIgnore = claw._loadIgnorePatterns().map(p => {
+    if (p.endsWith('/')) return '**/' + p + '**';
+    if (!p.includes('/') && !p.includes('*')) return '**/' + p;
+    return '**/' + p;
+  });
+  const ignored = [
+    '**/.git/**',
+    '**/.clawkeep/**',
+    ...(config.ignore || []),
+    ...clawIgnore,
+  ];
+
+  const watcher = chokidar.watch(dir, {
+    ignored,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 500,
+      pollInterval: 100,
+    },
+  });
+
+  const doSnap = async () => {
+    const files = Array.from(changedFiles);
+    changedFiles.clear();
+    if (files.length === 0) return;
+
+    try {
+      const result = await claw.snap();
+
+      if (result) {
+        snapCount++;
+        const now = new Date().toISOString().substring(11, 19);
+        const hash = chalk.yellow(result.hash.substring(0, 8));
+
+        if (!quiet) {
+          console.log(`  ${chalk.dim(now)} ${chalk.green('⬤')} ${hash} ${chalk.dim(result.message)}`);
+        }
+
+        if (autoPush && config.remote) {
+          try {
+            await claw.push();
+            if (!quiet) console.log(`  ${chalk.dim(now)} ${chalk.blue('↑')} ${chalk.dim('pushed')}`);
+          } catch (pushErr) {
+            if (!quiet) console.log(`  ${chalk.dim(now)} ${chalk.yellow('⚠')} ${chalk.dim('push failed: ' + pushErr.message)}`);
+          }
+        }
+
+        // Auto-sync to backup target
+        if (config.backup && config.backup.autoSync && config.backup.target) {
+          try {
+            const bm = new BackupManager(claw);
+            await bm.sync();
+            if (!quiet) console.log(`  ${chalk.dim(now)} ${chalk.blue('↑')} ${chalk.dim('synced to ' + (config.backup.targetLabel || config.backup.target))}`);
+          } catch (syncErr) {
+            if (!quiet) console.log(`  ${chalk.dim(now)} ${chalk.yellow('⚠')} ${chalk.dim('sync failed: ' + syncErr.message)}`);
+          }
+        }
+      }
+    } catch (err) {
+      if (!quiet) console.error(chalk.red(`  Error: ${err.message}`));
+    }
+  };
+
+  const onFileChange = (eventType, filePath) => {
+    const relative = path.relative(dir, filePath);
+    changedFiles.add(relative);
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(doSnap, interval);
+  };
+
+  watcher.on('add', (p) => onFileChange('add', p));
+  watcher.on('change', (p) => onFileChange('change', p));
+  watcher.on('unlink', (p) => onFileChange('unlink', p));
+
+  const cleanup = () => {
+    if (!quiet) {
+      console.log('');
+      console.log(chalk.dim(`  Stopped. ${snapCount} backup(s) taken this session.`));
+    }
+    try { fs.unlinkSync(pidPath); } catch {}
+    watcher.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}