@any-sync/cli 0.2.0

package/bin/auth.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+
+const { checkAuth } = require('../lib');
+
+try {
+  const token = checkAuth();
+  process.stdout.write(token + '\n');
+} catch (err) {
+  process.stderr.write(err.message + '\n');
+  process.exit(1);
+}

package/bin/cli.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pkg = require('../package.json');
+
+const COMMANDS = {
+  pull: 'Pull files from GitHub',
+  push: 'Push local changes to GitHub',
+  status: 'Show sync status',
+  reset: 'Remove config and lockfile',
+  auth: 'Check GitHub authentication',
+  init: 'Create config file (use --preset for defaults)',
+};
+
+function usage() {
+  process.stdout.write(`any-sync v${pkg.version} — bidirectional GitHub file sync\n\n`);
+  process.stdout.write('Usage: any-sync <command> [options]\n\n');
+  process.stdout.write('Commands:\n');
+  for (const [cmd, desc] of Object.entries(COMMANDS)) {
+    process.stdout.write(`  ${cmd.padEnd(10)} ${desc}\n`);
+  }
+  process.stdout.write('\nRun any-sync <command> --help for command-specific usage.\n');
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command || command === '--help' || command === '-h') {
+  usage();
+  process.exit(0);
+}
+
+if (command === '--version' || command === '-v') {
+  process.stdout.write(`${pkg.version}\n`);
+  process.exit(0);
+}
+
+if (!COMMANDS[command]) {
+  process.stderr.write(`Unknown command: ${command}\n`);
+  process.stderr.write('Run any-sync --help for available commands.\n');
+  process.exit(1);
+}
+
+const lib = require('../lib');
+const cmdArgs = args.slice(1);
+
+try {
+  switch (command) {
+    case 'pull': {
+      const configPath = cmdArgs[0];
+      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
+      if (!configPath || cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync pull <config-path> [lockfile-path]\n');
+        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      }
+      const result = lib.pull(configPath, lockfilePath);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      break;
+    }
+
+    case 'push': {
+      const configPath = cmdArgs[0];
+      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
+      if (!configPath || cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync push <config-path> [lockfile-path]\n');
+        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      }
+      const result = lib.push(configPath, lockfilePath);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      break;
+    }
+
+    case 'status': {
+      const configPath = cmdArgs[0];
+      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
+      if (!configPath || cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync status <config-path> [lockfile-path]\n');
+        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      }
+      const result = lib.status(configPath, lockfilePath);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      break;
+    }
+
+    case 'reset': {
+      const configPath = cmdArgs[0];
+      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
+      if (!configPath || cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync reset <config-path> [lockfile-path]\n');
+        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      }
+      const result = lib.reset(configPath, lockfilePath);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      break;
+    }
+
+    case 'auth': {
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync auth\n');
+        process.exit(0);
+      }
+      const token = lib.checkAuth();
+      process.stdout.write(token + '\n');
+      break;
+    }
+
+    case 'init': {
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write(
+          'Usage: any-sync init <config-path> <repo> [branch] [--preset claude|openclaw]\n',
+        );
+        process.exit(0);
+      }
+      // Parse --preset flag
+      const presetIdx = cmdArgs.indexOf('--preset');
+      let preset = null;
+      const positional = [];
+      for (let i = 0; i < cmdArgs.length; i++) {
+        if (cmdArgs[i] === '--preset') {
+          preset = cmdArgs[++i];
+        } else {
+          positional.push(cmdArgs[i]);
+        }
+      }
+      const configPath = positional[0];
+      const repo = positional[1];
+      const branch = positional[2] || 'main';
+      if (!configPath || !repo) {
+        process.stderr.write(
+          'Usage: any-sync init <config-path> <repo> [branch] [--preset claude|openclaw]\n',
+        );
+        process.exit(1);
+      }
+      let mappings;
+      if (preset) {
+        mappings = lib.getPresetMappings(preset);
+        if (!mappings) {
+          process.stderr.write(`Unknown preset: ${preset}. Available: claude, openclaw\n`);
+          process.exit(1);
+        }
+      } else {
+        process.stderr.write('Error: --preset is required. Available: claude, openclaw\n');
+        process.exit(1);
+      }
+      const result = lib.init(configPath, repo, branch, mappings);
+      process.stdout.write(result + '\n');
+      break;
+    }
+  }
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}

package/bin/pull.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const { pull } = require('../lib');
+
+const configPath = process.argv[2];
+const lockfilePath = process.argv[3] || '.any-sync.lock';
+
+if (!configPath) {
+  process.stderr.write('Usage: pull.js <config-path> [lockfile-path]\n');
+  process.exit(1);
+}
+
+try {
+  const result = pull(configPath, lockfilePath);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}

package/bin/push.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const { push } = require('../lib');
+
+const configPath = process.argv[2];
+const lockfilePath = process.argv[3] || '.any-sync.lock';
+
+if (!configPath) {
+  process.stderr.write('Usage: push.js <config-path> [lockfile-path]\n');
+  process.exit(1);
+}
+
+try {
+  const result = push(configPath, lockfilePath);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}

package/bin/reset.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const { reset } = require('../lib');
+
+const configPath = process.argv[2];
+const lockfilePath = process.argv[3] || '.any-sync.lock';
+
+if (!configPath) {
+  process.stderr.write('Usage: reset.js <config-path> [lockfile-path]\n');
+  process.exit(1);
+}
+
+try {
+  const result = reset(configPath, lockfilePath);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}

package/bin/status.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const { status } = require('../lib');
+
+const configPath = process.argv[2];
+const lockfilePath = process.argv[3] || '.any-sync.lock';
+
+if (!configPath) {
+  process.stderr.write('Usage: status.js <config-path> [lockfile-path]\n');
+  process.exit(1);
+}
+
+try {
+  const result = status(configPath, lockfilePath);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+} catch (err) {
+  process.stderr.write('Error: ' + err.message + '\n');
+  process.exit(1);
+}

package/lib/auth.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+/**
+ * Check GitHub authentication.
+ * Returns the auth token string.
+ * Throws if no auth available.
+ */
+function checkAuth() {
+  // 1. Check GITHUB_TOKEN env var
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+
+  // 2. Try gh CLI auth
+  try {
+    const token = execFileSync('gh', ['auth', 'token'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (token) return token;
+  } catch {
+    // Fall through
+  }
+
+  // 3. No auth available
+  throw new Error(
+    'No GitHub authentication found.\n\n' +
+      'Set up authentication using one of:\n' +
+      '  1. Set GITHUB_TOKEN environment variable\n' +
+      "  2. Run 'gh auth login' to authenticate with GitHub CLI"
+  );
+}
+
+module.exports = { checkAuth };

package/lib/config.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Load and validate a config file.
+ * Returns the parsed config object.
+ */
+function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    throw new Error('Config file not found: ' + configPath);
+  }
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (!Array.isArray(config.mappings)) {
+    throw new Error('Invalid config: missing "mappings" array');
+  }
+  return config;
+}
+
+/**
+ * Find config file. Checks $HOME/.any-sync.json first, then cwd.
+ * Returns the path or null.
+ */
+function findConfig() {
+  const home = path.join(os.homedir(), '.any-sync.json');
+  if (fs.existsSync(home)) return home;
+  const local = path.resolve('.any-sync.json');
+  if (fs.existsSync(local)) return local;
+  return null;
+}
+
+/**
+ * Expand ~ to home directory in a path.
+ */
+function expandTilde(p) {
+  if (p.startsWith('~/') || p === '~') {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+
+/**
+ * Parse a mapping entry, applying defaults and expanding paths.
+ */
+function parseMapping(m) {
+  return {
+    name: m.name,
+    repo: m.repo,
+    branch: m.branch || 'main',
+    sourcePath: (m.sourcePath || '').replace(/^\/+|\/+$/g, ''),
+    destPath: expandTilde(m.destPath),
+    include: m.include || [],
+    exclude: m.exclude || [],
+  };
+}
+
+module.exports = { loadConfig, findConfig, expandTilde, parseMapping };

package/lib/gh.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+/**
+ * Call gh api with the given arguments.
+ * For POST/PATCH with a body, pass the body string as opts.input.
+ */
+function ghApi(args, opts = {}) {
+  const options = { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 };
+  if (opts.input) {
+    options.input = opts.input;
+  }
+  return execFileSync('gh', ['api', ...args], options).trim();
+}
+
+/**
+ * Retry gh api on 5xx/network errors with exponential backoff.
+ */
+function ghApiRetry(args, opts = {}) {
+  const maxAttempts = opts.maxAttempts || 3;
+  let backoff = 1000;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return ghApi(args, opts);
+    } catch (err) {
+      const msg = (err.stderr || err.message || '').toString();
+      const isRetryable = /50[0234]|connect|timeout|network/i.test(msg);
+      if (!isRetryable || attempt === maxAttempts - 1) {
+        throw err;
+      }
+      // Synchronous sleep via Atomics
+      const buf = new SharedArrayBuffer(4);
+      Atomics.wait(new Int32Array(buf), 0, 0, backoff);
+      backoff *= 2;
+    }
+  }
+}
+
+/**
+ * Get GitHub auth token from GITHUB_TOKEN env or gh auth token.
+ */
+function getAuthToken() {
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+  try {
+    return execFileSync('gh', ['auth', 'token'], { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { ghApi, ghApiRetry, getAuthToken };

package/lib/glob.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Match a file path against a glob pattern.
+ * Supports: * (single segment), ** (multi-segment), ? (single char)
+ */
+function globMatch(pattern, filePath) {
+  const re = globToRegExp(pattern);
+  return re.test(filePath);
+}
+
+/**
+ * Convert a glob pattern to a RegExp.
+ */
+function globToRegExp(pattern) {
+  let re = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '*') {
+      if (pattern[i + 1] === '*') {
+        // ** — match zero or more path segments
+        i += 2;
+        if (pattern[i] === '/') {
+          i++; // consume trailing slash in **/
+          re += '(?:.+/)?';
+        } else {
+          re += '.*';
+        }
+      } else {
+        // * — match within a single path segment
+        re += '[^/]*';
+        i++;
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+      i++;
+    } else if (c === '.') {
+      re += '\\.';
+      i++;
+    } else if (c === '(' || c === ')' || c === '{' || c === '}' || c === '+' || c === '^' || c === '$' || c === '|' || c === '\\') {
+      re += '\\' + c;
+      i++;
+    } else {
+      re += c;
+      i++;
+    }
+  }
+  return new RegExp('^' + re + '$');
+}
+
+/**
+ * Check if a file path matches any pattern in the list.
+ */
+function matchesAny(patterns, filePath) {
+  return patterns.some(p => globMatch(p, filePath));
+}
+
+module.exports = { globMatch, matchesAny };

package/lib/hooks.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { findConfig } = require('./config');
+const { getAuthToken } = require('./gh');
+const { pull } = require('./pull');
+const { push } = require('./push');
+const { status } = require('./status');
+
+/**
+ * Auto-pull if config and auth are available.
+ * Returns the pull result, or null if skipped.
+ */
+function autoPull(lockfilePath) {
+  lockfilePath = lockfilePath || '.any-sync.lock';
+
+  const configPath = findConfig();
+  if (!configPath) return null;
+
+  const token = getAuthToken();
+  if (!token) return null;
+
+  return pull(configPath, lockfilePath);
+}
+
+/**
+ * Auto-push if config and auth are available and there are changes.
+ * Returns the push result, or null if skipped.
+ */
+function autoPush(lockfilePath) {
+  lockfilePath = lockfilePath || '.any-sync.lock';
+
+  const configPath = findConfig();
+  if (!configPath) return null;
+
+  const token = getAuthToken();
+  if (!token) return null;
+
+  const statusResult = status(configPath, lockfilePath);
+  const hasChanges = (statusResult.mappings || []).some(m => (m.changes || []).length > 0);
+  if (!hasChanges) return null;
+
+  return push(configPath, lockfilePath);
+}
+
+module.exports = { autoPull, autoPush };

package/lib/index.d.ts

@@ -0,0 +1,96 @@
+export declare class Lockfile {
+  static load(filePath: string): Lockfile;
+  save(): void;
+  getEntry(key: string): { remoteSha: string; localHash: string; syncedAt: string } | null;
+  setEntry(key: string, remoteSha: string, localHash: string): void;
+  getEntriesForMapping(name: string): Record<string, { remoteSha: string; localHash: string; syncedAt: string }>;
+  setLastSync(name: string): void;
+  getLastSync(name: string): string | null;
+}
+
+export declare function makeKey(mapping: string, relpath: string): string;
+export declare function hashFile(filePath: string): string;
+
+export declare function ghApi(args: string[], opts?: { input?: string }): string;
+export declare function ghApiRetry(args: string[], opts?: { maxAttempts?: number; input?: string }): string;
+export declare function getAuthToken(): string | null;
+
+export declare function globMatch(pattern: string, filePath: string): boolean;
+export declare function matchesAny(patterns: string[], filePath: string): boolean;
+
+export declare function loadConfig(configPath: string): { mappings: Array<Record<string, unknown>> };
+export declare function findConfig(): string | null;
+export declare function expandTilde(p: string): string;
+export declare function parseMapping(m: Record<string, unknown>): {
+  name: string;
+  repo: string;
+  branch: string;
+  sourcePath: string;
+  destPath: string;
+  include: string[];
+  exclude: string[];
+};
+
+export declare function checkAuth(): string;
+
+export declare function pull(configPath: string, lockfilePath: string): {
+  pulled: string[];
+  conflicts: string[];
+  skipped: number;
+};
+
+export declare function push(configPath: string, lockfilePath: string): {
+  pushed: string[];
+  branch: string;
+};
+
+export declare function status(configPath: string, lockfilePath: string): {
+  auth: { method: string; user: string | null };
+  config: { path: string; valid: boolean };
+  mappings: Array<{
+    name: string;
+    repo: string;
+    branch: string;
+    lastSync: string | null;
+    tracked: number;
+    changes: Array<{ file: string; type: string }>;
+  }>;
+};
+
+export declare function reset(configPath: string, lockfilePath: string): {
+  deletedConfig: boolean;
+  configPath: string;
+  deletedLockfile: boolean;
+  lockfilePath: string;
+};
+
+export declare function init(
+  configPath: string,
+  repo: string,
+  branch: string,
+  mappings: Array<{
+    name: string;
+    sourcePath: string;
+    destPath: string;
+    include?: string[];
+    exclude?: string[];
+  }>,
+): string;
+
+export declare function getPresetMappings(
+  preset: string,
+): Array<{
+  name: string;
+  sourcePath: string;
+  destPath: string;
+  include?: string[];
+  exclude?: string[];
+}> | null;
+
+export declare function autoPull(
+  lockfilePath?: string,
+): { pulled: string[]; conflicts: string[]; skipped: number } | null;
+
+export declare function autoPush(
+  lockfilePath?: string,
+): { pushed: string[]; branch: string } | null;

package/lib/index.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { Lockfile, makeKey, hashFile } = require('./lockfile');
+const { ghApi, ghApiRetry, getAuthToken } = require('./gh');
+const { globMatch, matchesAny } = require('./glob');
+const { loadConfig, findConfig, expandTilde, parseMapping } = require('./config');
+const { checkAuth } = require('./auth');
+const { pull } = require('./pull');
+const { push } = require('./push');
+const { status } = require('./status');
+const { reset } = require('./reset');
+const { init, getPresetMappings } = require('./init');
+const { autoPull, autoPush } = require('./hooks');
+
+module.exports = {
+  // Lockfile
+  Lockfile,
+  makeKey,
+  hashFile,
+  // GitHub
+  ghApi,
+  ghApiRetry,
+  getAuthToken,
+  // Glob
+  globMatch,
+  matchesAny,
+  // Config
+  loadConfig,
+  findConfig,
+  expandTilde,
+  parseMapping,
+  // Auth
+  checkAuth,
+  // Operations
+  pull,
+  push,
+  status,
+  reset,
+  init,
+  // Presets & hooks
+  getPresetMappings,
+  autoPull,
+  autoPush,
+};