h4-debug 0.1.1__tar.gz → 0.1.2__tar.gz

{h4_debug-0.1.1 → h4_debug-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h4-debug
-Version: 0.1.1
+Version: 0.1.2
 Summary: Advanced application proxy debugger and F12-style web console
 Author-email: h4 <h4@example.com>
 Requires-Python: >=3.8

h4_debug-0.1.2/h4_debug/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

{h4_debug-0.1.1 → h4_debug-0.1.2}/h4_debug/interceptor.py

@@ -7,13 +7,9 @@ import sys
 import threading
 import time
 import traceback
+import select
 from datetime import datetime
 
-try:
-    from websockets.sync.client import connect
-except ImportError:
-    connect = None
-
 # We must keep references to original functions to avoid infinite recursion
 _original_open = builtins.open
 _original_socket = socket.socket
@@ -27,37 +23,35 @@ class TelemetryClient:
         self.thread.start()
 
     def _run(self):
-        ws_url = f"ws://127.0.0.1:{self.port}/ws/telemetry"
-        if not connect:
-            return
-            
+        # Connect to the local TCP server spawned by h4-debug
+        server_port = self.port + 1
+        
         while True:
             try:
-                with connect(ws_url) as websocket:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as conn:
+                    conn.connect(("127.0.0.1", server_port))
+                    
                     while True:
                         # 1. Send all queued outgoing telemetry
                         while not self.queue.empty():
                             try:
                                 msg = self.queue.get_nowait()
-                                websocket.send(json.dumps(msg))
-                                self.queue.task_done()
+                                conn.sendall((json.dumps(msg) + "\n").encode("utf-8"))
                             except queue.Empty:
                                 break
                                 
                         # 2. Check for incoming commands (with short timeout)
-                        try:
-                            # Using recv(timeout) requires catching TimeoutError
-                            cmd_data = websocket.recv(timeout=0.05)
-                            self._handle_command(cmd_data)
-                        except TimeoutError:
-                            pass
-                        except Exception as e:
-                            # If it's not a timeout, might be a real error
-                            if "timed out" not in str(e).lower():
-                                raise
-                                
+                        r, _, _ = select.select([conn], [], [], 0.05)
+                        if r:
+                            data = conn.recv(4096)
+                            if not data:
+                                break # Connection closed
+                            for line in data.decode("utf-8").split("\n"):
+                                if line.strip():
+                                    self._handle_command(line)
+                                    
                         time.sleep(0.01)
-            except Exception as e:
+            except Exception:
                 time.sleep(1)
                 
     def _handle_command(self, cmd_data):

{h4_debug-0.1.1 → h4_debug-0.1.2}/h4_debug/server.py

@@ -10,7 +10,32 @@ app = FastAPI()
 
 # Store connected dashboard clients and the active telemetry process
 dashboard_clients = []
-active_telemetry_client = None
+active_telemetry_client = None  # This will now be a TCP socket
+
+# For broadcasting logs to WebSockets
+def broadcast_log(log_item_str):
+    try:
+        log_item = json.loads(log_item_str)
+        log_history.append(log_item)
+        if len(log_history) > MAX_HISTORY:
+            log_history.pop(0)
+    except Exception:
+        pass
+        
+    disconnected_clients = []
+    # Needs to be scheduled on the asyncio loop
+    async def _send(client):
+        try:
+            await client.send_text(log_item_str)
+        except Exception:
+            disconnected_clients.append(client)
+            
+    for client in dashboard_clients.copy():
+        asyncio.run_coroutine_threadsafe(_send(client), loop)
+        
+    for client in disconnected_clients:
+        if client in dashboard_clients:
+            dashboard_clients.remove(client)
 
 # To persist logs for when a dashboard connects slightly after startup
 log_history = []
@@ -31,40 +56,6 @@ async def get_dashboard():
             return HTMLResponse(f.read())
     return HTMLResponse("<h1>Dashboard not found</h1>")
 
-@app.websocket("/ws/telemetry")
-async def websocket_telemetry(websocket: WebSocket):
-    """Endpoint for the intercepted process to push logs and receive commands."""
-    global active_telemetry_client
-    await websocket.accept()
-    active_telemetry_client = websocket
-    
-    try:
-        while True:
-            data = await websocket.receive_text()
-            
-            try:
-                log_item = json.loads(data)
-                log_history.append(log_item)
-                if len(log_history) > MAX_HISTORY:
-                    log_history.pop(0)
-            except Exception:
-                pass
-                
-            # Broadcast to all dashboards
-            disconnected_clients = []
-            for client in dashboard_clients:
-                try:
-                    await client.send_text(data)
-                except Exception:
-                    disconnected_clients.append(client)
-            
-            for client in disconnected_clients:
-                if client in dashboard_clients:
-                    dashboard_clients.remove(client)
-    except WebSocketDisconnect:
-        if active_telemetry_client == websocket:
-            active_telemetry_client = None
-
 @app.websocket("/ws/dashboard")
 async def websocket_dashboard(websocket: WebSocket):
     """Endpoint for the web dashboard to receive logs and send commands."""
@@ -87,20 +78,60 @@ async def websocket_dashboard(websocket: WebSocket):
             if cmd.get("action") == "clear":
                 log_history.clear()
             elif cmd.get("action") in ["evaluate", "set_mode"]:
-                # Forward commands to the active telemetry process
+                # Forward commands to the active telemetry process via TCP
                 if active_telemetry_client:
                     try:
-                        await active_telemetry_client.send_text(json.dumps(cmd))
+                        active_telemetry_client.sendall((json.dumps(cmd) + "\n").encode("utf-8"))
                     except Exception:
-                        pass
+                        active_telemetry_client = None
     except WebSocketDisconnect:
         if websocket in dashboard_clients:
             dashboard_clients.remove(websocket)
 
+import socket
+import threading
+
+def run_tcp_server(port: int):
+    global active_telemetry_client
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server.bind(("127.0.0.1", port + 1))
+    server.listen(1)
+    
+    while True:
+        conn, addr = server.accept()
+        active_telemetry_client = conn
+        
+        def handle_client(c):
+            global active_telemetry_client
+            f = c.makefile("r", encoding="utf-8")
+            try:
+                while True:
+                    line = f.readline()
+                    if not line:
+                        break
+                    broadcast_log(line)
+            except Exception:
+                pass
+            finally:
+                if active_telemetry_client == c:
+                    active_telemetry_client = None
+                c.close()
+                
+        threading.Thread(target=handle_client, args=(conn,), daemon=True).start()
+
 def run_server(port: int):
     # Disable uvicorn access logs to keep terminal clean
     import logging
     log = logging.getLogger("uvicorn.access")
     log.setLevel(logging.WARNING)
     
-    uvicorn.run(app, host="127.0.0.1", port=port, log_level="warning")
+    global loop
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    threading.Thread(target=run_tcp_server, args=(port,), daemon=True).start()
+    
+    config = uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning", loop="asyncio")
+    server = uvicorn.Server(config)
+    loop.run_until_complete(server.serve())

{h4_debug-0.1.1 → h4_debug-0.1.2}/h4_debug.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h4-debug
-Version: 0.1.1
+Version: 0.1.2
 Summary: Advanced application proxy debugger and F12-style web console
 Author-email: h4 <h4@example.com>
 Requires-Python: >=3.8

{h4_debug-0.1.1 → h4_debug-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "h4-debug"
-version = "0.1.1"
+version = "0.1.2"
 description = "Advanced application proxy debugger and F12-style web console"
 readme = "README.md"
 requires-python = ">=3.8"

h4_debug-0.1.1/h4_debug/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.1"