Autore: UMNW

sudo apt update
sudo apt install -y python3-gi gir1.2-appindicator3-0.1 python3-gi-cairo gir1.2-notify-0.7

echo "$USER ALL=NOPASSWD: /bin/systemctl start wg-quick@wg0, /bin/systemctl stop wg-quick@wg0, /bin/systemctl restart wg-quick@wg0" \
| sudo tee /etc/sudoers.d/wg-indicator

sudo visudo -cf /etc/sudoers.d/wg-indicator

#!/usr/bin/env python3
import os, subprocess, pathlib
import gi
gi.require_version('AppIndicator3', '0.1')
gi.require_version('Gtk', '3.0')
gi.require_version('Notify', '0.7')
from gi.repository import AppIndicator3, Gtk, GLib, Notify, GdkPixbuf

SERVICE = "wg-quick@wg0"
APP_ID  = "wg-indicator"
ICON_DIR = os.path.join(pathlib.Path.home(), ".local", "share", "wg-indicator")
ICONS = {
    "green": os.path.join(ICON_DIR, "dot-green.png"),
    "grey":  os.path.join(ICON_DIR, "dot-grey.png"),
    "red":   os.path.join(ICON_DIR, "dot-red.png"),
}

# stato precedente per notifiche su cambio stato
last_state = None

def ensure_icons():
    os.makedirs(ICON_DIR, exist_ok=True)
    try:
        from PIL import Image, ImageDraw  # se Pillow c'è, icone più “tonde”
        for name, color in (("green",(0,185,0)), ("grey",(140,140,140)), ("red",(220,0,0))):
            path = ICONS[name]
            if not os.path.exists(path):
                img = Image.new("RGBA", (24,24), (0,0,0,0))
                d = ImageDraw.Draw(img)
                d.ellipse((3,3,21,21), fill=color+(255,), outline=(0,0,0,40))
                img.save(path, "PNG")
    except Exception:
        # fallback senza Pillow
        for name, rgba in (("green",(0,185,0,255)), ("grey",(140,140,140,255)), ("red",(220,0,0,255))):
            path = ICONS[name]
            if os.path.exists(path): 
                continue
            pix = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 24, 24)
            pix.fill(0x00000000)
            rs, gs, bs, a = rgba
            rowstride = pix.get_rowstride()
            pixels = pix.get_pixels()
            for y in range(24):
                for x in range(24):
                    dx, dy = x-12, y-12
                    if dx*dx + dy*dy <= 9*9:
                        off = y*rowstride + x*4
                        pixels[off+0] = rs
                        pixels[off+1] = gs
                        pixels[off+2] = bs
                        pixels[off+3] = a
            pix.savev(path, "png", [], [])

def svc_status():
    try:
        out = subprocess.check_output(["systemctl","is-active",SERVICE], text=True).strip()
    except subprocess.CalledProcessError:
        out = "inactive"
    if out in ("active","inactive","activating","deactivating","reloading"):
        return out
    try:
        f = subprocess.check_output(["systemctl","is-failed",SERVICE], text=True).strip()
        if f == "failed":
            return "failed"
    except subprocess.CalledProcessError:
        pass
    return "unknown"

def human_status(state):
    return {
        "active":"Active",
        "inactive":"Stopped",
        "activating":"Starting…",
        "deactivating":"Stopping…",
        "reloading":"Reloading…",
        "failed":"Error",
        "unknown":"Error",
    }.get(state, "Error")

def color_for_status(state):
    if state == "active": return "green"
    if state in ("inactive","activating","deactivating","reloading"): return "grey"
    return "red"  # failed/unknown

def icon_for_status(state):
    return ICONS[color_for_status(state)]

def notify_status(prefix=None, state=None):
    if state is None:
        state = svc_status()
    text = human_status(state)
    title = "WireGuard Indicator"
    body = f"{('' if not prefix else prefix + ' ')}Current status: {text}"
    n = Notify.Notification.new(title, body, None)
    n.set_timeout(3000)
    try: n.show()
    except: pass

def update_status_label(state):
    # Aggiorna la label "Current status: X" con X colorato
    global status_label
    color = color_for_status(state)
    text = human_status(state)
    status_label.set_markup(f'<span alpha="80%">Current status: </span>'
                            f'<span weight="bold" foreground="{color}">{text}</span>')

def refresh(ind):
    global last_state
    state = svc_status()
    ind.set_icon_full(icon_for_status(state), f"WireGuard: {human_status(state)}")
    ind.set_label("", "")  # niente testo accanto all’icona
    update_status_label(state)
    if last_state is None:
        # notifica all’avvio (load)
        notify_status(prefix="", state=state)
    elif state != last_state:
        # notifica su ogni cambio stato (anche se avviene fuori dal menu)
        notify_status(prefix="", state=state)
    last_state = state
    return True

def run_cmd(cmd, verb):
    try:
        subprocess.check_call(["sudo","-n"] + cmd)
        # La notifica “di conferma” la facciamo dopo, quando rileviamo lo stato aggiornato
        # (così è affidabile). Però diamo un hint immediato:
        notify_status(prefix=f"{verb} requested.", state=None)
    except subprocess.CalledProcessError:
        # Chiede autorizzazione grafica
        ret = subprocess.call(["pkexec"] + cmd)
        if ret != 0:
            n = Notify.Notification.new("WireGuard Indicator", f"{verb} failed (authorization?)", None)
            n.set_timeout(3000)
            try: n.show()
            except: pass
    # Aggiorna subito l’icona; ulteriori cambi verranno col polling
    GLib.idle_add(refresh, indicator)

def on_start(_):   run_cmd(["/bin/systemctl","start",SERVICE], "Start")
def on_stop(_):    run_cmd(["/bin/systemctl","stop",SERVICE], "Stop")
def on_restart(_): run_cmd(["/bin/systemctl","restart",SERVICE], "Restart")

def on_quit(_):
    # Notifica finale con stato corrente e poi quit
    notify_status(prefix="", state=svc_status())
    Gtk.main_quit()

def build_menu():
    global status_label
    menu = Gtk.Menu()

    for label, cb in (("Start", on_start), ("Stop", on_stop), ("Restart", on_restart)):
        item = Gtk.MenuItem(label=label); item.connect("activate", cb); menu.append(item)

    menu.append(Gtk.SeparatorMenuItem())

    quit_item = Gtk.MenuItem(label="Quit")
    quit_item.connect("activate", on_quit)
    menu.append(quit_item)

    # Status non cliccabile, sotto Quit
    menu.append(Gtk.SeparatorMenuItem())
    status_item = Gtk.MenuItem()
    status_item.set_sensitive(False)  # non cliccabile
    status_label = Gtk.Label()
    status_label.set_use_markup(True)
    status_label.set_xalign(0.0)
    status_item.add(status_label)
    status_item.show_all()
    menu.append(status_item)

    menu.show_all()
    return menu

# ---- main
ensure_icons()
Notify.init(APP_ID)

indicator = AppIndicator3.Indicator.new(APP_ID, ICONS["grey"], AppIndicator3.IndicatorCategory.SYSTEM_SERVICES)
indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
indicator.set_menu(build_menu())

# primo refresh + polling
refresh(indicator)
GLib.timeout_add_seconds(3, lambda: refresh(indicator))
Gtk.main()

chmod +x ~/.local/bin/wg-indicator.py
~/.local/bin/wg-indicator.py

mkdir -p ~/.config/autostart
cat > ~/.config/autostart/wg-indicator.desktop <<'EOF'
[Desktop Entry]
Type=Application
Name=WireGuard Indicator
Exec=/usr/bin/env python3 /home/YOURUSER/.local/bin/wg-indicator.py
X-GNOME-Autostart-enabled=true
EOF