hsync-cli 1.1.1 → 1.1.3

package/dist/bin.js

@@ -69670,16 +69670,15 @@ async function scanLocalPath(targetPath, rootDir) {
 function parseRemoteTarget(target) {
   const parts = target.split(":");
   const slug = parts[0];
-  const remotePath = (parts.slice(1).join(":") || "").replace(/^\/+|\/+$/g, "");
-  return { slug, remotePath };
+  const rawPath = parts.slice(1).join(":") || "";
+  const endsWithSlash = rawPath.endsWith("/");
+  const remotePath = rawPath.replace(/^\/+|\/+$/g, "");
+  return { slug, remotePath, endsWithSlash };
 }
 async function push(localPath, remoteTarget, options) {
-  const forceYes = options.yes || false;
   try {
     const config = await loadConfig();
-    const serverUrl = config.serverUrl;
-    const apiKey = config.apiKey;
-    if (!serverUrl || !apiKey) {
+    if (!config.serverUrl || !config.apiKey) {
       console.error(source_default.red("Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login"));
       process.exit(1);
     }
@@ -69694,22 +69693,28 @@ async function push(localPath, remoteTarget, options) {
     const spinner = ora2("Scanning local files...").start();
     const localFiles = await scanLocalPath(resolvedLocalPath, resolvedLocalPath);
     spinner.text = "Fetching remote file tree...";
-    const remoteClient = new RemoteClient(serverUrl, apiKey);
+    const remoteClient = new RemoteClient(config.serverUrl, config.apiKey);
     const remoteFiles = await remoteClient.getTree(remote.slug, remote.remotePath);
     spinner.stop();
     console.log(source_default.cyan(`Found ${localFiles.length} local files, ${remoteFiles.length} remote files.`));
-    const prompter = new OverwritePrompter(forceYes);
+    let isRemoteDir = !(await fs3.stat(resolvedLocalPath)).isFile() || remote.endsWithSlash;
+    if (!isRemoteDir) {
+      if (remoteFiles.length > 1) {
+        isRemoteDir = true;
+      } else if (remoteFiles.length === 1 && remoteFiles[0].path !== "") {
+        isRemoteDir = true;
+      }
+    }
+    const prompter = new OverwritePrompter(options.yes || false);
     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;
+      const remoteFile = remoteFiles.find((f) => f.path === (isRemoteDir ? localFile.relativePath : ""));
       let shouldUpload = false;
       if (!remoteFile) {
         shouldUpload = true;
       } else if (remoteFile.hash !== localFile.hash) {
-        const confirm = await prompter.shouldOverwrite(localFile.relativePath);
-        if (confirm) {
+        if (await prompter.shouldOverwrite(localFile.relativePath)) {
           shouldUpload = true;
         } else {
           skipCount++;
@@ -69720,7 +69725,7 @@ async function push(localPath, remoteTarget, options) {
       if (shouldUpload) {
         const fileSpinner = ora2(`Pushing ${localFile.relativePath}...`).start();
         try {
-          await remoteClient.uploadFile(remote.slug, destinationPath, localFile.absolutePath);
+          await remoteClient.uploadFile(remote.slug, isRemoteDir ? remote.remotePath ? `${remote.remotePath}/${localFile.relativePath}` : localFile.relativePath : remote.remotePath, localFile.absolutePath);
           fileSpinner.succeed(source_default.green(`Pushed ${localFile.relativePath}`));
           pushCount++;
         } catch (uploadErr) {
@@ -69736,38 +69741,65 @@ async function push(localPath, remoteTarget, options) {
   }
 }
 async function pull(remoteTarget, localPath, options) {
-  const forceYes = options.yes || false;
   try {
     const config = await loadConfig();
-    const serverUrl = config.serverUrl;
-    const apiKey = config.apiKey;
-    if (!serverUrl || !apiKey) {
+    if (!config.serverUrl || !config.apiKey) {
       console.error(source_default.red("Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login"));
       process.exit(1);
     }
     const remote = parseRemoteTarget(remoteTarget);
     const resolvedLocalPath = path4.resolve(localPath);
     const spinner = ora2("Fetching remote file tree...").start();
-    const remoteClient = new RemoteClient(serverUrl, apiKey);
+    const remoteClient = new RemoteClient(config.serverUrl, config.apiKey);
     const remoteFiles = await remoteClient.getTree(remote.slug, remote.remotePath);
     spinner.text = "Scanning local files...";
-    await fs3.mkdir(resolvedLocalPath, { recursive: true });
-    const localFiles = await scanLocalPath(resolvedLocalPath, resolvedLocalPath);
+    const isRemoteFile = remoteFiles.length === 1 && remoteFiles[0].path === "";
+    let isLocalDir = false;
+    try {
+      const localStat = await fs3.stat(resolvedLocalPath);
+      isLocalDir = localStat.isDirectory();
+    } catch {
+      isLocalDir = localPath.endsWith("/") || localPath.endsWith(path4.sep);
+    }
+    if (isRemoteFile && !isLocalDir) {
+      await fs3.mkdir(path4.dirname(resolvedLocalPath), { recursive: true });
+    } else {
+      await fs3.mkdir(resolvedLocalPath, { recursive: true });
+    }
+    let localFiles = [];
+    try {
+      localFiles = await scanLocalPath(resolvedLocalPath, resolvedLocalPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
     spinner.stop();
     console.log(source_default.cyan(`Found ${remoteFiles.length} remote files, ${localFiles.length} local files.`));
-    const prompter = new OverwritePrompter(forceYes);
+    const prompter = new OverwritePrompter(options.yes || false);
     let pullCount = 0;
     let skipCount = 0;
     for (const remoteFile of remoteFiles) {
-      const localFile = localFiles.find((f) => f.relativePath === remoteFile.path);
-      const localDestPath = path4.join(resolvedLocalPath, remoteFile.path);
-      const sourcePath = remote.remotePath ? `${remote.remotePath}/${remoteFile.path}` : remoteFile.path;
+      let localDestPath;
+      let localFile;
+      if (isRemoteFile) {
+        if (isLocalDir) {
+          localDestPath = path4.join(resolvedLocalPath, path4.basename(remote.remotePath));
+          localFile = localFiles.find((f) => f.relativePath === path4.basename(remote.remotePath));
+        } else {
+          localDestPath = resolvedLocalPath;
+          localFile = localFiles.length > 0 ? localFiles[0] : undefined;
+        }
+      } else {
+        localDestPath = path4.join(resolvedLocalPath, remoteFile.path);
+        localFile = localFiles.find((f) => f.relativePath === remoteFile.path);
+      }
       let shouldDownload = false;
       if (!localFile) {
         shouldDownload = true;
       } else if (localFile.hash !== remoteFile.hash) {
-        const confirm = await prompter.shouldOverwrite(remoteFile.path);
-        if (confirm) {
+        const promptPath = isRemoteFile ? remote.remotePath || path4.basename(localDestPath) : remoteFile.path;
+        if (await prompter.shouldOverwrite(promptPath)) {
           shouldDownload = true;
         } else {
           skipCount++;
@@ -69776,13 +69808,14 @@ async function pull(remoteTarget, localPath, options) {
         skipCount++;
       }
       if (shouldDownload) {
-        const fileSpinner = ora2(`Pulling ${remoteFile.path}...`).start();
+        const logPath = isRemoteFile ? remote.remotePath || path4.basename(localDestPath) : remoteFile.path;
+        const fileSpinner = ora2(`Pulling ${logPath}...`).start();
         try {
-          await remoteClient.downloadFile(remote.slug, sourcePath, localDestPath);
-          fileSpinner.succeed(source_default.green(`Pulled ${remoteFile.path}`));
+          await remoteClient.downloadFile(remote.slug, isRemoteFile ? remote.remotePath : remote.remotePath ? `${remote.remotePath}/${remoteFile.path}` : remoteFile.path, localDestPath);
+          fileSpinner.succeed(source_default.green(`Pulled ${logPath}`));
           pullCount++;
         } catch (downloadErr) {
-          fileSpinner.fail(source_default.red(`Failed to pull ${remoteFile.path}: ${downloadErr.message}`));
+          fileSpinner.fail(source_default.red(`Failed to pull ${logPath}: ${downloadErr.message}`));
         }
       }
     }
@@ -70153,6 +70186,177 @@ class SyncEngine {
   }
 }
 // src/commands/sync.ts
+function getHsyncDir() {
+  return path7.join(os4.homedir(), ".hsync");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function jobNameFromPidFile(filename) {
+  if (filename === "daemon.pid") {
+    return "all jobs";
+  }
+  return filename.replace("daemon-", "").replace(".pid", "");
+}
+async function readPidRecord(pidFile) {
+  try {
+    const pidText = await fs6.readFile(pidFile, "utf8");
+    const pid = parseInt(pidText.trim(), 10);
+    if (isNaN(pid)) {
+      await fs6.unlink(pidFile);
+      return null;
+    }
+    if (!isProcessAlive(pid)) {
+      await fs6.unlink(pidFile);
+      return null;
+    }
+    return { pid };
+  } catch {
+    return null;
+  }
+}
+async function listAllDaemonPids() {
+  const hsyncDir = getHsyncDir();
+  const results = [];
+  try {
+    const files = await fs6.readdir(hsyncDir);
+    for (const file of files) {
+      if (!file.startsWith("daemon") || !file.endsWith(".pid")) {
+        continue;
+      }
+      const pidFile = path7.join(hsyncDir, file);
+      const record = await readPidRecord(pidFile);
+      if (record) {
+        results.push({
+          pidFile,
+          pid: record.pid,
+          jobName: jobNameFromPidFile(file)
+        });
+      }
+    }
+  } catch {}
+  return results;
+}
+var RECONCILE_INTERVAL_MS = 1e4;
+async function isGlobalDaemonRunning() {
+  const globalFile = path7.join(getHsyncDir(), "daemon.pid");
+  const record = await readPidRecord(globalFile);
+  return record !== null;
+}
+async function executeSyncPass(jobId, activeJobs) {
+  if (activeJobs.has(jobId)) {
+    const config = await loadConfig();
+    const busyJob = config.syncJobs?.find((j) => j.id === jobId);
+    const busyName = busyJob?.name || jobId;
+    console.log(source_default.yellow(`[${new Date().toLocaleTimeString()}] [Sync: ${busyName}] Skip run — previous run still in progress.`));
+    return;
+  }
+  const freshConfig = await loadConfig();
+  const freshServerUrl = freshConfig.serverUrl;
+  const freshApiKey = freshConfig.apiKey;
+  const freshJob = freshConfig.syncJobs?.find((j) => j.id === jobId);
+  if (!freshJob) {
+    return;
+  }
+  if (!freshServerUrl || !freshApiKey) {
+    console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${freshJob.name}] Missing server URL or API key. Run: hsync login`));
+    return;
+  }
+  if (!freshJob.enabled) {
+    return;
+  }
+  activeJobs.add(jobId);
+  const stateDbPath = path7.join(getHsyncDir(), "state", `${freshJob.id}.db`);
+  const engine = new SyncEngine(freshJob, freshServerUrl, freshApiKey, stateDbPath);
+  let uploadCount = 0;
+  let downloadCount = 0;
+  let skipCount = 0;
+  let errorCount = 0;
+  engine.on((event) => {
+    const time = new Date().toLocaleTimeString();
+    if (event.type === "start") {
+      console.log(source_default.blue(`[${time}] [Sync: ${freshJob.name}] Running scan...`));
+    } else if (event.type === "scan-complete") {
+      console.log(source_default.blue(`[${time}] [Sync: ${freshJob.name}] Scan completed.`));
+    } else if (event.type === "upload-complete") {
+      uploadCount++;
+      console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Uploaded: ${event.path}`));
+    } else if (event.type === "download-complete") {
+      downloadCount++;
+      console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Downloaded: ${event.path}`));
+    } else if (event.type === "skip") {
+      skipCount++;
+    } else if (event.type === "conflict") {
+      console.log(source_default.yellow(`[${time}] [Sync: ${freshJob.name}] ⚠ Conflict resolved for: ${event.path}`));
+    } else if (event.type === "error") {
+      errorCount++;
+      console.error(source_default.red(`[${time}] [Sync: ${freshJob.name}] ✘ Error on "${event.path}": ${event.error?.message}`));
+    } else if (event.type === "complete") {
+      const summary = `${uploadCount} uploaded, ${downloadCount} downloaded, ${skipCount} unchanged`;
+      if (uploadCount === 0 && downloadCount === 0 && errorCount === 0) {
+        console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Sync pass completed (${summary}).`));
+      } else {
+        console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Sync pass completed successfully (${summary}).`));
+      }
+    }
+  });
+  try {
+    await engine.run();
+  } catch (runErr) {
+    console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${freshJob.name}] Sync crash: ${runErr.message}`));
+  } finally {
+    activeJobs.delete(jobId);
+  }
+}
+function scheduleSyncJob(job, activeJobs, scheduledJobs) {
+  const intervalDelay = job.intervalMs || 1e4;
+  const triggerSyncRun = async () => {
+    await executeSyncPass(job.id, activeJobs);
+  };
+  triggerSyncRun();
+  const intervalId = setInterval(triggerSyncRun, intervalDelay);
+  scheduledJobs.set(job.id, { intervalId, intervalMs: intervalDelay });
+  console.log(source_default.green(`[${new Date().toLocaleTimeString()}] [Scheduler] Registered: ${job.name} (every ${intervalDelay / 1000}s)`));
+}
+function unscheduleSyncJob(jobId, jobName, scheduledJobs) {
+  const entry = scheduledJobs.get(jobId);
+  if (!entry) {
+    return;
+  }
+  clearInterval(entry.intervalId);
+  scheduledJobs.delete(jobId);
+  console.log(source_default.yellow(`[${new Date().toLocaleTimeString()}] [Scheduler] Unregistered: ${jobName || jobId}`));
+}
+async function reconcileSchedules(activeJobs, scheduledJobs, singleJobName) {
+  const config = await loadConfig();
+  let jobs = (config.syncJobs || []).filter((j) => j.enabled);
+  if (singleJobName) {
+    jobs = jobs.filter((j) => j.name === singleJobName);
+  }
+  const enabledIds = new Set(jobs.map((j) => j.id));
+  for (const [jobId, entry] of scheduledJobs) {
+    if (!enabledIds.has(jobId)) {
+      const staleJob = config.syncJobs?.find((j) => j.id === jobId);
+      unscheduleSyncJob(jobId, staleJob?.name, scheduledJobs);
+      continue;
+    }
+    const job = jobs.find((j) => j.id === jobId);
+    if (job && entry.intervalMs !== (job.intervalMs || 1e4)) {
+      unscheduleSyncJob(jobId, job.name, scheduledJobs);
+      scheduleSyncJob(job, activeJobs, scheduledJobs);
+    }
+  }
+  for (const job of jobs) {
+    if (!scheduledJobs.has(job.id)) {
+      scheduleSyncJob(job, activeJobs, scheduledJobs);
+    }
+  }
+}
 function parseRemoteTarget2(target) {
   const parts = target.split(":");
   const slug = parts[0];
@@ -70201,6 +70405,11 @@ async function addSyncJob(localPath, remoteTarget, options) {
     console.log(`Direction: ${newJob.direction}`);
     console.log(`Strategy: ${newJob.conflictStrategy}`);
     console.log(`Interval: ${intervalSec} seconds`);
+    if (await isGlobalDaemonRunning()) {
+      console.log(source_default.gray("The running sync daemon will pick up this job automatically."));
+    } else {
+      console.log(source_default.gray("Start all sync jobs with: hsync sync start --daemon"));
+    }
   } catch (err) {
     console.error(source_default.red(`Error: Failed to register sync job: ${err.message}`));
     process.exit(1);
@@ -70249,37 +70458,44 @@ async function removeSyncJob(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");
+  let foregroundJobName = name;
+  const hsyncDir = getHsyncDir();
+  const globalPidFile = path7.join(hsyncDir, "daemon.pid");
+  if (isDaemon && foregroundJobName) {
+    console.log(source_default.yellow(`The sync daemon manages all enabled jobs. Starting global daemon instead of "${foregroundJobName}" only.`));
+    foregroundJobName = undefined;
+  }
   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], {
+    const existing = await readPidRecord(globalPidFile);
+    if (existing) {
+      console.log(source_default.yellow(`Warning: Sync daemon is already running (PID: ${existing.pid}).`));
+      console.log(source_default.gray("New sync jobs are picked up automatically — no restart needed."));
+      return;
+    }
+    const legacyDaemons = await listAllDaemonPids();
+    const perJobDaemons = legacyDaemons.filter((d) => d.jobName !== "all jobs");
+    if (perJobDaemons.length > 0) {
+      console.log(source_default.yellow("Warning: Legacy per-job daemons are still running. Stop them with: hsync sync stop"));
+    }
+    const logFile = path7.join(hsyncDir, "daemon.log");
+    console.log(source_default.cyan(`⚙️ Starting global sync daemon in the background...`));
+    const bunExec = process.execPath;
+    const scriptPath = Bun.main;
+    const spawnArgs = ["sync", "start"];
+    const logFileHandle = await fs6.open(logFile, "a");
+    const subprocess = Bun.spawn([bunExec, scriptPath, ...spawnArgs], {
       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}`);
+    await logFileHandle.close();
+    console.log(source_default.green(`✔ Global sync daemon started successfully!`));
+    console.log(source_default.gray("All enabled sync jobs will be scheduled automatically."));
+    console.log(`Logs: hsync sync logs -f`);
+    console.log(source_default.gray("Stop with: hsync sync stop"));
     return;
   }
   try {
@@ -70290,11 +70506,12 @@ async function startSyncScheduler(name, options) {
       console.error(source_default.red("Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login"));
       process.exit(1);
     }
+    const isGlobalScheduler = !foregroundJobName;
     let jobs = config.syncJobs || [];
-    if (name) {
-      jobs = jobs.filter((j) => j.name === name);
+    if (foregroundJobName) {
+      jobs = jobs.filter((j) => j.name === foregroundJobName);
       if (jobs.length === 0) {
-        console.error(source_default.red(`Error: Sync job named "${name}" was not found or is disabled.`));
+        console.error(source_default.red(`Error: Sync job named "${foregroundJobName}" was not found or is disabled.`));
         process.exit(1);
       }
     } else {
@@ -70305,10 +70522,10 @@ async function startSyncScheduler(name, options) {
       return;
     }
     await fs6.mkdir(hsyncDir, { recursive: true });
-    await fs6.writeFile(pidFile, process.pid.toString(), "utf8");
+    await fs6.writeFile(globalPidFile, process.pid.toString(), "utf8");
     const cleanPidFile = async () => {
       try {
-        await fs6.unlink(pidFile);
+        await fs6.unlink(globalPidFile);
       } catch {}
     };
     process.on("SIGINT", async () => {
@@ -70322,89 +70539,86 @@ async function startSyncScheduler(name, options) {
     console.log(source_default.cyan(`
 === Starting Sync Scheduler Service ===`));
     console.log(source_default.cyan(`Target Server: ${serverUrl}`));
-    console.log(source_default.cyan(`Active Profiles: ${jobs.map((j) => j.name).join(", ")}
+    if (isGlobalScheduler) {
+      console.log(source_default.cyan(`Mode: Global daemon (all enabled jobs, auto-discovers new jobs)`));
+      console.log(source_default.cyan(`Currently registered: ${jobs.map((j) => j.name).join(", ")}
 `));
+    } else {
+      console.log(source_default.cyan(`Active Profile: ${jobs.map((j) => j.name).join(", ")}
+`));
+    }
     const activeJobs = new Set;
-    for (const job of jobs) {
-      const intervalDelay = job.intervalMs || 1e4;
-      const stateDbPath = path7.join(os4.homedir(), ".hsync", "state", `${job.id}.db`);
-      const triggerSyncRun = async () => {
-        if (activeJobs.has(job.id)) {
-          console.log(source_default.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) => {
-          const time = new Date().toLocaleTimeString();
-          if (event.type === "start") {
-            console.log(source_default.blue(`[${time}] [Sync: ${job.name}] Running scan...`));
-          } else if (event.type === "scan-complete") {
-            console.log(source_default.blue(`[${time}] [Sync: ${job.name}] Scan completed.`));
-          } else if (event.type === "upload-complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Uploaded: ${event.path}`));
-          } else if (event.type === "download-complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Downloaded: ${event.path}`));
-          } else if (event.type === "conflict") {
-            console.log(source_default.yellow(`[${time}] [Sync: ${job.name}] ⚠ Conflict resolved for: ${event.path}`));
-          } else if (event.type === "error") {
-            console.error(source_default.red(`[${time}] [Sync: ${job.name}] ✘ Error on "${event.path}": ${event.error?.message}`));
-          } else if (event.type === "complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Sync pass completed successfully.`));
-          }
+    const scheduledJobs = new Map;
+    await reconcileSchedules(activeJobs, scheduledJobs, foregroundJobName);
+    if (isGlobalScheduler) {
+      setInterval(() => {
+        reconcileSchedules(activeJobs, scheduledJobs).catch((reconcileErr) => {
+          console.error(source_default.red(`[Scheduler] Failed to refresh job list: ${reconcileErr.message}`));
         });
-        try {
-          await engine.run();
-        } catch (runErr) {
-          console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${job.name}] Sync crash: ${runErr.message}`));
-        } finally {
-          activeJobs.delete(job.id);
-        }
-      };
-      triggerSyncRun();
-      setInterval(triggerSyncRun, intervalDelay);
+      }, RECONCILE_INTERVAL_MS);
     }
   } catch (err) {
     console.error(source_default.red(`Scheduler crashed: ${err.message}`));
     process.exit(1);
   }
 }
+async function showSyncStatus() {
+  try {
+    const globalFile = path7.join(getHsyncDir(), "daemon.pid");
+    const globalDaemon = await readPidRecord(globalFile);
+    const config = await loadConfig();
+    const enabledJobs = (config.syncJobs || []).filter((j) => j.enabled);
+    if (!globalDaemon) {
+      console.log(source_default.yellow("Global sync daemon is not running."));
+      console.log(source_default.gray("Start it with: hsync sync start --daemon"));
+      if (enabledJobs.length > 0) {
+        console.log(source_default.gray(`Registered jobs waiting: ${enabledJobs.map((j) => j.name).join(", ")}`));
+      }
+      return;
+    }
+    console.log(source_default.cyan(`
+=== Global Sync Daemon ===`));
+    console.log(`Status: ${source_default.green("running")} (PID: ${globalDaemon.pid})`);
+    if (enabledJobs.length === 0) {
+      console.log(source_default.yellow("No enabled sync jobs registered yet."));
+    } else {
+      console.log(`Jobs: ${enabledJobs.map((j) => j.name).join(", ")}`);
+      console.log(source_default.gray("New jobs are picked up automatically within ~10 seconds."));
+    }
+    console.log();
+  } catch (err) {
+    console.error(source_default.red(`Error checking sync status: ${err.message}`));
+  }
+}
 async function stopSyncScheduler(name) {
   try {
-    const hsyncDir = path7.join(os4.homedir(), ".hsync");
     if (name) {
-      const pidFile = path7.join(hsyncDir, `daemon-${name}.pid`);
+      console.log(source_default.yellow(`The sync daemon manages all jobs together. Stopping global daemon (includes "${name}")...`));
+    }
+    const globalFile = path7.join(getHsyncDir(), "daemon.pid");
+    const globalDaemon = await readPidRecord(globalFile);
+    if (globalDaemon) {
+      process.kill(globalDaemon.pid, "SIGTERM");
       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}".`));
-      }
+        await fs6.unlink(globalFile);
+      } catch {}
+      console.log(source_default.green(`✔ Global sync daemon stopped (PID: ${globalDaemon.pid}).`));
     } 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 {}
-        }
+      console.log(source_default.yellow("Global sync daemon is not running."));
+      console.log(source_default.gray("Check with: hsync sync status"));
+    }
+    const legacyDaemons = await listAllDaemonPids();
+    for (const daemon of legacyDaemons) {
+      if (daemon.jobName === "all jobs") {
+        continue;
       }
+      try {
+        process.kill(daemon.pid, "SIGTERM");
+      } catch {}
+      try {
+        await fs6.unlink(daemon.pidFile);
+      } catch {}
+      console.log(source_default.green(`✔ Stopped legacy per-job daemon (PID: ${daemon.pid}) for ${daemon.jobName}.`));
     }
   } catch (err) {
     console.error(source_default.red(`Error stopping daemon: ${err.message}`));
@@ -70583,6 +70797,172 @@ import { exec } from "child_process";
 import fs7 from "fs/promises";
 import path8 from "path";
 import os5 from "os";
+function getHsyncDir2() {
+  return path8.join(os5.homedir(), ".hsync");
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function jobNameFromPidFile2(filename) {
+  if (filename === "daemon.pid") {
+    return "all jobs";
+  }
+  return filename.replace("daemon-", "").replace(".pid", "");
+}
+async function readPidRecord2(pidFile) {
+  try {
+    const pidText = await fs7.readFile(pidFile, "utf8");
+    const pid = parseInt(pidText.trim(), 10);
+    if (isNaN(pid)) {
+      await fs7.unlink(pidFile);
+      return null;
+    }
+    if (!isProcessAlive2(pid)) {
+      await fs7.unlink(pidFile);
+      return null;
+    }
+    return { pid };
+  } catch {
+    return null;
+  }
+}
+async function listAllDaemonPids2() {
+  const hsyncDir = getHsyncDir2();
+  const results = [];
+  try {
+    const files = await fs7.readdir(hsyncDir);
+    for (const file of files) {
+      if (!file.startsWith("daemon") || !file.endsWith(".pid")) {
+        continue;
+      }
+      const pidFile = path8.join(hsyncDir, file);
+      const record = await readPidRecord2(pidFile);
+      if (record) {
+        results.push({
+          pidFile,
+          pid: record.pid,
+          jobName: jobNameFromPidFile2(file)
+        });
+      }
+    }
+  } catch {}
+  return results;
+}
+var RECONCILE_INTERVAL_MS2 = 1e4;
+async function executeSyncPass2(jobId, activeJobs) {
+  if (activeJobs.has(jobId)) {
+    const config = await loadConfig();
+    const busyJob = config.syncJobs?.find((j) => j.id === jobId);
+    const busyName = busyJob?.name || jobId;
+    console.log(source_default.yellow(`[${new Date().toLocaleTimeString()}] [Sync: ${busyName}] Skip run — previous run still in progress.`));
+    return;
+  }
+  const freshConfig = await loadConfig();
+  const freshServerUrl = freshConfig.serverUrl;
+  const freshApiKey = freshConfig.apiKey;
+  const freshJob = freshConfig.syncJobs?.find((j) => j.id === jobId);
+  if (!freshJob) {
+    return;
+  }
+  if (!freshServerUrl || !freshApiKey) {
+    console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${freshJob.name}] Missing server URL or API key. Run: hsync login`));
+    return;
+  }
+  if (!freshJob.enabled) {
+    return;
+  }
+  activeJobs.add(jobId);
+  const stateDbPath = path8.join(getHsyncDir2(), "state", `${freshJob.id}.db`);
+  const engine = new SyncEngine(freshJob, freshServerUrl, freshApiKey, stateDbPath);
+  let uploadCount = 0;
+  let downloadCount = 0;
+  let skipCount = 0;
+  let errorCount = 0;
+  engine.on((event) => {
+    const time = new Date().toLocaleTimeString();
+    if (event.type === "start") {
+      console.log(source_default.blue(`[${time}] [Sync: ${freshJob.name}] Running scan...`));
+    } else if (event.type === "scan-complete") {
+      console.log(source_default.blue(`[${time}] [Sync: ${freshJob.name}] Scan completed.`));
+    } else if (event.type === "upload-complete") {
+      uploadCount++;
+      console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Uploaded: ${event.path}`));
+    } else if (event.type === "download-complete") {
+      downloadCount++;
+      console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Downloaded: ${event.path}`));
+    } else if (event.type === "skip") {
+      skipCount++;
+    } else if (event.type === "conflict") {
+      console.log(source_default.yellow(`[${time}] [Sync: ${freshJob.name}] ⚠ Conflict resolved for: ${event.path}`));
+    } else if (event.type === "error") {
+      errorCount++;
+      console.error(source_default.red(`[${time}] [Sync: ${freshJob.name}] ✘ Error on "${event.path}": ${event.error?.message}`));
+    } else if (event.type === "complete") {
+      const summary = `${uploadCount} uploaded, ${downloadCount} downloaded, ${skipCount} unchanged`;
+      if (uploadCount === 0 && downloadCount === 0 && errorCount === 0) {
+        console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Sync pass completed (${summary}).`));
+      } else {
+        console.log(source_default.green(`[${time}] [Sync: ${freshJob.name}] ✔ Sync pass completed successfully (${summary}).`));
+      }
+    }
+  });
+  try {
+    await engine.run();
+  } catch (runErr) {
+    console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${freshJob.name}] Sync crash: ${runErr.message}`));
+  } finally {
+    activeJobs.delete(jobId);
+  }
+}
+function scheduleSyncJob2(job, activeJobs, scheduledJobs) {
+  const intervalDelay = job.intervalMs || 1e4;
+  const triggerSyncRun = async () => {
+    await executeSyncPass2(job.id, activeJobs);
+  };
+  triggerSyncRun();
+  const intervalId = setInterval(triggerSyncRun, intervalDelay);
+  scheduledJobs.set(job.id, { intervalId, intervalMs: intervalDelay });
+  console.log(source_default.green(`[${new Date().toLocaleTimeString()}] [Scheduler] Registered: ${job.name} (every ${intervalDelay / 1000}s)`));
+}
+function unscheduleSyncJob2(jobId, jobName, scheduledJobs) {
+  const entry = scheduledJobs.get(jobId);
+  if (!entry) {
+    return;
+  }
+  clearInterval(entry.intervalId);
+  scheduledJobs.delete(jobId);
+  console.log(source_default.yellow(`[${new Date().toLocaleTimeString()}] [Scheduler] Unregistered: ${jobName || jobId}`));
+}
+async function reconcileSchedules2(activeJobs, scheduledJobs, singleJobName) {
+  const config = await loadConfig();
+  let jobs = (config.syncJobs || []).filter((j) => j.enabled);
+  if (singleJobName) {
+    jobs = jobs.filter((j) => j.name === singleJobName);
+  }
+  const enabledIds = new Set(jobs.map((j) => j.id));
+  for (const [jobId, entry] of scheduledJobs) {
+    if (!enabledIds.has(jobId)) {
+      const staleJob = config.syncJobs?.find((j) => j.id === jobId);
+      unscheduleSyncJob2(jobId, staleJob?.name, scheduledJobs);
+      continue;
+    }
+    const job = jobs.find((j) => j.id === jobId);
+    if (job && entry.intervalMs !== (job.intervalMs || 1e4)) {
+      unscheduleSyncJob2(jobId, job.name, scheduledJobs);
+      scheduleSyncJob2(job, activeJobs, scheduledJobs);
+    }
+  }
+  for (const job of jobs) {
+    if (!scheduledJobs.has(job.id)) {
+      scheduleSyncJob2(job, activeJobs, scheduledJobs);
+    }
+  }
+}
 function parseRemoteTarget3(target) {
   const parts = target.split(":");
   const slug = parts[0];
@@ -70591,37 +70971,44 @@ function parseRemoteTarget3(target) {
 }
 async function startSyncScheduler2(name, options) {
   const isDaemon = options?.daemon;
-  const hsyncDir = path8.join(os5.homedir(), ".hsync");
-  const pidFile = path8.join(hsyncDir, name ? `daemon-${name}.pid` : "daemon.pid");
+  let foregroundJobName = name;
+  const hsyncDir = getHsyncDir2();
+  const globalPidFile = path8.join(hsyncDir, "daemon.pid");
+  if (isDaemon && foregroundJobName) {
+    console.log(source_default.yellow(`The sync daemon manages all enabled jobs. Starting global daemon instead of "${foregroundJobName}" only.`));
+    foregroundJobName = undefined;
+  }
   if (isDaemon) {
     await fs7.mkdir(hsyncDir, { recursive: true });
-    try {
-      const existingPidText = await fs7.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 = path8.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 fs7.open(logFile, "w");
-    const subprocess = Bun.spawn([process.argv[0], ...filteredArgs], {
+    const existing = await readPidRecord2(globalPidFile);
+    if (existing) {
+      console.log(source_default.yellow(`Warning: Sync daemon is already running (PID: ${existing.pid}).`));
+      console.log(source_default.gray("New sync jobs are picked up automatically — no restart needed."));
+      return;
+    }
+    const legacyDaemons = await listAllDaemonPids2();
+    const perJobDaemons = legacyDaemons.filter((d) => d.jobName !== "all jobs");
+    if (perJobDaemons.length > 0) {
+      console.log(source_default.yellow("Warning: Legacy per-job daemons are still running. Stop them with: hsync sync stop"));
+    }
+    const logFile = path8.join(hsyncDir, "daemon.log");
+    console.log(source_default.cyan(`⚙️ Starting global sync daemon in the background...`));
+    const bunExec = process.execPath;
+    const scriptPath = Bun.main;
+    const spawnArgs = ["sync", "start"];
+    const logFileHandle = await fs7.open(logFile, "a");
+    const subprocess = Bun.spawn([bunExec, scriptPath, ...spawnArgs], {
       detached: true,
       stdout: logFileHandle.fd,
       stderr: logFileHandle.fd,
       stdin: "ignore"
     });
-    const pid = subprocess.pid;
-    await fs7.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}`);
+    await logFileHandle.close();
+    console.log(source_default.green(`✔ Global sync daemon started successfully!`));
+    console.log(source_default.gray("All enabled sync jobs will be scheduled automatically."));
+    console.log(`Logs: hsync sync logs -f`);
+    console.log(source_default.gray("Stop with: hsync sync stop"));
     return;
   }
   try {
@@ -70632,11 +71019,12 @@ async function startSyncScheduler2(name, options) {
       console.error(source_default.red("Error: CLI not authenticated. Please run: hsync config set-server <url> && hsync login"));
       process.exit(1);
     }
+    const isGlobalScheduler = !foregroundJobName;
     let jobs = config.syncJobs || [];
-    if (name) {
-      jobs = jobs.filter((j) => j.name === name);
+    if (foregroundJobName) {
+      jobs = jobs.filter((j) => j.name === foregroundJobName);
       if (jobs.length === 0) {
-        console.error(source_default.red(`Error: Sync job named "${name}" was not found or is disabled.`));
+        console.error(source_default.red(`Error: Sync job named "${foregroundJobName}" was not found or is disabled.`));
         process.exit(1);
       }
     } else {
@@ -70647,10 +71035,10 @@ async function startSyncScheduler2(name, options) {
       return;
     }
     await fs7.mkdir(hsyncDir, { recursive: true });
-    await fs7.writeFile(pidFile, process.pid.toString(), "utf8");
+    await fs7.writeFile(globalPidFile, process.pid.toString(), "utf8");
     const cleanPidFile = async () => {
       try {
-        await fs7.unlink(pidFile);
+        await fs7.unlink(globalPidFile);
       } catch {}
     };
     process.on("SIGINT", async () => {
@@ -70664,47 +71052,23 @@ async function startSyncScheduler2(name, options) {
     console.log(source_default.cyan(`
 === Starting Sync Scheduler Service ===`));
     console.log(source_default.cyan(`Target Server: ${serverUrl}`));
-    console.log(source_default.cyan(`Active Profiles: ${jobs.map((j) => j.name).join(", ")}
+    if (isGlobalScheduler) {
+      console.log(source_default.cyan(`Mode: Global daemon (all enabled jobs, auto-discovers new jobs)`));
+      console.log(source_default.cyan(`Currently registered: ${jobs.map((j) => j.name).join(", ")}
 `));
+    } else {
+      console.log(source_default.cyan(`Active Profile: ${jobs.map((j) => j.name).join(", ")}
+`));
+    }
     const activeJobs = new Set;
-    for (const job of jobs) {
-      const intervalDelay = job.intervalMs || 1e4;
-      const stateDbPath = path8.join(os5.homedir(), ".hsync", "state", `${job.id}.db`);
-      const triggerSyncRun = async () => {
-        if (activeJobs.has(job.id)) {
-          console.log(source_default.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) => {
-          const time = new Date().toLocaleTimeString();
-          if (event.type === "start") {
-            console.log(source_default.blue(`[${time}] [Sync: ${job.name}] Running scan...`));
-          } else if (event.type === "scan-complete") {
-            console.log(source_default.blue(`[${time}] [Sync: ${job.name}] Scan completed.`));
-          } else if (event.type === "upload-complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Uploaded: ${event.path}`));
-          } else if (event.type === "download-complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Downloaded: ${event.path}`));
-          } else if (event.type === "conflict") {
-            console.log(source_default.yellow(`[${time}] [Sync: ${job.name}] ⚠ Conflict resolved for: ${event.path}`));
-          } else if (event.type === "error") {
-            console.error(source_default.red(`[${time}] [Sync: ${job.name}] ✘ Error on "${event.path}": ${event.error?.message}`));
-          } else if (event.type === "complete") {
-            console.log(source_default.green(`[${time}] [Sync: ${job.name}] ✔ Sync pass completed successfully.`));
-          }
+    const scheduledJobs = new Map;
+    await reconcileSchedules2(activeJobs, scheduledJobs, foregroundJobName);
+    if (isGlobalScheduler) {
+      setInterval(() => {
+        reconcileSchedules2(activeJobs, scheduledJobs).catch((reconcileErr) => {
+          console.error(source_default.red(`[Scheduler] Failed to refresh job list: ${reconcileErr.message}`));
         });
-        try {
-          await engine.run();
-        } catch (runErr) {
-          console.error(source_default.red(`[${new Date().toLocaleTimeString()}] [Sync: ${job.name}] Sync crash: ${runErr.message}`));
-        } finally {
-          activeJobs.delete(job.id);
-        }
-      };
-      triggerSyncRun();
-      setInterval(triggerSyncRun, intervalDelay);
+      }, RECONCILE_INTERVAL_MS2);
     }
   } catch (err) {
     console.error(source_default.red(`Scheduler crashed: ${err.message}`));
@@ -70713,40 +71077,33 @@ async function startSyncScheduler2(name, options) {
 }
 async function stopSyncScheduler2(name) {
   try {
-    const hsyncDir = path8.join(os5.homedir(), ".hsync");
     if (name) {
-      const pidFile = path8.join(hsyncDir, `daemon-${name}.pid`);
+      console.log(source_default.yellow(`The sync daemon manages all jobs together. Stopping global daemon (includes "${name}")...`));
+    }
+    const globalFile = path8.join(getHsyncDir2(), "daemon.pid");
+    const globalDaemon = await readPidRecord2(globalFile);
+    if (globalDaemon) {
+      process.kill(globalDaemon.pid, "SIGTERM");
       try {
-        const pidText = await fs7.readFile(pidFile, "utf8");
-        const pid = parseInt(pidText.trim(), 10);
-        process.kill(pid, "SIGTERM");
-        await fs7.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}".`));
-      }
+        await fs7.unlink(globalFile);
+      } catch {}
+      console.log(source_default.green(`✔ Global sync daemon stopped (PID: ${globalDaemon.pid}).`));
     } else {
-      const files = await fs7.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 = path8.join(hsyncDir, file);
-        try {
-          const pidText = await fs7.readFile(pidFile, "utf8");
-          const pid = parseInt(pidText.trim(), 10);
-          process.kill(pid, "SIGTERM");
-          await fs7.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 fs7.unlink(pidFile);
-          } catch {}
-        }
+      console.log(source_default.yellow("Global sync daemon is not running."));
+      console.log(source_default.gray("Check with: hsync sync status"));
+    }
+    const legacyDaemons = await listAllDaemonPids2();
+    for (const daemon of legacyDaemons) {
+      if (daemon.jobName === "all jobs") {
+        continue;
       }
+      try {
+        process.kill(daemon.pid, "SIGTERM");
+      } catch {}
+      try {
+        await fs7.unlink(daemon.pidFile);
+      } catch {}
+      console.log(source_default.green(`✔ Stopped legacy per-job daemon (PID: ${daemon.pid}) for ${daemon.jobName}.`));
     }
   } catch (err) {
     console.error(source_default.red(`Error stopping daemon: ${err.message}`));
@@ -70866,7 +71223,7 @@ async function editSyncJob2(name, options) {
 }
 
 // src/commands/ui.ts
-var __dirname = "/media/hyper2/HYPER/projects/node/hmd/file-sync-v2/packages/cli/src/commands";
+var __dirname = "/home/hamid/packages/node/hmd/file-sync/packages/cli/src/commands";
 function openBrowser(url2) {
   const start = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   exec(`${start} ${url2}`).unref();
@@ -70914,29 +71271,22 @@ async function startUiServer(options) {
   });
   localRouter.get("/jobs/:name/status", async (req, res) => {
     try {
-      const jobName = req.params.name;
-      const hsyncDir = path9.join(os6.homedir(), ".hsync");
-      const pidFile = path9.join(hsyncDir, `daemon-${jobName}.pid`);
-      const globalPidFile = path9.join(hsyncDir, "daemon.pid");
+      const globalPidFile = path9.join(os6.homedir(), ".hsync", "daemon.pid");
       let pidText = "";
       try {
-        pidText = await fs8.readFile(pidFile, "utf8");
+        pidText = await fs8.readFile(globalPidFile, "utf8");
       } catch {
-        try {
-          pidText = await fs8.readFile(globalPidFile, "utf8");
-        } catch {
-          return res.json({ running: false });
-        }
+        return res.json({ running: false, mode: "global" });
       }
       const pid = parseInt(pidText.trim(), 10);
       if (isNaN(pid)) {
-        return res.json({ running: false });
+        return res.json({ running: false, mode: "global" });
       }
       try {
         process.kill(pid, 0);
-        res.json({ running: true, pid });
+        res.json({ running: true, pid, mode: "global" });
       } catch {
-        res.json({ running: false });
+        res.json({ running: false, mode: "global" });
       }
     } catch (err) {
       res.status(500).json({ error: err.message });
@@ -70944,18 +71294,16 @@ async function startUiServer(options) {
   });
   localRouter.post("/jobs/:name/start", async (req, res) => {
     try {
-      const jobName = req.params.name;
-      await startSyncScheduler2(jobName, { daemon: true });
-      res.json({ success: true });
+      await startSyncScheduler2(undefined, { daemon: true });
+      res.json({ success: true, mode: "global" });
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
   });
   localRouter.post("/jobs/:name/stop", async (req, res) => {
     try {
-      const jobName = req.params.name;
-      await stopSyncScheduler2(jobName);
-      res.json({ success: true });
+      await stopSyncScheduler2();
+      res.json({ success: true, mode: "global" });
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
@@ -71100,7 +71448,7 @@ Press Ctrl+C to stop the server...
 // package.json
 var package_default = {
   name: "hsync-cli",
-  version: "1.1.1",
+  version: "1.1.3",
   description: "hsync CLI for file sync operations",
   bin: {
     hsync: "./dist/bin.js"
@@ -71177,12 +71525,15 @@ 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").option("-d, --daemon", "Run synchronization service in the background (detached daemon mode)").action(async (name, options) => {
+syncCmd.command("start [name]").description("Start sync scheduler (use --daemon to run all jobs in background)").option("-d, --daemon", "Run global sync daemon for all enabled jobs in the background").action(async (name, options) => {
   await startSyncScheduler(name, options);
 });
-syncCmd.command("stop [name]").description("Stop active background synchronization scheduler daemon").action(async (name) => {
+syncCmd.command("stop [name]").description("Stop the global background sync daemon").action(async (name) => {
   await stopSyncScheduler(name);
 });
+syncCmd.command("status").description("Show active background sync daemons").action(async () => {
+  await showSyncStatus();
+});
 syncCmd.command("autostart <action>").description('Configure hsync sync autostart daemon on login (action: "enable" | "disable")').action(async (action) => {
   if (action === "enable") {
     await configureAutostart(true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsync-cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "hsync CLI for file sync operations",
   "bin": {
     "hsync": "./dist/bin.js"