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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h4-debug
-Version: 0.1.0
+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.0 → 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,24 +23,80 @@ 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:
-                # Use original socket context if websockets internally creates sockets
-                # This might be tricky because websockets uses asyncio or sync wrappers 
-                # which use the monkeypatched socket. We must be very careful.
-                # A safer approach for the telemetry thread is to unpatch socket temporarily or 
-                # ensure our hooks bypass if thread == telemetry_thread
-                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:
-                        msg = self.queue.get()
-                        websocket.send(json.dumps(msg))
-                        self.queue.task_done()
-            except Exception as e:
+                        # 1. Send all queued outgoing telemetry
+                        while not self.queue.empty():
+                            try:
+                                msg = self.queue.get_nowait()
+                                conn.sendall((json.dumps(msg) + "\n").encode("utf-8"))
+                            except queue.Empty:
+                                break
+                                
+                        # 2. Check for incoming commands (with short timeout)
+                        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:
                 time.sleep(1)
+                
+    def _handle_command(self, cmd_data):
+        try:
+            cmd = json.loads(cmd_data)
+            action = cmd.get("action")
+            
+            if action == "set_mode":
+                new_mode = cmd.get("mode", "Normal")
+                global _mode
+                _mode = new_mode
+                
+                self.send("System", "info", {"text": f"Mode changed to {_mode}"})
+                
+            elif action == "evaluate":
+                code = cmd.get("code", "")
+                result = None
+                is_error = False
+                
+                # Try eval first, then exec
+                try:
+                    result = eval(code, globals())
+                except SyntaxError:
+                    try:
+                        # Capture stdout for exec
+                        import io
+                        old_stdout = sys.stdout
+                        sys.stdout = capture = io.StringIO()
+                        exec(code, globals())
+                        sys.stdout = old_stdout
+                        result = capture.getvalue()
+                    except Exception as e:
+                        is_error = True
+                        result = traceback.format_exc()
+                except Exception as e:
+                    is_error = True
+                    result = traceback.format_exc()
+                
+                self.send("Console", "eval_result", {
+                    "code": code,
+                    "result": str(result),
+                    "is_error": is_error
+                })
+        except Exception:
+            pass
 
     def send(self, module, event_type, data):
         msg = {
@@ -148,20 +200,27 @@ def trace_calls(frame, event, arg):
     if _is_telemetry_thread() or not _telemetry:
         return trace_calls
         
-    if event == "call":
-        func_name = frame.f_code.co_name
-        filename = frame.f_code.co_filename
-        # Ignore our own files and standard library to avoid noise, unless Full Debug
-        if "h4_debug" not in filename and ("site-packages" not in filename or _mode == "Full"):
+    if _mode == "Normal":
+        return trace_calls
+
+    filename = frame.f_code.co_filename
+    if "h4_debug" in filename or "websockets" in filename:
+        return trace_calls # Ignore our own debugger code
+
+    is_user_code = "site-packages" not in filename and "lib" not in filename.lower()
+    
+    if _mode == "Trace":
+        if not is_user_code:
+            return trace_calls
+            
+        if event == "call":
             _telemetry.send("Execution", "call", {
-                "function": func_name,
+                "function": frame.f_code.co_name,
                 "file": filename,
                 "line": frame.f_lineno
             })
-    elif event == "exception" and _mode in ("Trace", "Full"):
-        exc_type, exc_value, exc_traceback = arg
-        filename = frame.f_code.co_filename
-        if "h4_debug" not in filename:
+        elif event == "exception":
+            exc_type, exc_value, _ = arg
             _telemetry.send("Execution", "exception", {
                 "type": exc_type.__name__,
                 "value": str(exc_value),
@@ -169,6 +228,28 @@ def trace_calls(frame, event, arg):
                 "line": frame.f_lineno
             })
             
+    elif _mode == "Full":
+        if event == "line" and is_user_code:
+            _telemetry.send("Execution", "line", {
+                "function": frame.f_code.co_name,
+                "file": filename,
+                "line": frame.f_lineno
+            })
+        elif event in ("call", "return"):
+            _telemetry.send("Execution", event, {
+                "function": frame.f_code.co_name,
+                "file": filename,
+                "line": frame.f_lineno
+            })
+        elif event == "exception":
+            exc_type, exc_value, _ = arg
+            _telemetry.send("Execution", "exception", {
+                "type": exc_type.__name__,
+                "value": str(exc_value),
+                "file": filename,
+                "line": frame.f_lineno
+            })
+
     return trace_calls
 
 def start_interception(mode="Normal"):
@@ -189,9 +270,12 @@ def start_interception(mode="Normal"):
     sys.stdout = PatchedStream(sys.stdout, "stdout")
     sys.stderr = PatchedStream(sys.stderr, "stderr")
     
-    # Enable Tracing if required
-    if mode in ("Trace", "Full"):
-        sys.settrace(trace_calls)
+    # ALWAYS enable Tracing so dynamic mode switching works later
+    sys.settrace(trace_calls)
         
-    _telemetry.send("System", "init", {"mode": mode, "pid": os.getpid()})
-
+    _telemetry.send("System", "init", {
+        "mode": mode,
+        "pid": os.getpid(),
+        "language": "python",
+        "version": sys.version
+    })

h4_debug-0.1.2/h4_debug/server.py

@@ -0,0 +1,137 @@
+import asyncio
+import json
+import os
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+
+app = FastAPI()
+
+# Store connected dashboard clients and the active telemetry process
+dashboard_clients = []
+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 = []
+MAX_HISTORY = 5000
+
+# Get the path to static files
+STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
+if not os.path.exists(STATIC_DIR):
+    os.makedirs(STATIC_DIR)
+
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+@app.get("/")
+async def get_dashboard():
+    dashboard_path = os.path.join(STATIC_DIR, "dashboard.html")
+    if os.path.exists(dashboard_path):
+        with open(dashboard_path, "r", encoding="utf-8") as f:
+            return HTMLResponse(f.read())
+    return HTMLResponse("<h1>Dashboard not found</h1>")
+
+@app.websocket("/ws/dashboard")
+async def websocket_dashboard(websocket: WebSocket):
+    """Endpoint for the web dashboard to receive logs and send commands."""
+    await websocket.accept()
+    
+    # Send history on connect
+    for log_item in log_history:
+        try:
+            await websocket.send_text(json.dumps(log_item))
+        except Exception:
+            break
+            
+    dashboard_clients.append(websocket)
+    try:
+        while True:
+            # Receive commands from dashboard
+            data = await websocket.receive_text()
+            cmd = json.loads(data)
+            
+            if cmd.get("action") == "clear":
+                log_history.clear()
+            elif cmd.get("action") in ["evaluate", "set_mode"]:
+                # Forward commands to the active telemetry process via TCP
+                if active_telemetry_client:
+                    try:
+                        active_telemetry_client.sendall((json.dumps(cmd) + "\n").encode("utf-8"))
+                    except Exception:
+                        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)
+    
+    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.2/h4_debug/static/dashboard.css

@@ -0,0 +1,307 @@
+:root {
+    --bg-primary: #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover: #2a2d2e;
+    --border-color: #3e3e42;
+    --text-primary: #d4d4d4;
+    --text-secondary: #cccccc;
+    --accent: #007acc;
+    --danger: #f14c4c;
+    --warning: #cca700;
+    --success: #89d185;
+    --font-family: 'Consolas', 'Courier New', monospace;
+}
+
+@media (prefers-color-scheme: light) {
+    body:not(.theme-dark) {
+        --bg-primary: #ffffff;
+        --bg-secondary: #f3f3f3;
+        --bg-hover: #e8e8e8;
+        --border-color: #cccccc;
+        --text-primary: #333333;
+        --text-secondary: #666666;
+        --accent: #0078d4;
+    }
+}
+
+body.theme-light {
+    --bg-primary: #ffffff;
+    --bg-secondary: #f3f3f3;
+    --bg-hover: #e8e8e8;
+    --border-color: #cccccc;
+    --text-primary: #333333;
+    --text-secondary: #666666;
+    --accent: #0078d4;
+}
+
+body.theme-dark {
+    --bg-primary: #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover: #2a2d2e;
+    --border-color: #3e3e42;
+    --text-primary: #d4d4d4;
+    --text-secondary: #cccccc;
+    --accent: #007acc;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    height: 100vh;
+    overflow: hidden;
+}
+
+.app-container {
+    display: flex;
+    height: 100%;
+}
+
+/* Sidebar */
+.sidebar {
+    width: 250px;
+    background-color: var(--bg-secondary);
+    border-right: 1px solid var(--border-color);
+    display: flex;
+    flex-direction: column;
+}
+
+.logo {
+    padding: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.logo h1 {
+    font-size: 1.2rem;
+    font-weight: 600;
+}
+
+.status-indicator {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background-color: var(--danger);
+    transition: background-color 0.3s ease;
+}
+.status-indicator.connected {
+    background-color: var(--success);
+}
+
+.nav-links {
+    list-style: none;
+    flex-grow: 1;
+}
+
+.nav-links li {
+    padding: 15px 20px;
+    cursor: pointer;
+    transition: background 0.2s;
+    border-left: 3px solid transparent;
+}
+
+.nav-links li:hover {
+    background-color: var(--bg-hover);
+}
+
+.nav-links li.active {
+    background-color: var(--bg-hover);
+    border-left-color: var(--accent);
+    font-weight: bold;
+}
+
+.controls {
+    padding: 20px;
+    display: flex;
+    gap: 10px;
+    flex-direction: column;
+}
+
+button {
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+    padding: 8px 12px;
+    cursor: pointer;
+    border-radius: 4px;
+    transition: background 0.2s;
+}
+
+button:hover {
+    background-color: var(--bg-hover);
+}
+
+/* Main Content */
+.content-area {
+    flex-grow: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+.toolbar {
+    padding: 10px 20px;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    background-color: var(--bg-secondary);
+}
+
+.toolbar input {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 6px 12px;
+    border-radius: 4px;
+    width: 300px;
+}
+
+.toggles label {
+    margin-left: 15px;
+    font-size: 0.9rem;
+    cursor: pointer;
+}
+
+.tab-content {
+    display: none;
+    flex-grow: 1;
+    overflow: hidden;
+}
+
+.tab-content.active {
+    display: flex;
+    flex-direction: column;
+}
+
+.log-container {
+    flex-grow: 1;
+    overflow-y: auto;
+    padding: 10px;
+    font-family: var(--font-family);
+    font-size: 0.9rem;
+}
+
+/* Log Entries */
+.log-entry {
+    padding: 4px 8px;
+    border-bottom: 1px solid var(--border-color);
+    word-wrap: break-word;
+    display: flex;
+    gap: 10px;
+}
+
+.log-entry:hover {
+    background-color: var(--bg-hover);
+}
+
+.log-time {
+    color: var(--text-secondary);
+    min-width: 90px;
+}
+
+.log-module {
+    color: var(--accent);
+    min-width: 80px;
+}
+
+.log-data {
+    flex-grow: 1;
+    white-space: pre-wrap;
+}
+
+/* Specific log types */
+.log-entry.error .log-data { color: var(--danger); }
+.log-entry.warn .log-data { color: var(--warning); }
+.log-entry.system .log-data { color: var(--success); }
+.log-entry.eval_result .log-data { color: var(--accent); font-weight: bold; }
+.log-entry.eval_result.error .log-data { color: var(--danger); font-weight: normal; }
+
+/* REPL Console Input */
+.repl-container {
+    display: flex;
+    padding: 10px;
+    border-top: 1px solid var(--border-color);
+    background-color: var(--bg-secondary);
+    align-items: center;
+}
+
+.repl-prompt {
+    color: var(--accent);
+    font-weight: bold;
+    margin-right: 10px;
+    font-family: var(--font-family);
+}
+
+#repl-input {
+    flex-grow: 1;
+    background: transparent;
+    border: none;
+    color: var(--text-primary);
+    font-family: var(--font-family);
+    font-size: 0.9rem;
+    outline: none;
+}
+
+/* Split View for Network */
+.split-view {
+    display: flex;
+    height: 100%;
+}
+.list-pane {
+    width: 50%;
+    border-right: 1px solid var(--border-color);
+    overflow-y: auto;
+}
+.detail-pane {
+    width: 50%;
+    padding: 20px;
+    overflow-y: auto;
+    font-family: var(--font-family);
+    white-space: pre-wrap;
+}
+
+.network-item {
+    padding: 8px 10px;
+    border-bottom: 1px solid var(--border-color);
+    cursor: pointer;
+    font-family: var(--font-family);
+    font-size: 0.85rem;
+}
+.network-item:hover, .network-item.selected {
+    background-color: var(--bg-hover);
+}
+
+/* Context Menu */
+.context-menu {
+    display: none;
+    position: absolute;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    box-shadow: 0 2px 10px rgba(0,0,0,0.5);
+    z-index: 1000;
+    border-radius: 4px;
+    min-width: 150px;
+}
+
+.context-menu ul {
+    list-style: none;
+}
+
+.context-menu li {
+    padding: 8px 15px;
+    cursor: pointer;
+    font-size: 0.9rem;
+}
+
+.context-menu li:hover {
+    background-color: var(--accent);
+    color: white;
+}

h4_debug-0.1.2/h4_debug/static/dashboard.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>h4-debug | Advanced Telemetry</title>
+    <link rel="stylesheet" href="/static/dashboard.css">
+</head>
+<body>
+    <div class="app-container">
+        <!-- Sidebar / Navigation -->
+        <nav class="sidebar">
+            <div class="logo">
+                <h1>h4-debug</h1>
+                <span class="status-indicator"></span>
+            </div>
+            <ul class="nav-links">
+                <li data-tab="console" class="active">Console</li>
+                <li data-tab="network">Network</li>
+                <li data-tab="disk">Disk / Source</li>
+                <li data-tab="execution">Execution</li>
+            </ul>
+            <div class="controls">
+                <button id="btn-clear">Clear Logs</button>
+                <button id="btn-export">Export JSON</button>
+            </div>
+        </nav>
+
+        <!-- Main Content Area -->
+        <main class="content-area">
+            
+            <!-- Toolbar -->
+            <div class="toolbar">
+                <input type="text" id="filter-input" placeholder="Filter logs...">
+                <div class="toggles">
+                    <label>Mode: 
+                        <select id="mode-select">
+                            <option value="Normal">Normal</option>
+                            <option value="Trace">Trace</option>
+                            <option value="Full">Full Debug</option>
+                        </select>
+                    </label>
+                    <label>Theme: 
+                        <select id="theme-select">
+                            <option value="system">System</option>
+                            <option value="dark">Dark</option>
+                            <option value="light">Light</option>
+                        </select>
+                    </label>
+                    <label><input type="checkbox" id="toggle-info" checked> Info</label>
+                    <label><input type="checkbox" id="toggle-warn" checked> Warn</label>
+                    <label><input type="checkbox" id="toggle-error" checked> Error</label>
+                </div>
+            </div>
+
+            <!-- Tab Contents -->
+            <div id="tab-console" class="tab-content active">
+                <div class="log-container" id="console-logs"></div>
+                <div class="repl-container">
+                    <span class="repl-prompt">&gt;</span>
+                    <input type="text" id="repl-input" placeholder="Evaluate expression...">
+                </div>
+            </div>
+
+            <div id="tab-network" class="tab-content">
+                <div class="split-view">
+                    <div class="list-pane" id="network-logs"></div>
+                    <div class="detail-pane" id="network-details">Select a request to view details</div>
+                </div>
+            </div>
+
+            <div id="tab-disk" class="tab-content">
+                <div class="log-container" id="disk-logs"></div>
+            </div>
+
+            <div id="tab-execution" class="tab-content">
+                <div class="log-container" id="execution-logs"></div>
+            </div>
+
+        </main>
+    </div>
+
+    <!-- Custom Context Menu -->
+    <div id="context-menu" class="context-menu">
+        <ul>
+            <li id="menu-copy">Copy</li>
+            <li id="menu-copy-curl">Copy as cURL</li>
+            <li id="menu-copy-hex">Copy Hex Dump</li>
+        </ul>
+    </div>
+
+    <script src="/static/dashboard.js"></script>
+</body>
+</html>

h4_debug-0.1.2/h4_debug/static/dashboard.js

@@ -0,0 +1,317 @@
+document.addEventListener('DOMContentLoaded', () => {
+    // UI Elements
+    const tabs = document.querySelectorAll('.nav-links li');
+    const tabContents = document.querySelectorAll('.tab-content');
+    const statusIndicator = document.querySelector('.status-indicator');
+    const filterInput = document.getElementById('filter-input');
+    const modeSelect = document.getElementById('mode-select');
+    const themeSelect = document.getElementById('theme-select');
+    const replInput = document.getElementById('repl-input');
+    
+    const containers = {
+        console: document.getElementById('console-logs'),
+        network: document.getElementById('network-logs'),
+        disk: document.getElementById('disk-logs'),
+        execution: document.getElementById('execution-logs')
+    };
+    
+    const networkDetails = document.getElementById('network-details');
+    
+    let allLogs = [];
+    let ws = null;
+    let selectedNetworkLog = null;
+
+    // Tabs logic
+    tabs.forEach(tab => {
+        tab.addEventListener('click', () => {
+            tabs.forEach(t => t.classList.remove('active'));
+            tabContents.forEach(c => c.classList.remove('active'));
+            
+            tab.classList.add('active');
+            const targetId = `tab-${tab.dataset.tab}`;
+            document.getElementById(targetId).classList.add('active');
+        });
+    });
+
+    // WebSocket Connection
+    function connectWS() {
+        ws = new WebSocket(`ws://${window.location.host}/ws/dashboard`);
+        
+        ws.onopen = () => {
+            statusIndicator.classList.add('connected');
+            appendLog({
+                timestamp: new Date().toISOString(),
+                module: 'System',
+                type: 'info',
+                data: { text: 'Dashboard connected to proxy backend.' }
+            });
+        };
+        
+        ws.onclose = () => {
+            statusIndicator.classList.remove('connected');
+            setTimeout(connectWS, 2000); // Reconnect
+        };
+        
+        ws.onmessage = (event) => {
+            try {
+                const log = JSON.parse(event.data);
+                allLogs.push(log);
+                processLog(log);
+            } catch (e) {
+                console.error("Failed to parse log", e);
+            }
+        };
+    }
+    
+    connectWS();
+
+    // Log Processing
+    function processLog(log) {
+        if (!passesFilter(log, filterInput.value)) return;
+        
+        const timeStr = new Date(log.timestamp).toLocaleTimeString([], {hour12: false, fractionalSecondDigits: 3});
+        
+        if (log.module === 'Network') {
+            renderNetworkLog(log, timeStr);
+        } else if (log.module === 'Disk') {
+            renderBasicLog(containers.disk, log, timeStr);
+        } else if (log.module === 'Execution') {
+            renderBasicLog(containers.execution, log, timeStr);
+        } else if (log.module === 'Console') {
+            if (log.type === 'eval_result') {
+                renderEvalResult(containers.console, log, timeStr);
+            } else {
+                renderBasicLog(containers.console, log, timeStr);
+            }
+        } else if (log.module === 'System') {
+            if (log.type === 'init' && log.data.language) {
+                replInput.placeholder = `Evaluate ${log.data.language} expression...`;
+                if (log.data.mode) modeSelect.value = log.data.mode;
+            }
+            renderBasicLog(containers.console, log, timeStr, 'system');
+        } else {
+            renderBasicLog(containers.console, log, timeStr);
+        }
+    }
+
+    function renderBasicLog(container, log, timeStr, customClass='') {
+        const el = document.createElement('div');
+        el.className = `log-entry ${customClass}`;
+        el.dataset.raw = JSON.stringify(log);
+        
+        const timeEl = document.createElement('div');
+        timeEl.className = 'log-time';
+        timeEl.textContent = timeStr;
+        
+        const modEl = document.createElement('div');
+        modEl.className = 'log-module';
+        modEl.textContent = `[${log.module}]`;
+        
+        const dataEl = document.createElement('div');
+        dataEl.className = 'log-data';
+        
+        if (log.data && log.data.text) {
+            dataEl.textContent = log.data.text;
+            if (log.type === 'stderr' || log.type === 'exception') el.classList.add('error');
+        } else {
+            dataEl.textContent = JSON.stringify(log.data);
+        }
+        
+        el.appendChild(timeEl);
+        el.appendChild(modEl);
+        el.appendChild(dataEl);
+        
+        container.appendChild(el);
+        scrollToBottom(container);
+    }
+    
+    function renderEvalResult(container, log, timeStr) {
+        const el = document.createElement('div');
+        el.className = 'log-entry eval_result' + (log.data.is_error ? ' error' : '');
+        el.dataset.raw = JSON.stringify(log);
+        
+        const timeEl = document.createElement('div');
+        timeEl.className = 'log-time';
+        timeEl.textContent = timeStr;
+        
+        const modEl = document.createElement('div');
+        modEl.className = 'log-module';
+        modEl.textContent = `[Eval]`;
+        
+        const dataEl = document.createElement('div');
+        dataEl.className = 'log-data';
+        dataEl.textContent = log.data.result;
+        
+        el.appendChild(timeEl);
+        el.appendChild(modEl);
+        el.appendChild(dataEl);
+        
+        container.appendChild(el);
+        scrollToBottom(container);
+    }
+    
+    function renderNetworkLog(log, timeStr) {
+        const el = document.createElement('div');
+        el.className = 'network-item';
+        el.dataset.raw = JSON.stringify(log);
+        
+        let preview = '';
+        if (log.type === 'connect') preview = `CONNECT ${log.data.address}`;
+        else if (log.type === 'send') preview = `SEND ${log.data.bytes} bytes to ${log.data.address}`;
+        else if (log.type === 'recv') preview = `RECV ${log.data.bytes} bytes from ${log.data.address}`;
+        
+        el.textContent = `${timeStr} - ${preview}`;
+        
+        el.addEventListener('click', () => {
+            document.querySelectorAll('.network-item').forEach(i => i.classList.remove('selected'));
+            el.classList.add('selected');
+            selectedNetworkLog = log;
+            renderNetworkDetails(log);
+        });
+        
+        containers.network.appendChild(el);
+        scrollToBottom(containers.network);
+    }
+    
+    function renderNetworkDetails(log) {
+        let html = `<h3>Network Event: ${log.type}</h3>`;
+        html += `<div><strong>Time:</strong> ${log.timestamp}</div>`;
+        if (log.data.address) html += `<div><strong>Address:</strong> ${log.data.address}</div>`;
+        if (log.data.bytes) html += `<div><strong>Bytes:</strong> ${log.data.bytes}</div>`;
+        
+        if (log.data.payload_text) {
+            html += `<h4>Payload (Text)</h4><pre>${escapeHtml(log.data.payload_text)}</pre>`;
+        }
+        if (log.data.payload_hex) {
+            html += `<h4>Payload (Hex)</h4><pre>${log.data.payload_hex}</pre>`;
+        }
+        
+        networkDetails.innerHTML = html;
+    }
+    
+    function escapeHtml(unsafe) {
+        return (unsafe || '').toString()
+             .replace(/&/g, "&amp;")
+             .replace(/</g, "&lt;")
+             .replace(/>/g, "&gt;")
+             .replace(/"/g, "&quot;")
+             .replace(/'/g, "&#039;");
+    }
+
+    function scrollToBottom(el) {
+        if (el.scrollHeight - el.scrollTop < el.clientHeight + 100) {
+            el.scrollTop = el.scrollHeight;
+        }
+    }
+
+    function passesFilter(log, term) {
+        if (!term) return true;
+        return JSON.stringify(log).toLowerCase().includes(term.toLowerCase());
+    }
+
+    // Filter Logic
+    filterInput.addEventListener('input', () => {
+        Object.values(containers).forEach(c => c.innerHTML = '');
+        allLogs.forEach(processLog);
+    });
+
+    // Mode Toggle Logic
+    modeSelect.addEventListener('change', (e) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                action: 'set_mode',
+                mode: e.target.value
+            }));
+        }
+    });
+
+    // Theme Toggle Logic
+    themeSelect.addEventListener('change', (e) => {
+        const theme = e.target.value;
+        if (theme === 'dark') {
+            document.body.classList.add('theme-dark');
+            document.body.classList.remove('theme-light');
+        } else if (theme === 'light') {
+            document.body.classList.add('theme-light');
+            document.body.classList.remove('theme-dark');
+        } else {
+            document.body.classList.remove('theme-light', 'theme-dark');
+        }
+    });
+
+    // REPL Console Logic
+    replInput.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && replInput.value.trim() !== '') {
+            const code = replInput.value;
+            // Echo locally
+            renderBasicLog(containers.console, {
+                timestamp: new Date().toISOString(),
+                module: 'Console',
+                type: 'input',
+                data: { text: `> ${code}` }
+            }, new Date().toLocaleTimeString([], {hour12: false, fractionalSecondDigits: 3}));
+            
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    action: 'evaluate',
+                    code: code
+                }));
+            }
+            replInput.value = '';
+        }
+    });
+
+    // Clear Button
+    document.getElementById('btn-clear').addEventListener('click', () => {
+        allLogs = [];
+        Object.values(containers).forEach(c => c.innerHTML = '');
+        networkDetails.innerHTML = 'Select a request to view details';
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({action: 'clear'}));
+        }
+    });
+
+    // Export Button
+    document.getElementById('btn-export').addEventListener('click', () => {
+        const dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(allLogs, null, 2));
+        const anchor = document.createElement('a');
+        anchor.setAttribute("href", dataStr);
+        anchor.setAttribute("download", "h4_debug_export.json");
+        document.body.appendChild(anchor);
+        anchor.click();
+        anchor.remove();
+    });
+
+    // Context Menu Logic
+    const contextMenu = document.getElementById('context-menu');
+    let contextTargetData = null;
+
+    document.addEventListener('contextmenu', (e) => {
+        const entry = e.target.closest('.log-entry') || e.target.closest('.network-item');
+        if (entry) {
+            e.preventDefault();
+            contextTargetData = JSON.parse(entry.dataset.raw);
+            contextMenu.style.display = 'block';
+            contextMenu.style.left = `${e.pageX}px`;
+            contextMenu.style.top = `${e.pageY}px`;
+        } else {
+            contextMenu.style.display = 'none';
+        }
+    });
+
+    document.addEventListener('click', () => {
+        contextMenu.style.display = 'none';
+    });
+
+    document.getElementById('menu-copy').addEventListener('click', () => {
+        if (contextTargetData) {
+            navigator.clipboard.writeText(JSON.stringify(contextTargetData, null, 2));
+        }
+    });
+    
+    document.getElementById('menu-copy-hex').addEventListener('click', () => {
+        if (contextTargetData && contextTargetData.data.payload_hex) {
+            navigator.clipboard.writeText(contextTargetData.data.payload_hex);
+        }
+    });
+});

{h4_debug-0.1.0 → 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.0
+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.0 → h4_debug-0.1.2}/h4_debug.egg-info/SOURCES.txt

@@ -9,4 +9,7 @@ h4_debug.egg-info/SOURCES.txt
 h4_debug.egg-info/dependency_links.txt
 h4_debug.egg-info/entry_points.txt
 h4_debug.egg-info/requires.txt
-h4_debug.egg-info/top_level.txt
+h4_debug.egg-info/top_level.txt
+h4_debug/static/dashboard.css
+h4_debug/static/dashboard.html
+h4_debug/static/dashboard.js

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "h4-debug"
-version = "0.1.0"
+version = "0.1.2"
 description = "Advanced application proxy debugger and F12-style web console"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -19,3 +19,6 @@ dependencies = [
 
 [project.scripts]
 h4-debug = "h4_debug.cli:main"
+
+[tool.setuptools.package-data]
+h4_debug = ["static/*"]

h4_debug-0.1.0/h4_debug/__init__.py

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

h4_debug-0.1.0/h4_debug/server.py

@@ -1,94 +0,0 @@
-import asyncio
-import json
-import os
-import uvicorn
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
-
-app = FastAPI()
-
-# Store connected dashboard clients
-dashboard_clients = []
-
-# To persist logs for when a dashboard connects slightly after startup
-log_history = []
-MAX_HISTORY = 5000
-
-# Get the path to static files
-STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
-if not os.path.exists(STATIC_DIR):
-    os.makedirs(STATIC_DIR)
-
-app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
-
-@app.get("/")
-async def get_dashboard():
-    dashboard_path = os.path.join(STATIC_DIR, "dashboard.html")
-    if os.path.exists(dashboard_path):
-        with open(dashboard_path, "r", encoding="utf-8") as f:
-            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."""
-    await websocket.accept()
-    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:
-        pass
-
-@app.websocket("/ws/dashboard")
-async def websocket_dashboard(websocket: WebSocket):
-    """Endpoint for the web dashboard to receive logs."""
-    await websocket.accept()
-    
-    # Send history on connect
-    for log_item in log_history:
-        try:
-            await websocket.send_text(json.dumps(log_item))
-        except Exception:
-            break
-            
-    dashboard_clients.append(websocket)
-    try:
-        while True:
-            # Keep alive and receive commands from dashboard if needed
-            data = await websocket.receive_text()
-            cmd = json.loads(data)
-            if cmd.get("action") == "clear":
-                log_history.clear()
-    except WebSocketDisconnect:
-        if websocket in dashboard_clients:
-            dashboard_clients.remove(websocket)
-
-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")
-