driverclient 0.2.12__tar.gz → 0.2.17__tar.gz

{driverclient-0.2.12 → driverclient-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.12
+Version: 0.2.17
 Summary: Driver Server client with an embeddable connector for config injection at runtime.
 Project-URL: Homepage, https://example.com/driverclient
 Author-email: Raja Sanaullah <sanaullah@99technologies.com>

{driverclient-0.2.12 → driverclient-0.2.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "driverclient"
-version = "0.2.12"
+version = "0.2.17"
 description = "Driver Server client with an embeddable connector for config injection at runtime."
 readme = "README.md"
 requires-python = ">=3.10"

{driverclient-0.2.12 → driverclient-0.2.17}/src/driverclient/__init__.py

@@ -25,7 +25,7 @@ from driverclient.main import run as _run
 
 __all__ = ["DriverClient", "ClientEvent"]
 
-__version__ = "0.2.12"
+__version__ = "0.2.17"
 
 
 class DriverClient:

{driverclient-0.2.12 → driverclient-0.2.17}/src/driverclient/config.py

@@ -54,8 +54,17 @@ DEFAULTS: dict = {
     },
 
     # ── Windows Update ────────────────────────────────────────────────────
-    "wu_wait_minutes":          10,
+    # ABSOLUTE ceiling for the WU wait — a safety backstop, NOT the expected
+    # wait. The loop stops as soon as WU actually goes idle (see below); this
+    # only bounds a stuck/hanging WU so SA can never stall.
+    "wu_wait_minutes":          30,
     "wu_poll_interval_seconds": 30,
+    # Empty polls required AFTER Windows Update has gone idle before we stop.
+    # While WU is still working (install process alive), empty polls are NOT
+    # counted — so a scan/download that takes 2 min or 8 min both get exactly
+    # the time they need. This is what makes the wait adaptive instead of a
+    # fixed timer.
+    "wu_quiescent_polls":       2,
     # Classes to skip when deciding which not-found HWIDs trigger WU.
     # Empty list = no filtering (default — make no assumptions).
     # Use lowercase class names as reported by pnputil, e.g. "hidclass", "bluetooth".
@@ -70,6 +79,12 @@ DEFAULTS: dict = {
     # no new repo drivers or installs nothing.
     "automate_rescan_passes": 3,
     "force_resolve":        False,
+    # The server now offers every driver matching each device (primary + extensions
+    # + companions). Before downloading each, skip it if its INF is already in the
+    # Windows driver store at the same-or-newer version — so a still-current big
+    # driver (e.g. graphics) is never re-downloaded, while missing/extension drivers
+    # still install. Set False to force-reinstall everything the server offers.
+    "skip_installed_drivers": True,
 
     # ── HTTP timeouts (seconds) ───────────────────────────────────────────
     "timeout_tiny":      10,

{driverclient-0.2.12 → driverclient-0.2.17}/src/driverclient/core/proc.py

@@ -39,3 +39,15 @@ def run(cmd, **kwargs) -> subprocess.CompletedProcess:
     for key, value in _no_window_kwargs().items():
         kwargs.setdefault(key, value)
     return subprocess.run(cmd, **kwargs)
+
+
+def popen(cmd, **kwargs) -> subprocess.Popen:
+    """subprocess.Popen() that never shows a console window on Windows.
+
+    Same no-window guard as run(), for long-running children the caller wants to
+    supervise (poll/kill) instead of blocking on — e.g. the background Windows
+    Update install. All other behavior is identical to subprocess.Popen.
+    """
+    for key, value in _no_window_kwargs().items():
+        kwargs.setdefault(key, value)
+    return subprocess.Popen(cmd, **kwargs)

{driverclient-0.2.12 → driverclient-0.2.17}/src/driverclient/ops/capture.py

@@ -297,11 +297,12 @@ def wu_update(force: bool = False) -> CaptureResult:
                  f"triggering Windows Update…  ({skip_detail})",
                  total=len(wu_hwids), **skip_reasons)
 
-    if not _trigger_wu():
+    trigger = _trigger_wu()
+    if trigger is None:
         return CaptureResult(still_missing=len(wu_hwids))
 
     wu_start = datetime.now(timezone.utc)
-    total    = _poll_and_submit_incremental(wu_start, cfg)
+    total    = _poll_and_submit_incremental(wu_start, cfg, trigger)
     total.wu_triggered  = True
     total.still_missing = max(0, len(wu_hwids) - total.submitted)
     total.reboot_required = _wu_reboot_pending()
@@ -326,11 +327,12 @@ def wu_full() -> CaptureResult:
     events.start("windows_update",
                  "[wu-full] Triggering full Windows Update scan (no HWID filtering)…")
 
-    if not _trigger_wu():
+    trigger = _trigger_wu()
+    if trigger is None:
         return CaptureResult()
 
     wu_start = datetime.now(timezone.utc)
-    total    = _poll_and_submit_incremental(wu_start, cfg)
+    total    = _poll_and_submit_incremental(wu_start, cfg, trigger)
     total.wu_triggered = True
     _post_wu_session(cfg, wu_start, [], total.submitted)
     events.done("windows_update",
@@ -536,34 +538,211 @@ def _wu_reboot_pending() -> bool:
     return False
 
 
-def _trigger_wu() -> bool:
-    for cmd in (["usoclient", "StartScan"], ["wuauclt", "/detectnow"]):
+# PowerShell that drives a real Search → Download → Install through the Windows
+# Update Agent COM API (Microsoft.Update.Session). Built into every Windows — no
+# PSGallery module needed. It BLOCKS until download+install finishes, so the
+# process staying alive IS the "WU is still working" signal the poll loop reads.
+#
+# It searches the MICROSOFT UPDATE service (service id 7971f918-…), exactly like
+# the Settings ▸ "Check for updates" button with "receive updates for other
+# Microsoft products" on — that superset is what surfaces driver updates + other
+# Microsoft products, not the narrower default Windows Update service. The MU
+# service is registered on the fly; if that is blocked (WSUS / policy-managed),
+# it falls back to the default service so WU still runs.
+_WU_COM_SCRIPT = r"""
+$ErrorActionPreference = 'Stop'
+$MU_SERVICE_ID = '7971f918-a847-4430-9279-4a52d1efe18d'
+try {
+    $session  = New-Object -ComObject Microsoft.Update.Session
+    $searcher = $session.CreateUpdateSearcher()
+
+    # Target Microsoft Update so this matches the Settings "Check for updates"
+    # behaviour (drivers + other Microsoft products). Register the service if
+    # needed, then point the searcher at it explicitly.
+    try {
+        $sm = New-Object -ComObject Microsoft.Update.ServiceManager
+        # AddService2 flags 7 = registerServiceWithAU(1)+allowPendingRegistration(2)+allowOnlineRegistration(4)
+        [void]$sm.AddService2($MU_SERVICE_ID, 7, '')
+        $searcher.ServerSelection = 3            # ssOthers
+        $searcher.ServiceID       = $MU_SERVICE_ID
+        Write-Output "SERVICE microsoft_update"
+    } catch {
+        Write-Output ("SERVICE windows_update_fallback " + $_.Exception.Message)
+    }
+
+    Write-Output "SEARCHING"
+    $result = $searcher.Search("IsInstalled=0 and IsHidden=0")
+    if ($result.Updates.Count -eq 0) { Write-Output "NO_UPDATES"; exit 0 }
+
+    $toDownload = New-Object -ComObject Microsoft.Update.UpdateColl
+    foreach ($u in $result.Updates) {
+        if (-not $u.EulaAccepted) { try { $u.AcceptEula() } catch {} }
+        [void]$toDownload.Add($u)
+    }
+    Write-Output ("DOWNLOADING " + $toDownload.Count)
+    $downloader = $session.CreateUpdateDownloader()
+    $downloader.Updates = $toDownload
+    [void]$downloader.Download()
+
+    $toInstall = New-Object -ComObject Microsoft.Update.UpdateColl
+    foreach ($u in $result.Updates) { if ($u.IsDownloaded) { [void]$toInstall.Add($u) } }
+    if ($toInstall.Count -eq 0) { Write-Output "NONE_DOWNLOADED"; exit 0 }
+
+    Write-Output ("INSTALLING " + $toInstall.Count)
+    $installer = $session.CreateUpdateInstaller()
+    $installer.Updates = $toInstall
+    $r = $installer.Install()
+    Write-Output ("INSTALLED count=" + $toInstall.Count + " result=" + $r.ResultCode + " reboot=" + $r.RebootRequired)
+    exit 0
+} catch {
+    Write-Output ("WU_ERROR " + $_.Exception.Message)
+    exit 1
+}
+"""
+
+
+@dataclass
+class _WuTrigger:
+    """Handle for a launched Windows Update run.
+
+    proc is the live install process on the COM path (its liveness == WU is
+    still working); it is None for the fire-and-forget usoclient/wuauclt
+    fallbacks, which give no real progress signal.
+    """
+    method:   str
+    proc:     "subprocess.Popen | None" = None
+    workdir:  "str | None" = None
+    log_fh:   object = None
+    log_path: "str | None" = None
+
+    def is_running(self) -> bool:
+        return self.proc is not None and self.proc.poll() is None
+
+    def terminate(self) -> None:
+        """Kill a still-running install and clean up temp files. Idempotent and
+        never raises — the hard-cap backstop that guarantees no lingering WU
+        process can keep SA busy past the ceiling."""
+        try:
+            if self.proc is not None and self.proc.poll() is None:
+                self.proc.kill()
+        except Exception:
+            pass
+        try:
+            if self.log_fh is not None:
+                self.log_fh.close()
+        except Exception:
+            pass
+        try:
+            if self.workdir:
+                shutil.rmtree(self.workdir, ignore_errors=True)
+        except Exception:
+            pass
+
+
+def _wu_install_com() -> "_WuTrigger | None":
+    """Preferred trigger: launch the COM-API Search→Download→Install script as a
+    background process. Returns a _WuTrigger with a live proc, or None if
+    PowerShell is unavailable / launch fails (caller falls back)."""
+    try:
+        workdir     = tempfile.mkdtemp(prefix="dc_wu_")
+        script_path = Path(workdir) / "wu_install.ps1"
+        log_path    = Path(workdir) / "wu_install.log"
+        script_path.write_text(_WU_COM_SCRIPT, encoding="utf-8")
+        log_fh = open(log_path, "w", encoding="utf-8", errors="replace")
+        p = proc.popen(
+            ["powershell", "-ExecutionPolicy", "Bypass", "-NoProfile",
+             "-NonInteractive", "-File", str(script_path)],
+            stdout=log_fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
+        )
+        events.ok("windows_update",
+                  "[wu-update] Windows Update install started (COM API) — "
+                  "search → download → install running in background")
+        return _WuTrigger(method="com", proc=p, workdir=workdir,
+                          log_fh=log_fh, log_path=str(log_path))
+    except FileNotFoundError:
+        return None  # powershell not on PATH
+    except Exception as e:
+        events.warn("windows_update",
+                    f"[wu-update] COM-API WU launch failed ({e}) — trying usoclient",
+                    error=str(e))
+        return None
+
+
+def _wu_install_usoclient() -> "_WuTrigger | None":
+    """Fallback trigger: usoclient full sequence. These are asynchronous and
+    undocumented (no completion signal), so the poll loop treats WU as busy
+    until its fallback floor. Returns None if usoclient is unavailable."""
+    ran = False
+    for args in (["StartScan"], ["StartDownload"], ["StartInstall"]):
         try:
-            proc.run(cmd, capture_output=True, timeout=30)
-            events.ok("windows_update", "[wu-update] Windows Update scan triggered")
-            return True
+            proc.run(["usoclient", *args], capture_output=True, timeout=30)
+            ran = True
         except Exception:
             continue
+    if ran:
+        events.ok("windows_update",
+                  "[wu-update] Windows Update triggered via usoclient "
+                  "(scan → download → install)")
+        return _WuTrigger(method="usoclient")
+    return None
+
+
+def _trigger_wu() -> "_WuTrigger | None":
+    """Trigger Windows Update to actually install, best method first:
+      1. COM API (real Search→Download→Install, with a liveness signal)
+      2. usoclient full sequence (fire-and-forget fallback)
+      3. wuauclt /detectnow (legacy last resort — a no-op on Win10/11)
+    Returns a _WuTrigger, or None if nothing could be triggered."""
+    trigger = _wu_install_com()
+    if trigger is not None:
+        return trigger
+
+    trigger = _wu_install_usoclient()
+    if trigger is not None:
+        return trigger
+
+    try:
+        proc.run(["wuauclt", "/detectnow"], capture_output=True, timeout=30)
+        events.ok("windows_update",
+                  "[wu-update] Triggered wuauclt /detectnow (legacy fallback)")
+        return _WuTrigger(method="wuauclt")
+    except Exception:
+        pass
+
     events.error("windows_update", "[wu-update] Could not trigger Windows Update",
                  error="trigger_failed")
-    return False
+    return None
 
 
-def _poll_and_submit_incremental(wu_start: datetime, cfg: dict) -> CaptureResult:
+def _poll_and_submit_incremental(wu_start: datetime, cfg: dict,
+                                 trigger: "_WuTrigger | None") -> CaptureResult:
     """
-    Poll every wu_poll_interval_seconds for new DriverStore packages.
-    Submit each new batch immediately. Stop after wu_wait_minutes total
-    OR after 2 consecutive polls with no new packages.
+    Wait on Windows Update, submitting each new DriverStore package as it lands.
+
+    The stop decision is driven by WU's REAL activity, not a fixed timer:
+      • While WU is still working, empty polls are NOT counted — a scan/download
+        that takes 2 min or 8 min both get exactly the time they need.
+        (COM path: "working" = the install process is alive. Fallback path: no
+        liveness signal exists, so WU is assumed busy until a short floor.)
+      • Once WU goes idle, `wu_quiescent_polls` consecutive empty polls end the
+        wait (catches drivers that land right at the end).
+      • `wu_wait_minutes` is an ABSOLUTE hard cap — a backstop so a stuck WU can
+        never keep SA waiting. Any still-running install is killed at the cap.
     """
-    wait_min      = cfg.get("wu_wait_minutes", 10)
-    poll_secs     = cfg.get("wu_poll_interval_seconds", 30)
-    deadline      = wu_start + timedelta(minutes=wait_min)
-    seen:set[str] = set()
-    total         = CaptureResult()
-    empty_polls   = 0
+    wait_min         = cfg.get("wu_wait_minutes", 30)
+    poll_secs        = cfg.get("wu_poll_interval_seconds", 30)
+    quiescent_needed = max(1, int(cfg.get("wu_quiescent_polls", 2)))
+    deadline         = wu_start + timedelta(minutes=wait_min)
+    fallback_floor   = wu_start + timedelta(minutes=min(5, wait_min))
+    has_liveness     = trigger is not None and trigger.proc is not None
+
+    seen: set[str] = set()
+    total          = CaptureResult()
+    empty_polls    = 0
 
     events.progress("windows_update",
-                    f"[wu-update] Polling every {poll_secs}s, max {wait_min} min…")
+                    f"[wu-update] Waiting on Windows Update — polling every {poll_secs}s, "
+                    f"stops early once WU goes idle (hard cap {wait_min} min)")
 
     while datetime.now(timezone.utc) < deadline:
         all_new   = _enumerate_packages_since(wu_start, cfg)
@@ -581,17 +760,37 @@ def _poll_and_submit_incremental(wu_start: datetime, cfg: dict) -> CaptureResult
                             current=len(new_batch))
             total.merge(_export_and_submit(new_batch, cfg))
         else:
-            empty_polls += 1
-            if empty_polls >= 2:
+            # Is WU genuinely still working? Don't give up during its long
+            # initial scan/download latency.
+            if has_liveness:
+                busy = trigger.is_running()
+            else:
+                busy = datetime.now(timezone.utc) < fallback_floor
+
+            if busy:
+                empty_polls = 0
+                elapsed = int((datetime.now(timezone.utc) - wu_start).total_seconds())
                 events.progress("windows_update",
-                                "[wu-update] 2 consecutive empty polls — stopping")
-                break
-            remaining = int((deadline - datetime.now(timezone.utc)).total_seconds())
-            events.progress("windows_update",
-                            f"[wu-update]   no new drivers — {remaining}s remaining…")
+                                f"[wu-update]   WU still working — {elapsed}s elapsed, "
+                                f"no new drivers yet…")
+            else:
+                empty_polls += 1
+                if empty_polls >= quiescent_needed:
+                    events.progress("windows_update",
+                                    f"[wu-update] WU idle + {empty_polls} quiescent poll(s) — stopping")
+                    break
+                remaining = int((deadline - datetime.now(timezone.utc)).total_seconds())
+                events.progress("windows_update",
+                                f"[wu-update]   WU idle, no new drivers — "
+                                f"{empty_polls}/{quiescent_needed} quiescent, {remaining}s cap left…")
 
         time.sleep(poll_secs)
+    else:
+        events.warn("windows_update",
+                    f"[wu-update] Reached {wait_min} min hard cap — stopping WU wait")
 
+    if trigger is not None:
+        trigger.terminate()
     return total
 
 

{driverclient-0.2.12 → driverclient-0.2.17}/src/driverclient/ops/install.py

@@ -13,6 +13,7 @@ Download pipeline:
 Public API:
     resolve_and_install(force=False) -> InstallResult
 """
+import re
 import shutil
 import subprocess
 import time
@@ -86,6 +87,54 @@ class InstallResult:
         return any(r.reboot_required for r in self.installed_ok)
 
 
+def _parse_ver(s: str) -> tuple | None:
+    """Extract an x.x.x.x version tuple from a string (e.g. a pnputil 'Driver
+    Version: 12/02/2021 1.0.3.0' line or a repo version_label). None if absent."""
+    m = re.search(r"(\d+)\.(\d+)\.(\d+)\.(\d+)", s or "")
+    return tuple(int(x) for x in m.groups()) if m else None
+
+
+def _installed_inf_index() -> dict:
+    """Map original INF name (lowercase) → highest installed driver-version tuple,
+    parsed from `pnputil /enum-drivers`. Lets us skip re-downloading/installing a
+    driver the machine already has at the same-or-newer version. Best-effort: on any
+    error/parse miss it returns {} so nothing is ever wrongly skipped."""
+    idx: dict = {}
+    try:
+        r = proc.run(["pnputil", "/enum-drivers"], capture_output=True, text=True, timeout=120)
+        if r.returncode != 0:
+            return {}
+        cur = None
+        for line in r.stdout.splitlines():
+            low = line.lower()
+            if "original name" in low and ":" in line:
+                cur = line.split(":", 1)[1].strip().lower()
+            elif "driver version" in low and cur:
+                v = _parse_ver(line)
+                if v and (cur not in idx or v > idx[cur]):
+                    idx[cur] = v
+                cur = None
+    except Exception:
+        return {}
+    return idx
+
+
+def _already_in_store(driver: dict, idx: dict) -> bool:
+    """True when every INF this driver ships is already in the driver store at a
+    same-or-newer version — so it needn't be downloaded/installed again. Conservative:
+    returns False (→ install) whenever the version or an INF can't be confirmed."""
+    if not idx:
+        return False
+    ver = _parse_ver(driver.get("version_label", ""))
+    if not ver:
+        return False
+    infs = [f["filename"].lower() for f in driver.get("files", [])
+            if f.get("file_role") == "inf" or f.get("filename", "").lower().endswith(".inf")]
+    if not infs:
+        return False
+    return all(idx.get(name) is not None and idx[name] >= ver for name in infs)
+
+
 def resolve_and_install(force: bool = False) -> InstallResult:
     """
     Run resolve (or load cache) then download + install all available drivers.
@@ -99,14 +148,38 @@ def resolve_and_install(force: bool = False) -> InstallResult:
                     total=0)
         return InstallResult(trace_id=result.trace_id)
 
+    # Server now offers EVERY driver matching each device (primary + extensions +
+    # companions), so nothing is dropped by an assumption. Freshness is decided HERE
+    # against the real driver store: skip any package whose INF(s) are already present
+    # at the same-or-newer version — so a still-current big driver (graphics) is not
+    # re-downloaded, while missing/extension drivers still install. Toggle off with
+    # skip_installed_drivers=false to force-reinstall everything.
+    drivers = result.drivers
+    if cfg.get("skip_installed_drivers", True):
+        idx = _installed_inf_index()
+        kept = [d for d in drivers if not _already_in_store(d, idx)]
+        skipped = len(drivers) - len(kept)
+        if skipped:
+            events.progress(
+                "install",
+                f"[install] {skipped} driver(s) already current in the driver store — skipping",
+                skipped=skipped,
+            )
+        drivers = kept
+        if not drivers:
+            events.done("install",
+                        "[install] Nothing to install — all resolved drivers already current",
+                        total=0)
+            return InstallResult(trace_id=result.trace_id)
+
     session_id = str(uuid.uuid4())
     work_dir   = Path(cfg.get("work_dir", "C:\\DriverServer\\client\\staging")) / session_id
     work_dir.mkdir(parents=True, exist_ok=True)
 
     events.start("install",
-                 f"[install] {len(result.drivers)} driver(s) — starting parallel downloads…",
-                 total=len(result.drivers))
-    all_results = _stream_install(result.drivers, work_dir, cfg)
+                 f"[install] {len(drivers)} driver(s) — starting parallel downloads…",
+                 total=len(drivers))
+    all_results = _stream_install(drivers, work_dir, cfg)
 
     shutil.rmtree(work_dir, ignore_errors=True)