hsync-cli 1.0.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "hsync-cli",
+  "version": "1.0.0",
+  "description": "hsync CLI for file sync operations",
+  "bin": {
+    "hsync": "./dist/bin.js"
+  },
+  "main": "./src/index.ts",
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile dist/hsync",
+    "build:js": "bun scripts/build-js.ts",
+    "prepublishOnly": "bun run build:js",
+    "start": "bun src/index.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@file-sync/sync-engine": "workspace:*",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "axios": "^1.6.5",
+    "inquirer": "^9.2.12",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0"
+  }
+}

package/scripts/build-js.ts

@@ -0,0 +1,32 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+async function buildJs() {
+  const entry = path.resolve(__dirname, '../src/index.ts');
+  const outfile = path.resolve(__dirname, '../dist/bin.js');
+
+  console.log('Bundling CLI into a pure JS bundle for Node...');
+  
+  // 1. Build the JavaScript bundle with Bun targeting Node
+  const result = await Bun.build({
+    entrypoints: [entry],
+    target: 'node',
+    minify: false, // Keep it readable/debuggable for NPM users
+  });
+
+  if (!result.success) {
+    console.error('Bundle failed:', result.logs);
+    process.exit(1);
+  }
+
+  const rawCode = await result.outputs[0].text();
+
+  // 2. Prepend Node shebang and write with executable permissions (0755)
+  const shebang = '#!/usr/bin/env node\n\n';
+  await fs.mkdir(path.dirname(outfile), { recursive: true });
+  await fs.writeFile(outfile, shebang + rawCode, { mode: 0o755 });
+
+  console.log(`✓ Successfully created executable JS bundle: ${outfile}`);
+}
+
+buildJs();

package/src/commands/auth.ts

@@ -0,0 +1,139 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { loadConfig, saveConfig } from '../utils/config';
+import { getHttpClient } from '../utils/client';
+import axios from 'axios';
+
+export async function setServer(url: string): Promise<void> {
+  try {
+    const config = await loadConfig();
+    config.serverUrl = url;
+    await saveConfig(config);
+    console.log(chalk.green(`✔ Server URL successfully set to: ${url}`));
+  } catch (err: any) {
+    console.error(chalk.red(`Error saving server URL: ${err.message}`));
+  }
+}
+
+export async function login(options: { apiKey?: string }): Promise<void> {
+  const apiKeyFlag = options.apiKey;
+  if (apiKeyFlag) {
+    // Headless API Key Verification
+    try {
+      const config = await loadConfig();
+      config.apiKey = apiKeyFlag;
+      await saveConfig(config);
+
+      // Verify the key immediately
+      const client = await getHttpClient();
+      const res = await client.get('/api/auth/me');
+      const email = res.data.email;
+
+      console.log(chalk.green(`✔ Successfully authenticated headlessly!`));
+      console.log(chalk.cyan(`Account Email: ${email}`));
+    } catch (err: any) {
+      // Rollback configuration on failure
+      const config = await loadConfig();
+      config.apiKey = undefined;
+      await saveConfig(config);
+      console.error(chalk.red(`Error: API Key verification failed. Make sure server is reachable and API Key is valid. (${err.message})`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Interactive Email / Password Flow
+  try {
+    const config = await loadConfig();
+    const serverUrl = config.serverUrl;
+    if (!serverUrl) {
+      console.error(chalk.red('Error: Server URL is not configured. Please run: hsync config set-server <url>'));
+      process.exit(1);
+    }
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'email',
+        message: 'Enter your email address:',
+        validate: (input) => (input.trim() !== '' ? true : 'Email cannot be empty.'),
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Enter your password:',
+        mask: '*',
+        validate: (input) => (input.trim() !== '' ? true : 'Password cannot be empty.'),
+      },
+    ]);
+
+    const email = answers.email;
+    const password = answers.password;
+
+    console.log(chalk.cyan('Authenticating with server...'));
+    const loginRes = await axios.post(
+      `${serverUrl}/api/auth/login`,
+      { email: email, password: password },
+      { validateStatus: (status) => status === 200 }
+    );
+
+    const cookies = loginRes.headers['set-cookie'];
+    if (!cookies || cookies.length === 0) {
+      throw new Error('No session cookie returned by the server.');
+    }
+    const sessionCookie = cookies[0];
+
+    console.log(chalk.cyan('Generating secure persistent API key...'));
+    const keyRes = await axios.post(
+      `${serverUrl}/api/auth/keys`,
+      { name: 'hsync CLI Key' },
+      {
+        headers: { Cookie: sessionCookie },
+        validateStatus: (status) => status === 200,
+      }
+    );
+
+    const generatedKey = keyRes.data.apiKey;
+    config.apiKey = generatedKey;
+    await saveConfig(config);
+
+    console.log(chalk.green('✔ Successfully logged in! Secure API key has been registered locally.'));
+  } catch (err: any) {
+    let message = err.message;
+    if (err.response && err.response.data && err.response.data.error) {
+      message = err.response.data.error;
+    }
+    console.error(chalk.red(`Error: Authentication failed: ${message}`));
+    process.exit(1);
+  }
+}
+
+export async function showMe(): Promise<void> {
+  try {
+    const client = await getHttpClient();
+    const res = await client.get('/api/auth/me');
+    const profile = res.data;
+
+    console.log(chalk.cyan('=== Active CLI Auth Session ==='));
+    console.log(`Email: ${profile.email}`);
+    console.log(`Role: ${profile.role}`);
+  } catch (err: any) {
+    let message = err.message;
+    if (err.response && err.response.data && err.response.data.error) {
+      message = err.response.data.error;
+    }
+    console.error(chalk.red(`Error: Failed to retrieve profile: ${message}`));
+    process.exit(1);
+  }
+}
+
+export async function logout(): Promise<void> {
+  try {
+    const config = await loadConfig();
+    config.apiKey = undefined;
+    await saveConfig(config);
+    console.log(chalk.green('✔ Successfully logged out. API key removed.'));
+  } catch (err: any) {
+    console.error(chalk.red(`Error during logout: ${err.message}`));
+  }
+}

package/src/commands/bucket.ts

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getHttpClient } from '../utils/client';
+
+export async function listBuckets(): Promise<void> {
+  try {
+    const client = await getHttpClient();
+    const res = await client.get('/api/buckets');
+    const buckets = res.data;
+
+    if (buckets.length === 0) {
+      console.log(chalk.yellow('No buckets found. Create one with: hsync bucket create <name> <slug> --provider <local|s3>'));
+      return;
+    }
+
+    console.log(chalk.cyan('\n=== Registered Storage Buckets ==='));
+    for (const b of buckets) {
+      console.log(`- ${chalk.bold(b.name)} (${chalk.cyan(b.slug)})`);
+      console.log(`  Provider: ${b.providerType}`);
+      if (b.providerType === 'local') {
+        console.log(`  Path: ${b.storageConfig.rootPath}`);
+      } else {
+        console.log(`  S3 Bucket: ${b.storageConfig.bucket}`);
+      }
+      console.log();
+    }
+  } catch (err: any) {
+    let message = err.message;
+    if (err.response && err.response.data && err.response.data.error) {
+      message = err.response.data.error;
+    }
+    console.error(chalk.red(`Error: Failed to list buckets: ${message}`));
+    process.exit(1);
+  }
+}
+
+export async function createBucket(
+  name: string,
+  slug: string,
+  options: { provider: 'local' | 's3'; rootPath?: string; bucket?: string }
+): Promise<void> {
+  try {
+    const provider = options.provider;
+    const rootPath = options.rootPath;
+    const bucket = options.bucket;
+
+    const storageConfig: Record<string, any> = {};
+    if (provider === 'local') {
+      if (!rootPath) {
+        throw new Error('--rootPath is required when using local provider.');
+      }
+      storageConfig.rootPath = rootPath;
+    } else if (provider === 's3') {
+      if (!bucket) {
+        throw new Error('--bucket is required when using s3 provider.');
+      }
+      storageConfig.bucket = bucket;
+    } else {
+      throw new Error('Invalid provider type. Must be "local" or "s3".');
+    }
+
+    const client = await getHttpClient();
+    const res = await client.post('/api/buckets', {
+      name: name,
+      slug: slug,
+      providerType: provider,
+      storageConfig: storageConfig,
+    });
+
+    console.log(chalk.green(`✔ Bucket successfully created!`));
+    console.log(`Name: ${res.data.name}`);
+    console.log(`Slug: ${res.data.slug}`);
+  } catch (err: any) {
+    let message = err.message;
+    if (err.response && err.response.data && err.response.data.error) {
+      message = err.response.data.error;
+    }
+    console.error(chalk.red(`Error: Failed to create bucket: ${message}`));
+    process.exit(1);
+  }
+}
+
+export async function deleteBucket(slug: string): Promise<void> {
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Are you absolutely sure you want to delete the bucket "${slug}" and all cached metadata? This action CANNOT be undone!`,
+        default: false,
+      },
+    ]);
+
+    if (!answers.confirm) {
+      console.log(chalk.yellow('Bucket deletion cancelled.'));
+      return;
+    }
+
+    const client = await getHttpClient();
+    await client.delete(`/api/buckets/${slug}`);
+    console.log(chalk.green(`✔ Bucket "${slug}" successfully deleted.`));
+  } catch (err: any) {
+    let message = err.message;
+    if (err.response && err.response.data && err.response.data.error) {
+      message = err.response.data.error;
+    }
+    console.error(chalk.red(`Error: Failed to delete bucket: ${message}`));
+    process.exit(1);
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,213 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, saveConfig } from '../utils/config';
+import { SyncEngine } from '@file-sync/sync-engine';
+import type { SyncJob, SyncEvent } from '@file-sync/sync-engine';
+
+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 addSyncJob(
+  localPath: string,
+  remoteTarget: string,
+  options: {
+    name: string;
+    direction: 'push' | 'pull' | 'bidirectional';
+    strategy: 'local-wins' | 'server-wins' | 'newer-wins';
+    interval?: string;
+    noConflictCopy?: boolean;
+  }
+): Promise<void> {
+  try {
+    const config = await loadConfig();
+    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 remote = parseRemoteTarget(remoteTarget);
+    const intervalSec = options.interval ? parseInt(options.interval, 10) : 10;
+    if (isNaN(intervalSec) || intervalSec <= 0) {
+      throw new Error('Interval must be a positive integer in seconds.');
+    }
+
+    // Verify unique name
+    const existing = config.syncJobs?.find((j) => j.name === options.name);
+    if (existing) {
+      throw new Error(`A sync job with the name "${options.name}" already exists.`);
+    }
+
+    const newJob: SyncJob = {
+      id: `job-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+      name: options.name,
+      localPath: resolvedLocalPath,
+      remoteBucket: remote.slug,
+      remotePath: remote.remotePath,
+      direction: options.direction,
+      conflictStrategy: options.strategy,
+      conflictCopy: !options.noConflictCopy,
+      intervalMs: intervalSec * 1000,
+      enabled: true,
+    };
+
+    if (!config.syncJobs) {
+      config.syncJobs = [];
+    }
+    config.syncJobs.push(newJob);
+    await saveConfig(config);
+
+    console.log(chalk.green(`✔ Sync job "${options.name}" successfully registered!`));
+    console.log(`Local Path: ${newJob.localPath}`);
+    console.log(`Remote: ${newJob.remoteBucket}:${newJob.remotePath || ''}`);
+    console.log(`Direction: ${newJob.direction}`);
+    console.log(`Strategy: ${newJob.conflictStrategy}`);
+    console.log(`Interval: ${intervalSec} seconds`);
+  } catch (err: any) {
+    console.error(chalk.red(`Error: Failed to register sync job: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function listSyncJobs(): Promise<void> {
+  try {
+    const config = await loadConfig();
+    const jobs = config.syncJobs || [];
+
+    if (jobs.length === 0) {
+      console.log(chalk.yellow('No persistent sync jobs registered. Create one with: hsync sync add <localPath> <bucketSlug>:[remotePath] --name <jobName> ...'));
+      return;
+    }
+
+    console.log(chalk.cyan('\n=== Registered Sync Profiles ==='));
+    for (const j of jobs) {
+      console.log(`- Name: ${chalk.bold(j.name)} (${j.enabled ? chalk.green('Enabled') : chalk.red('Disabled')})`);
+      console.log(`  Local Path: ${j.localPath}`);
+      console.log(`  Remote Path: ${j.remoteBucket}:${j.remotePath || ''}`);
+      console.log(`  Direction: ${j.direction}`);
+      console.log(`  Strategy: ${j.conflictStrategy}`);
+      console.log(`  Conflict Copy Backup: ${j.conflictCopy ? chalk.green('Yes') : chalk.red('No')}`);
+      console.log(`  Interval: ${(j.intervalMs || 10000) / 1000} seconds`);
+      console.log();
+    }
+  } catch (err: any) {
+    console.error(chalk.red(`Error listing sync jobs: ${err.message}`));
+  }
+}
+
+export async function removeSyncJob(name: string): Promise<void> {
+  try {
+    const config = await loadConfig();
+    const jobs = config.syncJobs || [];
+    const index = jobs.findIndex((j) => j.name === name);
+
+    if (index === -1) {
+      throw new Error(`Sync job named "${name}" not found.`);
+    }
+
+    jobs.splice(index, 1);
+    config.syncJobs = jobs;
+    await saveConfig(config);
+
+    console.log(chalk.green(`✔ Sync job "${name}" successfully removed.`));
+  } catch (err: any) {
+    console.error(chalk.red(`Error removing sync job: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function startSyncScheduler(name?: string): Promise<void> {
+  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);
+    }
+
+    let jobs = config.syncJobs || [];
+    if (name) {
+      jobs = jobs.filter((j) => j.name === name);
+      if (jobs.length === 0) {
+        console.error(chalk.red(`Error: Sync job named "${name}" was not found or is disabled.`));
+        process.exit(1);
+      }
+    } else {
+      jobs = jobs.filter((j) => j.enabled);
+    }
+
+    if (jobs.length === 0) {
+      console.error(chalk.yellow('Warning: No active sync jobs to schedule. Register a sync job first.'));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n=== Starting Sync Scheduler Service ===`));
+    console.log(chalk.cyan(`Target Server: ${serverUrl}`));
+    console.log(chalk.cyan(`Active Profiles: ${jobs.map((j) => j.name).join(', ')}\n`));
+
+    // Overrun Lock Protection Tracker
+    const activeJobs = new Set<string>();
+
+    for (const job of jobs) {
+      const intervalDelay = job.intervalMs || 10000;
+      const stateDbPath = path.join(os.homedir(), '.hsync', 'state', `${job.id}.db`);
+
+      const triggerSyncRun = async () => {
+        if (activeJobs.has(job.id)) {
+          console.log(chalk.yellow(`[${new Date().toLocaleTimeString()}] [Sync: ${job.name}] Skip run — previous run still in progress.`));
+          return;
+        }
+
+        activeJobs.add(job.id);
+        const engine = new SyncEngine(job, serverUrl, apiKey, stateDbPath);
+
+        engine.on((event: SyncEvent) => {
+          const time = new Date().toLocaleTimeString();
+          if (event.type === 'start') {
+            console.log(chalk.blue(`[${time}] [Sync: ${job.name}] Running scan...`));
+          } else if (event.type === 'scan-complete') {
+            console.log(chalk.blue(`[${time}] [Sync: ${job.name}] Scan completed.`));
+          } else if (event.type === 'upload-complete') {
+            console.log(chalk.green(`[${time}] [Sync: ${job.name}] ✔ Uploaded: ${event.path}`));
+          } else if (event.type === 'download-complete') {
+            console.log(chalk.green(`[${time}] [Sync: ${job.name}] ✔ Downloaded: ${event.path}`));
+          } else if (event.type === 'conflict') {
+            console.log(chalk.yellow(`[${time}] [Sync: ${job.name}] ⚠ Conflict resolved for: ${event.path}`));
+          } else if (event.type === 'error') {
+            console.error(chalk.red(`[${time}] [Sync: ${job.name}] ✘ Error on "${event.path}": ${event.error?.message}`));
+          } else if (event.type === 'complete') {
+            console.log(chalk.green(`[${time}] [Sync: ${job.name}] ✔ Sync pass completed successfully.`));
+          }
+        });
+
+        try {
+          await engine.run();
+        } catch (runErr: any) {
+          console.error(chalk.red(`[${new Date().toLocaleTimeString()}] [Sync: ${job.name}] Sync crash: ${runErr.message}`));
+        } finally {
+          activeJobs.delete(job.id);
+        }
+      };
+
+      // Trigger immediately once, then queue interval loops
+      triggerSyncRun();
+      setInterval(triggerSyncRun, intervalDelay);
+    }
+  } catch (err: any) {
+    console.error(chalk.red(`Scheduler crashed: ${err.message}`));
+    process.exit(1);
+  }
+}