GuGa 1.0.3__py3-none-any.whl

guga/alerter.py

@@ -0,0 +1,174 @@
+import asyncio
+import asyncio.subprocess
+import re
+import aiohttp
+import os
+import platform
+import sys
+from dotenv import load_dotenv
+
+CONFIG_DIR = os.path.expanduser("~/.guga")
+env_path = os.path.join(CONFIG_DIR, '.env')
+load_dotenv(dotenv_path=env_path)
+
+# Enforce Linux-only restriction
+if platform.system() != "Linux":
+    print("❌ ERROR: OS Notification monitoring only works on Linux (D-Bus required).")
+    print(f"Current OS: {platform.system()}")
+    sys.exit(1)
+
+# ------------------------------------------------------------
+# Configuration
+# ------------------------------------------------------------
+SERVER_URL = os.getenv("ALERTER_SERVER_URL", "http://localhost:6769/send")
+LOG_FILE = os.path.join(CONFIG_DIR, "alerter.log")
+
+# ------------------------------------------------------------
+# Text Cleaning (Stripping Formatting)
+# ------------------------------------------------------------
+def clean_text(text: str) -> str:
+    """
+    Strips HTML-like tags and common markdown formatting from text.
+    """
+    if not text:
+        return ""
+    
+    # 1. Strip HTML tags (e.g., <b>, <i>, <a href="...">)
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    # 2. Strip Markdown bold/italic/strike (e.g., **, *, __, _, ~~)
+    text = re.sub(r'(\*\*|__|\*|_|~~)', '', text)
+    
+    # 3. Strip Markdown links [text](url) -> text
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
+    
+    # 4. Strip excessive newlines and whitespace
+    text = re.sub(r'\n+', ' ', text)
+    text = text.strip()
+    
+    return text
+
+# ------------------------------------------------------------
+# Forwarding Logic
+# ------------------------------------------------------------
+async def forward_to_server(app_name: str, title: str, body: str):
+    """
+    Sends the cleaned notification to the local server's /send route.
+    """
+    clean_title = clean_text(title)
+    clean_body = clean_text(body)
+    
+    payload_msg = f"{clean_title}: {clean_body}"
+    if not clean_title and not clean_body:
+        return
+
+    log_entry = f"Forwarding: {payload_msg}\n"
+    print(log_entry.strip())
+    with open(LOG_FILE, "a") as f:
+        f.write(log_entry)
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(SERVER_URL, json={"message": payload_msg , "title":app_name}) as resp:
+                status_msg = f"Server Response: {resp.status}\n"
+                print(status_msg.strip())
+                with open(LOG_FILE, "a") as f:
+                    f.write(status_msg)
+    except Exception as e:
+        err_msg = f"Error forwarding: {e}\n"
+        print(err_msg.strip())
+        with open(LOG_FILE, "a") as f:
+            f.write(err_msg)
+
+# ------------------------------------------------------------
+# D-Bus Monitor via Subprocess
+# ------------------------------------------------------------
+async def monitor_notifications():
+    """
+    Runs dbus-monitor and parses its output to detect notifications.
+    """
+    # Explicitly filter for method_call to avoid duplicates from signals
+    cmd = ["dbus-monitor", "type='method_call',interface='org.freedesktop.Notifications',member='Notify'"]
+    
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT
+        )
+    except Exception as e:
+        print(f"Failed to start dbus-monitor: {e}")
+        return
+
+    if not proc.stdout:
+        print("Failed to capture dbus-monitor stdout.")
+        return
+
+    print("Monitoring D-Bus for notifications (method calls only)...")
+    
+    # State tracking
+    state = "IDLE"
+    app_name = ""
+    summary = ""
+    body = ""
+    
+    while True:
+        line_bytes = await proc.stdout.readline()
+        if not line_bytes:
+            break
+            
+        line = line_bytes.decode(errors='replace').strip()
+        
+        # Detect start of method call specifically
+        if "method call" in line and "interface=org.freedesktop.Notifications; member=Notify" in line:
+            state = "APP_NAME"
+            app_name = ""
+            summary = ""
+            body = ""
+            continue
+            
+        if state == "APP_NAME":
+            match = re.search(r'string\s+"(.*)"', line)
+            if match:
+                app_name = match.group(1)
+                state = "REPLACES_ID"
+        
+        elif state == "REPLACES_ID":
+            if "uint32" in line:
+                state = "ICON"
+                
+        elif state == "ICON":
+            match = re.search(r'string\s+"(.*)"', line)
+            if match:
+                state = "SUMMARY"
+                
+        elif state == "SUMMARY":
+            match = re.search(r'string\s+"(.*)"', line)
+            if match:
+                summary = match.group(1)
+                state = "BODY"
+                
+        elif state == "BODY":
+            # Body can be a string or we might see 'array [' if body is empty
+            match = re.search(r'string\s+"(.*)"', line)
+            if match:
+                body = match.group(1)
+                # Done capturing this notification
+                print(f"\n[Intercepted] App: {app_name}")
+                with open(LOG_FILE, "a") as f:
+                    f.write(f"\n[Intercepted] App: {app_name}\nTitle: {summary}\nBody: {body}\n")
+                asyncio.create_task(forward_to_server(app_name, summary, body))
+                state = "IDLE"
+            elif "array [" in line:
+                # Body was empty, moving to actions
+                print(f"\n[Intercepted] App: {app_name} (No body)")
+                with open(LOG_FILE, "a") as f:
+                    f.write(f"\n[Intercepted] App: {app_name}\nTitle: {summary}\nBody: (empty)\n")
+                asyncio.create_task(forward_to_server(app_name, summary, ""))
+                state = "IDLE"
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(monitor_notifications())
+    except KeyboardInterrupt:
+        print("\nStopping OS Notification Alerter...")

guga/cli.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""
+guga - Send notifications to your Android via the GuGa server.
+
+Auto-detected mode:
+  echo "msg" | guga
+  guga "Build finished"
+  guga python train.py
+
+Explicit mode (overrides auto-detection):
+  guga --message "build done"
+  guga --run calc maintenance.cobol
+"""
+
+import argparse
+import sys
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import time
+import urllib.request
+import urllib.error
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def format_duration(seconds):
+    seconds = int(seconds)
+    if seconds < 60:
+        return f"{seconds}s"
+    elif seconds < 3600:
+        m, s = divmod(seconds, 60)
+        return f"{m}m {s}s"
+    else:
+        h, rem = divmod(seconds, 3600)
+        m, _ = divmod(rem, 60)
+        return f"{h}h {m}m"
+
+
+def is_runnable(token):
+    return shutil.which(token) is not None or os.path.isfile(token)
+
+
+def last_meaningful_line(text):
+    lines = [l.strip() for l in text.splitlines() if l.strip()]
+    return lines[-1] if lines else None
+
+
+# ── Core actions ──────────────────────────────────────────────────────────────
+
+def send_notification(message, port, silent, title=None):
+    url = f"http://localhost:{port}/send"
+
+    payload = {"message": message}
+    if title:
+        payload["title"] = title
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=5) as response:
+            if not silent:
+                print(f"✅ Sent ({response.status}): {message}")
+    except urllib.error.URLError as e:
+        reason = getattr(e, "reason", str(e))
+        if not silent:
+            print(f"❌ Could not reach GuGa server on port {port}: {reason}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        if not silent:
+            print(f"❌ Unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def run_command(cmd_args, port, silent, title):
+    cmd_label = " ".join(cmd_args)
+    start = time.time()
+
+    if not silent:
+        print(f"▶ guga watching: {cmd_label}\n")
+
+    captured_lines = []
+    try:
+        process = subprocess.Popen(
+            cmd_args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+        for line in process.stdout:
+            print(line, end="")
+            captured_lines.append(line)
+
+        process.wait()
+        exit_code = process.returncode
+
+    except FileNotFoundError:
+        print(f"❌ Command not found: {cmd_args[0]}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        elapsed = format_duration(time.time() - start)
+        send_notification(f"⚠️ {cmd_label} interrupted after {elapsed}", port, silent, title)
+        sys.exit(130)
+
+    elapsed = format_duration(time.time() - start)
+    last_line = last_meaningful_line("".join(captured_lines))
+
+    status, verb = ("✅", "done") if exit_code == 0 else ("❌", f"failed (exit {exit_code})")
+    parts = [f"{status} {cmd_label} {verb} — {elapsed}"]
+    if last_line:
+        parts.append(last_line)
+
+    send_notification("\n".join(parts), port, silent, title)
+    sys.exit(exit_code)
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        prog="guga",
+        description="Send notifications to Android, or watch a command and notify on completion.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+mode flags (override auto-detection):
+  -m / --message    Force message mode — treat all args as a plain string.
+  -r / --run        Force run mode    — treat all args as a command to execute.
+
+auto-detection rules:
+  1. stdin piped, no args  →  message mode
+  2. single non-executable string  →  message mode
+  3. everything else  →  run mode
+
+examples:
+  echo "Deploy done" | guga                         # auto: message via stdin
+  guga "Build finished"                             # auto: plain message
+  guga python train.py --epochs 100                # auto: run mode
+  guga calc maintenance.cobol                      # auto: run mode
+
+  guga -m "build done"                             # explicit: message
+  guga -m "python train.py"                        # sends the literal string, does not run
+  guga -r "sleep 5"                                # explicit: run (splits into tokens)
+  guga -r ./deploy.sh --title "Prod Server"        # explicit: run + title
+
+  guga -r python train.py --silent --title "GPU"   # run silently, labelled notification
+
+setup & pairing:
+  guga --qr                                        # show pairing QR code
+  guga --show-pin                                  # show the latest pairing PIN
+  guga --install-service                           # initialise background service
+
+for more details:
+  man guga
+  tldr guga
+        """,
+    )
+
+    parser.add_argument(
+        "args",
+        nargs="*",
+        help="Message string, or command + arguments.",
+    )
+
+    # Proxy mode flags
+    proxy_mode = parser.add_mutually_exclusive_group()
+    proxy_mode.add_argument(
+        "--qr",
+        action="store_true",
+        help="Show the pairing QR code and exit.",
+    )
+    proxy_mode.add_argument(
+        "--show-pin",
+        action="store_true",
+        help="Show the most recent pairing PIN and exit.",
+    )
+    proxy_mode.add_argument(
+        "--install-service",
+        action="store_true",
+        help="Initializes the Linux background systemd service and components.",
+    )
+
+    # Explicit mode flags — mutually exclusive
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "-m", "--message",
+        action="store_true",
+        help="Force message mode. Joins all positional args as a single string.",
+    )
+    mode.add_argument(
+        "-r", "--run",
+        action="store_true",
+        help="Force run mode. Executes positional args as a command.",
+    )
+
+    parser.add_argument(
+        "--server",
+        type=int,
+        default=6769,
+        metavar="PORT",
+        help="GuGa server port (default: 6769).",
+    )
+    parser.add_argument(
+        "--silent",
+        action="store_true",
+        help="Suppress guga's own output.",
+    )
+    parser.add_argument(
+        "--title",
+        default=None,
+        metavar="LABEL",
+        help='Label shown in the notification, e.g. "GPU Server".',
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    
+    # ── Proxy modes ───────────────────────────────────────────────────────────
+    if args.install_service or args.qr or args.show_pin:
+        from guga.installer import run_system_installer
+        run_system_installer(qr_only=args.qr, pin_only=args.show_pin, setup_only=args.install_service)
+        return
+
+    positional = args.args
+
+    # ── Explicit message mode ─────────────────────────────────────────────────
+    if args.message:
+        if not positional:
+            # Fall back to stdin if no positional args given with --message
+            if not sys.stdin.isatty():
+                message = sys.stdin.read().strip()
+            else:
+                print("❌ --message requires a string argument.", file=sys.stderr)
+                sys.exit(1)
+        else:
+            message = " ".join(positional)   # join so --message hello world works too
+        send_notification(message, args.server, args.silent, args.title)
+        return
+
+    # ── Explicit run mode ─────────────────────────────────────────────────────
+    if args.run:
+        if not positional:
+            print("❌ --run requires a command to execute.", file=sys.stderr)
+            sys.exit(1)
+        # If the user passed a single quoted string like "sleep 1" or "python train.py --lr 0.01",
+        # split it into proper tokens so subprocess can execute it correctly.
+        if len(positional) == 1:
+            positional = shlex.split(positional[0])
+        run_command(positional, args.server, args.silent, args.title)
+        return
+
+    # ── Auto-detection ────────────────────────────────────────────────────────
+
+    # 1. Stdin pipe with no positional args
+    if not sys.stdin.isatty() and not positional:
+        message = sys.stdin.read().strip()
+        if not message:
+            print("❌ Received empty stdin.", file=sys.stderr)
+            sys.exit(1)
+        send_notification(message, args.server, args.silent, args.title)
+        return
+
+    # 2. Nothing at all
+    if not positional:
+        print("❌ No message or command provided.\n", file=sys.stderr)
+        print("Usage:", file=sys.stderr)
+        print('  echo "msg" | guga', file=sys.stderr)
+        print('  guga "msg"', file=sys.stderr)
+        print('  guga python train.py', file=sys.stderr)
+        print('  guga --message "msg"       # explicit message mode', file=sys.stderr)
+        print('  guga --run python train.py # explicit run mode', file=sys.stderr)
+        sys.exit(1)
+
+    # 3. Single non-executable string → message
+    if len(positional) == 1 and not is_runnable(positional[0]):
+        send_notification(positional[0], args.server, args.silent, args.title)
+        return
+
+    # 4. Otherwise → run mode
+    run_command(positional, args.server, args.silent, args.title)
+
+
+if __name__ == "__main__":
+    main()