driverclient 0.2.24__tar.gz → 0.2.26__tar.gz

{driverclient-0.2.24 → driverclient-0.2.26}/.gitignore

@@ -61,3 +61,5 @@ deploy/bundles/
 
 # Claude Code
 .claude/
+*.log
+*.lock

{driverclient-0.2.24 → driverclient-0.2.26}/PKG-INFO

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

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

{driverclient-0.2.24 → driverclient-0.2.26}/src/driverclient/__init__.py

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

{driverclient-0.2.24 → driverclient-0.2.26}/src/driverclient/ops/automate.py

@@ -18,7 +18,7 @@ from datetime import datetime, timezone
 from driverclient import events
 from driverclient.config import get
 from driverclient.ops.capture import CaptureResult, classify_missing, wu_update
-from driverclient.ops.install import DriverResult, InstallResult, resolve_and_install
+from driverclient.ops.install import DriverResult, InstallResult, _bid, resolve_and_install
 from driverclient.ops.resolve import ResolveResult, resolve
 from driverclient.ops.scan import ScanResult, scan
 
@@ -113,11 +113,6 @@ def _step(n: int, label: str) -> None:
                     step=n, label=label)
 
 
-def _bid(driver: dict) -> str:
-    """Stable identity for a repo driver entry (matches install's dedup key)."""
-    return driver.get("binding_id") or driver.get("package_id", "")
-
-
 def _merge_install(combined: InstallResult, inst: InstallResult) -> None:
     """Fold one pass's results into the running total, deduped by binding_id so a
     same-boot re-attempt of an already-recorded driver is not double-counted; a

{driverclient-0.2.24 → driverclient-0.2.26}/src/driverclient/ops/install.py

@@ -26,9 +26,11 @@ from pathlib import Path
 from driverclient import events
 from driverclient.config import get
 from driverclient.core import proc
+from driverclient.core import hwid as hwid_mod
 from driverclient.core.http import http_post_retry
 from driverclient.ops.download import download_driver
 from driverclient.ops.resolve import ResolveResult, resolve
+from driverclient.ops.scan import scan
 
 # Install order: lower number first (hardware dependency)
 _CATEGORY_ORDER: dict[str, int] = {
@@ -62,6 +64,12 @@ _PNPUTIL_SUCCESS_MARKERS: tuple[str, ...] = (
 )
 
 
+def _bid(driver: dict) -> str:
+    """Stable identity for a repo driver entry — binding_id, falling back to
+    package_id. Shared dedup key: also imported by ops/automate.py."""
+    return driver.get("binding_id") or driver.get("package_id", "")
+
+
 @dataclass
 class DriverResult:
     binding_id:      str
@@ -167,9 +175,12 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     idx: dict = _installed_inf_index() if skip_installed else {}
 
     drivers = result.drivers
+    already_in_store: list[dict] = []
     if skip_installed:
-        kept = [d for d in drivers if not _already_in_store(d, idx)]
-        skipped = len(drivers) - len(kept)
+        kept = []
+        for d in drivers:
+            (already_in_store if _already_in_store(d, idx) else kept).append(d)
+        skipped = len(already_in_store)
         if skipped:
             events.progress(
                 "install",
@@ -178,6 +189,15 @@ def resolve_and_install(force: bool = False) -> InstallResult:
             )
         drivers = kept
         if not drivers:
+            # A display driver can be sitting in the store (e.g. staged offline
+            # via DISM during imaging) without ever being BOUND to the device —
+            # the primary adapter doesn't reliably switch itself over. Refresh it
+            # now instead of leaving that gap for Windows Update to close later.
+            _refresh_bound_devices(
+                already_in_store,
+                {_bid(d) for d in already_in_store},
+                cfg,
+            )
             events.done("install",
                         "[install] Nothing to install — all resolved drivers already current",
                         total=0)
@@ -201,6 +221,16 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # Skipped drivers ARE satisfied on the machine — report them upstream as success.
     _confirm(result.trace_id, installed_ok + skipped_now, install_failed, cfg)
 
+    # Force-bind any display driver now confirmed in the store — freshly
+    # installed here, or already present from an earlier offline/DISM pass —
+    # so the device actually switches over instead of staying on whatever it
+    # booted with until Windows Update eventually forces a real reinstall.
+    ready_ids = (
+        {r.binding_id for r in installed_ok}
+        | {_bid(d) for d in already_in_store}
+    )
+    _refresh_bound_devices(result.drivers, ready_ids, cfg)
+
     reboot_required = any(r.reboot_required for r in installed_ok)
     reboot_tag = "  — reboot required" if reboot_required else ""
     skip_tag   = f"  ({len(skipped_now)} already in store)" if skipped_now else ""
@@ -253,7 +283,7 @@ def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverRe
                    for d in ordered}
         for fut in as_completed(fut_map):
             driver = fut_map[fut]
-            bid    = driver.get("binding_id") or driver.get("package_id", "")
+            bid    = _bid(driver)
             try:
                 dest, dl_ok = fut.result()
             except Exception as e:
@@ -281,7 +311,7 @@ def _dedup_and_group(drivers: list[dict]) -> dict[int, list[dict]]:
     seen: set[str] = set()
     by_level: dict[int, list[dict]] = defaultdict(list)
     for d in drivers:
-        bid = d.get("binding_id") or d.get("package_id", "")
+        bid = _bid(d)
         if bid and bid not in seen:
             seen.add(bid)
             level = _CATEGORY_ORDER.get(d.get("category", "other"), 10)
@@ -334,7 +364,7 @@ def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
         count=n, duration_ms=dur, reboot_required=reboot, error=err)
 
     return [
-        DriverResult(binding_id=(d.get("binding_id") or d.get("package_id", "")),
+        DriverResult(binding_id=_bid(d),
                      success=ok, error="" if ok else err,
                      duration_ms=dur, reboot_required=reboot)
         for d, _ in inf_drivers
@@ -343,7 +373,7 @@ def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
 
 def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
     """Run one EXE-installer driver's silent setup (EXEs cannot be batched)."""
-    bid = driver.get("binding_id") or driver.get("package_id", "")
+    bid = _bid(driver)
     t0  = time.monotonic()
     try:
         exe_files = list(driver_dir.glob("*.exe"))
@@ -369,6 +399,97 @@ def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
 # the offline / pre-boot path.
 
 
+# ── Device refresh (force-bind display drivers) ─────────────────────────────────
+
+def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict) -> None:
+    """Force Windows to actually bind a display driver that's confirmed in the
+    driver store (just installed, or already there from an earlier offline/DISM
+    injection) but not necessarily applied to the device yet.
+
+    pnputil only stages a package into the store — the primary display adapter
+    is already rendering the current session with whatever driver it booted
+    with and doesn't reliably re-evaluate/switch itself over on its own. Left
+    alone, the device stays on the fallback driver until something forces a
+    real reinstall — which is what Windows' own automatic Windows Update
+    driver search eventually does, closing the gap our own pipeline left open.
+    Disabling + re-enabling the device here forces Windows to redo PnP install
+    for it immediately, picking up the driver that's already in the store.
+    """
+    display_hwids = {
+        d["hwid"] for d in drivers
+        if d.get("category") == "display" and d.get("hwid")
+        and _bid(d) in ready_ids
+    }
+    if not display_hwids:
+        return
+
+    canon_targets = {hwid_mod.canonicalize(h) for h in display_hwids}
+    scan_result = scan(force=False)
+    for dev in scan_result.devices:
+        if any(hwid_mod.canonicalize(h) in canon_targets for h in dev.hwids):
+            _refresh_device(dev.instance_id, cfg)
+
+
+def _refresh_device(instance_id: str, cfg: dict) -> None:
+    """Disable then re-enable one device by instance ID — forces Windows to redo
+    PnP install for it, so a driver already in the store but not yet bound
+    takes effect immediately, without a reboot.
+
+    A disable that succeeds but is never followed by a working re-enable is the
+    worst outcome here: unlike a failed install, a `pnputil /disable-device`
+    persists across reboot, so the device (the primary display adapter, in the
+    case this exists for) does not self-heal — it silently drops to Microsoft
+    Basic Display until someone notices and re-enables it by hand. So the
+    re-enable is attempted in `finally` regardless of how disable went (an
+    enable-device call on an already-enabled device is a harmless no-op),
+    retried a few times, and a persistent failure is escalated loudly rather
+    than swallowed.
+    """
+    events.progress("install",
+                    f"[install] Refreshing device to bind new driver: {instance_id}",
+                    instance_id=instance_id)
+    timeout = cfg.get("timeout_short", 30)
+    try:
+        r = proc.run(["pnputil", "/disable-device", instance_id],
+                     capture_output=True, text=True, timeout=timeout)
+        if r.returncode != 0:
+            events.warn("install",
+                        f"  [!] disable-device returned {r.returncode} for {instance_id}",
+                        instance_id=instance_id, error=r.stdout.strip()[:200])
+    except Exception as e:
+        events.warn("install", f"  [!] disable-device raised for {instance_id}: {e}",
+                     instance_id=instance_id, error=str(e))
+    finally:
+        ok, err = _enable_with_retries(instance_id, timeout)
+        if ok:
+            events.ok("install", f"  [ok] refreshed {instance_id}", instance_id=instance_id)
+        else:
+            events.error(
+                "install",
+                f"  [!!] CRITICAL: {instance_id} may be left DISABLED after refresh — "
+                f"run `pnputil /enable-device \"{instance_id}\"` manually to recover",
+                instance_id=instance_id, error=err, critical=True)
+
+
+def _enable_with_retries(instance_id: str, timeout: int, attempts: int = 3) -> tuple[bool, str]:
+    """Run `pnputil /enable-device`, retrying a couple of times before giving up —
+    a transient PnP busy state can fail the first attempt even though the device
+    would enable fine a moment later. Returns (success, last_error)."""
+    last_err = ""
+    for attempt in range(1, attempts + 1):
+        try:
+            r = proc.run(["pnputil", "/enable-device", instance_id],
+                         capture_output=True, text=True, timeout=timeout)
+            if r.returncode == 0:
+                return True, ""
+            last_err = r.stdout.strip()[:200]
+        except Exception as e:
+            last_err = str(e)
+        if attempt < attempts:
+            time.sleep(2)
+    return False, last_err
+
+
 # ── Driver installation ─────────────────────────────────────────────────────────
 
 def _classify(returncode: int, stdout: str = "", stderr: str = "") -> tuple[bool, str, bool]: