给 Agent 一台专用浏览器：独立 user-data-dir + CDP 常驻实例，绕开真实 profile 的独占锁

@echo off
REM ===========================================================================
REM  Hermes dedicated automation browser (silent, always-on)
REM  Used by Hermes browser.cdp_url -- fully isolated from your daily Brave.
REM  profile : %LOCALAPPDATA%\hermes\chrome-debug
REM  CDP port: 127.0.0.1:9222
REM
REM  To log in to a site: launch brave.exe with the SAME --user-data-dir but
REM  WITHOUT --no-startup-window -- that forwards into this instance and opens
REM  a window. Log in, close the window; the instance stays up, logged in.
REM  To stop: kill brave.exe processes whose command line mentions chrome-debug.
REM
REM  NOTE: keep this file ASCII-only. cmd.exe reads .cmd in the OEM codepage
REM        (cp936 here), so UTF-8 CJK comments get mangled into stray commands.
REM ===========================================================================
setlocal
set "EXE=C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"
set "UD=%LOCALAPPDATA%\hermes\chrome-debug"

netstat -ano | findstr "127.0.0.1:9222" | findstr "LISTENING" >nul 2>&1
if %errorlevel%==0 (
    echo [hermes-browser] already running on 127.0.0.1:9222 - nothing to do.
    exit /b 0
)

echo [hermes-browser] starting silent instance...
REM  Redirection matters: a detached GUI child that inherits the console handles
REM  makes a PowerShell caller (or any piped caller) wait forever.
start "" "%EXE%" --remote-debugging-port=9222 --user-data-dir="%UD%" --no-first-run --no-default-browser-check --no-startup-window >nul 2>&1
exit /b 0

"""Clear the dedicated Hermes browser instance (browser.cdp_url) and leave it running.

Usage:
    hermes-browser-reset.cmd                 close every tab (idle = no window, no taskbar entry)
    hermes-browser-reset.cmd --list          only print the current tabs
    hermes-browser-reset.cmd --keep-blank    keep one about:blank instead of closing all
    hermes-browser-reset.cmd --port N        target another CDP port (default 9222)

Why this exists: Hermes ATTACHES to this browser via browser.cdp_url, so it never
owns the process and never closes tabs it opened - a finished run leaves them
behind. This clears them over the DevTools HTTP endpoint (no websocket client).

Closing the LAST tab is safe HERE: the instance launches with --no-startup-window,
so it stays alive (and window-less) with zero tabs - and that window-less state is
exactly what removes its taskbar entry. The script verifies the endpoint
afterwards and, if a future Chromium ever does exit on last-window-close,
relaunches it through hermes-browser.cmd. Console output is ASCII on purpose
(cmd.exe reads batch and console text with the OEM code page).
"""

import argparse
import contextlib
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request

TIMEOUT = 3.0


def _http(url: str, method: str = "GET") -> tuple[int, str]:
    req = urllib.request.Request(url, method=method)
    try:
        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
            return resp.status, resp.read().decode("utf-8", "replace")
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode("utf-8", "replace")
    except Exception as e:  # noqa: BLE001 - connection refused, reset, etc.
        return 0, str(e)


def _json(url: str, method: str = "GET"):
    code, body = _http(url, method)
    if code != 200:
        return None
    try:
        return json.loads(body)
    except ValueError:
        return None


def _tabs(base: str):
    data = _json(base + "/json/list") or []
    return [t for t in data if t.get("type") == "page" and t.get("id")]


def _close(base: str, target_id: str) -> bool:
    for method in ("GET", "PUT"):
        code, _ = _http(f"{base}/json/close/{target_id}", method)
        if code == 200:
            return True
    return False


def _alive(base: str, seconds: float) -> bool:
    deadline = time.monotonic() + seconds
    while True:
        if _json(base + "/json/version"):
            return True
        if time.monotonic() >= deadline:
            return False
        time.sleep(0.5)


def _relaunch() -> None:
    """Start the instance again through its own script (detached, never waited on)."""
    start_cmd = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hermes-browser.cmd")
    if not os.path.exists(start_cmd):
        print(f"! start script not found: {start_cmd}")
        return
    print("... relaunching through hermes-browser.cmd")
    args = ["powershell", "-NoProfile", "-Command", f"Start-Process -FilePath '{start_cmd}'"]
    if os.name == "nt":
        flags = getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(
            subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
        subprocess.Popen(args, creationflags=flags, close_fds=True,
                         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                         stdin=subprocess.DEVNULL)
    else:
        subprocess.Popen(args, start_new_session=True, stdout=subprocess.DEVNULL,
                         stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)


def _profile_dir() -> str:
    return os.path.join(os.environ.get("LOCALAPPDATA", ""), "hermes", "chrome-debug")


def _stop_instance() -> int:
    """Kill only the processes whose command line carries THIS profile dir."""
    target = os.path.normcase(os.path.normpath(_profile_dir()))
    if not target:
        print("X cannot resolve the profile dir (LOCALAPPDATA unset).")
        return 1
    try:
        import psutil
    except ImportError:
        print("X psutil is unavailable (run this through the Hermes venv python).")
        return 1
    victims = []
    for proc in psutil.process_iter(["name", "cmdline"]):
        try:
            name = (proc.info.get("name") or "").lower()
            joined = os.path.normcase(os.path.normpath(
                " ".join(proc.info.get("cmdline") or [])))
        except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
            continue
        if "brave" in name and target in joined:
            victims.append(proc)
    if not victims:
        print("nothing running - the instance is already stopped.")
        return 0
    for proc in victims:
        with contextlib.suppress(Exception):
            proc.terminate()
    alive = psutil.wait_procs(victims, timeout=8.0)[1]
    for proc in alive:
        with contextlib.suppress(Exception):
            proc.kill()
    psutil.wait_procs(alive, timeout=3.0)
    print(f"stopped {len(victims)} process(es) holding {_profile_dir()}")
    print("Start it again with: hermes-browser.cmd (it also runs at next logon).")
    return 0


def main() -> int:
    ap = argparse.ArgumentParser(add_help=True)
    ap.add_argument("--port", type=int, default=9222)
    ap.add_argument("--list", action="store_true", help="print tabs and exit")
    ap.add_argument("--keep-blank", action="store_true",
                    help="keep one about:blank tab instead of closing every tab")
    ap.add_argument("--stop", action="store_true",
                    help="stop the instance itself (kills only processes holding this profile dir)")
    args = ap.parse_args()
    if args.stop:
        return _stop_instance()
    base = f"http://127.0.0.1:{args.port}"

    version = _json(base + "/json/version")
    if not version:
        print(f"X no CDP endpoint on 127.0.0.1:{args.port} - "
              "run hermes-browser.cmd to (re)start the instance.")
        return 1
    print(f"browser: {version.get('Browser')}  port: {args.port}")

    tabs = _tabs(base)
    print(f"tabs before: {len(tabs)}")
    for t in tabs:
        print(f"  - {t.get('title') or ''} | {t.get('url') or ''}")
    if args.list:
        return 0
    if not tabs:
        print("nothing to close (already idle: no window, no taskbar entry).")
        return 0

    keep = None
    if args.keep_blank:
        keep = next((t["id"] for t in reversed(tabs)
                     if (t.get("url") or "").startswith("about:blank")), None)
        if keep is None and _http(base + "/json/new?about:blank", "PUT")[0] == 200:
            fresh = [t for t in _tabs(base)
                     if (t.get("url") or "").startswith("about:blank")]
            keep = fresh[-1]["id"] if fresh else None
            if keep:
                print(f"created keep-alive about:blank ({keep})")
        if keep is None:
            keep = tabs[-1]["id"]
            print(f"! could not create a blank tab; keeping the last one ({keep})")

    closed = sum(1 for t in tabs if t["id"] != keep and _close(base, t["id"]))
    print(f"closed {closed} tab(s)" + (" -- kept 1" if keep else ""))

    if _alive(base, 5.0):
        print(f"tabs after: {len(_tabs(base))} (instance still up, now window-less)")
        print("OK - no window, no taskbar entry; the instance keeps running.")
        return 0

    print("! the instance exited with its last tab; restarting it")
    _relaunch()
    if _alive(base, 20.0):
        print("OK - instance restarted (it will hold one blank tab again).")
        return 0
    print("X could not restart it - run hermes-browser.cmd by hand and check its output.")
    return 1


if __name__ == "__main__":
    sys.exit(main())