KiCad - the KiCad Bridge

@@ -324,6 +324,7 @@ def get_focus_debug() -> dict:         "parkAttempts": _park_attempts,         "parkLastError": _park_last_error,         "sweepTicks": _sweep_ticks,+        "ownedPids": sorted(_owned_pids),     }  @@ -371,6 +372,182 @@ _park_baseline: set = set() _bridge_windows: set = set()  # windows the BRIDGE created (persists across verbs) _park_sweep_started = False +# ---- Ownership ledger (John, 2026-08-17: "what happens if the user opens their+# own kicad? i don't want us ruining that") -------------------------------------+# The bridge may only park/bounce/badge windows it OWNS. Ownership is decided by+# PROCESS: every kicad-family pid the bridge spawns is registered here (children+# count via parent-chain walk — the PM spawns eeschema.exe/pcbnew.exe). The set+# persists to %USERPROFILE%/.adom/kicad-bridge-owned.json so a bridge restart+# does not orphan (or worse, mis-adopt) windows. A KiCad the USER launched is in+# no spawned pid tree -> _is_owned_window() is False -> every focus/park/badge+# path leaves it completely alone. There is deliberately NO "adopt what exists"+# seeding: unknown windows default to user-owned.+_owned_pids: set = set()+_KICAD_EXES = ("kicad", "eeschema", "pcbnew", "gerbview", "pl_editor",+               "pcb_calculator", "bitmap2component")+++def _ledger_path():+    import os as _os+    from pathlib import Path as _P+    base = _os.environ.get("USERPROFILE") or str(_P.home())+    d = _P(base) / ".adom"+    try:+        d.mkdir(parents=True, exist_ok=True)+    except Exception:+        pass+    return d / "kicad-bridge-owned.json"+++def _pid_of_hwnd(hwnd) -> int:+    pid = ctypes.wintypes.DWORD()+    _user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))+    return int(pid.value)+++def _pid_exe_base(pid) -> str:+    try:+        h = _kernel32.OpenProcess(0x1000, False, int(pid))+        if not h:+            return ""+        try:+            buf = ctypes.create_unicode_buffer(512)+            size = ctypes.wintypes.DWORD(512)+            if _kernel32.QueryFullProcessImageNameW(h, 0, buf, ctypes.byref(size)):+                import os as _os+                return _os.path.basename(buf.value).lower()+        finally:+            _kernel32.CloseHandle(h)+    except Exception:+        pass+    return ""+++def _pid_is_kicad(pid) -> bool:+    base = _pid_exe_base(pid)+    return any(base.startswith(e) for e in _KICAD_EXES)+++def _save_ledger() -> None:+    try:+        import json as _json+        live = {int(p) for p in _owned_pids if _pid_is_kicad(p)}+        wins = []+        for h in list(_bridge_windows):+            try:+                if _user32.IsWindow(h):+                    wins.append({"hwnd": int(h), "pid": _pid_of_hwnd(h)})+            except Exception:+                pass+        _ledger_path().write_text(_json.dumps({"pids": sorted(live), "windows": wins}))+    except Exception:+        pass+++def load_owned_ledger() -> None:+    """Boot: re-own only what provably survived — a ledger hwnd whose pid still+    matches, and ledger pids still running a kicad-family exe. Everything else+    (including anything the user launched while the bridge was down) stays+    user-owned."""+    try:+        import json as _json+        data = _json.loads(_ledger_path().read_text())+    except Exception:+        return+    for e in data.get("windows", []):+        try:+            h, p = int(e.get("hwnd") or 0), int(e.get("pid") or 0)+            if h and _user32.IsWindow(h) and _pid_of_hwnd(h) == p and is_kicad_window(h):+                _bridge_windows.add(h)+                _owned_pids.add(p)+        except Exception:+            pass+    for p in data.get("pids", []):+        try:+            if _pid_is_kicad(p):+                _owned_pids.add(int(p))+        except Exception:+            pass+++def register_owned_pid(pid) -> None:+    """Spawn sites call this for every kicad-family process the bridge starts."""+    try:+        if pid:+            _owned_pids.add(int(pid))+            _save_ledger()+    except Exception:+        pass+++def _parent_pid_map() -> dict:+    """{pid: ppid} via toolhelp snapshot (cheap, ~ms)."""+    out = {}+    try:+        TH32CS_SNAPPROCESS = 0x02++        class PE32(ctypes.Structure):+            _fields_ = [("dwSize", ctypes.wintypes.DWORD),+                        ("cntUsage", ctypes.wintypes.DWORD),+                        ("th32ProcessID", ctypes.wintypes.DWORD),+                        ("th32DefaultHeapID", ctypes.POINTER(ctypes.c_ulong)),+                        ("th32ModuleID", ctypes.wintypes.DWORD),+                        ("cntThreads", ctypes.wintypes.DWORD),+                        ("th32ParentProcessID", ctypes.wintypes.DWORD),+                        ("pcPriClassBase", ctypes.c_long),+                        ("dwFlags", ctypes.wintypes.DWORD),+                        ("szExeFile", ctypes.c_wchar * 260)]++        snap = _kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)+        if snap == ctypes.wintypes.HANDLE(-1).value:+            return out+        try:+            pe = PE32()+            pe.dwSize = ctypes.sizeof(PE32)+            if _kernel32.Process32FirstW(snap, ctypes.byref(pe)):+                while True:+                    out[int(pe.th32ProcessID)] = int(pe.th32ParentProcessID)+                    if not _kernel32.Process32NextW(snap, ctypes.byref(pe)):+                        break+        finally:+            _kernel32.CloseHandle(snap)+    except Exception:+        pass+    return out+++def _is_owned_window(hwnd) -> bool:+    """Is this window the bridge's (spawned by us, or child of our spawn)?"""+    if hwnd in _bridge_windows:+        return True+    try:+        pid = _pid_of_hwnd(hwnd)+    except Exception:+        return False+    if pid in _owned_pids:+        return True+    try:+        pm = _parent_pid_map()+        p, depth = pid, 0+        while p in pm and depth < 6:+            p = pm[p]+            depth += 1+            if p in _owned_pids:+                _owned_pids.add(pid)  # child of our spawn: ours too+                _save_ledger()+                return True+    except Exception:+        pass+    return False+++def is_bridge_window(hwnd) -> bool:+    """Public ownership probe (kicad_state, taskbar badges)."""+    try:+        return _is_owned_window(hwnd)+    except Exception:+        return False+  def _enum_kicad_hwnds() -> set:     out = set()@@ -413,7 +590,14 @@ def _start_park_sweep() -> None:                     quiet_since = None                     if _t.monotonic() >= _expected_fg_until:                         for h in _enum_kicad_hwnds() - _park_baseline:-                            _bridge_windows.add(h)+                            # Ownership gate: a new window from a process tree we+                            # did NOT spawn is the USER's (e.g. they launched+                            # KiCad mid-verb) — never adopt, park, or badge it.+                            if h not in _bridge_windows and not _is_owned_window(h):+                                continue+                            if h not in _bridge_windows:+                                _bridge_windows.add(h)+                                _save_ledger()                             suppress_activation(h)                             _park_offscreen(h)                             try:@@ -671,6 +855,8 @@ def start_focus_event_hook() -> None:                 return  # sanctioned foreground in progress             if not is_kicad_window(hwnd):                 return+            if not _is_owned_window(hwnd):+                return  # the user's own KiCad: not ours to park or bounce             print(f"[focus-hook] event=0x{event:04x} hwnd={hwnd} inflight={_verb_inflight} guards={_guard_count}", file=sys.stderr)             if event == EVENT_OBJECT_SHOW:                 suppress_activation(hwnd)@@ -755,6 +941,31 @@ def start_focus_sentinel() -> None:         except Exception:             return False +    # 0.9.155 (caught live: John launched his own KiCad and the sentinel bounced+    # him 8 times, including a File Open Warning he never saw): a click on the+    # TASKBAR / Start is the canonical "bring this window up" gesture, but the+    # cursor is over the shell — not the raised window — when the transition+    # lands, so click-on-window missed it and the raise read as a self-raise.+    _SHELL_CLASSES = ("Shell_TrayWnd", "Shell_SecondaryTrayWnd",+                      "Windows.UI.Core.CoreWindow", "XamlExplorerHostIslandWindow",+                      "TopLevelWindowForOverflowXamlIsland", "Progman", "WorkerW")++    def _cursor_over_shell() -> bool:+        try:+            import ctypes as _ct+            pt = _ct.wintypes.POINT()+            _user32.GetCursorPos(_ct.byref(pt))+            under = _user32.WindowFromPoint(pt)+            GA_ROOT = 2+            root = _user32.GetAncestor(under, GA_ROOT) if under else None+            if not root:+                return False+            buf = _ct.create_unicode_buffer(64)+            _user32.GetClassNameW(root, buf, 64)+            return buf.value in _SHELL_CLASSES+        except Exception:+            return False+     def _loop():         # v0.9.115: "recent user input" was the wrong bless test — the user         # typing in ANOTHER app is exactly when a self-raise is most disruptive,@@ -781,12 +992,17 @@ def start_focus_sentinel() -> None:                 if fg != last_fg:                     if fg and is_kicad_window(fg):                         ago = _seconds_since_user_input()-                        clicked_here = (now - last_click_t) <= 1.2 and _cursor_over(fg)+                        clicked_here = (now - last_click_t) <= 1.2 and \+                            (_cursor_over(fg) or _cursor_over_shell())                         alt_tabbed = (now - last_alt_t) <= 2.0                         if now < _expected_fg_until:                             _log("sanctioned-foreground (allowed)", fg, ago)                         elif clicked_here or alt_tabbed:                             _log("user-foregrounded (left alone)", fg, ago)+                        elif not _is_owned_window(fg):+                            # Not our spawn tree: the USER's own KiCad. The+                            # bridge has no authority over it — ever.+                            _log("user-owned window (left alone)", fg, ago)                         elif _guard_count > 0:                             _log("steal-during-guard (guardian handles)", fg, ago)                         else: