agent-vx 0.1.0__py3-none-any.whl

agentaix/gui.py

@@ -0,0 +1,1321 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import queue
+import re
+import subprocess
+import sys
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+import tkinter as tk
+from tkinter import scrolledtext
+
+from playwright.async_api import (
+    Page,
+    TimeoutError as PlaywrightTimeoutError,
+    async_playwright,
+)
+
+
+# ----------------------------------------------------------------------
+# Core constants (unchanged)
+# ----------------------------------------------------------------------
+
+CHATGPT_URL = "https://chatgpt.com/"
+PROFILE_DIR = Path.home() / ".chatgpt_terminal_agent"
+OUTPUT_DIR = Path.cwd() / "agent_output"
+
+DEFAULT_TIMEOUT = 30_000
+RESPONSE_TIMEOUT = 600_000
+NAVIGATION_TIMEOUT = 120_000
+MAX_RETRIES = 3
+
+# Non-markdown markers (*** would be eaten by bold+italic rendering).
+START_MARKER = "@@@START@@@"
+END_MARKER = "@@@END@@@"
+
+
+SYSTEM_PROMPT = r"""
+You are a production-grade Python coding agent.
+
+The user will give you a programming request.
+
+You MUST return exactly ONE complete Python file that fulfils the request.
+
+STRICT RULES:
+
+1.  No introduction.
+2.  No explanation.
+3.  No conclusion.
+4.  No conversational text.
+5.  No "Sure", "Here is", or similar phrases.
+6.  Return COMPLETE working code.
+7.  Never return pseudocode.
+8.  Never use TODO placeholders.
+9.  Include every required import.
+10. NEVER return multiple files, markdown tables, or prose.
+11. The output must be a SINGLE self-contained Python file.
+12. If third-party packages are needed, the Python file MUST
+    install them itself at runtime using pip (via subprocess with
+    sys.executable -m pip) and only install what is missing.
+13. Do NOT emit a separate INSTALL block - the Python file handles
+    installation on its own.
+14. If the task requires OS-level setup on Windows (registry
+    changes, service install, scheduled task, persistent
+    environment variable, firewall rule, etc.), the Python file
+    MUST contain the PowerShell script as a Python string, WRITE
+    it to a temporary .ps1 file, run it via subprocess, then
+    delete the .ps1 file afterwards.
+15. Do not hard-code secrets.
+16. Use secure and practical defaults.
+17. Make the Python file runnable as `python the_file.py` with no
+    arguments required.
+18. If arguments are useful, provide sensible defaults via
+    argparse.
+19. Never wrap the code in anything other than a single python
+    fenced block.
+
+RESPONSE FORMAT (very important).
+
+Your reply must have exactly this shape, in this order, and nothing
+else. Do NOT write out the words in square brackets literally -
+produce the actual characters they describe.
+
+- Line 1: three at-sign characters, then the word START, then three
+  at-sign characters. (In other words: the character @ appears three
+  times, immediately followed by START, immediately followed by @
+  three more times. No spaces. Nothing before it.)
+
+- Line 2: three backticks, then the word python (this is the opening
+  of a fenced code block).
+
+- Then: the complete, real, working Python source code of the single
+  file the user asked for. Write ACTUAL code. Do NOT write any
+  placeholder text such as "full python file here" or similar.
+
+- Then: three backticks on their own line (this closes the fenced
+  code block).
+
+- Final line: three at-sign characters, then the word END, then three
+  at-sign characters. (Same pattern as the first line but with END.)
+
+Your response is INVALID if it contains anything before the first
+line or after the final line, or if it contains any explanation,
+heading, greeting, or prose.
+"""
+
+
+# ----------------------------------------------------------------------
+# UI palette  (red-on-black techy)
+# ----------------------------------------------------------------------
+
+UI_BG          = "#0a0000"   # window base
+UI_BG_DEEP     = "#050000"   # log / entry background
+UI_FG          = "#ff1a1a"   # primary red text
+UI_FG_DIM      = "#8a1010"   # dim red
+UI_FG_BRIGHT   = "#ff4444"   # bright red
+UI_ACCENT      = "#ff0033"   # accent / cursor
+UI_BORDER      = "#3a0000"   # divider / outline
+UI_OK          = "#00ff66"   # success
+UI_WARN        = "#ff8800"   # status / progress
+UI_ERR         = "#ff0033"   # error
+UI_OUT         = "#cc4444"   # program output
+UI_USER        = "#ffaaaa"   # user input echo
+
+UI_FONT        = ("Consolas", 10)
+UI_FONT_BOLD   = ("Consolas", 10, "bold")
+UI_FONT_SMALL  = ("Consolas", 9)
+UI_FONT_TITLE  = ("Consolas", 22, "bold")
+UI_FONT_GLYPH  = ("Consolas", 12, "bold")
+
+
+# ----------------------------------------------------------------------
+# CLI helpers (unchanged)
+# ----------------------------------------------------------------------
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Terminal ChatGPT coding agent"
+    )
+
+    parser.add_argument(
+        "prompt",
+        nargs="*",
+        help="Programming request (one-shot mode)"
+    )
+
+    parser.add_argument(
+        "-f",
+        "--file",
+        help="Read request from a text file (one-shot mode)"
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        default=str(OUTPUT_DIR / "response.txt"),
+        help="Save full response here (one-shot mode)"
+    )
+
+    parser.add_argument(
+        "--code-output",
+        default=str(OUTPUT_DIR / "code.txt"),
+        help="Save extracted code here (one-shot mode)"
+    )
+
+    parser.add_argument(
+        "--browser",
+        choices=("chromium", "chrome", "msedge"),
+        default="chromium"
+    )
+
+    parser.add_argument(
+        "--new-session",
+        action="store_true"
+    )
+
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=DEFAULT_TIMEOUT
+    )
+
+    parser.add_argument(
+        "--response-timeout",
+        type=int,
+        default=RESPONSE_TIMEOUT
+    )
+
+    return parser.parse_args()
+
+
+def get_one_shot_request(args) -> str:
+    if args.file:
+        path = Path(args.file)
+
+        if not path.exists():
+            raise FileNotFoundError(
+                f"Request file not found: {path}"
+            )
+
+        request = path.read_text(
+            encoding="utf-8"
+        ).strip()
+
+        if not request:
+            raise ValueError(
+                "Request file is empty."
+            )
+
+        return request
+
+    request = " ".join(args.prompt).strip()
+
+    if not request:
+        raise ValueError(
+            "No request supplied."
+        )
+
+    return request
+
+
+def get_interactive_request() -> str:
+    print()
+    print("Enter your request (single line).")
+    print("Type 'exit' or 'quit' to stop.")
+    print()
+
+    try:
+        line = input("request> ")
+    except EOFError:
+        return ""
+
+    line = line.strip()
+
+    if line.lower() in ("exit", "quit", ""):
+        return ""
+
+    return line
+
+
+def build_prompt(request: str) -> str:
+    return (
+        SYSTEM_PROMPT
+        + "\n\n"
+        + "USER REQUEST:\n"
+        + request
+    )
+
+
+# ----------------------------------------------------------------------
+# Input-box discovery (used by both navigation and sending)
+# ----------------------------------------------------------------------
+
+MESSAGE_BOX_SELECTORS = [
+    'textarea[data-testid="textbox"]',
+    'textarea[placeholder*="Message"]',
+    'textarea[placeholder*="message"]',
+    'textarea',
+    '[contenteditable="true"][role="textbox"]',
+    '[contenteditable="true"]',
+]
+
+
+async def visible_locator(
+    page: Page,
+    selectors: list[str],
+    timeout: int = 1500
+):
+    for selector in selectors:
+        try:
+            locator = page.locator(selector).first
+
+            if await locator.is_visible(timeout=timeout):
+                return locator
+
+        except Exception:
+            pass
+
+    return None
+
+
+async def find_message_box(
+    page: Page,
+    timeout: int
+):
+    deadline = time.monotonic() + timeout / 1000
+
+    while time.monotonic() < deadline:
+        box = await visible_locator(page, MESSAGE_BOX_SELECTORS)
+
+        if box:
+            return box
+
+        await page.wait_for_timeout(500)
+
+    return None
+
+
+async def find_send_button(page: Page):
+    selectors = [
+        'button[data-testid="send-button"]',
+        'button[aria-label="Send prompt"]',
+        'button[aria-label*="Send"]',
+        'button:has-text("Send")',
+    ]
+
+    return await visible_locator(page, selectors)
+
+
+async def detect_blocked_page(page: Page):
+    try:
+        body = (
+            await page.locator("body").inner_text(timeout=3000)
+        ).lower()
+    except Exception:
+        body = ""
+
+    captcha = (
+        "captcha",
+        "verify you are human",
+        "verify you're human",
+        "security check",
+    )
+
+    blocked = (
+        "access denied",
+        "request blocked",
+        "unusual activity",
+    )
+
+    login = (
+        "log in to chatgpt",
+        "sign in to chatgpt",
+        "create an account",
+    )
+
+    if any(x in body for x in captcha):
+        return "CAPTCHA/security verification detected."
+
+    if any(x in body for x in blocked):
+        return "Access/security block detected."
+
+    if any(x in body for x in login):
+        box = await find_message_box(page, 1000)
+
+        if box is None:
+            return (
+                "ChatGPT requires authentication "
+                "or logged-out chat is unavailable."
+            )
+
+    return None
+
+
+async def launch_context(playwright, args):
+    # Not headless - but launched minimized so it stays out of the way.
+    launch_options = {
+        "headless": False,
+        "args": [
+            "--start-minimized",
+            "--window-position=-32000,-32000",
+            "--window-size=200,200",
+        ],
+    }
+
+    if args.browser == "chrome":
+        launch_options["channel"] = "chrome"
+
+    elif args.browser == "msedge":
+        launch_options["channel"] = "msedge"
+
+    if args.new_session:
+        browser = await playwright.chromium.launch(**launch_options)
+
+        context = await browser.new_context(
+            viewport={
+                "width": 1440,
+                "height": 900,
+            },
+            locale="en-US",
+        )
+
+        return browser, context
+
+    PROFILE_DIR.mkdir(parents=True, exist_ok=True)
+
+    context = (
+        await playwright.chromium.launch_persistent_context(
+            user_data_dir=str(PROFILE_DIR),
+            viewport={
+                "width": 1440,
+                "height": 900,
+            },
+            locale="en-US",
+            **launch_options,
+        )
+    )
+
+    return None, context
+
+
+# ----------------------------------------------------------------------
+# Screen text helpers
+# ----------------------------------------------------------------------
+
+async def get_screen_text(page: Page) -> str:
+    """Return all visible text on the page as a single string."""
+    try:
+        return await page.locator("body").inner_text(timeout=5000)
+    except Exception:
+        return ""
+
+
+def count_marker(text: str, marker: str) -> int:
+    return text.count(marker)
+
+
+def extract_between_markers(text: str) -> str:
+    """
+    Return the text between the LAST @@@START@@@ and the LAST @@@END@@@.
+    """
+    if not text:
+        return ""
+
+    start = text.rfind(START_MARKER)
+    end = text.rfind(END_MARKER)
+
+    if start == -1 or end == -1 or end <= start:
+        return ""
+
+    return text[start + len(START_MARKER):end].strip()
+
+
+# ----------------------------------------------------------------------
+# Send
+# ----------------------------------------------------------------------
+
+async def send_prompt(page: Page, prompt: str, timeout: int):
+    box = await find_message_box(page, timeout)
+
+    if box is None:
+        try:
+            await page.screenshot(path="debug_no_input.png", full_page=True)
+            print("[!] Screenshot saved: debug_no_input.png")
+        except Exception:
+            pass
+        raise RuntimeError(
+            f"Could not find ChatGPT input. URL={page.url}"
+        )
+
+    await box.click()
+    await page.wait_for_timeout(150)
+
+    try:
+        await page.keyboard.insert_text(prompt)
+    except Exception:
+        try:
+            await box.fill(prompt)
+        except Exception:
+            await page.keyboard.type(prompt, delay=1)
+
+    await page.wait_for_timeout(400)
+
+    await box.press("Enter")
+
+    await page.wait_for_timeout(600)
+
+
+# ----------------------------------------------------------------------
+# Navigate to a fresh chat (new per iteration)
+# ----------------------------------------------------------------------
+
+async def open_new_chat(page: Page, timeout_ms: int):
+    """
+    Navigate to the ChatGPT root and wait until the input box is
+    actually present. Returns the input box locator.
+    """
+    try:
+        await page.goto(
+            CHATGPT_URL,
+            wait_until="domcontentloaded",
+            timeout=NAVIGATION_TIMEOUT,
+        )
+    except PlaywrightTimeoutError:
+        pass
+
+    # Wait for the React app to hydrate and render the input box.
+    box = await find_message_box(page, timeout_ms)
+
+    if box is None:
+        try:
+            await page.screenshot(
+                path="debug_no_input.png", full_page=True
+            )
+            print("[!] Screenshot saved: debug_no_input.png")
+        except Exception:
+            pass
+        raise RuntimeError(
+            f"Input box never appeared after navigation. URL={page.url}"
+        )
+
+    return box
+
+
+# ----------------------------------------------------------------------
+# Wait for response
+# ----------------------------------------------------------------------
+
+async def wait_for_response(
+    page: Page,
+    timeout_ms: int,
+    baseline_end_count: int,
+):
+    """
+    Wait until at least ONE new @@@END@@@ marker appears on screen
+    (from the AI reply), then extract the text between the last
+    @@@START@@@ and the last @@@END@@@.
+    """
+    start = time.monotonic()
+    last_debug = -1
+    target = baseline_end_count + 1
+
+    print(
+        f"[*] Waiting for reply (baseline ENDs={baseline_end_count}, "
+        f"target={target})..."
+    )
+
+    while True:
+        elapsed = (time.monotonic() - start) * 1000
+
+        if elapsed > timeout_ms:
+            try:
+                await page.screenshot(
+                    path="debug_timeout.png", full_page=True
+                )
+                print("[!] Screenshot saved: debug_timeout.png")
+            except Exception:
+                pass
+            raise TimeoutError(
+                "Timed out waiting for the reply. "
+                "See debug_timeout.png."
+            )
+
+        text = await get_screen_text(page)
+        end_count = count_marker(text, END_MARKER)
+
+        if end_count >= target:
+            extracted = extract_between_markers(text)
+            if extracted:
+                print(
+                    f"[✓] Reply captured "
+                    f"(ENDs={end_count}, chars={len(extracted)})."
+                )
+                return extracted
+
+        sec = int(elapsed / 1000)
+        if sec != last_debug and sec % 5 == 0:
+            last_debug = sec
+            print(
+                f"[debug] elapsed={sec}s "
+                f"ends={end_count}/{target} "
+                f"screen_chars={len(text)}"
+            )
+
+        await page.wait_for_timeout(500)
+
+
+def extract_code(response: str) -> str:
+    blocks = re.findall(
+        r"```(?:[a-zA-Z0-9_+#.-]+)?\s*\n(.*?)```",
+        response,
+        re.DOTALL,
+    )
+
+    if blocks:
+        return "\n\n".join(
+            block.strip()
+            for block in blocks
+            if block.strip()
+        )
+
+    return response.strip()
+
+
+def save_output(response: str, output_path: str, code_path: str):
+    output = Path(output_path)
+    code = Path(code_path)
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    code.parent.mkdir(parents=True, exist_ok=True)
+
+    output.write_text(response, encoding="utf-8")
+    code.write_text(extract_code(response), encoding="utf-8")
+
+
+def build_unique_paths(prefix: str) -> tuple[Path, Path, Path]:
+    """
+    Build a unique set of output paths for one iteration.
+    Returns (response_txt, code_txt, run_py).
+    """
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    response_path = OUTPUT_DIR / f"{prefix}_response_{stamp}.txt"
+    code_path = OUTPUT_DIR / f"{prefix}_code_{stamp}.txt"
+    py_path = OUTPUT_DIR / f"{prefix}_generated_{stamp}.py"
+
+    return response_path, code_path, py_path
+
+
+def run_generated_code(py_path: Path) -> int:
+    """
+    Execute the generated .py with the same interpreter, in a
+    subprocess, and stream its output live.
+    Returns the exit code.
+    """
+    print()
+    print("=" * 70)
+    print(f"[*] Running: {py_path}")
+    print("=" * 70)
+
+    try:
+        result = subprocess.run(
+            [sys.executable, str(py_path)],
+            check=False,
+        )
+        print("=" * 70)
+        print(f"[*] Exit code: {result.returncode}")
+        print("=" * 70)
+        return result.returncode
+
+    except KeyboardInterrupt:
+        print("\n[!] Interrupted.")
+        return -1
+
+    except Exception as exc:
+        print(f"[!] Failed to run: {exc}")
+        return -1
+
+
+async def do_one_iteration(
+    page: Page,
+    request: str,
+    args,
+    label_prefix: str,
+):
+    """
+    One full round: new chat -> send -> capture -> save -> run.
+    """
+    print()
+    print("#" * 70)
+    print(
+        f"[*] New chat. Request: {request[:80]}"
+        + ("..." if len(request) > 80 else "")
+    )
+    print("#" * 70)
+
+    # ------------------------------------------------------------
+    # Open a fresh chat each iteration and wait for input box.
+    # ------------------------------------------------------------
+    await open_new_chat(page, args.timeout)
+
+    blocked = await detect_blocked_page(page)
+    if blocked:
+        raise RuntimeError(blocked)
+
+    baseline_text = await get_screen_text(page)
+    baseline_end_count = count_marker(baseline_text, END_MARKER)
+
+    print(f"[*] Baseline END markers on screen: {baseline_end_count}")
+    print("[*] Sending request...")
+
+    await send_prompt(page, build_prompt(request), args.timeout)
+
+    print("[*] Waiting for response...")
+
+    response = await wait_for_response(
+        page,
+        args.response_timeout,
+        baseline_end_count,
+    )
+
+    if not response.strip():
+        raise RuntimeError("Empty ChatGPT response.")
+
+    # ------------------------------------------------------------
+    # Save outputs.
+    # ------------------------------------------------------------
+    response_path, code_path, py_path = build_unique_paths(label_prefix)
+
+    # NOTE: argument order must match the signature
+    # save_output(response, output_path, code_path).
+    save_output(response, str(response_path), str(code_path))
+
+    # Save the extracted python code as a runnable .py file.
+    code_body = extract_code(response)
+    py_path.write_text(code_body, encoding="utf-8")
+
+    print()
+    print("=" * 70)
+    print(response)
+    print("=" * 70)
+    print()
+    print(f"Response saved to: {response_path.resolve()}")
+    print(f"Code saved to:     {code_path.resolve()}")
+    print(f"Python file:       {py_path.resolve()}")
+
+    # ------------------------------------------------------------
+    # Run the generated code.
+    # ------------------------------------------------------------
+    run_generated_code(py_path)
+
+
+async def main_async(args):
+    one_shot = bool(args.prompt) or bool(args.file)
+
+    if one_shot:
+        request = get_one_shot_request(args)
+        label_prefix = "oneshot"
+    else:
+        label_prefix = "run"
+
+    browser = None
+    context = None
+
+    async with async_playwright() as playwright:
+        try:
+            browser, context = await launch_context(playwright, args)
+
+            context.set_default_timeout(args.timeout)
+
+            pages = context.pages
+
+            if pages:
+                page = pages[0]
+            else:
+                page = await context.new_page()
+
+            page.set_default_navigation_timeout(NAVIGATION_TIMEOUT)
+
+            print("[*] Opening ChatGPT...")
+
+            # Initial load; wait for input box to be sure we're logged in.
+            try:
+                await open_new_chat(page, args.timeout)
+            except Exception as exc:
+                print(f"[!] Initial load failed: {exc}")
+                raise
+
+            # ----------------------------------------------------
+            # One-shot mode.
+            # ----------------------------------------------------
+            if one_shot:
+                for attempt in range(1, MAX_RETRIES + 1):
+                    try:
+                        print(
+                            f"[*] Attempt {attempt}/{MAX_RETRIES}"
+                        )
+
+                        await do_one_iteration(
+                            page, request, args, label_prefix
+                        )
+                        return
+
+                    except KeyboardInterrupt:
+                        raise
+
+                    except Exception as exc:
+                        print(
+                            f"[!] Attempt failed: {exc}",
+                            file=sys.stderr,
+                        )
+
+                        if attempt < MAX_RETRIES:
+                            delay = attempt * 3
+                            print(
+                                f"[*] Retrying in {delay}s..."
+                            )
+                            await asyncio.sleep(delay)
+
+                raise RuntimeError(
+                    f"Agent failed after {MAX_RETRIES} attempts."
+                )
+
+            # ----------------------------------------------------
+            # Interactive loop mode.
+            # ----------------------------------------------------
+            iteration = 0
+
+            while True:
+                request = get_interactive_request()
+
+                if not request:
+                    print("[*] Exiting.")
+                    break
+
+                iteration += 1
+                prefix = f"run{iteration:03d}"
+
+                try:
+                    await do_one_iteration(
+                        page, request, args, prefix
+                    )
+
+                except KeyboardInterrupt:
+                    print("\n[*] Interrupted, exiting.")
+                    break
+
+                except Exception as exc:
+                    print(
+                        f"[!] Iteration failed: {exc}",
+                        file=sys.stderr,
+                    )
+
+            return
+
+        finally:
+            if context:
+                try:
+                    await context.close()
+                except Exception:
+                    pass
+
+            if browser:
+                try:
+                    await browser.close()
+                except Exception:
+                    pass
+
+
+# ======================================================================
+# GUI AGENT  -  AgentAnon
+# ======================================================================
+
+def _build_gui_args():
+    """Lightweight namespace that mirrors the CLI args used by the
+    existing core logic (browser / new_session / timeout ...)."""
+
+    class _Args:
+        browser = "chromium"
+        new_session = False
+        timeout = DEFAULT_TIMEOUT
+        response_timeout = RESPONSE_TIMEOUT
+
+    return _Args()
+
+
+class AgentAnonApp:
+    """
+    Red-on-black techy GUI wrapper around the existing async core.
+    All heavy lifting still happens through the same helpers
+    (launch_context, open_new_chat, send_prompt, wait_for_response,
+    extract_code, save_output, ...).
+    """
+
+    def __init__(self, root: tk.Tk):
+        self.root = root
+
+        # Thread-safe channels between GUI thread and worker thread.
+        self.out_queue: queue.Queue = queue.Queue()
+        self.request_queue: queue.Queue = queue.Queue()
+
+        self.running = True
+        self.busy = False
+        self.ready = False
+
+        self._setup_ui()
+        self._start_worker()
+
+        self.root.after(50, self._poll)
+        self.root.protocol("WM_DELETE_WINDOW", self._on_close)
+
+    # ------------------------------------------------------------------
+    # UI construction
+    # ------------------------------------------------------------------
+
+    def _setup_ui(self):
+        self.root.title("AgentAnon")
+        self.root.configure(bg=UI_BG)
+        self.root.geometry("960x680")
+        self.root.minsize(720, 520)
+
+        # ---- Header ------------------------------------------------
+        header = tk.Frame(self.root, bg=UI_BG)
+        header.pack(fill="x", padx=14, pady=(12, 0))
+
+        title = tk.Label(
+            header,
+            text="\u25e2 AGENTANON \u25e3",
+            bg=UI_BG,
+            fg=UI_FG,
+            font=UI_FONT_TITLE,
+        )
+        title.pack(side="left")
+
+        subtitle = tk.Label(
+            header,
+            text="// autonomous code synthesis unit",
+            bg=UI_BG,
+            fg=UI_FG_DIM,
+            font=UI_FONT_SMALL,
+        )
+        subtitle.pack(side="left", padx=(12, 0), pady=(10, 0))
+
+        self._divider(pady=(8, 8))
+
+        # ---- Log / chat area --------------------------------------
+        log_frame = tk.Frame(self.root, bg=UI_BG)
+        log_frame.pack(fill="both", expand=True, padx=14)
+
+        self.log_area = scrolledtext.ScrolledText(
+            log_frame,
+            bg=UI_BG_DEEP,
+            fg=UI_FG,
+            insertbackground=UI_ACCENT,
+            font=UI_FONT,
+            relief="flat",
+            borderwidth=0,
+            highlightthickness=1,
+            highlightbackground=UI_BORDER,
+            highlightcolor=UI_BORDER,
+            wrap="word",
+            state="disabled",
+            padx=10,
+            pady=8,
+        )
+        self.log_area.pack(fill="both", expand=True)
+
+        self.log_area.tag_configure("info",    foreground=UI_FG)
+        self.log_area.tag_configure("status",  foreground=UI_WARN)
+        self.log_area.tag_configure("success", foreground=UI_OK)
+        self.log_area.tag_configure("error",   foreground=UI_ERR)
+        self.log_area.tag_configure("output",  foreground=UI_OUT)
+        self.log_area.tag_configure("user",    foreground=UI_USER,
+                                    font=UI_FONT_BOLD)
+        self.log_area.tag_configure("heading", foreground=UI_FG_BRIGHT,
+                                    font=UI_FONT_BOLD)
+        self.log_area.tag_configure("system",  foreground=UI_FG_DIM,
+                                    font=UI_FONT_SMALL)
+
+        self._divider(pady=(8, 8))
+
+        # ---- Input row --------------------------------------------
+        input_frame = tk.Frame(self.root, bg=UI_BG)
+        input_frame.pack(fill="x", padx=14, pady=(0, 6))
+
+        prompt_glyph = tk.Label(
+            input_frame,
+            text="\u25b8",
+            bg=UI_BG,
+            fg=UI_FG,
+            font=UI_FONT_GLYPH,
+        )
+        prompt_glyph.pack(side="left", padx=(0, 6))
+
+        self.entry = tk.Entry(
+            input_frame,
+            bg=UI_BG_DEEP,
+            fg=UI_FG,
+            insertbackground=UI_ACCENT,
+            font=UI_FONT,
+            relief="flat",
+            highlightthickness=1,
+            highlightbackground=UI_BORDER,
+            highlightcolor=UI_ACCENT,
+            disabledbackground=UI_BG_DEEP,
+            disabledforeground=UI_FG_DIM,
+        )
+        self.entry.pack(
+            side="left", fill="x", expand=True, padx=(0, 10), ipady=6
+        )
+        self.entry.bind("<Return>", self._submit_event)
+
+        self.send_btn = tk.Button(
+            input_frame,
+            text="[ TRANSMIT ]",
+            bg=UI_BG,
+            fg=UI_FG,
+            activebackground=UI_ACCENT,
+            activeforeground="#000000",
+            font=UI_FONT_BOLD,
+            relief="flat",
+            borderwidth=0,
+            padx=14,
+            pady=4,
+            cursor="hand2",
+            command=self._submit_event,
+        )
+        self.send_btn.pack(side="right")
+
+        # ---- Status bar -------------------------------------------
+        status_frame = tk.Frame(self.root, bg=UI_BG)
+        status_frame.pack(fill="x", padx=14, pady=(0, 12))
+
+        self.status_label = tk.Label(
+            status_frame,
+            text="\u25cf  initializing",
+            bg=UI_BG,
+            fg=UI_WARN,
+            font=UI_FONT_SMALL,
+            anchor="w",
+        )
+        self.status_label.pack(side="left")
+
+        self.hint_label = tk.Label(
+            status_frame,
+            text="enter \u2192 transmit    |    esc \u2192 clear",
+            bg=UI_BG,
+            fg=UI_FG_DIM,
+            font=UI_FONT_SMALL,
+            anchor="e",
+        )
+        self.hint_label.pack(side="right")
+
+        self.root.bind("<Escape>", lambda e: self.entry.delete(0, "end"))
+
+        # Intro banner
+        self._append("\u2500" * 68, "system")
+        self._append("  AGENTANON :: autonomous code synthesis unit", "heading")
+        self._append("  channel: secure  |  mode: interactive  |  status: warming up", "system")
+        self._append("\u2500" * 68, "system")
+        self.entry.focus_set()
+
+    def _divider(self, pady=(0, 0)):
+        sep = tk.Frame(self.root, bg=UI_BORDER, height=1)
+        sep.pack(fill="x", padx=14, pady=pady)
+
+    # ------------------------------------------------------------------
+    # Threading / worker
+    # ------------------------------------------------------------------
+
+    def _start_worker(self):
+        t = threading.Thread(
+            target=self._worker_thread,
+            name="AgentAnonWorker",
+            daemon=True,
+        )
+        t.start()
+
+    def _worker_thread(self):
+        try:
+            asyncio.run(self._worker_main())
+        except Exception as exc:
+            self._log(f"worker crashed: {exc}", "error")
+            self._status("halted", UI_ERR)
+
+    async def _worker_main(self):
+        args = _build_gui_args()
+
+        async with async_playwright() as playwright:
+            browser = None
+            context = None
+            try:
+                self._log("booting headless runtime...", "system")
+                self._status("booting", UI_WARN)
+
+                browser, context = await launch_context(playwright, args)
+                context.set_default_timeout(args.timeout)
+
+                pages = context.pages
+                page = pages[0] if pages else await context.new_page()
+                page.set_default_navigation_timeout(NAVIGATION_TIMEOUT)
+
+                self._log("opening secure channel...", "system")
+                await open_new_chat(page, args.timeout)
+
+                self.ready = True
+                self._log("channel established.", "success")
+                self._status("ready", UI_OK)
+                self._log("awaiting instruction.", "system")
+
+                loop = asyncio.get_event_loop()
+
+                while self.running:
+                    try:
+                        request = await loop.run_in_executor(
+                            None, self.request_queue.get
+                        )
+                    except RuntimeError:
+                        break
+
+                    if request is None:
+                        break
+
+                    self._status("working", UI_WARN)
+                    self._log("", "info")
+                    self._log("\u25b8 working on:", "heading")
+                    self._log(f"  {request}", "user")
+
+                    try:
+                        py_path = await self._run_iteration(
+                            page, request, args
+                        )
+                        await self._run_generated_async(py_path)
+                    except Exception as exc:
+                        self._log(f"  \u2717 {exc}", "error")
+
+                    self._status("ready", UI_OK)
+                    self._done()
+
+            finally:
+                if context:
+                    try:
+                        await context.close()
+                    except Exception:
+                        pass
+                if browser:
+                    try:
+                        await browser.close()
+                    except Exception:
+                        pass
+
+    # ------------------------------------------------------------------
+    # GUI-flavoured version of do_one_iteration (same core logic,
+    # only prints replaced with queue messages).
+    # ------------------------------------------------------------------
+
+    async def _run_iteration(self, page: Page, request: str, args):
+        await open_new_chat(page, args.timeout)
+
+        blocked = await detect_blocked_page(page)
+        if blocked:
+            raise RuntimeError(blocked)
+
+        baseline_text = await get_screen_text(page)
+        baseline_end_count = count_marker(baseline_text, END_MARKER)
+
+        self._log("  \u00b7 transmitting payload...", "status")
+        await send_prompt(page, build_prompt(request), args.timeout)
+
+        self._log("  \u00b7 synthesizing response...", "status")
+        response = await self._wait_for_response(
+            page, args.response_timeout, baseline_end_count
+        )
+
+        if not response.strip():
+            raise RuntimeError("empty response payload.")
+
+        response_path, code_path, py_path = build_unique_paths("run")
+        save_output(response, str(response_path), str(code_path))
+
+        code_body = extract_code(response)
+        py_path.write_text(code_body, encoding="utf-8")
+
+        self._log(f"  \u2713 artifact: {py_path.name}", "success")
+        self._log(f"    \u2192 {py_path.resolve()}", "system")
+
+        return py_path
+
+    async def _wait_for_response(
+        self,
+        page: Page,
+        timeout_ms: int,
+        baseline_end_count: int,
+    ):
+        start = time.monotonic()
+        target = baseline_end_count + 1
+        last_tick = -1
+
+        while True:
+            elapsed_ms = (time.monotonic() - start) * 1000
+
+            if elapsed_ms > timeout_ms:
+                raise TimeoutError("response window expired.")
+
+            text = await get_screen_text(page)
+            end_count = count_marker(text, END_MARKER)
+
+            if end_count >= target:
+                extracted = extract_between_markers(text)
+                if extracted:
+                    return extracted
+
+            sec = int(elapsed_ms / 1000)
+            if sec != last_tick and sec % 5 == 0 and sec > 0:
+                last_tick = sec
+                self._log(f"  \u00b7 still synthesizing ({sec}s)", "status")
+
+            await page.wait_for_timeout(500)
+
+    async def _run_generated_async(self, py_path: Path):
+        self._log("  \u00b7 executing artifact...", "status")
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                sys.executable, str(py_path),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+
+            if proc.stdout is not None:
+                async for raw in proc.stdout:
+                    text = raw.decode(errors="replace").rstrip()
+                    if text:
+                        self._log(f"    | {text}", "output")
+
+            await proc.wait()
+
+            if proc.returncode == 0:
+                self._log("  \u2713 execution complete (exit 0)", "success")
+            else:
+                self._log(
+                    f"  \u2717 execution finished (exit {proc.returncode})",
+                    "error",
+                )
+        except Exception as exc:
+            self._log(f"  \u2717 execution failed: {exc}", "error")
+
+    # ------------------------------------------------------------------
+    # Cross-thread messaging
+    # ------------------------------------------------------------------
+
+    def _log(self, text: str, tag: str = "info"):
+        self.out_queue.put(("log", text, tag))
+
+    def _status(self, text: str, color: str = UI_FG):
+        self.out_queue.put(("status", text, color))
+
+    def _done(self):
+        self.out_queue.put(("done",))
+
+    def _poll(self):
+        try:
+            while True:
+                item = self.out_queue.get_nowait()
+                kind = item[0]
+
+                if kind == "log":
+                    self._append(item[1], item[2])
+                elif kind == "status":
+                    self.status_label.configure(
+                        text=f"\u25cf  {item[1]}", fg=item[2]
+                    )
+                elif kind == "done":
+                    self.busy = False
+                    self.send_btn.configure(state="normal")
+                    self.entry.focus_set()
+        except queue.Empty:
+            pass
+
+        if self.running:
+            self.root.after(50, self._poll)
+
+    def _append(self, text: str, tag: str = "info"):
+        self.log_area.configure(state="normal")
+        self.log_area.insert("end", text + "\n", tag)
+        self.log_area.see("end")
+        self.log_area.configure(state="disabled")
+
+    # ------------------------------------------------------------------
+    # User actions
+    # ------------------------------------------------------------------
+
+    def _submit_event(self, event=None):
+        text = self.entry.get().strip()
+        if not text:
+            return
+
+        if not self.ready:
+            self._append("[ waiting ] channel not ready yet", "status")
+            return
+
+        if self.busy:
+            self._append("[ busy ] previous task still running", "status")
+            return
+
+        self.entry.delete(0, "end")
+        self._append("", "info")
+        self._append(f"\u25b8 {text}", "user")
+
+        self.busy = True
+        self.send_btn.configure(state="disabled")
+        self.request_queue.put(text)
+
+    def _on_close(self):
+        self.running = False
+        try:
+            self.request_queue.put(None)
+        except Exception:
+            pass
+        try:
+            self.root.destroy()
+        except Exception:
+            pass
+
+
+def launch_gui():
+    root = tk.Tk()
+    AgentAnonApp(root)
+    root.mainloop()
+
+
+# ======================================================================
+# Entry point
+# ======================================================================
+
+def main():
+    # If CLI arguments are given, keep the original terminal behaviour.
+    # Otherwise, launch the AgentAnon GUI.
+    if len(sys.argv) > 1:
+        args = parse_args()
+
+        try:
+            asyncio.run(main_async(args))
+
+        except KeyboardInterrupt:
+            print("\nStopped.")
+
+        except Exception as exc:
+            print(f"\nERROR: {exc}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        launch_gui()
+
+
+if __name__ == "__main__":
+    main()