sftp-push-sync 1.0.15 → 1.0.17

package/README.md

@@ -65,26 +65,66 @@ Create a `sync.config.json` in the root folder of your project:
   },
   "include": [],
   "exclude": ["**/.DS_Store", "**/.git/**", "**/node_modules/**"],
-  "textExtensions": [
-    ".html",
-    ".xml",
-    ".txt",
-    ".json",
-    ".js",
-    ".css",
-    ".md",
-    ".svg"
-  ],
+  "textExtensions": [".html",".xml",".txt",".json",".js",".css",".md",".svg"],
+  "mediaExtensions": [".jpg",".jpeg",".png",".webp",".gif",".avif",".tif",".tiff",".mp4",".mov",".m4v","mp3",".wav",".flac"],
   "progress": {
     "scanChunk": 10,
     "analyzeChunk": 1
   },
   "logLevel": "normal",
+  "logFile": ".sftp-push-sync.{target}.log",
   "uploadList": [],
   "downloadList": ["download-counter.json"]
 }
 ```
 
+### CLI Usage
+
+```bash
+# Normal synchronisation
+node bin/sftp-push-sync.mjs staging
+
+# Consider normal synchronisation + upload list
+node bin/sftp-push-sync.mjs staging --upload-list
+
+# 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
+
+# (optional) only run lists dry
+node bin/sftp-push-sync.mjs staging --skip-sync --upload-list --dry-run
+```
+
+- Can be conveniently started via the scripts in `package.json`:
+
+```bash
+# For example
+npm run sync:staging
+# or short
+npm run ss
+```
+
+If you have stored the scripts in `package.json` as follows:
+
+```json
+
+"scripts": {
+    "sync:staging": "sftp-push-sync staging",
+    "sync:staging:dry": "sftp-push-sync staging --dry-run",
+    "ss": "npm run sync:staging",
+    "ssd": "npm run sync:staging:dry",
+
+    "sync:prod": "sftp-push-sync prod",
+    "sync:prod:dry": "sftp-push-sync prod --dry-run",
+    "sp": "npm run sync:prod",
+    "spd": "npm run sync:prod:dry",
+  },
+```
+
+The dry run is a great way to compare files and fill the cache.
+
+
 ### special uploads / downloads
 
 A list of files that are excluded from the sync comparison and can be downloaded or uploaded separately.
@@ -113,41 +153,45 @@ sftp-push-sync prod --download-list             # then do
 Logging can also be configured.
 
 - `logLevel` - normal, verbose, laconic.
+- `logFile` - an optional logFile.
 - `scanChunk` - After how many elements should a log output be generated during scanning?
 - `analyzeChunk` - After how many elements should a log output be generated during analysis?
 
 For >100k files, use analyzeChunk = 10 or 50, otherwise the TTY output itself is a relevant factor.
 
-## NPM Scripts
-
-- Can be conveniently started via the scripts in `package.json`:
-
-```bash
-# For example
-npm run sync:staging
-# or short
-npm run ss
+### Wildcards
+
+Examples for Wirdcards for `include`, `exclude`, `uploadList` and `downloadList`:
+
+- `"content/**"` - ALLES unterhalb von `content/`
+- `".html", ".htm", ".md", ".txt", ".json"`- Nur bestimmte Dateiendungen
+- `"**/*.html"` - alle HTML-Dateien
+- `"**/*.md"`- alle Markdown-Dateien
+- `"content/**/*.md"` - nur Markdown in `content/`
+- `"static/images/**/*.jpg"`
+- `"**/thumb-*.*"` - thumb-Bilder überall
+- `"**/*-draft.*"` - Dateien mit -draft vor der Extension
+- `"content/**/*.md"` - alle Markdown-Dateien
+- `"config/**"` - komplette Konfiguration
+- `"static/images/covers/**"`- nur Cover-Bilder
+- `"logs/**/*.log"` - alle Logs aus logs/
+- `"reports/**/*.xlsx"`
+
+practical excludes:
+
+```txt
+"exclude": [
+  ".git/**",           // kompletter .git Ordner
+  ".idea/**",          // JetBrains
+  "node_modules/**",   // Node dependencies
+  "dist/**",           // Build Output
+  "**/*.map",          // Source Maps
+  "**/~*",             // Emacs/Editor-Backups (~Dateien)
+  "**/#*#",            // weitere Editor-Backups
+  "**/.DS_Store"       // macOS Trash
+]
 ```
 
-If you have stored the scripts in `package.json` as follows:
-
-```json
-
-"scripts": {
-    "sync:staging": "sftp-push-sync staging",
-    "sync:staging:dry": "sftp-push-sync staging --dry-run",
-    "ss": "npm run sync:staging",
-    "ssd": "npm run sync:staging:dry",
-
-    "sync:prod": "sftp-push-sync prod",
-    "sync:prod:dry": "sftp-push-sync prod --dry-run",
-    "sp": "npm run sync:prod",
-    "spd": "npm run sync:prod:dry",
-  },
-```
-
-The dry run is a great way to compare files and fill the cache.
-
 ## Which files are needed?
 
 - `sync.config.json` - The configuration file (with passwords in plain text, so please leave it out of the git repository)
@@ -155,10 +199,11 @@ The dry run is a great way to compare files and fill the cache.
 ## Which files are created?
 
 - 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 again, because remote hashes will be streamed again. After that, everything will run fast.
 
-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 images – so be patient! Once the cache is full, it will be faster.
 
 ## Example Output
 

package/bin/sftp-push-sync.mjs

@@ -55,9 +55,6 @@ const hr1 = () => "─".repeat(65); // horizontal line -
 const hr2 = () => "=".repeat(65); // horizontal line =
 const tab_a = () => " ".repeat(3); // indentation for formatting the terminal output.
 const tab_b = () => " ".repeat(6);
-const cr_a = () => "\n".repeat(1);
-const cr_b = () => "\n".repeat(2);
-
 
 // ---------------------------------------------------------------------------
 // CLI arguments
@@ -68,6 +65,7 @@ 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 SKIP_SYNC = args.includes("--skip-sync");
 
 // logLevel override via CLI (optional)
 let cliLogLevel = null;
@@ -80,6 +78,14 @@ if (!TARGET) {
   process.exit(1);
 }
 
+// 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.")
+  );
+  process.exit(1);
+}
+
 // ---------------------------------------------------------------------------
 // Load config file
 // ---------------------------------------------------------------------------
@@ -104,6 +110,93 @@ if (!CONFIG_RAW.connections || typeof CONFIG_RAW.connections !== "object") {
   process.exit(1);
 }
 
+// ---------------------------------------------------------------------------
+// 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)
+);
+let LOG_STREAM = null;
+
+/** einmalig Logfile-Stream öffnen */
+function openLogFile() {
+  if (!LOG_FILE) return;
+  if (!LOG_STREAM) {
+    LOG_STREAM = fs.createWriteStream(LOG_FILE, {
+      flags: "w", // pro Lauf überschreiben
+      encoding: "utf8",
+    });
+  }
+}
+
+/** eine fertige Zeile ins Logfile schreiben (ohne Einfluss auf Terminal) */
+function writeLogLine(line) {
+  if (!LOG_STREAM) return;
+  // ANSI-Farbsequenzen aus der Log-Zeile entfernen
+  const clean =
+    typeof line === "string"
+      ? line.replace(/\x1b\[[0-9;]*m/g, "")
+      : String(line).replace(/\x1b\[[0-9;]*m/g, "");
+  try {
+    LOG_STREAM.write(clean + "\n");
+  } catch {
+    // falls Stream schon zu ist, einfach ignorieren – verhindert ERR_STREAM_WRITE_AFTER_END
+  }
+}
+
+/** Konsole + Logfile (normal) */
+function rawConsoleLog(...msg) {
+  clearProgressLine();
+  console.log(...msg);
+  const line = msg
+    .map((m) => (typeof m === "string" ? m : String(m)))
+    .join(" ");
+  writeLogLine(line);
+}
+
+function rawConsoleError(...msg) {
+  clearProgressLine();
+  console.error(...msg);
+  const line = msg
+    .map((m) => (typeof m === "string" ? m : String(m)))
+    .join(" ");
+  writeLogLine("[ERROR] " + line);
+}
+
+function rawConsoleWarn(...msg) {
+  clearProgressLine();
+  console.warn(...msg);
+  const line = msg
+    .map((m) => (typeof m === "string" ? m : String(m)))
+    .join(" ");
+  writeLogLine("[WARN] " + line);
+}
+
+// High-level Helfer, die du überall im Script schon verwendest:
+function log(...msg) {
+  rawConsoleLog(...msg);
+}
+
+function vlog(...msg) {
+  if (!IS_VERBOSE) return;
+  rawConsoleLog(...msg);
+}
+
+function elog(...msg) {
+  rawConsoleError(...msg);
+}
+
+function wlog(...msg) {
+  rawConsoleWarn(...msg);
+}
+
+// ---------------------------------------------------------------------------
+// Connection
+// ---------------------------------------------------------------------------
+
 const TARGET_CONFIG = CONFIG_RAW.connections[TARGET];
 if (!TARGET_CONFIG) {
   console.error(
@@ -149,6 +242,38 @@ const ANALYZE_CHUNK = PROGRESS.analyzeChunk ?? (IS_VERBOSE ? 1 : 10);
 const INCLUDE = CONFIG_RAW.include ?? [];
 const BASE_EXCLUDE = CONFIG_RAW.exclude ?? [];
 
+// textExtensions
+const TEXT_EXT = CONFIG_RAW.textExtensions ?? [
+  ".html",
+  ".htm",
+  ".xml",
+  ".txt",
+  ".json",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".css",
+  ".md",
+  ".svg",
+];
+
+// mediaExtensions – aktuell nur Meta, aber schon konfigurierbar
+const MEDIA_EXT = CONFIG_RAW.mediaExtensions ?? [
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".mp4",
+  ".mov",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".flac",
+  ".pdf",
+];
+
 // Special: Lists for targeted uploads/downloads
 function normalizeList(list) {
   if (!Array.isArray(list)) return [];
@@ -166,25 +291,13 @@ const UPLOAD_LIST = normalizeList(CONFIG_RAW.uploadList ?? []);
 const DOWNLOAD_LIST = normalizeList(CONFIG_RAW.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.
 const EXCLUDE = [...BASE_EXCLUDE, ...UPLOAD_LIST, ...DOWNLOAD_LIST];
 
 // List of ALL files that were excluded due to uploadList/downloadList
 const AUTO_EXCLUDED = new Set();
 
-const TEXT_EXT = CONFIG_RAW.textExtensions ?? [
-  ".html",
-  ".htm",
-  ".xml",
-  ".txt",
-  ".json",
-  ".js",
-  ".mjs",
-  ".cjs",
-  ".css",
-  ".md",
-  ".svg",
-];
-
 // Cache file name per connection
 const syncCacheName = TARGET_CONFIG.syncCache || `.sync-cache.${TARGET}.json`;
 const CACHE_PATH = path.resolve(syncCacheName);
@@ -245,11 +358,14 @@ let progressActive = false;
 
 function clearProgressLine() {
   if (!process.stdout.isTTY || !progressActive) return;
-  const width = process.stdout.columns || 80;
-  const blank = " ".repeat(width);
 
-  // Beide Progress-Zeilen leeren
-  process.stdout.write("\r" + blank + cr_a() + blank + "\r");
+  // Zwei Progress-Zeilen ohne zusätzliche Newlines leeren:
+  // Cursor steht nach updateProgress2() auf der ersten Zeile.
+  process.stdout.write("\r"); // an Zeilenanfang
+  process.stdout.write("\x1b[2K"); // erste Zeile löschen
+  process.stdout.write("\x1b[1B"); // eine Zeile nach unten
+  process.stdout.write("\x1b[2K"); // zweite Zeile löschen
+  process.stdout.write("\x1b[1A"); // wieder nach oben
 
   progressActive = false;
 }
@@ -258,27 +374,6 @@ function toPosix(p) {
   return p.split(path.sep).join("/");
 }
 
-function log(...msg) {
-  clearProgressLine();
-  console.log(...msg);
-}
-
-function vlog(...msg) {
-  if (!IS_VERBOSE) return;
-  clearProgressLine();
-  console.log(...msg);
-}
-
-function elog(...msg) {
-  clearProgressLine();
-  console.error(...msg);
-}
-
-function wlog(...msg) {
-  clearProgressLine();
-  console.warn(...msg);
-}
-
 function matchesAny(patterns, relPath) {
   if (!patterns || patterns.length === 0) return false;
   return patterns.some((pattern) => minimatch(relPath, pattern, { dot: true }));
@@ -303,6 +398,11 @@ function isTextFile(relPath) {
   return TEXT_EXT.includes(ext);
 }
 
+function isMediaFile(relPath) {
+  const ext = path.extname(relPath).toLowerCase();
+  return MEDIA_EXT.includes(ext);
+}
+
 function shortenPathForProgress(rel) {
   if (!rel) return "";
   const parts = rel.split("/");
@@ -320,17 +420,28 @@ function shortenPathForProgress(rel) {
   return `…/${prev}/${last}`;
 }
 
-// Two-line progress bar
+// Two-line progress bar (for terminal) + 1-line log entry
 function updateProgress2(prefix, current, total, rel = "") {
+  const short = rel ? shortenPathForProgress(rel) : "";
+
+  //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 : ""}`
+  );
+
   if (!process.stdout.isTTY) {
-    // Fallback für Pipes / Logs
+    // Fallback-Terminal
     if (total && total > 0) {
       const percent = ((current / total) * 100).toFixed(1);
       console.log(
-        `${tab_a()}${prefix}${current}/${total} Files (${percent}%) – ${rel}`
+        `${tab_a()}${prefix}${current}/${total} Files (${percent}%) – ${short}`
       );
     } else {
-      console.log(`${tab_a()}${prefix}${current} Files – ${rel}`);
+      console.log(`${tab_a()}${prefix}${current} Files – ${short}`);
     }
     return;
   }
@@ -346,14 +457,13 @@ function updateProgress2(prefix, current, total, rel = "") {
     line1 = `${tab_a()}${prefix}${current} Files`;
   }
 
-  const short = rel ? shortenPathForProgress(rel) : "";
   let line2 = short;
 
   if (line1.length > width) line1 = line1.slice(0, width - 1);
   if (line2.length > width) line2 = line2.slice(0, width - 1);
 
   // zwei Zeilen überschreiben
-  process.stdout.write("\r" + line1.padEnd(width) + cr_a());
+  process.stdout.write("\r" + line1.padEnd(width) + "\n");
   process.stdout.write(line2.padEnd(width));
 
   // Cursor wieder nach oben (auf die Fortschrittszeile)
@@ -383,8 +493,8 @@ async function runTasks(items, workerCount, handler, label = "Tasks") {
         elog(pc.red(`${tab_a()}⚠️ Error in ${label}:`), err.message || err);
       }
       done += 1;
-      if (done % 10 === 0 || done === total) {
-        updateProgress2(`${tab_a()}${label}: `, done, total);
+      if (done === 1 || done % 10 === 0 || done === total) {
+        updateProgress2(`${label}: `, done, total, item.rel ?? "");
       }
     }
   }
@@ -423,13 +533,13 @@ async function walkLocal(root) {
           size: stat.size,
           mtimeMs: stat.mtimeMs,
           isText: isTextFile(rel),
+          isMedia: isMediaFile(rel),
         });
 
         scanned += 1;
         const chunk = IS_VERBOSE ? 1 : SCAN_CHUNK;
         if (scanned === 1 || scanned % chunk === 0) {
-          // totally unknown → total = 0 → no automatic \n
-          updateProgress2(`${tab_a()}Scan local: `, scanned, 0, rel);
+          updateProgress2("Scan local: ", scanned, 0, rel);
         }
       }
     }
@@ -438,15 +548,38 @@ async function walkLocal(root) {
   await recurse(root);
 
   if (scanned > 0) {
-    // last line + neat finish
-    updateProgress2(`${tab_a()}Scan local: `, scanned, 0, "fertig");
-    process.stdout.write(cr_a());
+    updateProgress2("Scan local: ", scanned, 0, "fertig");
+    process.stdout.write("\n");
     progressActive = false;
   }
 
   return result;
 }
 
+// Plain walker für Bypass (ignoriert INCLUDE/EXCLUDE)
+async function walkLocalPlain(root) {
+  const result = new Map();
+
+  async function recurse(current) {
+    const entries = await fsp.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await recurse(full);
+      } else if (entry.isFile()) {
+        const rel = toPosix(path.relative(root, full));
+        result.set(rel, {
+          rel,
+          localPath: full,
+        });
+      }
+    }
+  }
+
+  await recurse(root);
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // Remote walker (recursive, all subdirectories) – respects INCLUDE/EXCLUDE
 // ---------------------------------------------------------------------------
@@ -480,23 +613,51 @@ async function walkRemote(sftp, remoteRoot) {
         scanned += 1;
         const chunk = IS_VERBOSE ? 1 : SCAN_CHUNK;
         if (scanned === 1 || scanned % chunk === 0) {
-          updateProgress2(`${tab_a()}Scan remote: `, scanned, 0, rel);
+          updateProgress2("Scan remote: ", scanned, 0, rel);
         }
       }
     }
   }
 
-  await recurse(remoteRoot);
+  await recurse(remoteRoot, "");
 
   if (scanned > 0) {
-    updateProgress2(`${tab_a()}Scan remote: `, scanned, 0, "fertig");
-    process.stdout.write(cr_a());
+    updateProgress2("Scan remote: ", scanned, 0, "fertig");
+    process.stdout.write("\n");
     progressActive = false;
   }
 
   return result;
 }
 
+// Plain walker für Bypass (ignoriert INCLUDE/EXCLUDE)
+async function walkRemotePlain(sftp, remoteRoot) {
+  const result = new Map();
+
+  async function recurse(remoteDir, prefix) {
+    const items = await sftp.list(remoteDir);
+
+    for (const item of items) {
+      if (!item.name || item.name === "." || item.name === "..") continue;
+
+      const full = path.posix.join(remoteDir, item.name);
+      const rel = prefix ? `${prefix}/${item.name}` : item.name;
+
+      if (item.type === "d") {
+        await recurse(full, rel);
+      } else {
+        result.set(rel, {
+          rel,
+          remotePath: full,
+        });
+      }
+    }
+  }
+
+  await recurse(remoteRoot, "");
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // Hash helper for binaries (streaming, memory-efficient)
 // ---------------------------------------------------------------------------
@@ -609,25 +770,140 @@ function describeSftpError(err) {
   return "";
 }
 
+// ---------------------------------------------------------------------------
+// Bypass-only Mode (uploadList / downloadList ohne normalen Sync)
+// ---------------------------------------------------------------------------
+
+async function collectUploadTargets() {
+  const all = await walkLocalPlain(CONNECTION.localRoot);
+  const results = [];
+
+  for (const [rel, meta] of all.entries()) {
+    if (matchesAny(UPLOAD_LIST, rel)) {
+      const remotePath = path.posix.join(CONNECTION.remoteRoot, rel);
+      results.push({
+        rel,
+        localPath: meta.localPath,
+        remotePath,
+      });
+    }
+  }
+
+  return results;
+}
+
+async function collectDownloadTargets(sftp) {
+  const all = await walkRemotePlain(sftp, CONNECTION.remoteRoot);
+  const results = [];
+
+  for (const [rel, meta] of all.entries()) {
+    if (matchesAny(DOWNLOAD_LIST, rel)) {
+      const localPath = path.join(CONNECTION.localRoot, rel);
+      results.push({
+        rel,
+        remotePath: meta.remotePath,
+        localPath,
+      });
+    }
+  }
+
+  return results;
+}
+
+async function performBypassOnly(sftp) {
+  log("");
+  log(pc.bold(pc.cyan("🚀 Bypass-Only Mode (skip-sync)")));
+
+  if (RUN_UPLOAD_LIST) {
+    log("");
+    log(pc.bold(pc.cyan("⬆️  Upload-Bypass (uploadList) …")));
+    const targets = await collectUploadTargets();
+    log(`${tab_a()}→ ${targets.length} files from uploadList`);
+
+    if (!DRY_RUN) {
+      await runTasks(
+        targets,
+        CONNECTION.workers,
+        async ({ localPath, remotePath, rel }) => {
+          const remoteDir = path.posix.dirname(remotePath);
+          try {
+            await sftp.mkdir(remoteDir, true);
+          } catch {
+            // Directory may already exist
+          }
+          await sftp.put(localPath, remotePath);
+          vlog(`${tab_a()}${ADD} Uploaded (bypass): ${rel}`);
+        },
+        "Bypass Uploads"
+      );
+    } else {
+      for (const t of targets) {
+        log(`${tab_a()}${ADD} (DRY-RUN) Upload: ${t.rel}`);
+      }
+    }
+  }
+
+  if (RUN_DOWNLOAD_LIST) {
+    log("");
+    log(pc.bold(pc.cyan("⬇️  Download-Bypass (downloadList) …")));
+    const targets = await collectDownloadTargets(sftp);
+    log(`${tab_a()}→ ${targets.length} files from downloadList`);
+
+    if (!DRY_RUN) {
+      await runTasks(
+        targets,
+        CONNECTION.workers,
+        async ({ remotePath, localPath, rel }) => {
+          const localDir = path.dirname(localPath);
+          await fsp.mkdir(localDir, { recursive: true });
+          await sftp.get(remotePath, localPath);
+          vlog(`${tab_a()}${CHA} Downloaded (bypass): ${rel}`);
+        },
+        "Bypass Downloads"
+      );
+    } else {
+      for (const t of targets) {
+        log(`${tab_a()}${CHA} (DRY-RUN) Download: ${t.rel}`);
+      }
+    }
+  }
+
+  log("");
+  log(pc.bold(pc.green("✅ Bypass-only run finished.")));
+}
+
 // ---------------------------------------------------------------------------
 // MAIN
 // ---------------------------------------------------------------------------
 
+async function initLogFile() {
+  if (!LOG_FILE) return;
+  const dir = path.dirname(LOG_FILE);
+  await fsp.mkdir(dir, { recursive: true });
+  LOG_STREAM = fs.createWriteStream(LOG_FILE, {
+    flags: "w",
+    encoding: "utf8",
+  });
+}
+
 async function main() {
   const start = Date.now();
 
-  log(`${cr_b()}${hr2()}`);
-  log(
-    pc.bold(
-      `🔐 SFTP Push-Synchronisation: sftp-push-sync  v${pkg.version}  [logLevel=${LOG_LEVEL}]`
-    )
-  );
+  await initLogFile();
+
+  // Header-Abstand wie gehabt: zwei Leerzeilen davor
+  log("\n" + hr2());
+  log(pc.bold(`🔐 SFTP Push-Synchronisation: sftp-push-sync  v${pkg.version}`));
+  log(`${tab_a()}LogLevel: ${LOG_LEVEL}`);
   log(`${tab_a()}Connection: ${pc.cyan(TARGET)}`);
   log(`${tab_a()}Worker: ${CONNECTION.workers}`);
-  log(`${tab_a()}Host: ${pc.green(CONNECTION.host)}:${pc.green(CONNECTION.port)}`);
+  log(
+    `${tab_a()}Host: ${pc.green(CONNECTION.host)}:${pc.green(CONNECTION.port)}`
+  );
   log(`${tab_a()}Local: ${pc.green(CONNECTION.localRoot)}`);
   log(`${tab_a()}Remote: ${pc.green(CONNECTION.remoteRoot)}`);
   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(
@@ -637,7 +913,10 @@ async function main() {
       )
     );
   }
-  log(`${hr1()}${cr_a()}`);
+  if (LOG_FILE) {
+    log(`${tab_a()}LogFile: ${pc.cyan(LOG_FILE)}`);
+  }
+  log(hr1());
 
   const sftp = new SftpClient();
   let connected = false;
@@ -647,6 +926,7 @@ async function main() {
   const toDelete = [];
 
   try {
+    log("");
     log(pc.cyan("🔌 Connecting to SFTP server …"));
     await sftp.connect({
       host: CONNECTION.host,
@@ -665,7 +945,25 @@ async function main() {
       process.exit(1);
     }
 
-    log(cr_a() + pc.bold(pc.cyan("📥 Phase 1: Scan local files …")));
+    // -------------------------------------------------------------
+    // SKIP-SYNC-Modus → nur Bypass mit Listen
+    // -------------------------------------------------------------
+    if (SKIP_SYNC) {
+      await performBypassOnly(sftp);
+      const duration = ((Date.now() - start) / 1000).toFixed(2);
+      log("");
+      log(pc.bold(pc.cyan("📊 Summary (bypass only):")));
+      log(`${tab_a()}Duration: ${pc.green(duration + " s")}`);
+      return;
+    }
+
+    // -------------------------------------------------------------
+    // Normaler Sync (inkl. evtl. paralleler Listen-Excludes)
+    // -------------------------------------------------------------
+
+    // Phase 1 – mit exakt einer Leerzeile davor
+    log("");
+    log(pc.bold(pc.cyan("📥 Phase 1: Scan local files …")));
     const local = await walkLocal(CONNECTION.localRoot);
     log(`${tab_a()}→ ${local.size} local files`);
 
@@ -678,14 +976,17 @@ async function main() {
       log("");
     }
 
-    log(cr_a() + pc.bold(pc.cyan("📤 Phase 2: Scan remote files …")));
+    // Phase 2 – auch mit einer Leerzeile davor
+    log("");
+    log(pc.bold(pc.cyan("📤 Phase 2: Scan remote files …")));
     const remote = await walkRemote(sftp, CONNECTION.remoteRoot);
-    log(`${tab_a()}→ ${remote.size} remote files${cr_a()}`);
+    log(`${tab_a()}→ ${remote.size} remote files`);
+    log("");
 
     const localKeys = new Set(local.keys());
     const remoteKeys = new Set(remote.keys());
 
-    log(cr_a() + pc.bold(pc.cyan("🔎 Phase 3: Compare & decide …")));
+    log(pc.bold(pc.cyan("🔎 Phase 3: Compare & decide …")));
     const totalToCheck = localKeys.size;
     let checkedCount = 0;
 
@@ -699,7 +1000,7 @@ async function main() {
         checkedCount % chunk === 0 ||
         checkedCount === totalToCheck
       ) {
-        updateProgress2("   Analyse: ", checkedCount, totalToCheck, rel);
+        updateProgress2("Analyse: ", checkedCount, totalToCheck, rel);
       }
 
       const l = local.get(rel);
@@ -749,7 +1050,9 @@ async function main() {
 
         toUpdate.push({ rel, local: l, remote: r, remotePath });
         if (!IS_LACONIC) {
-          log(`${tab_a()}${CHA} ${pc.yellow("Content changed (Text):")} ${rel}`);
+          log(
+            `${tab_a()}${CHA} ${pc.yellow("Content changed (Text):")} ${rel}`
+          );
         }
       } else {
         // Binary: Hash comparison with cache
@@ -781,12 +1084,12 @@ async function main() {
 
     // Wenn Phase 3 nichts gefunden hat, explizit sagen
     if (toAdd.length === 0 && toUpdate.length === 0) {
+      log("");
       log(`${tab_a()}No differences found. Everything is up to date.`);
     }
 
-    log(
-      cr_a() + pc.bold(pc.cyan("🧹 Phase 4: Removing orphaned remote files …"))
-    );
+    log("");
+    log(pc.bold(pc.cyan("🧹 Phase 4: Removing orphaned remote files …")));
     for (const rel of remoteKeys) {
       if (!localKeys.has(rel)) {
         const r = remote.get(rel);
@@ -807,7 +1110,8 @@ async function main() {
     // -------------------------------------------------------------------
 
     if (!DRY_RUN) {
-      log(cr_a() + pc.bold(pc.cyan("🚚 Phase 5: Apply changes …")));
+      log("");
+      log(pc.bold(pc.cyan("🚚 Phase 5: Apply changes …")));
 
       // Upload new files
       await runTasks(
@@ -859,82 +1163,14 @@ async function main() {
         "Deletes"
       );
     } else {
+      log("");
       log(
         pc.yellow(
-          `${cr_a()}💡 DRY-RUN: Connection tested, no files transferred or deleted.`
+          "💡 DRY-RUN: Connection tested, no files transferred or deleted."
         )
       );
     }
 
-    // -------------------------------------------------------------------
-    // Phase 6: optional uploadList / downloadList
-    // -------------------------------------------------------------------
-
-    if (RUN_UPLOAD_LIST && UPLOAD_LIST.length > 0) {
-      log(
-        cr_a() +
-          pc.bold(pc.cyan("⬆️ Extra Phase: Upload-List (explicit files) …"))
-      );
-
-      const tasks = UPLOAD_LIST.map((rel) => ({
-        rel,
-        localPath: path.join(CONNECTION.localRoot, rel),
-        remotePath: path.posix.join(CONNECTION.remoteRoot, toPosix(rel)),
-      }));
-
-      if (DRY_RUN) {
-        for (const t of tasks) {
-          log(`${tab_a()}${ADD} would upload (uploadList): ${t.rel}`);
-        }
-      } else {
-        await runTasks(
-          tasks,
-          CONNECTION.workers,
-          async ({ localPath, remotePath, rel }) => {
-            const remoteDir = path.posix.dirname(remotePath);
-            try {
-              await sftp.mkdir(remoteDir, true);
-            } catch {
-              // ignore
-            }
-            await sftp.put(localPath, remotePath);
-            log(`${tab_a()}${ADD} uploadList: ${rel}`);
-          },
-          "Upload-List"
-        );
-      }
-    }
-
-    if (RUN_DOWNLOAD_LIST && DOWNLOAD_LIST.length > 0) {
-      log(
-        cr_a() +
-          pc.bold(pc.cyan("⬇️ Extra Phase: Download-List (explicit files) …"))
-      );
-
-      const tasks = DOWNLOAD_LIST.map((rel) => ({
-        rel,
-        remotePath: path.posix.join(CONNECTION.remoteRoot, toPosix(rel)),
-        localPath: path.join(CONNECTION.localRoot, rel),
-      }));
-
-      if (DRY_RUN) {
-        for (const t of tasks) {
-          log(`${tab_a()}${ADD} would download (downloadList): ${t.rel}`);
-        }
-      } else {
-        await runTasks(
-          tasks,
-          CONNECTION.workers,
-          async ({ remotePath, localPath, rel }) => {
-            await fsp.mkdir(path.dirname(localPath), { recursive: true });
-            await sftp.fastGet(remotePath, localPath);
-            log(`${tab_a()}${ADD} downloadList: ${rel}`);
-          },
-          "Download-List"
-        );
-      }
-    }
-
     const duration = ((Date.now() - start) / 1000).toFixed(2);
 
     // Write cache safely at the end
@@ -942,18 +1178,22 @@ async function main() {
 
     // Summary
     log(hr1());
-    log(cr_a() + pc.bold(pc.cyan("📊 Summary:")));
+    log("");
+    log(pc.bold(pc.cyan("📊 Summary:")));
     log(`${tab_a()}Duration: ${pc.green(duration + " s")}`);
     log(`${tab_a()}${ADD} Added  : ${toAdd.length}`);
     log(`${tab_a()}${CHA} Changed: ${toUpdate.length}`);
     log(`${tab_a()}${DEL} Deleted: ${toDelete.length}`);
     if (AUTO_EXCLUDED.size > 0) {
       log(
-        `${tab_a()}${EXC} Excluded via uploadList | downloadList: ${AUTO_EXCLUDED.size}`
+        `${tab_a()}${EXC} Excluded via uploadList | downloadList: ${
+          AUTO_EXCLUDED.size
+        }`
       );
     }
     if (toAdd.length || toUpdate.length || toDelete.length) {
-      log(`${cr_a()}📄 Changes:`);
+      log("");
+      log("📄 Changes:");
       [...toAdd.map((t) => t.rel)]
         .sort()
         .forEach((f) => console.log(`${tab_a()}${ADD} ${f}`));
@@ -964,10 +1204,12 @@ async function main() {
         .sort()
         .forEach((f) => console.log(`${tab_a()}${DEL} ${f}`));
     } else {
-      log(`${cr_a()}No changes.`);
+      log("");
+      log("No changes.");
     }
 
-    log(cr_a() + pc.bold(pc.green("✅ Sync complete.")));
+    log("");
+    log(pc.bold(pc.green("✅ Sync complete.")));
   } catch (err) {
     const hint = describeSftpError(err);
     elog(pc.red("❌ Synchronisation error:"), err.message || err);
@@ -996,8 +1238,15 @@ async function main() {
         e.message || e
       );
     }
+
+    // Abschlusslinie + Leerzeile **vor** dem Schließen des Logfiles
+    log(hr2());
+    log("");
+
+    if (LOG_STREAM) {
+      LOG_STREAM.end();
+    }
   }
-  log(`${hr2()}${cr_b()}`);
 }
 
-main();
+main();

package/package.json

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