btkey-sync 0.2.0__py3-none-any.whl

actions.py

@@ -0,0 +1,146 @@
+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_windows import run_offline_windows_export
+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:
+        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)
+    _ensure_device_name(bond)
+    with tui.Spinner("Writing export files…"):
+        exports_dir = ensure_exports_dir()
+        reg_path = export_bond_key(bond)
+    print()
+    tui.ok(f"Exports folder : {tui.dim(str(exports_dir))}")
+    tui.ok(f"File generated : {tui.bold(reg_path.name)}")
+    tui.ok(f"Metadata (JSON): {tui.bold(reg_path.with_suffix('.json').name)}")
+
+
+def _pick_adapter(backend, default_adapter: str | None = None) -> str | None:
+    adapters = backend._list_adapters()
+    if not adapters:
+        tui.err("No Bluetooth adapters found in /var/lib/bluetooth.")
+        return None
+    if len(adapters) == 1:
+        return adapters[0]
+    print(f"\n  {tui.bold('Multiple Bluetooth adapters found on this system:')}\n")
+    for i, a in enumerate(adapters, 1):
+        mark = tui.green(" (matches file)") if a == default_adapter else ""
+        print(f"    {tui.cyan(f'[{i}]')}  {a}{mark}")
+    print()
+    while True:
+        raw = tui.ask("Adapter index")
+        if raw.isdigit():
+            idx = int(raw)
+            if 1 <= idx <= len(adapters):
+                return adapters[idx - 1]
+        tui.warn("Invalid index, try again.")
+
+
+def run_import_flow(reg_file_arg: str | None = None) -> None:
+    tui.header("Import & Reconnect — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    if env.os_kind != OSKind.LINUX:
+        tui.err("Import is only supported when running on Linux (target system).")
+        return
+    tui.header("Import & Reconnect — Step 2: Select file")
+    reg_path = Path(reg_file_arg) if reg_file_arg else common.prompt_select_export_file()
+    if not reg_path or not reg_path.exists():
+        tui.err(f"File not found: {reg_path}")
+        return
+    tui.ok(f"File: {tui.bold(reg_path.name)}")
+    tui.header("Import & Reconnect — Step 3: Inspect key")
+    try:
+        bond = load_bond_from_reg_file(reg_path)
+    except Exception as e:
+        tui.err(f"Failed to parse {reg_path.name}: {e}")
+        return
+    common.print_bond_summary(bond)
+    tui.header("Import & Reconnect — Step 4: Map local device")
+    chosen_adapter = _pick_adapter(backend, default_adapter=bond.adapter_mac)
+    if not chosen_adapter:
+        return
+    bond.adapter_mac = chosen_adapter
+    with tui.Spinner("Scanning existing devices in BlueZ…"):
+        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
+                        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 a different MAC address: {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 run_clone_flow() -> None:
+    """Delegates to unified clone flow for BLE, Classic, and Dual-Mode."""
+    from actions_clone import run_unified_clone_flow
+    run_unified_clone_flow()

actions_classic.py

@@ -0,0 +1,173 @@
+"""
+actions_classic.py
+
+Top-level orchestration for Classic (BR/EDR) export and import flows.
+
+Implements RC5, RC6, RC7, RC9, RC11 from CLASSIC_SUPPORT.agent.md.
+Each step of the bonding lifecycle is sequenced explicitly here — the backend
+exposes discrete methods (RC9) and this layer calls them in order.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import tui_helpers as tui
+import actions_common as common
+from exporters.classic_exporter import export_classic_bond
+from importers.classic_importer import load_classic_bond_from_reg_file
+from platform_detect import OSKind
+from actions_verify import verify_and_connect
+
+
+def _filter_classic_devices(backend, devices):
+    """Return only devices whose info file has a [LinkKey] section."""
+    import configparser
+    classic = []
+    for d in devices:
+        info_path = Path(d.raw_source_path)
+        if not info_path.exists():
+            continue
+        cfg = configparser.ConfigParser()
+        try:
+            cfg.read(info_path)
+            if "LinkKey" in cfg:
+                classic.append(d)
+        except Exception:
+            pass
+    return classic
+
+
+def run_classic_export_flow() -> None:
+    """
+    Full Classic export flow:
+    pre-flight → pick device → extract bond → write .reg + .json.
+    """
+    tui.header("Classic Export — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+
+    tui.header("Classic Export — Pre-flight Check")
+    if not tui.warn_classic_preflight():
+        tui.info("Aborted — pre-flight not acknowledged.")
+        return
+
+    tui.header("Classic Export — Step 2: Choose device")
+    with tui.Spinner("Scanning bonded devices…"):
+        all_devices = backend.list_devices()
+
+    classic_devices = _filter_classic_devices(backend, all_devices)
+    if not classic_devices:
+        tui.warn("No Classic (BR/EDR) bonded devices found.")
+        tui.info("Classic devices have a [LinkKey] section in their BlueZ info file.")
+        return
+
+    chosen = common.prompt_select_device(classic_devices)
+    if not chosen:
+        tui.info("Cancelled.")
+        return
+
+    tui.header("Classic Export — Step 3: Extract and save")
+    with tui.Spinner(f"Extracting Classic bond for {chosen.device_mac}…"):
+        bond = backend.extract_classic_bond(chosen)
+
+    tui.info(bond.summary())
+
+    with tui.Spinner("Writing export files…"):
+        reg_path = export_classic_bond(bond)
+
+    tui.ok(f"Exported to: {tui.bold(reg_path.name)}")
+    tui.warn("Keep the device powered ON. Do NOT power-cycle it before importing.")
+
+
+def run_classic_import_flow(reg_file_arg: str | None = None) -> None:
+    """
+    Full Classic import flow (RC5, RC9, RC11):
+    pre-flight → load .reg → check active link → confirm remove →
+    stop BT → remove → write info → set perms → start BT → post-import warnings.
+    """
+    tui.header("Classic Import — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+
+    if env.os_kind != OSKind.LINUX:
+        tui.err("Classic import (write destination) is only supported on Linux.")
+        return
+
+    tui.header("Classic Import — Pre-flight Check")
+    if not tui.warn_classic_preflight():
+        tui.info("Aborted — pre-flight not acknowledged.")
+        return
+
+    tui.header("Classic Import — Step 2: Load bond key")
+    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
+
+    with tui.Spinner(f"Parsing {reg_path.name}…"):
+        bond = load_classic_bond_from_reg_file(reg_path)
+
+    tui.info(bond.summary())
+
+    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()
+
+    tui.header("Classic Import — Step 3: Pre-write checks")
+
+    # RC11: check for active connection before touching bonding state
+    with tui.Spinner(f"Checking if {bond.device_mac} is currently connected…"):
+        is_connected = backend.check_active_link(bond.device_mac)
+
+    if is_connected:
+        tui.warn(f"Device {bond.device_mac} is currently connected!")
+        tui.info("Writing bonding state over an active connection may leave BlueZ inconsistent.")
+        confirm = tui.ask("Proceed anyway? [y/N]", default="N")
+        if confirm.strip().lower() != "y":
+            tui.info("Aborted. Disconnect the device first, then re-run.")
+            return
+
+    # RC5: remove existing bonding folder with explicit user confirmation
+    target_dir = (backend.bluetooth_dir / bond.adapter_mac / bond.device_mac)
+    if target_dir.exists():
+        tui.warn(f"Existing bonding folder found: {target_dir}")
+        tui.info("It must be removed before writing the new Classic bond (RC5).")
+        tui.info("A timestamped backup will be kept automatically.")
+        confirm_rm = tui.ask("Remove existing bonding? [y/N]", default="N")
+        if confirm_rm.strip().lower() != "y":
+            tui.info("Aborted. Existing bonding preserved.")
+            return
+
+    tui.header("Classic Import — Step 4: Write bond to disk")
+
+    with tui.Spinner("Stopping Bluetooth service…"):
+        backend.stop_bluetooth()
+    tui.ok("Bluetooth service stopped.")
+
+    if target_dir.exists():
+        with tui.Spinner(f"Removing {bond.device_mac} bonding folder…"):
+            backend.remove_bond_key(bond.adapter_mac, bond.device_mac)
+        tui.ok("Old bonding removed (backup kept).")
+
+    with tui.Spinner("Disabling discovery scan if active…"):
+        disabled = backend.disable_discovery_if_active()
+    if disabled:
+        tui.info("Discovery scan disabled.")
+
+    with tui.Spinner(f"Writing Classic info for {bond.device_mac}…"):
+        write_dir = backend.bluetooth_dir / bond.adapter_mac / bond.device_mac
+        info_path = backend.write_classic_info(bond, write_dir)
+        backend.set_info_permissions(info_path)
+    tui.ok(f"Written to: {tui.dim(str(info_path))}")
+
+    with tui.Spinner("Starting Bluetooth service…"):
+        backend.start_bluetooth()
+    tui.ok("Bluetooth service started.")
+
+    # RC7: mandatory post-import instructions
+    tui.warn_classic_post_import(bond.device_mac)
+
+    verify_and_connect(backend, bond.device_mac)

actions_classic_extra.py

@@ -0,0 +1,187 @@
+"""
+actions_classic_extra.py
+
+Classic (BR/EDR) Bluetooth verification and cloning workflows.
+Kept in a separate file to adhere to the 200-line limit (AGENTS.md R14).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from platform_detect import OSKind
+import tui_helpers as tui
+import actions_common as common
+from models import LinkKeyBond
+from actions_verify import verify_and_connect
+from exporters.classic_exporter import export_classic_bond
+from backends.offline_windows_classic import extract_classic_bt_keys_from_hive
+
+
+def run_classic_verify_flow() -> None:
+    """Choose a bonded Classic device and attempt connection."""
+    tui.header("Verify & Connect (Classic) — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    if env.os_kind != OSKind.LINUX:
+        tui.err("Verify & Connect is only supported on Linux.")
+        return
+
+    tui.header("Verify & Connect (Classic) — Step 2: Choose device")
+    with tui.Spinner("Scanning bonded Classic devices…"):
+        all_devices = backend.list_devices()
+
+    from actions_classic import _filter_classic_devices
+    classic_devices = _filter_classic_devices(backend, all_devices)
+    if not classic_devices:
+        tui.warn("No Classic (BR/EDR) bonded devices found.")
+        return
+
+    chosen = common.prompt_select_device(classic_devices)
+    if not chosen:
+        tui.info("No device selected.")
+        return
+
+    verify_and_connect(backend, chosen.device_mac)
+
+
+def _load_classic_hive(win_mount: Path | None):
+    """Locate hive, check reged, return Classic bonds list or None."""
+    from backends.offline_windows import reged_available
+    from actions_common import find_windows_system_hive
+    if not reged_available():
+        tui.err("reged not found. Install chntpw (e.g. `sudo apt install chntpw`).")
+        return None
+    hive = find_windows_system_hive(win_mount)
+    if not hive:
+        tui.err("Could not locate the Windows SYSTEM hive on the selected partition.")
+        return None
+    tui.ok(f"Hive: {tui.dim(str(hive))}")
+    with tui.Spinner("Reading Windows registry hive for Classic bonds…"):
+        bonds = extract_classic_bt_keys_from_hive(hive)
+    if not bonds:
+        tui.warn("No Classic (BR/EDR) bonding keys found in the Windows hive.")
+        return None
+    return bonds
+
+
+def _choose_classic_bond(bonds) -> LinkKeyBond | None:
+    """Present a list and return the chosen LinkKeyBond."""
+    for i, b in enumerate(bonds, 1):
+        name = b.device_name or "Unknown Device"
+        print(f"  [{i}]  {tui.bold(name)}  {tui.dim(b.device_mac)}")
+    raw = tui.ask("→ Device number [q to cancel]", default="q")
+    if raw.lower() == "q" or not raw.isdigit() or not (1 <= int(raw) <= len(bonds)):
+        tui.info("Cancelled.")
+        return None
+    return bonds[int(raw) - 1]
+
+
+def _pick_source_classic_bond(source_os: OSKind, win_mount: Path | None, env, backend) -> LinkKeyBond | None:
+    """Extract a Classic bond from the chosen source (local Linux or Windows partition)."""
+    if source_os == OSKind.WINDOWS and env.os_kind == OSKind.LINUX:
+        bonds = _load_classic_hive(win_mount)
+        if not bonds:
+            return None
+        return _choose_classic_bond(bonds)
+
+    with tui.Spinner("Scanning bonded Classic devices…"):
+        all_devices = backend.list_devices()
+    from actions_classic import _filter_classic_devices
+    classic_devices = _filter_classic_devices(backend, all_devices)
+    if not classic_devices:
+        tui.warn("No bonded Classic devices found.")
+        return None
+    source = common.prompt_select_device(classic_devices)
+    if source is None:
+        tui.info("Cancelled.")
+        return None
+    with tui.Spinner(f"Extracting Classic bond for {source.device_mac}…"):
+        bond = backend.extract_classic_bond(source)
+        bond.source_os = source_os.value
+    return bond
+
+
+def run_classic_clone_flow() -> None:
+    """Directly copy/clone a Classic bonding to the destination on Linux."""
+    tui.header("Classic 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
+
+    # RC6: Classic pre-flight safety warning
+    tui.header("Classic Clone — Pre-flight Check")
+    if not tui.warn_classic_preflight():
+        tui.info("Aborted — pre-flight not acknowledged.")
+        return
+
+    tui.header("Classic Clone — Step 2: Choose source")
+    source_os, win_mount = common.prompt_source_os(env.os_kind)
+    bond = _pick_source_classic_bond(source_os, win_mount, env, backend)
+    if bond is None:
+        return
+
+    tui.info(bond.summary())
+    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()
+
+    tui.header("Classic Clone — Step 3: Destination MAC")
+    target_mac = tui.ask("Destination MAC (Enter to keep original)", default=bond.device_mac)
+
+    tui.header("Classic Clone — Step 4: Pre-write checks")
+    # RC11: Check for active connection
+    with tui.Spinner(f"Checking if {target_mac} is currently connected…"):
+        is_connected = backend.check_active_link(target_mac)
+    if is_connected:
+        tui.warn(f"Device {target_mac} is currently connected!")
+        confirm = tui.ask("Proceed anyway? [y/N]", default="N")
+        if confirm.strip().lower() != "y":
+            tui.info("Aborted.")
+            return
+
+    # RC5: confirmation before overwriting
+    target_dir = backend.bluetooth_dir / bond.adapter_mac / target_mac
+    if target_dir.exists():
+        tui.warn(f"Existing bonding folder found: {target_dir}")
+        tui.info("It must be removed before writing (RC5). A backup will be kept.")
+        if tui.ask("Remove existing bonding? [y/N]", default="N").strip().lower() != "y":
+            tui.info("Aborted.")
+            return
+
+    tui.header("Classic Clone — Step 5: Write and restart Bluetooth")
+    with tui.Spinner("Stopping Bluetooth service…"):
+        backend.stop_bluetooth()
+
+    if target_dir.exists():
+        with tui.Spinner(f"Removing {target_mac} bonding folder…"):
+            backend.remove_bond_key(bond.adapter_mac, target_mac)
+
+    with tui.Spinner("Disabling discovery scan if active…"):
+        backend.disable_discovery_if_active()
+
+    with tui.Spinner(f"Writing Classic info for {target_mac}…"):
+        write_dir = backend.bluetooth_dir / bond.adapter_mac / target_mac
+        # Clone with target mac
+        bond_clone = LinkKeyBond(
+            adapter_mac=bond.adapter_mac,
+            device_mac=target_mac,
+            link_key_hex=bond.link_key_hex,
+            key_type=bond.key_type,
+            pin_length=bond.pin_length,
+            device_class=bond.device_class,
+            device_name=bond.device_name,
+            device_id=bond.device_id,
+            service_uuids=bond.service_uuids,
+            source_os=bond.source_os,
+        )
+        info_path = backend.write_classic_info(bond_clone, write_dir)
+        backend.set_info_permissions(info_path)
+
+    with tui.Spinner("Starting Bluetooth service…"):
+        backend.start_bluetooth()
+
+    # RC7: Post-import instructions
+    tui.warn_classic_post_import(target_mac)
+
+    verify_and_connect(backend, target_mac)

actions_clone.py

@@ -0,0 +1,166 @@
+"""
+actions_clone.py
+
+Unified, simplified cloning workflow for BLE, Classic, and Dual-Mode devices.
+Maintains 200-line file limit (AGENTS.md R14).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from platform_detect import OSKind
+import tui_helpers as tui
+import actions_common as common
+from backends import LinuxBluetoothBackend
+from models import BondKey, LinkKeyBond
+from actions_verify import force_push_sync, verify_and_connect
+from actions_clone_loader import UnifiedDevice, load_windows_devices, load_linux_devices
+
+
+def _resolve_target_adapter(backend: LinuxBluetoothBackend, src_adapter_mac: str) -> str | None:
+    """Finds or prompts for the local Linux Bluetooth adapter destination."""
+    local_adapters = backend._list_adapters()
+    if not local_adapters:
+        tui.err("No local Bluetooth adapters found under /var/lib/bluetooth.")
+        return None
+
+    if src_adapter_mac in local_adapters:
+        return src_adapter_mac
+    if len(local_adapters) == 1:
+        target = local_adapters[0]
+        if target.upper() != src_adapter_mac.upper():
+            tui.info(f"Using local adapter: {tui.bold(target)} {tui.dim(f'(source was {src_adapter_mac})')}")
+        return target
+
+    print(f"\n  {tui.bold('Select local destination adapter:')}")
+    for i, ad in enumerate(local_adapters, 1):
+        print(f"    [{i}] {ad}")
+    choice = tui.ask("Adapter number", default="1")
+    if choice.isdigit() and 1 <= int(choice) <= len(local_adapters):
+        return local_adapters[int(choice) - 1]
+    return local_adapters[0]
+
+
+def _write_cloned_keys(backend: LinuxBluetoothBackend, chosen_dev: UnifiedDevice, target_mac: str, target_adapter: str, target_dir: Path) -> None:
+    """Writes Classic and/or BLE keys to BlueZ directory for cloned device."""
+    if chosen_dev.classic_bond:
+        cb = chosen_dev.classic_bond
+        bond_clone = LinkKeyBond(
+            adapter_mac=target_adapter,
+            device_mac=target_mac,
+            link_key_hex=cb.link_key_hex,
+            key_type=cb.key_type,
+            pin_length=cb.pin_length,
+            device_class=cb.device_class,
+            device_name=chosen_dev.name,
+            device_id=cb.device_id,
+            service_uuids=cb.service_uuids,
+            source_os=cb.source_os,
+        )
+        backend.write_classic_info(bond_clone, target_dir)
+
+    if chosen_dev.ble_bond:
+        bb = chosen_dev.ble_bond
+        bond_clone = BondKey(
+            adapter_mac=target_adapter,
+            device_mac=target_mac,
+            ltk_hex=bb.ltk_hex,
+            ediv=bb.ediv,
+            erand=bb.erand,
+            auth_req=bb.auth_req,
+            device_name=chosen_dev.name,
+            source_os=bb.source_os,
+            irk_hex=bb.irk_hex,
+            address_type=bb.address_type,
+            is_le=bb.is_le,
+        )
+        backend.import_bond_key(bond_clone, target_device_mac=target_mac)
+
+    backend.set_info_permissions(target_dir / "info")
+
+
+def run_unified_clone_flow() -> None:
+    """Clones a device from source (Windows/Linux) automatically handling BLE/Classic/Both."""
+    tui.header("Clone Device — Step 1: System detection")
+    env, backend = common.detect_and_validate()
+    if env.os_kind != OSKind.LINUX or not isinstance(backend, LinuxBluetoothBackend):
+        tui.err("Cloning is only supported on Linux.")
+        return
+
+    tui.header("Clone Device — Step 2: Choose source")
+    source_os, win_mount = common.prompt_source_os(env.os_kind)
+    devices = load_windows_devices(win_mount) if source_os == OSKind.WINDOWS else load_linux_devices(backend)
+
+    if not devices:
+        tui.warn("No bonded devices found on the source.")
+        return
+
+    tui.header("Clone Device — Step 3: Choose device")
+    for i, dev in enumerate(devices, 1):
+        print(f"  [{i}]  {dev.summary()}")
+    print()
+
+    choice = tui.ask("Device number [q to cancel]", default="q")
+    if choice.lower() == "q" or not choice.isdigit() or not (1 <= int(choice) <= len(devices)):
+        tui.info("Cancelled.")
+        return
+
+    chosen_dev = devices[int(choice) - 1]
+
+    if chosen_dev.classic_bond:
+        tui.header("Classic/Dual-Mode Pre-flight Warning")
+        tui.warn("This device contains Bluetooth Classic bonding keys.")
+        tui.warn("Classic/Dual-Mode devices usually support only ONE active bonding slot.")
+        tui.info("Make sure the device is powered on, and do NOT put it in pairing mode during/after clone.")
+        if tui.ask("Type 'yes' to proceed", default="").lower() != "yes":
+            tui.info("Aborted.")
+            return
+
+    tui.header("Clone Device — Step 4: Destination MAC & Adapter")
+    target_mac = tui.ask("Destination MAC (Enter to keep original)", default=chosen_dev.mac)
+
+    bond = chosen_dev.ble_bond or chosen_dev.classic_bond
+    if not bond:
+        tui.err("No bonding keys found for this device.")
+        return
+
+    src_adapter = bond.adapter_mac
+    target_adapter = _resolve_target_adapter(backend, src_adapter)
+    if not target_adapter:
+        return
+
+    with tui.Spinner(f"Checking if {target_mac} is currently connected…"):
+        is_connected = backend.check_active_link(target_mac)
+    if is_connected:
+        tui.warn(f"Device {target_mac} is currently connected!")
+        if tui.ask("Proceed anyway? [y/N]", default="N").strip().lower() != "y":
+            tui.info("Aborted.")
+            return
+
+    target_dir = backend.bluetooth_dir / target_adapter / target_mac
+    if target_dir.exists():
+        tui.warn(f"Existing bonding folder found: {target_dir}")
+        if tui.ask("Over-write existing bonding? [y/N]", default="N").strip().lower() != "y":
+            tui.info("Aborted.")
+            return
+
+    tui.header("Clone Device — Step 5: Write and restart Bluetooth")
+    with tui.Spinner("Stopping Bluetooth service…"):
+        backend.stop_bluetooth()
+
+    if target_dir.exists():
+        backend.remove_bond_key(target_adapter, target_mac)
+
+    backend.disable_discovery_if_active()
+
+    with tui.Spinner(f"Writing bonding info for {target_mac}…"):
+        _write_cloned_keys(backend, chosen_dev, target_mac, target_adapter, target_dir)
+
+    with tui.Spinner("Starting Bluetooth service…"):
+        backend.start_bluetooth()
+
+    tui.ok("Bonding successfully cloned!")
+    if chosen_dev.classic_bond:
+        tui.warn_classic_post_import(target_mac)
+
+    force_push_sync(backend, target_mac)