feat: integrate rclone WebDAV backup for PC-to-PC file sync

Source PC serves backups/ folder via rclone WebDAV server (auto-starts with app).
Receiver PC pulls backups on schedule using rclone sync.
Network Backup UI now has two tabs: Rclone and API Key.
Rclone installed automatically via postinstall script.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

apps/Backend/src/app.ts

@@ -10,6 +10,7 @@ import { authenticateJWT } from "./middlewares/auth.middleware";
 import networkBackupPublicRoutes from "./routes/network-backup-public";
 import dotenv from "dotenv";
 import { startBackupCron } from "./cron/backupCheck";
+import { autoStartServer } from "./services/rcloneService";
 import path from "path";
 
 dotenv.config();
@@ -87,5 +88,6 @@ app.use(errorHandler);
 
 //startig cron job
 startBackupCron();
+autoStartServer();
 
 export default app;

apps/Backend/src/cron/backupCheck.ts

@@ -6,6 +6,8 @@ import { backupDatabaseToPath } from "../services/databaseBackupService";
 import { cronJobLogStorage } from "../storage/cron-job-log-storage";
 import { readSyncConfig, writeSyncConfig } from "../services/networkSyncConfigService";
 import { runNetworkSync, runNetworkFilesSync } from "../services/networkSyncService";
+import { readRcloneConfig, writeRcloneConfig } from "../services/rcloneConfigService";
+import { runRclonePull } from "../services/rcloneService";
 
 // Local backup folder in the app root (apps/Backend/backups)
 const LOCAL_BACKUP_DIR = path.resolve(process.cwd(), "backups");
@@ -174,6 +176,42 @@ export const startBackupCron = () => {
     console.log("✅ [9 PM] USB backup complete.");
   });
 
+  // ============================================================
+  // Every hour — Rclone backup (runs only when hour matches config)
+  // ============================================================
+  cron.schedule("0 * * * *", async () => {
+    const rcloneConfig = readRcloneConfig();
+    if (!rcloneConfig.receiverEnabled || !rcloneConfig.sourceIp) return;
+
+    const currentHour = new Date().getHours();
+    if (currentHour !== rcloneConfig.receiverSyncHour) return;
+
+    console.log(`[${rcloneConfig.receiverSyncHour}:00] Running rclone pull from ${rcloneConfig.sourceIp}...`);
+
+    const admin = await getAdminUser();
+    const startedAt = new Date();
+    const log = await cronJobLogStorage.createJobLog("rclone-backup", startedAt);
+
+    try {
+      await runRclonePull();
+      writeRcloneConfig({ lastSyncAt: new Date().toISOString(), lastSyncStatus: "success", lastSyncError: null });
+      await cronJobLogStorage.completeJobLog(log.id, "success", new Date());
+      console.log(`Rclone backup complete.`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      console.error("Rclone backup failed:", err);
+      writeRcloneConfig({ lastSyncAt: new Date().toISOString(), lastSyncStatus: "failed", lastSyncError: errorMessage });
+      await cronJobLogStorage.completeJobLog(log.id, "failed", new Date(), errorMessage);
+      if (admin) {
+        await storage.createNotification(
+          admin.id,
+          "BACKUP",
+          `Rclone backup failed: ${errorMessage}`
+        );
+      }
+    }
+  });
+
   // ============================================================
   // Every hour — Network sync (runs only when hour matches config)
   // ============================================================

apps/Backend/src/routes/database-management.ts

@@ -15,6 +15,8 @@ import {
   writeSyncConfig,
 } from "../services/networkSyncConfigService";
 import { runNetworkSync, runNetworkFilesSync } from "../services/networkSyncService";
+import { readRcloneConfig, writeRcloneConfig } from "../services/rcloneConfigService";
+import { checkRcloneInstalled, isServerRunning, startWebDavServer, stopWebDavServer, runRclonePull } from "../services/rcloneService";
 
 const UPLOADS_DIR = path.join(process.cwd(), "uploads");
 
@@ -605,4 +607,63 @@ router.post("/network-sync-now", async (req: Request, res: Response): Promise<an
   }
 });
 
+// ==============================
+// Rclone Backup
+// ==============================
+
+router.get("/rclone-config", (req, res) => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+  res.json(readRcloneConfig());
+});
+
+router.put("/rclone-config", (req: Request, res: Response): any => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+  const { serverEnabled, serverPort, receiverEnabled, receiverSyncHour, sourceIp, sourcePort } = req.body;
+  const patch: any = {};
+  if (typeof serverEnabled === "boolean") patch.serverEnabled = serverEnabled;
+  if (typeof serverPort === "number") patch.serverPort = serverPort;
+  if (typeof receiverEnabled === "boolean") patch.receiverEnabled = receiverEnabled;
+  if (typeof receiverSyncHour === "number") patch.receiverSyncHour = receiverSyncHour;
+  if (typeof sourceIp === "string") patch.sourceIp = sourceIp.trim();
+  if (typeof sourcePort === "number") patch.sourcePort = sourcePort;
+  const updated = writeRcloneConfig(patch);
+  res.json(updated);
+});
+
+router.get("/rclone-status", async (req, res) => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+  const installed = await checkRcloneInstalled();
+  const serverRunning = isServerRunning();
+  res.json({ installed, serverRunning });
+});
+
+router.post("/rclone-server/start", async (req: Request, res: Response): Promise<any> => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+  try {
+    await startWebDavServer();
+    res.json({ success: true, running: true });
+  } catch (err: any) {
+    res.status(500).json({ error: "Failed to start rclone server", details: err.message });
+  }
+});
+
+router.post("/rclone-server/stop", (req: Request, res: Response): any => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+  stopWebDavServer();
+  res.json({ success: true, running: false });
+});
+
+router.post("/rclone-pull-now", async (req: Request, res: Response): Promise<any> => {
+  if (!req.user?.id) return res.status(401).json({ error: "Unauthorized" });
+
+  try {
+    await runRclonePull();
+    writeRcloneConfig({ lastSyncAt: new Date().toISOString(), lastSyncStatus: "success", lastSyncError: null });
+    res.json({ success: true, syncedAt: new Date() });
+  } catch (err: any) {
+    writeRcloneConfig({ lastSyncAt: new Date().toISOString(), lastSyncStatus: "failed", lastSyncError: err.message });
+    res.status(500).json({ error: "Rclone pull failed", details: err.message });
+  }
+});
+
 export default router;

apps/Backend/src/services/rcloneConfigService.ts

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+
+const CONFIG_FILE = path.resolve(process.cwd(), "rclone-config.json");
+
+export const RCLONE_USER = "MyDentalApp";
+export const RCLONE_PASS = "SuperSecret!@2026";
+
+export interface RcloneConfig {
+  // Source role: serve backups folder via WebDAV
+  serverEnabled: boolean;
+  serverPort: number;
+
+  // Receiver role: pull backups from source PC
+  receiverEnabled: boolean;
+  receiverSyncHour: number;
+  sourceIp: string;
+  sourcePort: number;
+  lastSyncAt: string | null;
+  lastSyncStatus: string | null;
+  lastSyncError: string | null;
+}
+
+const DEFAULT_CONFIG: RcloneConfig = {
+  serverEnabled: false,
+  serverPort: 8080,
+  receiverEnabled: false,
+  receiverSyncHour: 21,
+  sourceIp: "",
+  sourcePort: 8080,
+  lastSyncAt: null,
+  lastSyncStatus: null,
+  lastSyncError: null,
+};
+
+export function readRcloneConfig(): RcloneConfig {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      return { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")) };
+    } catch {}
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+export function writeRcloneConfig(patch: Partial<RcloneConfig>): RcloneConfig {
+  const current = readRcloneConfig();
+  const updated = { ...current, ...patch };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), "utf8");
+  return updated;
+}

apps/Backend/src/services/rcloneService.ts

@@ -0,0 +1,140 @@
+import { spawn, ChildProcess } from "child_process";
+import path from "path";
+import { readRcloneConfig, RCLONE_USER, RCLONE_PASS } from "./rcloneConfigService";
+
+const LOCAL_BACKUP_DIR = path.resolve(process.cwd(), "backups");
+
+let serverProcess: ChildProcess | null = null;
+
+export function checkRcloneInstalled(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn("rclone", ["version"]);
+    proc.on("error", () => resolve(false));
+    proc.on("close", (code) => resolve(code === 0));
+  });
+}
+
+function obscurePassword(password: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("rclone", ["obscure", password]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => (stdout += d.toString()));
+    proc.stderr.on("data", (d) => (stderr += d.toString()));
+    proc.on("error", (err) => reject(new Error(`Failed to run rclone obscure: ${err.message}`)));
+    proc.on("close", (code) => {
+      if (code !== 0) return reject(new Error(`rclone obscure failed: ${stderr}`));
+      resolve(stdout.trim());
+    });
+  });
+}
+
+export function isServerRunning(): boolean {
+  return serverProcess !== null && serverProcess.exitCode === null;
+}
+
+// Source PC: rclone serve webdav ./backups --addr :8080 --user MyDentalApp --pass SuperSecret!@2026
+export async function startWebDavServer(): Promise<void> {
+  if (isServerRunning()) return;
+
+  const installed = await checkRcloneInstalled();
+  if (!installed) {
+    throw new Error("rclone is not installed. Run: curl https://rclone.org/install.sh | sudo bash");
+  }
+
+  const config = readRcloneConfig();
+
+  const args = [
+    "serve", "webdav",
+    LOCAL_BACKUP_DIR,
+    "--addr", `:${config.serverPort}`,
+    "--user", RCLONE_USER,
+    "--pass", RCLONE_PASS,
+    "--read-only",
+  ];
+
+  serverProcess = spawn("rclone", args, { stdio: "pipe" });
+
+  serverProcess.stdout?.on("data", (d) => console.log(`[rclone-server] ${d.toString().trim()}`));
+  serverProcess.stderr?.on("data", (d) => console.log(`[rclone-server] ${d.toString().trim()}`));
+
+  serverProcess.on("error", (err) => {
+    console.error("[rclone-server] Failed to start:", err.message);
+    serverProcess = null;
+  });
+
+  serverProcess.on("close", (code) => {
+    console.log(`[rclone-server] Exited with code ${code}`);
+    serverProcess = null;
+  });
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  if (!isServerRunning()) {
+    throw new Error("rclone WebDAV server failed to start");
+  }
+
+  console.log(`[rclone-server] WebDAV server started on port ${config.serverPort}`);
+}
+
+export function stopWebDavServer(): void {
+  if (serverProcess && serverProcess.exitCode === null) {
+    serverProcess.kill("SIGTERM");
+    serverProcess = null;
+    console.log("[rclone-server] WebDAV server stopped");
+  }
+}
+
+// Receiver PC: rclone sync :webdav:/ ./backups --webdav-url http://IP:PORT --webdav-user MyDentalApp --webdav-pass OBSCURED
+export async function runRclonePull(): Promise<void> {
+  const config = readRcloneConfig();
+  if (!config.sourceIp || !config.sourcePort) {
+    throw new Error("Rclone receiver configuration is incomplete — source IP and port are required");
+  }
+
+  const installed = await checkRcloneInstalled();
+  if (!installed) {
+    throw new Error("rclone is not installed. Run: curl https://rclone.org/install.sh | sudo bash");
+  }
+
+  const obscuredPass = await obscurePassword(RCLONE_PASS);
+  const webdavUrl = `http://${config.sourceIp}:${config.sourcePort}`;
+
+  const args = [
+    "sync",
+    `:webdav:/`,
+    LOCAL_BACKUP_DIR,
+    "--webdav-url", webdavUrl,
+    "--webdav-user", RCLONE_USER,
+    "--webdav-pass", obscuredPass,
+    "-v",
+  ];
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn("rclone", args);
+
+    let stderr = "";
+    proc.stdout.on("data", (d) => console.log(`[rclone-pull] ${d.toString().trim()}`));
+    proc.stderr.on("data", (d) => {
+      const line = d.toString().trim();
+      stderr += line + "\n";
+      console.log(`[rclone-pull] ${line}`);
+    });
+    proc.on("error", (err) => reject(new Error(`Failed to start rclone: ${err.message}`)));
+    proc.on("close", (code) => {
+      if (code !== 0) return reject(new Error(`rclone exited with code ${code}: ${stderr}`));
+      resolve();
+    });
+  });
+}
+
+export async function autoStartServer(): Promise<void> {
+  const config = readRcloneConfig();
+  if (config.serverEnabled) {
+    try {
+      await startWebDavServer();
+    } catch (err) {
+      console.error("[rclone-server] Auto-start failed:", err);
+    }
+  }
+}