driverclient 0.2.13__tar.gz → 0.2.18__tar.gz

{driverclient-0.2.13 → driverclient-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.13
+Version: 0.2.18
 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.13 → driverclient-0.2.18}/pyproject.toml

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

{driverclient-0.2.13 → driverclient-0.2.18}/src/driverclient/__init__.py

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

{driverclient-0.2.13 → driverclient-0.2.18}/src/driverclient/config.json

@@ -19,8 +19,9 @@
     "usb":    [".inf", ".sys", ".cat", ".dll"]
   },
 
-  "wu_wait_minutes": 10,
+  "wu_wait_minutes": 30,
   "wu_poll_interval_seconds": 30,
+  "wu_quiescent_polls": 2,
   "wu_ignore_classes": ["hidclass", "bluetooth", "printer"],
 
   "automate_wu_fallback": true,

{driverclient-0.2.13 → driverclient-0.2.18}/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".

{driverclient-0.2.13 → driverclient-0.2.18}/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.13 → driverclient-0.2.18}/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,36 +538,272 @@ 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:
-            proc.run(cmd, capture_output=True, timeout=30)
-            events.ok("windows_update", "[wu-update] Windows Update scan triggered")
-            return True
+            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(["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 _emit_wu_log_line(line: str) -> None:
+    """Turn one raw status line from the WU PowerShell into a friendly GUI event
+    so the operator sees WU's real phase (searching / downloading / installing)
+    live, instead of only a generic 'still working' tick."""
+    up = line.upper()
+    if up.startswith("SERVICE MICROSOFT_UPDATE"):
+        events.ok("windows_update",
+                  "[wu-update] Using the Microsoft Update service (drivers + Microsoft products)")
+    elif up.startswith("SERVICE WINDOWS_UPDATE_FALLBACK"):
+        detail = line.split(None, 2)[2] if len(line.split(None, 2)) > 2 else ""
+        events.warn("windows_update",
+                    f"[wu-update] Microsoft Update unavailable — falling back to default "
+                    f"Windows Update service  {detail}".rstrip())
+    elif up == "SEARCHING":
+        events.progress("windows_update",
+                        "[wu-update] Searching Windows Update for applicable updates… "
+                        "(the first scan can take several minutes)")
+    elif up == "NO_UPDATES":
+        events.progress("windows_update", "[wu-update] Search complete — no applicable updates found")
+    elif up.startswith("DOWNLOADING"):
+        n = line.split()[-1] if line.split() else "?"
+        events.progress("windows_update", f"[wu-update] Downloading {n} update(s)…")
+    elif up == "NONE_DOWNLOADED":
+        events.warn("windows_update", "[wu-update] Nothing downloaded")
+    elif up.startswith("INSTALLING"):
+        n = line.split()[-1] if line.split() else "?"
+        events.progress("windows_update", f"[wu-update] Installing {n} update(s)…")
+    elif up.startswith("INSTALLED"):
+        events.ok("windows_update", f"[wu-update] {line}")
+    elif up.startswith("WU_ERROR"):
+        detail = line[len("WU_ERROR"):].strip()
+        events.warn("windows_update", f"[wu-update] Windows Update error: {detail}", error=detail)
+    else:
+        events.progress("windows_update", f"[wu-update] {line}")
+
+
+def _drain_wu_log(trigger: "_WuTrigger | None", pos: int) -> int:
+    """Emit any new lines the WU PowerShell wrote to its log since offset `pos`,
+    return the new offset. Best-effort — a read failure just leaves `pos`
+    unchanged and never raises into the poll loop. Only the COM path writes a
+    log (trigger.log_path); the usoclient/wuauclt fallbacks have none."""
+    if trigger is None or not trigger.log_path:
+        return pos
+    try:
+        with open(trigger.log_path, "r", encoding="utf-8", errors="replace") as fh:
+            fh.seek(pos)
+            chunk   = fh.read()
+            new_pos = fh.tell()
+    except Exception:
+        return pos
+    for line in chunk.splitlines():
+        line = line.strip()
+        if line:
+            _emit_wu_log_line(line)
+    return new_pos
 
 
-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
+    log_pos        = 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:
+        log_pos   = _drain_wu_log(trigger, log_pos)   # surface WU's live phase
         all_new   = _enumerate_packages_since(wu_start, cfg)
         new_batch = [
             p for p in all_new
@@ -581,17 +819,38 @@ 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")
 
+    _drain_wu_log(trigger, log_pos)   # flush any final lines before cleanup
+    if trigger is not None:
+        trigger.terminate()
     return total