saltcorn-samba 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to `saltcorn-samba` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.4.4] – 2026-07-05
+
+### Fixed – **Falscher `NAME_NOT_FOUND` durch `stat()`-Vorprüfung**
+
+Die 0.4.3-Vorprüfung mit `client.stat(base_path)` schlug bei einigen
+Samba-Servern fehl, obwohl der Ordner existiert und per `readdir()`
+zugänglich ist. Ursache: `smb3-client` schickt in `stat()` ein CREATE
+ohne `DIRECTORY_FILE`-Flag (`createOptions: 0`); manche Samba-
+Konfigurationen (v.a. mit „access based enumeration“ oder speziellen
+POSIX-ACLs) beantworten das mit `NAME_NOT_FOUND`, während derselbe
+Ordner mit `readdir()` (`createOptions: 1 = DIRECTORY_FILE`) einwandfrei
+geht.
+
+**Fix:** Die Test-Route ruft direkt `readdir(base_path)` auf und fängt
+den Fehler ab. Das ist auch semantisch korrekter – wir wollen wissen,
+ob der Basispfad *aufgelistet* werden kann, nicht nur, ob er sich
+öffnen lässt.
+
+### Added – **Case-/Schreibvarianten-Test bei fehlender Basispfad-Erkennung**
+
+Schlägt der `readdir(base_path)`-Aufruf mit `NAME_NOT_FOUND` /
+`PATH_NOT_FOUND` fehl, probiert die Test-Route zusätzlich:
+
+- den Namen in UPPERCASE,
+- den Namen in lowercase,
+- den Namen als Capitalised.
+
+Gelingt eine dieser Varianten, wird der tatsächliche Name grün
+hervorgehoben („Gefunden: Der Ordner existiert unter dem Namen …“) und
+der User bekommt einen direkt umsetzbaren Fix. Schlagen alle Varianten
+mit demselben Fehler fehl, liegt es fast sicher an Zugriffsrechten
+(`hide unreadable = yes`) oder an `veto files` — die Meldung erklärt
+beide Fälle.
+
+Die Diagnose-Box im UI zeigt jetzt zusätzlich:
+
+- eine grüne Markierung mit dem richtigen Ordnernamen (falls gefunden),
+- eine ausklappbare Tabelle mit allen Schreibvarianten-Ergebnissen,
+- die Fehlermeldung beim Auflisten des übergeordneten Ordners (falls
+  das ebenfalls scheitert).
+
 ## [0.4.3] – 2026-07-05
 
 ### Fixed – **Unklare Meldung bei nicht-existierendem Basispfad**

package/index.js

@@ -200,8 +200,19 @@ window.sambaTestConn = async function(btn) {
             });
             var box = '<div style="margin-top:.4rem;padding:.4rem .6rem;background:#f8d7da;border:1px solid #f5c2c7;border-radius:.25rem">';
             box += '<b>Diagnose:</b> Der Server meldet, dass \u201e<code>' + esc(d.missing_segment) + '</code>\u201c im Ordner \u201e<code>' + esc(d.parent_path) + '</code>\u201c nicht existiert.';
+            // Working alternative spelling has the highest signal.
+            if (d.working_alternative) {
+              box += '<div style="margin-top:.3rem;padding:.3rem .5rem;background:#d1e7dd;border:1px solid #a3cfbb;border-radius:.25rem;color:#0f5132"><b>\u2192 Gefunden:</b> Der Ordner existiert unter dem Namen \u201e<code>' + esc(d.working_alternative) + '</code>\u201c. Bitte diesen exakt so als Basispfad eintragen.</div>';
+            }
             if (!d.parent_listable) {
-              box += '<br><span class="text-muted">(Der übergeordnete Ordner konnte nicht aufgelistet werden — Share-Root-Auflistung ist mit smb3-client aktuell blockiert.)</span>';
+              box += '<br><span class="text-muted">(Der übergeordnete Ordner konnte nicht aufgelistet werden';
+              if (d.parent_path === '(Share-Root)') {
+                box += ' \u2014 die direkte Auflistung des Share-Roots ist mit smb3-client auf Samba aktuell blockiert';
+              }
+              if (d.parent_error) {
+                box += '. Server-Antwort: <code>' + esc(d.parent_error) + '</code>';
+              }
+              box += '.)</span>';
             } else if (sibs.length === 0) {
               box += '<br>Der übergeordnete Ordner ist leer.';
             } else {
@@ -215,6 +226,18 @@ window.sambaTestConn = async function(btn) {
               if (sibs.length > 100) box += '<li><i>… (' + (sibs.length - 100) + ' weitere)</i></li>';
               box += '</ul></details>';
             }
+            // Spelling / case probes — always show, even without a
+            // working alternative, because seeing all four probes fail
+            // with the same error strongly suggests a permission issue
+            // rather than a spelling issue.
+            if (Array.isArray(d.spelling_probes) && d.spelling_probes.length) {
+              box += '<details style="margin-top:.3rem"><summary>Schreibvarianten-Test</summary><table class="table table-sm" style="margin-top:.3rem;font-size:.85em">';
+              box += '<thead><tr><th>Variante</th><th>Ergebnis</th></tr></thead><tbody>';
+              d.spelling_probes.forEach(function(p){
+                box += '<tr><td><code>' + esc(p.candidate) + '</code></td><td>' + (p.ok ? '✓ auflistbar' : '✗ <span class="text-muted">' + esc(String(p.error||'').split(/[\r\n]/)[0].slice(0,140)) + '</span>') + '</td></tr>';
+              });
+              box += '</tbody></table></details>';
+            }
             box += '</div>';
             return box;
           })()) +
@@ -835,66 +858,13 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           // BEFORE trying to enumerate it. This turns the opaque
           // "CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND" into a clear
           // "Basispfad existiert nicht" hint the user can act on.
-          if (rel) {
-            let st;
-            try {
-              st = await client.stat(rel);
-            } catch (statErr) {
-              const smsg = String((statErr && statErr.message) || statErr || "");
-              if (/OBJECT_NAME_NOT_FOUND|OBJECT_PATH_NOT_FOUND|ENOENT|STATUS_NO_SUCH_FILE/i.test(smsg)) {
-                // Try to list the parent directory so we can *show* the
-                // user what the server actually reports at that level.
-                // This helps distinguish typo vs. case-mismatch vs.
-                // permission-hidden entry. If the parent is the share
-                // root we can't list it (known smb3-client / Samba bug),
-                // so we just skip the sibling probe in that case.
-                const parts = rel.split("/").filter(Boolean);
-                const missing = parts[parts.length - 1];
-                const parent = parts.slice(0, -1).join("/");
-                let siblings = null;
-                if (parent) {
-                  try {
-                    const listing = await client.readdir(parent);
-                    siblings = Array.isArray(listing)
-                      ? listing.map((d) => ({
-                          name: d && (d.name || d),
-                          isDirectory: !!(d && (d.isDirectory === true || (typeof d.isDirectory === "function" && d.isDirectory()))),
-                        }))
-                      : null;
-                  } catch (_) {
-                    siblings = null;
-                  }
-                }
-                const hint =
-                  "Der Basispfad \u201e" + rel + "\u201c existiert auf der " +
-                  "Freigabe \u201e" + testCfg.share + "\u201c nicht " +
-                  "(oder ist f\u00fcr den angemeldeten Benutzer nicht " +
-                  "sichtbar). Bitte Schreibweise, Gro\u00df-/Kleinschreibung " +
-                  "und Zugriffsrechte pr\u00fcfen. Der Basispfad ist relativ " +
-                  "zur Freigabe \u2014 also z.\u202fB. \u201eprojekte/2026\u201c, " +
-                  "nicht \u201e/mnt/\u2026\u201c.";
-                const e = new Error(hint);
-                e.cause = statErr;
-                e.code = "BASE_PATH_NOT_FOUND";
-                e.diagnostics = {
-                  missing_segment: missing,
-                  parent_path: parent || "(Share-Root)",
-                  parent_listable: siblings !== null,
-                  siblings: siblings,
-                };
-                throw e;
-              }
-              throw statErr;
-            }
-            if (st && st.isDirectory === false && st.isFile === true) {
-              const e = new Error(
-                "Der Basispfad \u201e" + rel + "\u201c ist eine Datei, kein " +
-                "Verzeichnis. Bitte tragen Sie einen Ordnernamen ein."
-              );
-              e.code = "BASE_PATH_NOT_A_DIR";
-              throw e;
-            }
-          }
+          // We used to run a stat() first. That turned out to be flaky:
+          // smb3-client's stat() sends a CREATE with createOptions=0
+          // (no directory hint) which some Samba configurations reject
+          // for directories with strict ACLs. readdir() sends
+          // createOptions=1 (DIRECTORY_FILE) and is the right primitive
+          // for a base_path check anyway — we want to know the folder
+          // can actually be listed, not just opened.
           try {
             return await client.readdir(rel);
           } catch (err) {
@@ -919,6 +889,100 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
                 throw err;
               }
             }
+            // A non-existent base_path (or one hidden from this user by
+            // Samba's "hide unreadable" behaviour) surfaces here. Try to
+            // gather actionable diagnostics: list the parent directory
+            // (if not the share root) and probe common alternative
+            // spellings of the missing segment so we can distinguish
+            // typo / case-mismatch / permission problems.
+            const isMissing = /OBJECT_NAME_NOT_FOUND|OBJECT_PATH_NOT_FOUND|ENOENT|STATUS_NO_SUCH_FILE|existiert.*nicht/i.test(msg);
+            if (rel && isMissing) {
+              const parts = rel.split("/").filter(Boolean);
+              const missing = parts[parts.length - 1];
+              const parent = parts.slice(0, -1).join("/");
+              const parentAbs = parent || "(Share-Root)";
+              let siblings = null;
+              let parent_error = null;
+              if (parent) {
+                try {
+                  const listing = await client.readdir(parent);
+                  siblings = Array.isArray(listing)
+                    ? listing.map((d) => ({
+                        name: d && (d.name || d),
+                        isDirectory: !!(d && (d.isDirectory === true || (typeof d.isDirectory === "function" && d.isDirectory()))),
+                      }))
+                    : null;
+                } catch (parentErr) {
+                  parent_error = String((parentErr && parentErr.message) || parentErr || "");
+                }
+              }
+              // Probe alternate spellings: original, upper, lower, capitalised.
+              // This lets us report "Ordner existiert unter anderem Namen" if
+              // Samba is running with case sensitive = yes / case-preserved.
+              const probes = [];
+              const seen = new Set();
+              const addProbe = (name) => {
+                if (!name || seen.has(name)) return;
+                seen.add(name);
+                probes.push(name);
+              };
+              addProbe(missing);
+              addProbe(missing.toUpperCase());
+              addProbe(missing.toLowerCase());
+              addProbe(missing.charAt(0).toUpperCase() + missing.slice(1).toLowerCase());
+              const probe_results = [];
+              for (const p of probes) {
+                const candidate = parent ? parent + "/" + p : p;
+                let ok = false;
+                let perr = null;
+                try {
+                  await client.readdir(candidate);
+                  ok = true;
+                } catch (pErr) {
+                  perr = String((pErr && pErr.message) || pErr || "");
+                }
+                probe_results.push({ candidate: p, ok, error: ok ? null : perr });
+              }
+              const workingAlt = probe_results.find(
+                (r) => r.ok && r.candidate !== missing
+              );
+              let hintText;
+              if (workingAlt) {
+                hintText =
+                  "Der Ordner heisst auf dem Server \u201e" +
+                  workingAlt.candidate +
+                  "\u201c (andere Gross-/Kleinschreibung). Bitte den " +
+                  "Basispfad exakt so eintragen \u2014 der Samba-Server ist " +
+                  "case-sensitive (\u201ecase sensitive = yes\u201c in smb.conf).";
+              } else {
+                hintText =
+                  "Der Basispfad \u201e" + rel + "\u201c ist auf dem " +
+                  "Server nicht auffindbar. M\u00f6gliche Ursachen: " +
+                  "(a) der Ordner existiert wirklich nicht (bitte mit " +
+                  "einem SMB-Client wie \u201esmbclient\u201c oder dem " +
+                  "Windows-Explorer gegenpr\u00fcfen); " +
+                  "(b) der angemeldete Benutzer \u201e" +
+                  (testCfg.username || "(anonymous)") +
+                  "\u201c hat kein Leserecht auf den Ordner (Samba antwortet " +
+                  "dann bei \u201ehide unreadable = yes\u201c mit " +
+                  "NAME_NOT_FOUND statt ACCESS_DENIED); " +
+                  "(c) der Ordner ist per \u201eveto files\u201c / " +
+                  "\u201ehide files\u201c auf dem Server ausgeblendet.";
+              }
+              const e = new Error(hintText);
+              e.cause = err;
+              e.code = "BASE_PATH_NOT_FOUND";
+              e.diagnostics = {
+                missing_segment: missing,
+                parent_path: parentAbs,
+                parent_listable: siblings !== null,
+                parent_error: parent_error,
+                siblings: siblings,
+                spelling_probes: probe_results,
+                working_alternative: workingAlt ? workingAlt.candidate : null,
+              };
+              throw e;
+            }
             throw err;
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Saltcorn plugin: browse, upload, rename and delete files on a Samba/CIFS share via SMB 3.1.1 (AES-CMAC signing, optional encryption). File-manager view, directory tree, inline PDF viewer, external-app open (smb://).",
   "main": "index.js",
   "scripts": {