claude-code-backup 1.0.0

package/src/commands/status.js

@@ -0,0 +1,80 @@
+import chalk from 'chalk';
+import { requireConfig, LAUNCHD_PLIST, LAUNCHD_LABEL } from '../core/config.js';
+import { getStatus } from '../backends/github.js';
+import { collectFiles } from '../core/collector.js';
+import { log } from '../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+
+const execAsync = promisify(exec);
+
+async function getServiceStatus() {
+  if (!existsSync(LAUNCHD_PLIST)) return 'not installed';
+  try {
+    const uid = process.getuid();
+    const { stdout } = await execAsync(`launchctl print gui/${uid}/${LAUNCHD_LABEL} 2>/dev/null`);
+    return stdout.includes('pid') ? 'running' : 'loaded (not running)';
+  } catch {
+    try {
+      const { stdout } = await execAsync(`launchctl list | grep "${LAUNCHD_LABEL}"`);
+      const parts = stdout.trim().split(/\s+/);
+      return parts[0] !== '-' ? `running (PID ${parts[0]})` : 'loaded (stopped)';
+    } catch {
+      return 'not running';
+    }
+  }
+}
+
+export async function runStatus() {
+  const config = requireConfig();
+
+  log.header('Claude Backup Status');
+
+  // Watched dirs + file count
+  const files = collectFiles(config);
+  const claudeMdCount = files.filter(f => f.dest.startsWith('claude_md_')).length;
+  const watchedCount  = files.length - claudeMdCount;
+
+  console.log(chalk.bold('Watched dirs:'));
+  for (const dir of config.watched_dirs) {
+    console.log(`  ${dir}`);
+  }
+  console.log(`${chalk.bold('Files tracked:')} ${watchedCount}`);
+
+  const claudeMdDirs = config.claude_md_dirs || [];
+  if (claudeMdDirs.length > 0) {
+    console.log(`\n${chalk.bold('Project CLAUDE.md dirs:')}`);
+    for (const dir of claudeMdDirs) {
+      console.log(`  ${dir}`);
+    }
+    console.log(`${chalk.bold('CLAUDE.md files:')} ${claudeMdCount}`);
+  }
+
+  // GitHub
+  console.log(`\n${chalk.bold('GitHub:')} ${config.github.repo}  [${config.github.branch}]`);
+  const status = await getStatus(config);
+  if (status?.lastCommit) {
+    const c = status.lastCommit;
+    const dateStr = c.date ? String(c.date).slice(0, 19).replace('T', ' ') : 'unknown';
+    console.log(`${chalk.bold('Last backup:')}  ${dateStr}`);
+    console.log(`${chalk.bold('Commit:')}       ${String(c.hash).slice(0, 7)}  ${c.message}`);
+    if (status.pending > 0) {
+      console.log(`${chalk.bold('Local changes:')} ${chalk.yellow(status.pending + ' file(s) not yet pushed')}`);
+    } else {
+      console.log(`${chalk.bold('Sync status:')}  ${chalk.green('Up to date')}`);
+    }
+  } else {
+    console.log(chalk.dim('  No backups yet. Run: claude-backup push'));
+  }
+
+  // Launchd service
+  const svc = await getServiceStatus();
+  const svcColor = svc.startsWith('running') ? chalk.green : chalk.yellow;
+  console.log(`\n${chalk.bold('Auto-sync service:')} ${svcColor(svc)}`);
+  if (!svc.startsWith('running')) {
+    console.log(chalk.dim('  Run: claude-backup service install'));
+  }
+
+  console.log('');
+}

package/src/commands/watch.js

@@ -0,0 +1,101 @@
+import { existsSync } from 'fs';
+import chokidar from 'chokidar';
+import { requireConfig, expandPath } from '../core/config.js';
+import { push } from '../backends/github.js';
+import { log } from '../utils/logger.js';
+
+export async function runWatch(options) {
+  const config = requireConfig();
+
+  if (options.interval) {
+    await runIntervalMode(config, parseFloat(options.interval));
+    return;
+  }
+
+  const dirs = config.watched_dirs
+    .map(expandPath)
+    .filter(d => existsSync(d));
+
+  if (dirs.length === 0) {
+    log.error('No valid watched directories found — check your config');
+    process.exit(1);
+  }
+
+  log.header('Claude Backup — File Watcher');
+  for (const dir of dirs) log.dim(`  Watching: ${dir}`);
+  log.dim(`  Debounce: ${config.auto_sync?.debounce_ms ?? 2000}ms`);
+  log.dim('  Press Ctrl+C to stop\n');
+
+  const debounceMs = config.auto_sync?.debounce_ms ?? 2000;
+  let timer = null;
+  let busy = false;
+
+  const watcher = chokidar.watch(dirs, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
+    ignored: [/(^|[/\\])\.git([/\\]|$)/],
+  });
+
+  function scheduleSync() {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      if (busy) return;
+      busy = true;
+      const ts = new Date().toLocaleTimeString();
+      try {
+        const count = await push(config);
+        if (count > 0) {
+          log.success(`[${ts}] Synced ${count} file(s) → GitHub`);
+        } else {
+          log.dim(`[${ts}] No changes to push`);
+        }
+      } catch (err) {
+        log.error(`[${ts}] Sync failed: ${err.message}`);
+      } finally {
+        busy = false;
+      }
+    }, debounceMs);
+  }
+
+  watcher
+    .on('add', scheduleSync)
+    .on('change', scheduleSync)
+    .on('unlink', scheduleSync)
+    .on('error', err => log.error(`Watcher error: ${err.message}`));
+
+  function shutdown() {
+    watcher.close().then(() => {
+      log.info('File watcher stopped');
+      process.exit(0);
+    });
+  }
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', () => { console.log(''); shutdown(); });
+}
+
+async function runIntervalMode(config, minutes) {
+  log.header(`Claude Backup — Interval Sync (every ${minutes}m)`);
+
+  async function sync() {
+    const ts = new Date().toLocaleTimeString();
+    try {
+      const count = await push(config);
+      if (count > 0) {
+        log.success(`[${ts}] Synced ${count} file(s) → GitHub`);
+      } else {
+        log.dim(`[${ts}] No changes`);
+      }
+    } catch (err) {
+      log.error(`[${ts}] Sync failed: ${err.message}`);
+    }
+  }
+
+  await sync();
+  const ms = minutes * 60 * 1000;
+  setInterval(sync, ms);
+
+  process.on('SIGTERM', () => { log.info('Interval sync stopped'); process.exit(0); });
+  process.on('SIGINT',  () => { console.log(''); log.info('Interval sync stopped'); process.exit(0); });
+}

package/src/core/collector.js

@@ -0,0 +1,87 @@
+import { readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { expandPath, sanitizeDirName } from './config.js';
+
+// Prefix used in the repo and manifest to distinguish project CLAUDE.md entries
+// from regular watched-dir entries so the two namespaces never collide.
+export const CLAUDE_MD_PREFIX = 'claude_md_';
+
+function globMatch(name, pattern) {
+  if (!pattern.includes('*')) return name === pattern;
+  const re = new RegExp(
+    '^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$'
+  );
+  return re.test(name);
+}
+
+function shouldExclude(name, excludes) {
+  return excludes.some(p => globMatch(name, p));
+}
+
+function walkDir(dir, excludes, results, relPath) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (shouldExclude(entry.name, excludes)) continue;
+    const fullPath = join(dir, entry.name);
+    const rel = relPath ? join(relPath, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      walkDir(fullPath, excludes, results, rel);
+    } else if (entry.isFile()) {
+      results.push({ src: fullPath, rel });
+    }
+  }
+}
+
+export function collectFiles(config) {
+  const excludes = config.exclude || [];
+  const result = [];
+
+  // Full recursive backup of each watched dir (e.g. ~/.claude)
+  for (const rawDir of config.watched_dirs) {
+    const dir = expandPath(rawDir);
+    if (!existsSync(dir)) continue;
+
+    const label = sanitizeDirName(dir);
+    const files = [];
+    walkDir(dir, excludes, files, '');
+
+    for (const { src, rel } of files) {
+      result.push({ src, dest: join(label, rel) });
+    }
+  }
+
+  // Only the CLAUDE.md file from each project root
+  for (const rawDir of (config.claude_md_dirs || [])) {
+    const dir = expandPath(rawDir);
+    const claudeMd = join(dir, 'CLAUDE.md');
+    if (!existsSync(claudeMd)) continue;
+
+    const label = CLAUDE_MD_PREFIX + sanitizeDirName(dir);
+    result.push({ src: claudeMd, dest: join(label, 'CLAUDE.md') });
+  }
+
+  return result;
+}
+
+export function buildManifest(config) {
+  const manifest = {};
+
+  // Watched dirs
+  for (const rawDir of config.watched_dirs) {
+    const dir = expandPath(rawDir);
+    manifest[sanitizeDirName(dir)] = dir;
+  }
+
+  // Project CLAUDE.md dirs — prefixed so restore knows to target the project root
+  for (const rawDir of (config.claude_md_dirs || [])) {
+    const dir = expandPath(rawDir);
+    manifest[CLAUDE_MD_PREFIX + sanitizeDirName(dir)] = dir;
+  }
+
+  return manifest;
+}

package/src/core/config.js

@@ -0,0 +1,54 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'fs';
+
+export const CONFIG_DIR = join(homedir(), '.config', 'claude-backup');
+export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+export const REPO_DIR = join(CONFIG_DIR, 'repo');
+export const LOG_FILE = join(CONFIG_DIR, 'watch.log');
+export const ERROR_LOG_FILE = join(CONFIG_DIR, 'watch.error.log');
+export const LAUNCHD_PLIST = join(
+  homedir(), 'Library', 'LaunchAgents', 'com.claude-backup.watch.plist'
+);
+export const LAUNCHD_LABEL = 'com.claude-backup.watch';
+
+export function ensureConfigDir() {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+  try { chmodSync(CONFIG_FILE, 0o600); } catch {}
+}
+
+export function requireConfig() {
+  const config = loadConfig();
+  if (!config || !config.github?.pat || !config.github?.repo) {
+    console.error('Not configured. Run: claude-backup init');
+    process.exit(1);
+  }
+  return config;
+}
+
+export function expandPath(p) {
+  if (typeof p !== 'string') return p;
+  if (p.startsWith('~/') || p === '~') return join(homedir(), p.slice(1));
+  return p;
+}
+
+export function sanitizeDirName(dirPath) {
+  return dirPath
+    .replace(/^\//, '')
+    .replace(/\//g, '_')
+    .replace(/[^a-zA-Z0-9_.-]/g, '_');
+}

package/src/utils/logger.js

@@ -0,0 +1,15 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+export const log = {
+  info:    (msg) => console.log(chalk.blue('ℹ'), chalk.reset(msg)),
+  success: (msg) => console.log(chalk.green('✔'), chalk.reset(msg)),
+  warn:    (msg) => console.log(chalk.yellow('⚠'), chalk.reset(msg)),
+  error:   (msg) => console.error(chalk.red('✖'), chalk.reset(msg)),
+  dim:     (msg) => console.log(chalk.dim(msg)),
+  header:  (msg) => console.log('\n' + chalk.bold.cyan(msg) + '\n'),
+};
+
+export function spinner(text) {
+  return ora({ text, color: 'cyan' });
+}