hsync-cli 1.1.1 → 1.1.2

package/dist/bin.js

@@ -70153,6 +70153,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 +70372,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 +70425,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 +70473,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 +70489,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 +70506,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 +70764,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 +70938,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 +70986,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 +71002,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 +71019,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 +71044,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}`));
@@ -70914,29 +71238,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 +71261,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 +71415,7 @@ Press Ctrl+C to stop the server...
 // package.json
 var package_default = {
   name: "hsync-cli",
-  version: "1.1.1",
+  version: "1.1.2",
   description: "hsync CLI for file sync operations",
   bin: {
     hsync: "./dist/bin.js"
@@ -71177,12 +71492,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.2",
   "description": "hsync CLI for file sync operations",
   "bin": {
     "hsync": "./dist/bin.js"