hsync-cli 1.0.0

package/src/commands/transfer.ts

@@ -0,0 +1,220 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../utils/config';
+import { OverwritePrompter } from '../utils/prompts';
+import { RemoteClient } from '../../../sync-engine/src/RemoteClient';
+
+interface LocalFile {
+  relativePath: string;
+  absolutePath: string;
+  hash: string;
+  size: number;
+}
+
+async function hashFile(absolutePath: string): Promise<string> {
+  const content = await fs.readFile(absolutePath);
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+async function scanLocalPath(targetPath: string, rootDir: string): Promise<LocalFile[]> {
+  const stat = await fs.stat(targetPath);
+  if (stat.isFile()) {
+    const hash = await hashFile(targetPath);
+    return [{
+      relativePath: path.basename(targetPath),
+      absolutePath: targetPath,
+      hash: hash,
+      size: stat.size,
+    }];
+  }
+
+  const results: LocalFile[] = [];
+  async function recurse(currentPath: string) {
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        await recurse(fullPath);
+      } else if (entry.isFile()) {
+        const fileStat = await fs.stat(fullPath);
+        const hash = await hashFile(fullPath);
+        results.push({
+          relativePath: path.relative(rootDir, fullPath),
+          absolutePath: fullPath,
+          hash: hash,
+          size: fileStat.size,
+        });
+      }
+    }
+  }
+
+  await recurse(targetPath);
+  return results;
+}
+
+function parseRemoteTarget(target: string): { slug: string; remotePath: string } {
+  const parts = target.split(':');
+  const slug = parts[0];
+  const remotePath = (parts.slice(1).join(':') || '').replace(/^\/+|\/+$/g, '');
+  return { slug: slug, remotePath: remotePath };
+}
+
+export async function push(localPath: string, remoteTarget: string, options: { yes?: boolean }): Promise<void> {
+  const forceYes = options.yes || false;
+
+  try {
+    const config = await loadConfig();
+    const serverUrl = config.serverUrl;
+    const apiKey = config.apiKey;
+
+    if (!serverUrl || !apiKey) {
+      console.error(chalk.red('Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login'));
+      process.exit(1);
+    }
+
+    const remote = parseRemoteTarget(remoteTarget);
+    const resolvedLocalPath = path.resolve(localPath);
+
+    // Verify local path exists
+    try {
+      await fs.access(resolvedLocalPath);
+    } catch {
+      console.error(chalk.red(`Error: Local path "${localPath}" does not exist.`));
+      process.exit(1);
+    }
+
+    const spinner = ora('Scanning local files...').start();
+    const localFiles = await scanLocalPath(resolvedLocalPath, resolvedLocalPath);
+    spinner.text = 'Fetching remote file tree...';
+
+    const remoteClient = new RemoteClient(serverUrl, apiKey);
+    const remoteFiles = await remoteClient.getTree(remote.slug, remote.remotePath);
+    spinner.stop();
+
+    console.log(chalk.cyan(`Found ${localFiles.length} local files, ${remoteFiles.length} remote files.`));
+
+    const prompter = new OverwritePrompter(forceYes);
+    let pushCount = 0;
+    let skipCount = 0;
+
+    for (const localFile of localFiles) {
+      const remoteFile = remoteFiles.find((f) => f.path === localFile.relativePath);
+      const destinationPath = remote.remotePath
+        ? `${remote.remotePath}/${localFile.relativePath}`
+        : localFile.relativePath;
+
+      let shouldUpload = false;
+
+      if (!remoteFile) {
+        // New file
+        shouldUpload = true;
+      } else if (remoteFile.hash !== localFile.hash) {
+        // Conflict - content differs
+        const confirm = await prompter.shouldOverwrite(localFile.relativePath);
+        if (confirm) {
+          shouldUpload = true;
+        } else {
+          skipCount++;
+        }
+      } else {
+        // Identical hashes
+        skipCount++;
+      }
+
+      if (shouldUpload) {
+        const fileSpinner = ora(`Pushing ${localFile.relativePath}...`).start();
+        try {
+          await remoteClient.uploadFile(remote.slug, destinationPath, localFile.absolutePath);
+          fileSpinner.succeed(chalk.green(`Pushed ${localFile.relativePath}`));
+          pushCount++;
+        } catch (uploadErr: any) {
+          fileSpinner.fail(chalk.red(`Failed to push ${localFile.relativePath}: ${uploadErr.message}`));
+        }
+      }
+    }
+
+    console.log(chalk.green(`\n✔ Push complete. Pushed: ${pushCount}, Skipped: ${skipCount}`));
+  } catch (err: any) {
+    console.error(chalk.red(`Error: Push failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function pull(remoteTarget: string, localPath: string, options: { yes?: boolean }): Promise<void> {
+  const forceYes = options.yes || false;
+
+  try {
+    const config = await loadConfig();
+    const serverUrl = config.serverUrl;
+    const apiKey = config.apiKey;
+
+    if (!serverUrl || !apiKey) {
+      console.error(chalk.red('Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login'));
+      process.exit(1);
+    }
+
+    const remote = parseRemoteTarget(remoteTarget);
+    const resolvedLocalPath = path.resolve(localPath);
+
+    const spinner = ora('Fetching remote file tree...').start();
+    const remoteClient = new RemoteClient(serverUrl, apiKey);
+    const remoteFiles = await remoteClient.getTree(remote.slug, remote.remotePath);
+    spinner.text = 'Scanning local files...';
+
+    // Verify local path exists or create it
+    await fs.mkdir(resolvedLocalPath, { recursive: true });
+    const localFiles = await scanLocalPath(resolvedLocalPath, resolvedLocalPath);
+    spinner.stop();
+
+    console.log(chalk.cyan(`Found ${remoteFiles.length} remote files, ${localFiles.length} local files.`));
+
+    const prompter = new OverwritePrompter(forceYes);
+    let pullCount = 0;
+    let skipCount = 0;
+
+    for (const remoteFile of remoteFiles) {
+      const localFile = localFiles.find((f) => f.relativePath === remoteFile.path);
+      const localDestPath = path.join(resolvedLocalPath, remoteFile.path);
+      const sourcePath = remote.remotePath
+        ? `${remote.remotePath}/${remoteFile.path}`
+        : remoteFile.path;
+
+      let shouldDownload = false;
+
+      if (!localFile) {
+        // New remote file
+        shouldDownload = true;
+      } else if (localFile.hash !== remoteFile.hash) {
+        // Conflict - content differs
+        const confirm = await prompter.shouldOverwrite(remoteFile.path);
+        if (confirm) {
+          shouldDownload = true;
+        } else {
+          skipCount++;
+        }
+      } else {
+        // Identical hashes
+        skipCount++;
+      }
+
+      if (shouldDownload) {
+        const fileSpinner = ora(`Pulling ${remoteFile.path}...`).start();
+        try {
+          await remoteClient.downloadFile(remote.slug, sourcePath, localDestPath);
+          fileSpinner.succeed(chalk.green(`Pulled ${remoteFile.path}`));
+          pullCount++;
+        } catch (downloadErr: any) {
+          fileSpinner.fail(chalk.red(`Failed to pull ${remoteFile.path}: ${downloadErr.message}`));
+        }
+      }
+    }
+
+    console.log(chalk.green(`\n✔ Pull complete. Pulled: ${pullCount}, Skipped: ${skipCount}`));
+  } catch (err: any) {
+    console.error(chalk.red(`Error: Pull failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import { setServer, login, showMe, logout } from './commands/auth';
+import { listBuckets, createBucket, deleteBucket } from './commands/bucket';
+import { push, pull } from './commands/transfer';
+import { addSyncJob, listSyncJobs, removeSyncJob, startSyncScheduler } from './commands/sync';
+
+const program = new Command();
+
+program
+  .name('hsync')
+  .description('hsync CLI - Premium cross-device file synchronization client')
+  .version('1.0.0');
+
+// === Auth Commands ===
+const configCmd = program.command('config').description('Configure CLI settings');
+configCmd
+  .command('set-server <url>')
+  .description('Set target API server URL')
+  .action(async (url) => {
+    await setServer(url);
+  });
+
+program
+  .command('login')
+  .description('Authenticate and register local API Key')
+  .option('-k, --api-key <key>', 'Skip interactive prompts and login directly using a pre-generated API Key')
+  .action(async (options) => {
+    await login(options);
+  });
+
+program
+  .command('me')
+  .description('Show profile details of currently authenticated account')
+  .action(async () => {
+    await showMe();
+  });
+
+program
+  .command('logout')
+  .description('De-authenticate and remove local API Key')
+  .action(async () => {
+    await logout();
+  });
+
+// === Bucket Commands ===
+const bucketCmd = program.command('bucket').description('Manage remote storage buckets');
+
+bucketCmd
+  .command('list')
+  .description('List all storage buckets registered on your account')
+  .action(async () => {
+    await listBuckets();
+  });
+
+bucketCmd
+  .command('create <name> <slug>')
+  .description('Create a new storage bucket')
+  .requiredOption('-p, --provider <local|s3>', 'Storage provider type ("local" or "s3")')
+  .option('-r, --rootPath <path>', 'Physical folder path on host (required for local provider)')
+  .option('-b, --bucket <name>', 'S3 bucket name (required for s3 provider)')
+  .action(async (name, slug, options) => {
+    await createBucket(name, slug, options);
+  });
+
+bucketCmd
+  .command('delete <slug>')
+  .description('Permanently delete a storage bucket')
+  .action(async (slug) => {
+    await deleteBucket(slug);
+  });
+
+// === Transfer Commands ===
+program
+  .command('push <localPath> <remoteTarget>')
+  .description('Upload folder or file to a remote bucket')
+  .option('-y, --yes', 'Automatically overwrite conflicts without interactive prompts')
+  .action(async (localPath, remoteTarget, options) => {
+    await push(localPath, remoteTarget, options);
+  });
+
+program
+  .command('pull <remoteTarget> <localPath>')
+  .description('Download folder or file from a remote bucket')
+  .option('-y, --yes', 'Automatically overwrite conflicts without interactive prompts')
+  .action(async (remoteTarget, localPath, options) => {
+    await pull(remoteTarget, localPath, options);
+  });
+
+// === Sync Scheduler Commands ===
+const syncCmd = program.command('sync').description('Manage background synchronization schedules');
+
+syncCmd
+  .command('add <localPath> <remoteTarget>')
+  .description('Register a new persistent sync job profile')
+  .requiredOption('-n, --name <jobName>', 'Unique identifier label for the sync job')
+  .requiredOption('-d, --direction <push|pull|bidirectional>', 'Sync transfer direction mapping')
+  .requiredOption('-s, --strategy <local-wins|server-wins|newer-wins>', 'Conflict resolution strategy rules')
+  .option('-i, --interval <seconds>', 'Synchronization scheduling delay frequency in seconds', '10')
+  .option('--no-conflict-copy', 'Disable keeping backup copies (.conflict-YYYY-MM-DD) on conflict resolutions')
+  .action(async (localPath, remoteTarget, options) => {
+    await addSyncJob(localPath, remoteTarget, options);
+  });
+
+syncCmd
+  .command('list')
+  .description('List all registered local sync profiles')
+  .action(async () => {
+    await listSyncJobs();
+  });
+
+syncCmd
+  .command('remove <name>')
+  .description('Remove a registered local sync job')
+  .action(async (name) => {
+    await removeSyncJob(name);
+  });
+
+syncCmd
+  .command('start [name]')
+  .description('Start interval synchronization scheduler service')
+  .action(async (name) => {
+    await startSyncScheduler(name);
+  });
+
+program.parse(process.argv);

package/src/types.ts

@@ -0,0 +1,7 @@
+import type { SyncJob } from '@file-sync/sync-engine';
+
+export interface CliConfig {
+  serverUrl?: string;
+  apiKey?: string;
+  syncJobs?: SyncJob[];
+}

package/src/utils/client.ts

@@ -0,0 +1,24 @@
+import axios from 'axios';
+import type { AxiosInstance } from 'axios';
+import { loadConfig } from './config';
+
+export async function getHttpClient(): Promise<AxiosInstance> {
+  const config = await loadConfig();
+  const serverUrl = config.serverUrl;
+  const apiKey = config.apiKey;
+
+  if (!serverUrl) {
+    throw new Error('Server URL is not set. Please run: hsync config set-server <url>');
+  }
+
+  const headers: Record<string, string> = {};
+  if (apiKey) {
+    headers['X-API-Key'] = apiKey;
+  }
+
+  return axios.create({
+    baseURL: serverUrl,
+    headers: headers,
+    validateStatus: (status) => status >= 200 && status < 300,
+  });
+}

package/src/utils/config.ts

@@ -0,0 +1,25 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import type { CliConfig } from '../types';
+
+const configDir = path.join(os.homedir(), '.hsync');
+const configPath = path.join(configDir, 'config.json');
+
+export async function loadConfig(): Promise<CliConfig> {
+  try {
+    const raw = await fs.readFile(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.syncJobs) {
+      parsed.syncJobs = [];
+    }
+    return parsed;
+  } catch (err) {
+    return { syncJobs: [] };
+  }
+}
+
+export async function saveConfig(config: CliConfig): Promise<void> {
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}

package/src/utils/prompts.ts

@@ -0,0 +1,51 @@
+import inquirer from 'inquirer';
+
+export class OverwritePrompter {
+  private overrideDecision: 'overwrite-all' | 'skip-all' | null = null;
+  private forceYes: boolean;
+
+  constructor(forceYes: boolean = false) {
+    this.forceYes = forceYes;
+  }
+
+  async shouldOverwrite(filePath: string): Promise<boolean> {
+    if (this.forceYes || this.overrideDecision === 'overwrite-all') {
+      return true;
+    }
+    if (this.overrideDecision === 'skip-all') {
+      return false;
+    }
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'decision',
+        message: `Conflict detected on "${filePath}". Local and remote content differ. How do you want to proceed?`,
+        choices: [
+          { name: 'Overwrite', value: 'overwrite' },
+          { name: 'Skip', value: 'skip' },
+          { name: 'Overwrite All', value: 'overwrite-all' },
+          { name: 'Skip All', value: 'skip-all' },
+        ],
+      },
+    ]);
+
+    const choice = answer.decision;
+    if (choice === 'overwrite') {
+      return true;
+    }
+    if (choice === 'skip') {
+      return false;
+    }
+    if (choice === 'overwrite-all') {
+      this.overrideDecision = 'overwrite-all';
+      return true;
+    }
+    if (choice === 'skip-all') {
+      this.overrideDecision = 'skip-all';
+      return false;
+    }
+
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}