PCM.py

#!/usr/bin/env python3
"""
PCM - Python Connection Manager (GTK3 port)
Ispirato a MobaXterm, sviluppato in Python/GTK3.

Licensed under the European Union Public Licence (EUPL) v1.2
© 2025 - All rights reserved

Dipendenze:
  python3-gi
  gir1.2-gtk-3.0
  gir1.2-vte-2.91
  gir1.2-gtk-vnc-2.0   (VNC integrato nativo)
  python3-paramiko      (SFTP)

FreeBSD equivalenti:
  py311-gobject3  vte3  gtk-vnc  py311-paramiko
"""

import sys
import os
import subprocess
import shutil
import threading
import tempfile
import contextlib
from urllib.parse import urlparse

# ── Controllo dipendenze all'avvio ────────────────────────────────────────────
def _check_deps():
    errors = []
    hints = []

    # Python >= 3.10
    if sys.version_info < (3, 10):
        errors.append(f"Python 3.10+ richiesto (trovato {sys.version.split()[0]})")
        hints.append("Aggiorna Python: https://www.python.org/downloads/")

    # gi / PyGObject
    try:
        import gi as _gi
    except ImportError:
        errors.append("PyGObject (python3-gi) non installato")
        hints.append("  Debian/Ubuntu : sudo apt install python3-gi python3-gi-cairo")
        hints.append("  Arch          : sudo pacman -S python-gobject")
        hints.append("  Fedora        : sudo dnf install python3-gobject")

    if errors:
        _die(errors, hints)

    # GTK 3.0
    try:
        import gi as _gi
        _gi.require_version("Gtk", "3.0")
        from gi.repository import Gtk as _Gtk  # noqa: F401
    except (ValueError, ImportError):
        errors.append("GTK 3.0 non disponibile (gir1.2-gtk-3.0 / typelib-1_0-Gtk-3_0)")
        hints.append("  Debian/Ubuntu : sudo apt install gir1.2-gtk-3.0 libgtk-3-0")
        hints.append("  Arch          : sudo pacman -S gtk3")
        hints.append("  Fedora        : sudo dnf install gtk3")

    # VTE 2.91
    try:
        import gi as _gi
        _gi.require_version("Vte", "2.91")
        from gi.repository import Vte as _Vte  # noqa: F401
    except (ValueError, ImportError):
        errors.append("VTE 2.91 non disponibile (gir1.2-vte-2.91 / typelib-1_0-Vte-2_91)")
        hints.append("  Debian/Ubuntu : sudo apt install gir1.2-vte-2.91 libvte-2.91-0")
        hints.append("  Arch          : sudo pacman -S vte3")
        hints.append("  Fedora        : sudo dnf install vte291")

    if errors:
        _die(errors, hints)


def _die(errors, hints):
    SEP = "═" * 62
    print(f"\n╔{SEP}╗")
    print( "║  PCM — dipendenze mancanti                               ║")
    print(f"╠{SEP}╣")
    for e in errors:
        print(f"║  ✗  {e}")
    if hints:
        print(f"╠{SEP}╣")
        print( "║  Installa le dipendenze mancanti:                        ║")
        for h in hints:
            print(f"║  {h}")
    print(f"╚{SEP}╝\n")
    sys.exit(1)


_check_deps()
# ─────────────────────────────────────────────────────────────────────────────

# PCM è pensato per il tema chiaro: se la sessione desktop esporta
# GTK_THEME=<tema>:dark (o solo ":dark"), quella variabile ha priorità
# più alta di gtk-application-prefer-dark-theme impostata a runtime e
# forzerebbe comunque la variante scura di sistema, illeggibile con i
# nostri colori. Va tolta prima che GTK legga l'ambiente.
_gtk_theme = os.environ.get("GTK_THEME", "")
if _gtk_theme.endswith(":dark") or _gtk_theme.lower() == "dark":
    os.environ.pop("GTK_THEME", None)

import gi
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91")
from gi.repository import Gtk, Gdk, GLib, Gio, Vte

from pcm_logging import get_logger
_log = get_logger("pcm")

# ---------------------------------------------------------------------------
# Moduli PCM (tutti GTK3)
# ---------------------------------------------------------------------------
import config_manager
import translations as _tr
from translations import t
from themes import apply_css
from terminal_widget import TerminalWidget
from session_panel import SessionPanel
from session_dialog import SessionDialog
import protocols
from protocols import refresh_from_plugins as _refresh_protocols
from session_command import build_command, ssh_master_active
from settings_dialog import SettingsDialog
from tunnel_manager import (TunnelManagerDialog, get_active_tunnels, stop_tunnel,
                            reattach_tunnels, get_recent_tunnels, start_tunnel,
                            ensure_tunnel_by_name, pop_died_tunnels)
from vnc_widget import VncWebWidget
from rdp_widget import RdpEmbedWidget
from sftp_browser import SftpBrowserWidget
from winscp_widget import WinScpWidget, FtpWinScpWidget
from log_viewer import LogViewerWidget
from sysmon_widget import SysMonitorWidget
from panel_monitor import InfoPanelWidget
from cron_widget import CronWidget
from sftp_editor import SftpEditorWidget
from snippets_dialog import SnippetsDialog
from welcome_widget import WelcomeWidget
from quick_connect_dialog import QuickConnectDialog
from external_tools_dialog import ExternalToolsDialog
from port_scan_dialog import PortScanDialog
import port_scanner
from plugins.plugin_base import (
    pcm_has_protocol, pcm_build_command, pcm_create_widget,
    pcm_menu_items as _plugin_menu_items,
    pcm_context_actions as _plugin_context_actions,
)
from plugins.plugin_manager import load_plugins as _load_plugins

# ---------------------------------------------------------------------------
# Percorso icone
# ---------------------------------------------------------------------------
_HERE      = os.path.dirname(os.path.abspath(__file__))
_ICONS_DIR = os.path.join(_HERE, "icons")


def _icon_path(name: str) -> str:
    return os.path.join(_ICONS_DIR, name)


def _load_icon(name: str, size: int = 24):
    from gi.repository import GdkPixbuf
    path = _icon_path(name)
    if os.path.isfile(path):
        try:
            return GdkPixbuf.Pixbuf.new_from_file_at_size(path, size, size)
        except Exception as e:
            _log.debug("Icona non caricata '%s': %s", name, e)
    return None


# ===========================================================================
# Finestra principale
# ===========================================================================

def _askpass_autodelete(widget, path, timeout_ms=120000):
    """Elimina lo script SSH_ASKPASS quando il processo termina (o dopo timeout_ms).

    Un timer breve e fisso lo cancellava prima che ssh arrivasse all'autenticazione
    (connessione lenta dopo inattivita'/sospensione): ssh falliva con
    'ssh_askpass: exec(...): No such file or directory'.
    """
    state = {"hid": None, "src": None}

    def _cleanup(*_a):
        if state["hid"] is not None:
            with contextlib.suppress(Exception):
                widget.disconnect(state["hid"])
            state["hid"] = None
        if state["src"] is not None:
            with contextlib.suppress(Exception):
                GLib.source_remove(state["src"])
            state["src"] = None
        with contextlib.suppress(Exception):
            os.unlink(path)
        return False

    def _on_timeout():
        state["src"] = None
        return _cleanup()

    state["hid"] = widget.connect("processo-terminato", _cleanup)
    state["src"] = GLib.timeout_add(timeout_ms, _on_timeout)


class MainWindow(Gtk.ApplicationWindow):

    def __init__(self, app):
        super().__init__(application=app, title=t("app.title"))
        self.set_default_size(1200, 720)
        self.set_position(Gtk.WindowPosition.CENTER)

        _tr.init_from_settings()
        self._settings = config_manager.load_settings()
        config_manager._fix_permissions()
        # Ripulisci eventuali file temporanei residui di un crash precedente.
        with contextlib.suppress(Exception):
            config_manager.cleanup_stale_temp_files()
        self._profili:  dict = {}

        # Icona finestra
        pb = _load_icon("app.png", 64)
        if pb:
            self.set_icon(pb)

        self._build_ui()
        self._connect_signals()
        self._setup_accels()
        self._pannello.aggiorna()

        self._auto_lock_timer = 0
        self._avvia_auto_lock()
        self.connect("key-press-event", lambda w, e: self._reset_auto_lock())
        self.connect("motion-notify-event", lambda w, e: self._reset_auto_lock())

        self._pending_cli_uri: str | None = None   # URI da aprire dopo unlock crypto

        # Avvio a cascata: ogni step richiama il successivo dopo il rendering
        # Sblocco credenziali -> notifica tunnel -> ripristino sessioni
        GLib.idle_add(self._startup_chain, 0)

    # ------------------------------------------------------------------
    # Catena di avvio
    # ------------------------------------------------------------------

    def _startup_chain(self, step: int) -> bool:
        """Esegue la catena di inizializzazione a step:
        0: load plugins, 1: unlock crypto, 2: notifica tunnel, 3: restore sessioni, 4: stato live."""
        if step == 0:
            self._load_pcm_plugins()
            GLib.timeout_add(200, self._startup_chain, 1)
        elif step == 1:
            self._check_crypto_unlock()
            GLib.timeout_add(300, self._startup_chain, 2)
        elif step == 2:
            self._notifica_tunnel_avvio()
            GLib.timeout_add(500, self._startup_chain, 3)
        elif step == 3:
            self._ripristina_sessioni()
            GLib.timeout_add(500, self._startup_chain, 4)
        elif step == 4:
            self._timer_stato_live = GLib.timeout_add(3000, self._aggiorna_stato_live)
        return False  # one-shot per ogni step

    # ------------------------------------------------------------------
    # Sblocco credenziali cifrate
    # ------------------------------------------------------------------

    def _load_pcm_plugins(self):
        """Carica i plugin all'avvio e aggiorna il registro protocolli."""
        try:
            loaded = _load_plugins(confirm=self._confirm_external_plugin)
            if loaded:
                _refresh_protocols()
                self._pannello.aggiorna()
            _log.info("%d plugin caricati", len(loaded))
        except Exception as e:
            _log.warning("Errore caricamento plugin: %s", e)

    def _confirm_external_plugin(self, info, fingerprint: str) -> bool:
        """Ask before executing code supplied outside the PCM package."""
        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.WARNING,
            buttons=Gtk.ButtonsType.YES_NO,
            text="Plugin esterno non ancora autorizzato",
        )
        dlg.format_secondary_text(
            f"Il plugin '{info.name}' ({info.plugin_id}, v{info.version}) "
            f"eseguira codice Python con i privilegi di PCM.\n\n"
            f"Percorso: {info.plugin_path}\n"
            f"Fingerprint SHA-256: {fingerprint}\n\n"
            "Autorizzarlo solo se la sorgente e affidabile?"
        )
        response = dlg.run()
        dlg.destroy()
        return response == Gtk.ResponseType.YES

    def _check_crypto_unlock(self):
        """Chiamato 300ms dopo l'avvio per sbloccare le credenziali cifrate.

        Gestisce due scenari:
        a) crypto.enabled=True + salt in settings  → flusso normale
        b) ENC: trovati nei profili ma settings incompleto → flusso recovery
           (tipico quando si porta connections.json da un'altra installazione)
        """
        try:
            import crypto_manager
            import config_manager as _cm

            already_unlocked = crypto_manager.is_unlocked()
            if already_unlocked:
                return False

            # --- Scenario A: impostazioni crypto complete ---
            if crypto_manager.is_enabled():
                self._esegui_unlock_dialog()
                return False

            # --- Scenario B: ENC: trovati ma settings incompleto ---
            # Controlla se connections.json ha valori cifrati
            profili = _cm.load_profiles()
            # load_profiles() può restituire voci non-dict su errore/corruzione
            # ({"_corrupted": True} / {"_error": ...}): non assumere che lo siano.
            ha_enc = any(
                isinstance(v, dict) and (
                    str(v.get("user", "")).startswith("ENC:") or
                    str(v.get("password", "")).startswith("ENC:")
                )
                for v in profili.values()
            )
            if not ha_enc:
                return False  # nessuna cifratura, niente da fare

            # Ha valori ENC: ma manca la configurazione crypto in settings.
            # Chiedi la password e tenta di recuperare il salt dal vecchio settings.
            s = _cm.load_settings()
            salt_b64 = s.get("crypto", {}).get("salt", "")

            if not salt_b64:
                # Manca il salt: non possiamo decifrare senza il pcm_settings.json originale
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.WARNING,
                    buttons=Gtk.ButtonsType.OK,
                    text=t("crypto.unlock.title"),
                    secondary_text=(
                        "Il file connections.json contiene credenziali cifrate (ENC:…)\n"
                        "ma il file pcm_settings.json non contiene il salt di cifratura.\n\n"
                        "Soluzione: copia il pcm_settings.json originale dalla vecchia installazione\n"
                        "e assicurati che contenga la sezione \"crypto\" con salt, verify ed enabled:true.\n\n"
                        "In alternativa, modifica le sessioni manualmente per reinserire le credenziali."
                    )
                )
                dlg.run()
                dlg.destroy()
                return False

            # Il salt c'è ma enabled=False: ripristiniamo enabled e proviamo
            s["crypto"]["enabled"] = True
            _cm.save_settings(s)
            self._esegui_unlock_dialog()

        except ImportError:
            pass
        return False

    _UNLOCK_MAX_TENTATIVI = 3

    def _esegui_unlock_dialog(self):
        """Mostra il dialog password e sblocca le credenziali.

        Consente fino a _UNLOCK_MAX_TENTATIVI tentativi senza dover
        riavviare l'app: alla password sbagliata il dialog si riapre subito.
        Se l'utente annulla, o esaurisce i tentativi, l'app si chiude
        (senza sblocco le sessioni cifrate sarebbero comunque inutilizzabili)."""
        import crypto_manager
        tentativi = 0

        while tentativi < self._UNLOCK_MAX_TENTATIVI:
            dlg = _CryptoUnlockDialog(parent=self)
            resp = dlg.run()
            pwd  = dlg.get_password()
            dlg.destroy()

            if resp != Gtk.ResponseType.OK:
                self.get_application().quit()
                return

            if pwd and crypto_manager.unlock(pwd):
                self._pannello.aggiorna()
                self._aggiorna_welcome_recenti()
                falliti = config_manager.decrypt_failures()
                if falliti:
                    self._warn(
                        "Impossibile decifrare le credenziali di: " + ", ".join(falliti) +
                        " (token corrotto o chiave non corrispondente)"
                    )
                if self._pending_cli_uri:
                    uri, self._pending_cli_uri = self._pending_cli_uri, None
                    GLib.idle_add(self.apri_da_cli, uri)
                return

            tentativi += 1
            rimanenti = self._UNLOCK_MAX_TENTATIVI - tentativi
            err = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.ERROR,
                buttons=Gtk.ButtonsType.OK,
                text=t("crypto.unlock.wrong_master"),
                secondary_text=(
                    f"Tentativi rimasti: {rimanenti}" if rimanenti > 0
                    else "Troppi tentativi errati: l'applicazione verrà chiusa."
                )
            )
            err.run()
            err.destroy()

        self.get_application().quit()

    # ------------------------------------------------------------------
    # Costruzione UI
    # ------------------------------------------------------------------

    def _avvia_auto_lock(self):
        minuti = self._settings.get("general", {}).get("auto_lock_minutes", 15)
        if minuti <= 0:
            return
        if self._auto_lock_timer:
            GLib.source_remove(self._auto_lock_timer)
        self._auto_lock_timer = GLib.timeout_add_seconds(
            minuti * 60, self._lock_now
        )

    def _reset_auto_lock(self):
        if getattr(self, "_auto_lock_timer", 0):
            GLib.source_remove(self._auto_lock_timer)
            self._auto_lock_timer = 0
        self._avvia_auto_lock()

    def _lock_now(self):
        import crypto_manager
        if crypto_manager.is_enabled() and crypto_manager.is_unlocked():
            crypto_manager.lock()
            _log.info("Cifratura bloccata per inattività")
        self._auto_lock_timer = 0
        return GLib.SOURCE_REMOVE

    def _build_ui(self):
        # Layout radice: headerbar + contenuto
        self._build_headerbar()

        # Paned principale: sidebar | area lavoro
        self._paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned.set_position(240)
        self.add(self._paned)

        # --- Sidebar ---
        self._pannello = SessionPanel()
        self._paned.pack1(self._pannello, False, False)

        # --- Area lavoro destra: paned orizzontale [terminali | pannello info] ---
        self._paned_right = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned.pack2(self._paned_right, True, True)

        right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        self._paned_right.pack1(right_box, True, True)

        self._info_panel = InfoPanelWidget()
        self._info_panel.set_no_show_all(True)
        # shrink=True: l'utente può trascinare il Paned per restringere il pannello
        self._paned_right.pack2(self._info_panel, False, True)

        # Paned terminali: supporta split verticale/orizzontale
        self._paned_term = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned_term.set_wide_handle(True)
        self._paned_term.set_position(99999)  # handle fuori schermo in single mode
        right_box.pack_start(self._paned_term, True, True, 0)

        # Notebook primario (sempre visibile)
        self._notebook = Gtk.Notebook()
        self._notebook.set_scrollable(True)
        self._notebook.set_show_border(False)
        self._notebook.connect("switch-page", self._on_switch_tab)
        self._notebook.connect("button-press-event", self._on_nb_button_press)
        self._paned_term.pack1(self._notebook, True, True)

        # Notebook secondario (split — inizialmente nascosto)
        self._notebook2 = Gtk.Notebook()
        self._notebook2.set_scrollable(True)
        self._notebook2.set_show_border(False)
        self._notebook2.set_no_show_all(True)
        self._notebook2.connect("button-press-event", self._on_nb2_button_press)
        self._notebook2.connect("switch-page", self._on_switch_tab)
        self._paned_term.pack2(self._notebook2, True, True)

        # Quale notebook è attivo (aggiornato da switch-page di entrambi)
        self._notebook_attivo = self._notebook

        # page_widget → Gtk.Label dentro la box del tab (per leggere/scrivere il nome)
        self._tab_labels: dict = {}
        # page_widget → pallino di attività (output/campanello su tab non attiva)
        self._tab_dots: dict = {}

        # page_widget → Gtk.Notebook (lookup O(1) per _trova_in_notebook)
        self._widget_nb_map: dict = {}

        # Barra inferiore: toast notifications + statusbar
        bottom_bar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        bottom_bar.get_style_context().add_class("bottom-bar")

        self._toast_revealer = Gtk.Revealer()
        self._toast_revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP)
        self._toast_revealer.set_transition_duration(250)
        self._toast_label = Gtk.Label()
        self._toast_label.set_xalign(0.0)
        self._toast_label.set_margin_start(12)
        self._toast_label.set_margin_end(12)
        self._toast_label.set_margin_top(4)
        self._toast_label.set_margin_bottom(4)
        self._toast_close_btn = Gtk.Button()
        self._toast_close_btn.set_relief(Gtk.ReliefStyle.NONE)
        self._toast_close_btn.add(Gtk.Image.new_from_icon_name("window-close-symbolic", Gtk.IconSize.MENU))
        self._toast_close_btn.connect("clicked", lambda b: self._nascondi_toast())
        self._toast_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        self._toast_box.pack_start(self._toast_label, True, True, 0)
        self._toast_box.pack_start(self._toast_close_btn, False, False, 0)
        self._toast_revealer.add(self._toast_box)
        self._toast_timer = 0

        self._statusbar = Gtk.Statusbar()
        self._statusbar_ctx = self._statusbar.get_context_id("main")
        self._statusbar.set_hexpand(True)
        bottom_bar.pack_start(self._statusbar, True, True, 0)

        right_box.pack_start(bottom_bar, False, False, 0)
        bottom_bar.pack_start(self._toast_revealer, True, True, 0)

        # Schermata benvenuto (prima tab)
        self._mostra_benvenuto()

    def _build_headerbar(self):
        hb = Gtk.HeaderBar()
        hb.set_show_close_button(True)
        hb.set_title(t("app.title"))
        self.set_titlebar(hb)

        # Pulsante nuova sessione
        btn_new = Gtk.Button()
        btn_new.set_tooltip_text(t("toolbar.session.tooltip"))
        btn_new.add(Gtk.Image.new_from_icon_name("list-add-symbolic", Gtk.IconSize.BUTTON))
        btn_new.connect("clicked", lambda b: self._on_nuova_sessione())
        hb.pack_start(btn_new)

        # Pulsante terminale locale
        btn_term = Gtk.Button()
        btn_term.set_tooltip_text(t("toolbar.local.tooltip"))
        btn_term.add(Gtk.Image.new_from_icon_name("utilities-terminal-symbolic", Gtk.IconSize.BUTTON))
        btn_term.connect("clicked", lambda b: self._on_terminale_locale())
        hb.pack_start(btn_term)

        # Pulsante quick connect
        btn_qc = Gtk.Button()
        btn_qc.set_tooltip_text(t("toolbar.quickconn.tooltip"))
        btn_qc.add(Gtk.Image.new_from_icon_name("go-jump-symbolic", Gtk.IconSize.BUTTON))
        btn_qc.connect("clicked", lambda b: self._on_quick_connect())
        hb.pack_start(btn_qc)

        # Pulsante cluster
        btn_cl = Gtk.Button()
        btn_cl.set_tooltip_text(t("toolbar.cluster.tooltip"))
        btn_cl.add(Gtk.Image.new_from_icon_name("network-workgroup-symbolic", Gtk.IconSize.BUTTON))
        btn_cl.connect("clicked", lambda b: self._on_cluster_from_toolbar())
        hb.pack_start(btn_cl)

        # Pulsante quick search / command palette
        btn_qs = Gtk.Button()
        btn_qs.set_tooltip_text(t("toolbar.quick_switcher.tooltip"))
        btn_qs.add(Gtk.Image.new_from_icon_name("system-search-symbolic", Gtk.IconSize.BUTTON))
        btn_qs.connect("clicked", lambda b: self._on_quick_switcher())
        hb.pack_start(btn_qs)

        # Bottone tunnel unificato: indicatore stato + accesso al gestore
        self._btn_tun_ind = Gtk.MenuButton()
        _tun_box = Gtk.Box(spacing=2)
        self._img_tun = Gtk.Image.new_from_icon_name("network-vpn-symbolic", Gtk.IconSize.BUTTON)
        _tun_box.pack_start(self._img_tun, False, False, 0)
        self._lbl_tun_count = Gtk.Label(label="")
        _tun_box.pack_start(self._lbl_tun_count, False, False, 0)
        self._btn_tun_ind.add(_tun_box)
        self._btn_tun_ind.set_tooltip_text(t("tunnel.indicator_tooltip"))

        self._tun_pop = Gtk.Popover()
        self._tun_pop_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self._tun_pop_box.set_margin_start(8)
        self._tun_pop_box.set_margin_end(8)
        self._tun_pop_box.set_margin_top(8)
        self._tun_pop_box.set_margin_bottom(8)
        self._tun_pop.add(self._tun_pop_box)
        self._tun_pop.connect("show", self._on_tun_pop_show)
        self._btn_tun_ind.set_popover(self._tun_pop)
        hb.pack_start(self._btn_tun_ind)

        self._timer_tun_ind = GLib.timeout_add(3000, self._aggiorna_tun_indicator)
        self._aggiorna_tun_indicator()

        # Pulsante split
        btn_split = Gtk.MenuButton()
        btn_split.set_tooltip_text(t("toolbar.split.tooltip"))
        self._split_img = Gtk.Image.new_from_icon_name("view-dual-symbolic", Gtk.IconSize.BUTTON)
        btn_split.add(self._split_img)
        split_menu = Gtk.Menu()
        self._split_menu_items = []
        self._updating_split_ui = False
        group = None
        for label, cb, mode in [
            (f"□  {t('toolbar.split.single')}",     self._split_singolo, "single"),
            (f"◫  {t('toolbar.split.vertical')}",   self._split_verticale, "vertical"),
            (f"⬒  {t('toolbar.split.horizontal')}", self._split_orizzontale, "horizontal"),
        ]:
            mi = Gtk.RadioMenuItem.new_with_label(group, label)
            group = mi.get_group()
            mi.connect("toggled", lambda w, c=cb, m=mode: self._on_split_toggled(w, c, m))
            split_menu.append(mi)
            self._split_menu_items.append((mi, mode))
        split_menu.show_all()
        btn_split.set_popup(split_menu)
        hb.pack_start(btn_split)
        self._aggiorna_split_indicator("single")

        # Menu applicazione (⋮ tre puntini verticali)
        self._menu_btn = Gtk.MenuButton()
        self._menu_btn.set_direction(Gtk.ArrowType.DOWN)
        self._menu_btn.set_tooltip_text(t("toolbar.menu.tooltip"))
        self._menu_btn.add(Gtk.Image.new_from_icon_name("view-more-symbolic", Gtk.IconSize.BUTTON))
        self._menu_btn.set_popup(self._build_menu())
        hb.pack_end(self._menu_btn)

        # Impostazioni (rotella ⚙)
        btn_set = Gtk.Button()
        btn_set.set_tooltip_text(t("toolbar.settings.tooltip"))
        btn_set.add(Gtk.Image.new_from_icon_name("preferences-system-symbolic", Gtk.IconSize.BUTTON))
        btn_set.connect("clicked", lambda b: self._on_impostazioni())
        hb.pack_end(btn_set)

    def _build_menu(self) -> Gtk.Menu:
        menu = Gtk.Menu()

        def _item(label, callback):
            mi = Gtk.MenuItem(label=label)
            mi.connect("activate", lambda _: callback())
            menu.append(mi)

        _item(t("menu.tools.tunnels"),     self._on_tunnel_manager)
        _item(t("menu.tools.workspaces"),  self._on_workspaces)
        _item(t("menu.tools.broadcast"),   self._on_broadcast)
        _item(t("menu.tools.variables"),   self._on_variabili_globali)
        _item(t("menu.tools.ftp_server"),  self._on_ftp_server)
        _item(t("menu.tools.snippets"),    self._apri_snippet_dialog)
        _item(t("menu.tools.quick_switcher"), self._on_quick_switcher)
        _item(t("menu.tools.import_from"), self._on_importa_sessioni)
        _item(t("menu.file.export_sessions"), self._on_esporta_sessioni)
        _item(t("menu.tools.port_scan"), self._on_port_scan)
        _item(t("menu.tools.audit"),       self._on_audit_log)
        _item(t("menu.tools.keepass"),     self._on_keepass_settings)
        menu.append(Gtk.SeparatorMenuItem())
        for p_label, p_icon, p_callback in _plugin_menu_items():
            _item(p_label, p_callback)
        if _plugin_menu_items():
            menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.tools.crypto"),      self._on_gestione_crypto)
        _item(t("menu.tools.check_deps"),  self._on_check_deps)
        menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.help.guide"),        self._on_guida)
        _item(t("menu.help.about"),        self._on_about)
        menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.file.quit"),         self._on_esci)

        menu.show_all()
        return menu

    # ------------------------------------------------------------------
    # Segnali
    # ------------------------------------------------------------------

    def _connect_signals(self):
        self._pannello.connect("connetti", self._on_connetti)
        self._pannello.connect("nuova",    lambda p: self._on_nuova_sessione())
        self._pannello.connect("nuova-in-gruppo",
                               lambda _p, g: self._on_nuova_sessione(g))
        self._pannello.connect("modifica", self._on_modifica_sessione)
        self._pannello.connect("elimina",  self._on_elimina_sessione)
        self._pannello.connect("duplica",  self._on_duplica_sessione)
        self._pannello.connect("apri-multiplo", lambda p, nomi: self._apri_sessioni_multiple(nomi))
        self._pannello.connect("preferiti-cambiati", lambda p: self._aggiorna_welcome_recenti())
        self._pannello.connect("clona-modifica", self._on_clona_modifica_sessione)
        self._pannello.connect("ping-gruppo",    self._on_ping_gruppo)
        self._pannello.connect("apri-ft",      lambda _p, n, d: self._apri_ft_da_sessione(d))
        self._pannello.connect("ping",         self._on_ping_sessione)
        self._pannello.connect("apri-log",     lambda _p, n, d: self._apri_log_viewer(n, d))
        self._pannello.connect("apri-monitor", lambda _p, n, d: self._apri_sysmon(n, d))
        self._pannello.connect("apri-cron",    lambda _p, n, d: self._apri_cron(n, d))
        self._pannello.connect("apri-cluster", lambda _p, n, d: self._apri_cluster(n, d))
        self._pannello.connect("apri-tools",  lambda _p, n, d: self._apri_external_tools(n, d))
        self.connect("delete-event", self._on_close)
        # Tornando sulla finestra l'urgenza non serve più (i pallini restano).
        self.connect("focus-in-event",
                     lambda *_: (self.set_urgency_hint(False), False)[1])

    def _accel_to_gtk(self, shortcut):
        shortcut = (shortcut or "").strip()
        if not shortcut:
            return None
        # Accetta anche tasti singoli senza modificatori (es. "F11"): prima
        # rsplit("+", 1) restituiva un solo elemento e li scartava in silenzio.
        if "+" in shortcut:
            mods_str, tasto = shortcut.rsplit("+", 1)
            parti_mods = mods_str.split("+")
        else:
            parti_mods, tasto = [], shortcut
        if not tasto:
            return None
        gtk_mods = []
        for m in parti_mods:
            m = m.strip()
            if m in ("Ctrl", "Control"):
                gtk_mods.append("<Primary>")
            elif m == "Shift":
                gtk_mods.append("<Shift>")
            elif m == "Alt":
                gtk_mods.append("<Alt>")
            elif m in ("Super", "Meta"):
                gtk_mods.append("<Super>")
            else:
                return None
        acceleratore = "".join(gtk_mods) + tasto.strip()
        key, mod = Gtk.accelerator_parse(acceleratore)
        if key == 0 and mod == 0:
            return None
        return acceleratore, key, mod

    def _toggle_sidebar(self):
        visibile = self._pannello.get_visible()
        self._pannello.set_visible(not visibile)
        s = config_manager.load_settings()
        s.setdefault("display", {})["sidebar_visible"] = not visibile
        config_manager.save_settings(s)
        return True

    def _toggle_fullscreen(self):
        if hasattr(self, "_fullscreen_active") and self._fullscreen_active:
            self.unfullscreen()
            self._fullscreen_active = False
        else:
            self.fullscreen()
            self._fullscreen_active = True
        return True

    def _setup_accels(self):
        if hasattr(self, "_accel_group") and self._accel_group:
            self.remove_accel_group(self._accel_group)
        ag = Gtk.AccelGroup()
        self.add_accel_group(ag)
        self._accel_group = ag

        mappa_azioni = {
            "new_terminal":   self._on_terminale_locale,
            "new_session":    self._on_nuova_sessione,
            "close_tab":      self._chiudi_tab_corrente,
            "next_tab":       lambda: self._notebook_attivo.next_page() or True,
            "prev_tab":       lambda: self._notebook_attivo.prev_page() or True,
            "find":           self._attiva_ricerca_terminale,
            "quick_switcher": self._on_quick_switcher,
            "toggle_sidebar": self._toggle_sidebar,
            "fullscreen":     self._toggle_fullscreen,
        }

        shortcuts = config_manager.load_settings().get("shortcuts", {})
        for nome, combinazione in shortcuts.items():
            azione = mappa_azioni.get(nome)
            if not azione:
                continue
            risultato = self._accel_to_gtk(combinazione)
            if risultato is None:
                continue
            _, key, mod = risultato
            solo_ctrl = (mod & Gtk.accelerator_get_default_mod_mask()) == Gdk.ModifierType.CONTROL_MASK
            ag.connect(key, mod, Gtk.AccelFlags.VISIBLE,
                       lambda *a, cb=azione, sc=solo_ctrl: self._esegui_accel(cb, sc))

        key_fissa, mod_fissa = Gtk.accelerator_parse("<Primary><Shift>G")
        if key_fissa:
            ag.connect(key_fissa, mod_fissa, Gtk.AccelFlags.VISIBLE,
                       lambda *_: self._on_variabili_globali() or True)

        # Accel per modalità split (Ctrl+Alt+1, Ctrl+Alt+2, Ctrl+Alt+3)
        for _sc, _cb, _m in (
            ("<Primary><Alt>1", self._split_singolo, "single"),
            ("<Primary><Alt>2", self._split_verticale, "vertical"),
            ("<Primary><Alt>3", self._split_orizzontale, "horizontal"),
        ):
            _k, _m_code = Gtk.accelerator_parse(_sc)
            if _k:
                ag.connect(_k, _m_code, Gtk.AccelFlags.VISIBLE,
                           lambda *_, c=_cb, m=_m: (c(), self._aggiorna_split_indicator(m)) or True)

    def _esegui_accel(self, cb, solo_ctrl):
        # Ctrl+lettera semplice appartiene ai programmi nel terminale
        # (nano, bash, vim...): se il focus e' su un VTE lascialo passare.
        if solo_ctrl and isinstance(self.get_focus(), Vte.Terminal):
            return False
        return cb()

    def _attiva_ricerca_terminale(self):
        idx = self._notebook_attivo.get_current_page()
        if idx < 0:
            return True
        page = self._notebook_attivo.get_nth_page(idx)
        if hasattr(page, "mostra_cerca"):
            page.mostra_cerca()
        return True

    def _aggiorna_welcome_recenti(self):
        """Aggiorna la lista recenti nella schermata home dopo lo sblocco crypto."""
        idx = self._notebook.page_num(self._notebook.get_nth_page(0))
        welcome = self._notebook.get_nth_page(0)
        if hasattr(welcome, "aggiorna"):
            welcome.aggiorna()

    def _mostra_benvenuto(self):
        welcome = WelcomeWidget()
        welcome.connect("nuova-sessione",   lambda w: self._on_nuova_sessione())
        welcome.connect("terminale-locale", lambda w: self._on_terminale_locale())
        welcome.connect("apri-sessione",    lambda w, n, d: self._on_connetti(None, n, d))
        welcome.connect("preferiti-cambiati", lambda w: self._pannello.aggiorna())
        welcome.show_all()
        lbl = Gtk.Label(label=t("app.home_tab"))
        self._notebook.append_page(welcome, lbl)

    # ------------------------------------------------------------------
    # Apertura sessioni
    # ------------------------------------------------------------------

    def _on_connetti(self, panel, nome: str, dati: dict):
        # Dopo il blocco automatico il pannello puo' ancora contenere i valori
        # ENC:. Sblocca e ricarica il profilo prima di passarli a un client.
        try:
            import crypto_manager
            if crypto_manager.is_enabled() and not crypto_manager.is_unlocked():
                self._esegui_unlock_dialog()
                if not crypto_manager.is_unlocked():
                    return
                # I dati ricevuti sono stati letti prima dello sblocco (ENC:):
                # ricarica il profilo decifrato.
                fresh = config_manager.load_profiles().get(nome)
                if isinstance(fresh, dict):
                    dati = fresh
        except ImportError:
            self._warn("cryptography non installato; impossibile usare le credenziali cifrate.")
            return

        proto = dati.get("protocol", "ssh")
        pre_cmd = dati.get("pre_cmd", "").strip()
        wol_mac = dati.get("wol_mac", "") if dati.get("wol_enabled") else ""

        if (dati.get("jump_host", "").strip() and
                proto not in ("ssh", "mosh") and
                not self._supports_ssh_gateway(dati)):
            self._warn(
                "SSH gateway supportato solo per SFTP, Telnet, RDP, VNC e SPICE; "
                "FTP/FTPS e i protocolli locali non possono usare un singolo port forwarding."
            )
            return

        config_manager.add_recent(nome, dati)
        self._pannello.aggiorna()
        self._aggiorna_welcome_recenti()

        # La sidebar può contenere un riferimento creato prima dell'ultimo
        # unlock o aggiornamento della cache. Usa il profilo appena ricaricato
        # per evitare di passare a SSH credenziali ancora in formato ENC:.
        profili_correnti = config_manager.load_profiles()
        if nome in profili_correnti:
            dati = dict(profili_correnti[nome])
        else:
            dati = dict(dati)

        if any(str(dati.get(field, "")).startswith("ENC:")
               for field in ("user", "password", "totp_secret")):
            self._warn(
                "Le credenziali della sessione sono ancora cifrate: "
                "sblocca PCM con la password master prima di connetterti."
            )
            return

        use_gateway = self._needs_ssh_gateway(dati)
        tunnel_assoc = (str(dati.get("tunnel", "") or "").strip()
                        if dati.get("tunnel_start") else "")

        if pre_cmd or wol_mac or use_gateway or tunnel_assoc:
            def _bg():
                try:
                    dati_loc = dict(dati)
                    if tunnel_assoc:
                        ok, err = ensure_tunnel_by_name(tunnel_assoc)
                        if not ok:
                            GLib.idle_add(self._warn, f"{t('tunnel.start_failed')} ({tunnel_assoc}): {err}")
                            return
                    if pre_cmd:
                        timeout = dati_loc.get("pre_cmd_timeout", 15)
                        try:
                            import shlex as _shlex_pre
                            subprocess.run(_shlex_pre.split(pre_cmd), shell=False, timeout=timeout)
                        except Exception as e:
                            GLib.idle_add(self._warn, f"Pre-cmd fallito: {e}")
                            return
                    if wol_mac:
                        err = self._invia_wol(wol_mac, dati_loc.get("wol_wait", 20))
                        if err:
                            GLib.idle_add(self._warn, f"WoL fallito: {err}")
                            return
                    if use_gateway:
                        local_port, gw_proc = self._start_ssh_gateway(dati_loc)
                        if local_port is None:
                            GLib.idle_add(self._warn, "SSH gateway fallito: tunnel non stabilito")
                            return
                        dati_loc["_gateway_tunnel"] = gw_proc
                        dati_loc["_gateway_local_port"] = str(local_port)
                        dati_loc["_gateway_target_host"] = dati_loc.get("host", "")
                    GLib.idle_add(self._apri_protocollo, proto, nome, dati_loc)
                except Exception as exc:
                    _log.error("Errore nel thread di connessione (_bg): %s", exc, exc_info=True)
                    GLib.idle_add(self._warn, f"Errore di connessione: {exc}")
            threading.Thread(target=_bg, daemon=True).start()
            return

        self._apri_protocollo(proto, nome, dati)

    def _needs_ssh_gateway(self, dati: dict) -> bool:
        """Check if this connection needs an SSH gateway tunnel."""
        return bool(dati.get("jump_host", "").strip() and
                    self._supports_ssh_gateway(dati))

    @staticmethod
    def _supports_ssh_gateway(dati: dict) -> bool:
        """Return whether one local TCP forward can carry this protocol."""
        proto = dati.get("protocol", "")
        return (proto in ("sftp", "telnet", "rdp", "vnc", "spice") or
                (proto == "file_transfer" and
                 dati.get("ft_protocol", "SFTP").upper() == "SFTP"))

    @staticmethod
    def _apply_ssh_gateway(dati: dict) -> dict:
        """Route a gateway-backed connection through its local TCP forward."""
        local_port = dati.get("_gateway_local_port")
        if not local_port:
            return dati
        forwarded = dict(dati)
        forwarded["host"] = "127.0.0.1"
        forwarded["port"] = str(local_port)
        return forwarded

    def _start_ssh_gateway(self, dati: dict) -> tuple:
        """Start an SSH tunnel to the jump host for gateway access.
        Returns (local_port, process) or (None, None) on failure.
        """
        import socket as _sock
        import time

        jump_host = dati.get("jump_host", "").strip()
        jump_user = dati.get("jump_user", "").strip()
        jump_port = dati.get("jump_port", "22").strip()
        target_host = dati.get("host", "").strip()
        target_port = dati.get("port", "").strip()
        pkey = dati.get("private_key", "").strip()
        pwd = dati.get("password", "")

        local_port = self._find_free_port()
        if local_port is None:
            return None, None

        ssh_exe = shutil.which("ssh") or "ssh"
        strict_default = config_manager.load_settings().get("ssh", {}).get("strict_host_check", False)
        strict = "yes" if dati.get("strict_host", strict_default) else "accept-new"
        cmd = [
            ssh_exe, "-N", "-T",
            "-o", f"StrictHostKeyChecking={strict}",
            "-o", "ConnectTimeout=10",
            "-o", "ServerAliveInterval=15",
            "-o", "ExitOnForwardFailure=yes",
            "-p", jump_port,
        ]
        if pkey and os.path.exists(pkey):
            cmd.extend(["-i", pkey])

        target = f"{jump_user}@{jump_host}" if jump_user else jump_host
        cmd.extend(["-L", f"{local_port}:{target_host}:{target_port}", target])

        env = os.environ.copy()
        askpass = None
        if pwd and not pkey:
            askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
            os.makedirs(askpass_dir, mode=0o700, exist_ok=True)
            if os.stat(askpass_dir).st_uid != os.getuid():
                _log.error("SSH gateway: directory SSH_ASKPASS non di proprieta dell'utente")
                return None, None
            fd, askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=askpass_dir, text=True)
            with os.fdopen(fd, "w") as f:
                # Nessun segreto scritto su disco: lo script legge la password
                # dall'ambiente ereditato dal processo ssh.
                f.write('#!/bin/sh\nprintf \'%s\' "$PCM_ASKPASS_PW"\n')
            os.chmod(askpass, 0o700)
            env["SSH_ASKPASS"] = askpass
            env["SSH_ASKPASS_REQUIRE"] = "force"
            env["PCM_ASKPASS_PW"] = pwd

        try:
            proc = subprocess.Popen(
                cmd, stdin=subprocess.DEVNULL,
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                env=env,
            )

            if askpass:
                def _cleanup_askpass():
                    proc.wait()
                    with contextlib.suppress(OSError):
                        os.unlink(askpass)
                threading.Thread(target=_cleanup_askpass, daemon=True).start()

            for _ in range(60):
                time.sleep(0.1)
                try:
                    s = _sock.create_connection(("127.0.0.1", local_port), timeout=0.5)
                    s.close()
                    return local_port, proc
                except OSError:
                    if proc.poll() is not None:
                        return None, None
            proc.terminate()
            try:
                proc.wait(timeout=2)
            except subprocess.TimeoutExpired:
                proc.kill()
            return None, None
        except Exception:
            if askpass:
                with contextlib.suppress(OSError):
                    os.unlink(askpass)
            return None, None

    def apri_da_cli(self, uri: str):
        """Apre una connessione da URI passato via riga di comando.

        Formati supportati:
          ssh://nome_sessione          — cerca sessione salvata per nome o hostname
          ssh://user@host:port         — connessione ad-hoc
          rdp://host?mode=external     — forza client esterno
          sftp://host / ftp://host     — file transfer
          vnc://host / telnet://host   — altri protocolli

        Query string opzionali (solo connessioni ad-hoc):
          ?mode=external               — apre in terminale/client esterno
          ?terminal=xterm              — emulatore esterno specifico
        """
        _PROTO_MAP = {
            "ssh": "ssh", "telnet": "telnet", "mosh": "mosh", "serial": "serial",
            "rdp": "rdp", "vnc": "vnc",
            "sftp": "file_transfer", "ftp": "file_transfer", "ftps": "file_transfer",
        }
        _DEFAULT_PORTS = {
            "ssh": "22", "telnet": "23", "mosh": "22", "rdp": "3389",
            "vnc": "5900", "file_transfer": "22", "ftp": "21", "ftps": "21",
        }
        _FT_PROTO = {"sftp": "SFTP", "ftp": "FTP", "ftps": "FTPS"}

        # Se crypto è abilitato ma non ancora sbloccato, rimanda dopo l'unlock
        try:
            import crypto_manager
            if crypto_manager.is_enabled() and not crypto_manager.is_unlocked():
                self._pending_cli_uri = uri
                return
        except ImportError:
            _log.warning("cryptography non installato — apertura URI sospesa")
            GLib.idle_add(self._warn, "cryptography non installato; impossibile aprire URI con credenziali cifrate.")

        parsed = urlparse(uri)
        scheme = (parsed.scheme or "ssh").lower()
        proto = _PROTO_MAP.get(scheme)
        if not proto:
            self._warn(f"Protocollo non supportato nella URI: {scheme}")
            return

        host = parsed.hostname or ""
        port = str(parsed.port) if parsed.port else ""
        user = parsed.username or ""
        password = parsed.password or ""

        # Opzioni da query string (solo per connessioni ad-hoc)
        from urllib.parse import parse_qs
        qs = parse_qs(parsed.query)
        mode_ext = qs.get("mode", [""])[0].lower() == "external"
        terminal_ext = qs.get("terminal", [""])[0]

        # --- Cerca sessione salvata ---
        profili = config_manager.load_profiles()
        nome_match = None
        dati_match = None

        # 1. Nome sessione == host nella URI (case-insensitive)
        for nome_s, dati_s in profili.items():
            if nome_s.lower() == host.lower():
                nome_match, dati_match = nome_s, dati_s
                break

        # 2. Hostname + stesso protocollo
        if not dati_match:
            for nome_s, dati_s in profili.items():
                if (dati_s.get("host", "").lower() == host.lower()
                        and dati_s.get("protocol") == proto):
                    nome_match, dati_match = nome_s, dati_s
                    break

        # 3. Hostname qualsiasi protocollo
        if not dati_match:
            for nome_s, dati_s in profili.items():
                if dati_s.get("host", "").lower() == host.lower():
                    nome_match, dati_match = nome_s, dati_s
                    break

        if dati_match:
            dati = dict(dati_match)
            if user:
                dati["user"] = user
            if port:
                dati["port"] = port
            self._on_connetti(None, nome_match, dati)
            return

        # --- Connessione ad-hoc ---
        dati = {
            "protocol": proto,
            "host": host,
            "port": port or _DEFAULT_PORTS.get(proto, ""),
            "user": user,
            "password": password,
        }
        if scheme in _FT_PROTO:
            dati["ft_protocol"] = _FT_PROTO[scheme]
            dati["ftp_tls"] = scheme == "ftps"

        # Modalità apertura per protocollo
        mode = qs.get("mode", [""])[0].lower()   # "external" | "internal" | ""
        if proto in ("ssh", "telnet", "mosh", "serial"):
            if mode in ("external", "internal"):
                dati["ssh_open_mode"] = mode
            if terminal_ext:
                dati["terminal_type"] = terminal_ext
        elif proto == "rdp":
            # default RDP è già "external"; accetta esplicito "internal"
            if mode in ("external", "internal"):
                dati["rdp_open_mode"] = mode
        elif proto == "vnc":
            # vnc_internal=True → viewer embedded, False → client esterno
            if mode == "internal":
                dati["vnc_internal"] = True
            elif mode == "external":
                dati["vnc_internal"] = False

        nome_display = f"{scheme}://{host}"
        self._on_connetti(None, nome_display, dati)

    def _apri_protocollo(self, proto: str, nome: str, dati: dict):
        from datetime import datetime
        _ts_start = datetime.now()
        _status = "ok"
        try:
            dati = self._apply_ssh_gateway(dati)
            handled = True
            # Plugin-based protocols
            if pcm_has_protocol(proto):
                self._apri_protocollo_plugin(proto, nome, dati)
            elif proto in ("ssh", "telnet", "mosh", "serial", "exec"):
                self._apri_terminale(nome, dati)
            elif proto == "sftp" or (proto == "file_transfer" and dati.get("ft_protocol", "SFTP") == "SFTP"):
                self._apri_sftp(nome, dati)
            elif proto in ("ftp", "file_transfer"):
                self._apri_ftp(nome, dati)
            elif proto == "rdp":
                self._apri_rdp(nome, dati)
            elif proto == "vnc":
                self._apri_vnc(nome, dati)
            else:
                # Protocollo sconosciuto: prima non succedeva nulla ma lo stato
                # riportava "connesso" e l'audit registrava un successo.
                handled = False
            if handled:
                self._status(t("status.connected", name=nome))
            else:
                _status = "error"
                self._warn(f"Protocollo non supportato: {proto}")
        except Exception as e:
            _status = "error"
            self._warn(str(e))
        finally:
            _dur = int((datetime.now() - _ts_start).total_seconds())
            config_manager.audit_append({
                "ts":       _ts_start.strftime("%Y-%m-%d %H:%M:%S"),
                "session":  nome,
                "host":     dati.get("_gateway_target_host", dati.get("host", "")),
                "proto":    proto,
                "duration": _dur,
                "status":   _status,
            })

    def _apri_terminale(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        log_dir = dati.get("log_dir", "") if dati.get("log_output") else ""

        cmd, modalita = build_command(dati)

        # Gestione password: feed_child (primario) + SSH_ASKPASS (fallback)
        # feed_child digita la password quando compare il prompt nel VTE (imposta_auto_password).
        # SSH_ASKPASS gestisce il caso in cui SSH non mostra il prompt nel VTE:
        #   OpenSSH ≥ 8.4 + SSH_ASKPASS_REQUIRE=force → auth silenziosa senza prompt visibile.
        #   Old SSH → SSH_ASKPASS ignorato (TTY presente) → feed_child gestisce tutto.
        env_extra = {}
        _initial_askpass = None
        pwd  = dati.get("password", "")
        pkey = dati.get("private_key", "").strip()
        # Multiplexing SSH: se la connessione master esiste gia' non c'e' login,
        # quindi niente password/OTP da digitare (finirebbero in un prompt
        # successivo, ad es. quello di sudo).
        _riusa_master = ssh_master_active(dati)
        if _riusa_master:
            pwd = ""
        if pwd and not pkey:
            # SSH_ASKPASS: script temp in directory privata (non /tmp).
            # La password NON è nel file: passa via variabile d'ambiente.
            _askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
            os.makedirs(_askpass_dir, mode=0o700, exist_ok=True)
            # Verifica che la directory sia di proprietà dell'utente corrente
            if os.stat(_askpass_dir).st_uid != os.getuid():
                self._warn("Attenzione: ~/.cache/pcm non è di proprietà dell'utente corrente. SSH_ASKPASS disabilitato.")
            else:
                _fd, _askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=_askpass_dir, text=True)
                with os.fdopen(_fd, "w") as _f:
                    _f.write('#!/bin/sh\nprintf \'%s\' "$PCM_ASKPASS_PW"\n')
                os.chmod(_askpass, 0o700)
                env_extra["SSH_ASKPASS"] = _askpass
                env_extra["SSH_ASKPASS_REQUIRE"] = "force"   # OpenSSH ≥ 8.4
                env_extra["PCM_ASKPASS_PW"] = pwd
                _initial_askpass = _askpass

        # Modalità terminale ESTERNO: lancia nel terminal emulator scelto
        if modalita and modalita.endswith("_term_ext"):
            term = dati.get("terminal_type", "Terminale Interno")
            if term and term != "Terminale Interno":
                import shlex
                _press_enter_msg = t("term_ext.press_enter")
                inner = cmd + f"; echo ''; read -rp '{_press_enter_msg}' _x"
                inner_q = shlex.quote(inner)
                term_lower = term.lower()
                if "xfce4-terminal" in term_lower:
                    args = [term, f"--command=bash -c {inner_q}"]
                elif "gnome-terminal" in term_lower or "mate-terminal" in term_lower:
                    args = [term, "--", "bash", "-c", inner]
                elif "konsole" in term_lower:
                    args = [term, "-e", "bash", "-c", inner]
                elif "tilix" in term_lower:
                    args = [term, "-e", f"bash -c {inner_q}"]
                elif "alacritty" in term_lower:
                    args = [term, "-e", "bash", "-c", inner]
                elif "kitty" in term_lower or "foot" in term_lower:
                    args = [term, "bash", "-c", inner]
                else:
                    # xterm e generici: -e bash -c CMD
                    args = [term, "-e", "bash", "-c", inner]
                proc_env = None
                if env_extra:
                    proc_env = os.environ.copy()
                    proc_env.update(env_extra)
                try:
                    subprocess.Popen(args,
                                     stdout=subprocess.DEVNULL,
                                     stderr=subprocess.DEVNULL,
                                     env=proc_env)
                except FileNotFoundError:
                    self._warn(t("term_ext.not_found", term=term))
                self._status(t("status.connected_ext", name=nome))
                return

        # Modalità INTERNA: usa TerminalWidget VTE
        widget = TerminalWidget.da_profilo(dati, log_dir=log_dir)
        widget.comando_display   = nome
        widget.comando_originale = cmd
        widget._tipo_sessione    = dati.get("protocol", "ssh")

        # SFTP browser laterale: SSH e Mosh usano direttamente la porta di sessione
        if dati.get("sftp_browser") and dati.get("protocol") in ("ssh", "mosh"):
            paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
            sftp = SftpBrowserWidget(
                dati,
                on_apri_editor=lambda sftp_c, path, n=nome: self._apri_sftp_editor(sftp_c, path, n),
            )
            # Latenza SSH reale riusando la connessione del pannello SFTP.
            widget._latency_probe = sftp.misura_latenza
            paned.pack1(widget, True, True)
            paned.pack2(sftp, False, False)
            paned.set_position(700)
            container = paned
        else:
            container = widget

        container._pcm_dati = dati
        container.show_all()
        self._append_tab(container, nome)
        GLib.idle_add(widget.grab_focus)

        # Primario: feed_child digita la password quando il VTE mostra un prompt
        if pwd and not pkey:
            widget.imposta_auto_password(pwd)

        # TOTP / 2FA: feed_child digita il codice OTP dopo la password
        totp_secret = "" if _riusa_master else dati.get("totp_secret", "").strip()
        if totp_secret:
            try:
                from totp_manager import generate_totp, parse_otpauth, render_uri_to_secret
                # Se è un otpauth:// URI rispetta digits/period/algorithm,
                # altrimenti usa i default RFC 6238.
                parsed_uri = parse_otpauth(totp_secret)
                if parsed_uri:
                    otp_code = generate_totp(
                        parsed_uri["secret"],
                        parsed_uri.get("digits", 6),
                        parsed_uri.get("period", 30),
                        parsed_uri.get("algorithm", "sha1"),
                    )
                else:
                    otp_code = generate_totp(render_uri_to_secret(totp_secret))
                if otp_code:
                    widget.imposta_auto_password(otp_code)
            except Exception as e:
                _log.debug("TOTP fallito per '%s': %s", nome, e)

        expect_rules = dati.get("expect_rules", [])
        if expect_rules:
            widget.imposta_expect(expect_rules)

        widget.avvia(cmd, env_extra=env_extra)
        if _initial_askpass:
            _askpass_autodelete(widget, _initial_askpass)
        widget.connect("processo-terminato",
                       lambda w: self._on_processo_terminato(w))

        if dati.get("auto_reconnect"):
            delay = max(1, int(dati.get("reconnect_delay", 5)))
            _pcm = self
            _cmd, _pwd, _pkey = cmd, pwd, pkey
            _nome = nome
            _has_env_askpass = bool(env_extra.get("SSH_ASKPASS"))

            def _do_reconnect(w=widget):
                for nb in (_pcm._notebook, _pcm._notebook2):
                    _, page = _pcm._trova_in_notebook(nb, w)
                    if page is not None:
                        _pcm._set_tab_nome(page, getattr(page, "_pcm_tab_nome", _nome))
                        break
                _reconnect_env = {}
                if _pwd and not _pkey and _has_env_askpass:
                    _askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
                    os.makedirs(_askpass_dir, mode=0o700, exist_ok=True)
                    _fd, _askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=_askpass_dir, text=True)
                    with os.fdopen(_fd, "w") as _f:
                        _f.write('#!/bin/sh\nprintf \'%s\' "$PCM_ASKPASS_PW"\n')
                    os.chmod(_askpass, 0o700)
                    _reconnect_env["SSH_ASKPASS"] = _askpass
                    _reconnect_env["SSH_ASKPASS_REQUIRE"] = "force"
                    _reconnect_env["PCM_ASKPASS_PW"] = _pwd
                    _askpass_autodelete(w, _askpass)
                w.avvia(_cmd, env_extra=_reconnect_env)
                if _pwd and not _pkey and not ssh_master_active(dati):
                    w.imposta_auto_password(_pwd)
                if _erules:
                    w.imposta_expect(_erules)
                return False

            widget._pcm_reconnect = _do_reconnect
            widget._pcm_reconnect_delay = delay
            _erules = expect_rules

    def _apri_protocollo_plugin(self, proto: str, nome: str, dati: dict):
        """Open a connection for a plugin-provided protocol."""
        self._resolve_credentials(dati)

        widget = pcm_create_widget(proto, dati, self)
        if widget is not None:
            widget._pcm_dati = dati
            container = self._sftp_browser_paned(widget, dati)
            container.show_all()
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
            return

        cmd, modalita = pcm_build_command(proto, dati)
        log_dir = dati.get("log_dir", "") if dati.get("log_output") else ""

        if modalita == "embedded":
            widget = TerminalWidget.da_profilo(dati, log_dir=log_dir)
            widget.comando_display = nome
            widget.comando_originale = cmd
            widget._tipo_sessione = proto
            widget.show_all()
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)

            pwd = dati.get("password", "")
            pkey = dati.get("private_key", "").strip()
            if pwd and not pkey:
                widget.imposta_auto_password(pwd)
            widget.avvia(cmd)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))
        elif modalita == "none":
            self._warn(f"Protocollo '{proto}' non ha comando associato.")
        else:
            self._warn(f"Modalità '{modalita}' non supportata per il protocollo '{proto}'.")

    def _apri_sftp(self, nome: str, dati: dict):
        widget = WinScpWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, nome, lambda: self._chiudi_tab(widget))

    def _apri_ftp(self, nome: str, dati: dict):
        widget = FtpWinScpWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, nome, lambda: self._chiudi_tab(widget))

    def _apri_log_viewer(self, nome: str, dati: dict):
        widget = LogViewerWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Log: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_sysmon(self, nome: str, dati: dict):
        widget = SysMonitorWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Mon: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_cron(self, nome: str, dati: dict):
        widget = CronWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Cron: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_sftp_editor(self, sftp, remote_path: str, session_nome: str = ""):
        fname  = remote_path.rsplit("/", 1)[-1] or remote_path
        label  = f"Edit: {fname}"
        widget = SftpEditorWidget(sftp, remote_path)
        widget.show_all()
        self._append_tab(widget, label, lambda: self._chiudi_tab(widget))

    def _apri_snippet_dialog(self):
        """Apre la libreria snippet; invia al terminale attivo se è un TerminalWidget."""
        nb  = self._notebook_attivo
        idx = nb.get_current_page()
        page = nb.get_nth_page(idx)
        terminal = None
        if isinstance(page, TerminalWidget):
            terminal = page
        elif hasattr(page, "get_child1"):
            c1 = page.get_child1()
            if isinstance(c1, TerminalWidget):
                terminal = c1

        on_invia = None
        if terminal:
            on_invia = lambda cmd: terminal.invia_testo(cmd, sorgente="snippet")

        dlg = SnippetsDialog(parent=self, on_invia=on_invia)
        dlg.run()
        dlg.destroy()

    def _apri_ft_da_sessione(self, dati_ssh: dict):
        dlg = _DialogApriFileTransfer(parent=self, dati_ssh=dati_ssh)
        resp = dlg.run()
        if resp == Gtk.ResponseType.OK:
            dati_ft = dlg.get_dati()
            host = dati_ft.get("host", "")
            ft_proto = dati_ft.get("ft_protocol", "SFTP")
            nome_tab = f"{ft_proto}: {host}"
            if ft_proto == "SFTP":
                self._apri_sftp(nome_tab, dati_ft)
            else:
                self._apri_ftp(nome_tab, dati_ft)
        dlg.destroy()

    def _on_cluster_from_toolbar(self):
        profili = config_manager.load_profiles()
        if not profili:
            self._warn(t("cluster.no_sessions"))
            return
        dlg = _SessionPickerDialog(parent=self, profili=profili)
        resp = dlg.run()
        if resp != Gtk.ResponseType.OK:
            dlg.destroy()
            return
        selected = dlg.get_selected()
        dlg.destroy()
        if not selected:
            return
        self._apri_cluster_multi(selected, profili)

    def _apri_cluster(self, nome: str, dati: dict):
        profili = config_manager.load_profiles()
        self._apri_cluster_multi([nome], profili)

    def _apri_cluster_multi(self, nomi: list[str], profili: dict):
        from cluster_dialog import ClusterDialog
        sessions = {}
        for n in nomi:
            if n in profili:
                sessions[n] = profili[n]
        if not sessions:
            return
        dlg = ClusterDialog(parent=self, sessions=sessions)
        resp = dlg.run()
        if resp != Gtk.ResponseType.OK:
            dlg.destroy()
            return
        cluster_plan = dlg.get_cluster_plan()
        enable_bc = dlg.enable_broadcast()
        delay = dlg.get_delay()
        dlg.destroy()
        self._connect_to_cluster_plan(cluster_plan, delay, enable_bc)

    def _connect_to_cluster_plan(self, plan: dict, delay: float, enable_bc: bool):
        def _worker():
            import time
            connected = 0
            for nome_sessione, hosts_info in plan.items():
                dati = hosts_info.get("dati", {})
                keep_user = hosts_info.get("keep_user", True)
                keep_port = hosts_info.get("keep_port", True)
                for host in hosts_info.get("hosts", []):
                    d = dict(dati)
                    d["host"] = host
                    if not keep_user:
                        d["user"] = ""
                    if not keep_port:
                        d["port"] = ""
                    label = f"{nome_sessione} [{host}]"
                    if connected > 0 and delay > 0:
                        time.sleep(delay)
                    GLib.idle_add(lambda dd=d, l=label: self._on_connetti(None, l, dd))
                    connected += 1
            if enable_bc and connected > 0:
                GLib.idle_add(self._on_broadcast)

        import threading
        threading.Thread(target=_worker, daemon=True).start()

    def _save_cluster(self, name: str, session_names: list[str]):
        s = config_manager.load_settings()
        clusters = s.get("saved_clusters", {})
        clusters[name] = {"sessions": session_names}
        s["saved_clusters"] = clusters
        config_manager.save_settings(s)

    def _load_clusters(self) -> dict:
        return config_manager.load_settings().get("saved_clusters", {})

    def _resolve_credentials(self, dati: dict):
        """Inject user/password/domain from a named credential profile into dati."""
        profile_name = dati.get("credential_profile", "")
        if not profile_name or profile_name == "ask":
            return
        for p in config_manager.load_credential_profiles():
            if p.get("name") == profile_name:
                if p.get("user"):
                    dati["user"] = p["user"]
                if p.get("password"):
                    dati["password"] = p["password"]
                if p.get("domain"):
                    dati["rdp_domain"] = p["domain"]
                return

    def _chiedi_credenziali_rdp(self, nome: str, dati: dict) -> bool:
        """Mostra un dialogo per user/password mancanti. Aggiorna dati in-place.
        Ritorna False se l'utente annulla."""
        user   = dati.get("user", "").strip()
        domain = dati.get("rdp_domain", "").strip()
        pwd    = dati.get("password", "")
        if user and pwd:
            return True  # già tutto presente, nessun dialogo

        host = dati.get("host", "")
        dlg = Gtk.Dialog(
            title=f"Credenziali RDP — {host}",
            transient_for=self,
            modal=True,
            destroy_with_parent=True,
        )
        dlg.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK,     Gtk.ResponseType.OK,
        )
        dlg.set_default_response(Gtk.ResponseType.OK)
        dlg.set_default_size(340, -1)

        warn = Gtk.Label()
        warn.set_markup(
            "<small><i>⚠  Credenziali non complete nel profilo sessione.\n"
            "Completarle qui per accesso diretto, oppure salvarle nella sessione.</i></small>"
        )
        warn.set_xalign(0.0)
        warn.set_line_wrap(True)
        warn.set_margin_start(12)
        warn.set_margin_end(12)
        warn.set_margin_top(10)
        warn.set_margin_bottom(4)
        dlg.get_content_area().add(warn)

        grid = Gtk.Grid(column_spacing=8, row_spacing=6,
                        margin_start=12, margin_end=12,
                        margin_top=4, margin_bottom=8)
        row = 0

        def _row(label_text, widget):
            nonlocal row
            lbl = Gtk.Label(label=label_text, xalign=1.0)
            grid.attach(lbl,    0, row, 1, 1)
            grid.attach(widget, 1, row, 1, 1)
            widget.set_hexpand(True)
            row += 1

        e_user = Gtk.Entry(text=user)
        e_user.set_activates_default(True)
        _row(t("sd.user") + ":", e_user)

        e_domain = Gtk.Entry(text=domain)
        e_domain.set_activates_default(True)
        _row("Domain:", e_domain)

        e_pwd = Gtk.Entry(text=pwd, visibility=False)
        e_pwd.set_activates_default(True)
        _row(t("sd.password") + ":", e_pwd)

        chk_salva = Gtk.CheckButton(label="Salva nel profilo sessione")
        chk_salva.set_margin_start(12)
        chk_salva.set_margin_bottom(8)

        dlg.get_content_area().add(grid)
        dlg.get_content_area().add(chk_salva)
        dlg.show_all()
        resp = dlg.run()
        if resp == Gtk.ResponseType.OK:
            new_user   = e_user.get_text().strip()
            new_domain = e_domain.get_text().strip()
            new_pwd    = e_pwd.get_text()
            dati["user"]       = new_user
            dati["rdp_domain"] = new_domain
            dati["password"]   = new_pwd
            if chk_salva.get_active():
                self._salva_credenziali_sessione(
                    nome, {"user": new_user, "rdp_domain": new_domain, "password": new_pwd}
                )
        dlg.destroy()
        return resp == Gtk.ResponseType.OK

    def _salva_credenziali_sessione(self, nome: str, credenziali: dict):
        try:
            profili = config_manager.load_profiles()
            if nome in profili:
                profili[nome].update(credenziali)
                config_manager.save_profiles(profili)
        except Exception as e:
            self._warn(f"Errore salvataggio credenziali: {e}")

    def _sftp_browser_paned(self, widget, dati: dict):
        """Avvolge widget in Paned con SFTP browser se sftp_browser è attivo.
        Per VNC/RDP usa mon_ssh_port invece della porta di sessione."""
        if not dati.get("sftp_browser"):
            return widget
        sftp_dati = dati
        if dati.get("protocol") in ("vnc", "rdp"):
            sftp_dati = dict(dati)
            sftp_dati["port"] = dati.get("mon_ssh_port", 22)
        paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        sftp = SftpBrowserWidget(
            sftp_dati,
            on_apri_editor=lambda sftp_c, path: self._apri_sftp_editor(sftp_c, path),
        )
        if hasattr(widget, "_latency_probe"):
            widget._latency_probe = sftp.misura_latenza
        paned.pack1(widget, True, True)
        paned.pack2(sftp, False, False)
        paned.set_position(700)
        return paned

    def _find_free_port(self) -> int | None:
        """Find a free TCP port for SSH port forwarding."""
        import socket as _sock
        try:
            s = _sock.socket(_sock.AF_INET, _sock.SOCK_STREAM)
            s.bind(("127.0.0.1", 0))
            port = s.getsockname()[1]
            s.close()
            return port
        except Exception:
            return None

    def _apri_rdp(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        if not self._chiedi_credenziali_rdp(nome, dati):
            return
        open_mode = dati.get("rdp_open_mode", "external")
        if open_mode == "internal":
            widget = RdpEmbedWidget(dati, open_mode="internal")
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
            widget.avvia()
        else:
            # Apre xfreerdp in finestra esterna con output visibile nel tab VTE
            import shlex as _shlex
            from rdp_widget import _build_freerdp_cmd
            cmd_parts = _build_freerdp_cmd(dati)
            cmd_shell  = " ".join(_shlex.quote(p) for p in cmd_parts)
            cmd_display = " ".join(
                p if not p.startswith("/p:") else "/p:****" for p in cmd_parts
            )
            _press = t("term_ext.press_enter")
            pwd = dati.get("password", "")
            env_extra = {}
            if pwd and cmd_parts[0] != "rdesktop":
                # Non mettere la password nell'argv (visibile con ps): la
                # passiamo via variabile d'ambiente e la inviamo su stdin.
                cmd_shell = f"printf '%s\\n' \"$PCM_RDP_PW\" | {cmd_shell}"
                env_extra["PCM_RDP_PW"] = pwd
            full_cmd = f'{cmd_shell}; echo; read -rp "{_press}" _x'
            widget = TerminalWidget.da_profilo(dati)
            widget.comando_display = cmd_display
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)
            widget.avvia(full_cmd, env_extra=env_extra)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))

    def _apri_vnc(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        sftp_enabled = dati.get("sftp_browser", False)

        if dati.get("vnc_internal", False):
            # Viewer integrato
            def _salva_password_vnc(pwd: str):
                """Callback chiamato da VncWebWidget se l'utente sceglie 'salva'."""
                try:
                    profili = config_manager.load_profiles()
                    for gruppo in profili.values():
                        if isinstance(gruppo, dict) and nome in gruppo:
                            gruppo[nome]["password"] = pwd
                            if not config_manager.save_profiles(profili):
                                self._warn(t("sd.save_vnc_password_failed"))
                            return
                    if nome in profili:
                        profili[nome]["password"] = pwd
                        if not config_manager.save_profiles(profili):
                            self._warn(t("sd.save_vnc_password_failed"))
                except Exception as exc:
                    _log.error("Impossibile salvare password VNC: %s", exc)
                    GLib.idle_add(self._warn, t("sd.save_vnc_password_failed"))

            if sftp_enabled:
                # Pannello SFTP differito: aperto solo dopo che VNC è connesso
                # e solo se la porta SSH risponde.
                ssh_host = dati.get("host", "")
                ssh_port = int(dati.get("mon_ssh_port", 22))
                sftp_dati = dict(dati)
                sftp_dati["port"] = ssh_port

                ph_lbl = Gtk.Label(label="In attesa della connessione VNC…")
                ph_lbl.set_valign(Gtk.Align.CENTER)
                ph_lbl.set_halign(Gtk.Align.CENTER)
                ph_lbl.set_line_wrap(True)
                ph_lbl.set_margin_start(8)
                ph_lbl.set_margin_end(8)
                placeholder = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                placeholder.set_size_request(220, -1)
                placeholder.pack_start(ph_lbl, True, True, 0)

                paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)

                def _on_vnc_ready():
                    import socket as _sock
                    ph_lbl.set_text(f"Verifica SSH {ssh_host}:{ssh_port}…")

                    def _probe():
                        try:
                            s = _sock.create_connection((ssh_host, ssh_port), timeout=3)
                            s.close()
                            GLib.idle_add(_ssh_aperta)
                        except OSError:
                            GLib.idle_add(_ssh_chiusa)

                    def _ssh_aperta():
                        sftp = SftpBrowserWidget(
                            sftp_dati,
                            on_apri_editor=lambda c, p: self._apri_sftp_editor(c, p),
                        )
                        paned.remove(placeholder)
                        paned.pack2(sftp, False, False)
                        sftp.show_all()

                    def _ssh_chiusa():
                        ph_lbl.set_markup(
                            f"<small>Porta SSH {ssh_port}\nnon raggiungibile\nsu {ssh_host}</small>"
                        )

                    threading.Thread(target=_probe, daemon=True).start()

                widget = VncWebWidget(
                    host=dati.get("host", ""),
                    port=dati.get("port", "5900"),
                    password=dati.get("password", ""),
                    color_depth=dati.get("vnc_color", 0),
                    quality=dati.get("vnc_quality", 2),
                    on_save_password=_salva_password_vnc,
                    on_vnc_ready=_on_vnc_ready,
                )
                widget.show_all()
                paned.pack1(widget, True, True)
                paned.pack2(placeholder, False, True)
                paned.set_position(700)
                paned.show_all()
                container = paned
            else:
                widget = VncWebWidget(
                    host=dati.get("host", ""),
                    port=dati.get("port", "5900"),
                    password=dati.get("password", ""),
                    color_depth=dati.get("vnc_color", 0),
                    quality=dati.get("vnc_quality", 2),
                    on_save_password=_salva_password_vnc,
                )
                widget.show_all()
                container = widget

            container._pcm_dati = dati
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
        else:
            # Client VNC esterno con output visibile nel tab VTE
            cmd, _ = build_command(dati)
            if not cmd:
                self._warn(t("vnc.unavailable", log=""))
                return
            import shlex as _shlex
            _press = t("term_ext.press_enter")
            full_cmd = f'{cmd}; echo; read -rp "{_press}" _x'
            widget = TerminalWidget.da_profilo(dati)
            widget.comando_display = nome
            widget.show_all()

            if sftp_enabled:
                # Pannello SFTP differito: probe SSH in background senza attendere VNC
                ssh_host = dati.get("host", "")
                ssh_port = int(dati.get("mon_ssh_port", 22))
                sftp_dati = dict(dati)
                sftp_dati["port"] = ssh_port

                ph_lbl = Gtk.Label(label=f"Verifica SSH {ssh_host}:{ssh_port}…")
                ph_lbl.set_valign(Gtk.Align.CENTER)
                ph_lbl.set_halign(Gtk.Align.CENTER)
                ph_lbl.set_line_wrap(True)
                ph_lbl.set_margin_start(8)
                ph_lbl.set_margin_end(8)
                placeholder = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                placeholder.set_size_request(220, -1)
                placeholder.pack_start(ph_lbl, True, True, 0)

                paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
                paned.pack1(widget, True, True)
                paned.pack2(placeholder, False, True)
                paned.set_position(700)
                paned.show_all()
                container = paned

                def _ssh_aperta_ext():
                    sftp = SftpBrowserWidget(
                        sftp_dati,
                        on_apri_editor=lambda c, p: self._apri_sftp_editor(c, p),
                    )
                    paned.remove(placeholder)
                    paned.pack2(sftp, False, False)
                    sftp.show_all()

                def _ssh_chiusa_ext():
                    ph_lbl.set_markup(
                        f"<small>Porta SSH {ssh_port}\nnon raggiungibile\nsu {ssh_host}</small>"
                    )

                def _probe_ext():
                    import socket as _sock
                    try:
                        s = _sock.create_connection((ssh_host, ssh_port), timeout=3)
                        s.close()
                        GLib.idle_add(_ssh_aperta_ext)
                    except OSError:
                        GLib.idle_add(_ssh_chiusa_ext)

                threading.Thread(target=_probe_ext, daemon=True).start()
            else:
                container = widget

            container._pcm_dati = dati
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)
            widget.avvia(full_cmd)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))

    # ------------------------------------------------------------------
    # Tab label con pulsante chiudi
    # ------------------------------------------------------------------

    # ------------------------------------------------------------------
    # Helper label tab
    # ------------------------------------------------------------------

    def _make_tab_label(self, nome: str,
                        on_close) -> "tuple[Gtk.Box, Gtk.Label, Gtk.Button, Gtk.Label]":
        """Crea la box label di un tab con pallino attività + nome + pulsante X."""
        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        dot = Gtk.Label(label="●")
        dot.get_style_context().add_class("tab-attention")
        dot.set_tooltip_text(t("tab.activity_tooltip"))
        dot.set_no_show_all(True)
        dot.hide()
        lbl = Gtk.Label(label=nome)
        btn = Gtk.Button()
        btn.set_relief(Gtk.ReliefStyle.NONE)
        btn.set_focus_on_click(False)
        btn.set_tooltip_text(t("tab.close_session_tooltip"))
        img = Gtk.Image.new_from_icon_name("window-close-symbolic", Gtk.IconSize.MENU)
        btn.add(img)
        btn.connect("clicked", lambda _b: on_close())
        box.pack_start(dot, False, False, 0)
        box.pack_start(lbl, True, True, 0)
        box.pack_start(btn, False, False, 0)
        box.show_all()
        dot.hide()
        return box, lbl, btn, dot

    def _get_tab_nome(self, widget) -> str:
        """Legge il nome del tab da _tab_labels (o stringa vuota per la Home)."""
        lbl = self._tab_labels.get(widget)
        return lbl.get_text() if lbl else ""

    def _set_tab_nome(self, widget, nome: str):
        """Aggiorna il testo del label nel tab."""
        lbl = self._tab_labels.get(widget)
        if lbl:
            lbl.set_text(nome)

    def _rinomina_tab(self, widget):
        """Chiede un nuovo nome e aggiorna il label del tab senza modificare il profilo."""
        nome_attuale = self._get_tab_nome(widget)
        if not nome_attuale:
            return

        dlg = Gtk.Dialog(
            title=t("tab.rename_title"),
            transient_for=self,
            modal=True,
            destroy_with_parent=True,
        )
        area = dlg.get_content_area()
        area.set_spacing(8)
        area.set_margin_start(12)
        area.set_margin_end(12)
        area.set_margin_top(12)
        area.set_margin_bottom(8)

        label = Gtk.Label(label=t("tab.rename_label"))
        label.set_xalign(0.0)
        area.pack_start(label, False, False, 0)

        entry = Gtk.Entry(text=nome_attuale)
        entry.set_activates_default(True)
        entry.select_region(0, -1)
        area.pack_start(entry, False, False, 0)

        dlg.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        dlg.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        dlg.set_default_response(Gtk.ResponseType.OK)
        area.show_all()

        response = dlg.run()
        nuovo_nome = entry.get_text().strip()
        dlg.destroy()

        if response == Gtk.ResponseType.OK and nuovo_nome:
            self._set_tab_nome(widget, nuovo_nome)
            # Nome indipendente dal prefisso temporaneo (↻/✖) usato per lo stato.
            widget._pcm_tab_nome = nuovo_nome
            self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names())

    def _get_open_session_names(self) -> set:
        """Nomi delle sessioni con tab aperta e processo ancora vivo (no ✖)."""
        names = set()
        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                nome = self._get_tab_nome(page)
                if nome and not nome.startswith("✖"):
                    names.add(nome)
        return names

    def _widget_terminale(self, widget):
        """Restituisce il TerminalWidget contenuto nel page widget, se c'è."""
        if isinstance(widget, TerminalWidget):
            return widget
        if hasattr(widget, "get_child1"):
            c1 = widget.get_child1()
            if isinstance(c1, TerminalWidget):
                return c1
        return None

    def _collega_segnali_terminale(self, widget):
        """Collega attività/campanello/titolo remoto di un TerminalWidget."""
        tw = self._widget_terminale(widget)
        if tw is None or getattr(tw, "_pcm_segnali_collegati", False):
            return
        tw._pcm_segnali_collegati = True
        tw.connect("attivita", self._on_terminale_attivita)
        tw.connect("campanello", self._on_terminale_campanello)
        tw.connect("titolo-cambiato", self._on_terminale_titolo)

    def _append_tab(self, widget, nome: str, on_close=None):
        """Aggiunge un tab con label personalizzata (nome + pulsante X)."""
        cb = on_close or (lambda: self._chiudi_tab(widget))
        self._collega_segnali_terminale(widget)
        lbl_box, lbl, btn, dot = self._make_tab_label(nome, cb)
        self._tab_labels[widget] = lbl
        self._tab_dots[widget] = dot
        widget._tab_close_btn = btn
        widget._pcm_tab_nome = nome
        self._widget_nb_map[widget] = self._notebook
        self._notebook.append_page(widget, lbl_box)
        self._notebook.set_tab_reorderable(widget, True)
        self._notebook.set_current_page(self._notebook.get_n_pages() - 1)
        GLib.idle_add(widget.grab_focus)
        GLib.idle_add(lambda: self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names()))

    # ------------------------------------------------------------------
    # Split pannelli
    # ------------------------------------------------------------------

    def _split_singolo(self):
        while self._notebook2.get_n_pages() > 0:
            self._sposta_tab(self._notebook2, self._notebook, 0)
        self._notebook2.hide()
        self._notebook_attivo = self._notebook
        self._paned_term.set_orientation(Gtk.Orientation.HORIZONTAL)
        self._paned_term.set_position(99999)

    def _split_verticale(self):
        self._paned_term.set_orientation(Gtk.Orientation.HORIZONTAL)
        self._notebook2.show()
        alloc = self._paned_term.get_allocation()
        self._paned_term.set_position(max(200, alloc.width // 2))

    def _split_orizzontale(self):
        self._paned_term.set_orientation(Gtk.Orientation.VERTICAL)
        self._notebook2.show()
        alloc = self._paned_term.get_allocation()
        self._paned_term.set_position(max(100, alloc.height // 2))

    def _on_split_toggled(self, widget, cb, mode: str):
        if getattr(self, "_updating_split_ui", False):
            return
        if widget.get_active():
            cb()
            self._aggiorna_split_indicator(mode)

    def _aggiorna_split_indicator(self, mode: str = None):
        if not hasattr(self, "_split_menu_items"):
            return
        if mode is None:
            if not self._notebook2.get_visible():
                mode = "single"
            elif self._paned_term.get_orientation() == Gtk.Orientation.VERTICAL:
                mode = "horizontal"
            else:
                mode = "vertical"
        self._updating_split_ui = True
        try:
            for mi, m in self._split_menu_items:
                mi.set_active(m == mode)
        finally:
            self._updating_split_ui = False
        icons = {
            "single": "window-maximize-symbolic",
            "vertical": "view-dual-symbolic",
            "horizontal": "format-justify-fill-symbolic",
        }
        icon_name = icons.get(mode, "view-dual-symbolic")
        theme = Gtk.IconTheme.get_default()
        if not (theme and theme.has_icon(icon_name)):
            icon_name = "view-dual-symbolic"
        self._split_img.set_from_icon_name(icon_name, Gtk.IconSize.BUTTON)

    def _sposta_tab(self, sorgente: Gtk.Notebook, destinazione: Gtk.Notebook, idx: int):
        """Sposta il tab idx da sorgente a destinazione."""
        if idx < 0 or idx >= sorgente.get_n_pages():
            return
        widget = sorgente.get_nth_page(idx)
        nome   = self._get_tab_nome(widget)
        sorgente.remove_page(idx)
        # Ricrea la label custom per il notebook di destinazione
        lbl_box, lbl, btn, dot = self._make_tab_label(
            nome, lambda: self._chiudi_tab(widget))
        self._tab_labels[widget] = lbl
        self._tab_dots[widget] = dot
        dot.set_visible(getattr(widget, "_pcm_attivita", False))
        widget._tab_close_btn = btn
        if getattr(widget, "_pcm_pinned", False):
            btn.set_visible(False)
        self._widget_nb_map[widget] = destinazione
        destinazione.append_page(widget, lbl_box)
        destinazione.set_tab_reorderable(widget, True)
        destinazione.set_current_page(destinazione.get_n_pages() - 1)
        if destinazione is self._notebook2:
            self._notebook2.show()
        if sorgente is self._notebook2 and sorgente.get_n_pages() == 0:
            self._notebook2.hide()
            self._notebook_attivo = self._notebook
            self._aggiorna_split_indicator("single")

    def _toggle_pin_tab(self, widget, notebook: Gtk.Notebook):
        """Fissa o sblocca la scheda selezionata (tab pinning)."""
        pinned = getattr(widget, "_pcm_pinned", False)
        new_pinned = not pinned
        widget._pcm_pinned = new_pinned
        nome = self._get_tab_nome(widget)
        btn = getattr(widget, "_tab_close_btn", None)
        if new_pinned:
            if not nome.startswith("📌 "):
                self._set_tab_nome(widget, f"📌 {nome}")
            if btn:
                btn.set_visible(False)
            first_idx = 1 if notebook is self._notebook else 0
            notebook.reorder_child(widget, first_idx)
        else:
            if nome.startswith("📌 "):
                self._set_tab_nome(widget, nome[2:].lstrip())
            if btn:
                btn.set_visible(True)

    def _menu_tab(self, notebook, idx, event):
        """Menu tasto destro su un tab."""
        if idx < 0:
            return
        menu = Gtk.Menu()
        altra = self._notebook2 if notebook is self._notebook else self._notebook

        mi_sposta = Gtk.MenuItem(label=t("tab.move_to_other"))
        mi_sposta.connect("activate", lambda _: self._sposta_tab(notebook, altra, idx))
        menu.append(mi_sposta)

        page = notebook.get_nth_page(idx)
        is_pinned = getattr(page, "_pcm_pinned", False)
        mi_pin = Gtk.MenuItem(label=t("tab.unpin") if is_pinned else t("tab.pin"))
        mi_pin.connect("activate", lambda _: self._toggle_pin_tab(page, notebook))
        menu.append(mi_pin)

        dati_tab = getattr(page, "_pcm_dati", None)
        if dati_tab and dati_tab.get("protocol") in ("ssh", "telnet", "mosh", "serial"):
            menu.append(Gtk.SeparatorMenuItem())
            mi_ft = Gtk.MenuItem(label=t("tab.open_ft_here"))
            mi_ft.connect("activate", lambda _b, d=dati_tab: self._apri_ft_da_sessione(d))
            menu.append(mi_ft)

        if dati_tab and dati_tab.get("protocol") == "ssh":
            nome_tab = self._get_tab_nome(page)
            mi_log = Gtk.MenuItem(label=t("panel.apri_log"))
            mi_log.connect("activate",
                           lambda _b, n=nome_tab, d=dati_tab: self._apri_log_viewer(n, d))
            menu.append(mi_log)
            mi_mon = Gtk.MenuItem(label=t("panel.apri_monitor"))
            mi_mon.connect("activate",
                           lambda _b, n=nome_tab, d=dati_tab: self._apri_sysmon(n, d))
            menu.append(mi_mon)
            mi_cron = Gtk.MenuItem(label=t("panel.apri_cron"))
            mi_cron.connect("activate",
                            lambda _b, n=nome_tab, d=dati_tab: self._apri_cron(n, d))
            menu.append(mi_cron)

        if dati_tab:
            nome_tab = self._get_tab_nome(page)
            menu.append(Gtk.SeparatorMenuItem())
            mi_rename = Gtk.MenuItem(label=t("tab.rename"))
            mi_rename.connect("activate", lambda _b, w=page: self._rinomina_tab(w))
            menu.append(mi_rename)
            mi_dup = Gtk.MenuItem(label=t("tab.duplicate"))
            mi_dup.connect(
                "activate",
                lambda _b, d=dati_tab, n=nome_tab: self._apri_protocollo(d.get("protocol", "ssh"), n, dict(d)),
            )
            menu.append(mi_dup)

        menu.append(Gtk.SeparatorMenuItem())

        mi_chiudi = Gtk.MenuItem(label=t("tab.close"))
        mi_chiudi.connect("activate", lambda _: self._chiudi_tab(notebook.get_nth_page(idx)))
        menu.append(mi_chiudi)

        mi_chiudi_altre = Gtk.MenuItem(label=t("tab.close_others"))
        mi_chiudi_altre.connect("activate", lambda _: self._chiudi_altre_schede(notebook, page))
        menu.append(mi_chiudi_altre)

        mi_chiudi_destra = Gtk.MenuItem(label=t("tab.close_right"))
        mi_chiudi_destra.connect("activate", lambda _: self._chiudi_schede_a_destra(notebook, page))
        menu.append(mi_chiudi_destra)

        menu.show_all()
        menu.popup_at_pointer(event)

    def _chiudi_altre_schede(self, notebook: Gtk.Notebook, target_page: Gtk.Widget):
        """Chiude tutte le schede del notebook tranne quella selezionata (e la welcome page)."""
        pagine = [notebook.get_nth_page(i) for i in range(notebook.get_n_pages())]
        for p in pagine:
            if p is target_page:
                continue
            if notebook is self._notebook and notebook.page_num(p) == 0:
                continue
            if getattr(p, "_pcm_pinned", False):
                continue
            self._chiudi_tab(p)

    def _chiudi_schede_a_destra(self, notebook: Gtk.Notebook, target_page: Gtk.Widget):
        """Chiude tutte le schede a destra della scheda selezionata."""
        target_idx = notebook.page_num(target_page)
        if target_idx < 0:
            return
        pagine = [notebook.get_nth_page(i) for i in range(notebook.get_n_pages())]
        for p in pagine:
            curr_idx = notebook.page_num(p)
            if curr_idx > target_idx:
                if getattr(p, "_pcm_pinned", False):
                    continue
                self._chiudi_tab(p)

    def _on_nb_button_press(self, nb, event):
        if event.button != 3:
            return False
        # Trova su quale tab è il click
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            lbl  = nb.get_tab_label(page)
            if lbl and lbl.get_window():
                alloc = lbl.get_allocation()
                x, y  = lbl.translate_coordinates(nb, 0, 0)
                if x <= event.x <= x + alloc.width and y <= event.y <= y + alloc.height:
                    if i > 0:  # non mostrare menu su Home
                        self._menu_tab(nb, i, event)
                    return True
        return False

    def _on_nb2_button_press(self, nb, event):
        if event.button != 3:
            return False
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            lbl  = nb.get_tab_label(page)
            if lbl and lbl.get_window():
                alloc = lbl.get_allocation()
                x, y  = lbl.translate_coordinates(nb, 0, 0)
                if x <= event.x <= x + alloc.width and y <= event.y <= y + alloc.height:
                    self._menu_tab(nb, i, event)
                    return True
        return False

    def _trova_in_notebook(self, nb: "Gtk.Notebook", widget) -> "tuple[int, object]":
        """Cerca widget (o il Paned che lo contiene) in nb.
        Usa _widget_nb_map per lookup O(1); fallback su iterazione per compatibilità.
        Ritorna (idx, page_widget) se trovato, (-1, widget) altrimenti."""
        mapped_nb = self._widget_nb_map.get(widget)
        if mapped_nb is not None and mapped_nb is nb:
            idx = nb.page_num(widget)
            if idx >= 0:
                return idx, widget
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            if page is widget:
                return i, widget
            if hasattr(page, "get_child1"):
                if page.get_child1() is widget or page.get_child2() is widget:
                    return i, page
        return -1, widget

    def _chiudi_tab_corrente(self):
        """Chiude la tab corrente nel notebook attivo (primo o secondo pannello)."""
        nb  = self._notebook_attivo
        idx = nb.get_current_page()
        # Non chiudere la Home (sempre idx 0 nel notebook primario)
        if nb is self._notebook and idx <= 0:
            return
        widget = nb.get_nth_page(idx)
        if widget:
            self._chiudi_tab(widget)

    def _chiudi_tab(self, widget):
        """Chiude la tab che contiene widget (cerca in entrambi i notebook)."""
        nb = None
        idx = -1
        for candidate in (self._notebook, self._notebook2):
            idx, widget = self._trova_in_notebook(candidate, widget)
            if idx >= 0:
                nb = candidate
                break
        if idx < 0 or nb is None:
            return

        # Conferma se la scheda è fissata
        if getattr(widget, "_pcm_pinned", False):
            _nome_fissata = self._get_tab_nome(widget).lstrip("📌 ")
            dlg_pin = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.QUESTION,
                buttons=Gtk.ButtonsType.YES_NO,
                text=t("tab.close_pinned_title"),
            )
            dlg_pin.format_secondary_text(t("tab.close_pinned_msg", name=_nome_fissata))
            resp_pin = dlg_pin.run()
            dlg_pin.destroy()
            if resp_pin != Gtk.ResponseType.YES:
                return

        # --- Conferma chiusura se processo attivo ---
        # Trova il TerminalWidget (direttamente o dentro un Paned)
        _term_widget = None
        if hasattr(widget, "_pid"):
            _term_widget = widget
        elif hasattr(widget, "get_child1"):
            for _child in [widget.get_child1(), widget.get_child2()]:
                if _child and hasattr(_child, "_pid"):
                    _term_widget = _child
                    break

        if _term_widget is not None and getattr(_term_widget, "_pid", -1) > 0:
            # Legge l'impostazione dal profilo della sessione
            _dati = getattr(widget, "_pcm_dati", None) or getattr(_term_widget, "_pcm_dati", None)
            _confirm = True  # default: chiedi conferma
            if _dati is not None:
                _confirm = _dati.get("term_confirm_close", True)
            if _confirm:
                _nome_tab = self._get_tab_nome(widget)
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.QUESTION,
                    buttons=Gtk.ButtonsType.YES_NO,
                    text=t("tab.close_confirm_title"),
                )
                dlg.format_secondary_text(
                    t("tab.close_confirm_msg", name=_nome_tab) if _nome_tab
                    else t("tab.close_confirm_msg", name="?")
                )
                resp = dlg.run()
                dlg.destroy()
                if resp != Gtk.ResponseType.YES:
                    return  # l'utente ha annullato

        # Cleanup processo gateway SSH (tunnel per RDP/VNC tramite jump host)
        _dati = getattr(widget, "_pcm_dati", None)
        if _dati and _dati.get("_gateway_tunnel"):
            try:
                _dati["_gateway_tunnel"].terminate()
            except Exception as e:
                _log.debug("Terminazione gateway tunnel fallita: %s", e)

        # Cleanup processi
        def _cleanup_widget(w):
            if not w:
                return
            if hasattr(w, "chiudi_processo"):
                try:
                    w.chiudi_processo()
                except Exception as e:
                    _log.debug("chiudi_processo fallito su %s: %s", w, e)
            elif hasattr(w, "chiudi"):
                try:
                    w.chiudi()
                except Exception as e:
                    _log.debug("chiudi fallito su %s: %s", w, e)
            if hasattr(w, "get_child1"):
                _cleanup_widget(w.get_child1())
                _cleanup_widget(w.get_child2())

        _cleanup_widget(widget)
        # Cleanup timer di riconnessione
        if hasattr(widget, "_pcm_reconnect_timer"):
            try:
                GLib.source_remove(widget._pcm_reconnect_timer)
            except Exception as e:
                _log.debug("Rimozione timer riconnessione fallita: %s", e)
        nb.remove_page(idx)
        self._tab_labels.pop(widget, None)
        self._tab_dots.pop(widget, None)
        self._widget_nb_map.pop(widget, None)
        if not any(d.get_visible() for d in self._tab_dots.values()):
            self.set_urgency_hint(False)
        if nb is self._notebook2 and nb.get_n_pages() == 0:
            self._notebook2.hide()
            self._notebook_attivo = self._notebook
            self._aggiorna_split_indicator("single")
        self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names())

    def _on_processo_terminato(self, widget, tab_label=None):
        """Marca la tab come terminata. Se auto_reconnect, programma riconnessione."""
        for nb in (self._notebook, self._notebook2):
            idx, page = self._trova_in_notebook(nb, widget)
            if idx >= 0:
                nome = self._get_tab_nome(page)
                reconnect = getattr(widget, "_pcm_reconnect", None)
                if reconnect:
                    delay = getattr(widget, "_pcm_reconnect_delay", 5)
                    nome_clean = nome.lstrip("↻✖ ") if nome else ""
                    self._set_tab_nome(page, f"↻ {nome_clean} ({delay}s)")
                    widget._pcm_reconnect_timer = GLib.timeout_add(delay * 1000, reconnect)
                else:
                    if nome and not nome.startswith("✖"):
                        self._set_tab_nome(page, f"✖ {nome}")
                self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names())
                return

    # ------------------------------------------------------------------
    # Azioni menu / toolbar
    # ------------------------------------------------------------------

    def _on_nuova_sessione(self, gruppo: str = ""):
        # Evita di costruire il dialogo con credenziali ancora cifrate: in
        # quel caso il caricamento dei profili credenziali non è possibile.
        try:
            import crypto_manager
            if crypto_manager.is_enabled() and not crypto_manager.is_unlocked():
                self._esegui_unlock_dialog()
                if not crypto_manager.is_unlocked():
                    return
        except ImportError:
            pass

        try:
            dlg = SessionDialog(parent=self, gruppo=gruppo)
        except Exception as exc:
            _log.error("Impossibile aprire il dialogo nuova sessione: %s",
                       exc, exc_info=True)
            self._warn(t("sd.open_error", error=str(exc)))
            return
        resp = dlg.run()
        if resp == Gtk.ResponseType.CANCEL:
            dlg.destroy()
            return
        nome, dati = dlg.get_data()
        profili = config_manager.load_profiles()
        profili[nome] = dati
        config_manager.save_profiles(profili)
        self._pannello.aggiorna(profili)
        dlg.destroy()
        if resp in (100, 101):
            from session_panel import SessionPanel
            self._on_connetti(None, nome, dati)

    def _on_terminale_locale(self):
        # Usa tutte le impostazioni globali del terminale (tema, font,
        # dimensione, scrollback, encoding, bell, warn_paste, paste destro).
        s = config_manager.load_settings().get("terminal", {})
        log_dir = s.get("log_dir", "") if s.get("log_output") else ""
        widget = TerminalWidget.da_impostazioni(log_dir=log_dir)
        widget.show_all()
        self._append_tab(widget, "Locale", lambda: self._chiudi_tab(widget))
        widget.avvia_locale()

    def _on_modifica_sessione(self, panel, nome: str, dati: dict):
        dlg = SessionDialog(parent=self, nome=nome, dati=dati)
        resp = dlg.run()
        if resp == Gtk.ResponseType.CANCEL:
            dlg.destroy()
            return
        nuovo_nome, nuovi_dati = dlg.get_data()
        if dati.get("favorite"):
            nuovi_dati["favorite"] = True
        profili = config_manager.load_profiles()
        if nome != nuovo_nome and nome in profili:
            del profili[nome]
        profili[nuovo_nome] = nuovi_dati
        config_manager.save_profiles(profili)
        self._pannello.aggiorna(profili)
        dlg.destroy()
        if resp in (100, 101):
            self._on_connetti(None, nuovo_nome, nuovi_dati)

    def _on_elimina_sessione(self, panel, nome: str):
        profili = config_manager.load_profiles()
        if nome in profili:
            del profili[nome]
            config_manager.save_profiles(profili)
            self._pannello.aggiorna(profili)
        else:
            self._pannello.aggiorna()

    def _on_duplica_sessione(self, panel, nome: str):
        profili = config_manager.load_profiles()
        if nome in profili:
            nuovo_nome = f"{nome} (copia)"
            profili[nuovo_nome] = dict(profili[nome])
            profili[nuovo_nome].pop("favorite", None)
            config_manager.save_profiles(profili)
            self._pannello.aggiorna(profili)
        else:
            self._pannello.aggiorna()

    def _on_clona_modifica_sessione(self, panel, nome: str, dati: dict):
        nuovo_nome = f"{nome} (copia)"
        nuovi_dati = dict(dati)
        nuovi_dati.pop("favorite", None)
        dlg = SessionDialog(parent=self, nome=nuovo_nome, dati=nuovi_dati)
        resp = dlg.run()
        if resp == Gtk.ResponseType.CANCEL:
            dlg.destroy()
            return
        salvato_nome, salvato_dati = dlg.get_data()
        profili = config_manager.load_profiles()
        profili[salvato_nome] = salvato_dati
        config_manager.save_profiles(profili)
        self._pannello.aggiorna(profili)
        dlg.destroy()
        if resp in (100, 101):
            self._on_connetti(None, salvato_nome, salvato_dati)

    def _on_ping_gruppo(self, panel, gruppo: str):
        from group_health_dialog import GroupHealthDialog
        dlg = GroupHealthDialog(parent=self, gruppo=gruppo)
        dlg.run()
        dlg.destroy()

    def _on_esporta_sessioni(self):
        from export_dialog import ExportDialog
        dlg = ExportDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _apri_sessioni_multiple(self, nomi: list):
        """Apre piu' sessioni in sequenza (salta quelle già aperte)."""
        # Sblocca una volta sola: altrimenti ogni apertura aprirebbe un suo dialogo
        try:
            import crypto_manager
            if crypto_manager.is_enabled() and not crypto_manager.is_unlocked():
                self._esegui_unlock_dialog()
                if not crypto_manager.is_unlocked():
                    return
        except ImportError:
            pass
        profili = config_manager.load_profiles()
        gia_aperte = {n.lstrip("📌↻✖ ") for n in self._get_open_session_names()}
        da_aprire = [n for n in nomi if n in profili and n not in gia_aperte]
        for i, nome in enumerate(da_aprire):
            def _apri(n=nome):
                self._on_connetti(None, n, dict(config_manager.load_profiles().get(n, {})))
                return False
            GLib.timeout_add(i * 250, _apri)

    def _on_workspaces(self):
        """Dialog per salvare le sessioni aperte come workspace e riaprirle."""
        dlg = Gtk.Dialog(title=t("workspace.title"), transient_for=self, modal=True)
        dlg.set_default_size(420, 360)
        area = dlg.get_content_area()
        area.set_spacing(8)
        for side in ("start", "end", "top", "bottom"):
            getattr(area, f"set_margin_{side}")(12)

        store = Gtk.ListStore(str, str)
        view = Gtk.TreeView(model=store)
        view.set_headers_visible(False)
        view.append_column(Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=1))
        sc = Gtk.ScrolledWindow()
        sc.set_vexpand(True)
        sc.add(view)
        area.pack_start(sc, True, True, 0)

        def _ricarica():
            store.clear()
            for nome, sess in sorted(config_manager.load_workspaces().items()):
                store.append([nome, f"{nome}  ({len(sess)})"])

        def _sel():
            model, it = view.get_selection().get_selected()
            return model.get_value(it, 0) if it else None

        def _apri(*_):
            nome = _sel()
            if nome:
                dlg.destroy()
                self._apri_sessioni_multiple(config_manager.load_workspaces().get(nome, []))

        def _elimina(*_):
            nome = _sel()
            if nome:
                config_manager.delete_workspace(nome)
                _ricarica()

        def _salva(*_):
            nome = entry.get_text().strip()
            profili = config_manager.load_profiles()
            aperte = sorted({n.lstrip("📌↻✖ ") for n in self._get_open_session_names()}
                            & set(profili))
            if not nome:
                return
            if not aperte:
                self._warn(t("workspace.no_open"))
                return
            config_manager.save_workspace(nome, aperte)
            entry.set_text("")
            _ricarica()

        view.connect("row-activated", _apri)
        row = Gtk.Box(spacing=6)
        btn_apri = Gtk.Button(label=t("workspace.open"))
        btn_apri.connect("clicked", _apri)
        btn_del = Gtk.Button(label=t("workspace.delete"))
        btn_del.connect("clicked", _elimina)
        row.pack_start(btn_apri, False, False, 0)
        row.pack_start(btn_del, False, False, 0)
        area.pack_start(row, False, False, 0)

        area.pack_start(Gtk.Separator(), False, False, 0)
        save_row = Gtk.Box(spacing=6)
        entry = Gtk.Entry()
        entry.set_placeholder_text(t("workspace.name_ph"))
        entry.connect("activate", _salva)
        btn_salva = Gtk.Button(label=t("workspace.save_open"))
        btn_salva.connect("clicked", _salva)
        save_row.pack_start(entry, True, True, 0)
        save_row.pack_start(btn_salva, False, False, 0)
        area.pack_start(save_row, False, False, 0)

        dlg.add_button(t("tunnel.btn_close"), Gtk.ResponseType.CLOSE)
        _ricarica()
        dlg.show_all()
        dlg.run()
        dlg.destroy()

    def _on_tunnel_manager(self):
        dlg = TunnelManagerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _apri_external_tools(self, nome: str, dati: dict):
        dlg = ExternalToolsDialog(self, dati, nome)
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # Indicatore tunnel attivi nella toolbar
    # ------------------------------------------------------------------

    def _notifica_tunnel_avvio(self) -> bool:
        """Chiamato 1s dopo l'avvio: riaggancia i tunnel con PID persistito e mostra notifica."""
        def _worker():
            # reattach_tunnels() scansiona /proc: eseguilo fuori dal main loop.
            reattach_tunnels()  # popola _active_procs dai PID salvati nella config
            attivi = get_active_tunnels()
            if attivi:
                nomi = ", ".join(tun.get("nome", "?") for tun in attivi)
                msg = t("tunnel.startup_found").format(n=len(attivi)) + f": {nomi}"
                GLib.idle_add(self._status, msg)
        threading.Thread(target=_worker, daemon=True).start()
        return False  # esegui una volta sola

    def _aggiorna_tun_indicator(self) -> bool:
        attivi = get_active_tunnels()
        morti = pop_died_tunnels()
        if morti:
            self._status(t("tunnel.died").format(names=", ".join(morti)))
        n = len(attivi)
        self._lbl_tun_count.set_text(str(n) if n > 0 else "")
        if n > 0:
            tip_key = "tunnel.indicator_tooltip_active1" if n == 1 else "tunnel.indicator_tooltip_activeN"
            self._btn_tun_ind.set_tooltip_text(t(tip_key).format(n=n))
            self._img_tun.get_style_context().add_class("tunnel-active")
            self._lbl_tun_count.get_style_context().add_class("tunnel-active")
        else:
            self._btn_tun_ind.set_tooltip_text(t("tunnel.indicator_tooltip"))
            self._img_tun.get_style_context().remove_class("tunnel-active")
            self._lbl_tun_count.get_style_context().remove_class("tunnel-active")
        return True  # mantieni il timer

    def _on_tun_pop_show(self, popover):
        for w in self._tun_pop_box.get_children():
            w.destroy()

        attivi = get_active_tunnels()

        hdr = Gtk.Label()
        hdr.set_markup(f"<b>{t('tunnel.indicator_header')}</b>")
        hdr.set_halign(Gtk.Align.START)
        self._tun_pop_box.pack_start(hdr, False, False, 0)
        self._tun_pop_box.pack_start(Gtk.Separator(), False, False, 0)

        if not attivi:
            self._tun_pop_box.pack_start(
                Gtk.Label(label=t("tunnel.none_active")), False, False, 0
            )
        else:
            for tun in attivi:
                row = Gtk.Box(spacing=8)
                nome = tun.get("nome", "?")
                tipo = tun.get("tipo", "")
                lport = str(tun.get("local_port", ""))
                lbl = Gtk.Label(label=f"{nome}  ({tipo} :{lport})")
                lbl.set_halign(Gtk.Align.START)
                lbl.set_hexpand(True)
                btn_stop = Gtk.Button(label=t("tunnel.btn_stop"))
                idx = tun["_idx"]
                btn_stop.connect("clicked", lambda b, i=idx: self._ferma_da_ind(i))
                row.pack_start(lbl, True, True, 0)
                row.pack_start(btn_stop, False, False, 0)
                self._tun_pop_box.pack_start(row, False, False, 0)

        recenti = get_recent_tunnels(4)
        if recenti:
            self._tun_pop_box.pack_start(Gtk.Separator(), False, False, 0)
            hdr2 = Gtk.Label()
            hdr2.set_markup(f"<b>{t('tunnel.recent_header')}</b>")
            hdr2.set_halign(Gtk.Align.START)
            self._tun_pop_box.pack_start(hdr2, False, False, 0)
            for tun in recenti:
                row = Gtk.Box(spacing=8)
                lbl = Gtk.Label(label=f"{tun.get('nome', '?')}  ({tun.get('tipo', '')} :{tun.get('local_port', '')})")
                lbl.set_halign(Gtk.Align.START)
                lbl.set_hexpand(True)
                row.pack_start(lbl, True, True, 0)
                idx = tun["_idx"]
                if tun["_active"]:
                    btn = Gtk.Button(label=t("tunnel.btn_stop"))
                    btn.connect("clicked", lambda b, i=idx: self._ferma_da_ind(i))
                else:
                    btn = Gtk.Button(label=t("tunnel.btn_start"))
                    btn.connect("clicked", lambda b, i=idx: self._avvia_da_ind(i))
                row.pack_start(btn, False, False, 0)
                self._tun_pop_box.pack_start(row, False, False, 0)

        self._tun_pop_box.pack_start(Gtk.Separator(), False, False, 0)
        btn_mgr = Gtk.Button(label=t("tunnel.open_manager"))
        btn_mgr.connect("clicked", lambda b: (self._tun_pop.popdown(), self._on_tunnel_manager()))
        self._tun_pop_box.pack_start(btn_mgr, False, False, 0)

        self._tun_pop_box.show_all()

    def _avvia_da_ind(self, idx: int):
        self._tun_pop.popdown()

        def _bg():
            ok, err = start_tunnel(idx, wait=5)
            if not ok:
                GLib.idle_add(self._warn, f"{t('tunnel.start_failed')}: {err}" if err else t("tunnel.start_failed"))
            GLib.idle_add(self._aggiorna_tun_indicator)
        threading.Thread(target=_bg, daemon=True).start()

    def _ferma_da_ind(self, idx: int):
        stop_tunnel(idx)
        self._tun_pop.popdown()
        self._aggiorna_tun_indicator()

    def _on_impostazioni(self):
        dlg = SettingsDialog(parent=self)
        resp = dlg.run()
        dlg.destroy()
        if resp == Gtk.ResponseType.OK:
            self._settings = config_manager.load_settings()
            self._riapplica_accels()
            _tr.init_from_settings()
            self._propaga_copy_on_select(
                self._settings.get("terminal", {}).get("copy_on_select", False))
            if hasattr(self, "_menu_btn") and self._menu_btn is not None:
                self._menu_btn.set_popup(self._build_menu())

    def _propaga_copy_on_select(self, attivo: bool):
        """Applica subito l'opzione ai terminali già aperti (anche annidati)."""
        def _cammina(widget):
            if isinstance(widget, TerminalWidget):
                widget.imposta_copia_selezione(attivo)
                return
            if isinstance(widget, Gtk.Container):
                for figlio in widget.get_children():
                    _cammina(figlio)

        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                _cammina(nb.get_nth_page(i))

    def _riapplica_accels(self):
        """Riapplica gli acceleratori dopo un salvataggio impostazioni."""
        if hasattr(self, "_accel_group") and self._accel_group:
            self._setup_accels()

    def _on_importa_sessioni(self):
        """Dialog di importazione sessioni da sorgenti esterne."""
        dlg = Gtk.Dialog(
            title=t("import.title"),
            transient_for=self,
            modal=True,
            destroy_with_parent=True
        )
        dlg.set_default_size(480, 0)
        area = dlg.get_content_area()
        area.set_spacing(10)
        area.set_margin_start(16); area.set_margin_end(16)
        area.set_margin_top(16);  area.set_margin_bottom(8)

        lbl = Gtk.Label()
        lbl.set_markup(f"<b>{t('import.label')}</b>")
        area.pack_start(lbl, False, False, 0)

        # Sorgenti: 0=Remmina, 1=RDM, 2=mRemoteNG, 3=PuTTY, 4=SSH Config, 5=MobaXterm
        # (indici usati in _esegui e _on_src_changed)
        SORGENTI = [
            t("import.source_remmina"),
            t("import.source_rdm"),
            t("import.source_mremoteng"),
            t("importer.putty_title"),
            t("importer.ssh_cfg_title"),
            t("importer.moba_title"),
        ]

        sorgente_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        lbl_src = Gtk.Label(label=t("import.source_lbl"))
        lbl_src.set_xalign(0.0)
        combo_src = Gtk.ComboBoxText()
        for s in SORGENTI:
            combo_src.append_text(s)
        combo_src.set_active(0)
        combo_src.set_hexpand(True)
        sorgente_box.pack_start(lbl_src, False, False, 0)
        sorgente_box.pack_start(combo_src, True, True, 0)
        area.pack_start(sorgente_box, False, False, 0)

        # Selettore file (per sorgenti basate su file: Remmina, RDM, mRemoteNG, MobaXterm)
        fc = Gtk.FileChooserButton(title=t("import.file_chooser"),
                                   action=Gtk.FileChooserAction.OPEN)
        fc.set_hexpand(True)
        area.pack_start(fc, False, False, 0)

        _filters_remmina = [("Remmina", "*.remmina"), (t("import.filter_all"), "*")]
        _filters_rdm     = [(t("import.filter_rdmxml"), "*.rdm"), (t("import.filter_rdmjson"), "*.json"), (t("import.filter_all"), "*")]
        _filters_mrng    = [(t("import.filter_mrng"), "*.xml"), (t("import.filter_all"), "*")]
        _filters_moba    = [("MobaXterm sessions", "*.mxtsessions"), ("MobaXterm config", "*.mobaconf"), (t("import.filter_all"), "*")]

        def _set_filters(filtri):
            for old in fc.list_filters():
                fc.remove_filter(old)
            for nome_f, pattern in filtri:
                f = Gtk.FileFilter(); f.set_name(nome_f); f.add_pattern(pattern)
                fc.add_filter(f)

        _set_filters(_filters_remmina)

        def _on_src_changed(_combo):
            src = combo_src.get_active()
            file_based = src in (0, 1, 2, 5)
            fc.set_sensitive(file_based)
            if src == 0:
                _set_filters(_filters_remmina)
            elif src == 1:
                _set_filters(_filters_rdm)
            elif src == 2:
                _set_filters(_filters_mrng)
            elif src == 5:
                _set_filters(_filters_moba)

        combo_src.connect("changed", _on_src_changed)

        chk_sost = Gtk.CheckButton(label=t("import.overwrite"))
        area.pack_start(chk_sost, False, False, 0)

        lbl_result = Gtk.Label(label="")
        lbl_result.set_xalign(0.0); lbl_result.set_line_wrap(True)
        area.pack_start(lbl_result, False, False, 0)

        btn_import = dlg.add_button(t("import.btn"), Gtk.ResponseType.APPLY)
        btn_import.get_style_context().add_class("suggested-action")
        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)

        def _esegui(b):
            # Legge i widget sul thread GTK, poi importa in background: i file
            # di import (PuTTY/RDM/MobaXterm) possono essere grandi e bloccare
            # la UI se letti nel main loop.
            src = combo_src.get_active()
            sostituzione = chk_sost.get_active()
            percorso = fc.get_filename()

            def _msg(inner, color="red"):
                GLib.idle_add(lbl_result.set_markup,
                              f"<span foreground='{color}'>{inner}</span>")

            def _worker():
                import importer as _imp
                try:
                    _moba_warn = False
                    if src == 0:  # Remmina
                        if not percorso:
                            _msg(t("import.no_file")); return
                        nuovi = _imp.importa_remmina(percorso)
                    elif src == 1:  # RDM
                        if not percorso:
                            _msg(t("import.no_file")); return
                        nuovi = _imp.importa_rdm(percorso)
                    elif src == 2:  # mRemoteNG
                        if not percorso:
                            _msg(t("import.no_file")); return
                        nuovi = _imp.importa_mremoteng(percorso)
                        if not nuovi:
                            _msg(t("importer.mrng_none"), "orange"); return
                    elif src == 3:  # PuTTY
                        nuovi = _imp.importa_putty()
                        if not nuovi:
                            _msg(t("importer.putty_none"), "orange"); return
                    elif src == 4:  # SSH Config
                        nuovi = _imp.importa_ssh_config()
                        if not nuovi:
                            _msg(t("importer.ssh_cfg_none"), "orange"); return
                    else:  # MobaXterm
                        if not percorso:
                            _msg(t("import.no_file")); return
                        nuovi = _imp.importa_mobaxterm(percorso)
                        if not nuovi:
                            _msg(t("importer.moba_none"), "orange"); return
                        _moba_warn = True

                    aggiunti, saltati = _imp.unisci_in_pcm(nuovi, sostituzione)
                    _skipped_str = t("import.skipped", n=saltati) if saltati else ""
                    _res = t("import.result", n=aggiunti, skipped=_skipped_str)
                    if _moba_warn:
                        _res += f"\n{t('importer.moba_warn')}"
                    _msg(_res, "green")
                    GLib.idle_add(self._pannello.aggiorna)
                except Exception as e:
                    _msg(t("import.error", e=e))

            threading.Thread(target=_worker, daemon=True).start()

        btn_import.connect("clicked", _esegui)
        dlg.show_all()
        dlg.run()
        dlg.destroy()

    def _on_port_scan(self):
        def import_results(results, protocol):
            profiles = config_manager.load_profiles()
            added = 0
            for result in results:
                name, data = port_scanner.profile_for_result(result, protocol)
                original = name
                suffix = 2
                while name in profiles:
                    name = f"{original} ({suffix})"
                    suffix += 1
                data["group"] = "Port scan"
                profiles[name] = data
                added += 1
            if added:
                config_manager.save_profiles(profiles)
                self._pannello.aggiorna(profiles)
                self._status(t("port_scan.imported").format(count=added))

        dlg = PortScanDialog(self, import_results)
        dlg.run()
        dlg.destroy()

    def _on_ftp_server(self):
        from ftp_server_dialog import FtpServerDialog
        dlg = FtpServerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # Quick connect
    # ------------------------------------------------------------------

    def _on_quick_connect(self):
        """Dialog connessione rapida senza salvare la sessione."""
        result = QuickConnectDialog(parent=self).run_and_get()
        if result:
            proto, nome_tab, dati = result
            self._apri_protocollo(proto, nome_tab, dati)

    def _on_quick_switcher(self):
        """Dialog Command Palette per ricerca e connessione rapida."""
        from quick_switcher_dialog import QuickSwitcherDialog
        azioni = [
            (t("menu.tools.tunnels"),        self._on_tunnel_manager),
            (t("menu.tools.workspaces"),     self._on_workspaces),
            (t("sidebar.new_session_tooltip"), self._on_nuova_sessione),
            (t("menu.tools.import_from"),    self._on_importa_sessioni),
            (t("menu.file.export_sessions"), self._on_esporta_sessioni),
            (t("menu.tools.snippets"),       self._apri_snippet_dialog),
            (t("menu.tools.variables"),      self._on_variabili_globali),
            (t("menu.tools.port_scan"),      self._on_port_scan),
            (t("menu.tools.audit"),          self._on_audit_log),
            (t("menu.tools.crypto"),         self._on_gestione_crypto),
            (t("menu.help.guide"),           self._on_guida),
            (t("menu.help.about"),           self._on_about),
            (t("quick_switcher.act_settings"), self._on_impostazioni),
        ]
        dlg = QuickSwitcherDialog(parent=self, on_connect=lambda n, d: self._on_connetti(None, n, d),
                                  actions=azioni)
        dlg.run()

    # ------------------------------------------------------------------
    # Connectivity test / ping
    # ------------------------------------------------------------------

    def _on_ping_sessione(self, _panel, nome: str, dati: dict):
        host = dati.get("host", "")
        try:
            port = int(dati.get("port", 22))
        except (ValueError, TypeError):
            port = 22

        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.INFO,
            buttons=Gtk.ButtonsType.CLOSE,
            text=f"Ping: {nome}",
        )
        dlg.format_secondary_text(t("ping.testing"))
        dlg.show_all()

        def _cb(ms):
            if ms >= 0:
                dlg.format_secondary_markup(
                    f"<span foreground='green'>{t('ping.ok', ms=ms)}</span>"
                )
            else:
                dlg.format_secondary_markup(
                    f"<span foreground='red'>{t('ping.fail', port=port)}</span>"
                )

        self._test_connettivita(host, port, _cb)
        dlg.run()
        dlg.destroy()

    def _test_connettivita(self, host: str, port: int, callback):
        """Verifica TCP raggiungibilità in thread. Chiama callback(ms) o callback(-1)."""
        import socket
        import time
        def _check():
            try:
                t0 = time.monotonic()
                with socket.create_connection((host, port), timeout=5):
                    ms = int((time.monotonic() - t0) * 1000)
                GLib.idle_add(callback, ms)
            except Exception:
                GLib.idle_add(callback, -1)
        threading.Thread(target=_check, daemon=True).start()

    # ------------------------------------------------------------------
    # Broadcast terminali
    # ------------------------------------------------------------------

    def _raccoglie_terminal_widgets(self) -> list:
        """Restituisce lista di (nome_tab, TerminalWidget) attivi."""
        result = []
        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                tw = None
                if isinstance(page, TerminalWidget):
                    tw = page
                elif hasattr(page, "get_child1"):
                    c1 = page.get_child1()
                    if isinstance(c1, TerminalWidget):
                        tw = c1
                if tw and not getattr(tw, "_stato_terminato", True):
                    nome = self._get_tab_nome(page) or f"Tab {i}"
                    result.append((nome, tw))
        return result

    def _on_broadcast(self):
        """Dialog broadcast: invia testo a più terminali selezionati."""
        terminali = self._raccoglie_terminal_widgets()

        dlg = Gtk.Dialog(
            title=t("broadcast.title"), transient_for=self,
            modal=True, destroy_with_parent=True
        )
        dlg.set_default_size(500, 380)
        area = dlg.get_content_area()
        area.set_spacing(8)
        area.set_margin_start(16); area.set_margin_end(16)
        area.set_margin_top(12);  area.set_margin_bottom(8)

        if not terminali:
            lbl_no = Gtk.Label(label=t("broadcast.no_terminals"))
            area.pack_start(lbl_no, True, True, 0)
            dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)
            dlg.show_all(); dlg.run(); dlg.destroy()
            return

        banner = Gtk.InfoBar()
        banner.set_message_type(Gtk.MessageType.WARNING)
        banner_lbl = Gtk.Label(label=t("broadcast.banner"))
        banner_lbl.set_line_wrap(True)
        banner.get_content_area().pack_start(banner_lbl, True, True, 0)
        banner.show_all()
        area.pack_start(banner, False, False, 0)

        lbl = Gtk.Label(label=t("broadcast.select_terminals"))
        lbl.set_xalign(0.0)
        area.pack_start(lbl, False, False, 0)

        # Lista terminali con checkbox
        scroll_t = Gtk.ScrolledWindow()
        scroll_t.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll_t.set_min_content_height(120)
        chk_list = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
        scroll_t.add(chk_list)
        checks = []
        for nome_tab, tw in terminali:
            chk = Gtk.CheckButton(label=nome_tab)
            chk.set_active(True)
            chk.set_tooltip_text(getattr(tw, "_stato_testo", ""))
            chk_list.pack_start(chk, False, False, 0)
            checks.append((chk, tw))
        area.pack_start(scroll_t, True, True, 0)

        # Pulsanti seleziona/deseleziona
        btn_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
        btn_all = Gtk.Button(label=t("broadcast.select_all"))
        btn_all.connect("clicked", lambda _: [c.set_active(True) for c, _ in checks])
        btn_none = Gtk.Button(label=t("broadcast.deselect_all"))
        btn_none.connect("clicked", lambda _: [c.set_active(False) for c, _ in checks])
        btn_row.pack_start(btn_all, False, False, 0)
        btn_row.pack_start(btn_none, False, False, 0)
        area.pack_start(btn_row, False, False, 0)

        # Area testo
        lbl2 = Gtk.Label(label=t("broadcast.label"))
        lbl2.set_xalign(0.0)
        area.pack_start(lbl2, False, False, 0)

        sw_txt = Gtk.ScrolledWindow()
        sw_txt.set_min_content_height(80)
        tv = Gtk.TextView()
        tv.set_monospace(True)
        sw_txt.add(tv)
        area.pack_start(sw_txt, True, True, 0)

        chk_newline = Gtk.CheckButton(label=t("broadcast.add_enter"))
        chk_newline.set_active(True)
        area.pack_start(chk_newline, False, False, 0)

        lbl_result = Gtk.Label(label="")
        lbl_result.set_xalign(0.0)
        area.pack_start(lbl_result, False, False, 0)

        btn_send = dlg.add_button(t("broadcast.send"), Gtk.ResponseType.APPLY)
        btn_send.get_style_context().add_class("suggested-action")
        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)

        def _invia(b):
            buf = tv.get_buffer()
            testo = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), True)
            if not testo:
                return
            add_nl = chk_newline.get_active()
            payload = (testo + "\n").encode("utf-8") if add_nl else testo.encode("utf-8")
            n_inviati = 0
            for chk, tw in checks:
                if chk.get_active():
                    if getattr(tw, "_sola_lettura", False):
                        continue
                    try:
                        tw._vte.feed_child(payload)
                        n_inviati += 1
                    except Exception as e:
                        _log.debug("Broadcast feed_child fallito: %s", e)
            lbl_result.set_markup(f"<span foreground='green'>{t('broadcast.sent', n=n_inviati)}</span>")

        btn_send.connect("clicked", _invia)
        dlg.show_all()
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.APPLY:
                break
        dlg.destroy()

    # ------------------------------------------------------------------
    # Audit log viewer
    # ------------------------------------------------------------------

    def _on_audit_log(self):
        """Dialog visualizzazione registro audit connessioni."""
        dlg = Gtk.Dialog(
            title=t("audit.title"), transient_for=self,
            modal=True, destroy_with_parent=True
        )
        dlg.set_default_size(820, 480)
        area = dlg.get_content_area()
        area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(8);   area.set_margin_bottom(8)

        # TreeView
        store = Gtk.ListStore(str, str, str, str, str, str)
        tv = Gtk.TreeView(model=store)
        for i, col_title in enumerate([
            t("audit.col_time"), t("audit.col_session"), t("audit.col_host"),
            t("audit.col_proto"), t("audit.col_duration"), t("audit.col_status")
        ]):
            cell = Gtk.CellRendererText()
            col = Gtk.TreeViewColumn(col_title, cell, text=i)
            col.set_resizable(True)
            tv.append_column(col)

        def _ricarica():
            store.clear()
            log = config_manager.audit_load()
            if not log:
                store.append(["", t("audit.no_entries"), "", "", "", ""])
                return
            for e in reversed(log):
                dur = e.get("duration", 0)
                dur_str = f"{dur}s" if dur < 60 else f"{dur//60}m{dur%60:02d}s"
                stato = t("audit.status_ok") if e.get("status") == "ok" else t("audit.status_err")
                store.append([
                    e.get("ts", ""), e.get("session", ""), e.get("host", ""),
                    e.get("proto", ""), dur_str, stato
                ])

        _ricarica()

        sw = Gtk.ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        sw.add(tv)
        area.pack_start(sw, True, True, 0)

        btn_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        btn_row.set_margin_top(6)
        btn_clear = Gtk.Button(label=t("audit.clear"))
        btn_clear.get_style_context().add_class("destructive-action")
        def _cancella(_b):
            config_manager.audit_clear()
            _ricarica()
        btn_clear.connect("clicked", _cancella)

        btn_csv = Gtk.Button(label=t("audit.export_csv"))
        def _esporta_csv(_b):
            import csv
            import io
            fc = Gtk.FileChooserDialog(
                title=t("audit.csv_title"), transient_for=dlg,
                action=Gtk.FileChooserAction.SAVE
            )
            fc.add_button(t("audit.csv_cancel"), Gtk.ResponseType.CANCEL)
            fc.add_button(t("audit.csv_save"),   Gtk.ResponseType.OK)
            fc.set_current_name("pcm_audit.csv")
            if fc.run() == Gtk.ResponseType.OK:
                path = fc.get_filename()
                log  = config_manager.audit_load()
                with open(path, "w", newline="", encoding="utf-8") as f:
                    w = csv.DictWriter(f, fieldnames=["ts","session","host","proto","duration","status"])
                    w.writeheader(); w.writerows(log)
            fc.destroy()
        btn_csv.connect("clicked", _esporta_csv)

        btn_row.pack_start(btn_clear, False, False, 0)
        btn_row.pack_end(btn_csv, False, False, 0)
        area.pack_start(btn_row, False, False, 0)

        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)
        dlg.show_all()
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # KeePassXC settings (placeholder — configurazione associazione)
    # ------------------------------------------------------------------

    def _on_keepass_settings(self):
        """Apre il dialog impostazioni KeePassXC."""
        try:
            from keepassxc_manager import KeePassXCSettingsDialog
            dlg = KeePassXCSettingsDialog(parent=self)
            dlg.run()
            dlg.destroy()
        except ImportError:
            self._warn(t("keepass.missing"))

    def _on_variabili_globali(self):
        """Dialog variabili globali (variabili {VAR} usabili nei comandi)."""
        from variables_dialog import VariablesDialog
        dlg = VariablesDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_gestione_crypto(self):
        """Dialog gestione password master / cifratura credenziali."""
        from crypto_manager_dialog import CryptoManagerDialog
        dlg = CryptoManagerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_check_deps(self):
        """Apre il pannello di configurazione dei percorsi eseguibili."""
        from deps_dialog import DepsConfigDialog
        dlg = DepsConfigDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_guida(self):
        """Apre la guida HTML nella lingua corrente (fallback inglese)."""
        import os
        from translations import get_lang
        here = os.path.dirname(os.path.abspath(__file__))
        lang = get_lang()
        # Cerca prima il file specifico per la lingua, poi cade sull'inglese
        html_path = os.path.join(here, f"pcm_help_{lang}.html")
        if not os.path.exists(html_path):
            html_path = os.path.join(here, "pcm_help_en.html")
        if not os.path.exists(html_path):
            dlg = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.WARNING,
                buttons=Gtk.ButtonsType.CLOSE,
                text=t("guide.file_missing"),
            )
            dlg.run()
            dlg.destroy()
            return
        import subprocess
        subprocess.Popen(["xdg-open", html_path])

    def _on_about(self):
        """Dialog Informazioni su PCM."""
        dlg = Gtk.Dialog(
            title="PCM — Python Connection Manager",
            transient_for=self,
            modal=True,
        )  # titolo app: non tradotto intenzionalmente
        dlg.set_default_size(400, -1)
        dlg.add_button("OK", Gtk.ResponseType.OK)

        box = dlg.get_content_area()
        box.set_spacing(12)
        box.set_margin_start(20)
        box.set_margin_end(20)
        box.set_margin_top(16)
        box.set_margin_bottom(12)

        lbl_title = Gtk.Label()
        lbl_title.set_markup("<b>PCM — Python Connection Manager</b>")
        lbl_title.set_xalign(0.0)
        box.pack_start(lbl_title, False, False, 0)

        lbl_desc = Gtk.Label(label=t("about.dev_label"))
        lbl_desc.set_xalign(0.0)
        box.pack_start(lbl_desc, False, False, 0)

        lbl_proto = Gtk.Label()
        lbl_proto.set_markup(t("about.proto_label"))
        lbl_proto.set_xalign(0.0)
        lbl_proto.set_line_wrap(True)
        box.pack_start(lbl_proto, False, False, 0)

        lbl_author = Gtk.Label()
        lbl_author.set_markup(
            "<b>Autore:</b> Andres Zanzani - "
            "<a href=\"mailto:azanzani@gmail.com\">azanzani@gmail.com</a>"
        )
        lbl_author.set_xalign(0.0)
        box.pack_start(lbl_author, False, False, 0)

        lbl_gh = Gtk.Label()
        lbl_gh.set_markup(
            "<b>GitHub:</b> "
            "<a href=\"https://github.com/buzzqw/Python_Connection_Manager\">"
            "github.com/buzzqw/Python_Connection_Manager</a>"
        )
        lbl_gh.set_xalign(0.0)
        box.pack_start(lbl_gh, False, False, 0)

        lbl_lic = Gtk.Label()
        lbl_lic.set_markup(t("about.license_label"))
        lbl_lic.set_xalign(0.0)
        box.pack_start(lbl_lic, False, False, 0)

        box.show_all()
        dlg.run()
        dlg.destroy()

    def _on_esci(self):
        self.get_application().quit()

    # ------------------------------------------------------------------
    # Chiusura finestra
    # ------------------------------------------------------------------

    def _on_close(self, window, event):
        settings = config_manager.load_settings()
        if settings.get("general", {}).get("confirm_on_exit", True):
            # Conta tab aperte (escludi la tab benvenuto)
            n_tabs = self._notebook.get_n_pages() - 1
            if n_tabs > 0:
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.QUESTION,
                    buttons=Gtk.ButtonsType.YES_NO,
                    text=t("close.title"),
                )
                dlg.format_secondary_text(t("close.confirm_msg"))
                resp = dlg.run()
                dlg.destroy()
                if resp != Gtk.ResponseType.YES:
                    return True  # blocca la chiusura
        # Controlla tunnel SSH attivi
        tunnel_attivi = get_active_tunnels()
        if tunnel_attivi:
            nomi = "\n".join(f"  • {tun.get('nome', '?')}" for tun in tunnel_attivi)
            dlg = Gtk.Dialog(
                title=t("tunnel.close_warning_title"),
                transient_for=self,
                modal=True,
                destroy_with_parent=True,
            )
            dlg.set_default_size(400, 0)
            area = dlg.get_content_area()
            area.set_spacing(8)
            area.set_margin_start(16); area.set_margin_end(16)
            area.set_margin_top(16);  area.set_margin_bottom(8)
            lbl = Gtk.Label()
            msg = t("tunnel.close_warning_msg").replace("<b>", "").replace("</b>", "").format(
                n=len(tunnel_attivi), names=nomi
            )
            lbl.set_text(msg)
            lbl.set_line_wrap(True)
            lbl.set_xalign(0.0)
            area.pack_start(lbl, False, False, 0)
            area.show_all()
            # Pulsanti: Annulla | Lascia attivi | Ferma tunnel
            _RESP_CANCEL = 0
            _RESP_KEEP   = 1
            _RESP_STOP   = 2
            dlg.add_button(t("tunnel.close_cancel"), _RESP_CANCEL)
            dlg.add_button(t("tunnel.close_keep"),   _RESP_KEEP)
            dlg.add_button(t("tunnel.close_stop"),   _RESP_STOP)
            resp = dlg.run()
            dlg.destroy()
            if resp == _RESP_CANCEL:
                return True  # blocca la chiusura
            if resp == _RESP_STOP:
                for tun in tunnel_attivi:
                    stop_tunnel(tun["_idx"])
            # _RESP_KEEP: lascia i tunnel attivi, si chiude normalmente
        # Salva sessioni aperte per il ripristino al prossimo avvio
        s_r = config_manager.load_settings()
        if s_r.get("general", {}).get("restore_sessions_on_start", False):
            restore_list = []
            for nb in (self._notebook, self._notebook2):
                for i in range(nb.get_n_pages()):
                    pg = nb.get_nth_page(i)
                    if pg and hasattr(pg, "_pcm_dati"):
                        d = pg._pcm_dati
                        restore_list.append({
                            "host":        d.get("host", ""),
                            "protocol":    d.get("protocol", "ssh"),
                            "port":        d.get("port", "22"),
                            "user":        d.get("user", ""),
                            "ft_protocol": d.get("ft_protocol", ""),
                        })
            s_r["_restore_sessions"] = restore_list
        else:
            s_r.pop("_restore_sessions", None)
        config_manager.save_settings(s_r)

        # Chiudi tutti i processi aperti
        def _chiudi_ricorsivo(widget):
            if hasattr(widget, "chiudi_processo"):
                try:
                    widget.chiudi_processo()
                except Exception as e:
                    _log.debug("chiudi_processo fallito: %s", e)
            elif hasattr(widget, "get_child1"):
                for child in (widget.get_child1(), widget.get_child2()):
                    if child:
                        _chiudi_ricorsivo(child)
            _dati = getattr(widget, "_pcm_dati", None)
            if _dati and _dati.get("_gateway_tunnel"):
                try:
                    _dati["_gateway_tunnel"].terminate()
                except Exception as e:
                    _log.debug("Terminazione gateway tunnel fallita: %s", e)

        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                if page is None:
                    continue
                _chiudi_ricorsivo(page)
        if self._auto_lock_timer:
            GLib.source_remove(self._auto_lock_timer)
        if hasattr(self, "_timer_stato_live") and self._timer_stato_live:
            GLib.source_remove(self._timer_stato_live)
        if hasattr(self, "_timer_tun_ind") and self._timer_tun_ind:
            GLib.source_remove(self._timer_tun_ind)
        return False  # permetti chiusura

    # ------------------------------------------------------------------
    # Session restore
    # ------------------------------------------------------------------

    def _ripristina_sessioni(self) -> bool:
        s       = config_manager.load_settings()
        refs    = s.pop("_restore_sessions", [])
        if not refs:
            return False
        config_manager.save_settings(s)

        profili = config_manager.load_profiles()

        # I profili sono un dict piatto nome -> dati (non annidati per gruppo).
        lookup = {}
        for nome, dati in profili.items():
            if not isinstance(dati, dict):
                continue
            key = (dati.get("host"), dati.get("protocol", "ssh"),
                   str(dati.get("port", "22")), dati.get("user", ""),
                   dati.get("ft_protocol", ""))
            lookup[key] = (nome, dati)

        for ref in refs:
            key = (ref.get("host", ""), ref.get("protocol", "ssh"),
                   str(ref.get("port", "22")), ref.get("user", ""),
                   ref.get("ft_protocol", ""))
            found = lookup.get(key)
            if found:
                self._apri_protocollo(found[1].get("protocol", "ssh"), found[0], dict(found[1]))

        return False  # one-shot GLib.timeout_add

    # ------------------------------------------------------------------
    # Utility
    # ------------------------------------------------------------------

    def _imposta_attivita_tab(self, page, attivo: bool):
        """Mostra/nasconde il pallino di attività sul tab."""
        page._pcm_attivita = bool(attivo)
        dot = self._tab_dots.get(page)
        if dot is not None:
            dot.set_visible(bool(attivo))

    def _on_terminale_attivita(self, tw):
        """Output arrivato: segnala il tab se non è quello attivo."""
        for nb in (self._notebook, self._notebook2):
            idx, page = self._trova_in_notebook(nb, tw)
            if idx < 0:
                continue
            if nb is self._notebook_attivo and nb.get_current_page() == idx:
                return
            self._imposta_attivita_tab(page, True)
            return

    def _on_terminale_campanello(self, tw):
        """Campanello: urgenza finestra e notifica desktop se non è attiva."""
        nome = ""
        for nb in (self._notebook, self._notebook2):
            idx, page = self._trova_in_notebook(nb, tw)
            if idx >= 0:
                nome = self._get_tab_nome(page)
                break
        if self.is_active():
            return
        self.set_urgency_hint(True)
        # Evita raffiche di notifiche.
        import time as _time
        adesso = _time.monotonic()
        if adesso - getattr(self, "_ultima_notifica_bell", 0.0) < 2.0:
            return
        self._ultima_notifica_bell = adesso
        try:
            app = self.get_application()
            if app is not None:
                notifica = Gio.Notification.new(t("notify.bell.title"))
                notifica.set_body(t("notify.bell.body", name=nome or "PCM"))
                app.send_notification("pcm-bell", notifica)
        except Exception as e:
            _log.debug("Notifica campanello fallita: %s", e)

    def _on_terminale_titolo(self, _tw, titolo: str):
        """Titolo remoto (OSC 0/2): mostralo nel tooltip del tab."""
        for nb in (self._notebook, self._notebook2):
            idx, page = self._trova_in_notebook(nb, _tw)
            if idx < 0:
                continue
            page._pcm_titolo_remoto = titolo
            lbl = self._tab_labels.get(page)
            if lbl is not None:
                lbl.set_tooltip_text(titolo or None)
            return

    def _on_switch_tab(self, notebook, page, page_num):
        """Aggiorna statusbar e pannello info al cambio tab."""
        self._notebook_attivo = notebook
        # Il tab selezionato non ha più bisogno del pallino di attività.
        self._imposta_attivita_tab(page, False)
        if not any(d.get_visible() for d in self._tab_dots.values()):
            self.set_urgency_hint(False)
        is_home = page not in self._tab_labels
        if is_home:
            self._status(t("status.ready"))
            self._info_panel.nascondi()
        else:
            nome_pulito = self._get_tab_nome(page).lstrip("📌✖ ")
            self._status(t("status.connected", name=nome_pulito))
            dati = getattr(page, "_pcm_dati", None)
            if dati and dati.get("protocol") in ("ssh", "mosh", "vnc", "rdp"):
                self._info_panel.aggiorna_per_sessione(dati)
            else:
                self._info_panel.nascondi()

    def _aggiorna_stato_live(self) -> bool:
        """Timer ogni 3s: aggiorna la statusbar con le stat live del terminale attivo."""
        nb = getattr(self, "_notebook_attivo", None) or self._notebook
        idx = nb.get_current_page()
        if nb is self._notebook and idx <= 0:
            return True
        if idx < 0:
            return True
        page = nb.get_nth_page(idx)
        if page is None:
            return True
        # Cerca il TerminalWidget (può essere direttamente la page o figlio di Paned)
        tw = None
        if hasattr(page, "get_stato"):
            tw = page
        elif hasattr(page, "get_child1"):
            child = page.get_child1()
            if child and hasattr(child, "get_stato"):
                tw = child
        if tw is None:
            return True
        stato, terminato = tw.get_stato()
        if not stato:
            return True
        nome_pulito = self._get_tab_nome(page).lstrip("📌✖ ")
        if terminato:
            self._status(t("status.terminated", name=nome_pulito, state=stato))
        else:
            self._status(t("status.active", name=nome_pulito, state=stato))
        return True  # continua il timer

    def _status(self, msg: str):
        self._statusbar.pop(self._statusbar_ctx)
        self._statusbar.push(self._statusbar_ctx, msg)

    def _warn(self, msg: str):
        self._mostra_toast(msg, "warning")

    def _mostra_toast(self, msg: str, css_class: str = ""):
        self._toast_label.set_text(msg)
        if css_class:
            css_name = f"toast-{css_class}"
            self._toast_box.get_style_context().add_class(css_name)
        self._toast_revealer.set_reveal_child(True)
        if self._toast_timer:
            GLib.source_remove(self._toast_timer)
        self._toast_timer = GLib.timeout_add(5000, self._nascondi_toast)

    def _nascondi_toast(self):
        self._toast_revealer.set_reveal_child(False)
        self._toast_box.get_style_context().remove_class("toast-warning")
        self._toast_box.get_style_context().remove_class("toast-error")
        self._toast_box.get_style_context().remove_class("toast-info")
        self._toast_timer = 0
        return False

    def _invia_wol(self, mac: str, attesa: int) -> str:
        """Invia magic packet WoL e attende. Restituisce stringa errore o "" se OK.
        Thread-safe: non tocca la UI."""
        import socket
        import time
        try:
            mac_clean = mac.replace(":", "").replace("-", "")
            payload = bytes.fromhex("FF" * 6 + mac_clean * 16)
            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
                s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
                s.sendto(payload, ("<broadcast>", 9))
            time.sleep(attesa)
            return ""
        except Exception as e:
            return str(e)


# ===========================================================================
# Applicazione GTK
# ===========================================================================


# ---------------------------------------------------------------------------
# Dialog "Apri SFTP/FTP da sessione esistente"
# ---------------------------------------------------------------------------

class _SessionPickerDialog(Gtk.Dialog):
    """Dialog multi-selezione sessioni per cluster, con salvataggio/caricamento."""

    def __init__(self, parent, profili: dict):
        super().__init__(
            title=t("cluster.pick_session"),
            transient_for=parent, modal=True, destroy_with_parent=True,
        )
        self.set_default_size(500, 500)
        self._selected: list[str] = []
        self._profili = profili
        self._saved_clusters = config_manager.load_settings().get("saved_clusters", {})

        area = self.get_content_area()
        area.set_spacing(6)
        area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(10); area.set_margin_bottom(6)

        title_lbl = Gtk.Label()
        title_lbl.set_markup(f"<b>{t('cluster.pick_session')}</b>")
        title_lbl.set_xalign(0.0); title_lbl.set_margin_bottom(2)
        area.pack_start(title_lbl, False, False, 0)

        # ── Sezione cluster salvati ──────────────────────────────
        if self._saved_clusters:
            saved_frame = Gtk.Frame(label=f"  {t('cluster.saved_title')}  ")
            saved_frame.set_label_align(0.02, 0.5)
            saved_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
            saved_box.set_margin_start(8); saved_box.set_margin_end(8)
            saved_box.set_margin_top(6); saved_box.set_margin_bottom(8)

            for cname, cdata in sorted(self._saved_clusters.items()):
                row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
                sessions_list = ", ".join(cdata.get("sessions", [])[:5])
                if len(cdata.get("sessions", [])) > 5:
                    sessions_list += f" +{len(cdata['sessions']) - 5}"
                lbl = Gtk.Label(label=f"{cname}")
                lbl.set_xalign(0.0); lbl.set_hexpand(True)
                row.pack_start(lbl, True, True, 0)
                detail = Gtk.Label(label=f"({sessions_list})")
                detail.set_xalign(0.0)
                detail.get_style_context().add_class("dim-label")
                row.pack_start(detail, False, False, 0)
                btn_load = Gtk.Button(label=t("cluster.load"))
                btn_load.set_relief(Gtk.ReliefStyle.NONE)
                btn_load.connect("clicked", lambda b, cn=cname: self._load_cluster(cn))
                row.pack_start(btn_load, False, False, 0)
                btn_del = Gtk.Button()
                btn_del.set_relief(Gtk.ReliefStyle.NONE)
                btn_del.add(Gtk.Image.new_from_icon_name("edit-delete-symbolic", Gtk.IconSize.BUTTON))
                btn_del.connect("clicked", lambda b, cn=cname: self._delete_cluster(cn))
                row.pack_start(btn_del, False, False, 0)
                saved_box.pack_start(row, False, False, 0)

            saved_frame.add(saved_box)
            area.pack_start(saved_frame, False, False, 0)

        # ── Descrizione ──────────────────────────────────────────
        desc = Gtk.Label()
        desc.set_markup(f"<small>{t('cluster.pick_multi_desc')}</small>")
        desc.set_xalign(0.0); desc.set_line_wrap(True)
        desc.set_margin_top(4)
        area.pack_start(desc, False, False, 0)

        # ── Ricerca ──────────────────────────────────────────────
        search = Gtk.SearchEntry()
        search.set_placeholder_text(t("sidebar.search_placeholder"))
        search.set_margin_top(4)
        area.pack_start(search, False, False, 0)

        # ── Lista sessioni ───────────────────────────────────────
        sw = Gtk.ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)

        store = Gtk.ListStore(bool, str, str, str, int)
        self._store = store
        self._tree = Gtk.TreeView(model=store)
        self._tree.set_headers_visible(True)

        col_sel = Gtk.TreeViewColumn("")
        cell_toggle = Gtk.CellRendererToggle()
        cell_toggle.connect("toggled", self._on_toggle, store)
        col_sel.pack_start(cell_toggle, False)
        col_sel.add_attribute(cell_toggle, "active", 0)
        self._tree.append_column(col_sel)

        for title, idx, expand in [(t("sd.session_name"), 1, True),
                                    (t("sd.protocol"), 2, False),
                                    (t("sd.host"), 3, True)]:
            cell = Gtk.CellRendererText()
            col = Gtk.TreeViewColumn(title, cell, text=idx)
            col.set_expand(expand)
            self._tree.append_column(col)

        self._all_items: list[dict] = []
        for nome, dati in sorted(profili.items()):
            proto = protocols.PROTO_LABEL.get(dati.get("protocol", ""), dati.get("protocol", ""))
            host = dati.get("host", "")
            self._all_items.append({"nome": nome, "proto": proto, "host": host, "idx": len(self._all_items)})

        self._lbl_count = Gtk.Label()

        self._rebuild = lambda f="": self._do_rebuild(f)
        self._rebuild()
        search.connect("search-changed", lambda e: self._rebuild(e.get_text()))

        self._tree.connect("row-activated", self._on_row_activated)
        sw.add(self._tree)
        area.pack_start(sw, True, True, 0)

        # ── Barra inferiore: contatore + Salva ──────────────────
        bottom = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        bottom.set_margin_top(4)

        bottom.pack_start(self._lbl_count, True, True, 0)
        self._update_count()

        btn_save = Gtk.Button(label=t("cluster.save_btn"))
        btn_save.set_tooltip_text(t("cluster.save_btn_tt"))
        btn_save.connect("clicked", lambda b: self._save_current_cluster())
        bottom.pack_start(btn_save, False, False, 0)

        area.pack_start(bottom, False, False, 0)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        self.add_button(t("sd.ok"), Gtk.ResponseType.OK)

    def _on_toggle(self, cell, path, store):
        store[path][0] = not store[path][0]
        self._update_count()

    def _on_row_activated(self, tree, path, column):
        if column is not None:
            self.response(Gtk.ResponseType.OK)

    def _do_rebuild(self, filtro: str):
        self._store.clear()
        f = filtro.strip().lower()
        for item in self._all_items:
            if f and f not in item["nome"].lower() and f not in item["host"].lower():
                continue
            self._store.append([False, item["nome"], item["proto"], item["host"], item["idx"]])
        self._update_count()

    def _update_count(self):
        n = sum(1 for row in self._store if row[0])
        if n == 0:
            self._lbl_count.set_markup(
                f"<small><span foreground='#888'>{t('cluster.sel_none')}</span></small>")
        else:
            self._lbl_count.set_markup(
                f"<small><b>{t('cluster.sel_count', n=n)}</b></small>  "
                f"<small><span foreground='#888'>{t('cluster.sel_hint')}</span></small>")

    def get_selected(self) -> list[str]:
        return [row[1] for row in self._store if row[0]]

    def _load_cluster(self, cname: str):
        cdata = self._saved_clusters.get(cname, {})
        sessions = cdata.get("sessions", [])
        for row in self._store:
            if row[1] in sessions:
                row[0] = True
        self._update_count()

    def _delete_cluster(self, cname: str):
        dlg = Gtk.MessageDialog(
            transient_for=self, modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=t("cluster.delete_confirm", name=cname))
        resp = dlg.run()
        dlg.destroy()
        if resp == Gtk.ResponseType.YES:
            s = config_manager.load_settings()
            s.get("saved_clusters", {}).pop(cname, None)
            config_manager.save_settings(s)
            self._saved_clusters.pop(cname, None)
            self._warn_info(t("cluster.deleted", name=cname))

    def _save_current_cluster(self):
        selected = self.get_selected()
        if not selected:
            self._warn_info(t("cluster.save_no_sel"))
            return
        dlg = Gtk.Dialog(
            title=t("cluster.save_title"),
            transient_for=self, modal=True, destroy_with_parent=True,
        )
        dlg.set_default_size(350, -1)
        area = dlg.get_content_area()
        area.set_spacing(6); area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(10); area.set_margin_bottom(6)
        lbl = Gtk.Label(label=t("cluster.save_name_lbl"))
        lbl.set_xalign(0.0)
        area.pack_start(lbl, False, False, 0)
        entry = Gtk.Entry()
        entry.set_placeholder_text(t("cluster.save_ph"))
        entry.set_activates_default(True)
        area.pack_start(entry, False, False, 0)
        area.show_all()
        dlg.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        dlg.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        dlg.set_default_response(Gtk.ResponseType.OK)
        resp = dlg.run()
        nome = entry.get_text().strip()
        dlg.destroy()
        if resp == Gtk.ResponseType.OK and nome:
            s = config_manager.load_settings()
            clusters = s.get("saved_clusters", {})
            clusters[nome] = {"sessions": selected}
            s["saved_clusters"] = clusters
            config_manager.save_settings(s)
            self._saved_clusters = clusters
            self._warn_info(t("cluster.saved_ok", name=nome))

    def _warn_info(self, msg: str):
        dlg = Gtk.MessageDialog(
            transient_for=self, modal=True,
            message_type=Gtk.MessageType.INFO,
            buttons=Gtk.ButtonsType.OK, text=msg)
        dlg.run(); dlg.destroy()

    def run(self):
        self.show_all()
        return super().run()


class _DialogApriFileTransfer(Gtk.Dialog):
    """Dialog che pre-compila host/credenziali da una sessione SSH e chiede il protocollo FT."""

    _PORT_DEFAULT = {"SFTP": "22", "FTP": "21", "FTPS": "21"}

    def __init__(self, parent, dati_ssh: dict):
        super().__init__(
            title=t("dlg_ft.title"),
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.set_default_size(420, 0)
        self._dati_ssh = dati_ssh
        self._init_ui()
        self.show_all()
        self._on_proto_changed(self._combo_proto)

    def _init_ui(self):
        area = self.get_content_area()
        area.set_spacing(6)
        area.set_margin_start(16)
        area.set_margin_end(16)
        area.set_margin_top(12)
        area.set_margin_bottom(8)

        grid = Gtk.Grid(row_spacing=6, column_spacing=8)
        area.pack_start(grid, False, False, 0)

        def _row(row, label_key, widget):
            lbl = Gtk.Label(label=t(label_key))
            lbl.set_xalign(1.0)
            grid.attach(lbl, 0, row, 1, 1)
            grid.attach(widget, 1, row, 1, 1)
            widget.set_hexpand(True)

        # Protocollo
        self._combo_proto = Gtk.ComboBoxText()
        for p in ("SFTP", "FTP", "FTPS"):
            self._combo_proto.append_text(p)
        self._combo_proto.set_active(0)
        self._combo_proto.connect("changed", self._on_proto_changed)
        _row(0, "dlg_ft.protocol", self._combo_proto)

        # Host
        self._entry_host = Gtk.Entry()
        self._entry_host.set_text(self._dati_ssh.get("host", ""))
        _row(1, "dlg_ft.host", self._entry_host)

        # Porta
        self._entry_port = Gtk.Entry()
        self._entry_port.set_text(self._dati_ssh.get("port", "22") or "22")
        _row(2, "dlg_ft.port", self._entry_port)

        # Utente
        self._entry_user = Gtk.Entry()
        self._entry_user.set_text(self._dati_ssh.get("user", ""))
        _row(3, "dlg_ft.user", self._entry_user)

        # Password
        self._entry_pwd = Gtk.Entry()
        self._entry_pwd.set_visibility(False)
        self._entry_pwd.set_text(self._dati_ssh.get("password", ""))
        _row(4, "dlg_ft.password", self._entry_pwd)

        # Chiave privata (solo SFTP)
        self._pkey_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        self._entry_pkey = Gtk.Entry()
        self._entry_pkey.set_text(self._dati_ssh.get("private_key", ""))
        self._entry_pkey.set_hexpand(True)
        btn_pkey = Gtk.Button(label=t("dlg_ft.pkey_browse"))
        btn_pkey.connect("clicked", self._on_browse_pkey)
        self._pkey_box.pack_start(self._entry_pkey, True, True, 0)
        self._pkey_box.pack_start(btn_pkey, False, False, 0)
        self._lbl_pkey = Gtk.Label(label=t("dlg_ft.pkey"))
        self._lbl_pkey.set_xalign(1.0)
        grid.attach(self._lbl_pkey, 0, 5, 1, 1)
        grid.attach(self._pkey_box, 1, 5, 1, 1)
        self._pkey_box.set_hexpand(True)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        ok = self.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        ok.get_style_context().add_class("suggested-action")
        self.set_default_response(Gtk.ResponseType.OK)
        self._entry_host.connect("activate", lambda _: self.response(Gtk.ResponseType.OK))

    def _on_proto_changed(self, combo):
        proto = combo.get_active_text() or "SFTP"
        is_sftp = proto == "SFTP"
        self._lbl_pkey.set_visible(is_sftp)
        self._pkey_box.set_visible(is_sftp)
        # Aggiorna porta solo se invariata rispetto ai default
        current_port = self._entry_port.get_text().strip()
        for p, default in self._PORT_DEFAULT.items():
            if current_port == default:
                self._entry_port.set_text(self._PORT_DEFAULT[proto])
                break

    def _on_browse_pkey(self, _btn):
        dlg = Gtk.FileChooserDialog(
            title=t("dlg_ft.pkey"),
            transient_for=self,
            action=Gtk.FileChooserAction.OPEN,
        )
        dlg.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        dlg.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        if dlg.run() == Gtk.ResponseType.OK:
            self._entry_pkey.set_text(dlg.get_filename() or "")
        dlg.destroy()

    def get_dati(self) -> dict:
        proto = self._combo_proto.get_active_text() or "SFTP"
        return {
            "protocol":    "file_transfer",
            "ft_protocol": proto,
            "host":        self._entry_host.get_text().strip(),
            "port":        self._entry_port.get_text().strip(),
            "user":        self._entry_user.get_text().strip(),
            "password":    self._entry_pwd.get_text(),
            "private_key": self._entry_pkey.get_text().strip() if proto == "SFTP" else "",
            "ftp_tls":     proto == "FTPS",
            "ftp_passive": True,
        }


# ---------------------------------------------------------------------------
# Dialog sblocco password master (cifratura credenziali)
# ---------------------------------------------------------------------------

class _CryptoUnlockDialog(Gtk.Dialog):
    """Dialog modale per inserire la password master al primo avvio con crypto."""

    def __init__(self, parent=None):
        super().__init__(
            title=t("crypto.unlock.title"),
            transient_for=parent,
            modal=True,
            destroy_with_parent=True
        )
        self.set_default_size(360, 0)
        self._pwd = ""
        self._init_ui()
        self.show_all()

    def _init_ui(self):
        area = self.get_content_area()
        area.set_spacing(10)
        area.set_margin_start(16)
        area.set_margin_end(16)
        area.set_margin_top(16)
        area.set_margin_bottom(8)

        lbl = Gtk.Label()
        lbl.set_markup(f"<b>🔒 {t('crypto.unlock.title')}</b>\n"
                       f"<small>{t('crypto.unlock.prompt')}</small>")
        lbl.set_xalign(0.0)
        lbl.set_line_wrap(True)
        area.pack_start(lbl, False, False, 0)

        self._entry = Gtk.Entry()
        self._entry.set_visibility(False)
        self._entry.set_placeholder_text(t("crypto.password_label"))
        self._entry.connect("activate", lambda e: self.response(Gtk.ResponseType.OK))
        area.pack_start(self._entry, False, False, 0)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        ok = self.add_button(t("crypto.unlock.btn_ok"), Gtk.ResponseType.OK)
        ok.get_style_context().add_class("suggested-action")

    def get_password(self) -> str:
        return self._entry.get_text()

class PCMApp(Gtk.Application):

    def __init__(self):
        super().__init__(
            application_id="it.pcm.connectionmanager",
            flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE,
        )
        self.connect("activate", self._on_activate)
        self.connect("command-line", self._on_command_line)

    def _on_activate(self, app):
        apply_css()
        win = MainWindow(app)
        win.show_all()

    def _on_command_line(self, app, cmdline):
        args = cmdline.get_arguments()   # args[0] = nome programma
        uri = args[1] if len(args) > 1 else None

        # Porta la finestra principale in primo piano (o la crea)
        wins = self.get_windows()
        if not wins:
            self.activate()
            wins = self.get_windows()

        if wins:
            wins[0].present()
            if uri:
                GLib.idle_add(wins[0].apri_da_cli, uri)

        return 0


def main():
    _tr.init_from_settings()
    app = PCMApp()
    sys.exit(app.run(sys.argv))


if __name__ == "__main__":
    main()