fix: allow network paths

2026-05-27 15:02:32 -04:00
parent 5996443f38
commit ba86f5830f
9 changed files with 342 additions and 196 deletions
@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react'
 import DirectoryBrowser from './DirectoryBrowser'
 import { useConfig, useSaveConfig } from '../hooks/useConfig'
+import { apiFetch } from '../lib/api'

 function fmtSeconds(s) {
  if (s == null) return ''
@@ -16,15 +17,21 @@ export default function ConfigModal({ onClose }) {
  const [browser, setBrowser]     = useState(null) // 'target_dir' | 'results_dir' | null
  const [scanResult, setScanResult] = useState(null) // { testCount, completedCount } | null
  const [saveError, setSaveError]   = useState(null)
+  const [isRescanning, setIsRescanning] = useState(false)
+  const [isSavingTimes, setIsSavingTimes] = useState(false)

  useEffect(() => {
    if (config) {
      setForm({
        target_dir:      config.target_dir      ?? '',
        results_dir:     config.results_dir     ?? '',
+        results_dir_ref: config.results_dir_ref ?? '',
        avg_time_coe: config.avg_time_coe ? fmtSeconds(config.avg_time_coe) : '',
        avg_time_p2p: config.avg_time_p2p ? fmtSeconds(config.avg_time_p2p) : '',
        avg_time_p3p: config.avg_time_p3p ? fmtSeconds(config.avg_time_p3p) : '',
+        smb_username: config.smb_username ?? '',
+        smb_password: config.smb_password ?? '',
+        smb_domain: config.smb_domain ?? '',
      })
    }
  }, [config])
@@ -35,10 +42,14 @@ export default function ConfigModal({ onClose }) {
    const payload = {
      target_dir:      form.target_dir      || null,
      results_dir:     form.results_dir     || null,
+      results_dir_ref: form.results_dir_ref || null,
      // Convert minutes → seconds; empty/null clears the override
      avg_time_coe: form.avg_time_coe ? String(parseFloat(form.avg_time_coe) * 60) : null,
      avg_time_p2p: form.avg_time_p2p ? String(parseFloat(form.avg_time_p2p) * 60) : null,
      avg_time_p3p: form.avg_time_p3p ? String(parseFloat(form.avg_time_p3p) * 60) : null,
+      smb_username: form.smb_username || null,
+      smb_password: form.smb_password || null,
+      smb_domain: form.smb_domain || null,
    }
    save(payload, {
      onSuccess: (data) => {
@@ -56,6 +67,43 @@ export default function ConfigModal({ onClose }) {
    })
  }

+  async function handleSaveTimes() {
+    setSaveError(null)
+    setScanResult(null)
+    setIsSavingTimes(true)
+    try {
+      await apiFetch('/config', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          avg_time_coe: form.avg_time_coe ? String(parseFloat(form.avg_time_coe) * 60) : null,
+          avg_time_p2p: form.avg_time_p2p ? String(parseFloat(form.avg_time_p2p) * 60) : null,
+          avg_time_p3p: form.avg_time_p3p ? String(parseFloat(form.avg_time_p3p) * 60) : null,
+        }),
+      })
+    } catch (err) {
+      setSaveError(err?.message ?? 'Failed to save')
+    } finally {
+      setIsSavingTimes(false)
+    }
+  }
+
+  async function handleRescanResults() {
+    setSaveError(null)
+    setScanResult(null)
+    setIsRescanning(true)
+    try {
+      const data = await apiFetch('/config/rescan-results', { method: 'POST' })
+      if (data?.testCount !== null && data?.testCount !== undefined) {
+        setScanResult({ testCount: data.testCount, completedCount: data.completedCount })
+      }
+    } catch (err) {
+      setSaveError(err?.message ?? 'Rescan failed')
+    } finally {
+      setIsRescanning(false)
+    }
+  }
+
  const AVG_FIELDS = [
    { key: 'avg_time_coe', label: 'COE avg time (min)' },
    { key: 'avg_time_p2p', label: 'P2P avg time (min)' },
@@ -105,7 +153,8 @@ export default function ConfigModal({ onClose }) {
                  <div className="space-y-3">
                    {[
                      { key: 'target_dir',      label: 'Target Tests Directory' },
-                      { key: 'results_dir', label: 'Results Directory' },
+                      { key: 'results_dir',     label: 'Results Directory (DUT)' },
+                      { key: 'results_dir_ref', label: 'Results Directory (Reference)' },
                    ].map(({ key, label }) => (
                      <div key={key}>
                        <label className="text-slate-400 text-xs block mb-1">{label}</label>
@@ -152,12 +201,58 @@ export default function ConfigModal({ onClose }) {
                    ))}
                  </div>
                </section>
+
+                {/* SMB Credentials */}
+                <section>
+                  <h3 className="text-slate-300 text-xs uppercase tracking-widest mb-1">SMB Credentials</h3>
+                  <p className="text-slate-500 text-xs mb-3">
+                    Optional credentials for network shares used by target/results directories.
+                  </p>
+                  <div className="grid grid-cols-1 sm:grid-cols-3 gap-3">
+                    <input
+                      type="text"
+                      value={form.smb_domain ?? ''}
+                      onChange={e => setForm(f => ({ ...f, smb_domain: e.target.value }))}
+                      placeholder="Domain"
+                      className="w-full bg-slate-800 border border-slate-700 text-slate-200 text-sm rounded-lg px-3 py-2 focus:outline-none focus:border-blue-500"
+                    />
+                    <input
+                      type="text"
+                      value={form.smb_username ?? ''}
+                      onChange={e => setForm(f => ({ ...f, smb_username: e.target.value }))}
+                      placeholder="Username"
+                      className="w-full bg-slate-800 border border-slate-700 text-slate-200 text-sm rounded-lg px-3 py-2 focus:outline-none focus:border-blue-500"
+                    />
+                    <input
+                      type="password"
+                      value={form.smb_password ?? ''}
+                      onChange={e => setForm(f => ({ ...f, smb_password: e.target.value }))}
+                      placeholder="Password"
+                      className="w-full bg-slate-800 border border-slate-700 text-slate-200 text-sm rounded-lg px-3 py-2 focus:outline-none focus:border-blue-500"
+                    />
+                  </div>
+                </section>
              </>
            )}
          </div>

          {/* Footer */}
-          <div className="flex justify-end gap-2 px-5 py-4 border-t border-slate-800">
+          <div className="flex justify-between gap-2 px-5 py-4 border-t border-slate-800">
+            <button
+              onClick={handleRescanResults}
+              disabled={isRescanning || isPending || isSavingTimes}
+              className="px-4 py-2 text-sm rounded-lg border border-slate-700 text-slate-300 hover:bg-slate-800 disabled:opacity-50 transition-colors"
+            >
+              {isRescanning ? 'Rescanning…' : 'Save Results'}
+            </button>
+            <div className="flex gap-2">
+              <button
+                onClick={handleSaveTimes}
+                disabled={isSavingTimes || isPending || isRescanning}
+                className="px-4 py-2 text-sm rounded-lg border border-slate-700 text-slate-300 hover:bg-slate-800 disabled:opacity-50 transition-colors"
+              >
+                {isSavingTimes ? 'Saving…' : 'Save Times'}
+              </button>
              <button
                onClick={onClose}
                className="px-4 py-2 text-sm rounded-lg border border-slate-700 text-slate-300 hover:bg-slate-800 transition-colors"
@@ -166,14 +261,15 @@ export default function ConfigModal({ onClose }) {
              </button>
              <button
                onClick={handleSave}
-              disabled={isPending}
+                disabled={isPending || isRescanning || isSavingTimes}
                className="px-4 py-2 text-sm rounded-lg bg-blue-600 text-white hover:bg-blue-700 disabled:opacity-50 transition-colors"
              >
-              {isPending ? 'Saving…' : 'Save & Rescan'}
+                {isPending ? 'Saving…' : 'Save All'}
              </button>
            </div>
          </div>
        </div>
+      </div>

      {browser && (
        <DirectoryBrowser
@@ -8,7 +8,6 @@ export default function DirectoryBrowser({ onSelect, onClose }) {
  const [loading, setLoading] = useState(false)
  const [error, setError]     = useState(null)
  const [manualPath, setManualPath] = useState('')
-  const [networkHost, setNetworkHost] = useState('')

  async function navigate(path) {
    setLoading(true)
@@ -35,31 +34,18 @@ export default function DirectoryBrowser({ onSelect, onClose }) {
    navigate(path)
  }

-  function goToHost() {
-    const host = networkHost.trim()
-    if (!host) return
-    navigate(`\\\\${host}`)
-  }
-
  // Load roots on first render
  if (dirs === null && !loading && !error) {
    navigate(null)
  }

  const normalizedCurrent = current ?? ''
+  const normalizedPath = normalizedCurrent.replace(/\\/g, '/')
  const isUnixPath = normalizedCurrent.startsWith('/')
-  const isUncPath = normalizedCurrent.startsWith('\\\\')
-  const breadcrumbs = normalizedCurrent
-    ? (isUncPath
-      ? normalizedCurrent.slice(2).split(/\\+/).filter(Boolean)
-      : normalizedCurrent.replace(/\\/g, '/').split('/').filter(Boolean))
-    : []
+  const breadcrumbs = normalizedPath ? normalizedPath.split('/').filter(Boolean) : []

  function breadcrumbPathAt(index) {
    const parts = breadcrumbs.slice(0, index + 1)
-    if (isUncPath) {
-      return `\\\\${parts.join('\\')}`
-    }
    if (isUnixPath) {
      return `/${parts.join('/')}`
    }
@@ -95,40 +81,6 @@ export default function DirectoryBrowser({ onSelect, onClose }) {
          })}
        </div>

-        {/* Jump controls */}
-        <div className="px-4 py-3 border-b border-slate-800 space-y-2">
-          <div className="flex gap-2">
-            <input
-              type="text"
-              value={manualPath}
-              onChange={e => setManualPath(e.target.value)}
-              placeholder="Path (e.g. C:\\data or \\\\192.168.1.10\\share)"
-              className="flex-1 bg-slate-800 border border-slate-700 text-slate-200 text-sm rounded-lg px-3 py-2 focus:outline-none focus:border-blue-500"
-            />
-            <button
-              onClick={goToManualPath}
-              className="px-3 py-2 text-sm rounded-lg border border-slate-700 text-slate-300 hover:bg-slate-800 transition-colors"
-            >
-              Go
-            </button>
-          </div>
-          <div className="flex gap-2">
-            <input
-              type="text"
-              value={networkHost}
-              onChange={e => setNetworkHost(e.target.value)}
-              placeholder="Network host/IP (e.g. 192.168.1.10)"
-              className="flex-1 bg-slate-800 border border-slate-700 text-slate-200 text-sm rounded-lg px-3 py-2 focus:outline-none focus:border-blue-500"
-            />
-            <button
-              onClick={goToHost}
-              className="px-3 py-2 text-sm rounded-lg border border-slate-700 text-slate-300 hover:bg-slate-800 transition-colors"
-            >
-              Open Host
-            </button>
-          </div>
-        </div>
-
        {/* Directory list */}
        <div className="overflow-y-auto max-h-64 divide-y divide-slate-800">
          {loading && (
@@ -210,6 +210,34 @@ export default function TestTable({ tests = [], allTests = [], isLoading }) {
                        <TagPill label="Direction"    value={test.direction} />
                        <TagPill label="Elapsed Time" value={fmtDuration(test.duration_seconds)} />
                      </div>
+                      {(() => {
+                        const rows = parseTputRows(test.tput_results)
+                        if (!test.completed || rows.length === 0) return null
+                        return (
+                          <div className="mt-3 pt-3 border-t border-slate-700/50">
+                            <table className="text-xs w-auto border-collapse">
+                              <thead>
+                                <tr className="text-slate-500 uppercase tracking-wide">
+                                  <th className="pr-6 pb-1 text-left font-medium">Station</th>
+                                  <th className="pr-6 pb-1 text-right font-medium">Throughput</th>
+                                  <th className="pr-6 pb-1 text-right font-medium">DL RSSI</th>
+                                  <th className="pb-1 text-right font-medium">UL RSSI</th>
+                                </tr>
+                              </thead>
+                              <tbody>
+                                {rows.map(r => (
+                                  <tr key={r.station} className="text-slate-300">
+                                    <td className="pr-6 py-0.5 text-cyan-400 font-medium">STA{r.station}</td>
+                                    <td className="pr-6 py-0.5 text-right">{r.tput} Mbps</td>
+                                    <td className="pr-6 py-0.5 text-right">{r.dlRssi} dBm</td>
+                                    <td className="py-0.5 text-right">{r.ulRssi} dBm</td>
+                                  </tr>
+                                ))}
+                              </tbody>
+                            </table>
+                          </div>
+                        )
+                      })()}
                      {(() => {
                        const pairs = parsePairArray(test.coe_pair)
                        if (pairs.length === 0) return null
@@ -298,34 +326,6 @@ export default function TestTable({ tests = [], allTests = [], isLoading }) {
                          </div>
                        )
                      })()}
-                      {(() => {
-                        const rows = parseTputRows(test.tput_results)
-                        if (!test.completed || rows.length === 0) return null
-                        return (
-                          <div className="mt-3 pt-3 border-t border-slate-700/50">
-                            <table className="text-xs w-auto border-collapse">
-                              <thead>
-                                <tr className="text-slate-500 uppercase tracking-wide">
-                                  <th className="pr-6 pb-1 text-left font-medium">Station</th>
-                                  <th className="pr-6 pb-1 text-right font-medium">Throughput</th>
-                                  <th className="pr-6 pb-1 text-right font-medium">DL RSSI</th>
-                                  <th className="pb-1 text-right font-medium">UL RSSI</th>
-                                </tr>
-                              </thead>
-                              <tbody>
-                                {rows.map(r => (
-                                  <tr key={r.station} className="text-slate-300">
-                                    <td className="pr-6 py-0.5 text-cyan-400 font-medium">STA{r.station}</td>
-                                    <td className="pr-6 py-0.5 text-right">{r.tput} Mbps</td>
-                                    <td className="pr-6 py-0.5 text-right">{r.dlRssi} dBm</td>
-                                    <td className="py-0.5 text-right">{r.ulRssi} dBm</td>
-                                  </tr>
-                                ))}
-                              </tbody>
-                            </table>
-                          </div>
-                        )
-                      })()}
                    </td>
                  </tr>
                )}
@@ -1,12 +1,11 @@
 import os
-import subprocess
 from pathlib import Path

 from flask import Flask, Response, jsonify, request, send_from_directory
 from flask_cors import CORS

 from db_py import count_tests, del_config, get_all_tests, get_config, set_config
-from scanner import full_scan
+from scanner import full_scan, scan_results_only
 from sse_py import broadcast, stream_events
 from watcher import start_watching

@@ -14,9 +13,13 @@ PORT = int(os.getenv("PORT", "3001"))
 ALLOWED_KEYS = {
    "target_dir",
    "results_dir",
+    "results_dir_ref",
    "avg_time_coe",
    "avg_time_p2p",
    "avg_time_p3p",
+    "smb_username",
+    "smb_password",
+    "smb_domain",
 }

 BASE_DIR = Path(__file__).resolve().parent
@@ -26,6 +29,20 @@ app = Flask(__name__, static_folder=str(DIST_DIR), static_url_path="")
 CORS(app)


+def _apply_smb_env_from_config():
+    mapping = {
+        "SMB_USERNAME": get_config("smb_username"),
+        "SMB_PASSWORD": get_config("smb_password"),
+        "SMB_DOMAIN": get_config("smb_domain"),
+    }
+
+    for env_key, value in mapping.items():
+        if value in (None, ""):
+            os.environ.pop(env_key, None)
+        else:
+            os.environ[env_key] = str(value)
+
+
@app.get("/api/tests")
 def get_tests_route():
    completed = request.args.get("completed")
@@ -205,14 +222,16 @@ def set_config_route():
        else:
            set_config(key, str(value))

-        if key in {"target_dir", "results_dir"}:
+        if key in {"target_dir", "results_dir", "results_dir_ref"}:
            dirs_changed = True

    if dirs_changed:
+        _apply_smb_env_from_config()
        target_dir = get_config("target_dir")
        results_dir = get_config("results_dir")
+        results_dir_ref = get_config("results_dir_ref")
        try:
-            full_scan(target_dir, results_dir)
+            full_scan(target_dir, results_dir, results_dir_ref)
            start_watching(target_dir, results_dir)
        except Exception as exc:
            print(f"[config] fullScan error: {exc}")
@@ -224,18 +243,21 @@ def set_config_route():
        broadcast({"type": "update"})
        return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})

+    broadcast({"type": "update"})
    return jsonify({"ok": True, "testCount": None, "completedCount": None})


@app.post("/api/config/rescan")
 def rescan_route():
+    _apply_smb_env_from_config()
    target_dir = get_config("target_dir")
    results_dir = get_config("results_dir")
+    results_dir_ref = get_config("results_dir_ref")
    if not target_dir or not results_dir:
        return jsonify({"error": "Directories not configured"}), 400

    try:
-        full_scan(target_dir, results_dir)
+        full_scan(target_dir, results_dir, results_dir_ref)
        start_watching(target_dir, results_dir)
    except Exception as exc:
        print(f"[config] rescan error: {exc}")
@@ -248,6 +270,27 @@ def rescan_route():
    return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})


+@app.post("/api/config/rescan-results")
+def rescan_results_route():
+    _apply_smb_env_from_config()
+    results_dir = get_config("results_dir")
+    results_dir_ref = get_config("results_dir_ref")
+    if not results_dir:
+        return jsonify({"error": "Results directory not configured"}), 400
+
+    try:
+        scan_results_only(results_dir, results_dir_ref)
+    except Exception as exc:
+        print(f"[config] rescan-results error: {exc}")
+        return jsonify({"error": f"Scan failed: {exc}"}), 500
+
+    tests = get_all_tests()
+    completed = len([t for t in tests if t.get("completed")])
+    print(f"[config] Results rescan complete -> {len(tests)} tests, {completed} completed")
+    broadcast({"type": "update"})
+    return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})
+
+
@app.get("/api/browse")
 def browse_route():
    def _normalize_request_path(path):
@@ -258,48 +301,6 @@ def browse_route():
            p = p.replace("/", "\\")
        return p

-    def _is_unc_host_only(path):
-        if os.name != "nt" or not path:
-            return False
-        p = path.rstrip("\\")
-        if not p.startswith("\\\\"):
-            return False
-        remainder = p[2:]
-        return bool(remainder) and "\\" not in remainder
-
-    def _shares_for_unc_host(host):
-        # Enumerate SMB shares with native Windows tooling for host-only UNC paths.
-        proc = subprocess.run(
-            ["net", "view", f"\\\\{host}"],
-            capture_output=True,
-            text=True,
-            timeout=10,
-            check=False,
-        )
-        if proc.returncode != 0:
-            raise RuntimeError(proc.stderr.strip() or proc.stdout.strip() or "Cannot query network host")
-
-        shares = []
-        in_table = False
-        for raw_line in proc.stdout.splitlines():
-            line = raw_line.strip()
-            if not line:
-                continue
-            if line.startswith("---"):
-                in_table = True
-                continue
-            if not in_table:
-                continue
-            if line.lower().startswith("the command completed successfully"):
-                break
-
-            first = line.split()[0]
-            if first and first.lower() not in {"share", "name"}:
-                shares.append(first)
-
-        unique = sorted(set(shares), key=str.lower)
-        return [{"name": share, "path": f"\\\\{host}\\{share}"} for share in unique]
-
    def _configured_roots():
        raw = os.getenv("BROWSE_ROOTS", "").strip()
        if not raw:
@@ -326,17 +327,6 @@ def browse_route():
                continue
        return False

-    def _is_unc_host_allowed(host, roots):
-        if not roots:
-            return True
-        host_prefix = os.path.normcase(f"\\\\{host}\\")
-        host_exact = host_prefix.rstrip("\\")
-        for root in roots:
-            normalized_root = os.path.normcase(root)
-            if normalized_root == host_exact or normalized_root.startswith(host_prefix):
-                return True
-        return False
-
    roots = _configured_roots()
    req_path = _normalize_request_path(request.args.get("path"))

@@ -359,16 +349,6 @@ def browse_route():

        return jsonify({"path": None, "parent": None, "dirs": dirs})

-    if _is_unc_host_only(req_path):
-        host = req_path.rstrip("\\")[2:]
-        if not _is_unc_host_allowed(host, roots):
-            return jsonify({"error": "Path is outside allowed browse roots"}), 403
-        try:
-            dirs = _shares_for_unc_host(host)
-        except Exception as exc:
-            return jsonify({"error": f"Cannot list shares for host: {exc}"}), 403
-        return jsonify({"path": f"\\\\{host}", "parent": None, "dirs": dirs})
-
    if not os.path.exists(req_path):
        return jsonify({"error": "Path does not exist"}), 400
    if not os.path.isdir(req_path):
@@ -416,8 +396,10 @@ def static_or_spa(path=""):


 def bootstrap():
+    _apply_smb_env_from_config()
    target_dir = get_config("target_dir")
    results_dir = get_config("results_dir")
+    results_dir_ref = get_config("results_dir_ref")

    if target_dir and results_dir:
        existing = count_tests()
@@ -425,7 +407,7 @@ def bootstrap():
            print(f"[server] Resuming from DB -> {existing} tests already loaded.")
        else:
            print("[server] No cached data, scanning directories...")
-            full_scan(target_dir, results_dir)
+            full_scan(target_dir, results_dir, results_dir_ref)
            tests = get_all_tests()
            completed = len([t for t in tests if t.get("completed")])
            print(f"[server] Scan complete -> {len(tests)} tests found, {completed} completed")
@@ -1,3 +1,4 @@
 Flask>=3.0.0,<4.0.0
 Flask-Cors>=4.0.1,<5.0.0
 watchdog>=4.0.1,<5.0.0
+smbprotocol>=1.13.0,<2.0.0
@@ -1,5 +1,6 @@
 import os
 import re
+import smbclient

 from db_py import clear_tests, get_all_tests, mark_completed, set_coe_pair, upsert_test
 from parser import (
@@ -11,16 +12,125 @@ from parser import (
 )


-def full_scan(target_dir, results_dir):
+_SMB_SESSIONS = set()
+
+
+def _normalize_input_path(path_value):
+    if not path_value:
+        return path_value
+
+    path = str(path_value).strip()
+
+    # Accept //server/share style and normalize to UNC for smbclient.
+    if path.startswith("//"):
+        return "\\\\" + path.lstrip("/").replace("/", "\\")
+
+    # Accept /<ipv4>/<share>/... and normalize to UNC for Linux-hosted inputs.
+    if re.match(r"^/\d{1,3}(?:\.\d{1,3}){3}/[^/]+", path):
+        return "\\\\" + path.lstrip("/").replace("/", "\\")
+
+    return path
+
+
+def _is_unc_path(path):
+    return isinstance(path, str) and path.startswith("\\\\")
+
+
+def _extract_unc_server(path):
+    if not _is_unc_path(path):
+        return None
+    rest = path[2:]
+    return rest.split("\\", 1)[0] if rest else None
+
+
+def _register_smb_session_if_needed(path):
+    if not _is_unc_path(path):
+        return
+
+    server = _extract_unc_server(path)
+    if not server or server in _SMB_SESSIONS:
+        return
+
+    username = os.getenv("SMB_USERNAME", "").strip()
+    password = os.getenv("SMB_PASSWORD", "")
+    domain = os.getenv("SMB_DOMAIN", "").strip()
+
+    if username and domain and "\\" not in username and "@" not in username:
+        username = f"{domain}\\{username}"
+
+    if username:
+        smbclient.register_session(server, username=username, password=password)
+    else:
+        smbclient.register_session(server)
+
+    _SMB_SESSIONS.add(server)
+
+
+def _iter_dir_entries(path):
+    path = _normalize_input_path(path)
+    if _is_unc_path(path):
+        _register_smb_session_if_needed(path)
+        return list(smbclient.scandir(path))
+    return list(os.scandir(path))
+
+
+def _join_path(path, name):
+    if _is_unc_path(path):
+        base = path.rstrip("\\")
+        return f"{base}\\{name}"
+    return os.path.join(path, name)
+
+
+def _read_text_lines(path):
+    path = _normalize_input_path(path)
+    if _is_unc_path(path):
+        _register_smb_session_if_needed(path)
+        with smbclient.open_file(path, mode="r", encoding="utf-8", errors="ignore") as fh:
+            for line in fh:
+                yield line
+        return
+
+    with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+        for line in fh:
+            yield line
+
+
+def scan_results_only(results_dir, results_dir_ref=None):
+    """Re-scan only the results directories without clearing or re-scanning targets."""
+    results_dir = _normalize_input_path(results_dir)
+    results_dir_ref = _normalize_input_path(results_dir_ref)
+
+    if not results_dir:
+        return
+
+    print(f"[scanner] results-only scan dir     : {results_dir}")
+    if results_dir_ref:
+        print(f"[scanner] results-only scan dir ref : {results_dir_ref}")
+
+    scan_results(results_dir)
+    if results_dir_ref:
+        scan_results(results_dir_ref)
+    update_p2p_coe_pairs()
+
+
+def full_scan(target_dir, results_dir, results_dir_ref=None):
+    target_dir = _normalize_input_path(target_dir)
+    results_dir = _normalize_input_path(results_dir)
+    results_dir_ref = _normalize_input_path(results_dir_ref)
+
    clear_tests()
    if not target_dir or not results_dir:
        return

    print(f"[scanner] target dir      : {target_dir}")
    print(f"[scanner] results dir     : {results_dir}")
+    if results_dir_ref:
+        print(f"[scanner] results dir ref : {results_dir_ref}")

    scan_targets(target_dir)
    scan_results(results_dir)
+    if results_dir_ref:
+        scan_results(results_dir_ref)
    update_p2p_coe_pairs()


@@ -66,11 +176,13 @@ def update_p2p_coe_pairs():


 def scan_targets(target_dir):
+    target_dir = _normalize_input_path(target_dir)
+
    try:
        parent_entries = [
-            name
-            for name in os.listdir(target_dir)
-            if os.path.isdir(os.path.join(target_dir, name))
+            entry.name
+            for entry in _iter_dir_entries(target_dir)
+            if entry.is_dir()
        ]
    except OSError as exc:
        print(f"[scanner] Cannot read target dir: {exc}")
@@ -79,14 +191,14 @@ def scan_targets(target_dir):
    print(f"[scanner] subdirectories found: {len(parent_entries)}")

    for parent_name in parent_entries:
-        parent_path = os.path.join(target_dir, parent_name)
+        parent_path = _join_path(target_dir, parent_name)
        try:
            files = [
-                name
-                for name in os.listdir(parent_path)
-                if os.path.isfile(os.path.join(parent_path, name))
-                and not name.startswith("GLOBAL")
-                and name.endswith(".ini")
+                entry.name
+                for entry in _iter_dir_entries(parent_path)
+                if entry.is_file()
+                and not entry.name.startswith("GLOBAL")
+                and entry.name.endswith(".ini")
            ]
        except OSError as exc:
            print(f"[scanner] Cannot read parent dir {parent_name}: {exc}")
@@ -125,11 +237,13 @@ def scan_targets(target_dir):


 def scan_results(results_dir):
+    results_dir = _normalize_input_path(results_dir)
+
    try:
        entries = [
-            name
-            for name in os.listdir(results_dir)
-            if os.path.isdir(os.path.join(results_dir, name))
+            entry.name
+            for entry in _iter_dir_entries(results_dir)
+            if entry.is_dir()
        ]
    except OSError as exc:
        print(f"[scanner] Cannot read results dir: {exc}")
@@ -141,21 +255,23 @@ def scan_results(results_dir):


 def process_result_dir(results_dir, result_dir_name):
+    results_dir = _normalize_input_path(results_dir)
+
    parsed = parse_result_filename(result_dir_name)
    test_id = parsed["test_id"]
    device = parsed["device"]
    if not test_id or not device:
        return

-    result_dir_path = os.path.join(results_dir, result_dir_name)
+    result_dir_path = _join_path(results_dir, result_dir_name)

    try:
        log_files = [
-            name
-            for name in os.listdir(result_dir_path)
-            if os.path.isfile(os.path.join(result_dir_path, name))
-            and name.endswith(".txt")
-            and test_id in name
+            entry.name
+            for entry in _iter_dir_entries(result_dir_path)
+            if entry.is_file()
+            and entry.name.endswith(".txt")
+            and test_id in entry.name
        ]
    except OSError as exc:
        print(f"[scanner] Cannot read result dir {result_dir_name}: {exc}")
@@ -167,7 +283,7 @@ def process_result_dir(results_dir, result_dir_name):
        return

    latest_log = sorted(log_files)[-1]
-    log_path = os.path.join(result_dir_path, latest_log)
+    log_path = _join_path(result_dir_path, latest_log)
    completed_at = parse_timestamp(latest_log)
    data = extract_log_data(log_path)

@@ -199,8 +315,7 @@ def extract_log_data(log_file_path):

    result = {"duration_seconds": None, "tputResults": []}
    try:
-        with open(log_file_path, "r", encoding="utf-8", errors="ignore") as fh:
-            for line in fh:
+        for line in _read_text_lines(log_file_path):
            time_match = elapsed_regex.search(line)
            if time_match:
                result["duration_seconds"] = parse_elapsed_time(time_match.group(1))