sftp-push-sync 1.0.11 → 1.0.13

package/README.md

@@ -26,10 +26,16 @@ The file `sftp-push-sync.mjs` is pure JavaScript (ESM), not TypeScript. Node.js
 ## Install
 
 ```bash
-npm i sftp-push-sync
+npm i -D sftp-push-sync
+# or
+npm install --save-dev sftp-push-sync
+# or
+yarn add --dev sftp-push-sync
+# or
+pnpm add -D sftp-push-sync
 ```
 
-## Config file
+## Setup
 
 Create a `sync.config.json` in the root folder of your project:
 
@@ -58,18 +64,24 @@ Create a `sync.config.json` in the root folder of your project:
     }
   },
   "include": [],
-  "exclude": [
-    "**/.DS_Store",
-    "**/.git/**",
-    "**/node_modules/**"
-  ],
+  "exclude": ["**/.DS_Store", "**/.git/**", "**/node_modules/**"],
   "textExtensions": [
-    ".html", ".xml", ".txt", ".json", ".js", ".css", ".md", ".svg"
+    ".html",
+    ".xml",
+    ".txt",
+    ".json",
+    ".js",
+    ".css",
+    ".md",
+    ".svg"
   ],
+  "progress": {
+    "scanChunk": 10,
+    "analyzeChunk": 1
+  },
+  "logLevel": "normal",
   "uploadList": [],
-  "downloadList": [
-    "download-counter.json"
-  ]
+  "downloadList": ["download-counter.json"]
 }
 ```
 
@@ -84,7 +96,6 @@ A list of files that are excluded from the sync comparison and can be downloaded
   - Relative to remoteRoot "download-counter.json"
   - or e.g. "logs/download-counter.json"
 
-
 ```bash
 # normal synchronisation
 sftp-push-sync staging
@@ -97,6 +108,16 @@ sftp-push-sync prod --download-list --dry-run   # view first
 sftp-push-sync prod --download-list             # then do
 ```
 
+### Logging Progress
+
+Logging can also be configured.
+
+- `logLevel` - normal, verbose, laconic.
+- `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`:
@@ -146,4 +167,4 @@ The first run always takes a while, especially with lots of images – so be pat
 ## Links
 
 - <https://www.npmjs.com/package/sftp-push-sync>
-- <https://github.com/cnichte/sftp-push-sync>
+- <https://github.com/cnichte/sftp-push-sync>

package/bin/sftp-push-sync.mjs

@@ -2,7 +2,7 @@
 /**
  ** sftp-push-sync.mjs - SFTP Syncronisations Tool
  *
- * @author Carsten Nichte, 2025 / https://carsten-nichte.de
+ * @author Carsten Nichte, 2025 / https://carsten-nichte.de/
  *
  * SFTP push sync with dry run
  * 1. Upload new files
@@ -40,12 +40,21 @@ import { createHash } from "crypto";
 import { Writable } from "stream";
 import pc from "picocolors";
 
+// get Versionsnummer
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
 // Colors for the State (works on dark + light background)
 const ADD = pc.green("+"); // Added
 const CHA = pc.yellow("~"); // Changed
 const DEL = pc.red("-"); // Deleted
 const EXC = pc.redBright("-"); // Excluded
 
+const hr1 = () => "─".repeat(65); // horizontal line -
+const hr2 = () => "=".repeat(65); // horizontal line =
+const tab_a = () => " ".repeat(3); // indentation for formatting the output.
+
 // ---------------------------------------------------------------------------
 // CLI arguments
 // ---------------------------------------------------------------------------
@@ -53,10 +62,14 @@ const EXC = pc.redBright("-"); // Excluded
 const args = process.argv.slice(2);
 const TARGET = args[0];
 const DRY_RUN = args.includes("--dry-run");
-const VERBOSE = args.includes("--verbose") || args.includes("-v");
 const RUN_UPLOAD_LIST = args.includes("--upload-list");
 const RUN_DOWNLOAD_LIST = args.includes("--download-list");
 
+// logLevel override via CLI (optional)
+let cliLogLevel = null;
+if (args.includes("--verbose")) cliLogLevel = "verbose";
+if (args.includes("--laconic")) cliLogLevel = "laconic";
+
 if (!TARGET) {
   console.error(pc.red("❌ Please specify a connection profile:"));
   console.error(pc.yellow("   sftp-push-sync staging --dry-run"));
@@ -78,18 +91,20 @@ let CONFIG_RAW;
 try {
   CONFIG_RAW = JSON.parse(await fsp.readFile(CONFIG_PATH, "utf8"));
 } catch (err) {
-  elog(pc.red("❌ Error reading sync.config.json:"), err.message);
+  console.error(pc.red("❌ Error reading sync.config.json:"), err.message);
   process.exit(1);
 }
 
 if (!CONFIG_RAW.connections || typeof CONFIG_RAW.connections !== "object") {
-  elog(pc.red("❌ sync.config.json must have a 'connections' field."));
+  console.error(pc.red("❌ sync.config.json must have a 'connections' field."));
   process.exit(1);
 }
 
 const TARGET_CONFIG = CONFIG_RAW.connections[TARGET];
 if (!TARGET_CONFIG) {
-  elog(pc.red(`❌ Connection '${TARGET}' not found in sync.config.json.`));
+  console.error(
+    pc.red(`❌ Connection '${TARGET}' not found in sync.config.json.`)
+  );
   process.exit(1);
 }
 
@@ -103,18 +118,39 @@ const CONNECTION = {
   workers: TARGET_CONFIG.worker ?? 2,
 };
 
+// ---------------------------------------------------------------------------
+// LogLevel + Progress aus Config
+// ---------------------------------------------------------------------------
+
+// logLevel: "verbose", "normal", "laconic"
+let LOG_LEVEL = (CONFIG_RAW.logLevel ?? "normal").toLowerCase();
+
+// Override config with CLI flags
+if (cliLogLevel) {
+  LOG_LEVEL = cliLogLevel;
+}
+
+const IS_VERBOSE = LOG_LEVEL === "verbose";
+const IS_LACONIC = LOG_LEVEL === "laconic";
+
+const PROGRESS = CONFIG_RAW.progress ?? {};
+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.
+
+// ---------------------------------------------------------------------------
 // Shared config from JSON
-// Shared config from JSON
+// ---------------------------------------------------------------------------
+
 const INCLUDE = CONFIG_RAW.include ?? [];
 const BASE_EXCLUDE = CONFIG_RAW.exclude ?? [];
 
-// Spezial: Listen für gezielte Uploads / Downloads
+// Special: Lists for targeted uploads/downloads
 function normalizeList(list) {
   if (!Array.isArray(list)) return [];
   return list.flatMap((item) =>
     typeof item === "string"
-      ? // erlaubt: ["a.json, b.json"] -> ["a.json", "b.json"]
-        item
+      ? item
           .split(",")
           .map((s) => s.trim())
           .filter(Boolean)
@@ -128,7 +164,7 @@ const DOWNLOAD_LIST = normalizeList(CONFIG_RAW.downloadList ?? []);
 // Effektive Exclude-Liste: explizites exclude + Upload/Download-Listen
 const EXCLUDE = [...BASE_EXCLUDE, ...UPLOAD_LIST, ...DOWNLOAD_LIST];
 
-// Liste ALLER Dateien, die wegen uploadList/downloadList ausgeschlossen wurden
+// List of ALL files that were excluded due to uploadList/downloadList
 const AUTO_EXCLUDED = new Set();
 
 const TEXT_EXT = CONFIG_RAW.textExtensions ?? [
@@ -144,6 +180,7 @@ const TEXT_EXT = CONFIG_RAW.textExtensions ?? [
   ".md",
   ".svg",
 ];
+
 // Cache file name per connection
 const syncCacheName = TARGET_CONFIG.syncCache || `.sync-cache.${TARGET}.json`;
 const CACHE_PATH = path.resolve(syncCacheName);
@@ -166,7 +203,10 @@ try {
     CACHE.remote = raw.remote ?? {};
   }
 } catch (err) {
-  wlog(pc.yellow("⚠️  Could not load cache, starting without:"), err.message);
+  console.warn(
+    pc.yellow("⚠️ Could not load cache, starting without:"),
+    err.message
+  );
 }
 
 function cacheKey(relPath) {
@@ -217,7 +257,7 @@ function log(...msg) {
 }
 
 function vlog(...msg) {
-  if (!VERBOSE) return;
+  if (!IS_VERBOSE) return;
   clearProgressLine();
   console.log(...msg);
 }
@@ -256,27 +296,63 @@ function isTextFile(relPath) {
   return TEXT_EXT.includes(ext);
 }
 
-// Single-line progress bar
-function updateProgress(prefix, current, total) {
-  const percent = total > 0 ? ((current / total) * 100).toFixed(1) : "0.0";
-  const msg = `${prefix}${current}/${total} Dateien (${percent}%)`;
+function shortenPathForProgress(rel) {
+  if (!rel) return "";
+  const parts = rel.split("/");
+  if (parts.length === 1) {
+    return rel; // nur Dateiname
+  }
+  if (parts.length === 2) {
+    return rel; // schon kurz genug
+  }
+
+  const last = parts[parts.length - 1];
+  const prev = parts[parts.length - 2];
+
+  // z.B. …/images/foo.jpg
+  return `…/${prev}/${last}`;
+}
 
+// Two-line progress bar
+function updateProgress2(prefix, current, total, rel = "") {
   if (!process.stdout.isTTY) {
-    // Fallback: simply log
-    console.log("   " + msg);
+    // Fallback für Pipes / Logs
+    if (total && total > 0) {
+      const percent = ((current / total) * 100).toFixed(1);
+      console.log(
+        `${tab_a()}${prefix}${current}/${total} Files (${percent}%) – ${rel}`
+      );
+    } else {
+      console.log(`${tab_a()}${prefix}${current} Files – ${rel}`);
+    }
     return;
   }
 
   const width = process.stdout.columns || 80;
-  const line = msg.padEnd(width - 1);
-
-  progressActive = true;
-  process.stdout.write("\r" + line);
 
-  if (current === total) {
-    process.stdout.write("\n");
-    progressActive = false;
+  let line1;
+  if (total && total > 0) {
+    const percent = ((current / total) * 100).toFixed(1);
+    line1 = `${tab_a()}${prefix}${current}/${total} Files (${percent}%)`;
+  } else {
+    // „unknown total“ / Scanner-Modus
+    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) + "\n");
+  process.stdout.write(line2.padEnd(width));
+
+  // Cursor wieder nach oben (auf die Fortschrittszeile)
+  process.stdout.write("\x1b[1A");
+
+  progressActive = true;
 }
 
 // Simple worker pool for parallel tasks
@@ -297,11 +373,11 @@ async function runTasks(items, workerCount, handler, label = "Tasks") {
       try {
         await handler(item);
       } catch (err) {
-        elog(pc.red(`   ⚠️ Error in ${label}:`), err.message || err);
+        elog(pc.red(`${tab_a()}⚠️ Error in ${label}:`), err.message || err);
       }
       done += 1;
       if (done % 10 === 0 || done === total) {
-        updateProgress(`   ${label}: `, done, total);
+        updateProgress2(`${tab_a()}${label}: `, done, total);
       }
     }
   }
@@ -320,6 +396,7 @@ async function runTasks(items, workerCount, handler, label = "Tasks") {
 
 async function walkLocal(root) {
   const result = new Map();
+  let scanned = 0;
 
   async function recurse(current) {
     const entries = await fsp.readdir(current, { withFileTypes: true });
@@ -329,7 +406,9 @@ async function walkLocal(root) {
         await recurse(full);
       } else if (entry.isFile()) {
         const rel = toPosix(path.relative(root, full));
+
         if (!isIncluded(rel)) continue;
+
         const stat = await fsp.stat(full);
         result.set(rel, {
           rel,
@@ -338,11 +417,26 @@ async function walkLocal(root) {
           mtimeMs: stat.mtimeMs,
           isText: isTextFile(rel),
         });
+
+        scanned += 1;
+        const chunk = IS_VERBOSE ? 1 : SCAN_CHUNK;
+        if (scanned === 1 || scanned % chunk === 0) {
+          // totally unknown → totally = 0 → no automatic \n
+          updateProgress2("   Scan local: ", scanned, 0, rel);
+        }
       }
     }
   }
 
   await recurse(root);
+
+  if (scanned > 0) {
+    // last line + neat finish
+    updateProgress2("   Scan local: ", scanned, 0, "fertig");
+    process.stdout.write("\n");
+    progressActive = false;
+  }
+
   return result;
 }
 
@@ -352,6 +446,7 @@ async function walkLocal(root) {
 
 async function walkRemote(sftp, remoteRoot) {
   const result = new Map();
+  let scanned = 0;
 
   async function recurse(remoteDir, prefix) {
     const items = await sftp.list(remoteDir);
@@ -374,11 +469,24 @@ async function walkRemote(sftp, remoteRoot) {
           size: Number(item.size),
           modifyTime: item.modifyTime ?? 0,
         });
+
+        scanned += 1;
+        const chunk = IS_VERBOSE ? 1 : SCAN_CHUNK;
+        if (scanned === 1 || scanned % chunk === 0) {
+          updateProgress2("   Scan remote: ", scanned, 0, rel);
+        }
       }
     }
   }
 
-  await recurse(remoteRoot, "");
+  await recurse(remoteRoot);
+
+  if (scanned > 0) {
+    updateProgress2("   Scan remote: ", scanned, 0, "fertig");
+    process.stdout.write("\n");
+    progressActive = false;
+  }
+
   return result;
 }
 
@@ -455,6 +563,45 @@ async function getRemoteHash(rel, meta, sftp) {
   return hash;
 }
 
+// ---------------------------------------------------------------------------
+// SFTP error explanation (for clearer messages)
+// ---------------------------------------------------------------------------
+
+function describeSftpError(err) {
+  if (!err) return "";
+
+  const code = err.code || err.errno || "";
+  const msg = (err.message || "").toLowerCase();
+
+  // Netzwerk / DNS
+  if (code === "ENOTFOUND") {
+    return "Host not found (ENOTFOUND) – Check hostname or DNS entry.";
+  }
+  if (code === "EHOSTUNREACH") {
+    return "Host not reachable (EHOSTUNREACH) – Check network/firewall.";
+  }
+  if (code === "ECONNREFUSED") {
+    return "Connection refused (ECONNREFUSED) – Check the port or SSH service.";
+  }
+  if (code === "ECONNRESET") {
+    return "Connection was reset by the server (ECONNRESET).";
+  }
+  if (code === "ETIMEDOUT") {
+    return "Connection timeout (ETIMEDOUT) – Server is not responding or is blocked.";
+  }
+
+  // Auth / Authorisations
+  if (msg.includes("all configured authentication methods failed")) {
+    return "Authentication failed – check your username/password or SSH keys.";
+  }
+  if (msg.includes("permission denied")) {
+    return "Access denied – check permissions on the server.";
+  }
+
+  // Fallback
+  return "";
+}
+
 // ---------------------------------------------------------------------------
 // MAIN
 // ---------------------------------------------------------------------------
@@ -462,39 +609,46 @@ async function getRemoteHash(rel, meta, sftp) {
 async function main() {
   const start = Date.now();
 
-  log("\n\n==================================================================");
-  log(pc.bold("🔐 SFTP Push-Synchronisation: sftp-push-sync"));
-  log(`   Connection: ${pc.cyan(TARGET)}  (Worker: ${CONNECTION.workers})`);
-  log(`   Host:   ${pc.green(CONNECTION.host)}:${pc.green(CONNECTION.port)}`);
-  log(`   Local:  ${pc.green(CONNECTION.localRoot)}`);
-  log(`   Remote: ${pc.green(CONNECTION.remoteRoot)}`);
+  log(`\n\n${hr2()}`);
+  log(
+    pc.bold(
+      `🔐 SFTP Push-Synchronisation: sftp-push-sync  v${pkg.version}  [logLevel=${LOG_LEVEL}]`
+    )
+  );
+  log(`${tab_a()}Connection: ${pc.cyan(TARGET)}`);
+  log(`Worker: ${CONNECTION.workers}`);
+  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("   Mode: DRY-RUN (no changes)"));
   if (RUN_UPLOAD_LIST || RUN_DOWNLOAD_LIST) {
     log(
       pc.blue(
-        `   Extra: ${RUN_UPLOAD_LIST ? "uploadList " : ""}${
+        `${tab_a()}Extra: ${RUN_UPLOAD_LIST ? "uploadList " : ""}${
           RUN_DOWNLOAD_LIST ? "downloadList" : ""
         }`
       )
     );
   }
-  log("-----------------------------------------------------------------\n");
+  log(`${hr1()}\n`);
 
   const sftp = new SftpClient();
+  let connected = false;
 
   const toAdd = [];
   const toUpdate = [];
   const toDelete = [];
 
   try {
+    log(pc.cyan("🔌 Connecting to SFTP server …"));
     await sftp.connect({
       host: CONNECTION.host,
       port: CONNECTION.port,
       username: CONNECTION.user,
       password: CONNECTION.password,
     });
-
-    vlog(pc.dim("   Connection established."));
+    connected = true;
+    log(pc.green(`${tab_a()}✔ Connected to SFTP.`));
 
     if (!fs.existsSync(CONNECTION.localRoot)) {
       console.error(
@@ -506,20 +660,20 @@ async function main() {
 
     log(pc.bold(pc.cyan("📥 Phase 1: Scan local files …")));
     const local = await walkLocal(CONNECTION.localRoot);
-    log(`   → ${local.size} local files`);
+    log(`${tab_a()}→ ${local.size} local files`);
 
     if (AUTO_EXCLUDED.size > 0) {
       log("");
       log(pc.dim("   Auto-excluded (uploadList/downloadList):"));
       [...AUTO_EXCLUDED].sort().forEach((file) => {
-        log(pc.dim(`      - ${file}`));
+        log(pc.dim(`${tab_a()} - ${file}`));
       });
       log("");
     }
 
     log(pc.bold(pc.cyan("📤 Phase 2: Scan remote files …")));
     const remote = await walkRemote(sftp, CONNECTION.remoteRoot);
-    log(`   → ${remote.size} remote files\n`);
+    log(`${tab_a()}→ ${remote.size} remote files\n`);
 
     const localKeys = new Set(local.keys());
     const remoteKeys = new Set(remote.keys());
@@ -531,28 +685,34 @@ async function main() {
     // Analysis: just decide, don't upload/delete anything yet
     for (const rel of localKeys) {
       checkedCount += 1;
+
+      const chunk = IS_VERBOSE ? 1 : ANALYZE_CHUNK;
       if (
-        checkedCount === 1 || // sofortige erste Ausgabe
-        checkedCount % 100 === 0 || // aktualisieren alle 100
-        checkedCount === totalToCheck // letzte Ausgabe immer
+        checkedCount === 1 || // immediate first issue
+        checkedCount % chunk === 0 ||
+        checkedCount === totalToCheck
       ) {
-        updateProgress("   Analyse: ", checkedCount, totalToCheck);
+        updateProgress2("   Analyse: ", checkedCount, totalToCheck, rel);
       }
+
       const l = local.get(rel);
       const r = remote.get(rel);
-
       const remotePath = path.posix.join(CONNECTION.remoteRoot, rel);
 
       if (!r) {
         toAdd.push({ rel, local: l, remotePath });
-        log(`${ADD} ${pc.green("New:")} ${rel}`);
+        if (!IS_LACONIC) {
+          log(`${ADD} ${pc.green("New:")} ${rel}`);
+        }
         continue;
       }
 
       // 1. size comparison
       if (l.size !== r.size) {
         toUpdate.push({ rel, local: l, remote: r, remotePath });
-        log(`${CHA} ${pc.yellow("Size changed:")} ${rel}`);
+        if (!IS_LACONIC) {
+          log(`${CHA} ${pc.yellow("Size changed:")} ${rel}`);
+        }
         continue;
       }
 
@@ -570,18 +730,20 @@ async function main() {
         ).toString("utf8");
 
         if (localStr === remoteStr) {
-          vlog(`   ${pc.dim("✓ Unchanged (Text):")} ${rel}`);
+          vlog(`${tab_a()}${pc.dim("✓ Unchanged (Text):")} ${rel}`);
           continue;
         }
 
-        if (VERBOSE) {
+        if (IS_VERBOSE) {
           const diff = diffWords(remoteStr, localStr);
           const blocks = diff.filter((d) => d.added || d.removed).length;
-          vlog(`   ${CHA} Text difference (${blocks} blocks) in ${rel}`);
+          vlog(`${tab_a()}${CHA} Text difference (${blocks} blocks) in ${rel}`);
         }
 
         toUpdate.push({ rel, local: l, remote: r, remotePath });
-        log(`${CHA} ${pc.yellow("Content changed (Text):")} ${rel}`);
+        if (!IS_LACONIC) {
+          log(`${tab_a()}${CHA} ${pc.yellow("Content changed (Text):")} ${rel}`);
+        }
       } else {
         // Binary: Hash comparison with cache
         const localMeta = l;
@@ -593,18 +755,20 @@ async function main() {
         ]);
 
         if (localHash === remoteHash) {
-          vlog(`   ${pc.dim("✓ Unchanged (binary, hash):")} ${rel}`);
+          vlog(`${tab_a()}${pc.dim("✓ Unchanged (binary, hash):")} ${rel}`);
           continue;
         }
 
-        if (VERBOSE) {
-          vlog(`   ${CHA} Hash different (binary): ${rel}`);
-          vlog(`      local:  ${localHash}`);
-          vlog(`      remote: ${remoteHash}`);
+        if (IS_VERBOSE) {
+          vlog(`${tab_a()}${CHA} Hash different (binary): ${rel}`);
+          vlog(`${tab_a()}   local:  ${localHash}`);
+          vlog(`${tab_a()}   remote: ${remoteHash}`);
         }
 
         toUpdate.push({ rel, local: l, remote: r, remotePath });
-        log(`${CHA} ${pc.yellow("Content changed (Binary):")} ${rel}`);
+        if (!IS_LACONIC) {
+          log(`${CHA} ${pc.yellow("Content changed (Binary):")} ${rel}`);
+        }
       }
     }
 
@@ -615,7 +779,9 @@ async function main() {
       if (!localKeys.has(rel)) {
         const r = remote.get(rel);
         toDelete.push({ rel, remotePath: r.remotePath });
-        log(`   ${DEL} ${pc.red("Remove:")} ${rel}`);
+        if (!IS_LACONIC) {
+          log(`${tab_a()}${DEL} ${pc.red("Remove:")} ${rel}`);
+        }
       }
     }
 
@@ -676,7 +842,11 @@ async function main() {
         "Deletes"
       );
     } else {
-      log(pc.yellow("\n💡 DRY-RUN: No files transferred or deleted."));
+      log(
+        pc.yellow(
+          "\n💡 DRY-RUN: Connection tested, no files transferred or deleted."
+        )
+      );
     }
 
     // -------------------------------------------------------------------
@@ -686,7 +856,7 @@ async function main() {
     if (RUN_UPLOAD_LIST && UPLOAD_LIST.length > 0) {
       log(
         "\n" +
-          pc.bold(pc.cyan("⬆️  Extra Phase: Upload-List (explicit files) …"))
+          pc.bold(pc.cyan("⬆️ Extra Phase: Upload-List (explicit files) …"))
       );
 
       const tasks = UPLOAD_LIST.map((rel) => ({
@@ -697,7 +867,7 @@ async function main() {
 
       if (DRY_RUN) {
         for (const t of tasks) {
-          log(`   ${ADD} would upload (uploadList): ${t.rel}`);
+          log(`${tab_a()}${ADD} would upload (uploadList): ${t.rel}`);
         }
       } else {
         await runTasks(
@@ -711,7 +881,7 @@ async function main() {
               // ignore
             }
             await sftp.put(localPath, remotePath);
-            log(`   ${ADD} uploadList: ${rel}`);
+            log(`${tab_a()}${ADD} uploadList: ${rel}`);
           },
           "Upload-List"
         );
@@ -721,7 +891,7 @@ async function main() {
     if (RUN_DOWNLOAD_LIST && DOWNLOAD_LIST.length > 0) {
       log(
         "\n" +
-          pc.bold(pc.cyan("⬇️  Extra Phase: Download-List (explicit files) …"))
+          pc.bold(pc.cyan("⬇️ Extra Phase: Download-List (explicit files) …"))
       );
 
       const tasks = DOWNLOAD_LIST.map((rel) => ({
@@ -732,7 +902,7 @@ async function main() {
 
       if (DRY_RUN) {
         for (const t of tasks) {
-          log(`   ${ADD} would download (downloadList): ${t.rel}`);
+          log(`${tab_a()}${ADD} would download (downloadList): ${t.rel}`);
         }
       } else {
         await runTasks(
@@ -741,7 +911,7 @@ async function main() {
           async ({ remotePath, localPath, rel }) => {
             await fsp.mkdir(path.dirname(localPath), { recursive: true });
             await sftp.fastGet(remotePath, localPath);
-            log(`   ${ADD} downloadList: ${rel}`);
+            log(`${tab_a()}${ADD} downloadList: ${rel}`);
           },
           "Download-List"
         );
@@ -755,36 +925,41 @@ async function main() {
 
     // Summary
     log("\n" + pc.bold(pc.cyan("📊 Summary:")));
-    log(`   Duration: ${pc.green(duration + " s")}`);
-    log(`   ${ADD} Added  : ${toAdd.length}`);
-    log(`   ${CHA} Changed: ${toUpdate.length}`);
-    log(`   ${DEL} Deleted: ${toDelete.length}`);
+    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(
-        `   ${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("\n📄 Changes:");
       [...toAdd.map((t) => t.rel)]
         .sort()
-        .forEach((f) => console.log(`   ${ADD} ${f}`));
+        .forEach((f) => console.log(`${tab_a()}${ADD} ${f}`));
       [...toUpdate.map((t) => t.rel)]
         .sort()
-        .forEach((f) => console.log(`   ${CHA} ${f}`));
+        .forEach((f) => console.log(`${tab_a()}${CHA} ${f}`));
       [...toDelete.map((t) => t.rel)]
         .sort()
-        .forEach((f) => console.log(`   ${DEL} ${f}`));
+        .forEach((f) => console.log(`${tab_a()}${DEL} ${f}`));
     } else {
       log("\nNo changes.");
     }
 
     log("\n" + pc.bold(pc.green("✅ Sync complete.")));
-    log(
-      "==================================================================\n\n"
-    );
   } catch (err) {
-    elog(pc.red("❌ Synchronisation error:"), err);
+    const hint = describeSftpError(err);
+    elog(pc.red("❌ Synchronisation error:"), err.message || err);
+    if (hint) {
+      wlog(pc.yellow(`${tab_a()}Mögliche Ursache:`), hint);
+    }
+    if (IS_VERBOSE) {
+      // Vollständiges Error-Objekt nur in verbose anzeigen
+      console.error(err);
+    }
     process.exitCode = 1;
     try {
       await saveCache(true);
@@ -793,11 +968,18 @@ async function main() {
     }
   } finally {
     try {
-      await sftp.end();
-    } catch {
-      // ignore
+      if (connected) {
+        await sftp.end();
+        log(pc.green(`${tab_a()}✔ Connection closed.`));
+      }
+    } catch (e) {
+      wlog(
+        pc.yellow("⚠️ Could not close SFTP connection cleanly:"),
+        e.message || e
+      );
     }
   }
+  log(`${hr2()}\n\n`);
 }
 
 main();

package/package.json

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