Btkey-Sync 0.1.1__tar.gz

btkey_sync-0.1.1/Btkey_Sync.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: Btkey-Sync
+Version: 0.1.1
+Summary: Synchronize Bluetooth LE and Classic bond keys between Windows and Linux in dual-boot setups
+License: MIT
+Project-URL: Homepage, https://github.com/netssv/btkey_sync
+Project-URL: Repository, https://github.com/netssv/btkey_sync
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# btkey_sync
+
+Syncs Bluetooth LE bonding (LTK / EDIV / ERand) from BLE devices between
+any two "sides": dual-boot operating systems, two partitions/installs of
+the same OS, or two separate physical machines — without having to re-pair
+the physical device on every switch.
+
+> See `REQUIREMENTS.md` for the full functional scope and `AGENTS.md` if
+> you're using an AI agent (Claude Code, etc.) to maintain/extend this project.
+
+## Why this exists
+
+Some budget BLE devices (mice, keyboards) use private MAC addresses that
+rotate between pairing sessions (RPA). Windows and Linux store bonding
+data in completely different formats and paths:
+
+|                    | Windows                                                                      | Linux (BlueZ)                               |
+| ------------------ | ---------------------------------------------------------------------------- | ------------------------------------------- |
+| Location           | `HKLM\SYSTEM\CurrentControlSet\Services\BTHPORT\Parameters\Keys`             | `/var/lib/bluetooth/<adapter>/<device>/info` |
+| Required access    | SYSTEM account (Administrator is not enough)                                 | root                                        |
+| EDIV/ERand format  | Hexadecimal                                                                  | Decimal                                     |
+| Hot reload         | —                                                                            | No: requires `systemctl restart bluetooth`  |
+
+This project automates extraction, conversion, and writing on both sides,
+leaving the exchangeable files in an `exports/` folder intended to be copied
+manually between partitions (there's no way to sync this live without a
+daemon running on both OSes simultaneously).
+
+## Installation
+
+No external dependencies required for normal use (only Python ≥3.10 stdlib).
+
+```bash
+git clone <this-repo>
+cd btkey_sync
+# Optional, only if running tests with pytest:
+pip install -e ".[dev]" --break-system-packages
+```
+
+## Usage
+
+### Export (on the system where the device IS connecting successfully)
+
+**Linux:**
+
+```bash
+sudo python3 -m btkey_sync
+```
+
+**Windows** (PowerShell or CMD as Administrator):
+
+```powershell
+python -m btkey_sync
+```
+
+Interactive flow:
+
+1. Detects the OS automatically.
+2. Lists BLE devices with bonding found.
+3. You choose which one to export.
+4. Generates `exports/<MAC>__<os>__<timestamp>.reg` + `.json` with the same info in plain text.
+
+### Copy the file to the destination
+
+Copy the generated `.reg` file (USB, shared partition, local network,
+whatever you have at hand) to the `exports/` folder of the target
+installation — this can be the other OS (dual boot), another
+partition/install of the same OS, or the equivalent on another machine.
+
+### Import (on the system that needs the bonding)
+
+```bash
+sudo python3 -m btkey_sync --import filename.reg
+```
+
+Shows locally known devices, lets you confirm or change the destination MAC
+(important if the device rotated its RPA address since last time), writes
+the bonding, and automatically restarts the Bluetooth stack.
+
+## Project structure
+
+```
+btkey_sync/
+├── cli.py                  # orchestrates the 4-step flow
+├── models.py                # BondKey: OS-agnostic bonding representation
+├── platform_detect.py       # Windows/Linux detection + environment validation
+├── storage.py                # manages the exports/ folder and naming convention
+├── backends/
+│   ├── base.py                # interface all backends must implement
+│   ├── windows_backend.py     # Windows registry via SYSTEM scheduled task
+│   └── linux_backend.py       # BlueZ info files in /var/lib/bluetooth
+├── exporters/reg_exporter.py  # BondKey -> .reg content
+└── importers/reg_importer.py  # .reg -> BondKey
+```
+
+## Testing
+
+```bash
+python3 tests/test_parsing.py
+# or, if you installed pytest:
+pytest
+```
+
+Tests use data from a real confirmed-working migration
+(`tests/fixtures/sample_mouse.reg`), including the round-trip case with
+a MAC change (rotated RPA).
+
+To test a backend without touching your real system, inject a temporary
+directory:
+
+```python
+from pathlib import Path
+from btkey_sync.backends.linux_backend import LinuxBluetoothBackend
+
+backend = LinuxBluetoothBackend(bluetooth_dir=Path("/tmp/fake_bluetooth"))
+```
+
+## Known limitations
+
+- No automatic/live sync between the two sides — always requires a manual
+  step of copying the exported file to the destination.
+- BLE only (SMP/LTK). Does not cover Bluetooth Classic (BR/EDR).
+- If the device uses RPA and rotates its address, the export→copy→import
+  cycle must be repeated; this project does not resolve IRK automatically.
+- Windows and Linux only. No macOS backend (see `AGENTS.md` if you want
+  to add one).
+
+## License / use
+
+Personal project for managing your own equipment. Use at your own
+discretion; you are touching internal structures not officially documented
+by Microsoft or the BlueZ project.

btkey_sync-0.1.1/Btkey_Sync.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+README.md
+actions.py
+actions_classic.py
+actions_classic_extra.py
+actions_clone.py
+actions_common.py
+actions_help.py
+actions_remove.py
+actions_show.py
+actions_verify.py
+actions_windows.py
+cli.py
+models.py
+platform_detect.py
+pyproject.toml
+storage.py
+tui_helpers.py
+Btkey_Sync.egg-info/PKG-INFO
+Btkey_Sync.egg-info/SOURCES.txt
+Btkey_Sync.egg-info/dependency_links.txt
+Btkey_Sync.egg-info/entry_points.txt
+Btkey_Sync.egg-info/requires.txt
+Btkey_Sync.egg-info/top_level.txt
+backends/__init__.py
+backends/base.py
+backends/linux_backend.py
+backends/linux_classic.py
+backends/offline_windows.py
+backends/offline_windows_classic.py
+backends/windows_backend.py
+backends/windows_common.py
+exporters/__init__.py
+exporters/classic_exporter.py
+exporters/reg_exporter.py
+importers/__init__.py
+importers/classic_importer.py
+importers/reg_importer.py
+tests/test_parsing.py

btkey_sync-0.1.1/Btkey_Sync.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

btkey_sync-0.1.1/Btkey_Sync.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+btkey-sync = cli:main

btkey_sync-0.1.1/Btkey_Sync.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

btkey_sync-0.1.1/Btkey_Sync.egg-info/top_level.txt

@@ -0,0 +1,18 @@
+actions
+actions_classic
+actions_classic_extra
+actions_clone
+actions_common
+actions_help
+actions_remove
+actions_show
+actions_verify
+actions_windows
+backends
+cli
+exporters
+importers
+models
+platform_detect
+storage
+tui_helpers

btkey_sync-0.1.1/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: Btkey-Sync
+Version: 0.1.1
+Summary: Synchronize Bluetooth LE and Classic bond keys between Windows and Linux in dual-boot setups
+License: MIT
+Project-URL: Homepage, https://github.com/netssv/btkey_sync
+Project-URL: Repository, https://github.com/netssv/btkey_sync
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# btkey_sync
+
+Syncs Bluetooth LE bonding (LTK / EDIV / ERand) from BLE devices between
+any two "sides": dual-boot operating systems, two partitions/installs of
+the same OS, or two separate physical machines — without having to re-pair
+the physical device on every switch.
+
+> See `REQUIREMENTS.md` for the full functional scope and `AGENTS.md` if
+> you're using an AI agent (Claude Code, etc.) to maintain/extend this project.
+
+## Why this exists
+
+Some budget BLE devices (mice, keyboards) use private MAC addresses that
+rotate between pairing sessions (RPA). Windows and Linux store bonding
+data in completely different formats and paths:
+
+|                    | Windows                                                                      | Linux (BlueZ)                               |
+| ------------------ | ---------------------------------------------------------------------------- | ------------------------------------------- |
+| Location           | `HKLM\SYSTEM\CurrentControlSet\Services\BTHPORT\Parameters\Keys`             | `/var/lib/bluetooth/<adapter>/<device>/info` |
+| Required access    | SYSTEM account (Administrator is not enough)                                 | root                                        |
+| EDIV/ERand format  | Hexadecimal                                                                  | Decimal                                     |
+| Hot reload         | —                                                                            | No: requires `systemctl restart bluetooth`  |
+
+This project automates extraction, conversion, and writing on both sides,
+leaving the exchangeable files in an `exports/` folder intended to be copied
+manually between partitions (there's no way to sync this live without a
+daemon running on both OSes simultaneously).
+
+## Installation
+
+No external dependencies required for normal use (only Python ≥3.10 stdlib).
+
+```bash
+git clone <this-repo>
+cd btkey_sync
+# Optional, only if running tests with pytest:
+pip install -e ".[dev]" --break-system-packages
+```
+
+## Usage
+
+### Export (on the system where the device IS connecting successfully)
+
+**Linux:**
+
+```bash
+sudo python3 -m btkey_sync
+```
+
+**Windows** (PowerShell or CMD as Administrator):
+
+```powershell
+python -m btkey_sync
+```
+
+Interactive flow:
+
+1. Detects the OS automatically.
+2. Lists BLE devices with bonding found.
+3. You choose which one to export.
+4. Generates `exports/<MAC>__<os>__<timestamp>.reg` + `.json` with the same info in plain text.
+
+### Copy the file to the destination
+
+Copy the generated `.reg` file (USB, shared partition, local network,
+whatever you have at hand) to the `exports/` folder of the target
+installation — this can be the other OS (dual boot), another
+partition/install of the same OS, or the equivalent on another machine.
+
+### Import (on the system that needs the bonding)
+
+```bash
+sudo python3 -m btkey_sync --import filename.reg
+```
+
+Shows locally known devices, lets you confirm or change the destination MAC
+(important if the device rotated its RPA address since last time), writes
+the bonding, and automatically restarts the Bluetooth stack.
+
+## Project structure
+
+```
+btkey_sync/
+├── cli.py                  # orchestrates the 4-step flow
+├── models.py                # BondKey: OS-agnostic bonding representation
+├── platform_detect.py       # Windows/Linux detection + environment validation
+├── storage.py                # manages the exports/ folder and naming convention
+├── backends/
+│   ├── base.py                # interface all backends must implement
+│   ├── windows_backend.py     # Windows registry via SYSTEM scheduled task
+│   └── linux_backend.py       # BlueZ info files in /var/lib/bluetooth
+├── exporters/reg_exporter.py  # BondKey -> .reg content
+└── importers/reg_importer.py  # .reg -> BondKey
+```
+
+## Testing
+
+```bash
+python3 tests/test_parsing.py
+# or, if you installed pytest:
+pytest
+```
+
+Tests use data from a real confirmed-working migration
+(`tests/fixtures/sample_mouse.reg`), including the round-trip case with
+a MAC change (rotated RPA).
+
+To test a backend without touching your real system, inject a temporary
+directory:
+
+```python
+from pathlib import Path
+from btkey_sync.backends.linux_backend import LinuxBluetoothBackend
+
+backend = LinuxBluetoothBackend(bluetooth_dir=Path("/tmp/fake_bluetooth"))
+```
+
+## Known limitations
+
+- No automatic/live sync between the two sides — always requires a manual
+  step of copying the exported file to the destination.
+- BLE only (SMP/LTK). Does not cover Bluetooth Classic (BR/EDR).
+- If the device uses RPA and rotates its address, the export→copy→import
+  cycle must be repeated; this project does not resolve IRK automatically.
+- Windows and Linux only. No macOS backend (see `AGENTS.md` if you want
+  to add one).
+
+## License / use
+
+Personal project for managing your own equipment. Use at your own
+discretion; you are touching internal structures not officially documented
+by Microsoft or the BlueZ project.

btkey_sync-0.1.1/README.md

@@ -0,0 +1,132 @@
+# btkey_sync
+
+Syncs Bluetooth LE bonding (LTK / EDIV / ERand) from BLE devices between
+any two "sides": dual-boot operating systems, two partitions/installs of
+the same OS, or two separate physical machines — without having to re-pair
+the physical device on every switch.
+
+> See `REQUIREMENTS.md` for the full functional scope and `AGENTS.md` if
+> you're using an AI agent (Claude Code, etc.) to maintain/extend this project.
+
+## Why this exists
+
+Some budget BLE devices (mice, keyboards) use private MAC addresses that
+rotate between pairing sessions (RPA). Windows and Linux store bonding
+data in completely different formats and paths:
+
+|                    | Windows                                                                      | Linux (BlueZ)                               |
+| ------------------ | ---------------------------------------------------------------------------- | ------------------------------------------- |
+| Location           | `HKLM\SYSTEM\CurrentControlSet\Services\BTHPORT\Parameters\Keys`             | `/var/lib/bluetooth/<adapter>/<device>/info` |
+| Required access    | SYSTEM account (Administrator is not enough)                                 | root                                        |
+| EDIV/ERand format  | Hexadecimal                                                                  | Decimal                                     |
+| Hot reload         | —                                                                            | No: requires `systemctl restart bluetooth`  |
+
+This project automates extraction, conversion, and writing on both sides,
+leaving the exchangeable files in an `exports/` folder intended to be copied
+manually between partitions (there's no way to sync this live without a
+daemon running on both OSes simultaneously).
+
+## Installation
+
+No external dependencies required for normal use (only Python ≥3.10 stdlib).
+
+```bash
+git clone <this-repo>
+cd btkey_sync
+# Optional, only if running tests with pytest:
+pip install -e ".[dev]" --break-system-packages
+```
+
+## Usage
+
+### Export (on the system where the device IS connecting successfully)
+
+**Linux:**
+
+```bash
+sudo python3 -m btkey_sync
+```
+
+**Windows** (PowerShell or CMD as Administrator):
+
+```powershell
+python -m btkey_sync
+```
+
+Interactive flow:
+
+1. Detects the OS automatically.
+2. Lists BLE devices with bonding found.
+3. You choose which one to export.
+4. Generates `exports/<MAC>__<os>__<timestamp>.reg` + `.json` with the same info in plain text.
+
+### Copy the file to the destination
+
+Copy the generated `.reg` file (USB, shared partition, local network,
+whatever you have at hand) to the `exports/` folder of the target
+installation — this can be the other OS (dual boot), another
+partition/install of the same OS, or the equivalent on another machine.
+
+### Import (on the system that needs the bonding)
+
+```bash
+sudo python3 -m btkey_sync --import filename.reg
+```
+
+Shows locally known devices, lets you confirm or change the destination MAC
+(important if the device rotated its RPA address since last time), writes
+the bonding, and automatically restarts the Bluetooth stack.
+
+## Project structure
+
+```
+btkey_sync/
+├── cli.py                  # orchestrates the 4-step flow
+├── models.py                # BondKey: OS-agnostic bonding representation
+├── platform_detect.py       # Windows/Linux detection + environment validation
+├── storage.py                # manages the exports/ folder and naming convention
+├── backends/
+│   ├── base.py                # interface all backends must implement
+│   ├── windows_backend.py     # Windows registry via SYSTEM scheduled task
+│   └── linux_backend.py       # BlueZ info files in /var/lib/bluetooth
+├── exporters/reg_exporter.py  # BondKey -> .reg content
+└── importers/reg_importer.py  # .reg -> BondKey
+```
+
+## Testing
+
+```bash
+python3 tests/test_parsing.py
+# or, if you installed pytest:
+pytest
+```
+
+Tests use data from a real confirmed-working migration
+(`tests/fixtures/sample_mouse.reg`), including the round-trip case with
+a MAC change (rotated RPA).
+
+To test a backend without touching your real system, inject a temporary
+directory:
+
+```python
+from pathlib import Path
+from btkey_sync.backends.linux_backend import LinuxBluetoothBackend
+
+backend = LinuxBluetoothBackend(bluetooth_dir=Path("/tmp/fake_bluetooth"))
+```
+
+## Known limitations
+
+- No automatic/live sync between the two sides — always requires a manual
+  step of copying the exported file to the destination.
+- BLE only (SMP/LTK). Does not cover Bluetooth Classic (BR/EDR).
+- If the device uses RPA and rotates its address, the export→copy→import
+  cycle must be repeated; this project does not resolve IRK automatically.
+- Windows and Linux only. No macOS backend (see `AGENTS.md` if you want
+  to add one).
+
+## License / use
+
+Personal project for managing your own equipment. Use at your own
+discretion; you are touching internal structures not officially documented
+by Microsoft or the BlueZ project.

btkey_sync-0.1.1/actions.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+from pathlib import Path
+from exporters import export_bond_key
+from importers import load_bond_from_reg_file
+from platform_detect import OSKind
+from storage import ensure_exports_dir
+import tui_helpers as tui
+import actions_common as common
+from actions_verify import verify_and_connect, run_verify_flow  # noqa: F401
+from actions_remove import run_remove_flow  # noqa: F401
+
+
+def _ensure_device_name(bond) -> None:
+    """If bond has no name, prompt the user to enter one interactively."""
+    if not bond.device_name:
+        name = tui.ask("Device has no name — enter a label (Enter to skip)", default="")
+        if name.strip():
+            bond.device_name = name.strip()
+
+
+def run_export_flow() -> None:
+    tui.header("Select & Extract — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    tui.header("Select & Extract — Step 2: Choose extraction source")
+    source_os, win_mount = common.prompt_source_os(env.os_kind)
+    if source_os == OSKind.WINDOWS and env.os_kind == OSKind.LINUX:
+        common.run_offline_windows_export(win_mount, export_bond_key, ensure_exports_dir)
+        return
+    tui.header("Select & Extract — Step 3: Choose a device")
+    with tui.Spinner("Scanning bonded BLE devices…"):
+        devices = backend.list_devices()
+    chosen = common.prompt_select_device(devices) if devices else None
+    if not chosen:
+        tui.info("No devices or cancelled.")
+        return
+    tui.header("Select & Extract — Step 4: Extract and save")
+    with tui.Spinner(f"Extracting bonding for {chosen.device_mac}…"):
+        bond = backend.extract_bond_key(chosen)
+        bond.source_os = source_os.value
+    common.print_bond_summary(bond)
+    with tui.Spinner("Writing export files…"):
+        exports_dir = ensure_exports_dir()
+        reg_path = export_bond_key(bond)
+    tui.ok(f"Exported to: {tui.bold(reg_path.name)}")
+
+
+def run_import_flow(reg_file_arg: str | None = None) -> None:
+    tui.header("Import — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    reg_path = Path(reg_file_arg) if reg_file_arg else common.prompt_select_export_file()
+    if not reg_path:
+        tui.info("Cancelled.")
+        return
+    if not reg_path.exists():
+        tui.err(f"File not found: {reg_path}")
+        return
+
+    tui.header("Import — Step 3: Load bond key")
+    with tui.Spinner(f"Parsing {reg_path.name}…"):
+        bond = load_bond_from_reg_file(reg_path)
+    common.print_bond_summary(bond)
+    _ensure_device_name(bond)
+
+    tui.header("Import — Step 4: Compare with local device")
+    with tui.Spinner("Looking up local bonding for this device…"):
+        existing = backend.list_devices()
+
+    local_match = next(
+        (d for d in existing if d.device_mac.upper() == bond.device_mac.upper()), None
+    )
+    ltk_match = None
+    if not local_match:
+        for d in existing:
+            if d.has_ltk:
+                try:
+                    local_bond = backend.extract_bond_key(d)
+                    if (local_bond.ltk_hex.upper() == bond.ltk_hex.upper() or
+                        (bond.irk_hex and local_bond.irk_hex and
+                         local_bond.irk_hex.upper() == bond.irk_hex.upper())):
+                        ltk_match = d
+                        # Propagate name if source has no name
+                        if not bond.device_name and local_bond.device_name:
+                            bond.device_name = local_bond.device_name
+                        break
+                except Exception:
+                    pass
+
+    source_device_mac = None
+    if local_match and local_match.has_ltk:
+        try:
+            local_bond = backend.extract_bond_key(local_match)
+            if local_bond.ltk_hex.upper() == bond.ltk_hex.upper():
+                tui.ok("Keys are already in sync — LTK matches. No import needed.")
+                return
+            tui.warn(f"Key mismatch!\n    Local LTK: {local_bond.ltk_hex}\n    New LTK:   {bond.ltk_hex}")
+        except Exception:
+            pass
+    elif ltk_match:
+        tui.info(f"Matched physical device under different MAC: {ltk_match.device_mac}")
+        q = f"Migrate profile/cache from {ltk_match.device_mac} to {bond.device_mac}? [Y/n]"
+        if tui.ask(q, default="Y").upper() == "Y":
+            source_device_mac = ltk_match.device_mac
+    elif local_match:
+        tui.info("Device found locally but has no LTK.")
+    else:
+        tui.info("Device not paired locally yet.")
+
+    print()
+    target_mac = tui.ask("Destination MAC (Enter to keep original)", default=bond.device_mac)
+    target_mac = target_mac if target_mac != bond.device_mac else None
+
+    tui.header("Import — Step 5: Write and restart Bluetooth")
+    with tui.Spinner("Writing bonding to disk…"):
+        written_path = backend.import_bond_key(
+            bond, target_device_mac=target_mac, source_device_mac=source_device_mac
+        )
+    tui.ok(f"Written to: {tui.dim(str(written_path))}")
+    tui.info("Restarting Bluetooth service to apply changes. This may take a moment…")
+    with tui.Spinner("Restarting Bluetooth service…"):
+        backend.restart_bluetooth_stack()
+    tui.ok("Bluetooth service restarted.")
+    verify_and_connect(backend, target_mac or bond.device_mac)
+
+
+def _pick_source_bond(source_os: OSKind, win_mount, env) -> "BondKey | None":
+    """Extract a bond from the chosen source (Linux or Windows partition)."""
+    if source_os == OSKind.WINDOWS and env.os_kind == OSKind.LINUX:
+        return common.pick_bond_from_windows(win_mount)
+    src_backend = common.get_backend(source_os)
+    with tui.Spinner("Scanning bonded BLE devices…"):
+        devices = src_backend.list_devices()
+    if not devices:
+        tui.warn("No bonded BLE devices found.")
+        return None
+    source = common.prompt_select_device(devices)
+    if source is None:
+        tui.info("Cancelled.")
+        return None
+    with tui.Spinner(f"Extracting bonding for {source.device_mac}…"):
+        bond = src_backend.extract_bond_key(source)
+        bond.source_os = source_os.value
+    return bond
+
+def run_clone_flow() -> None:
+    tui.header("Clone — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    if env.os_kind != OSKind.LINUX:
+        tui.err("Clone (write destination) is only supported on Linux.")
+        return
+    tui.header("Clone — Step 2: Choose source")
+    source_os, win_mount = common.prompt_source_os(env.os_kind)
+    bond = _pick_source_bond(source_os, win_mount, env)
+    if bond is None:
+        return
+    common.print_bond_summary(bond)
+    _ensure_device_name(bond)
+    tui.header("Clone — Step 3: Destination MAC")
+    target_mac = tui.ask("Destination MAC (Enter = same)", default=bond.device_mac)
+    with tui.Spinner("Scanning local devices…"):
+        existing = backend.list_devices()
+    local_match = next((d for d in existing if d.device_mac.upper() == target_mac.upper()), None)
+    ltk_match = None
+    if not local_match:
+        for d in existing:
+            if d.has_ltk:
+                try:
+                    local_bond = backend.extract_bond_key(d)
+                    if (local_bond.ltk_hex.upper() == bond.ltk_hex.upper() or
+                        (bond.irk_hex and local_bond.irk_hex and
+                         local_bond.irk_hex.upper() == bond.irk_hex.upper())):
+                        ltk_match = d
+                        if not bond.device_name and local_bond.device_name:
+                            bond.device_name = local_bond.device_name
+                        break
+                except Exception:
+                    pass
+    source_device_mac = None
+    if ltk_match:
+        tui.info(f"Matched physical device under different MAC: {ltk_match.device_mac}")
+        q = f"Migrate profile/cache from {ltk_match.device_mac} to {target_mac}? [Y/n]"
+        if tui.ask(q, default="Y").upper() == "Y":
+            source_device_mac = ltk_match.device_mac
+    tui.header("Clone — Step 4: Write and restart Bluetooth")
+    with tui.Spinner("Writing cloned bonding to disk…"):
+        written_path = backend.import_bond_key(
+            bond, target_device_mac=target_mac, source_device_mac=source_device_mac
+        )
+    tui.ok(f"Cloned bonding written to: {tui.dim(str(written_path))}")
+    tui.info("Restarting Bluetooth service to apply changes. This may take a moment…")
+    with tui.Spinner("Restarting Bluetooth service…"):
+        backend.restart_bluetooth_stack()
+    tui.ok("Bluetooth service restarted.")
+    verify_and_connect(backend, target_mac)