h4-debug 0.1.4__tar.gz → 0.2.0__tar.gz

{h4_debug-0.1.4 → h4_debug-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h4-debug
-Version: 0.1.4
+Version: 0.2.0
 Summary: Advanced application proxy debugger and F12-style web console
 Author-email: h4 <h4@example.com>
 Requires-Python: >=3.8
@@ -8,6 +8,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: fastapi>=0.100
 Requires-Dist: uvicorn[standard]>=0.20
 Requires-Dist: websockets>=11.0
+Requires-Dist: Pillow>=10.0.0
 
 # h4-debug
 

h4_debug-0.2.0/h4_debug/__init__.py

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

h4_debug-0.2.0/h4_debug/cli.py

@@ -0,0 +1,71 @@
+import argparse
+import os
+import sys
+import threading
+import time
+import webbrowser
+
+from . import server
+from . import handlers
+
+def main():
+    parser = argparse.ArgumentParser(description="h4-debug: Advanced application proxy debugger", usage="h4-debug [--mode MODE] command ...")
+    parser.add_argument("--mode", choices=["Normal", "Trace", "Full"], default="Normal", help="Debugging mode")
+    parser.add_argument("--port", type=int, default=8008, help="Port for the web dashboard")
+    parser.add_argument("command", nargs=argparse.REMAINDER, help="Command to run")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    command = args.command
+    if command[0] == "--":
+        command = command[1:]
+
+    target = command[0]
+
+    # 1. Start the web server in a background thread
+    print(f"[h4-debug] Starting dashboard on http://localhost:{args.port} ...")
+    server_thread = threading.Thread(target=server.run_server, args=(args.port,), daemon=True)
+    server_thread.start()
+
+    time.sleep(1.0)
+    webbrowser.open(f"http://localhost:{args.port}")
+
+    # 2. Setup interception environment
+    env = os.environ.copy()
+
+    # 3. Dispatch to handler based on file extension
+    ext = ""
+    if os.path.isfile(target):
+        ext = os.path.splitext(target)[1].lower()
+
+    if ext == ".py":
+        handlers.handle_python(target, command, env, args)
+    elif ext in [".bat", ".cmd"]:
+        handlers.handle_batch(target, command, env, args)
+    elif ext in [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"]:
+        handlers.handle_image(target, command, env, args)
+    elif ext in [".js", ".ts", ".mjs", ".cjs"] or target.lower() in ["node", "npm", "npx", "node.exe", "npm.cmd", "npx.cmd"]:
+        handlers.handle_node(target, command, env, args)
+    elif ext == ".exe":
+        handlers.handle_exe(target, command, env, args)
+    else:
+        # Check if it's implicitly a python script via "python script.py"
+        if target.lower().endswith("python") or target.lower().endswith("python.exe"):
+            handlers.handle_python(target, command, env, args)
+        else:
+            handlers.handle_generic(target, command, env, args)
+
+    print("[h4-debug] Process finished. Dashboard will remain open until you exit (Ctrl+C).")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("[h4-debug] Shutting down.")
+
+if __name__ == "__main__":
+    main()
+

h4_debug-0.2.0/h4_debug/handlers.py

@@ -0,0 +1,252 @@
+import os
+import subprocess
+import tempfile
+import sys
+import time
+
+from .interceptor import TelemetryClient
+
+def _create_sitecustomize(mode, temp_dir):
+    sitecustomize_path = os.path.join(temp_dir, "sitecustomize.py")
+    script = f"""
+import sys
+import os
+
+try:
+    sys.path.remove(r"{temp_dir}")
+except ValueError:
+    pass
+
+try:
+    import h4_debug.interceptor
+    h4_debug.interceptor.start_interception(mode="{mode}")
+except ImportError as e:
+    print(f"h4-debug: Failed to load interceptor: {{e}}", file=sys.stderr)
+"""
+    with open(sitecustomize_path, "w", encoding="utf-8") as f:
+        f.write(script)
+
+def handle_python(target, command, env, args):
+    print(f"[h4-debug] Handling as Python script")
+    temp_dir = tempfile.mkdtemp(prefix="h4_debug_")
+    _create_sitecustomize(args.mode, temp_dir)
+    
+    if "PYTHONPATH" in env:
+        env["PYTHONPATH"] = f"{temp_dir}{os.pathsep}{env['PYTHONPATH']}"
+    else:
+        env["PYTHONPATH"] = temp_dir
+        
+    env["H4_DEBUG_MODE"] = args.mode
+    env["H4_DEBUG_PORT"] = str(args.port)
+
+    print(f"[h4-debug] Launching process: {' '.join(command)}")
+    process = None
+    try:
+        process = subprocess.Popen(command, env=env)
+        process.wait()
+    except KeyboardInterrupt:
+        print("\n[h4-debug] Interrupted by user. Terminating process...")
+        if process:
+            process.terminate()
+            process.wait()
+    except Exception as e:
+        print(f"[h4-debug] Error running command: {e}")
+
+def handle_batch(target, command, env, args):
+    print(f"[h4-debug] Handling as Batch script")
+    client = TelemetryClient(args.port)
+    time.sleep(0.5) # Wait for connection
+    
+    # Read batch file and send content
+    try:
+        with open(target, 'r', encoding='utf-8', errors='replace') as f:
+            content = f.read()
+            client.send("File", "batch_content", {"file": target, "content": content})
+    except Exception as e:
+        client.send("System", "error", {"text": f"Failed to read batch file: {e}"})
+
+    # Prepare env for inner python calls
+    temp_dir = tempfile.mkdtemp(prefix="h4_debug_")
+    _create_sitecustomize(args.mode, temp_dir)
+    if "PYTHONPATH" in env:
+        env["PYTHONPATH"] = f"{temp_dir}{os.pathsep}{env['PYTHONPATH']}"
+    else:
+        env["PYTHONPATH"] = temp_dir
+    env["H4_DEBUG_MODE"] = args.mode
+    env["H4_DEBUG_PORT"] = str(args.port)
+    
+    print(f"[h4-debug] Launching batch process: {' '.join(command)}")
+    process = None
+    try:
+        # Wrap command with cmd.exe /c if not already
+        if not command[0].lower().endswith('cmd.exe'):
+            cmd_args = ["cmd.exe", "/c"] + command
+        else:
+            cmd_args = command
+            
+        process = subprocess.Popen(cmd_args, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+        
+        # Stream stdout and stderr
+        import threading
+        def stream_output(pipe, is_err):
+            for line in pipe:
+                client.send("Console", "stderr" if is_err else "stdout", {"text": line.rstrip()})
+                print(line, end='', file=sys.stderr if is_err else sys.stdout)
+                
+        t1 = threading.Thread(target=stream_output, args=(process.stdout, False), daemon=True)
+        t2 = threading.Thread(target=stream_output, args=(process.stderr, True), daemon=True)
+        t1.start()
+        t2.start()
+        
+        process.wait()
+        t1.join()
+        t2.join()
+        
+        client.send("System", "info", {"text": f"Batch process finished with code {process.returncode}"})
+    except KeyboardInterrupt:
+        print("\n[h4-debug] Interrupted by user.")
+        if process:
+            process.terminate()
+            process.wait()
+    except Exception as e:
+        print(f"[h4-debug] Error running command: {e}")
+
+def handle_image(target, command, env, args):
+    print(f"[h4-debug] Handling as Image file")
+    
+    try:
+        from PIL import Image
+    except ImportError:
+        print("[h4-debug] Pillow is not installed. EXIF extraction unavailable.")
+        handle_generic(target, command, env, args)
+        return
+
+    def cmd_handler(cmd):
+        if cmd.get("action") == "strip_exif":
+            try:
+                img = Image.open(target)
+                data = list(img.getdata())
+                image_without_exif = Image.new(img.mode, img.size)
+                image_without_exif.putdata(data)
+                
+                name, ext = os.path.splitext(target)
+                new_target = f"{name}_stripped{ext}"
+                image_without_exif.save(new_target)
+                client.send("System", "info", {"text": f"Image metadata stripped and saved to: {new_target}"})
+                print(f"[h4-debug] Image stripped successfully: {new_target}")
+            except Exception as e:
+                client.send("System", "error", {"text": f"Failed to strip EXIF: {e}"})
+            return True
+        return False
+
+    client = TelemetryClient(args.port, command_callback=cmd_handler)
+    time.sleep(0.5)
+
+    try:
+        img = Image.open(target)
+        exif = img.getexif()
+        metadata = {
+            "format": img.format,
+            "mode": img.mode,
+            "size": img.size,
+            "exif": {k: str(v) for k, v in (exif.items() if exif else [])},
+            "file": target
+        }
+        client.send("Data", "image_metadata", metadata)
+        print(f"[h4-debug] Extracted metadata for {target}. Sent to dashboard.")
+    except Exception as e:
+        client.send("System", "error", {"text": f"Failed to read image metadata: {e}"})
+        print(f"[h4-debug] Error reading image: {e}")
+        
+    print("[h4-debug] Image handler running. Dashboard is active. (Press Ctrl+C to stop)")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\n[h4-debug] Exiting image handler.")
+
+def handle_generic(target, command, env, args):
+    print(f"[h4-debug] Handling as generic command")
+    client = TelemetryClient(args.port)
+    time.sleep(0.5)
+    
+    try:
+        size = os.path.getsize(target)
+        client.send("System", "info", {"text": f"Generic file: {target} (Size: {size} bytes)"})
+    except Exception:
+        pass
+
+    process = None
+    try:
+        process = subprocess.Popen(command, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+        
+        import threading
+        def stream_output(pipe, is_err):
+            for line in pipe:
+                client.send("Console", "stderr" if is_err else "stdout", {"text": line.rstrip()})
+                print(line, end='', file=sys.stderr if is_err else sys.stdout)
+                
+        t1 = threading.Thread(target=stream_output, args=(process.stdout, False), daemon=True)
+        t2 = threading.Thread(target=stream_output, args=(process.stderr, True), daemon=True)
+        t1.start()
+        t2.start()
+        
+        process.wait()
+        t1.join()
+        t2.join()
+        
+        client.send("System", "info", {"text": f"Generic process finished with code {process.returncode}"})
+    except KeyboardInterrupt:
+        if process:
+            process.terminate()
+            process.wait()
+    except Exception as e:
+        print(f"[h4-debug] Error running generic command: {e}")
+
+def handle_node(target, command, env, args):
+    print(f"[h4-debug] Handling as Node.js script")
+    
+    # Locate the interceptor script
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    interceptor_path = os.path.join(current_dir, "node_interceptor.js").replace("\\", "/")
+    
+    # Format NODE_OPTIONS
+    node_opts = env.get("NODE_OPTIONS", "")
+    new_opt = f'--require "{interceptor_path}"'
+    env["NODE_OPTIONS"] = f"{new_opt} {node_opts}".strip()
+    
+    env["H4_DEBUG_MODE"] = args.mode
+    env["H4_DEBUG_PORT"] = str(args.port)
+    
+    process = None
+    try:
+        # If target is .js but command doesn't start with node, prepend node
+        if target.endswith('.js') and command[0] == target:
+            command = ["node"] + command
+            
+        process = subprocess.Popen(command, env=env)
+        process.wait()
+    except KeyboardInterrupt:
+        if process:
+            process.terminate()
+            process.wait()
+    except Exception as e:
+        print(f"[h4-debug] Error running node command: {e}")
+
+def handle_exe(target, command, env, args):
+    print(f"[h4-debug] Handling as Native Executable (using ctypes Windows Debugger)")
+    client = TelemetryClient(args.port)
+    time.sleep(0.5)
+
+    env["H4_DEBUG_MODE"] = args.mode
+    env["H4_DEBUG_PORT"] = str(args.port)
+    
+    try:
+        from h4_debug.win_debugger import debug_process
+        client.send("System", "info", {"text": f"Starting native debug wrapper for {target}"})
+        debug_process(command, client)
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print(f"[h4-debug] Error running EXE command: {e}")
+

{h4_debug-0.1.4 → h4_debug-0.2.0}/h4_debug/interceptor.py

@@ -18,8 +18,9 @@ _original_socket = socket.socket
 _original_print = builtins.print
 
 class TelemetryClient:
-    def __init__(self, port):
+    def __init__(self, port, command_callback=None):
         self.port = port
+        self.command_callback = command_callback
         self.queue = queue.Queue()
         self.buffer = ""
         self.thread = threading.Thread(target=self._run, daemon=True)
@@ -64,6 +65,9 @@ class TelemetryClient:
         try:
             cmd = json.loads(cmd_data)
             
+            if self.command_callback and self.command_callback(cmd):
+                return
+                
             if cmd.get("action") == "set_mode":
                 global _mode
                 _mode = cmd.get("mode", "Normal")

h4_debug-0.2.0/h4_debug/node_interceptor.js

@@ -0,0 +1,126 @@
+const net = require('net');
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+
+const mode = process.env.H4_DEBUG_MODE || 'Normal';
+const port = parseInt(process.env.H4_DEBUG_PORT || '8008', 10) + 1;
+const isTelemetryThread = false;
+
+const messageQueue = [];
+let client = null;
+let connected = false;
+
+function connectTelemetry() {
+    client = net.createConnection({ port: port, host: '127.0.0.1' }, () => {
+        connected = true;
+        sendQueue();
+    });
+
+    client.on('error', () => {
+        connected = false;
+        setTimeout(connectTelemetry, 1000);
+    });
+
+    client.on('close', () => {
+        connected = false;
+        setTimeout(connectTelemetry, 1000);
+    });
+}
+
+function sendQueue() {
+    if (!connected || !client) return;
+    while (messageQueue.length > 0) {
+        const msg = messageQueue.shift();
+        try {
+            client.write(JSON.stringify(msg) + '\n');
+        } catch (e) {
+            messageQueue.unshift(msg);
+            break;
+        }
+    }
+}
+
+function sendEvent(module, type, data) {
+    if (mode === 'Normal' && module !== 'System') return; // Do not send if normal, unless system init
+    const msg = {
+        timestamp: new Date().toISOString(),
+        module: module,
+        type: type,
+        data: data,
+        thread: 'Main'
+    };
+    messageQueue.push(msg);
+    sendQueue();
+}
+
+// Start connection
+connectTelemetry();
+
+sendEvent('System', 'init', {
+    mode: mode,
+    pid: process.pid,
+    language: 'node.js',
+    version: process.version
+});
+
+// Patch Console
+const originalLog = console.log;
+const originalError = console.error;
+const originalWarn = console.warn;
+
+console.log = function(...args) {
+    sendEvent('Console', 'stdout', { text: args.join(' ') });
+    originalLog.apply(console, args);
+};
+console.error = function(...args) {
+    sendEvent('Console', 'stderr', { text: args.join(' ') });
+    originalError.apply(console, args);
+};
+console.warn = function(...args) {
+    sendEvent('Console', 'stdout', { text: '[WARN] ' + args.join(' ') });
+    originalWarn.apply(console, args);
+};
+
+// Patch HTTP
+const originalHttpRequest = http.request;
+http.request = function(...args) {
+    let url = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].href) ? args[0].href : JSON.stringify(args[0]);
+    sendEvent('Network', 'connect', { address: url });
+    return originalHttpRequest.apply(http, args);
+};
+
+const originalHttpsRequest = https.request;
+https.request = function(...args) {
+    let url = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].href) ? args[0].href : JSON.stringify(args[0]);
+    sendEvent('Network', 'connect', { address: url });
+    return originalHttpsRequest.apply(https, args);
+};
+
+// Patch File System (read sync as example)
+const originalReadFileSync = fs.readFileSync;
+fs.readFileSync = function(...args) {
+    sendEvent('Disk', 'open', { file: args[0], mode: 'r' });
+    return originalReadFileSync.apply(fs, args);
+};
+
+// Unhandled Rejection
+process.on('unhandledRejection', (reason, promise) => {
+    sendEvent('Execution', 'exception', {
+        type: 'UnhandledRejection',
+        value: String(reason),
+        file: 'unknown',
+        line: 0
+    });
+});
+
+process.on('uncaughtException', (err) => {
+    sendEvent('Execution', 'exception', {
+        type: err.name,
+        value: err.message,
+        file: err.stack,
+        line: 0
+    });
+    // Rethrow to maintain standard behavior
+    throw err;
+});

{h4_debug-0.1.4 → h4_debug-0.2.0}/h4_debug/static/dashboard.js

@@ -77,6 +77,10 @@ document.addEventListener('DOMContentLoaded', () => {
             renderBasicLog(containers.disk, log, timeStr);
         } else if (log.module === 'Execution') {
             renderBasicLog(containers.execution, log, timeStr);
+        } else if (log.module === 'Data' && log.type === 'image_metadata') {
+            renderImageMetadata(containers.disk, log, timeStr);
+            // Also show a brief info in console
+            renderBasicLog(containers.console, {module: 'System', type: 'info', data: {text: `Image metadata loaded for ${log.data.file}. Check Disk tab.`}}, timeStr, 'system');
         } else if (log.module === 'Console') {
             if (log.type === 'eval_result') {
                 renderEvalResult(containers.console, log, timeStr);
@@ -94,6 +98,43 @@ document.addEventListener('DOMContentLoaded', () => {
         }
     }
 
+    function renderImageMetadata(container, log, timeStr) {
+        const el = document.createElement('div');
+        el.className = 'log-entry image-metadata';
+        
+        let html = `<h3>Image: ${log.data.file}</h3>`;
+        html += `<div><strong>Format:</strong> ${log.data.format} | <strong>Size:</strong> ${log.data.size[0]}x${log.data.size[1]} | <strong>Mode:</strong> ${log.data.mode}</div>`;
+        
+        const exifCount = Object.keys(log.data.exif).length;
+        if (exifCount > 0) {
+            html += `<h4>EXIF Data (${exifCount} entries)</h4>`;
+            html += `<pre style="max-height: 200px; overflow-y: auto; background: var(--bg-dark); padding: 5px; font-size: 0.9em;">`;
+            for (let [k, v] of Object.entries(log.data.exif)) {
+                html += `${k}: ${v}\n`;
+            }
+            html += `</pre>`;
+            html += `<button class="btn-strip-exif" style="margin-top: 10px; padding: 5px 10px; background: #e74c3c; color: white; border: none; border-radius: 4px; cursor: pointer;">Strip EXIF Metadata</button>`;
+        } else {
+            html += `<h4>No EXIF Data found.</h4>`;
+        }
+        
+        el.innerHTML = html;
+        
+        const btn = el.querySelector('.btn-strip-exif');
+        if (btn) {
+            btn.addEventListener('click', () => {
+                if(ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({action: 'strip_exif', file: log.data.file}));
+                    btn.textContent = "Stripping...";
+                    btn.disabled = true;
+                }
+            });
+        }
+        
+        container.appendChild(el);
+        scrollToBottom(container);
+    }
+
     function renderBasicLog(container, log, timeStr, customClass='') {
         const el = document.createElement('div');
         el.className = `log-entry ${customClass}`;

h4_debug-0.2.0/h4_debug/win_debugger.py

@@ -0,0 +1,227 @@
+import ctypes
+from ctypes import wintypes
+import time
+import struct
+import sys
+import os
+
+kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+
+DEBUG_PROCESS = 0x00000001
+DEBUG_ONLY_THIS_PROCESS = 0x00000002
+DBG_CONTINUE = 0x00010002
+DBG_EXCEPTION_NOT_HANDLED = 0x80010001
+
+# Event Codes
+EXCEPTION_DEBUG_EVENT = 1
+CREATE_THREAD_DEBUG_EVENT = 2
+CREATE_PROCESS_DEBUG_EVENT = 3
+EXIT_THREAD_DEBUG_EVENT = 4
+EXIT_PROCESS_DEBUG_EVENT = 5
+LOAD_DLL_DEBUG_EVENT = 6
+UNLOAD_DLL_DEBUG_EVENT = 7
+OUTPUT_DEBUG_STRING_EVENT = 8
+RIP_EVENT = 9
+
+class STARTUPINFO(ctypes.Structure):
+    _fields_ = [
+        ("cb", wintypes.DWORD),
+        ("lpReserved", wintypes.LPWSTR),
+        ("lpDesktop", wintypes.LPWSTR),
+        ("lpTitle", wintypes.LPWSTR),
+        ("dwX", wintypes.DWORD),
+        ("dwY", wintypes.DWORD),
+        ("dwXSize", wintypes.DWORD),
+        ("dwYSize", wintypes.DWORD),
+        ("dwXCountChars", wintypes.DWORD),
+        ("dwYCountChars", wintypes.DWORD),
+        ("dwFillAttribute", wintypes.DWORD),
+        ("dwFlags", wintypes.DWORD),
+        ("wShowWindow", wintypes.WORD),
+        ("cbReserved2", wintypes.WORD),
+        ("lpReserved2", ctypes.POINTER(wintypes.BYTE)),
+        ("hStdInput", wintypes.HANDLE),
+        ("hStdOutput", wintypes.HANDLE),
+        ("hStdError", wintypes.HANDLE),
+    ]
+
+class PROCESS_INFORMATION(ctypes.Structure):
+    _fields_ = [
+        ("hProcess", wintypes.HANDLE),
+        ("hThread", wintypes.HANDLE),
+        ("dwProcessId", wintypes.DWORD),
+        ("dwThreadId", wintypes.DWORD),
+    ]
+
+class EXCEPTION_RECORD(ctypes.Structure):
+    pass
+EXCEPTION_RECORD._fields_ = [
+    ("ExceptionCode", wintypes.DWORD),
+    ("ExceptionFlags", wintypes.DWORD),
+    ("ExceptionRecord", ctypes.POINTER(EXCEPTION_RECORD)),
+    ("ExceptionAddress", ctypes.c_void_p),
+    ("NumberParameters", wintypes.DWORD),
+    ("ExceptionInformation", ctypes.c_void_p * 15),
+]
+
+class EXCEPTION_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("ExceptionRecord", EXCEPTION_RECORD),
+        ("dwFirstChance", wintypes.DWORD),
+    ]
+
+class CREATE_THREAD_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("hThread", wintypes.HANDLE),
+        ("lpThreadLocalBase", ctypes.c_void_p),
+        ("lpStartAddress", ctypes.c_void_p),
+    ]
+
+class CREATE_PROCESS_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("hFile", wintypes.HANDLE),
+        ("hProcess", wintypes.HANDLE),
+        ("hThread", wintypes.HANDLE),
+        ("lpBaseOfImage", ctypes.c_void_p),
+        ("dwDebugInfoFileOffset", wintypes.DWORD),
+        ("nDebugInfoSize", wintypes.DWORD),
+        ("lpThreadLocalBase", ctypes.c_void_p),
+        ("lpStartAddress", ctypes.c_void_p),
+        ("lpImageName", ctypes.c_void_p),
+        ("fUnicode", wintypes.WORD),
+    ]
+
+class EXIT_THREAD_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("dwExitCode", wintypes.DWORD),
+    ]
+
+class EXIT_PROCESS_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("dwExitCode", wintypes.DWORD),
+    ]
+
+class LOAD_DLL_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("hFile", wintypes.HANDLE),
+        ("lpBaseOfDll", ctypes.c_void_p),
+        ("dwDebugInfoFileOffset", wintypes.DWORD),
+        ("nDebugInfoSize", wintypes.DWORD),
+        ("lpImageName", ctypes.c_void_p),
+        ("fUnicode", wintypes.WORD),
+    ]
+
+class UNLOAD_DLL_DEBUG_INFO(ctypes.Structure):
+    _fields_ = [
+        ("lpBaseOfDll", ctypes.c_void_p),
+    ]
+
+class OUTPUT_DEBUG_STRING_INFO(ctypes.Structure):
+    _fields_ = [
+        ("lpDebugStringData", ctypes.c_void_p),
+        ("fUnicode", wintypes.WORD),
+        ("nDebugStringLength", wintypes.WORD),
+    ]
+
+class RIP_INFO(ctypes.Structure):
+    _fields_ = [
+        ("dwError", wintypes.DWORD),
+        ("dwType", wintypes.DWORD),
+    ]
+
+class DEBUG_EVENT_UNION(ctypes.Union):
+    _fields_ = [
+        ("Exception", EXCEPTION_DEBUG_INFO),
+        ("CreateThread", CREATE_THREAD_DEBUG_INFO),
+        ("CreateProcessInfo", CREATE_PROCESS_DEBUG_INFO),
+        ("ExitThread", EXIT_THREAD_DEBUG_INFO),
+        ("ExitProcess", EXIT_PROCESS_DEBUG_INFO),
+        ("LoadDll", LOAD_DLL_DEBUG_INFO),
+        ("UnloadDll", UNLOAD_DLL_DEBUG_INFO),
+        ("DebugString", OUTPUT_DEBUG_STRING_INFO),
+        ("RipInfo", RIP_INFO),
+    ]
+
+class DEBUG_EVENT(ctypes.Structure):
+    _fields_ = [
+        ("dwDebugEventCode", wintypes.DWORD),
+        ("dwProcessId", wintypes.DWORD),
+        ("dwThreadId", wintypes.DWORD),
+        ("u", DEBUG_EVENT_UNION),
+    ]
+
+def read_process_memory(hProcess, address, size):
+    buffer = ctypes.create_string_buffer(size)
+    bytesRead = ctypes.c_size_t()
+    if kernel32.ReadProcessMemory(hProcess, ctypes.c_void_p(address), buffer, size, ctypes.byref(bytesRead)):
+        return buffer.raw[:bytesRead.value]
+    return b""
+
+def debug_process(command, client):
+    si = STARTUPINFO()
+    si.cb = ctypes.sizeof(si)
+    pi = PROCESS_INFORMATION()
+
+    creation_flags = DEBUG_PROCESS
+
+    # Convert command list to string for Windows
+    cmd_str = " ".join(f'"{c}"' if " " in c else c for c in command)
+
+    if not kernel32.CreateProcessW(
+        None, ctypes.c_wchar_p(cmd_str), None, None, False,
+        creation_flags, None, None, ctypes.byref(si), ctypes.byref(pi)):
+        client.send("System", "error", {"text": f"Failed to CreateProcess: {ctypes.GetLastError()}"})
+        return
+
+    process_handle = None
+    debug_event = DEBUG_EVENT()
+
+    while True:
+        if not kernel32.WaitForDebugEvent(ctypes.byref(debug_event), 1000): # 1 sec timeout to yield
+            # Check if process exited
+            exit_code = wintypes.DWORD()
+            if kernel32.GetExitCodeProcess(pi.hProcess, ctypes.byref(exit_code)) and exit_code.value != 259: # STILL_ACTIVE
+                break
+            continue
+
+        continue_status = DBG_CONTINUE
+
+        if debug_event.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT:
+            process_handle = debug_event.u.CreateProcessInfo.hProcess
+            client.send("System", "info", {"text": f"Process Created: PID {debug_event.dwProcessId}"})
+            if debug_event.u.CreateProcessInfo.hFile:
+                kernel32.CloseHandle(debug_event.u.CreateProcessInfo.hFile)
+
+        elif debug_event.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT:
+            if debug_event.u.LoadDll.hFile:
+                kernel32.CloseHandle(debug_event.u.LoadDll.hFile)
+            # Address resolution of DLL names can be complex in Win32, so we just log the event natively.
+            # Real debuggers use GetMappedFileName on the lpBaseOfDll.
+            pass # Keep output clean unless we resolve name
+
+        elif debug_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT:
+            if process_handle:
+                info = debug_event.u.DebugString
+                data = read_process_memory(process_handle, info.lpDebugStringData, info.nDebugStringLength * (2 if info.fUnicode else 1))
+                if data:
+                    text = data.decode('utf-16' if info.fUnicode else 'ansi', 'replace').strip('\x00\r\n')
+                    if text:
+                        client.send("Console", "stdout", {"text": f"[DEBUG] {text}"})
+
+        elif debug_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT:
+            exc = debug_event.u.Exception.ExceptionRecord.ExceptionCode
+            # Ignore standard breakpoint exceptions (0x80000003)
+            if exc != 0x80000003:
+                # Log exception
+                continue_status = DBG_EXCEPTION_NOT_HANDLED
+
+        elif debug_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT:
+            client.send("System", "info", {"text": f"Process Exited with code {debug_event.u.ExitProcess.dwExitCode}"})
+            kernel32.ContinueDebugEvent(debug_event.dwProcessId, debug_event.dwThreadId, continue_status)
+            break
+
+        kernel32.ContinueDebugEvent(debug_event.dwProcessId, debug_event.dwThreadId, continue_status)
+    
+    if process_handle:
+        kernel32.CloseHandle(pi.hThread)
+        kernel32.CloseHandle(pi.hProcess)

{h4_debug-0.1.4 → h4_debug-0.2.0}/h4_debug.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h4-debug
-Version: 0.1.4
+Version: 0.2.0
 Summary: Advanced application proxy debugger and F12-style web console
 Author-email: h4 <h4@example.com>
 Requires-Python: >=3.8
@@ -8,6 +8,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: fastapi>=0.100
 Requires-Dist: uvicorn[standard]>=0.20
 Requires-Dist: websockets>=11.0
+Requires-Dist: Pillow>=10.0.0
 
 # h4-debug
 

{h4_debug-0.1.4 → h4_debug-0.2.0}/h4_debug.egg-info/SOURCES.txt

@@ -2,8 +2,11 @@ README.md
 pyproject.toml
 h4_debug/__init__.py
 h4_debug/cli.py
+h4_debug/handlers.py
 h4_debug/interceptor.py
+h4_debug/node_interceptor.js
 h4_debug/server.py
+h4_debug/win_debugger.py
 h4_debug.egg-info/PKG-INFO
 h4_debug.egg-info/SOURCES.txt
 h4_debug.egg-info/dependency_links.txt

{h4_debug-0.1.4 → h4_debug-0.2.0}/h4_debug.egg-info/requires.txt

@@ -1,3 +1,4 @@
 fastapi>=0.100
 uvicorn[standard]>=0.20
 websockets>=11.0
+Pillow>=10.0.0

{h4_debug-0.1.4 → h4_debug-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "h4-debug"
-version = "0.1.4"
+version = "0.2.0"
 description = "Advanced application proxy debugger and F12-style web console"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -15,10 +15,11 @@ dependencies = [
     "fastapi>=0.100",
     "uvicorn[standard]>=0.20",
     "websockets>=11.0",
+    "Pillow>=10.0.0",
 ]
 
 [project.scripts]
 h4-debug = "h4_debug.cli:main"
 
 [tool.setuptools.package-data]
-h4_debug = ["static/*"]
+"h4_debug" = ["static/*", "*.js"]

h4_debug-0.1.4/h4_debug/__init__.py

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

h4_debug-0.1.4/h4_debug/cli.py

@@ -1,103 +0,0 @@
-import argparse
-import os
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-import webbrowser
-import pathlib
-
-from . import server
-
-def create_sitecustomize(mode):
-    temp_dir = tempfile.mkdtemp(prefix="h4_debug_")
-    sitecustomize_path = os.path.join(temp_dir, "sitecustomize.py")
-    
-    # We will write a sitecustomize.py that imports our interceptor
-    # and initializes it with the selected mode.
-    script = f"""
-import sys
-import os
-
-# Remove this temp dir from sys.path so we don't mess with other imports too much
-try:
-    sys.path.remove(r"{temp_dir}")
-except ValueError:
-    pass
-
-try:
-    import h4_debug.interceptor
-    h4_debug.interceptor.start_interception(mode="{mode}")
-except ImportError as e:
-    print(f"h4-debug: Failed to load interceptor: {{e}}", file=sys.stderr)
-"""
-    with open(sitecustomize_path, "w", encoding="utf-8") as f:
-        f.write(script)
-    
-    return temp_dir
-
-def main():
-    parser = argparse.ArgumentParser(description="h4-debug: Advanced application proxy debugger", usage="h4-debug [--mode MODE] command ...")
-    parser.add_argument("--mode", choices=["Normal", "Trace", "Full"], default="Normal", help="Debugging mode")
-    parser.add_argument("--port", type=int, default=8008, help="Port for the web dashboard")
-    parser.add_argument("command", nargs=argparse.REMAINDER, help="Command to run")
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        sys.exit(1)
-
-    command = args.command
-    # argparse puts '--' in the remainder if it's there
-    if command[0] == "--":
-        command = command[1:]
-
-    # 1. Start the web server in a background thread
-    print(f"[h4-debug] Starting dashboard on http://localhost:{args.port} ...")
-    server_thread = threading.Thread(target=server.run_server, args=(args.port,), daemon=True)
-    server_thread.start()
-
-    # Give server a moment to start
-    time.sleep(1.0)
-    
-    # Open dashboard in browser
-    webbrowser.open(f"http://localhost:{args.port}")
-
-    # 2. Setup interception environment
-    env = os.environ.copy()
-    
-    # Python interception via sitecustomize
-    sitecustomize_dir = create_sitecustomize(args.mode)
-    
-    if "PYTHONPATH" in env:
-        env["PYTHONPATH"] = f"{sitecustomize_dir}{os.pathsep}{env['PYTHONPATH']}"
-    else:
-        env["PYTHONPATH"] = sitecustomize_dir
-        
-    env["H4_DEBUG_MODE"] = args.mode
-    env["H4_DEBUG_PORT"] = str(args.port)
-
-    # 3. Launch the target process
-    print(f"[h4-debug] Launching process: {' '.join(command)}")
-    try:
-        process = subprocess.Popen(command, env=env)
-        process.wait()
-    except KeyboardInterrupt:
-        print("\n[h4-debug] Interrupted by user. Terminating process...")
-        if process:
-            process.terminate()
-            process.wait()
-    except Exception as e:
-        print(f"[h4-debug] Error running command: {e}")
-    finally:
-        print("[h4-debug] Process finished. Dashboard will remain open until you exit (Ctrl+C).")
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            print("[h4-debug] Shutting down.")
-
-if __name__ == "__main__":
-    main()