saltcorn-samba 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -4,6 +4,83 @@ 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**
+
+Wenn ein Basispfad angegeben wurde, der auf dem Server nicht existiert
+(oder für den angemeldeten Benutzer nicht sichtbar ist), meldete die
+Test-Route bisher nur die rohe Server-Antwort:
+
+```
+CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND (ENOENT)
+CREATE failed: STATUS_OBJECT_PATH_NOT_FOUND (ENOENT)
+```
+
+Daraus konnte der Benutzer nicht erkennen, ob es sich um einen Tippfehler,
+um einen Klein-/Großschreibungs-Konflikt (Samba mit `case sensitive = yes`)
+oder um eine Berechtigung handelt.
+
+**Neu:**
+
+1. Die Test-Route prüft den Basispfad jetzt zuerst mit `stat()`, bevor sie
+   `readdir()` versucht. Fehlt der Ordner, wird eine deutsche Meldung
+   zurückgegeben, die den betroffenen Pfad, die Freigabe und typische
+   Ursachen (Schreibweise, Groß-/Kleinschreibung, Zugriffsrechte) nennt.
+2. Zusätzlich liefert die Route ein `diagnostics`-Objekt zurück, das
+   den fehlenden Segmentnamen, den übergeordneten Pfad und — sofern der
+   übergeordnete Ordner auflistbar ist — dessen tatsächliche Einträge
+   enthält. Das Test-UI hebt ähnlich geschriebene Nachbareinträge hervor,
+   damit Tippfehler oder Case-Mismatch sofort sichtbar werden.
+3. Der `smb-client.js`-`readdir()`-Wrapper mappt `OBJECT_NAME_NOT_FOUND`
+   und `OBJECT_PATH_NOT_FOUND` ebenfalls auf eine deutsche Meldung, damit
+   auch der File-Manager (außerhalb der Test-Route) verständlich über
+   fehlende Ordner informiert.
+
+**Kein Config-Migrationsschritt nötig.** Wer die neuen Diagnose-Boxen
+sehen will, muss lediglich `pv-host/saltcorn-samba@0.4.3` einspielen.
+
 ## [0.4.2] – 2026-07-05
 
 ### Fixed – **Dropdown-Felder zeigen `[object Object]` statt Optionen**

package/index.js

@@ -184,6 +184,63 @@ window.sambaTestConn = async function(btn) {
           'Fehler: <code>' + String(data && data.error || 'Unbekannt').replace(/[<>&]/g,'?') + '</code>' +
           (data && data.code ? ' <span class="text-muted">(' + data.code + ')</span>' : '') + '<br>' +
           (data && data.hint ? '<div style="margin-top:.4rem"><b>Hinweis:</b> ' + String(data.hint).replace(/[<>&]/g,'?') + '</div>' : '') +
+          ((function(){
+            var d = data && data.diagnostics;
+            if (!d) return '';
+            var esc = function(s){ return String(s==null?'':s).replace(/[<>&]/g,function(c){return {'<':'&lt;','>':'&gt;','&':'&amp;'}[c];}); };
+            var lc = String(d.missing_segment||'').toLowerCase();
+            var sibs = Array.isArray(d.siblings) ? d.siblings : [];
+            var similar = sibs.filter(function(s){
+              var n = String(s.name||'').toLowerCase();
+              if (!n || !lc) return false;
+              if (n === lc) return true;
+              if (n.indexOf(lc) !== -1 || lc.indexOf(n) !== -1) return true;
+              // simple Levenshtein-1 heuristic: same length ±1 and share prefix
+              return Math.abs(n.length - lc.length) <= 1 && n.substring(0, Math.min(3, n.length)) === lc.substring(0, Math.min(3, lc.length));
+            });
+            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';
+              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 {
+              if (similar.length) {
+                box += '<br><b>Ähnliche Einträge, die tatsächlich existieren:</b><ul style="margin:.3rem 0 .3rem 1rem">';
+                similar.slice(0, 10).forEach(function(s){ box += '<li>' + (s.isDirectory?'📁 ':'📄 ') + '<code>' + esc(s.name) + '</code></li>'; });
+                box += '</ul>';
+              }
+              box += '<details style="margin-top:.3rem"><summary>Alle Einträge im Ordner \u201e' + esc(d.parent_path) + '\u201c anzeigen (' + sibs.length + ')</summary><ul style="margin:.3rem 0 0 1rem">';
+              sibs.slice(0, 100).forEach(function(s){ box += '<li>' + (s.isDirectory?'📁 ':'📄 ') + '<code>' + esc(s.name) + '</code></li>'; });
+              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;
+          })()) +
           (a.server ? (
             '<details style="margin-top:.4rem"><summary>Versuchte Verbindungsdaten</summary>' +
             '<table class="table table-sm" style="margin-top:.4rem">' +
@@ -797,6 +854,17 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           // (TCP + Negotiate + Session + TREE_CONNECT + Auth) works, which
           // is all the connection test actually promises.
           const rel = testCfg.base_path ? sanitizeRelativePath(testCfg.base_path) : "";
+          // When a base_path is set, verify it exists and is a directory
+          // 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.
+          // 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) {
@@ -821,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;
           }
         });
@@ -890,6 +1052,7 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           error: msg,
           code,
           hint,
+          diagnostics: (err && err.diagnostics) || undefined,
           attempted: {
             server: testCfg.server,
             share: testCfg.share,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.2",
+  "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": {

package/smb-client.js

@@ -304,6 +304,28 @@ async function buildClient(config) {
           e.cause = err;
           throw e;
         }
+        // A missing directory (either the base_path itself or a
+        // sub-directory the caller asked to list) surfaces as CREATE
+        // failing with STATUS_OBJECT_NAME_NOT_FOUND / OBJECT_PATH_NOT_FOUND
+        // (both reported by smb3-client with an ENOENT tail). The raw
+        // "CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND (ENOENT)" is not
+        // actionable for end users, so rewrap it into a German hint that
+        // names the actual missing path.
+        const isMissing =
+          /OBJECT_NAME_NOT_FOUND|OBJECT_PATH_NOT_FOUND|ENOENT|STATUS_NO_SUCH_FILE/i.test(msg);
+        if (isMissing) {
+          const shown = full.replace(/^[^/]+\/?/, "") || "(Share-Root)";
+          const e = new Error(
+            "Der Pfad „" + shown + "“ existiert auf der Freigabe „" +
+            shareName + "“ nicht (oder ist für den angemeldeten Benutzer " +
+            "nicht sichtbar). Bitte Schreibweise, Groß-/Kleinschreibung " +
+            "und Zugriffsrechte prüfen. Ursprüngliche Server-Antwort: " +
+            (msg || "CREATE failed")
+          );
+          e.cause = err;
+          e.code = "ENOENT";
+          throw e;
+        }
         throw err;
       }
       // Parallel enrichment. Bounded to a reasonable concurrency to avoid