hsync-cli 1.0.2 → 1.0.4

package/dist/bin.js

@@ -1,6 +1,5 @@
-#!/usr/bin/env node
-
 #!/usr/bin/env bun
+
 // @bun
 import { createRequire } from "node:module";
 var __create = Object.create;
@@ -45776,6 +45775,7 @@ import path2 from "path";
 import os3 from "os";
 var configDir = path2.join(os3.homedir(), ".hsync");
 var configPath = path2.join(configDir, "config.json");
+var DEFAULT_SERVER_URL = "https://hsync-backend.giftsh.in";
 async function loadConfig() {
   try {
     const raw = await fs.readFile(configPath, "utf-8");
@@ -45783,9 +45783,15 @@ async function loadConfig() {
     if (!parsed.syncJobs) {
       parsed.syncJobs = [];
     }
+    if (!parsed.serverUrl) {
+      parsed.serverUrl = DEFAULT_SERVER_URL;
+    }
     return parsed;
   } catch (err) {
-    return { syncJobs: [] };
+    return {
+      serverUrl: DEFAULT_SERVER_URL,
+      syncJobs: []
+    };
   }
 }
 async function saveConfig(config) {
@@ -51728,7 +51734,41 @@ async function removeSyncJob(name) {
     process.exit(1);
   }
 }
-async function startSyncScheduler(name) {
+async function startSyncScheduler(name, options) {
+  const isDaemon = options?.daemon;
+  const hsyncDir = path7.join(os4.homedir(), ".hsync");
+  const pidFile = path7.join(hsyncDir, name ? `daemon-${name}.pid` : "daemon.pid");
+  if (isDaemon) {
+    await fs6.mkdir(hsyncDir, { recursive: true });
+    try {
+      const existingPidText = await fs6.readFile(pidFile, "utf8");
+      if (existingPidText) {
+        const pid2 = parseInt(existingPidText.trim(), 10);
+        try {
+          process.kill(pid2, 0);
+          console.log(source_default.yellow(`Warning: Sync daemon is already running (PID: ${pid2}).`));
+          return;
+        } catch {}
+      }
+    } catch {}
+    const logFile = path7.join(hsyncDir, name ? `daemon-${name}.log` : "daemon.log");
+    console.log(source_default.cyan(`⚙️ Starting sync daemon in the background...`));
+    const filteredArgs = process.argv.slice(1).filter((arg) => arg !== "--daemon" && arg !== "-d");
+    const logFileHandle = await fs6.open(logFile, "w");
+    const subprocess = Bun.spawn([process.argv[0], ...filteredArgs], {
+      detached: true,
+      stdout: logFileHandle.fd,
+      stderr: logFileHandle.fd,
+      stdin: "ignore"
+    });
+    const pid = subprocess.pid;
+    await fs6.writeFile(pidFile, pid.toString(), "utf8");
+    subprocess.unref();
+    console.log(source_default.green(`✔ Sync daemon started successfully!`));
+    console.log(`PID: ${pid}`);
+    console.log(`Logs: tail -f ${logFile}`);
+    return;
+  }
   try {
     const config = await loadConfig();
     const serverUrl = config.serverUrl;
@@ -51751,6 +51791,21 @@ async function startSyncScheduler(name) {
       console.error(source_default.yellow("Warning: No active sync jobs to schedule. Register a sync job first."));
       return;
     }
+    await fs6.mkdir(hsyncDir, { recursive: true });
+    await fs6.writeFile(pidFile, process.pid.toString(), "utf8");
+    const cleanPidFile = async () => {
+      try {
+        await fs6.unlink(pidFile);
+      } catch {}
+    };
+    process.on("SIGINT", async () => {
+      await cleanPidFile();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      await cleanPidFile();
+      process.exit(0);
+    });
     console.log(source_default.cyan(`
 === Starting Sync Scheduler Service ===`));
     console.log(source_default.cyan(`Target Server: ${serverUrl}`));
@@ -51801,6 +51856,208 @@ async function startSyncScheduler(name) {
     process.exit(1);
   }
 }
+async function stopSyncScheduler(name) {
+  try {
+    const hsyncDir = path7.join(os4.homedir(), ".hsync");
+    if (name) {
+      const pidFile = path7.join(hsyncDir, `daemon-${name}.pid`);
+      try {
+        const pidText = await fs6.readFile(pidFile, "utf8");
+        const pid = parseInt(pidText.trim(), 10);
+        process.kill(pid, "SIGTERM");
+        await fs6.unlink(pidFile);
+        console.log(source_default.green(`✔ Sync daemon for "${name}" (PID: ${pid}) has been stopped.`));
+      } catch {
+        console.error(source_default.red(`Error: No active sync daemon found for "${name}".`));
+      }
+    } else {
+      const files = await fs6.readdir(hsyncDir);
+      const pidFiles = files.filter((f) => f.startsWith("daemon") && f.endsWith(".pid"));
+      if (pidFiles.length === 0) {
+        console.log(source_default.yellow("No active sync daemons found running."));
+        return;
+      }
+      for (const file of pidFiles) {
+        const pidFile = path7.join(hsyncDir, file);
+        try {
+          const pidText = await fs6.readFile(pidFile, "utf8");
+          const pid = parseInt(pidText.trim(), 10);
+          process.kill(pid, "SIGTERM");
+          await fs6.unlink(pidFile);
+          const jobName = file.replace("daemon-", "").replace(".pid", "");
+          console.log(source_default.green(`✔ Stopped sync daemon (PID: ${pid}) for ${jobName === "daemon" ? "all jobs" : jobName}.`));
+        } catch {
+          try {
+            await fs6.unlink(pidFile);
+          } catch {}
+        }
+      }
+    }
+  } catch (err) {
+    console.error(source_default.red(`Error stopping daemon: ${err.message}`));
+  }
+}
+async function configureAutostart(enable) {
+  try {
+    const platform = os4.platform();
+    if (platform === "linux") {
+      const autostartDir = path7.join(os4.homedir(), ".config", "autostart");
+      const desktopFile = path7.join(autostartDir, "hsync-autostart.desktop");
+      if (enable) {
+        await fs6.mkdir(autostartDir, { recursive: true });
+        const content = `[Desktop Entry]
+Type=Application
+Exec=hsync sync start --daemon
+Hidden=false
+NoDisplay=false
+X-GNOME-Autostart-enabled=true
+Name=hsync Autostart Daemon
+Comment=Start hsync background synchronization daemon on login
+`;
+        await fs6.writeFile(desktopFile, content, "utf8");
+        await fs6.chmod(desktopFile, 493);
+        console.log(source_default.green("✔ Autostart successfully enabled!"));
+        console.log(`Created autostart entry: ${desktopFile}`);
+      } else {
+        try {
+          await fs6.unlink(desktopFile);
+          console.log(source_default.green("✔ Autostart successfully disabled."));
+        } catch {
+          console.log(source_default.yellow("Autostart was not enabled."));
+        }
+      }
+    } else if (platform === "win32") {
+      const appData = process.env.APPDATA;
+      if (!appData) {
+        throw new Error("APPDATA environment variable not found.");
+      }
+      const startupDir = path7.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+      const batFile = path7.join(startupDir, "hsync-autostart.bat");
+      if (enable) {
+        await fs6.mkdir(startupDir, { recursive: true });
+        const content = `@echo off
+hsync sync start --daemon
+`;
+        await fs6.writeFile(batFile, content, "utf8");
+        console.log(source_default.green("✔ Windows Autostart successfully enabled!"));
+        console.log(`Created startup script: ${batFile}`);
+      } else {
+        try {
+          await fs6.unlink(batFile);
+          console.log(source_default.green("✔ Windows Autostart successfully disabled."));
+        } catch {
+          console.log(source_default.yellow("Windows Autostart was not enabled."));
+        }
+      }
+    } else {
+      console.error(source_default.red(`Error: Autostart configuration is not natively supported on platform "${platform}".`));
+    }
+  } catch (err) {
+    console.error(source_default.red(`Error configuring autostart: ${err.message}`));
+  }
+}
+async function showSyncLogs(name, options) {
+  const hsyncDir = path7.join(os4.homedir(), ".hsync");
+  const logFile = path7.join(hsyncDir, name ? `daemon-${name}.log` : "daemon.log");
+  try {
+    await fs6.access(logFile);
+  } catch {
+    console.log(source_default.yellow("No sync logs found. Either the daemon has not run yet, or logs were cleaned."));
+    return;
+  }
+  if (options?.follow) {
+    console.log(source_default.cyan(`=== Streaming Sync Logs (Ctrl+C to exit) ===`));
+    let fileHandle = await fs6.open(logFile, "r");
+    let stat = await fileHandle.stat();
+    let currentSize = stat.size;
+    const startPos = Math.max(0, currentSize - 5000);
+    const buffer = Buffer.alloc(currentSize - startPos);
+    if (buffer.length > 0) {
+      await fileHandle.read(buffer, 0, buffer.length, startPos);
+      process.stdout.write(buffer.toString("utf8"));
+    }
+    const watcher = fs6.watch(logFile);
+    try {
+      for await (const event of watcher) {
+        if (event.eventType === "change") {
+          const newStat = await fs6.stat(logFile);
+          const newSize = newStat.size;
+          if (newSize > currentSize) {
+            const sizeDiff = newSize - currentSize;
+            const readBuffer = Buffer.alloc(sizeDiff);
+            const tempHandle = await fs6.open(logFile, "r");
+            await tempHandle.read(readBuffer, 0, sizeDiff, currentSize);
+            await tempHandle.close();
+            process.stdout.write(readBuffer.toString("utf8"));
+            currentSize = newSize;
+          }
+        }
+      }
+    } catch (watchErr) {} finally {
+      await fileHandle.close();
+    }
+  } else {
+    const content = await fs6.readFile(logFile, "utf8");
+    const lines = content.split(`
+`);
+    const lastLines = lines.slice(-200).join(`
+`);
+    process.stdout.write(lastLines);
+  }
+}
+async function editSyncJob(name, options) {
+  try {
+    const config = await loadConfig();
+    const jobs = config.syncJobs || [];
+    const job = jobs.find((j) => j.name === name);
+    if (!job) {
+      throw new Error(`Sync job named "${name}" not found.`);
+    }
+    if (options.localPath) {
+      const resolvedLocalPath = path7.resolve(options.localPath);
+      try {
+        await fs6.access(resolvedLocalPath);
+      } catch {
+        console.error(source_default.red(`Error: Local path "${options.localPath}" does not exist.`));
+        process.exit(1);
+      }
+      job.localPath = resolvedLocalPath;
+    }
+    if (options.remoteTarget) {
+      const remote = parseRemoteTarget2(options.remoteTarget);
+      job.remoteBucket = remote.slug;
+      job.remotePath = remote.remotePath;
+    }
+    if (options.direction) {
+      job.direction = options.direction;
+    }
+    if (options.strategy) {
+      job.conflictStrategy = options.strategy;
+    }
+    if (options.interval) {
+      const intervalSec = parseInt(options.interval, 10);
+      if (isNaN(intervalSec) || intervalSec <= 0) {
+        throw new Error("Interval must be a positive integer in seconds.");
+      }
+      job.intervalMs = intervalSec * 1000;
+    }
+    if (options.noConflictCopy !== undefined) {
+      job.conflictCopy = !options.noConflictCopy;
+    } else if (options.conflictCopy !== undefined) {
+      job.conflictCopy = options.conflictCopy;
+    }
+    await saveConfig(config);
+    console.log(source_default.green(`✔ Sync job "${name}" successfully updated!`));
+    console.log(`Local Path: ${job.localPath}`);
+    console.log(`Remote: ${job.remoteBucket}:${job.remotePath || ""}`);
+    console.log(`Direction: ${job.direction}`);
+    console.log(`Strategy: ${job.conflictStrategy}`);
+    console.log(`Interval: ${(job.intervalMs || 1e4) / 1000} seconds`);
+  } catch (err) {
+    console.error(source_default.red(`Error: Failed to update sync job: ${err.message}`));
+    process.exit(1);
+  }
+}
 
 // src/index.ts
 var program2 = new Command;
@@ -51844,7 +52101,26 @@ syncCmd.command("list").description("List all registered local sync profiles").a
 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);
+syncCmd.command("start [name]").description("Start interval synchronization scheduler service").option("-d, --daemon", "Run synchronization service in the background (detached daemon mode)").action(async (name, options) => {
+  await startSyncScheduler(name, options);
+});
+syncCmd.command("stop [name]").description("Stop active background synchronization scheduler daemon").action(async (name) => {
+  await stopSyncScheduler(name);
+});
+syncCmd.command("autostart <action>").description('Configure hsync sync autostart daemon on login (action: "enable" | "disable")').action(async (action) => {
+  if (action === "enable") {
+    await configureAutostart(true);
+  } else if (action === "disable") {
+    await configureAutostart(false);
+  } else {
+    console.error('Error: Invalid action. Use "enable" or "disable".');
+    process.exit(1);
+  }
+});
+syncCmd.command("logs [name]").description("View active sync scheduler daemon output logs").option("-f, --follow", "Stream live logs in real-time (continuous follow mode)").action(async (name, options) => {
+  await showSyncLogs(name, options);
+});
+syncCmd.command("edit <name>").description("Edit parameters of an existing persistent sync job profile").option("-l, --localPath <path>", "Local folder path to synchronize").option("-r, --remoteTarget <target>", "Remote target bucket and subpath (slug:[path])").option("-d, --direction <push|pull|bidirectional>", "Sync transfer direction mapping").option("-s, --strategy <local-wins|server-wins|newer-wins>", "Conflict resolution strategy rules").option("-i, --interval <seconds>", "Synchronization scheduling delay frequency in seconds").option("--no-conflict-copy", "Disable keeping backup copies (.conflict-YYYY-MM-DD) on conflict resolutions").option("--conflict-copy", "Enable keeping backup copies (.conflict-YYYY-MM-DD) on conflict resolutions").action(async (name, options) => {
+  await editSyncJob(name, options);
 });
 program2.parse(process.argv);

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "hsync-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "hsync CLI for file sync operations",
   "bin": {
     "hsync": "./dist/bin.js"
   },
+  "files": [
+    "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": "bun build src/index.ts --compile --define \"process.env.DEFAULT_SERVER_URL='https://hsync-backend.giftsh.in'\" --outfile dist/hsync",
     "build:js": "bun scripts/build-js.ts",
     "prepublishOnly": "bun run build:js",
     "start": "bun src/index.ts",

package/scripts/build-js.ts

@@ -1,32 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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);
-  }
-}

package/src/commands/transfer.ts

@@ -1,220 +0,0 @@
-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

@@ -1,126 +0,0 @@
-#!/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

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

package/src/utils/client.ts

@@ -1,24 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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