synapse-hub 2.0.1 → 2.1.0

package/tools/network_mock_shield.py

@@ -109,6 +109,119 @@ class NetworkMockShield:
         delay_opt = f", delay: {delay_ms}" if delay_ms > 0 else ""
         return f"cy.intercept('{method}', '{url_pattern}', {{ statusCode: {status}, body: {body_json}{delay_opt} }}).as('mock_{url_pattern.split('/')[-1]}');"
 
+    @classmethod
+    def generate_playwright_har_harness(cls, har_path: str, mode: str = "replay", url_glob: str = "**/*", lang: str = "ts") -> str:
+        """
+        Generates Playwright Native Zero-Latency HAR Record & Replay harness.
+        - record: Dumps real network traffic to HAR file.
+        - replay: Intercepts all matching requests and returns responses from HAR with 0ms delay.
+        """
+        if mode == "record":
+            if lang == "python":
+                return "\n".join([
+                    f"# --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright Python) ---",
+                    f"# Dumps live network traffic to '{har_path}'",
+                    f"context = browser.new_context(",
+                    f"    record_har_path='{har_path}',",
+                    f"    record_har_mode='minimal',",
+                    f"    record_har_url_filter='{url_glob}'",
+                    f")",
+                    f"page = context.new_page()",
+                    f"# Note: Run 'python tools/network_mock_shield.py --har-sanitize {har_path}' before committing to git!"
+                ])
+            else:
+                return "\n".join([
+                    f"// --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright TS) ---",
+                    f"// Dumps live network traffic to '{har_path}'",
+                    f"const context = await browser.newContext({{",
+                    f"  recordHar: {{",
+                    f"    path: '{har_path}',",
+                    f"    mode: 'minimal',",
+                    f"    urlFilter: '{url_glob}'",
+                    f"  }}",
+                    f"}});",
+                    f"const page = await context.newPage();",
+                    f"// Note: Run 'python tools/network_mock_shield.py --har-sanitize {har_path}' before committing to git!"
+                ])
+        else:
+            # Replay Mode
+            if lang == "python":
+                return "\n".join([
+                    f"# --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright Python) ---",
+                    f"# Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
+                    f"page.route_from_har(",
+                    f"    har_id='{har_path}',",
+                    f"    url='{url_glob}',",
+                    f"    not_found='fallback',",
+                    f"    update=False",
+                    f")"
+                ])
+            else:
+                return "\n".join([
+                    f"// --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright TS) ---",
+                    f"// Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
+                    f"await page.routeFromHAR('{har_path}', {{",
+                    f"  url: '{url_glob}',",
+                    f"  notFound: 'fallback',",
+                    f"  update: false",
+                    f"}});"
+                ])
+
+    @classmethod
+    def sanitize_har_file(cls, input_har_path: str, output_har_path: Optional[str] = None) -> int:
+        """
+        Parses a recorded HAR file and redacts sensitive PII & credentials:
+        Bearer tokens, Authorization headers, Cookie headers, passwords, API keys.
+        Returns the count of redacted entries.
+        """
+        import re
+        if not os.path.exists(input_har_path):
+            raise FileNotFoundError(f"HAR file not found: {input_har_path}")
+
+        with open(input_har_path, "r", encoding="utf-8", errors="replace") as fp:
+            data = json.load(fp)
+
+        entries = data.get("log", {}).get("entries", [])
+        redacted_count = 0
+
+        pii_patterns = [
+            (re.compile(r'"(password|pass|secret|token|api_?key|access_?token)"\s*:\s*"[^"]+"', re.IGNORECASE), r'"\1": "REDACTED_SECRET"'),
+            (re.compile(r'"(credit_?card|card_?number|pan)"\s*:\s*"[^"]+"', re.IGNORECASE), r'"\1": "411111******1111"'),
+            (re.compile(r'"(cvv|cvc)"\s*:\s*"[^"]+"', re.IGNORECASE), r'"\1": "999"'),
+            (re.compile(r'"(email)"\s*:\s*"[^"]+"', re.IGNORECASE), r'"\1": "auto_user@enterprise.local"')
+        ]
+
+        for entry in entries:
+            req = entry.get("request", {})
+            # 1. Scrub Request Headers
+            for header in req.get("headers", []):
+                h_name = header.get("name", "").lower()
+                if h_name in ("authorization", "cookie", "x-api-key", "token", "proxy-authorization"):
+                    header["value"] = "Bearer REDACTED_TOKEN" if "bearer" in header.get("value", "").lower() else "REDACTED"
+                    redacted_count += 1
+
+            # 2. Scrub Request Post Data
+            post_data = req.get("postData", {})
+            if "text" in post_data:
+                txt = post_data["text"]
+                for pat, rep in pii_patterns:
+                    txt = pat.sub(rep, txt)
+                post_data["text"] = txt
+
+            # 3. Scrub Response Headers (Set-Cookie)
+            resp = entry.get("response", {})
+            for header in resp.get("headers", []):
+                h_name = header.get("name", "").lower()
+                if h_name in ("set-cookie", "authorization"):
+                    header["value"] = "REDACTED_COOKIE"
+                    redacted_count += 1
+
+        out_path = output_har_path or input_har_path
+        with open(out_path, "w", encoding="utf-8") as fp:
+            json.dump(data, fp, indent=2)
+
+        return redacted_count
+
     @classmethod
     def get_preset(cls, preset_name: str) -> Dict[str, Any]:
         """Returns preset details or raises ValueError."""
@@ -127,8 +240,36 @@ def main():
     parser.add_argument("--lang", choices=["ts", "python", "cypress"], default="ts", help="Target script language")
     parser.add_argument("--list-presets", action="store_true", help="List all available presets")
 
+    # HAR Record & Replay options
+    parser.add_argument("--har-mode", choices=["record", "replay"], default=None, help="Generate Playwright HAR record or replay harness")
+    parser.add_argument("--har-path", default="fixtures/network_trace.har", help="Path to HAR archive file")
+    parser.add_argument("--har-sanitize", default=None, help="Sanitize PII, tokens, and cookies from recorded HAR file")
+    parser.add_argument("--har-out", default=None, help="Optional output path for sanitized HAR")
+
     args = parser.parse_args()
 
+    # Handle HAR Sanitization
+    if args.har_sanitize:
+        redacted = NetworkMockShield.sanitize_har_file(args.har_sanitize, output_har_path=args.har_out)
+        target = args.har_out or args.har_sanitize
+        print(f"✅ [HAR SANITIZED] Scrubbed {redacted} sensitive headers/tokens in: {target}")
+        return
+
+    # Handle HAR Harness Generation
+    if args.har_mode:
+        code = NetworkMockShield.generate_playwright_har_harness(
+            har_path=args.har_path,
+            mode=args.har_mode,
+            url_glob=args.url,
+            lang=args.lang
+        )
+        print("======================================================================")
+        print(f"  PLAYWRIGHT ZERO-LATENCY HAR {args.har_mode.upper()} HARNESS ({args.lang.upper()})")
+        print("======================================================================")
+        print(code)
+        print("======================================================================")
+        return
+
     if args.list_presets:
         print("======================================================================")
         print("  AVAILABLE NETWORK MOCK & CHAOS FAULT PRESETS")

package/tools/repo_map.json

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-10-29 20:23:27",
+  "generated_at": "2026-10-29 21:59:04",
   "target_repository": "/Users/phungcao/Documents/Agent Skill",
   "classes_count": 0,
   "methods_count": 0,

package/tools/repo_map.txt

@@ -1,6 +1,6 @@
 # ==============================================================================
 # ENTERPRISE AUTOMATION REPOSITORY MAP (Aider-Style AST Compression)
-# Generated : 2026-10-29 20:23:27
+# Generated : 2026-10-29 21:59:04
 # Target    : /Users/phungcao/Documents/Agent Skill
 # Scope     : 0 Classes (0 source lines, 0.0 KB)
 # Purpose   : Token-budgeted index (< 600 tokens) for instant method lookup

package/tools/visual_som_helper.py

@@ -27,12 +27,13 @@ import sqlite3
 import argparse
 from typing import Dict, Any, List, Optional, Tuple, Union
 try:
-    from PIL import Image, ImageDraw, ImageFont
+    from PIL import Image, ImageDraw, ImageFont, ImageFilter
     HAS_PIL = True
 except ImportError:
     Image = None
     ImageDraw = None
     ImageFont = None
+    ImageFilter = None
     HAS_PIL = False
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
@@ -229,6 +230,89 @@ class VisualSoMHelper:
 
         return visual_hash
 
+    def detect_canvas_interactive_regions(
+        self,
+        image_path: str,
+        stride: int = 16,
+        edge_threshold: int = 28,
+        min_pixels_per_cell: int = 6,
+        min_w: int = 16,
+        min_h: int = 16,
+        max_ratio: float = 0.88
+    ) -> List[Dict[str, Any]]:
+        """
+        Standalone Computer Vision Contour / Active Blob Detector for Canvas/GIS.
+        Detects interactive visual components (buttons, polygon nodes, markers, sliders, chart icons)
+        without requiring DOM elements or accessibility nodes.
+        Uses pure PIL edge filtering and connected-grid component clustering (Zero-Dependency).
+        """
+        if not os.path.exists(image_path) or not HAS_PIL:
+            return []
+
+        img = Image.open(image_path).convert("L")
+        w, h = img.size
+        max_allowed_w = int(w * max_ratio)
+        max_allowed_h = int(h * max_ratio)
+
+        # Detect high-contrast edges & contours
+        edges = img.filter(ImageFilter.FIND_EDGES)
+        edges = edges.point(lambda p: 255 if p > edge_threshold else 0)
+        pixels = edges.load()
+
+        # Identify active cells with high edge density
+        active_cells = set()
+        for y in range(0, h, stride):
+            for x in range(0, w, stride):
+                count = 0
+                for cy in range(y, min(h, y + stride)):
+                    for cx in range(x, min(w, x + stride)):
+                        if pixels[cx, cy] > 0:
+                            count += 1
+                if count >= min_pixels_per_cell:
+                    active_cells.add((x // stride, y // stride))
+
+        # 8-direction BFS clustering to group connected components
+        visited = set()
+        detected_elements = []
+        cluster_id = 1
+
+        for cell in sorted(active_cells):
+            if cell in visited:
+                continue
+            queue = [cell]
+            visited.add(cell)
+            cluster = [cell]
+
+            while queue:
+                curr = queue.pop(0)
+                cx, cy = curr
+                for dx in (-1, 0, 1):
+                    for dy in (-1, 0, 1):
+                        nb = (cx + dx, cy + dy)
+                        if nb in active_cells and nb not in visited:
+                            visited.add(nb)
+                            queue.append(nb)
+                            cluster.append(nb)
+
+            min_x = max(0, min(c[0] for c in cluster) * stride - 4)
+            min_y = max(0, min(c[1] for c in cluster) * stride - 4)
+            box_w = min(w - min_x, (max(c[0] for c in cluster) + 1) * stride - min_x + 8)
+            box_h = min(h - min_y, (max(c[1] for c in cluster) + 1) * stride - min_y + 8)
+
+            # Filter out whole-canvas background borders or tiny noise
+            if box_w >= min_w and box_h >= min_h and (box_w < max_allowed_w or box_h < max_allowed_h):
+                detected_elements.append({
+                    "x": min_x,
+                    "y": min_y,
+                    "width": box_w,
+                    "height": box_h,
+                    "label": f"Canvas_Target_{cluster_id}",
+                    "tag": "canvas_interactive_node"
+                })
+                cluster_id += 1
+
+        return detected_elements
+
     def generate_som_overlay(
         self,
         image_path: str,
@@ -237,22 +321,27 @@ class VisualSoMHelper:
     ) -> Tuple[str, Dict[int, Dict[str, Any]]]:
         """
         Draws high-contrast numbered badges (Set-of-Marks) over each element bounding box.
+        If elements is omitted, autonomously runs detect_canvas_interactive_regions.
         Returns (marked_image_path, marks_map).
         """
+        if not os.path.exists(image_path):
+            img = Image.new("RGB", (self.viewport_width, self.viewport_height), color="#1E1E2E")
+            draw = ImageDraw.Draw(img)
+            draw.text((50, 50), "Mock Financial Dashboard (HTML5 Canvas)", fill="#FFFFFF")
+            draw.rectangle([100, 150, 220, 190], outline="#00CCFF", width=2)
+            draw.rectangle([240, 150, 360, 190], outline="#FF0055", width=2)
+            draw.rectangle([500, 300, 700, 350], outline="#00FF66", width=2)
+            img.save(image_path)
+
         if not elements:
-            elements = [
+            detected = self.detect_canvas_interactive_regions(image_path)
+            elements = detected if detected else [
                 {"x": 100, "y": 150, "width": 120, "height": 40, "label": "TradingView Zoom In", "tag": "canvas_control"},
                 {"x": 240, "y": 150, "width": 120, "height": 40, "label": "TradingView Zoom Out", "tag": "canvas_control"},
                 {"x": 500, "y": 300, "width": 200, "height": 50, "label": "Execute Trade Order", "tag": "shadow_button"},
                 {"x": 720, "y": 300, "width": 150, "height": 50, "label": "Cancel Order", "tag": "shadow_button"}
             ]
 
-        if not os.path.exists(image_path):
-            img = Image.new("RGB", (self.viewport_width, self.viewport_height), color="#1E1E2E")
-            draw = ImageDraw.Draw(img)
-            draw.text((50, 50), "Mock Financial Dashboard (HTML5 Canvas)", fill="#FFFFFF")
-            img.save(image_path)
-
         img = Image.open(image_path).convert("RGBA")
         overlay = Image.new("RGBA", img.size, (255, 255, 255, 0))
         draw = ImageDraw.Draw(overlay)
@@ -342,6 +431,7 @@ def main():
     parser.add_argument("--cache-lookup", action="store_true", help="Attempt zero-token visual cache resolution first")
     parser.add_argument("--cache-save", action="store_true", help="Save resolved coordinates to visual cache")
     parser.add_argument("--threshold", type=float, default=0.98, help="Visual similarity threshold for cache hit (default: 0.98)")
+    parser.add_argument("--detect-only", action="store_true", help="Run pure contour/blob detector and print detected bounding boxes")
     parser.add_argument("--json", action="store_true", help="Output results in JSON format")
     args = parser.parse_args()
 
@@ -364,6 +454,27 @@ def main():
                 print(f"   Action      : {cached_result['playwright_action']}\n")
             return 0
 
+    # Auto-generate mock canvas if image doesn't exist
+    if not os.path.exists(args.image):
+        img = Image.new("RGB", (helper.viewport_width, helper.viewport_height), color="#1E1E2E")
+        draw = ImageDraw.Draw(img)
+        draw.text((50, 50), "Mock GIS & Financial Dashboard (HTML5 Canvas)", fill="#FFFFFF")
+        draw.rectangle([100, 150, 220, 190], fill="#00CCFF", outline="#FFFFFF", width=2)
+        draw.rectangle([240, 150, 360, 190], fill="#FF0055", outline="#FFFFFF", width=2)
+        draw.rectangle([500, 300, 700, 350], fill="#00FF66", outline="#FFFFFF", width=2)
+        img.save(args.image)
+
+    # Detect Only
+    if args.detect_only:
+        blobs = helper.detect_canvas_interactive_regions(args.image)
+        if args.json:
+            print(json.dumps(blobs, indent=2))
+        else:
+            print(f"\n🔍 [CANVAS CONTOURS DETECTED] Found {len(blobs)} interactive regions:")
+            for b in blobs:
+                print(f"   • {b['label']}: Bounds {b['x']},{b['y']} ({b['width']}x{b['height']} px)")
+        return 0
+
     # Load elements
     elements = []
     if args.elements_json:
@@ -377,7 +488,8 @@ def main():
                 pass
 
     if not elements:
-        elements = [
+        detected = helper.detect_canvas_interactive_regions(args.image)
+        elements = detected if detected else [
             {"x": 100, "y": 150, "width": 120, "height": 40, "label": "TradingView Zoom In", "tag": "canvas_control"},
             {"x": 240, "y": 150, "width": 120, "height": 40, "label": "TradingView Zoom Out", "tag": "canvas_control"},
             {"x": 500, "y": 300, "width": 200, "height": 50, "label": "Execute Trade Order", "tag": "shadow_button"},