sftp-push-sync 1.0.21 → 2.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [2.0.0] - 2025-11-18
+
+### Breaking
+
+- CLI flags renamed:
+  - `--upload-list` → `--sidecar-upload`
+  - `--download-list` → `--sidecar-download`
+- Configuration per connection restructured:
+  - `localRoot` / `remoteRoot` now under `sync`
+  - `sidecar` block for sidecar uploads/downloads
+
+### Added
+
+- Separate `sidecar.localRoot` / `sidecar.remoteRoot` für Upload-/Download-Listen.
+
+---

package/README.md

@@ -23,6 +23,12 @@ Features:
 
 The file `sftp-push-sync.mjs` is pure JavaScript (ESM), not TypeScript. Node.js can execute it directly as long as "type": "module" is specified in package.json or the file has the extension .mjs.
 
+## Breaking changes in 2.0.0
+
+- The flags `--upload-list` / `--download-list` have been replaced by
+  `--sidecar-upload` / `--sidecar-download`.
+- The settings for sidecars are now located in the `sidecar` block of the connection.
+
 ## Install
 
 ```bash
@@ -47,22 +53,40 @@ Create a `sync.config.json` in the root folder of your project:
       "port": 23,
       "user": "ftpuser",
       "password": "mypassword",
-      "remoteRoot": "/folder/",
-      "localRoot": "public",
       "syncCache": ".sync-cache.prod.json",
-      "worker": 3
+      "worker": 3,
+      "cleanupEmptyDirs": true,
+      "sync": {
+        "localRoot": "public",
+        "remoteRoot": "/folder/"
+      },
+      "sidecar": {
+        "localRoot": "sidecar-local",
+        "remoteRoot": "/sidecar-remote/",
+        "uploadList": [],
+        "downloadList": []
+      }
     },
     "staging": {
       "host": "ftpserver02",
       "port": 22,
       "user": "ftp_user",
       "password": "total_secret",
-      "remoteRoot": "/web/my-page/",
-      "localRoot": "public",
       "syncCache": ".sync-cache.staging.json",
-      "worker": 1
+      "worker": 1,
+      "sync": {
+        "localRoot": "public",
+        "remoteRoot": "/web/my-page/"
+      },
+      "sidecar": {
+        "localRoot": "sidecar-local",
+        "remoteRoot": "/sidecar-remote/",
+        "uploadList": [],
+        "downloadList": []
+      }
     }
   },
+  "cleanupEmptyDirs": true,
   "include": [],
   "exclude": ["**/.DS_Store", "**/.git/**", "**/node_modules/**"],
   "textExtensions": [".html",".xml",".txt",".json",".js",".css",".md",".svg"],
@@ -72,9 +96,7 @@ Create a `sync.config.json` in the root folder of your project:
     "analyzeChunk": 1
   },
   "logLevel": "normal",
-  "logFile": ".sftp-push-sync.{target}.log",
-  "uploadList": [],
-  "downloadList": ["download-counter.json"]
+  "logFile": ".sftp-push-sync.{target}.log"
 }
 ```
 
@@ -84,16 +106,18 @@ Create a `sync.config.json` in the root folder of your project:
 # Normal synchronisation
 node bin/sftp-push-sync.mjs staging
 
-# Consider normal synchronisation + upload list
-node bin/sftp-push-sync.mjs staging --upload-list
+# Normal synchronisation + sidecar upload list
+node bin/sftp-push-sync.mjs staging --sidecar-upload
+
+# Normal synchronisation + sidecar download list
+node bin/sftp-push-sync.mjs staging --sidecar-download
 
-# Only lists, no standard synchronisation
-node bin/sftp-push-sync.mjs staging --skip-sync --upload-list
-node bin/sftp-push-sync.mjs staging --skip-sync --download-list
-node bin/sftp-push-sync.mjs staging --skip-sync --upload-list --download-list
+# Only sidecar lists, no standard synchronisation
+node bin/sftp-push-sync.mjs staging --skip-sync --sidecar-upload
+node bin/sftp-push-sync.mjs staging --skip-sync --sidecar-download
 
 # (optional) only run lists dry
-node bin/sftp-push-sync.mjs staging --skip-sync --upload-list --dry-run
+node bin/sftp-push-sync.mjs staging --skip-sync --sidecar-upload --dry-run
 ```
 
 - Can be conveniently started via the scripts in `package.json`:
@@ -128,30 +152,29 @@ The dry run is a great way to compare files and fill the cache.
 
 A list of files that are excluded from the sync comparison and can be downloaded or uploaded separately.
 
-- `uploadList`
-  - Relative to localRoot "downloads.json"
-  - or with subfolders: "data/downloads.json"
-- `downloadList`
-  - Relative to remoteRoot "download-counter.json"
-  - or e.g. "logs/download-counter.json"
+- `sidecar.uploadList`
+  - Relative to sidecar.localRoot, e.g. "downloads.json" or "data/downloads.json"
+- `sidecar.downloadList`
+  - Relative to sidecar.remoteRoot, e.g. "download-counter.json" or "logs/download-counter.json"
 
 ```bash
 # normal synchronisation
 sftp-push-sync staging
 
-# Normal synchronisation + explicitly transfer upload list
-sftp-push-sync staging --upload-list
+# Normal synchronisation + explicitly transfer sidecar upload list
+sftp-push-sync staging --sidecar-upload
 
-# just fetch the download list from the server (combined with normal synchronisation)
-sftp-push-sync prod --download-list --dry-run   # view first
-sftp-push-sync prod --download-list             # then do
+# just fetch the sidecar download list from the server
+# combined with normal synchronisation
+sftp-push-sync prod --sidecar-download --dry-run   # view first
+sftp-push-sync prod --sidecar-download             # then do
 ```
 
-- The `sidecar` is always executed together with `sync` when you use the `--download-list` or `--upload-list` option.
-- However, with `--skip-sync`, you can exclude the sync process and only process the sidecar:
+- The sidecar is always executed together with sync when using `--sidecar-download` or `--sidecar-upload`.
+- With `--skip-sync`, you can exclude the sync process and only process the sidecar:
 
 ```bash
-sftp-push-sync prod --download-list --skip-sync
+sftp-push-sync prod --sidecar-download --skip-sync
 ```
 
 ### Logging Progress
@@ -198,6 +221,14 @@ practical excludes:
 ]
 ```
 
+### Folder handling
+
+Sync only handles files and creates missing directories during upload.
+However, it should also manage directories:
+
+- If, for example, a directory is empty because all files have been deleted from it.
+- Or if a directory no longer exists locally.
+
 ## Which files are needed?
 
 - `sync.config.json` - The configuration file (with passwords in plain text, so please leave it out of the git repository)
@@ -207,9 +238,9 @@ practical excludes:
 - The cache files: `.sync-cache.*.json`
 - The log file: `.sftp-push-sync.{target}.log` (Optional, overwritten with each run)
 
-You can safely delete the local cache at any time. The first analysis will then take longer again, because remote hashes will be streamed again. After that, everything will run fast.
+You can safely delete the local cache at any time. The first analysis will then take longer, because remote hashes will be streamed again. After that, everything will run fast.
 
-Note: The first run always takes a while, especially with lots of images – so be patient! Once the cache is full, it will be faster.
+Note: The first run always takes a while, especially with lots of media – so be patient! Once the cache is full, it will be faster.
 
 ## Example Output
 

package/bin/sftp-push-sync.mjs

@@ -8,6 +8,7 @@
  * 1. Upload new files
  * 2. Delete remote files that no longer exist locally
  * 3. Detect changes based on size or modified content and upload them
+ * 4. Supports separate sidecar upload/download lists for special files
  *
  * Features:
  *  - multiple connections in sync.config.json
@@ -25,6 +26,11 @@
  * - For example, log files or other special files.
  * - These files can be downloaded or uploaded separately.
  *
+ * Folder handling:
+ *  Delete Folders if
+ *  - If, for example, a directory is empty because all files have been deleted from it.
+ *  - Or if a directory no longer exists locally.
+ * 
  * The file sftp-push-sync.mjs is pure JavaScript (ESM), not TypeScript.
  * Node.js can execute it directly as long as "type": "module" is specified in package.json
  * or the file has the extension .mjs.
@@ -63,8 +69,8 @@ const tab_b = () => " ".repeat(6);
 const args = process.argv.slice(2);
 const TARGET = args[0];
 const DRY_RUN = args.includes("--dry-run");
-const RUN_UPLOAD_LIST = args.includes("--upload-list");
-const RUN_DOWNLOAD_LIST = args.includes("--download-list");
+const RUN_UPLOAD_LIST = args.includes("--sidecar-upload");
+const RUN_DOWNLOAD_LIST = args.includes("--sidecar-download");
 const SKIP_SYNC = args.includes("--skip-sync");
 
 // logLevel override via CLI (optional)
@@ -81,7 +87,9 @@ if (!TARGET) {
 // Wenn jemand --skip-sync ohne Listen benutzt → sinnlos, also abbrechen
 if (SKIP_SYNC && !RUN_UPLOAD_LIST && !RUN_DOWNLOAD_LIST) {
   console.error(
-    pc.red("❌ --skip-sync requires at least --upload-list or --download-list.")
+    pc.red(
+      "❌ --skip-sync requires at least --sidecar-upload or --sidecar-download."
+    )
   );
   process.exit(1);
 }
@@ -113,12 +121,11 @@ if (!CONFIG_RAW.connections || typeof CONFIG_RAW.connections !== "object") {
 // ---------------------------------------------------------------------------
 // Logging helpers (Terminal + optional Logfile)
 // ---------------------------------------------------------------------------
+
 // Default: .sync.{TARGET}.log, kann via config.logFile überschrieben werden
 const DEFAULT_LOG_FILE = `.sync.${TARGET}.log`;
 const rawLogFilePattern = CONFIG_RAW.logFile || DEFAULT_LOG_FILE;
-const LOG_FILE = path.resolve(
-  rawLogFilePattern.replace("{target}", TARGET)
-);
+const LOG_FILE = path.resolve(rawLogFilePattern.replace("{target}", TARGET));
 let LOG_STREAM = null;
 
 /** einmalig Logfile-Stream öffnen */
@@ -175,7 +182,7 @@ function rawConsoleWarn(...msg) {
   writeLogLine("[WARN] " + line);
 }
 
-// High-level Helfer, die du überall im Script schon verwendest:
+// High-level Helfer
 function log(...msg) {
   rawConsoleLog(...msg);
 }
@@ -205,13 +212,30 @@ if (!TARGET_CONFIG) {
   process.exit(1);
 }
 
+// Haupt-Sync-Config + Sidecar
+const SYNC_CFG = TARGET_CONFIG.sync ?? TARGET_CONFIG;
+const SIDECAR_CFG = TARGET_CONFIG.sidecar ?? {};
+
+if (!SYNC_CFG.localRoot || !SYNC_CFG.remoteRoot) {
+  console.error(
+    pc.red(
+      `❌ Connection '${TARGET}' is missing sync.localRoot or sync.remoteRoot.`
+    )
+  );
+  process.exit(1);
+}
+
 const CONNECTION = {
   host: TARGET_CONFIG.host,
   port: TARGET_CONFIG.port ?? 22,
   user: TARGET_CONFIG.user,
   password: TARGET_CONFIG.password,
-  localRoot: path.resolve(TARGET_CONFIG.localRoot),
-  remoteRoot: TARGET_CONFIG.remoteRoot,
+  // Main sync roots
+  localRoot: path.resolve(SYNC_CFG.localRoot),
+  remoteRoot: SYNC_CFG.remoteRoot,
+  // Sidecar roots (für sidecar-upload / sidecar-download)
+  sidecarLocalRoot: path.resolve(SIDECAR_CFG.localRoot ?? SYNC_CFG.localRoot),
+  sidecarRemoteRoot: SIDECAR_CFG.remoteRoot ?? SYNC_CFG.remoteRoot,
   workers: TARGET_CONFIG.worker ?? 2,
 };
 
@@ -235,6 +259,10 @@ const SCAN_CHUNK = PROGRESS.scanChunk ?? (IS_VERBOSE ? 1 : 100);
 const ANALYZE_CHUNK = PROGRESS.analyzeChunk ?? (IS_VERBOSE ? 1 : 10);
 // For >100k files, rather 10–50, for debugging/troubleshooting 1.
 
+// Leere Verzeichnisse nach dem Sync entfernen?
+const CLEANUP_EMPTY_DIRS = CONFIG_RAW.cleanupEmptyDirs ?? true;
+const CLEANUP_EMPTY_ROOTS = CONFIG_RAW.cleanupEmptyRoots ?? false;
+
 // ---------------------------------------------------------------------------
 // Shared config from JSON
 // ---------------------------------------------------------------------------
@@ -274,7 +302,7 @@ const MEDIA_EXT = CONFIG_RAW.mediaExtensions ?? [
   ".pdf",
 ];
 
-// Special: Lists for targeted uploads/downloads
+// Special: Lists for targeted uploads/downloads (per-connection sidecar)
 function normalizeList(list) {
   if (!Array.isArray(list)) return [];
   return list.flatMap((item) =>
@@ -287,15 +315,16 @@ function normalizeList(list) {
   );
 }
 
-const UPLOAD_LIST = normalizeList(CONFIG_RAW.uploadList ?? []);
-const DOWNLOAD_LIST = normalizeList(CONFIG_RAW.downloadList ?? []);
+// Lists from sidecar config (relative to sidecar.localRoot / sidecar.remoteRoot)
+const UPLOAD_LIST = normalizeList(SIDECAR_CFG.uploadList ?? []);
+const DOWNLOAD_LIST = normalizeList(SIDECAR_CFG.downloadList ?? []);
 
 // Effektive Exclude-Liste: explizites exclude + Upload/Download-Listen
 // → diese Dateien werden im „normalen“ Sync nicht angerührt,
-//   sondern nur über die Bypass-Mechanik behandelt.
+//   sondern nur über die Sidecar-Mechanik behandelt.
 const EXCLUDE = [...BASE_EXCLUDE, ...UPLOAD_LIST, ...DOWNLOAD_LIST];
 
-// List of ALL files that were excluded due to uploadList/downloadList
+// List of ALL files that were ausgeschlossen durch uploadList/downloadList
 const AUTO_EXCLUDED = new Set();
 
 // Cache file name per connection
@@ -384,7 +413,7 @@ function isIncluded(relPath) {
   if (INCLUDE.length > 0 && !matchesAny(INCLUDE, relPath)) return false;
   // Exclude-Regeln
   if (EXCLUDE.length > 0 && matchesAny(EXCLUDE, relPath)) {
-    // Falls durch Upload/Download-Liste → merken
+    // Falls durch Sidecar-Listen → merken
     if (UPLOAD_LIST.includes(relPath) || DOWNLOAD_LIST.includes(relPath)) {
       AUTO_EXCLUDED.add(relPath);
     }
@@ -424,14 +453,12 @@ function shortenPathForProgress(rel) {
 function updateProgress2(prefix, current, total, rel = "") {
   const short = rel ? shortenPathForProgress(rel) : "";
 
-  //Log file: always as a single line with **full** rel path
+  // Log file: always as a single line with **full** rel path
   const base =
     total && total > 0
       ? `${prefix}${current}/${total} Files`
       : `${prefix}${current} Files`;
-  writeLogLine(
-    `[progress] ${base}${rel ? " – " + rel : ""}`
-  );
+  writeLogLine(`[progress] ${base}${rel ? " – " + rel : ""}`);
 
   if (!process.stdout.isTTY) {
     // Fallback-Terminal
@@ -507,6 +534,124 @@ async function runTasks(items, workerCount, handler, label = "Tasks") {
   await Promise.all(workers);
 }
 
+// ---------------------------------------------------------------------------
+// Neue Helper: Verzeichnisse für Uploads/Updates vorbereiten
+// ---------------------------------------------------------------------------
+
+function collectDirsFromChanges(changes) {
+  const dirs = new Set();
+
+  for (const item of changes) {
+    const rel = item.rel;
+    if (!rel) continue;
+
+    const parts = rel.split("/");
+    if (parts.length <= 1) continue; // Dateien im Root
+
+    let acc = "";
+    for (let i = 0; i < parts.length - 1; i += 1) {
+      acc = acc ? `${acc}/${parts[i]}` : parts[i];
+      dirs.add(acc);
+    }
+  }
+
+  // flachere Pfade zuerst, damit Eltern vor Kindern angelegt werden
+  return [...dirs].sort(
+    (a, b) => a.split("/").length - b.split("/").length
+  );
+}
+
+async function ensureAllRemoteDirsExist(sftp, remoteRoot, toAdd, toUpdate) {
+  const dirs = collectDirsFromChanges([...toAdd, ...toUpdate]);
+
+  for (const relDir of dirs) {
+    const remoteDir = path.posix.join(remoteRoot, relDir);
+    try {
+      await sftp.mkdir(remoteDir, true);
+      vlog(`${tab_a()}${pc.dim("dir ok:")} ${remoteDir}`);
+    } catch {
+      // Directory may already exist / keine Rechte – ignorieren
+    }
+  }
+}
+
+// -----------------------------------------------------------
+// Cleanup: remove *only truly empty* directories on remote
+// -----------------------------------------------------------
+
+async function cleanupEmptyDirs(sftp, rootDir) {
+  // Rekursiv prüfen, ob ein Verzeichnis und seine Unterverzeichnisse
+  // KEINE Dateien enthalten. Nur dann löschen wir es.
+  async function recurse(dir, depth = 0) {
+    let hasFile = false;
+    const subdirs = [];
+
+    let items;
+    try {
+      items = await sftp.list(dir);
+    } catch (e) {
+      // Falls das Verzeichnis inzwischen weg ist o.ä., brechen wir hier ab.
+      wlog(
+        pc.yellow("⚠️  Could not list directory during cleanup:"),
+        dir,
+        e.message || e
+      );
+      return false;
+    }
+
+    for (const item of items) {
+      if (!item.name || item.name === "." || item.name === "..") continue;
+
+      if (item.type === "d") {
+        subdirs.push(item);
+      } else {
+        // Jede Datei (egal ob sie nach INCLUDE/EXCLUDE
+        // sonst ignoriert würde) verhindert das Löschen.
+        hasFile = true;
+      }
+    }
+
+    // Erst alle Unterverzeichnisse aufräumen (post-order)
+    let allSubdirsEmpty = true;
+    for (const sub of subdirs) {
+      const full = path.posix.join(dir, sub.name);
+      const subEmpty = await recurse(full, depth + 1);
+      if (!subEmpty) {
+        allSubdirsEmpty = false;
+      }
+    }
+
+    const isRoot = dir === rootDir;
+    const isEmpty = !hasFile && allSubdirsEmpty;
+
+    // Root nur löschen, wenn explizit erlaubt
+    if (isEmpty && (!isRoot || CLEANUP_EMPTY_ROOTS)) {
+      const rel = toPosix(path.relative(rootDir, dir)) || ".";
+      if (DRY_RUN) {
+        log(`${tab_a()}${DEL} (DRY-RUN) Remove empty directory: ${rel}`);
+      } else {
+        try {
+          // Nicht rekursiv: wir löschen nur, wenn unser eigener Check "leer" sagt.
+          await sftp.rmdir(dir, false);
+          log(`${tab_a()}${DEL} Removed empty directory: ${rel}`);
+        } catch (e) {
+          wlog(
+            pc.yellow("⚠️  Could not remove directory:"),
+            dir,
+            e.message || e
+          );
+          // Falls rmdir scheitert, betrachten wir das Verzeichnis als "nicht leer"
+          return false;
+        }
+      }
+    }
+
+    return isEmpty;
+  }
+
+  await recurse(rootDir, 0);
+}
+
 // ---------------------------------------------------------------------------
 // Local file walker (recursive, all subdirectories)
 // ---------------------------------------------------------------------------
@@ -597,7 +742,7 @@ async function walkRemote(sftp, remoteRoot) {
       const full = path.posix.join(remoteDir, item.name);
       const rel = prefix ? `${prefix}/${item.name}` : item.name;
 
-      // Apply include/exclude rules also on remote side
+      // Include/Exclude-Regeln auch auf Remote anwenden
       if (!isIncluded(rel)) continue;
 
       if (item.type === "d") {
@@ -771,16 +916,16 @@ function describeSftpError(err) {
 }
 
 // ---------------------------------------------------------------------------
-// Bypass-only Mode (uploadList / downloadList ohne normalen Sync)
+// Bypass-only Mode (sidecar-upload / sidecar-download ohne normalen Sync)
 // ---------------------------------------------------------------------------
 
 async function collectUploadTargets() {
-  const all = await walkLocalPlain(CONNECTION.localRoot);
+  const all = await walkLocalPlain(CONNECTION.sidecarLocalRoot);
   const results = [];
 
   for (const [rel, meta] of all.entries()) {
     if (matchesAny(UPLOAD_LIST, rel)) {
-      const remotePath = path.posix.join(CONNECTION.remoteRoot, rel);
+      const remotePath = path.posix.join(CONNECTION.sidecarRemoteRoot, rel);
       results.push({
         rel,
         localPath: meta.localPath,
@@ -793,12 +938,12 @@ async function collectUploadTargets() {
 }
 
 async function collectDownloadTargets(sftp) {
-  const all = await walkRemotePlain(sftp, CONNECTION.remoteRoot);
+  const all = await walkRemotePlain(sftp, CONNECTION.sidecarRemoteRoot);
   const results = [];
 
   for (const [rel, meta] of all.entries()) {
     if (matchesAny(DOWNLOAD_LIST, rel)) {
-      const localPath = path.join(CONNECTION.localRoot, rel);
+      const localPath = path.join(CONNECTION.sidecarLocalRoot, rel);
       results.push({
         rel,
         remotePath: meta.remotePath,
@@ -813,10 +958,20 @@ async function collectDownloadTargets(sftp) {
 async function performBypassOnly(sftp) {
   log("");
   log(pc.bold(pc.cyan("🚀 Bypass-Only Mode (skip-sync)")));
+  log(`${tab_a()}Sidecar Local: ${pc.green(CONNECTION.sidecarLocalRoot)}`);
+  log(`${tab_a()}Sidecar Remote: ${pc.green(CONNECTION.sidecarRemoteRoot)}`);
+
+  if (RUN_UPLOAD_LIST && !fs.existsSync(CONNECTION.sidecarLocalRoot)) {
+    elog(
+      pc.red("❌ Sidecar local root does not exist:"),
+      CONNECTION.sidecarLocalRoot
+    );
+    process.exit(1);
+  }
 
   if (RUN_UPLOAD_LIST) {
     log("");
-    log(pc.bold(pc.cyan("⬆️  Upload-Bypass (uploadList) …")));
+    log(pc.bold(pc.cyan("⬆️  Upload-Bypass (sidecar-upload) …")));
     const targets = await collectUploadTargets();
     log(`${tab_a()}→ ${targets.length} files from uploadList`);
 
@@ -845,7 +1000,7 @@ async function performBypassOnly(sftp) {
 
   if (RUN_DOWNLOAD_LIST) {
     log("");
-    log(pc.bold(pc.cyan("⬇️  Download-Bypass (downloadList) …")));
+    log(pc.bold(pc.cyan("⬇️  Download-Bypass (sidecar-download) …")));
     const targets = await collectDownloadTargets(sftp);
     log(`${tab_a()}→ ${targets.length} files from downloadList`);
 
@@ -902,17 +1057,24 @@ async function main() {
   );
   log(`${tab_a()}Local: ${pc.green(CONNECTION.localRoot)}`);
   log(`${tab_a()}Remote: ${pc.green(CONNECTION.remoteRoot)}`);
+  if (RUN_UPLOAD_LIST || RUN_DOWNLOAD_LIST || SKIP_SYNC) {
+    log(`${tab_a()}Sidecar Local: ${pc.green(CONNECTION.sidecarLocalRoot)}`);
+    log(`${tab_a()}Sidecar Remote: ${pc.green(CONNECTION.sidecarRemoteRoot)}`);
+  }
   if (DRY_RUN) log(pc.yellow(`${tab_a()}Mode: DRY-RUN (no changes)`));
   if (SKIP_SYNC) log(pc.yellow(`${tab_a()}Mode: SKIP-SYNC (bypass only)`));
   if (RUN_UPLOAD_LIST || RUN_DOWNLOAD_LIST) {
     log(
       pc.blue(
-        `${tab_a()}Extra: ${RUN_UPLOAD_LIST ? "uploadList " : ""}${
-          RUN_DOWNLOAD_LIST ? "downloadList" : ""
-        }`
+        `${tab_a()}Extra: ${
+          RUN_UPLOAD_LIST ? "sidecar-upload " : ""
+        }${RUN_DOWNLOAD_LIST ? "sidecar-download" : ""}`
       )
     );
   }
+  if (CLEANUP_EMPTY_DIRS) {
+    log(`${tab_a()}Cleanup empty dirs: ${pc.green("enabled")}`);
+  }
   if (LOG_FILE) {
     log(`${tab_a()}LogFile: ${pc.cyan(LOG_FILE)}`);
   }
@@ -937,7 +1099,7 @@ async function main() {
     connected = true;
     log(pc.green(`${tab_a()}✔ Connected to SFTP.`));
 
-    if (!fs.existsSync(CONNECTION.localRoot)) {
+    if (!SKIP_SYNC && !fs.existsSync(CONNECTION.localRoot)) {
       console.error(
         pc.red("❌ Local root does not exist:"),
         CONNECTION.localRoot
@@ -946,7 +1108,7 @@ async function main() {
     }
 
     // -------------------------------------------------------------
-    // SKIP-SYNC-Modus → nur Bypass mit Listen
+    // SKIP-SYNC-Modus → nur Sidecar-Listen
     // -------------------------------------------------------------
     if (SKIP_SYNC) {
       await performBypassOnly(sftp);
@@ -958,7 +1120,7 @@ async function main() {
     }
 
     // -------------------------------------------------------------
-    // Normaler Sync (inkl. evtl. paralleler Listen-Excludes)
+    // Normaler Sync (inkl. evtl. paralleler Sidecar-Excludes)
     // -------------------------------------------------------------
 
     // Phase 1 – mit exakt einer Leerzeile davor
@@ -969,7 +1131,7 @@ async function main() {
 
     if (AUTO_EXCLUDED.size > 0) {
       log("");
-      log(pc.dim("   Auto-excluded (uploadList/downloadList):"));
+      log(pc.dim("   Auto-excluded (sidecar upload/download):"));
       [...AUTO_EXCLUDED].sort().forEach((file) => {
         log(pc.dim(`${tab_a()} - ${file}`));
       });
@@ -1105,6 +1267,20 @@ async function main() {
       log(`${tab_a()}No orphaned remote files found.`);
     }
 
+    // -------------------------------------------------------------------
+    // Verzeichnisse vorab anlegen (damit Worker sich nicht ins Gehege kommen)
+    // -------------------------------------------------------------------
+    if (!DRY_RUN && (toAdd.length || toUpdate.length)) {
+      log("");
+      log(pc.bold(pc.cyan("📁 Preparing remote directories …")));
+      await ensureAllRemoteDirsExist(
+        sftp,
+        CONNECTION.remoteRoot,
+        toAdd,
+        toUpdate
+      );
+    }
+
     // -------------------------------------------------------------------
     // Phase 5: Execute changes (parallel, worker-based)
     // -------------------------------------------------------------------
@@ -1118,6 +1294,7 @@ async function main() {
         toAdd,
         CONNECTION.workers,
         async ({ local: l, remotePath }) => {
+          // Verzeichnisse sollten bereits existieren – mkdir hier nur als Fallback
           const remoteDir = path.posix.dirname(remotePath);
           try {
             await sftp.mkdir(remoteDir, true);
@@ -1171,6 +1348,13 @@ async function main() {
       );
     }
 
+    // Optional: leere Verzeichnisse aufräumen
+    if (!DRY_RUN && CLEANUP_EMPTY_DIRS) {
+      log("");
+      log(pc.bold(pc.cyan("🧹 Cleaning up empty remote directories …")));
+      await cleanupEmptyDirs(sftp, CONNECTION.remoteRoot);
+    }
+
     const duration = ((Date.now() - start) / 1000).toFixed(2);
 
     // Write cache safely at the end
@@ -1186,7 +1370,7 @@ async function main() {
     log(`${tab_a()}${DEL} Deleted: ${toDelete.length}`);
     if (AUTO_EXCLUDED.size > 0) {
       log(
-        `${tab_a()}${EXC} Excluded via uploadList | downloadList: ${
+        `${tab_a()}${EXC} Excluded via sidecar upload/download: ${
           AUTO_EXCLUDED.size
         }`
       );
@@ -1249,4 +1433,4 @@ async function main() {
   }
 }
 
-main();
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sftp-push-sync",
-  "version": "1.0.21",
+  "version": "2.1.0",
   "description": "SFTP sync tool for Hugo projects (local to remote, with hash cache)",
   "type": "module",
   "bin": {