Dockerize stack, strip watermarking, add navigator monitor

Compose the headless-Chrome monitor with the three backend servers and
make the live monitor a full in-browser navigator.

Infra:
- Add docker-compose.yml wiring chrome + chatgpt + gemini + flow on a
shared loopback (network_mode: service:chrome); only chrome publishes.
- Add Dockerfiles for chatgpt-free-api and flow-agent.
- flow: run the FastAPI API on 8101 so it no longer collides with the
ExtensionBridge HTTP callback on 8100 (was crash-looping).
- Update extension cookie-WS ports: gemini 9226, flow 9227.

Cleanup:
- Remove watermark code from flow-agent (omniflash/watermark.py) and
gemini (gemini/watermark.go); drop ffmpeg usage.

Monitor navigator:
- Tabs are now discovered live from CDP (known services first) instead of
being hardcoded.
- Add address bar + back/forward/reload and new/close-tab, backed by new
/api/navigate, /api/reload, /api/back, /api/forward, /api/newtab and
/api/closetab endpoints.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Dockerfile

@@ -1,3 +1,9 @@
+# Build the 3-tab monitor server (GPT / Gemini / Flow live view) from source.
+FROM golang:1.22-bookworm AS monitor-build
+WORKDIR /src
+COPY monitor/ ./
+RUN go mod tidy && CGO_ENABLED=0 go build -ldflags="-s -w" -o /monitor .
+
 FROM akashyadav758/chrome:latest
 
 USER root
@@ -7,6 +13,9 @@ COPY chatgpt-free-api/gpt-extension /opt/gpt-extension
 COPY free-gemini-api/gemini-extension /opt/gemini-extension
 COPY flow-agent/Flow-extension /opt/flow-extension
 
+# 3-tab monitor binary (replaces the single-view base monitor)
+COPY --from=monitor-build /monitor /opt/monitor3/monitor
+
 # Install Chrome for Testing (unbranded). Branded google-chrome-stable (>=128)
 # silently ignores --load-extension, so unpacked extensions never load. CfT is the
 # unbranded build of the same Chrome version where --load-extension still works.
@@ -20,8 +29,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends unzip && \
 
 # Set correct permissions and ownership
 RUN rm -rf /opt/flow-extension/_metadata && \
-    chown -R 1000:1000 /opt/gpt-extension /opt/gemini-extension /opt/flow-extension /opt/chrome-linux64 && \
-    chmod -R 755 /opt/gpt-extension /opt/gemini-extension /opt/flow-extension /opt/chrome-linux64
+    chown -R 1000:1000 /opt/gpt-extension /opt/gemini-extension /opt/flow-extension /opt/chrome-linux64 /opt/monitor3 && \
+    chmod -R 755 /opt/gpt-extension /opt/gemini-extension /opt/flow-extension /opt/chrome-linux64 /opt/monitor3
 
 # Replace the start script with the non-root version
 COPY --chmod=755 start_hf.sh /start.sh

README.md

@@ -8,4 +8,163 @@ app_port: 3001
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Chrome Space — Headless Chrome + Unpacked Extensions
+
+A [Hugging Face Space](https://huggingface.co/spaces/akash1313/chrome) that runs a
+persistent, headless **Chrome for Testing** browser inside Docker with three custom
+unpacked extensions auto-loaded, plus a live web monitor to watch the browser in real time.
+
+The browser stays logged in across restarts (persistent profile), and the bundled
+extensions sync cookies / automate workflows for ChatGPT, Google Gemini, and Google Flow.
+
+---
+
+## Bundled extensions
+
+| Extension | Source dir | Loaded at | What it does |
+|-----------|-----------|-----------|--------------|
+| **Gpt Agent Api** | `chatgpt-free-api/gpt-extension` | `/opt/gpt-extension` | Auto-syncs ChatGPT cookies to a local ChatGPT Free API server |
+| **Gemini Api Agent** | `free-gemini-api/gemini-extension` | `/opt/gemini-extension` | Auto-syncs Google Gemini cookies to a local Free Gemini API server |
+| **Flow Agent** | `flow-agent/Flow-extension` | `/opt/flow-extension` | Automates Google Flow — T2V / V2V / I2V video + T2I / I2I image generation |
+
+All three are Manifest V3 extensions with background service workers. Each subfolder
+also contains the matching backend server and its own README.
+
+---
+
+## Backend servers
+
+Each extension is the browser half of a standalone project. The extension uses your
+authenticated browser session and forwards requests to a **local** API server (which you
+run yourself — see each subproject's README for setup):
+
+| Project | Server | Talks to | Purpose |
+|---------|--------|----------|---------|
+| [`chatgpt-free-api`](chatgpt-free-api/README.md) | Go | `127.0.0.1:9225` | ChatGPT backend API from your logged-in session |
+| [`free-gemini-api`](free-gemini-api/README.md) | Go reverse-proxy | local server | Gemini text / Imagen 3 images / Gemini video |
+| [`flow-agent`](flow-agent/README.md) | Python FastAPI + CLI | `127.0.0.1:8100` | Google Flow T2V / V2V / I2V video + T2I / I2I images |
+
+> ⚠️ This Space runs **only the browser + the 3 extensions**. It does **not** start the
+> backend servers — run those locally (or in their own containers) and the extensions will
+> connect once the matching port is reachable.
+
+---
+
+## How it works
+
+```
+HF Space (port 3001)
+        │
+        ▼
+┌─────────────────────────────────────────────────────────┐
+│ Docker container (Debian 12)                             │
+│                                                          │
+│  monitor-server ──┐  serves the live UI + /chrome.log    │
+│   (Go, :3001)     │                                      │
+│                   ▼                                      │
+│  Chrome for Testing 145 (--headless=new)                 │
+│    --load-extension=/opt/gpt,/opt/gemini,/opt/flow       │
+│    --remote-debugging-port=9222  (CDP)                   │
+│    --user-data-dir=/home/chrome/data  (persistent)       │
+│                   ▲                                      │
+│  socat :9223 ─────┘  forwards external CDP → 127.0.0.1   │
+└─────────────────────────────────────────────────────────┘
+```
+
+`start_hf.sh` is the boot sequence:
+
+1. **Profile repair & cleanup** — fixes a nested `data/data` layout and removes cache/junk
+   to keep the persistent profile small.
+2. **Lock removal** — clears `Singleton*` / `LOCK` files left by an unclean shutdown.
+3. **Preferences injection** — enables `extensions.ui.developer_mode` and sets a clean
+   `exit_type` so the "restore pages?" popup never appears.
+4. **Monitor server** — starts the Go monitor on `:3001` and symlinks `chrome.log` into it.
+5. **CDP proxy** — `socat` exposes the DevTools port (9223 → 127.0.0.1:9222).
+6. **Auto-navigate** — a tiny WebSocket client drives the first tab to `chrome://extensions/`.
+7. **Launch Chrome** — Chrome for Testing in `--headless=new` with all three extensions.
+
+---
+
+## Why Chrome for Testing (not regular Chrome)
+
+Branded **Google Chrome ≥ 128 silently ignores `--load-extension`** (removed by the
+[March 2025 Chrome RFC](https://developer.chrome.com/blog/remote-debugging-port) to curb
+abuse). On a branded build the extensions never load and `chrome://extensions/` shows an
+empty list with **no error in the log**.
+
+The fix is to run **[Chrome for Testing](https://googlechromelabs.github.io/chrome-for-testing/)**
+— the unbranded build of the same Chrome version where `--load-extension` still works. The
+Dockerfile downloads CfT `145.0.7632.117` to `/opt/chrome-linux64` and `start_hf.sh` launches
+that binary. Everything else (monitor, CDP proxy, flags) is unchanged.
+
+> Alternatives if you ever upgrade: use the CDP `Extensions.loadUnpacked` method
+> (requires `--remote-debugging-pipe` + `--enable-unsafe-extension-debugging`), or plain
+> Chromium. Both also keep `--load-extension`-style loading working.
+
+---
+
+## Endpoints
+
+| URL | Description |
+|-----|-------------|
+| `https://akash1313-chrome.hf.space/` | Live Chrome monitor UI |
+| `https://akash1313-chrome.hf.space/chrome.log` | Streaming Chrome log (debugging) |
+| `127.0.0.1:9222` (in-container) | Chrome DevTools Protocol |
+| `:9223` | CDP proxied for external tools (via socat) |
+
+---
+
+## Project layout
+
+```
+chrome-space/
+├── Dockerfile              # builds on akashyadav758/chrome, installs CfT, copies extensions
+├── start_hf.sh             # container entrypoint / Chrome boot sequence
+├── chatgpt-free-api/       # ChatGPT Free API server + gpt-extension
+├── free-gemini-api/        # Free Gemini API server + gemini-extension
+└── flow-agent/             # Flow automation CLI + Flow-extension
+```
+
+---
+
+## Local development
+
+Requires Docker. The base image is `linux/amd64` only.
+
+```bash
+# Build
+docker build --platform linux/amd64 -t chrome-space .
+
+# Run
+docker run -d --name chrome-space -p 3001:3001 --platform linux/amd64 chrome-space
+
+# Verify the 3 extensions loaded (look for service_worker targets)
+docker exec chrome-space curl -s http://127.0.0.1:9222/json \
+  | python3 -c 'import json,sys;[print(t["type"],t["url"]) for t in json.load(sys.stdin)]'
+```
+
+Open <http://localhost:3001> to watch the browser.
+
+---
+
+## Deploy
+
+This repo **is** the HF Space — pushing to `main` triggers an automatic rebuild:
+
+```bash
+git push origin main
+```
+
+> `hf-token` is gitignored — keep your Hugging Face token out of commits.
+
+---
+
+## Troubleshooting
+
+| Symptom | Cause / fix |
+|---------|-------------|
+| `chrome://extensions/` empty, no error in log | Branded Chrome ignoring `--load-extension` → use Chrome for Testing (see above) |
+| `COPY failed: ... not found` at build | Extension source dir name in the Dockerfile doesn't match disk |
+| Extension listed but service worker idle | MV3 headless quirk — open the extension's toggle or hit **Update** on the extensions page |
+| `Failed to connect to the bus` spam in log | Harmless D-Bus warnings in a container with no system bus |
+| "Restore pages?" popup | Handled by the `exit_type=Normal` Preferences injection in `start_hf.sh` |

chatgpt-free-api/Dockerfile

@@ -0,0 +1,17 @@
+# ChatGPT Free API agent — talks to the gpt-extension over ws/http on 127.0.0.1:9225.
+FROM golang:1.26-bookworm AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o agent .
+
+FROM debian:12-slim
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY --from=builder /app/agent .
+COPY config.json .
+
+EXPOSE 9225
+CMD ["./agent"]

chatgpt-free-api/config.json

@@ -10,5 +10,5 @@
   "bulk_delay_seconds": 2,
   "browser_wake_cooldown_seconds": 60,
   "timezone_offset_min": -330,
-  "raw_sse_output_path": "/Users/akashyadav/.gemini/antigravity-ide/scratch/raw_sse.txt"
+  "raw_sse_output_path": ""
 }

docker-compose.yml

@@ -0,0 +1,49 @@
+# Runs the headless Chrome + 3-tab monitor together with the three backend servers.
+#
+# The server containers join the chrome container's network namespace
+# (network_mode: "service:chrome"), so they all share one 127.0.0.1 — exactly what the
+# extensions expect. Only the chrome service publishes ports.
+#
+# Port map (shared loopback):
+#   chrome   : 9222 CDP, 3001 monitor UI
+#   chatgpt  : 9225 (ws+http)
+#   gemini   : 8000 http, 9226 cookie-WS
+#   flow     : 8101 http API, 8100 ext-callback, 9227 cookie-WS
+
+services:
+  chrome:
+    build: .
+    platform: linux/amd64
+    ports:
+      - "3001:3001"   # 3-tab monitor UI (also the only published port)
+    restart: unless-stopped
+
+  chatgpt:
+    build: ./chatgpt-free-api
+    platform: linux/amd64
+    network_mode: "service:chrome"
+    depends_on:
+      - chrome
+    restart: unless-stopped
+
+  gemini:
+    build: ./free-gemini-api
+    platform: linux/amd64
+    environment:
+      WS_PORT: "9226"
+      PORT: "8000"
+    network_mode: "service:chrome"
+    depends_on:
+      - chrome
+    restart: unless-stopped
+
+  flow:
+    build: ./flow-agent
+    platform: linux/amd64
+    environment:
+      WS_PORT: "9227"
+      HTTP_PORT: "8100"
+    network_mode: "service:chrome"
+    depends_on:
+      - chrome
+    restart: unless-stopped

flow-agent/Dockerfile

@@ -0,0 +1,16 @@
+# Flow Agent FastAPI server — talks to the Flow extension.
+#   Public HTTP API        : 127.0.0.1:8101 (uvicorn / FastAPI)
+#   Extension callback HTTP : 127.0.0.1:8100 (HTTP_PORT, ExtensionBridge — hardcoded in extension)
+#   cookie/token WebSocket  : 127.0.0.1:9227 (WS_PORT)
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+
+ENV WS_PORT=9227 \
+    HTTP_PORT=8100
+
+EXPOSE 8100 8101 9227
+CMD ["uvicorn", "cli.api:app", "--host", "127.0.0.1", "--port", "8101"]

flow-agent/Flow-extension/background.js

@@ -5,7 +5,7 @@
  * Captures bearer token, solves reCAPTCHA, proxies API calls through browser.
  */
 
-const AGENT_WS_URL = 'ws://127.0.0.1:9222';
+const AGENT_WS_URL = 'ws://127.0.0.1:9227';
 // NOTE: This is a browser-restricted public API key — safe to ship in extension bundles.
 const API_KEY = 'AIzaSyBtrm0o5ab1c-Ec8ZuLcGt3oJAA5VWt3pY';
 

flow-agent/cli/api.py

@@ -352,20 +352,9 @@ async def api_generate_video(req: VideoGenerationRequest, download: bool = Query
         temp_path = os.path.join(TEMP_DIR, filename)
         
         if await download_video(active_bridge, media_id, temp_path):
-            if not req.no_clean:
-                try:
-                    from omniflash.watermark import remove_watermark_video
-                    remove_watermark_video(temp_path, out_path)
-                    try:
-                        os.remove(temp_path)
-                    except OSError:
-                        pass
-                except Exception as e:
-                    log.warning(f"Watermark removal failed: {e}. Fallback to raw video.")
-                    os.replace(temp_path, out_path)
-            else:
-                os.replace(temp_path, out_path)
-                
+            # Watermark removal disabled — save the raw downloaded video as-is.
+            os.replace(temp_path, out_path)
+
             outputs.append({
                 "media_id": media_id,
                 "filename": filename,
@@ -482,18 +471,9 @@ async def api_edit_video(req: VideoEditRequest):
         temp_path = os.path.join(TEMP_DIR, filename)
         
         if await download_video(active_bridge, media_id, temp_path):
-            # V2V edited segments might also have watermarks
-            try:
-                from omniflash.watermark import remove_watermark_video
-                remove_watermark_video(temp_path, out_path)
-                try:
-                    os.remove(temp_path)
-                except OSError:
-                    pass
-            except Exception as e:
-                log.warning(f"Watermark removal failed: {e}. Fallback to raw video.")
-                os.replace(temp_path, out_path)
-                
+            # Watermark removal disabled — save the raw downloaded video as-is.
+            os.replace(temp_path, out_path)
+
             outputs.append({
                 "media_id": media_id,
                 "filename": filename,

flow-agent/cli/edit.py

@@ -115,14 +115,8 @@ async def edit_segment(bridge, prompt, aspect, project_id, media_id,
     temp_path = os.path.join(temp_dir, f"segment_{segment_num:03d}.mp4")
 
     if await download_video(bridge, result_media_id, temp_path):
-        # Auto-remove watermark
-        try:
-            from omniflash.watermark import remove_watermark_video
-            remove_watermark_video(temp_path, out_path, show_progress=False)
-            os.remove(temp_path)
-        except Exception as e:
-            os.replace(temp_path, out_path)
-            log.warning("⚠️  Watermark removal failed for segment %d: %s", segment_num, e)
+        # Watermark removal disabled — save the raw downloaded segment as-is.
+        os.replace(temp_path, out_path)
         # Cleanup empty .temp dir
         try:
             os.rmdir(temp_dir)
@@ -213,13 +207,6 @@ async def run(args):
                 "-i", concat_file, "-c", "copy", merge_path
             ], capture_output=True)
             os.remove(concat_file)
-            # Auto-remove watermark from merged output
-            try:
-                from omniflash.watermark import remove_watermark_video
-                clean_path = remove_watermark_video(merge_path, show_progress=False)
-                os.replace(clean_path, merge_path)
-            except Exception:
-                pass
             log.info("✅ Merged: %s", merge_path)
         except Exception as e:
             log.warning("⚠️ Merge failed (ffmpeg needed): %s", e)

flow-agent/cli/generate.py

@@ -99,19 +99,8 @@ async def run(args):
         temp_path = os.path.join(temp_dir, os.path.basename(out_path))
 
         if await download_video(bridge, media_id, temp_path):
-            # Auto-remove watermark unless --no-clean
-            if not args.no_clean:
-                try:
-                    from omniflash.watermark import remove_watermark_video
-                    remove_watermark_video(temp_path, out_path)
-                    os.remove(temp_path)
-                    print(f"🧹 Watermark removed!")
-                except Exception as e:
-                    # Fallback: move temp to output as-is
-                    os.replace(temp_path, out_path)
-                    print(f"⚠️  Watermark removal failed: {e}")
-            else:
-                os.replace(temp_path, out_path)
+            # Watermark removal disabled — save the raw downloaded video as-is.
+            os.replace(temp_path, out_path)
 
             # Cleanup empty .temp dir
             try:

flow-agent/omniflash/watermark.py

@@ -1,375 +0,0 @@
-"""Omni Flash — Video Watermark Remover.
-
-Removes Gemini/Flow watermark from generated videos using reverse alpha blending.
-Ported from Gemini-Watermark-Remover-UI (TypeScript → Python).
-
-Algorithm:
-  Gemini adds watermark:  watermarked = α × logo + (1 - α) × original
-  Reverse solve:          original = (watermarked - α × logo) / (1 - α)
-"""
-
-import logging
-import os
-import cv2
-import numpy as np
-import subprocess
-import json
-import sys
-
-log = logging.getLogger("omniflash.watermark")
-
-# ── Constants ──────────────────────────────────────────────
-ALPHA_THRESHOLD = 0.002   # Ignore very small alpha values (noise)
-MAX_ALPHA = 0.99          # Avoid division by near-zero values
-LOGO_VALUE = 255          # White watermark color value
-VIDEO_ALPHA_SCALE = 0.6   # Gemini videos use 60% opacity watermark
-
-
-# ── Embedded watermark assets (base64-encoded PNGs) ──
-_BG_48_B64 = "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"
-
-_BG_96_B64 = "iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAIAAABt+uBvAAAfrElEQVR4nJV9zXNc15Xf75zXIuBUjG45M7GyEahFTMhVMUEvhmQqGYJeRPTG1mokbUL5v5rsaM/CkjdDr4b2RqCnKga9iIHJwqCyMCgvbG/ibparBGjwzpnF+bjnvm7Q9isU2Hj93r3nno/f+bgfJOaZqg4EJfglSkSXMtLAKkRETKqqRMM4jmC1Z5hZVZEXEylUiYgAISKBf8sgiKoqDayqIkJEKBeRArh9++7BwcHn558/+8XRz//30cDDOI7WCxGBCYCIZL9EpKoKEKCqzFzpr09aCzZAb628DjAAggBin5UEBCPfuxcRiIpIG2+On8TuZ9Ot9eg+Pxt9+TkIIDBZL9lU/yLv7Czeeeedra2txWLxzv948KXtL9WxGWuS1HzRvlKAFDpKtm8yGMfRPmc7diVtRcA+8GEYGqMBEDEgIpcABKqkSiIMgYoIKQjCIACqojpmQ+v8IrUuRyVJ9pk2qY7Gpon0AIAAJoG+8Z/eaGQp9vb2UloCFRWI6igQJQWEmGbeCBGI7DMpjFpmBhPPBh/zbAATRCEKZSgn2UzEpGyM1iZCKEhBopzq54IiqGqaWw5VtXAkBl9V3dlUpG2iMD7Yncpcex7eIO/tfb3IDbu7u9kaFTv2Xpi1kMUAmJi5ERDWnZprJm/jomCohjJOlAsFATjJVcIwzFgZzNmKqIg29VNVIiW2RkLD1fGo2hoRQYhBAInAmBW/Z0SD9y9KCmJ9663dVB8o3n77bSJ7HUQ08EBEzMxGFyuxjyqErwLDt1FDpUzfBU6n2w6JYnRlrCCljpXMDFUEv9jZFhDoRAYo8jDwMBiVYcwAYI0Y7xuOAvW3KS0zM7NB5jAMwdPR/jSx77755ny+qGqytbV1/fr11Oscnph+a1PDqphErjnGqqp0eYfKlc1mIz4WdStxDWJms8+0IITdyeWoY2sXgHFalQBiEClctswOBETqPlEASXAdxzGG5L7JsA/A/q1bQDEkAoAbN27kDbN6/1FVHSFjNyS3LKLmW1nVbd9NHsRwxBCoYaKqmpyUREl65IYzKDmaVo1iO0aEccHeGUdXnIo4CB+cdpfmrfHA5eVlEXvzdNd3dxtF4V/39/cFKujIJSIaWMmdReqFjGO2ZpaCUGRXc1COvIIOhbNL3acCQDb2Es5YtIIBI3SUgZw7Ah1VBKpQmH0RlCAQ81noVd16UnKMpOBa93twRbvx9t5ivnC1MQ4Rwaxsd7eyu36wUQzkxDMxmd9Rl6uxyaU+du6/sEBERkMrUmSgY97DyGN7pwlc4UqUuq1q0Cgi6LlrHtY0yNQnv5qMZ/23iHexf/OmhXr5ajZycHC/oklqsT1BAYK1lxy/RtCUNphW0uDCZUdJP3UBCgAwmEYVoiEBmyBEauFJ0w4JnGdWSvCHJHK5TimY3BW5hUqNnoxpNkYiWuzM927sdWakjUfXd3cX83mMzBVcRaAGgo0wOA5YvGZdiMjo5sZEA4NLMK2SKAZpumZDViWMgBjgFoHXq0p7YpberAgA5iC0iMgF7r4fKX/nZDSmqvfu3attrne0f+tWCsmxdhhSlao/yp5SkZkpoj6dtN/rshANptFVfZgtsHAJSKYmREqkDNWxSYM5GjWvpIAoGIJIgkR1lPBrEQCqQiwzM91G+ACGYLHz+q39W5UlTkC5c/f2nWvXrjnQBLKk3WlkdqRQESIGKPwdjxp4Fw4XmaVYKKUQqKE+GEqw4COIIZHwYqkpqtpsLeJOs50ItFpgYoJJL1Dl74lEoobLChbqARiGYX9/XzHV3OzU/tza2rp7925VE44rlcJlTi2VqcplXWeQMfVTmg63Cak+UIIXVQXzbHAzjywnHhsQTtSkoapE3GJiu6Tpp/VYs1PjkcHBl+c7+/v7BKoaQ2SOCCDNb27fuX1t65qJmgYWBIIw0eDphRJM8lr426ROMABSQs3FwAB5EDMMM+ZZlXc+gprFQDnMm2salYFGdQEosU+2aFmuMdX+ybdM8kb3/YP788WihUONJiViTVgnbG9/6c7du0Q0ljCKIoJvFBY3VEU2USuQELdMkJhNhKZiGmlTY5CZTyZyImLGLlBNpRUikKmRB2/mHUM7Mj50iYWXcUMI6YmKBX47Ozs3b36jKg4oYgKFNUupWap3bt+Z7+xYDigiSiygcRyppNkM0lHM1ZICMjJUVCz4NtlbVcfZqgohHaEQwUgtlyoYJ9KKT6lKIpLp/LpbMV3wBKIm0OKZoaq/raOM/3qJgkQUEj44OLCRh4ynvjLU2f/c3tp68OBBakcx2FYkMDmJiNmIB3PULjT1j7ciQKnxXQ2UeBgYUHMzAEQvFSNYlYQwQFrEGVA1dE2IQERMAgMEYjCRDzPPKmX2+e0be/vfuBkKktgIoqaGwbMmmL29vTff3I1xewUqC0Cq5nOK6TFqrquqyqoOUi11hPnZsUV8FLHiQAxRRoG0asNExMNg+XdVv57TbQAWR4hLz6Dh0kJEVU0LB/BO6MJEObuakY2td3Hvfvfd7e1t6omMyAUAtBaOyxUm1hHfY5NbwBClC2Sg51qmYJANzx2JjtAxogZk7uspj3PNQx6DYCJmmmkEqESkKqZlKfaDeweL+VxrvFwGktwBoAnU4c4W88X9gwNS8TqBR+3+UGW4KQcR7GGyorcIhyKnETAzgxkDqZKKoZiqZNbUkm/K8K5wfRIUVAiotfcUiKpSqwB6Vqnq6PPVr3713r17zfLXL+rvR9ICdSC/ffvO7u51J52b+mdklLDNnNoRH/q6lUZoHmQjm2UmzUpGhElehIZ0fHE8F4XoQDOGFRXJ80e28iKrEmGQEYl/RMqzGZhFHC/mX955/72/s8jMR7+RR21U8bV9DA159913t7f/HdEAZVI2s4o40Avno14Gs9j9aY1CGth7nsjMEX+LYIQQKUcVqahAKkhyN0EhYajoUfMpLWpwf+/Ba7mDg4OD+c7CzCgUr5MwjCkGF9IqCl0pjTBfLL77ne8YiQ0uu8C6hdfVRWRMv24Wlo4F9Gg+Q0RliqMRMdjT1fWYfKxCmDcBj1kAWADmwAYmZfMCYFXC3x7cu7l/s3aSvxQgTutWr5umi4sPYWoAsHdj787f3CZS1bFiykAzCBGxjKo0jIFKqqPIZdR61GZZmBkggM39JdYyD9mmiLAqVDDhKFFXh88Xwr6iqoQWQVRWpg4CgOj169cP7h1URdCsKJKDVGOcexxMwoCJur3zzjtvvvlmEWpTZx3B/BplfBQSjVG0cC+RyzNEbSqGzPtIiSnQziom7AVgcJ+2mYoSaPAqTxbx3PGJVtS3Mtt8/vr7f/felWijUFFMHFpGiRWzC2Db9f7777/++rwW5y/FFEqho1uHKBMDnGhrHj39jE8ujqqqIMdsq4VZENfGU6UBQGS0e7XMXJ9J866/VTNphkB3dnYePny4tbVV360aMf1btUEzrX3f5+vb29sPH364mM9TZw1rndpWq3HK1wsAOQoeuijRO7Q2lUSQDlut7mPqbNZYp5KJyGZfqjVx5Htl1ghgnr8+//B7Hy4WiylrvK3yO3lAoLCyyENexdT54vXvffi9+Zd3krzWPCmjhoJUw+6cNVNVUlYlJcEwad7wNN8n8vpGIr/VSqg9AAf5Rk1KI8DbMkVsb29/+DC4c7U77741gK55WSIRNXY2ZbTocbH44IMPtra2mNnTV3fBha/FRyNYv0mp1+4ARAOriAXDSqIK5kEtrFQwD5k0O/sJsNS5xARtxYUCTPPXd95/7/2v/sc3oo/SNSHgxP5qk/QETy+d1sI4f4DQyiB5RwFguVz94B9+sFwumVkuPd2hCBpVRxXYDGiUotlm7pQ8MRAoiAY0F6SjqcXANjBVtaUtEQwrs8fvlgTGMwT48pc6Z5D8ev311x9++HA+n1OIpDGIHEpy6M6g6uJTa6x8BlKrqCO8WyffxrXVavXo0aPVapVZVap/zBrYSNtnJWmCV62fAZByA+nIGxiIUiBskYy7ZGtLCb5GoiS3KOoa3FkAJXGpHrrVEBUTPbcgsY83jF+K9dpspmz+13w+//Dhhzs7O4YGCYh1MqrhdLzV1i6VycUasvgaEcN80ybEjBUNHDBkDnxQ7bhjgsolI2+99dZ77723tbUVaw7Mhf8lFxUdydBR+/trPKJ4CsD5+fnHH398dnZm34dTK1ojwp57kJJHaomzFafYqoLD7Jqqyviv5iOTQV3oSMX02yxeV/S8fef2tx98GxvB7y+6NvJigkf9Y+Ytar+Hh4eHP3uao1ARtnRd1Tz1RschyGURREQDzVSViGeqHllVDVJV046CTVZAaBUr++e1115799139/b2/oIB/5nf+3dmlpFuxFfUMwW9ChyfHB8+fbparXzsANEACKACxxq7HD3JEk57nckKzRRrEOr0rk+o2qPsXPeyb/gvr5Ardnd3v/Pud82dV/q6QeJP8GjKkfyNeHddg9Y4st77arX64ccf/f73v4cID1CBxMIdtizMWSMI7xzYxMmBzFAasqShWdBd4uP2GoBr167dPzi4fefOnzvsyajSneczsAC8Wk7vuSjuqm7UoI3COPzZ039+eig2HUDwWg+8dgxEEkIWqDqDEJ6deDYQKcTr8LGMzCbsWwJBRKphVord3d3vfue788V8M3HNbVOSEXyJxyYMqhxZG2TXxeSP3g9ufHH1cvlPT56cnp5G+JmFSDe9EqmIGVchakDeyuds2seZyTyOl4AHkPOdnQcPvr1344ZFfH0E6ExxRhRV8BrN1CG194nR0qwW9BbDqdwpZjjVIwoaqvYRYKj0yeHy5UvYmuVSFOw6goeOnq/Nrr3WKo9j1ZqWyAhGAFuvbd+9e/f2ndvb29ubHA2Zs82eJpy6Mthr/KXmrjc/ENyZ3J+E6Y2hrsDEbfAnJ8efHD5dLpdMM1UFCW2EToB8RqPN0rj9ZyUo37y2de3u3Tt3bt/1GOcV+l+tqR+AM+iqd5uou/rQn8GgK9halcsTDn9/uVwdnxwf//JfVqsVD6gFE9iyX26RdHPtlkZYSgHAErSdxfyb3/zm7dt/s7W1vWlkV4/zFWpy1firt9qoTVfx6CpyOvPsX1aAcHJ8cnh4uFqtmFnkkpkrr+CxDDvuGu6kHu2++ebBwf3d67vxKLDuNeqw1z3OVfHeK4Zn6sCEUcG2WGYtpvuL4tA1oytNOGT/6lenJycnn356CkDEc4OEFwJ7+AdAFbu71/f29m7d2u9UpoYnVw3sFXrRkRufuupUfEFrjVwdBF3ZC2LsiKrAelSl3TvM/Ic//OHs7Ozk5P+enZ3lYigzMWxtbb99Y+/69et7e3tXmhKV1oMEb4XNvF2DpgBUjSX5EP62Mah5/U2hzSsYtNFsJ8C0Rnx8pUmMmkmKrlarFy/Onj9//tvf/na5XNKd/3rnwTsPGgUdCnh+0cF87SZ1ta2gaBR2JE/AuwsCE8ZfwQWahpT55JW2TNMQqQ6qNexfhKQ6Mf/0pz/lO7dbKFwmgaxbLVyaEFy7105lJhFyzyqvJKxHwGVSrNKdXXR8mejZ5FnP4LXeL2sl2jYDiqmaYE0Tvjnxe/fuzba3m02VMnCIND53I6qmUc1nSjQBWise6WiNYi39IZEh6JtyhLLmuHZV9TRnIvF6amqngGZPhgzkAiZE+wbJpIrPzy/48OnTJpM1BEAKk6b369gmH6+6GXpBU4doItA11KgtaNPojV2o1yK5GW8PfOtXgE+17q7jo6NnRAN/5Stf+ev/8Fdf//rXd3enm0omUeYr/Nhffl0BORT68oqoEuXVDS5s7ZWNnNoI4UrnFxfPT391dnZ2enp6cXER6yBdD8fd3es3b+6/9dZb8/l8I+VY49qfc00z1Y6u9ac3RxUdmmn/cG1yveUJg7Sgftw8Pz8/Pjk+PX3+4uw3sdRHPZImanXZTMG+duNrt27t3/jaXhJxZbmno6/knzUXWwvSYClSK25c4Yw6gIdepcSb4G/DY5PnCQDOzl4cPj08++zXICLL46XlsV6Trjuw/GJV1fmXF/fv379586bfs2nDnBhZj32ok0/mX5EuUoQejJgNmPJi3aP/ycG/ysSom0FC082Li4ufPzs6OTlZLpeAwFKuEcaNnA0lWxgdjQ0gYZBqrIwQArCzmO/v79+6ub9YLCpTYOFPDuwqkitY2AjDH13hl4IxtBbLKCZhgze6ITQl0HqmQoCen58/Ozo6Ojq6uDi3u5ZmCSmJTe359AQREc+GtqJFGSQQJfKikk2ejSrMvPPvv3z//v2b+zfTrVYoVcvjwoF0SlyVCx3FmxiU4fb6yHsG1cFr90wPN63li4vznx/9/Ojo6PKLL2SSmDIJKSuRwnbrkA9zKLPPZWrQ9gXaQit7wOrQO/Odb33rW9/4L9+oGjSpARGzqnS2UEOVdW5sMCKsffEnUKWZ/BXX6enzJz958vLlS1X1FQheWeS0GFtCZ3X3WIo5+KKY5stiupaI6opMz3GZANz4z1978ODBYrFoeUKfgmX9xW+/gkEbsXnCkbU7V3iM4v+K7qxWy398/Pizz36TrwwE9X3ABoheurcimRtXaJBnEiWf4GSQ1Wvd58XmGYQ23bt3r+1n2ui101w2lUr6Ofu+KDEpg1IkhH0jU/ZuigmPnh09fXp4fn6eKzU2XsoKUQjIdkBlyZVn4c/iVkxoxzrNXL9xOdb5eHvrjTfe+OCDDyp4b2SQm6F/bgtLu2pHA/5N0L0mgA0S6Rm0XC4f//jxixdnceNKBhGR2L567eaWYRoEoJ/0aK95Md+wRpQAHmw7kACggSG6WCwODg5u7u9vcM9XaRCF9+3jvaicYN15rcfWVzDIGz09ff74x48vLi4A9FseNzNLWZNB1KHqAIqDSMLq6mDK/pmOr6Q2ly+qqsMw/Le//e8H9w4azYRalNow9+AimUxaxCsVa9KR2/Kq0Pe4vcYz4MmTJ89+8YtCrU4MPKew2h0SU6QEk4yk850oWnmtk0EEjHmmi/VRS/q5CMaM8vr16++/957PeRBitdhVCzNcI7qAux+nZ4/UsQxTEXZQdH5+/tGPPn7x4oWq5GxwQQ+NhWXJoDjxhe2Ui6G0HBPWRCTSlpo7BCkTs+olgG4e0rkZGsfJaVLVxWLx8H8+XMznyEmFcCydEoW+ELKy8cqSGLCBy0hccxnYEqHly1UObxPuCMfydj91Bc2LDTSrs/CqI2EGYFMtmOx+S2VhSUZZ4u9QLQS2A1QEwM7O3BffrYWF6YIzBdkQ2uGK53WNWzViUl2ulo++/2i5XKLUQNOOTIQiYqbEakstxRb2JINIbXkU5wrGXGmPbAgZJdcVMOl3y0Ly/M3lWJ9VEkrTMJ84Qu0WW1MutfBV7dO3+ue7y5RTAf3d73//6PuPVqsl+c4aSiKnjdTRZgUvky3/t+zUj09TmjBFNcc5W31suyL8RCHKw3B8N81yufz7//X3v/vd79aGWWq36zqbVW2DHu0fs5ps7GktjdByufqHH/zgjy//qLEsNVdC2+4dKqXV2oCtb23jL1LPq+UZlUrPRAqDc7N0ZVY04SqtfpKJEuHi4vyjH320XC2nbGj+qTXXfdW7+ahBxsq9CMqT0cvl8tH3H33++YWI5BkYuTbQ9rvVrQGq+SFsIltTtYAmFwnDViSWJasEMCnn+o/c/7O+oc46U4UgVGno9GK1XD569Gi5XPYimVgdHGK1vFt4qCV8d0ii6JuwXK3MnAVj2TuWg9dRR49gYhE086BKNVMloE1Lw/fca9jWZJ10YAqocrrpZ2RYkQAUi7EZ2u78L1qtlo8ePfr88/PKlLoDeO3qgc9/ty4pC+SE8/PzR99/9PLly/SheS5FwWYQkc2419XubaRxpd1pH0O0fQwASGEnvqgqg9HtAnEzti0yOQoiUoIyUZyhkZdt0lwtlx9/9BEZpqjz28ZNayq5XpmncFXFLJxzH/3wRy9Xf6y8HmjI0AwA0WDrEicupfQ2ilzqeGknGZF6WFwpKkd0qdoJQxOZNlQKh1/QqY1wcpiGxoJGIrx4cfbkyZP1Nifkls/Ni657Hvv+8PDwsxcv1llsM+vWRJtij73y651edeUzTCozbh5RMAqUZ4PtpFcdY3NGxKDEqcLKUKaBZmzbHdqPeZA2tl8cPXt+ejrhjmqBmG5uVpsfy3XVoYBQHP/yl08PnyLO74PFYoCq2lqvcpnDFekPb/SKDw2qJJ1c/SQT1VFVBlsK3JxixIe2/WCC9iJQ6jCrEqL98QLsx9IN7tmZ/vHx4+VyOZGSa3QN+Vro539NnOZqtfrZz35GsRLOVDt3E0a/1K3QoC4di3NrbPd4t0esrSVXEEFE2OM7AdFA4ExG1NYMeZ1ogLRtjxZIqCorsfp+USJqG/YNgFiVxM4bEugXX3zx+PHjwh7TIMkAoxO8OlxXL2aG98OPP1q+XNnhlVHbU8VIZPu8eojlmalJ4qwL2z2vY/BAea7MyGz5w8DMEWUrQCSxtb1qR9TSNFfJUnDHuCCSu+3HtSCgk7wSPvvss2fPnrW/C+iU9xqUhsdsPvjw6WGNP3PxYI58EkOPl7a6su2P7i9XpWyHSlo7jgrf9MJ22EoXCnpQBLYzUbrWc9QM2DlDMqqVckQYHnl5A/aGuK89PDy06JGyJOQA07kYNbCpnRKtVsunh/88EA/E0QsZPtr+2BybBXuqo51t1vsZCtJtpKNvs40f5pkveGYCD75OkcrG4Xq5JKk75mEiCe9U1SBIPaPoQIqIbLnkxcXF4x//GBQ1HXRtBkpXvrTf//Tkie10HscxZ2JUDZvrTrHkVAviaqSS4p1koFouS/dlHNk2/ChBMJop+k876ETJjpKFxQm2J3qwmDsxi5RFkpUAQCqx9wgqlyFJefHrs+enzwGN0zO7ALlX0XYdnxx/+umnNEQXwyw5q6o0wE5wycsLOHYOCakhDhHleYl+PlnQ7D9gUX/G9rt2WpMMrla9LoHq3aoEXC6bAmWeDRqbEYnoyZMn5+clvHY3EcoySU0IAA4/+aSBURwYpKWGV0liP/CttNLTHF4vM7/UJQGVPd0A2zG/REqkdi6inT4QN4nIj5AzjTBtyvOk1eq4QhAdiAEWOy3DXBwx+dFhY+44U8Ly5erZs6OOhZG71KSMfFETjk9OVqs/QuPssHIsj/q2d/LN3d6bbXGiyBNINY7osfMa1N8gZtsCh/YT3AQrnNNpqE2iVV9SPnX/Uy1RZ0K/rlP+LkesF/WaOvNL7Jm69vhj7S2Xq6dPn5psiwV1dfjCL53NZgapWYGwr7rTZXoie4WX2jjXpzUOJwzAUyUZ9dJ0x2S1TpOI5L4FirMw86AuWPBZKl7G988vzn9+dGQG1ZG9hkLHx79cLv+/siprFKFaO86XEYhzPBKnS17aVMPxxVro9mQ0r+L+SkeCdBhERDU7GwbWmKrLYwZrpBCPDQlSE1fIE9nUkA84enbUIdHkCh6d/Mux1vSvBPf5mW2XUwQ1Odqr9LoqeK24Z+SVLbTxiHSFIiWMowBkx1dmKXNUyd0L1p4hgB/22icc4eDayKwr1ZGBL87PjwyJJl6rGNrxyfFqtWImUmYvALIhZh9JiOrY7acFkba9uDl7wxgMNEnZbFbgAbMQyI9pkIx789gYSz1aME7M5Afx+AL9DZYfR12lrDJCSe5svPKb4+NjoAt2Jn8eHh5WfcmcK1WDqK3+Sl02SiZHLayTRJlzAwrGpm85lMrYDFX4nP5ovPAT4jTP/kIjCAZAZZ6kqnRV2u6ID3CcKc4vly9fnL3oyon+Mgg4PT19+XIVMS6SNZE65MYJrsgdWqyqY0bYSR5EGWTxkZNqft1nt9rJs65B9kdh9rQqmNdEbtXOq21TXwN2ppe0oz4J4JNPPuk1p0XVx8fH6TRblWf0//7AQJB51o7RXkvNxnL8Y3XKG7V7ctOMI3IQ0ZhBHcAzRVffWX/Z74jmUXTrWFjY5xFtHMLWziFSwovffHZ+cR4ZmbMGhOVydfr/Ts1DEClIBaPIZZFfqFU4xzykzjggInZOq/HOUQk6qV4nUJLC4MlwygWAUB8ugOLlPO6CgGwxFSo9yEQyhcrW/bpw0iKOT46zn+AQXrx4kTcA+LKuiVeMRLQ5nYghM5LOqvNGEebYs5HJk8FysjMiRxHBCBKCHUQIAH7y+ERFs3UpR20nFjYbDIBnxH9+ArZKQtJ6evo8JZpx0Mnx/4Hk+fmceUGG4wz1gmHQlrGPqsLOktI4KiKQiJllHHWU/CFVHS8l0heL4DJA4RSy/VscZ5V2A51kSnLBGjUFro4jPgAS/jGqSxM3d3Z2dn5+UaeqV6vl2dlZfdi/KuR5Hk1NHimk6jqqXsOKpakvDg5O8ETq4cVKZEl21LglbDqa9O0ANCOl7vSdzWZZu0SEHhmJ+JKPPINXAIniKwXeNBPW0+e/qkHlr399FosuOs/o+Q3Zrv8WYRANFHBhg7RgbRgGK/INQwisnAOJQC6jqtkBtUUZXcmiqFLnsCYHu6U2orr52NTpZxFwpyP5n3mkVKuSEuHs12f1zumnz52zExQzhBRHfrMA0qYmteWkTbU7T7o9Foe4V12bqN5MR2Do4y772ghXVgiYRUfyVRCggWNWgDRiVq0g2tkp217+MtfsJ+ygDOn09LQG0L/77W+pLSrxBIIpAMGgnAReEgUgtovFqLLsUMNSfAkCQ3IFK1GS6px3LhtIj83iiHydXWVt8wHBzDijwqcE8j9eco+WI1ZLm6zM7RP2Whxfrzit34svzn/ykyfLPyzPz8+f/OTJ6uVLNLrF9qsbd2owXSWan6U73q47YXrioeqVEF4fBvBvwZvfB2giLLAAAAAASUVORK5CYII="
-
-
-def _load_alpha_map(size: int) -> np.ndarray:
-    """Load alpha map from embedded base64 PNG data.
-    
-    Alpha map is the max RGB channel of the watermark on black background,
-    normalized to [0, 1].
-    """
-    import base64
-    
-    b64 = _BG_48_B64 if size == 48 else _BG_96_B64
-    png_bytes = base64.b64decode(b64)
-    arr = np.frombuffer(png_bytes, dtype=np.uint8)
-    bg = cv2.imdecode(arr, cv2.IMREAD_COLOR)
-    
-    if bg is None:
-        raise ValueError(f"Failed to decode embedded bg_{size}.png")
-    
-    # Resize to exact size if needed
-    if bg.shape[0] != size or bg.shape[1] != size:
-        bg = cv2.resize(bg, (size, size))
-    
-    # Max of RGB channels, normalized to [0, 1]
-    alpha_map = bg.max(axis=2).astype(np.float32) / 255.0
-    return alpha_map
-
-
-# Cache alpha maps
-_alpha_cache: dict[int, np.ndarray] = {}
-
-
-def get_alpha_map(size: int) -> np.ndarray:
-    """Get cached alpha map for given watermark size."""
-    if size not in _alpha_cache:
-        _alpha_cache[size] = _load_alpha_map(size)
-    return _alpha_cache[size]
-
-
-def detect_watermark_config(width: int, height: int, is_video: bool = True):
-    """Detect watermark size and position based on dimensions."""
-    if is_video:
-        short_dim = min(width, height)
-        if short_dim >= 1080:
-            logo_size = 96
-            margin_right = 64
-            margin_bottom = 64
-        else:
-            logo_size = 48
-            margin_right = 72
-            margin_bottom = 72
-    else:
-        if width == 720 and height == 1280:
-            logo_size = 48
-            margin_right = 72
-            margin_bottom = 72
-        else:
-            short_dim = min(width, height)
-            if short_dim > 800:
-                logo_size = 96
-                margin_right = 64
-                margin_bottom = 64
-            else:
-                logo_size = 48
-                margin_right = 32
-                margin_bottom = 32
-
-    x = width - margin_right - logo_size
-    y = height - margin_bottom - logo_size
-
-    return {
-        "logo_size": logo_size,
-        "x": x,
-        "y": y,
-        "width": logo_size,
-        "height": logo_size,
-    }
-
-
-def remove_watermark_frame(frame: np.ndarray, is_video: bool = True) -> np.ndarray:
-    """Remove watermark from a single frame (BGR numpy array).
-    
-    Uses reverse alpha blending:
-      original = (watermarked - α × logo) / (1 - α)
-    """
-    h, w = frame.shape[:2]
-    config = detect_watermark_config(w, h, is_video)
-    alpha_map = get_alpha_map(config["logo_size"])
-    
-    x, y = config["x"], config["y"]
-    size = config["logo_size"]
-    
-    # Extract watermark region
-    region = frame[y:y+size, x:x+size].astype(np.float32)
-    
-    # Scale alpha for video
-    alpha = alpha_map.copy()
-    if is_video:
-        alpha = alpha * VIDEO_ALPHA_SCALE
-    
-    # Create mask for significant alpha values
-    mask = alpha >= ALPHA_THRESHOLD
-    alpha_clamped = np.clip(alpha, 0, MAX_ALPHA)
-    one_minus_alpha = 1.0 - alpha_clamped
-    
-    # Apply reverse alpha blending to each channel
-    for c in range(3):  # BGR
-        channel = region[:, :, c]
-        # original = (watermarked - α × LOGO_VALUE) / (1 - α)
-        original = (channel - alpha_clamped * LOGO_VALUE) / one_minus_alpha
-        # Only modify pixels where alpha is significant
-        channel[mask] = original[mask]
-        region[:, :, c] = np.clip(channel, 0, 255)
-    
-    # Write back
-    frame[y:y+size, x:x+size] = region.astype(np.uint8)
-    return frame
-
-
-def remove_watermark_yuv_frame(frame_bytes: bytes, width: int, height: int, config: dict) -> bytes:
-    """Apply YUV watermark reverse blending directly in raw yuv420p buffer using NumPy."""
-    frame_arr = np.frombuffer(frame_bytes, dtype=np.uint8).copy()
-    
-    y_size = width * height
-    uv_size = (width // 2) * (height // 2)
-    
-    # Reshape planes into 2D views
-    Y = frame_arr[0:y_size].reshape((height, width))
-    U = frame_arr[y_size:y_size + uv_size].reshape((height // 2, width // 2))
-    V = frame_arr[y_size + uv_size:].reshape((height // 2, width // 2))
-    
-    x, y = config["x"], config["y"]
-    size = config["logo_size"]
-    
-    # Align coordinates to even numbers for YUV420p subsampling compatibility
-    x0 = (x // 2) * 2
-    y0 = (y // 2) * 2
-    x1 = ((x + size + 1) // 2) * 2
-    y1 = ((y + size + 1) // 2) * 2
-    
-    # Ensure bounds are within image dimensions (which must also be even)
-    x0 = max(0, min(x0, width))
-    y0 = max(0, min(y0, height))
-    x1 = max(0, min(x1, width))
-    y1 = max(0, min(y1, height))
-    
-    # Intersect aligned bounds with actual watermark bounding box
-    w_x0, w_y0 = x, y
-    w_x1, w_y1 = x + size, y + size
-    
-    int_x0 = max(x0, w_x0)
-    int_y0 = max(y0, w_y0)
-    int_x1 = min(x1, w_x1)
-    int_y1 = min(y1, w_y1)
-    
-    # Create target alpha map for coordinate-aligned region
-    alpha_map_full = np.zeros((y1 - y0, x1 - x0), dtype=np.float32)
-    
-    if int_x1 > int_x0 and int_y1 > int_y0:
-        src_x0 = int_x0 - w_x0
-        src_y0 = int_y0 - w_y0
-        src_x1 = int_x1 - w_x0
-        src_y1 = int_y1 - w_y0
-        
-        dst_x0 = int_x0 - x0
-        dst_y0 = int_y0 - y0
-        dst_x1 = int_x1 - x0
-        dst_y1 = int_y1 - y0
-        
-        alpha_map_full[dst_y0:dst_y1, dst_x0:dst_x1] = get_alpha_map(size)[src_y0:src_y1, src_x0:src_x1]
-        
-    scaled_alpha = alpha_map_full * VIDEO_ALPHA_SCALE
-    scaled_alpha = np.clip(scaled_alpha, 0, MAX_ALPHA)
-    one_minus_alpha = 1.0 - scaled_alpha
-    mask = alpha_map_full >= ALPHA_THRESHOLD
-    
-    # 1. Process Y channel (Luminance)
-    Y_roi = Y[y0:y1, x0:x1].astype(np.float32)
-    new_Y = (Y_roi - scaled_alpha * 235.0) / one_minus_alpha
-    Y[y0:y1, x0:x1] = np.where(mask, np.clip(new_Y, 0, 255).astype(np.uint8), Y[y0:y1, x0:x1])
-    
-    # 2. Process U & V channels (Chroma, subsampled 2x2)
-    x0_sub, y0_sub = x0 // 2, y0 // 2
-    x1_sub, y1_sub = x1 // 2, y1 // 2
-    
-    scaled_alpha_sub = scaled_alpha[::2, ::2]
-    one_minus_alpha_sub = one_minus_alpha[::2, ::2]
-    mask_sub = mask[::2, ::2]
-    
-    # U Channel
-    U_roi = U[y0_sub:y1_sub, x0_sub:x1_sub].astype(np.float32)
-    new_U = (U_roi - 128.0) / one_minus_alpha_sub + 128.0
-    U[y0_sub:y1_sub, x0_sub:x1_sub] = np.where(mask_sub, np.clip(new_U, 0, 255).astype(np.uint8), U[y0_sub:y1_sub, x0_sub:x1_sub])
-    
-    # V Channel
-    V_roi = V[y0_sub:y1_sub, x0_sub:x1_sub].astype(np.float32)
-    new_V = (V_roi - 128.0) / one_minus_alpha_sub + 128.0
-    V[y0_sub:y1_sub, x0_sub:x1_sub] = np.where(mask_sub, np.clip(new_V, 0, 255).astype(np.uint8), V[y0_sub:y1_sub, x0_sub:x1_sub])
-    
-    return frame_arr.tobytes()
-
-
-def remove_watermark_video(input_path: str, output_path: str = None, 
-                            show_progress: bool = True) -> str:
-    """Remove watermark from a video file using ffmpeg YUV420p pipes.
-    
-    Args:
-        input_path: Path to input video file
-        output_path: Path for output video (default: adds _clean suffix)
-        show_progress: Show progress log
-    
-    Returns:
-        Path to cleaned video file
-    """
-    input_path = str(input_path)
-    if output_path is None:
-        base, ext = os.path.splitext(input_path)
-        output_path = f"{base}_clean{ext}"
-        
-    abs_input = os.path.abspath(input_path)
-    abs_output = os.path.abspath(output_path)
-    
-    # Get video info via ffprobe
-    probe = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", abs_input],
-        capture_output=True, text=True
-    )
-    info = json.loads(probe.stdout)
-    
-    video_stream = next(s for s in info["streams"] if s["codec_type"] == "video")
-    width = int(video_stream["width"])
-    height = int(video_stream["height"])
-    
-    # Parse fps
-    fps_str = video_stream.get("r_frame_rate", "24/1")
-    if "/" in fps_str:
-        num, den = fps_str.split("/")
-        fps = float(num) / float(den)
-    else:
-        fps = float(fps_str)
-        
-    duration = float(info.get("format", {}).get("duration", 0))
-    total_frames = int(duration * fps) if duration > 0 else 0
-    
-    log.info("🎬 Processing YUV video: %dx%d @ %.1f fps (%d frames)", width, height, fps, total_frames)
-    
-    config = detect_watermark_config(width, height, is_video=True)
-    
-    # Temp file for safe rewrite
-    temp_out = abs_output + ".tmp.mp4"
-    if os.path.exists(temp_out):
-        os.remove(temp_out)
-        
-    # Dynamic macOS Hardware Acceleration vs standard CPU fallback
-    if sys.platform == "darwin":
-        read_cmd = [
-            "ffmpeg", "-hwaccel", "videotoolbox", "-i", abs_input,
-            "-f", "rawvideo", "-pix_fmt", "yuv420p",
-            "-v", "quiet", "-"
-        ]
-        encoder_args = ["-c:v", "h264_videotoolbox", "-b:v", "4000k"]
-    else:
-        read_cmd = [
-            "ffmpeg", "-i", abs_input,
-            "-f", "rawvideo", "-pix_fmt", "yuv420p",
-            "-v", "quiet", "-"
-        ]
-        encoder_args = ["-c:v", "libx264", "-preset", "fast", "-crf", "18"]
-        
-    write_cmd = [
-        "ffmpeg", "-y",
-        "-f", "rawvideo", "-pix_fmt", "yuv420p",
-        "-s", f"{width}x{height}", "-r", str(fps_str),
-        "-i", "-",
-        "-i", abs_input,
-        "-map", "0:v", "-map", "1:a?",
-    ] + encoder_args + [
-        "-c:a", "copy",
-        "-movflags", "+faststart",
-        "-v", "quiet",
-        temp_out
-    ]
-    
-    reader = subprocess.Popen(read_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-    writer = subprocess.Popen(write_cmd, stdin=subprocess.PIPE, stderr=subprocess.DEVNULL)
-    
-    y_size = width * height
-    uv_size = (width // 2) * (height // 2)
-    frame_size = y_size + 2 * uv_size
-    frame_count = 0
-    
-    try:
-        while True:
-            raw = reader.stdout.read(frame_size)
-            if len(raw) < frame_size:
-                break
-                
-            clean_raw = remove_watermark_yuv_frame(raw, width, height, config)
-            writer.stdin.write(clean_raw)
-            
-            frame_count += 1
-            if show_progress and frame_count % 30 == 0:
-                pct = int(frame_count / total_frames * 100) if total_frames > 0 else 0
-                log.info("   Processing: %d%% (%d/%d frames)", pct, frame_count, total_frames)
-    finally:
-        writer.stdin.close()
-        writer.wait()
-        reader.wait()
-        
-    if os.path.exists(temp_out):
-        if os.path.exists(abs_output):
-            os.remove(abs_output)
-        os.rename(temp_out, abs_output)
-    else:
-        raise RuntimeError("Failed to compile clean watermark-free video")
-        
-    size_mb = os.path.getsize(abs_output) / (1024 * 1024)
-    log.info("✅ Watermark removed: %s (%.1f MB, %d frames)", abs_output, size_mb, frame_count)
-    return abs_output
-
-
-def remove_watermark_image(input_path: str, output_path: str = None) -> str:
-    """Remove watermark from a single image file.
-    
-    Args:
-        input_path: Path to input image
-        output_path: Path for output (default: adds _clean suffix)
-    
-    Returns:
-        Path to cleaned image
-    """
-    input_path = str(input_path)
-    if output_path is None:
-        base, ext = os.path.splitext(input_path)
-        output_path = f"{base}_clean{ext}"
-    
-    img = cv2.imread(input_path)
-    if img is None:
-        raise ValueError(f"Cannot read image: {input_path}")
-    
-    clean = remove_watermark_frame(img, is_video=False)
-    cv2.imwrite(output_path, clean)
-    
-    log.info("✅ Watermark removed: %s", output_path)
-    return output_path

flow-agent/requirements.txt

@@ -1,7 +1,4 @@
 websockets>=12.0
-opencv-python-headless>=4.8
-numpy>=1.24
 fastapi>=0.100.0
 uvicorn>=0.22.0
 python-multipart>=0.0.6
-

free-gemini-api/Dockerfile

@@ -8,14 +8,14 @@ RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o free-gemini-api .
 
 # Runtime stage
 FROM alpine:3.19
-RUN apk --no-cache add ca-certificates curl ffmpeg
+RUN apk --no-cache add ca-certificates curl
 WORKDIR /app
 COPY --from=builder /app/free-gemini-api .
 RUN mkdir -p /app/output
 
-EXPOSE 8000 9222
+EXPOSE 8000 9226
 
-ENV WS_PORT="9222" \
+ENV WS_PORT="9226" \
     PORT="8000"
 
 CMD ["./free-gemini-api"]

free-gemini-api/gemini-extension/background.js

@@ -3,7 +3,7 @@
  * Proactively keeps Google Gemini cookies fresh and auto-syncs them on change.
  */
 
-const LOCAL_WS_URL = 'ws://127.0.0.1:9222';
+const LOCAL_WS_URL = 'ws://127.0.0.1:9226';
 let ws = null;
 let lastSyncTime = null;
 let hasSyncedOnce = false;

free-gemini-api/gemini/client.go

@@ -1166,24 +1166,6 @@ func (c *GeminiClient) DownloadFile(urlStr, savePath string) error {
 			return fmt.Errorf("file too small (%d bytes), likely failed download", info.Size())
 		}
 
-		// Run watermark remover if file is image or video
-		ext := strings.ToLower(filepath.Ext(savePath))
-		var fileType string
-		if ext == ".png" || ext == ".jpg" || ext == ".jpeg" {
-			fileType = "image"
-		} else if ext == ".mp4" {
-			fileType = "video"
-		}
-
-		if fileType != "" {
-			log.Printf("🧹 Removing watermark from %s (%s) natively in Go...", savePath, fileType)
-			if err := RemoveWatermark(savePath, fileType); err != nil {
-				log.Printf("⚠️ Failed to remove watermark natively: %v", err)
-			} else {
-				log.Printf("✨ Watermark removed successfully natively in Go: %s", savePath)
-			}
-		}
-
 		return nil
 	}
 

free-gemini-api/gemini/watermark.go

@@ -1,424 +0,0 @@
-package gemini
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"image"
-	"image/color"
-	"image/draw"
-	"image/jpeg"
-	"image/png"
-	"io"
-	"log"
-	"math"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-// Constants for mathematical reverse alpha blending
-const (
-	alphaThreshold  = 0.002
-	maxAlpha        = 0.99
-	logoValue       = 255.0
-	videoAlphaScale = 0.6
-)
-
-// Embedded base64-encoded PNG assets for the 48px and 96px watermarks
-const (
-	bg48B64 = "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"
-	bg96B64 = "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"
-)
-
-// Global cache for decoded alpha maps
-var (
-	alphaCache48 []float32
-	alphaCache96 []float32
-)
-
-func init() {
-	// Pre-decode and cache the watermark grids
-	var err error
-	alphaCache48, err = loadAlphaMap(48)
-	if err != nil {
-		log.Printf("⚠️ Failed to load 48px alpha map: %v", err)
-	}
-	alphaCache96, err = loadAlphaMap(96)
-	if err != nil {
-		log.Printf("⚠️ Failed to load 96px alpha map: %v", err)
-	}
-}
-
-// loadAlphaMap decodes base64 PNGs and extracts the maximum RGB channel as alpha mapping
-func loadAlphaMap(size int) ([]float32, error) {
-	b64Str := bg48B64
-	if size == 96 {
-		b64Str = bg96B64
-	}
-
-	data, err := base64.StdEncoding.DecodeString(b64Str)
-	if err != nil {
-		return nil, err
-	}
-
-	img, _, err := image.Decode(bytes.NewReader(data))
-	if err != nil {
-		return nil, err
-	}
-
-	bounds := img.Bounds()
-	w, h := bounds.Dx(), bounds.Dy()
-
-	// Resize using simple nearest-neighbor if dimensions mismatch
-	alphaMap := make([]float32, size*size)
-	for y := 0; y < size; y++ {
-		srcY := int(float64(y) * float64(h) / float64(size))
-		for x := 0; x < size; x++ {
-			srcX := int(float64(x) * float64(w) / float64(size))
-			r, g, b, _ := img.At(bounds.Min.X+srcX, bounds.Min.Y+srcY).RGBA()
-
-			// Max of RGB, scale [0, 65535] down to [0.0, 1.0]
-			maxVal := r
-			if g > maxVal {
-				maxVal = g
-			}
-			if b > maxVal {
-				maxVal = b
-			}
-
-			alphaMap[y*size+x] = float32(maxVal) / 65535.0
-		}
-	}
-
-	return alphaMap, nil
-}
-
-// WatermarkConfig holds dimensions and offset coordinates
-type WatermarkConfig struct {
-	LogoSize int
-	X        int
-	Y        int
-}
-
-// DetectWatermarkConfig returns position configurations based on dimensions
-func DetectWatermarkConfig(width, height int, isVideo bool) WatermarkConfig {
-	var logoSize, marginRight, marginBottom int
-
-	if isVideo {
-		shortDim := width
-		if height < shortDim {
-			shortDim = height
-		}
-
-		if shortDim >= 1080 {
-			logoSize = 96
-			marginRight = 64
-			marginBottom = 64
-		} else {
-			logoSize = 48
-			marginRight = 72
-			marginBottom = 72
-		}
-	} else {
-		// Portrait standard matching
-		if width == 720 && height == 1280 {
-			logoSize = 48
-			marginRight = 72
-			marginBottom = 72
-		} else {
-			shortDim := width
-			if height < shortDim {
-				shortDim = height
-			}
-
-			if shortDim > 800 {
-				logoSize = 96
-				marginRight = 64
-				marginBottom = 64
-			} else {
-				logoSize = 48
-				marginRight = 32
-				marginBottom = 32
-			}
-		}
-	}
-
-	x := width - marginRight - logoSize
-	y := height - marginBottom - logoSize
-
-	return WatermarkConfig{
-		LogoSize: logoSize,
-		X:        x,
-		Y:        y,
-	}
-}
-
-// RemoveWatermark native hub. Dispatches based on file extensions.
-func RemoveWatermark(savePath string, fileType string) error {
-	ext := strings.ToLower(filepath.Ext(savePath))
-	if ext == ".png" || ext == ".jpg" || ext == ".jpeg" {
-		return removeWatermarkFromImage(savePath)
-	} else if ext == ".mp4" {
-		return removeWatermarkFromVideo(savePath)
-	}
-	return fmt.Errorf("unsupported watermark file type: %s", ext)
-}
-
-// removeWatermarkFromImage performs native Go reverse-alpha editing on static images
-func removeWatermarkFromImage(imagePath string) error {
-	file, err := os.Open(imagePath)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	img, format, err := image.Decode(file)
-	if err != nil {
-		return err
-	}
-	file.Close() // Close early for in-place write
-
-	bounds := img.Bounds()
-	width, height := bounds.Dx(), bounds.Dy()
-	config := DetectWatermarkConfig(width, height, false)
-
-	// Fetch cached alpha map
-	alphaMap := alphaCache48
-	if config.LogoSize == 96 {
-		alphaMap = alphaCache96
-	}
-	if len(alphaMap) == 0 {
-		return fmt.Errorf("alpha map cache for size %d is empty", config.LogoSize)
-	}
-
-	// Create writable canvas
-	canvas := image.NewRGBA(bounds)
-	draw.Draw(canvas, bounds, img, bounds.Min, draw.Src)
-
-	// Apply math formula on watermark region
-	for dy := 0; dy < config.LogoSize; dy++ {
-		py := config.Y + dy
-		if py < bounds.Min.Y || py >= bounds.Max.Y {
-			continue
-		}
-
-		for dx := 0; dx < config.LogoSize; dx++ {
-			px := config.X + dx
-			if px < bounds.Min.X || px >= bounds.Max.X {
-				continue
-			}
-
-			alpha := alphaMap[dy*config.LogoSize+dx]
-			if alpha < alphaThreshold {
-				continue
-			}
-
-			// Clamp alpha to avoid division by zero
-			if alpha > maxAlpha {
-				alpha = maxAlpha
-			}
-
-			r, g, b, a := canvas.At(px, py).RGBA()
-
-			// Scale down values to standard float32 [0.0, 255.0]
-			fR := float64(r) / 257.0
-			fG := float64(g) / 257.0
-			fB := float64(b) / 257.0
-
-			// Solve original = (watermarked - alpha * 255.0) / (1 - alpha)
-			oneMinusAlpha := 1.0 - float64(alpha)
-			newR := (fR - float64(alpha)*logoValue) / oneMinusAlpha
-			newG := (fG - float64(alpha)*logoValue) / oneMinusAlpha
-			newB := (fB - float64(alpha)*logoValue) / oneMinusAlpha
-
-			// Clamp to [0, 255]
-			cR := uint8(math.Min(math.Max(newR, 0), 255))
-			cG := uint8(math.Min(math.Max(newG, 0), 255))
-			cB := uint8(math.Min(math.Max(newB, 0), 255))
-			cA := uint8(a / 257)
-
-			canvas.SetRGBA(px, py, color.RGBA{R: cR, G: cG, B: cB, A: cA})
-		}
-	}
-
-	// Save back in-place
-	outFile, err := os.Create(imagePath)
-	if err != nil {
-		return err
-	}
-	defer outFile.Close()
-
-	if format == "png" {
-		return png.Encode(outFile, canvas)
-	}
-	return jpeg.Encode(outFile, canvas, &jpeg.Options{Quality: 95})
-}
-
-// VideoStreamInfo is mapped from ffprobe JSON output
-type VideoStreamInfo struct {
-	Streams []struct {
-		Width      int    `json:"width"`
-		Height     int    `json:"height"`
-		CodecType  string `json:"codec_type"`
-		RFrameRate string `json:"r_frame_rate"`
-	} `json:"streams"`
-}
-
-// removeWatermarkFromVideo runs native FFMPEG byte pipes for zero-Python video watermark removal
-func removeWatermarkFromVideo(videoPath string) error {
-	absPath, err := filepath.Abs(videoPath)
-	if err != nil {
-		return err
-	}
-
-	// 1. Get dimensions using ffprobe
-	probeCmd := exec.Command("ffprobe", "-v", "quiet", "-print_format", "json", "-show_streams", absPath)
-	probeOut, err := probeCmd.Output()
-	if err != nil {
-		return fmt.Errorf("ffprobe failed (is ffmpeg installed?): %w", err)
-	}
-
-	var info VideoStreamInfo
-	if err := json.Unmarshal(probeOut, &info); err != nil {
-		return fmt.Errorf("failed to parse ffprobe json: %w", err)
-	}
-
-	var width, height int
-	var fps string
-	for _, stream := range info.Streams {
-		if stream.CodecType == "video" {
-			width = stream.Width
-			height = stream.Height
-			fps = stream.RFrameRate
-			break
-		}
-	}
-
-	if width == 0 || height == 0 {
-		return fmt.Errorf("could not extract video dimensions for: %s", videoPath)
-	}
-
-	if fps == "" {
-		fps = "24"
-	}
-
-	config := DetectWatermarkConfig(width, height, true)
-	alphaMap := alphaCache48
-	if config.LogoSize == 96 {
-		alphaMap = alphaCache96
-	}
-
-	// Setup temp path for safe in-place rewrite
-	tempOut := absPath + ".tmp.mp4"
-	defer os.Remove(tempOut)
-
-	// FFMPEG Read command: Decode frames to raw BGR24 on stdout
-	readCmd := exec.Command("ffmpeg", "-i", absPath, "-f", "rawvideo", "-pix_fmt", "bgr24", "-v", "quiet", "-")
-	stdout, err := readCmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-
-	// FFMPEG Write command: Encode BGR24 frames back into H.264 mp4, copying audio from original
-	writeCmd := exec.Command("ffmpeg", "-y",
-		"-f", "rawvideo", "-pix_fmt", "bgr24",
-		"-s", fmt.Sprintf("%dx%d", width, height), "-r", fps,
-		"-i", "-",
-		"-i", absPath, // Re-read for audio mapping
-		"-map", "0:v", "-map", "1:a?",
-		"-c:v", "libx264", "-preset", "fast", "-crf", "18",
-		"-c:a", "copy",
-		"-movflags", "+faststart",
-		"-v", "quiet",
-		tempOut,
-	)
-
-	stdin, err := writeCmd.StdinPipe()
-	if err != nil {
-		return err
-	}
-
-	if err := readCmd.Start(); err != nil {
-		return fmt.Errorf("ffmpeg reader start failed: %w", err)
-	}
-	if err := writeCmd.Start(); err != nil {
-		return fmt.Errorf("ffmpeg writer start failed: %w", err)
-	}
-
-	frameSize := width * height * 3 // BGR24
-	frameBuf := make([]byte, frameSize)
-
-	for {
-		_, err := io.ReadFull(stdout, frameBuf)
-		if err == io.EOF || err == io.ErrUnexpectedEOF {
-			break
-		}
-		if err != nil {
-			break
-		}
-
-		// Apply watermark reverse blending directly in BGR24 byte slice
-		for dy := 0; dy < config.LogoSize; dy++ {
-			py := config.Y + dy
-			if py < 0 || py >= height {
-				continue
-			}
-
-			for dx := 0; dx < config.LogoSize; dx++ {
-				px := config.X + dx
-				if px < 0 || px >= width {
-					continue
-				}
-
-				alpha := alphaMap[dy*config.LogoSize+dx]
-				if alpha < alphaThreshold {
-					continue
-				}
-
-				// Scale down watermark intensity for videos
-				scaledAlpha := alpha * videoAlphaScale
-				if scaledAlpha > maxAlpha {
-					scaledAlpha = maxAlpha
-				}
-
-				// Offset inside raw BGR24 frame byte slice
-				pixelOffset := (py*width + px) * 3
-
-				b := frameBuf[pixelOffset]
-				g := frameBuf[pixelOffset+1]
-				r := frameBuf[pixelOffset+2]
-
-				// Solve original = (watermarked - alpha * 255.0) / (1 - alpha)
-				oneMinusAlpha := 1.0 - float64(scaledAlpha)
-
-				newB := (float64(b) - float64(scaledAlpha)*logoValue) / oneMinusAlpha
-				newG := (float64(g) - float64(scaledAlpha)*logoValue) / oneMinusAlpha
-				newR := (float64(r) - float64(scaledAlpha)*logoValue) / oneMinusAlpha
-
-				// Set BGR byte values, clamped to [0, 255]
-				frameBuf[pixelOffset] = byte(math.Min(math.Max(newB, 0), 255))
-				frameBuf[pixelOffset+1] = byte(math.Min(math.Max(newG, 0), 255))
-				frameBuf[pixelOffset+2] = byte(math.Min(math.Max(newR, 0), 255))
-			}
-		}
-
-		// Write modified frame to encoder stdin pipe
-		if _, err := stdin.Write(frameBuf); err != nil {
-			break
-		}
-	}
-
-	stdin.Close()
-	writeCmd.Wait()
-	readCmd.Wait()
-
-	// Replace original video with clean copy
-	if _, err := os.Stat(tempOut); err == nil {
-		return os.Rename(tempOut, absPath)
-	}
-
-	return fmt.Errorf("failed to compile clean watermark-free video")
-}

monitor/go.mod

@@ -0,0 +1,5 @@
+module monitor
+
+go 1.22
+
+require github.com/gorilla/websocket v1.5.3

monitor/go.sum

@@ -0,0 +1,2 @@
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

monitor/index.html

@@ -0,0 +1,261 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Chrome Navigator — GPT · Gemini · Flow</title>
+    <style>
+        :root { --accent: #007acc; }
+        * { box-sizing: border-box; }
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: #1e1e1e; color: #d4d4d4; margin: 0; padding: 16px;
+            display: flex; flex-direction: column; align-items: center; min-height: 100vh;
+        }
+        .dashboard { display: flex; flex-wrap: wrap; gap: 10px; margin-bottom: 12px; justify-content: center; }
+        .card { background: #252526; border-radius: 8px; padding: 8px 15px; display: flex; align-items: center; gap: 12px; box-shadow: 0 4px 6px rgba(0,0,0,.3); }
+        .card-header { font-size: .72rem; color: #888; text-transform: uppercase; }
+        .card-value { font-size: 1.1rem; font-weight: 600; color: #fff; }
+        .progress-bg { background: #333; height: 6px; border-radius: 3px; overflow: hidden; width: 60px; }
+        .progress-fill { background: var(--accent); height: 100%; width: 0%; transition: width .5s ease; }
+
+        .tabs { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 10px; justify-content: center; max-width: 95vw; }
+        .tab-btn {
+            background: #252526; color: #d4d4d4; border: 1px solid #333; border-radius: 8px;
+            padding: 7px 10px 7px 14px; font-size: .9rem; font-weight: 600; cursor: pointer;
+            transition: all .15s; display: inline-flex; align-items: center; gap: 8px; max-width: 220px;
+        }
+        .tab-btn:hover { border-color: var(--accent); }
+        .tab-btn.active { background: var(--accent); color: #fff; border-color: var(--accent); box-shadow: 0 0 14px rgba(0,122,204,.55); }
+        .tab-label { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+        .tab-close {
+            border: none; background: transparent; color: inherit; opacity: .6;
+            font-size: 1rem; line-height: 1; cursor: pointer; padding: 0 2px; border-radius: 4px;
+        }
+        .tab-close:hover { opacity: 1; background: rgba(255,255,255,.15); }
+        .tab-new { font-weight: 700; padding: 7px 13px; }
+
+        .navbar { display: flex; gap: 6px; margin-bottom: 12px; width: min(95vw, 900px); }
+        .nav-btn {
+            background: #252526; color: #d4d4d4; border: 1px solid #333; border-radius: 8px;
+            width: 38px; min-width: 38px; font-size: 1rem; cursor: pointer; transition: all .15s;
+        }
+        .nav-btn:hover { border-color: var(--accent); color: #fff; }
+        #address {
+            flex: 1; background: #1b1b1b; color: #e8e8e8; border: 1px solid #333; border-radius: 8px;
+            padding: 8px 12px; font-size: .9rem; font-family: ui-monospace, Menlo, Consolas, monospace;
+        }
+        #address:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 10px rgba(0,122,204,.4); }
+        .nav-go { width: auto; padding: 0 16px; font-weight: 600; }
+
+        #screen-container {
+            border: 2px solid var(--accent); box-shadow: 0 0 20px rgba(0,122,204,.5);
+            background: #000; border-radius: 8px; overflow: hidden; line-height: 0; position: relative;
+        }
+        img { max-width: 95vw; max-height: 72vh; width: auto; height: auto; display: block; }
+        #hint { color: #777; font-size: .75rem; margin-top: 8px; }
+    </style>
+</head>
+
+<body>
+    <div class="dashboard">
+        <div class="card"><div class="card-header">Memory</div>
+            <div style="display:flex;align-items:center;gap:10px">
+                <div class="card-value" id="memVal">...</div>
+                <div class="progress-bg"><div class="progress-fill" id="memBar"></div></div>
+            </div>
+        </div>
+        <div class="card"><div class="card-header">CPU Load</div><div class="card-value" id="cpuVal">...</div></div>
+        <div class="card"><div class="card-header">Uptime</div><div class="card-value" id="uptimeVal">...</div></div>
+    </div>
+
+    <div class="tabs" id="tabs"></div>
+
+    <div class="navbar">
+        <button class="nav-btn" id="backBtn" title="Back">←</button>
+        <button class="nav-btn" id="fwdBtn" title="Forward">→</button>
+        <button class="nav-btn" id="reloadBtn" title="Reload">⟳</button>
+        <input id="address" type="text" placeholder="Enter URL and press Enter…" spellcheck="false" autocomplete="off" />
+        <button class="nav-btn nav-go" id="goBtn">Go</button>
+    </div>
+
+    <div id="screen-container">
+        <img id="monitor" alt="Live Stream" />
+    </div>
+    <div id="hint">Click and type directly on the page · use the bar above to navigate the active tab anywhere.</div>
+
+    <script>
+        let activeTab = null;       // active CDP target id
+        let tabList = [];           // last /api/tabs payload
+        const img = document.getElementById('monitor');
+        const tabsEl = document.getElementById('tabs');
+        const address = document.getElementById('address');
+
+        const urlOf = id => (tabList.find(t => t.id === id) || {}).url || '';
+
+        // Build the tab strip from the server's live target list.
+        async function buildTabs() {
+            try {
+                const res = await fetch('/api/tabs');
+                tabList = await res.json();
+                if (!tabList.length) { tabsEl.innerHTML = ''; return; }
+                if (!tabList.some(t => t.id === activeTab)) activeTab = tabList[0].id;
+
+                tabsEl.innerHTML = '';
+                tabList.forEach(t => {
+                    const b = document.createElement('button');
+                    b.className = 'tab-btn' + (t.id === activeTab ? ' active' : '');
+                    b.dataset.key = t.id;
+                    b.title = t.url;
+
+                    const label = document.createElement('span');
+                    label.className = 'tab-label';
+                    label.textContent = t.title;
+                    b.appendChild(label);
+
+                    const x = document.createElement('button');
+                    x.className = 'tab-close';
+                    x.textContent = '×';
+                    x.title = 'Close tab';
+                    x.onclick = e => { e.stopPropagation(); closeTab(t.id); };
+                    b.appendChild(x);
+
+                    b.onclick = () => switchTab(t.id);
+                    tabsEl.appendChild(b);
+                });
+
+                // "+ new" button
+                const plus = document.createElement('button');
+                plus.className = 'tab-btn tab-new';
+                plus.textContent = '+';
+                plus.title = 'New tab';
+                plus.onclick = newTab;
+                tabsEl.appendChild(plus);
+
+                syncAddress();
+            } catch (e) { console.error(e); }
+        }
+
+        function syncAddress() {
+            if (document.activeElement !== address) address.value = urlOf(activeTab);
+        }
+
+        function switchTab(id) {
+            activeTab = id;
+            document.querySelectorAll('.tab-btn').forEach(b =>
+                b.classList.toggle('active', b.dataset.key === id));
+            syncAddress();
+            refreshImage();
+        }
+
+        async function post(path) {
+            try { await fetch(path, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' }); }
+            catch (e) { console.error(e); }
+        }
+
+        async function navigate() {
+            const url = address.value.trim();
+            if (!url || !activeTab) return;
+            try {
+                await fetch('/api/navigate?tab=' + activeTab, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url })
+                });
+                address.blur();
+                setTimeout(() => { buildTabs(); refreshImage(); }, 600);
+            } catch (e) { console.error(e); }
+        }
+
+        async function reload() { await post('/api/reload?tab=' + activeTab); setTimeout(refreshImage, 500); }
+        async function goBack() { await post('/api/back?tab=' + activeTab); setTimeout(() => { buildTabs(); refreshImage(); }, 500); }
+        async function goForward() { await post('/api/forward?tab=' + activeTab); setTimeout(() => { buildTabs(); refreshImage(); }, 500); }
+
+        async function newTab() {
+            const url = prompt('Open URL in a new tab:', 'https://');
+            if (url === null) return;
+            try {
+                const res = await fetch('/api/newtab', {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url: url.trim() })
+                });
+                const { id } = await res.json();
+                if (id) activeTab = id;
+                await buildTabs();
+                refreshImage();
+            } catch (e) { console.error(e); }
+        }
+
+        async function closeTab(id) {
+            try {
+                await fetch('/api/closetab?tab=' + id, { method: 'POST' });
+                if (id === activeTab) activeTab = null;
+                await buildTabs();
+                refreshImage();
+            } catch (e) { console.error(e); }
+        }
+
+        document.getElementById('goBtn').onclick = navigate;
+        document.getElementById('reloadBtn').onclick = reload;
+        document.getElementById('backBtn').onclick = goBack;
+        document.getElementById('fwdBtn').onclick = goForward;
+        address.addEventListener('keydown', e => { if (e.key === 'Enter') { e.preventDefault(); navigate(); } });
+
+        async function sendInput(data) {
+            if (!activeTab) return;
+            try {
+                await fetch('/api/input?tab=' + activeTab, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data)
+                });
+                setTimeout(refreshImage, 120);
+            } catch (e) { console.error(e); }
+        }
+
+        function coords(e) {
+            const rect = img.getBoundingClientRect();
+            return {
+                x: Math.round((e.clientX - rect.left) * (img.naturalWidth / rect.width)),
+                y: Math.round((e.clientY - rect.top) * (img.naturalHeight / rect.height))
+            };
+        }
+        img.addEventListener('mousedown', e => sendInput({ type: 'mousedown', ...coords(e), button: 'left' }));
+        img.addEventListener('mouseup', e => sendInput({ type: 'mouseup', ...coords(e), button: 'left' }));
+
+        document.addEventListener('keydown', e => {
+            if (document.activeElement === address) return;   // typing in the URL bar
+            if (e.key === 'r' && (e.metaKey || e.ctrlKey)) return;
+            if (e.key.length === 1) sendInput({ type: 'keydown', text: e.key });
+            else if (e.key === 'Enter') sendInput({ type: 'keydown', text: '\r' });
+            else if (e.key === 'Backspace') sendInput({ type: 'keydown', text: '\b' });
+        });
+
+        function refreshImage() {
+            if (!activeTab) return;
+            const src = `/api/screen?tab=${activeTab}&t=${Date.now()}`;
+            const tmp = new Image();
+            tmp.onload = () => { img.src = src; };
+            tmp.src = src;
+        }
+        setInterval(refreshImage, 1000);
+        setInterval(buildTabs, 5000);   // pick up new/closed tabs and url changes
+
+        async function updateStats() {
+            try {
+                const d = await (await fetch('/api/stats')).json();
+                document.getElementById('memVal').innerText = `${d.memUsedGB}/${d.memTotalGB}GB`;
+                document.getElementById('memBar').style.width = `${d.memPct}%`;
+                document.getElementById('cpuVal').innerText = `${Math.round(d.cpu)}%`;
+                const h = Math.floor(d.uptime / 3600), m = Math.floor((d.uptime % 3600) / 60);
+                document.getElementById('uptimeVal').innerText = `${h}h ${m}m`;
+            } catch (e) { console.error(e); }
+        }
+        setInterval(updateStats, 2000);
+
+        buildTabs().then(refreshImage);
+        updateStats();
+    </script>
+</body>
+
+</html>

monitor/main.go

@@ -0,0 +1,543 @@
+// Chrome live monitor with a built-in navigator.
+//
+// Talks to Chrome's DevTools Protocol on 127.0.0.1:9222 and serves a browser-like
+// UI on :3001:
+//   - a live tab strip listing every open Chrome page (known AI services first),
+//   - an address bar + back / forward / reload to drive the active tab anywhere,
+//   - new-tab / close-tab buttons,
+//   - click + type forwarded straight into the active page.
+// The active tab is brought to front before every screenshot so background tabs
+// still render. Tabs are keyed by their live CDP target id (not hardcoded).
+package main
+
+import (
+	_ "embed"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+const cdpBase = "http://127.0.0.1:9222"
+
+//go:embed index.html
+var indexHTML []byte
+
+// knownTab is one of the AI services we pre-open and label nicely.
+type knownTab struct {
+	Title string
+	URL   string // page to open on startup
+	Match string // substring used to find an already-open page target
+}
+
+var knownTabs = []knownTab{
+	{"ChatGPT", "https://chatgpt.com/", "chatgpt.com"},
+	{"Gemini", "https://gemini.google.com/", "gemini.google.com"},
+	{"Flow", "https://labs.google/fx/tools/flow", "labs.google"},
+}
+
+// cdpTarget mirrors the relevant fields of an entry from GET /json.
+type cdpTarget struct {
+	ID    string `json:"id"`
+	Type  string `json:"type"`
+	URL   string `json:"url"`
+	Title string `json:"title"`
+	WS    string `json:"webSocketDebuggerUrl"`
+}
+
+// tabInfo is what the UI consumes from /api/tabs.
+type tabInfo struct {
+	ID    string `json:"id"`
+	Title string `json:"title"`
+	URL   string `json:"url"`
+}
+
+// cdpConn is a serialized request/response wrapper around one DevTools websocket.
+type cdpConn struct {
+	c  *websocket.Conn
+	mu sync.Mutex
+	id int
+}
+
+func (cc *cdpConn) call(method string, params map[string]any) (json.RawMessage, error) {
+	cc.mu.Lock()
+	defer cc.mu.Unlock()
+	cc.id++
+	myID := cc.id
+	if err := cc.c.WriteJSON(map[string]any{"id": myID, "method": method, "params": params}); err != nil {
+		return nil, err
+	}
+	cc.c.SetReadDeadline(time.Now().Add(15 * time.Second))
+	for {
+		_, data, err := cc.c.ReadMessage()
+		if err != nil {
+			return nil, err
+		}
+		var m struct {
+			ID     int             `json:"id"`
+			Result json.RawMessage `json:"result"`
+			Error  *struct {
+				Message string `json:"message"`
+			} `json:"error"`
+		}
+		if json.Unmarshal(data, &m) != nil {
+			continue
+		}
+		if m.ID == myID { // ignore CDP events (no matching id)
+			if m.Error != nil {
+				return nil, fmt.Errorf("cdp %s: %s", method, m.Error.Message)
+			}
+			return m.Result, nil
+		}
+	}
+}
+
+// connections, one persistent websocket per target id.
+var (
+	conns  = map[string]*cdpConn{}
+	connMu sync.Mutex
+)
+
+func httpGetJSON(url string, out any) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return json.NewDecoder(resp.Body).Decode(out)
+}
+
+func listTargets() ([]cdpTarget, error) {
+	var t []cdpTarget
+	err := httpGetJSON(cdpBase+"/json", &t)
+	return t, err
+}
+
+// pageTargets returns the open page targets, known services first then the rest.
+func pageTargets() ([]cdpTarget, error) {
+	targets, err := listTargets()
+	if err != nil {
+		return nil, err
+	}
+	var pages []cdpTarget
+	for _, t := range targets {
+		if t.Type != "page" || strings.HasPrefix(t.URL, "devtools://") {
+			continue
+		}
+		pages = append(pages, t)
+	}
+	rank := func(t cdpTarget) int {
+		for i, k := range knownTabs {
+			if strings.Contains(t.URL, k.Match) {
+				return i
+			}
+		}
+		return len(knownTabs) + 1
+	}
+	sort.SliceStable(pages, func(i, j int) bool { return rank(pages[i]) < rank(pages[j]) })
+	return pages, nil
+}
+
+// friendlyTitle prefers a known service label, then the page title, then the URL.
+func friendlyTitle(t cdpTarget) string {
+	for _, k := range knownTabs {
+		if strings.Contains(t.URL, k.Match) {
+			return k.Title
+		}
+	}
+	if t.URL == "" || t.URL == "about:blank" {
+		return "New Tab"
+	}
+	if strings.TrimSpace(t.Title) != "" {
+		return t.Title
+	}
+	return t.URL
+}
+
+// browserWS returns the browser-level websocket URL (for Target.* calls).
+func browserWS() (string, error) {
+	var v struct {
+		WS string `json:"webSocketDebuggerUrl"`
+	}
+	if err := httpGetJSON(cdpBase+"/json/version", &v); err != nil {
+		return "", err
+	}
+	return v.WS, nil
+}
+
+func dial(ws string) (*cdpConn, error) {
+	c, _, err := websocket.DefaultDialer.Dial(ws, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &cdpConn{c: c}, nil
+}
+
+// browserCall runs a single browser-level command (createTarget / closeTarget).
+func browserCall(method string, params map[string]any) (json.RawMessage, error) {
+	bws, err := browserWS()
+	if err != nil {
+		return nil, err
+	}
+	bc, err := dial(bws)
+	if err != nil {
+		return nil, err
+	}
+	defer bc.c.Close()
+	return bc.call(method, params)
+}
+
+// targetWSByID looks up a page target's websocket URL by its id.
+func targetWSByID(id string) (string, error) {
+	targets, err := listTargets()
+	if err != nil {
+		return "", err
+	}
+	for _, t := range targets {
+		if t.ID == id {
+			return t.WS, nil
+		}
+	}
+	return "", fmt.Errorf("no target %q", id)
+}
+
+// ensureKnown finds an already-open page for a known service, creating it if absent.
+func ensureKnown(k knownTab) error {
+	targets, err := listTargets()
+	if err != nil {
+		return err
+	}
+	for _, tg := range targets {
+		if tg.Type == "page" && strings.Contains(tg.URL, k.Match) {
+			return nil
+		}
+	}
+	_, err = browserCall("Target.createTarget", map[string]any{"url": k.URL})
+	return err
+}
+
+// conn returns a live cdpConn for the given target id, (re)dialing as needed.
+func conn(id string) (*cdpConn, error) {
+	connMu.Lock()
+	defer connMu.Unlock()
+	if cc, ok := conns[id]; ok {
+		if _, err := cc.call("Target.getTargetInfo", nil); err == nil { // cheap liveness probe
+			return cc, nil
+		}
+		cc.c.Close()
+		delete(conns, id)
+	}
+	ws, err := targetWSByID(id)
+	if err != nil {
+		return nil, err
+	}
+	cc, err := dial(ws)
+	if err != nil {
+		return nil, err
+	}
+	conns[id] = cc
+	return cc, nil
+}
+
+// connForReq resolves the ?tab= target, writing an error response on failure.
+func connForReq(w http.ResponseWriter, r *http.Request) (*cdpConn, bool) {
+	id := r.URL.Query().Get("tab")
+	if id == "" {
+		http.Error(w, "missing tab", http.StatusBadRequest)
+		return nil, false
+	}
+	cc, err := conn(id)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return nil, false
+	}
+	return cc, true
+}
+
+func screenHandler(w http.ResponseWriter, r *http.Request) {
+	cc, ok := connForReq(w, r)
+	if !ok {
+		return
+	}
+	cc.call("Page.bringToFront", nil) // ensure background tab renders
+	res, err := cc.call("Page.captureScreenshot", map[string]any{"format": "png"})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	var out struct {
+		Data string `json:"data"`
+	}
+	if json.Unmarshal(res, &out) != nil || out.Data == "" {
+		http.Error(w, "no screenshot", http.StatusBadGateway)
+		return
+	}
+	png, err := base64.StdEncoding.DecodeString(out.Data)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	w.Header().Set("Content-Type", "image/png")
+	w.Header().Set("Cache-Control", "no-store")
+	w.Write(png)
+}
+
+func inputHandler(w http.ResponseWriter, r *http.Request) {
+	var in struct {
+		Type   string  `json:"type"`
+		X      float64 `json:"x"`
+		Y      float64 `json:"y"`
+		Button string  `json:"button"`
+		Text   string  `json:"text"`
+	}
+	if json.NewDecoder(r.Body).Decode(&in) != nil {
+		http.Error(w, "bad json", http.StatusBadRequest)
+		return
+	}
+	cc, ok := connForReq(w, r)
+	if !ok {
+		return
+	}
+	switch in.Type {
+	case "mousedown", "mouseup":
+		mt := "mousePressed"
+		if in.Type == "mouseup" {
+			mt = "mouseReleased"
+		}
+		btn := in.Button
+		if btn == "" {
+			btn = "left"
+		}
+		cc.call("Input.dispatchMouseEvent", map[string]any{
+			"type": mt, "x": in.X, "y": in.Y, "button": btn, "clickCount": 1,
+		})
+	case "keydown":
+		if in.Text == "\r" || in.Text == "\n" {
+			cc.call("Input.dispatchKeyEvent", map[string]any{
+				"type": "keyDown", "key": "Enter", "windowsVirtualKeyCode": 13, "text": "\r",
+			})
+			cc.call("Input.dispatchKeyEvent", map[string]any{"type": "keyUp", "key": "Enter", "windowsVirtualKeyCode": 13})
+		} else if in.Text == "\b" {
+			cc.call("Input.dispatchKeyEvent", map[string]any{"type": "keyDown", "key": "Backspace", "windowsVirtualKeyCode": 8})
+			cc.call("Input.dispatchKeyEvent", map[string]any{"type": "keyUp", "key": "Backspace", "windowsVirtualKeyCode": 8})
+		} else if in.Text != "" {
+			cc.call("Input.insertText", map[string]any{"text": in.Text})
+		}
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// normalizeURL prepends https:// when the user typed a bare host.
+func normalizeURL(u string) string {
+	u = strings.TrimSpace(u)
+	if u == "" {
+		return ""
+	}
+	if !strings.Contains(u, "://") {
+		u = "https://" + u
+	}
+	return u
+}
+
+func navigateHandler(w http.ResponseWriter, r *http.Request) {
+	var in struct {
+		URL string `json:"url"`
+	}
+	if json.NewDecoder(r.Body).Decode(&in) != nil {
+		http.Error(w, "bad json", http.StatusBadRequest)
+		return
+	}
+	url := normalizeURL(in.URL)
+	if url == "" {
+		http.Error(w, "empty url", http.StatusBadRequest)
+		return
+	}
+	cc, ok := connForReq(w, r)
+	if !ok {
+		return
+	}
+	if _, err := cc.call("Page.navigate", map[string]any{"url": url}); err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func reloadHandler(w http.ResponseWriter, r *http.Request) {
+	cc, ok := connForReq(w, r)
+	if !ok {
+		return
+	}
+	cc.call("Page.reload", nil)
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// historyStep moves the active tab back (delta -1) or forward (delta +1).
+func historyStep(cc *cdpConn, delta int) error {
+	res, err := cc.call("Page.getNavigationHistory", nil)
+	if err != nil {
+		return err
+	}
+	var h struct {
+		CurrentIndex int `json:"currentIndex"`
+		Entries      []struct {
+			ID int `json:"id"`
+		} `json:"entries"`
+	}
+	if err := json.Unmarshal(res, &h); err != nil {
+		return err
+	}
+	target := h.CurrentIndex + delta
+	if target < 0 || target >= len(h.Entries) {
+		return nil // nothing to do at the ends
+	}
+	_, err = cc.call("Page.navigateToHistoryEntry", map[string]any{"entryId": h.Entries[target].ID})
+	return err
+}
+
+func historyHandler(delta int) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cc, ok := connForReq(w, r)
+		if !ok {
+			return
+		}
+		if err := historyStep(cc, delta); err != nil {
+			http.Error(w, err.Error(), http.StatusBadGateway)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	}
+}
+
+func newtabHandler(w http.ResponseWriter, r *http.Request) {
+	var in struct {
+		URL string `json:"url"`
+	}
+	json.NewDecoder(r.Body).Decode(&in)
+	url := normalizeURL(in.URL)
+	if url == "" {
+		url = "about:blank"
+	}
+	res, err := browserCall("Target.createTarget", map[string]any{"url": url})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	var out struct {
+		TargetID string `json:"targetId"`
+	}
+	json.Unmarshal(res, &out)
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]string{"id": out.TargetID})
+}
+
+func closetabHandler(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("tab")
+	if id == "" {
+		http.Error(w, "missing tab", http.StatusBadRequest)
+		return
+	}
+	if _, err := browserCall("Target.closeTarget", map[string]any{"targetId": id}); err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	connMu.Lock()
+	if cc, ok := conns[id]; ok {
+		cc.c.Close()
+		delete(conns, id)
+	}
+	connMu.Unlock()
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func tabsHandler(w http.ResponseWriter, r *http.Request) {
+	pages, err := pageTargets()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadGateway)
+		return
+	}
+	out := make([]tabInfo, 0, len(pages))
+	for _, t := range pages {
+		out = append(out, tabInfo{ID: t.ID, Title: friendlyTitle(t), URL: t.URL})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(out)
+}
+
+func chromeLogHandler(w http.ResponseWriter, r *http.Request) {
+	f, err := os.Open("/home/chrome/chrome.log")
+	if err != nil {
+		http.Error(w, "no log", http.StatusNotFound)
+		return
+	}
+	defer f.Close()
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+	io.Copy(w, f)
+}
+
+func statsHandler(w http.ResponseWriter, r *http.Request) {
+	mem := readMeminfo()
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{
+		"memUsedGB":  mem.usedGB,
+		"memTotalGB": mem.totalGB,
+		"memPct":     mem.pct,
+		"cpu":        readCPUPercent(),
+		"uptime":     readUptime(),
+	})
+}
+
+func main() {
+	// Pre-open the known AI services in the background so they're ready by first view.
+	go func() {
+		for i := 0; i < 60; i++ {
+			ok := true
+			for _, k := range knownTabs {
+				if err := ensureKnown(k); err != nil {
+					ok = false
+				}
+			}
+			if ok {
+				log.Println("all known tabs ready")
+				return
+			}
+			time.Sleep(2 * time.Second)
+		}
+	}()
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/" {
+			http.NotFound(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		w.Write(indexHTML)
+	})
+	http.HandleFunc("/api/tabs", tabsHandler)
+	http.HandleFunc("/api/screen", screenHandler)
+	http.HandleFunc("/api/input", inputHandler)
+	http.HandleFunc("/api/navigate", navigateHandler)
+	http.HandleFunc("/api/reload", reloadHandler)
+	http.HandleFunc("/api/back", historyHandler(-1))
+	http.HandleFunc("/api/forward", historyHandler(+1))
+	http.HandleFunc("/api/newtab", newtabHandler)
+	http.HandleFunc("/api/closetab", closetabHandler)
+	http.HandleFunc("/api/stats", statsHandler)
+	http.HandleFunc("/chrome.log", chromeLogHandler)
+
+	addr := ":3001"
+	if p := os.Getenv("MONITOR_PORT"); p != "" {
+		addr = ":" + p
+	}
+	log.Printf("navigator monitor listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, nil))
+}

monitor/stats.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"bufio"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type memInfo struct {
+	usedGB  float64
+	totalGB float64
+	pct     float64
+}
+
+func readMeminfo() memInfo {
+	f, err := os.Open("/proc/meminfo")
+	if err != nil {
+		return memInfo{}
+	}
+	defer f.Close()
+	var totalKB, availKB float64
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		fields := strings.Fields(sc.Text())
+		if len(fields) < 2 {
+			continue
+		}
+		v, _ := strconv.ParseFloat(fields[1], 64)
+		switch fields[0] {
+		case "MemTotal:":
+			totalKB = v
+		case "MemAvailable:":
+			availKB = v
+		}
+	}
+	if totalKB == 0 {
+		return memInfo{}
+	}
+	usedKB := totalKB - availKB
+	return memInfo{
+		usedGB:  round1(usedKB / 1024 / 1024),
+		totalGB: round1(totalKB / 1024 / 1024),
+		pct:     round1(usedKB / totalKB * 100),
+	}
+}
+
+func round1(f float64) float64 {
+	return float64(int(f*10+0.5)) / 10
+}
+
+// readCPUPercent samples /proc/stat over a short window.
+func readCPUPercent() float64 {
+	idle1, total1 := cpuSample()
+	time.Sleep(200 * time.Millisecond)
+	idle2, total2 := cpuSample()
+	dt := total2 - total1
+	if dt == 0 {
+		return 0
+	}
+	return round1((1 - (idle2-idle1)/dt) * 100)
+}
+
+func cpuSample() (idle, total float64) {
+	f, err := os.Open("/proc/stat")
+	if err != nil {
+		return 0, 0
+	}
+	defer f.Close()
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		fields := strings.Fields(sc.Text())
+		if len(fields) > 0 && fields[0] == "cpu" {
+			for i, v := range fields[1:] {
+				n, _ := strconv.ParseFloat(v, 64)
+				total += n
+				if i == 3 { // idle
+					idle = n
+				}
+			}
+			return idle, total
+		}
+	}
+	return 0, 0
+}
+
+func readUptime() int {
+	b, err := os.ReadFile("/proc/uptime")
+	if err != nil {
+		return 0
+	}
+	fields := strings.Fields(string(b))
+	if len(fields) == 0 {
+		return 0
+	}
+	v, _ := strconv.ParseFloat(fields[0], 64)
+	return int(v)
+}

start_hf.sh

@@ -85,94 +85,15 @@ with open(pref_path, 'w') as f:
 
 
 # 5. Start Go Monitor Server
-echo "🚀 Starting Go Monitor Server..."
+echo "🚀 Starting 3-tab Monitor Server..."
 touch /home/chrome/chrome.log
-ln -sf /home/chrome/chrome.log /opt/monitor-server/public/chrome.log
-cd /opt/monitor-server
-./monitor-server > /home/chrome/monitor.log 2>&1 &
+/opt/monitor3/monitor > /home/chrome/monitor.log 2>&1 &
 
 # 6. Start CDP Proxy
 echo "🔌 Starting CDP Proxy..."
 socat TCP-LISTEN:9223,fork,bind=0.0.0.0 TCP:127.0.0.1:9222 &
 
-# 7. Start Auto-Navigation to chrome://extensions/ in background
-cat << 'EOF' > /tmp/navigate.py
-import urllib.request
-import json
-import socket
-import urllib.parse
-import time
-
-# Wait for Chrome to start and expose a page target
-page_target = None
-for _ in range(30):
-    try:
-        res = urllib.request.urlopen("http://127.0.0.1:9222/json")
-        targets = json.loads(res.read().decode())
-        pages = [t for t in targets if t["type"] == "page"]
-        if pages:
-            page_target = pages[0]
-            break
-    except:
-        pass
-    time.sleep(1)
-
-if not page_target:
-    print("Failed to get targets: No active page found")
-    exit(1)
-
-ws_url = page_target['webSocketDebuggerUrl']
-
-parsed = urllib.parse.urlparse(ws_url)
-host = '127.0.0.1'
-port = parsed.port or 9222
-path = parsed.path
-
-s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-s.connect((host, port))
-
-handshake = (
-    f"GET {path} HTTP/1.1\r\n"
-    f"Host: {host}:{port}\r\n"
-    "Upgrade: websocket\r\n"
-    "Connection: Upgrade\r\n"
-    "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
-    "Sec-WebSocket-Version: 13\r\n\r\n"
-)
-s.sendall(handshake.encode())
-resp = s.recv(1024)
-
-payload = json.dumps({
-    "id": 1,
-    "method": "Page.navigate",
-    "params": {"url": "chrome://extensions/"}
-})
-
-payload_bytes = payload.encode()
-length = len(payload_bytes)
-
-frame = bytearray([0x81])
-if length <= 125:
-    frame.append(length | 0x80)
-elif length <= 65535:
-    frame.append(126 | 0x80)
-    frame.extend(length.to_bytes(2, byteorder='big'))
-else:
-    frame.append(127 | 0x80)
-    frame.extend(length.to_bytes(8, byteorder='big'))
-
-mask_key = b'\x11\x22\x33\x44'
-frame.extend(mask_key)
-masked_payload = bytearray(b ^ mask_key[i % 4] for i, b in enumerate(payload_bytes))
-frame.extend(masked_payload)
-
-s.sendall(frame)
-s.close()
-print("Successfully navigated to chrome://extensions/")
-EOF
-python3 -u /tmp/navigate.py >> /home/chrome/chrome.log 2>&1 &
-
-# 8. Launch Chrome Headless
+# 7. Launch Chrome Headless
 echo "✨ Launching Chrome Headless..."
 /opt/chrome-linux64/chrome \
   --headless=new \
@@ -232,4 +153,4 @@ echo "✨ Launching Chrome Headless..."
   --disable-site-isolation-trials \
   --js-flags="--max-old-space-size=256" \
   --metrics-recording-only \
-  'chrome://extensions/' >> /home/chrome/chrome.log 2>&1
+  'about:blank' >> /home/chrome/chrome.log 2>&1