cloudsync-cli 2026.7.1

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "cloudsync-cli",
+  "version": "2026.7.1",
+  "description": "An open-source, Git-like version control CLI for secure cloud-to-local synchronization via encrypted SSH tunnels",
+  "type": "module",
+  "main": "./bin/cloudsync.js",
+  "bin": {
+    "cloudsync": "./bin/cloudsync.js"
+  },
+  "scripts": {
+    "start": "node bin/cloudsync.js",
+    "dev": "node --watch bin/cloudsync.js",
+    "test": "node test.js",
+    "lint": "eslint src/ || true",
+    "lint:fix": "eslint src/ --fix || true",
+    "format": "prettier --write \"**/*.js\" || true",
+    "format:check": "prettier --check \"**/*.js\" || true",
+    "build": "node scripts/build.mjs",
+    "pkg:linux": "pkg bin/cloudsync.js -t node20-linux-x64 -o dist/cloudsync-linux",
+    "pkg:macos": "pkg bin/cloudsync.js -t node20-macos-x64 -o dist/cloudsync-macos",
+    "pkg:win": "pkg bin/cloudsync.js -t node20-win-x64 -o dist/cloudsync-win.exe",
+    "pkg:all": "npm run pkg:linux && npm run pkg:macos && npm run pkg:win",
+    "postinstall": "echo 'CloudSync-CLI installed successfully!'",
+    "build:binary": "node scripts/build.mjs && pkg dist/bundle.cjs -t node22-linux-x64 -o dist/cloudsync"
+  },
+  "keywords": [
+    "cli",
+    "sync",
+    "ssh",
+    "sftp",
+    "rsync",
+    "cloud",
+    "version-control",
+    "git",
+    "file-transfer",
+    "encryption",
+    "devops",
+    "deployment",
+    "configuration",
+    "environment",
+    "dotenv",
+    "secure",
+    "cloud-sync",
+    "synchronization"
+  ],
+  "author": {
+    "name": "CloudSync Team",
+    "email": "team@cloudsync.dev",
+    "url": "https://github.com/Tech4File"
+  },
+  "contributors": [
+    {
+      "name": "CloudSync Contributors",
+      "url": "https://github.com/Tech4File/cloudsync-cli/graphs/contributors"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tech4File/cloudsync-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Tech4File/cloudsync-cli/issues"
+  },
+  "homepage": "https://github.com/Tech4File/cloudsync-cli#readme",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/Tech4File"
+  },
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "diff-match-patch": "^1.0.5",
+    "figlet": "^1.11.0",
+    "ssh2": "^1.15.0",
+    "uuid": "^14.0.1"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.1",
+    "eslint": "^8.54.0",
+    "pkg": "^5.8.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "x86",
+    "arm64"
+  ],
+  "pkg": {
+    "assets": [
+      "src/**/*.js",
+      "package.json"
+    ],
+    "outputPath": "dist"
+  }
+}

package/src/cli/commands/clone.js

@@ -0,0 +1,103 @@
+/**
+ * clone.js - Clone a remote workspace
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+
+const cloneCommand = new Command('clone')
+  .description('📥 Clone a remote workspace to local')
+  .argument('<remote>', 'Remote workspace identifier (user@host:path)')
+  .option('--directory <path>', 'Target directory', process.cwd())
+  .option('--depth <n>', 'Clone depth (full=0)', (v) => parseInt(v, 10), 0)
+  .option('--profile <name>', 'Config profile to use', 'default')
+  .option('--verbose', 'Show detailed progress', false)
+  .action(async (remote, options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    
+    // Parse remote identifier
+    const parsed = parseRemote(remote);
+    
+    if (!parsed) {
+      console.log(chalk.red('❌ Invalid remote format. Use: user@host:path'));
+      return;
+    }
+
+    console.log(chalk.cyan('\n📥 CloudSync Clone'));
+    console.log(chalk.gray('━'.repeat(60)));
+    console.log(chalk.white(`   Remote:  ${chalk.cyan(remote)}`));
+    console.log(chalk.white(`   User:    ${chalk.cyan(parsed.user)}`));
+    console.log(chalk.white(`   Host:    ${chalk.cyan(parsed.host)}`));
+    console.log(chalk.white(`   Path:    ${chalk.cyan(parsed.path)}`));
+    console.log(chalk.gray('━'.repeat(60)));
+
+    // Create target directory
+    const targetDir = options.directory;
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+
+    if (verbose) {
+      console.log(chalk.gray(`\n   Target: ${targetDir}`));
+    }
+
+    // Simulate clone
+    console.log(chalk.cyan('\n📦 Cloning workspace...'));
+    console.log(chalk.gray('   (This would transfer files via SFTP/SCP in production)'));
+    
+    // Create local .cloudsync directory
+    const cloudsyncDir = join(targetDir, '.cloudsync');
+    mkdirSync(cloudsyncDir, { recursive: true });
+    mkdirSync(join(cloudsyncDir, 'history', 'commits'), { recursive: true });
+    mkdirSync(join(cloudsyncDir, 'history', 'diffs'), { recursive: true });
+    mkdirSync(join(cloudsyncDir, 'staging'), { recursive: true });
+    mkdirSync(join(cloudsyncDir, 'cache'), { recursive: true });
+
+    // Create config
+    const config = {
+      profiles: {
+        default: {
+          host: parsed.host,
+          user: parsed.user,
+          path: parsed.path,
+          port: 22,
+          clonedAt: new Date().toISOString()
+        }
+      },
+      settings: {
+        compression: 'zip',
+        defaultProfile: 'default'
+      }
+    };
+
+    writeFileSync(
+      join(cloudsyncDir, 'config.json'),
+      JSON.stringify(config, null, 2)
+    );
+
+    console.log(chalk.green('\n✅ Clone complete!'));
+    console.log(chalk.gray(`   Workspace: ${targetDir}`));
+    console.log(chalk.gray('━'.repeat(60)));
+    console.log(chalk.cyan('\n🚀 Next steps:'));
+    console.log(chalk.gray(`   cd ${targetDir}`));
+    console.log(chalk.gray('   cloudsync status'));
+  });
+
+function parseRemote(remote) {
+  // Format: user@host:path or host:path
+  const match = remote.match(/^(?:([^@]+)@)?([^:]+):(.+)$/);
+  
+  if (!match) return null;
+  
+  return {
+    user: match[1] || 'root',
+    host: match[2],
+    path: match[3]
+  };
+}
+
+export default cloneCommand;

package/src/cli/commands/commit.js

@@ -0,0 +1,153 @@
+/**
+ * commit.js - Commit staged changes with version control
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, createWriteStream } from 'fs';
+import { join, basename } from 'path';
+import { createHash, randomBytes } from 'crypto';
+import archiver from 'archiver';
+import { logOperation } from '../../utils/logger.js';
+import { fileURLToPath } from 'url';
+
+
+const commitCommand = new Command('commit')
+  .description('💾 Commit staged changes with version tracking')
+  .argument('[message]', 'Commit message')
+  .option('--amend', 'Amend the last commit', false)
+  .option('--no-verify', 'Skip pre-commit hooks', false)
+  .option('--verbose', 'Show detailed commit info', false)
+  .option('--dry-run', 'Preview without committing', false)
+  .action(async (message, options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    const stagingDir = join(process.cwd(), '.cloudsync', 'staging');
+    const historyDir = join(process.cwd(), '.cloudsync', 'history', 'commits');
+    const indexFile = join(stagingDir, 'index.json');
+
+    if (!existsSync(stagingDir)) {
+      console.log(chalk.red('❌ No staging area. Run: cloudsync init'));
+      return;
+    }
+
+    const stagedFiles = readdirSync(stagingDir).filter(f => f !== 'index.json');
+
+    if (stagedFiles.length === 0) {
+      console.log(chalk.yellow('⚠️ Nothing to commit. Stage some files first:'));
+      console.log(chalk.gray('   cloudsync stage <files>'));
+      return;
+    }
+
+    const commitMessage = message || 'No message provided';
+    
+    if (!commitMessage) {
+      console.log(chalk.yellow('\n⚠️ Commit cancelled - no message provided'));
+      return;
+    }
+
+    if (verbose) {
+      console.log(chalk.gray('\n📋 Commit Details:'));
+      console.log(chalk.gray(`   Message: ${commitMessage}`));
+      console.log(chalk.gray(`   Files: ${stagedFiles.length}`));
+      console.log(chalk.gray(`   Amend: ${options.amend ? 'Yes' : 'No'}`));
+      stagedFiles.forEach(f => console.log(chalk.gray(`   + ${f}`)));
+    }
+
+    if (options.dryRun) {
+      console.log(chalk.yellow('\n🔍 Dry run - commit preview:'));
+      console.log(chalk.gray(`   Message: "${commitMessage}"`));
+      console.log(chalk.gray(`   Files: ${stagedFiles.length}`));
+      return;
+    }
+
+    // Generate commit ID
+    const commitId = generateCommitId();
+    const timestamp = new Date().toISOString();
+
+    // Create commit object
+    const commit = {
+      id: commitId,
+      message: commitMessage,
+      timestamp,
+      author: { name: process.env.USER || 'user' },
+      files: stagedFiles,
+      checksum: null
+    };
+
+    // Create archive of staged files
+    const archivePath = join(historyDir, `${commitId}.zip`);
+    await createStagedArchive(stagingDir, stagedFiles, archivePath);
+
+    // Save commit metadata
+    mkdirSync(historyDir, { recursive: true });
+    writeFileSync(join(historyDir, `${commitId}.json`), JSON.stringify(commit, null, 2));
+
+    // Update history index
+    const indexPath = join(process.cwd(), '.cloudsync', 'history', 'index.json');
+    let history = [];
+    if (existsSync(indexPath)) {
+      history = JSON.parse(readFileSync(indexPath, 'utf8'));
+    }
+
+    if (options.amend && history.length > 0) {
+      // Replace last commit
+      const lastCommit = history[0];
+      const lastCommitFile = join(historyDir, `${lastCommit.id}.json`);
+      if (existsSync(lastCommitFile)) {
+        unlinkSync(lastCommitFile);
+      }
+      history.shift();
+      console.log(chalk.gray('\n   Amending previous commit...'));
+    }
+
+    history.unshift({
+      id: commitId,
+      timestamp,
+      message: commitMessage
+    });
+    writeFileSync(indexPath, JSON.stringify(history, null, 2));
+
+    // Clear staging area
+    stagedFiles.forEach(f => {
+      unlinkSync(join(stagingDir, f));
+    });
+    if (existsSync(indexFile)) {
+      unlinkSync(indexFile);
+    }
+
+    // Display commit info
+    logOperation('commit', `Committed: ${commitMessage}`, { files: stagedFiles, commitId });
+    console.log(chalk.green('\n✅ Committed successfully!'));
+    console.log(chalk.gray('━'.repeat(60)));
+    console.log(chalk.cyan(`   Commit ID: ${commitId}`));
+    console.log(chalk.white(`   Message: ${commitMessage}`));
+    console.log(chalk.gray(`   Files: ${stagedFiles.length}`));
+    console.log(chalk.gray(`   Time: ${new Date(timestamp).toLocaleString()}`));
+    console.log(chalk.gray('━'.repeat(60)));
+    console.log(chalk.cyan('\n   Push with: ') + chalk.white('cloudsync upload'));
+  });
+
+function generateCommitId() {
+  const timestamp = Date.now().toString(36);
+  const random = randomBytes(2).toString('hex');
+  return `${timestamp}-${random}`;
+}
+
+async function createStagedArchive(stagingDir, files, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = createWriteStream(outputPath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+
+    output.on('close', () => resolve());
+    archive.on('error', reject);
+    archive.pipe(output);
+
+    files.forEach(f => {
+      archive.file(join(stagingDir, f), { name: f });
+    });
+
+    archive.finalize();
+  });
+}
+
+export default commitCommand;

package/src/cli/commands/config.js

@@ -0,0 +1,188 @@
+/**
+ * config.js - Manage CloudSync configuration
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const configCommand = new Command('config')
+  .description('⚙️ Manage CloudSync configuration')
+  .argument('[key]', 'Configuration key')
+  .argument('[value]', 'Configuration value')
+  .option('--global', 'Use global config', false)
+  .option('--list', 'List all configuration', false)
+  .option('--unset <key>', 'Remove a configuration key')
+  .option('--verbose', 'Show detailed info', false)
+  .action(async (key, value, options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    
+    const configDir = options.global 
+      ? join(homedir(), '.cloudsync')
+      : join(process.cwd(), '.cloudsync');
+    
+    const configPath = join(configDir, 'config.json');
+
+    // Ensure config directory exists
+    if (!existsSync(configDir)) {
+      if (key || value) {
+        console.log(chalk.yellow('⚠️ No config found. Run: cloudsync init'));
+        return;
+      }
+    }
+
+    // Load or create config
+    let config = {};
+    if (existsSync(configPath)) {
+      try {
+        config = JSON.parse(readFileSync(configPath, 'utf8'));
+      } catch (e) {
+        config = {};
+      }
+    }
+
+    if (verbose) {
+      console.log(chalk.gray(`\n📋 Config path: ${configPath}`));
+    }
+
+    // List all config
+    if (options.list) {
+      console.log(chalk.cyan('\n⚙️ CloudSync Configuration'));
+      console.log(chalk.gray('━'.repeat(50)));
+      displayConfig(config, verbose);
+      return;
+    }
+
+    // Unset key
+    if (options.unset) {
+      const keys = options.unset.split('.');
+      unsetNestedKey(config, keys);
+      mkdirSync(configDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(chalk.green(`\n✅ Unset: ${options.unset}`));
+      return;
+    }
+
+    // Get value
+    if (key && !value) {
+      const keys = key.split('.');
+      const val = getNestedValue(config, keys);
+      
+      if (val !== undefined) {
+        console.log(chalk.cyan(`${key} = `) + chalk.white(JSON.stringify(val)));
+      } else {
+        console.log(chalk.yellow(`\n⚠️ Key not found: ${key}`));
+      }
+      return;
+    }
+
+    // Set value
+    if (key && value) {
+      const keys = key.split('.');
+      setNestedValue(config, keys, parseValue(value));
+      mkdirSync(configDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(chalk.green('\n✅ Configuration updated:'));
+      console.log(chalk.cyan(`   ${key} = `) + chalk.white(JSON.stringify(parseValue(value))));
+      return;
+    }
+
+    // Show usage
+    console.log(chalk.cyan('\n⚙️ CloudSync Config'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(chalk.gray('Usage:'));
+    console.log(chalk.gray('   cloudsync config                    # Show all config'));
+    console.log(chalk.gray('   cloudsync config --list             # List all settings'));
+    console.log(chalk.gray('   cloudsync config <key>              # Get value'));
+    console.log(chalk.gray('   cloudsync config <key> <value>      # Set value'));
+    console.log(chalk.gray('   cloudsync config --unset <key>     # Remove key'));
+    console.log(chalk.gray('   cloudsync config --global          # Use global config'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(chalk.gray('\n📁 Current config:'));
+    displayConfig(config, verbose);
+  });
+
+function displayConfig(config, verbose) {
+  if (verbose) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+
+  const settings = config.settings || {};
+  const profiles = config.profiles || {};
+
+  console.log(chalk.gray('\n   Settings:'));
+  if (Object.keys(settings).length === 0) {
+    console.log(chalk.yellow('      No settings configured'));
+  } else {
+    Object.entries(settings).forEach(([k, v]) => {
+      console.log(chalk.gray(`      ${k}: `) + chalk.white(JSON.stringify(v)));
+    });
+  }
+
+  console.log(chalk.gray('\n   Profiles:'));
+  if (Object.keys(profiles).length === 0) {
+    console.log(chalk.yellow('      No profiles configured'));
+  } else {
+    Object.entries(profiles).forEach(([name, p]) => {
+      console.log(chalk.cyan(`      [${name}]`));
+      console.log(chalk.gray(`         host: ${p.host || 'N/A'}`));
+      console.log(chalk.gray(`         user: ${p.user || 'N/A'}`));
+      console.log(chalk.gray(`         port: ${p.port || 22}`));
+    });
+  }
+}
+
+function getNestedValue(obj, keys) {
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === 'object' && key in current) {
+      current = current[key];
+    } else {
+      return undefined;
+    }
+  }
+  return current;
+}
+
+function setNestedValue(obj, keys, value) {
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
+function unsetNestedKey(obj, keys) {
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (current && typeof current === 'object' && keys[i] in current) {
+      current = current[keys[i]];
+    } else {
+      return;
+    }
+  }
+  const lastKey = keys[keys.length - 1];
+  if (current && typeof current === 'object' && lastKey in current) {
+    delete current[lastKey];
+  }
+}
+
+function parseValue(value) {
+  // Try to parse as JSON
+  try {
+    const parsed = JSON.parse(value);
+    return parsed;
+  } catch {
+    // Return as string
+    return value;
+  }
+}
+
+export default configCommand;

package/src/cli/commands/diff.js

@@ -0,0 +1,122 @@
+/**
+ * diff.js - Compare file versions
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import DiffMatchPatch from 'diff-match-patch';
+
+
+const diffCommand = new Command('diff')
+  .description('📊 Compare file versions')
+  .argument('[versions...]', 'Version IDs to compare (default: last 2)')
+  .option('--stat', 'Show change statistics only', false)
+  .option('--verbose', 'Show detailed diff output', false)
+  .option('--file <path>', 'Compare specific file across versions')
+  .action(async (versions, options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    const indexFile = join(process.cwd(), '.cloudsync', 'history', 'index.json');
+    
+    if (!existsSync(indexFile)) {
+      console.log(chalk.red('❌ No history found'));
+      return;
+    }
+
+    const history = JSON.parse(readFileSync(indexFile, 'utf8'));
+    
+    // Default to last 2 versions
+    if (versions.length === 0) {
+      versions = [history[1]?.id, history[0]?.id].filter(Boolean);
+    }
+
+    if (versions.length < 2) {
+      console.log(chalk.yellow('⚠️ Need at least 2 versions to compare'));
+      return;
+    }
+
+    console.log(chalk.cyan('\n📊 CloudSync Diff'));
+    console.log(chalk.gray('━'.repeat(60)));
+    console.log(chalk.white(`   Comparing: ${chalk.cyan(versions[0])} → ${chalk.cyan(versions[1])}`));
+    if (options.file) console.log(chalk.white(`   File: ${chalk.cyan(options.file)}`));
+    console.log(chalk.gray('━'.repeat(60)));
+
+    // Load commits
+    const commitsDir = join(process.cwd(), '.cloudsync', 'history', 'commits');
+    const commits = versions.map(v => {
+      const file = join(commitsDir, `${v}.json`);
+      if (existsSync(file)) {
+        return JSON.parse(readFileSync(file, 'utf8'));
+      }
+      return null;
+    }).filter(Boolean);
+
+    if (commits.length < 2) {
+      console.log(chalk.red('❌ Could not load one or more versions'));
+      return;
+    }
+
+    // Calculate diff statistics
+    const stats = {
+      added: 0,
+      removed: 0,
+      modified: 0
+    };
+
+    // Files in first version
+    const oldFiles = new Set(commits[0].files || []);
+    // Files in second version
+    const newFiles = new Set(commits[1].files || []);
+
+    // Find added files
+    for (const file of newFiles) {
+      if (!oldFiles.has(file)) {
+        stats.added++;
+        if (verbose) console.log(chalk.green(`+ ${file} (new)`));
+      }
+    }
+
+    // Find removed files
+    for (const file of oldFiles) {
+      if (!newFiles.has(file)) {
+        stats.removed++;
+        if (verbose) console.log(chalk.red(`- ${file} (removed)`));
+      }
+    }
+
+    // Find modified files
+    for (const file of oldFiles) {
+      if (newFiles.has(file)) {
+        stats.modified++;
+        if (verbose) console.log(chalk.yellow(`~ ${file} (modified)`));
+      }
+    }
+
+    if (options.stat) {
+      console.log(chalk.cyan('\n📈 Change Statistics:'));
+      console.log(chalk.gray('─'.repeat(40)));
+      console.log(chalk.green(`   Added:     ${stats.added}`));
+      console.log(chalk.red(`   Removed:   ${stats.removed}`));
+      console.log(chalk.yellow(`   Modified:  ${stats.modified}`));
+      console.log(chalk.gray('─'.repeat(40)));
+    }
+
+    // Summary
+    console.log(chalk.cyan('\n📋 Summary:'));
+    console.log(chalk.gray('━'.repeat(60)));
+    const totalChanges = stats.added + stats.removed + stats.modified;
+    console.log(chalk.white(`   Total changes: ${chalk.cyan(totalChanges)}`));
+    console.log(chalk.gray(`   Commits compared: ${commits.length}`));
+    
+    if (totalChanges === 0) {
+      console.log(chalk.green('   Status: No differences detected'));
+    } else {
+      const changePercent = ((totalChanges / (commits[1].files?.length || 1)) * 100).toFixed(1);
+      console.log(chalk.white(`   Change rate: ${chalk.cyan(changePercent + '%')}`));
+    }
+    console.log(chalk.gray('━'.repeat(60)));
+  });
+
+export default diffCommand;