gemcode 0.3.23__tar.gz → 0.3.24__tar.gz

{gemcode-0.3.23/src/gemcode.egg-info → gemcode-0.3.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.23
+Version: 0.3.24
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.23 → gemcode-0.3.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.23"
+version = "0.3.24"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.3.23 → gemcode-0.3.24}/src/gemcode/agent.py

@@ -71,6 +71,143 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Working in subfolders** — use tools: e.g. `list_directory("Desktop")`, `glob_files("**/query.ts")`, `read_file("testing/ai-edtech-app/src/app/page.tsx")`, or `run_command` with `cwd_subdir`. Never claim the sandbox cannot reach a subpath unless a tool returned an explicit error."""
 
 
+def _build_computer_use_section(cfg: GemCodeConfig) -> str:
+  """Rich computer use guidance, only injected when enable_computer_use=True."""
+  w = getattr(cfg, "_cfg", None)
+  viewport_w = 1280
+  viewport_h = 720
+  try:
+    import os
+    viewport_w = int(os.environ.get("GEMCODE_BROWSER_WIDTH", "1280"))
+    viewport_h = int(os.environ.get("GEMCODE_BROWSER_HEIGHT", "720"))
+  except Exception:
+    pass
+  return f"""
+## Browser Computer Use
+You have full browser automation capabilities via a real Chromium instance ({viewport_w}×{viewport_h} px).
+
+### Available tools
+
+**Navigation:**
+- `navigate(url)` — Load a URL, wait for DOM, return screenshot + URL
+- `go_back()` / `go_forward()` — Browser history
+- `search()` — Open Google homepage
+
+**Mouse:**
+- `click_at(x, y)` — Left-click at pixel coordinates (0,0 = top-left corner)
+- `double_click_at(x, y)` — Double-click
+- `right_click_at(x, y)` — Right-click (opens context menus)
+- `hover_at(x, y)` — Hover to reveal tooltips / dropdown menus
+- `drag_and_drop(x, y, dest_x, dest_y)` — Click-drag
+
+**Keyboard:**
+- `type_text_at(x, y, text, press_enter=True, clear_before_typing=True)` — Click field then type
+- `key_combination(keys)` — Press combos: `["control+a"]`, `["control+c"]`, `["control+v"]`, `["escape"]`, `["tab"]`
+
+**Scroll:**
+- `scroll_document(direction)` — Scroll whole page: `"up"`, `"down"`, `"left"`, `"right"`
+- `scroll_at(x, y, direction, magnitude)` — Scroll at a specific coordinate (for panels)
+
+**Wait:**
+- `wait(seconds)` — Pause for dynamic content (SPAs, animations, lazy-loading)
+- `browser_wait_for_navigation(timeout_seconds)` — Wait for a page transition to complete
+
+**Read-only inspection (NO side effects — always safe to call):**
+- `browser_screenshot()` — Take screenshot, save to file, return path + URL + title
+- `browser_get_text(max_chars)` — Extract ALL visible text from page (best for data extraction)
+- `browser_get_url()` — Get current URL and page title
+- `browser_find_element(selector_or_text, selector_type)` — Find element position by CSS or text; returns center (x, y) for clicking
+
+### Human-like execution strategy — ALWAYS follow this loop
+
+Every computer use task MUST follow this exact loop:
+
+1. **THINK** — call `think` first. Reason through: What is the goal? What page do I need? What sequence of actions?
+2. **NAVIGATE** — go to the right URL with `navigate(url)`
+3. **LOOK** — call `browser_screenshot()` to see the current page state
+4. **ANALYZE** — study the screenshot carefully: Where are the buttons? Inputs? Text? What are their approximate pixel coordinates?
+5. **FIND** — use `browser_find_element(text_or_selector)` to get precise coordinates for important elements
+6. **ACT** — execute ONE action (`click_at`, `type_text_at`, etc.)
+7. **VERIFY** — study the new screenshot returned by the action. Did it work?
+8. **ADAPT** — if unexpected result, reconsider; try different coordinates or approach
+9. **REPEAT** — continue until the task is fully done
+
+### Critical rules
+
+- **ALWAYS call `think` before a sequence of computer actions** — plan the exact steps before touching the browser
+- **Coordinates are (x, y) from the top-left corner (0, 0)** — viewport is {viewport_w}×{viewport_h} px
+- **Use `browser_find_element` for precision** — do not guess coordinates; find elements by their visible text
+- **Click THEN verify** — every action returns a screenshot; always analyze it before the next action
+- **For slow pages** — call `wait(2)` after navigation if content is still loading in the screenshot
+- **For forms** — click each field individually, then type; `type_text_at` handles this automatically
+- **For data extraction** — use `browser_get_text()` instead of trying to read screenshot text
+- **If a click misses** — take `browser_screenshot()`, analyze coordinates more carefully, try again
+- **For menus** — `hover_at` first (to reveal), then `click_at` the menu item
+
+### Common patterns
+
+**Web search for information:**
+```
+think("I need to search Google for X")
+navigate("https://www.google.com")
+browser_screenshot()  # verify Google loaded
+type_text_at(640, 360, "your query", press_enter=True)
+browser_screenshot()  # see search results
+browser_get_text()    # extract text of results
+click_at(x, y)        # click most relevant result
+browser_get_text()    # extract the article
+```
+
+**Fill and submit a form:**
+```
+think("I need to fill in: field1=value1, field2=value2, then submit")
+navigate("https://example.com/form")
+browser_screenshot()  # see the form layout
+browser_find_element("Email", selector_type="text")  # get input coords
+type_text_at(x, y, "user@email.com", press_enter=False)
+browser_find_element("Password", selector_type="text")
+type_text_at(x, y, "password", press_enter=False)
+browser_find_element("Submit", selector_type="text")
+click_at(center_x, center_y)
+browser_screenshot()  # verify submission
+```
+
+**Log in to a website:**
+```
+navigate("https://example.com/login")
+browser_screenshot()
+browser_find_element("input[type='email']", selector_type="css")
+type_text_at(x, y, "user@email.com", press_enter=False)
+browser_find_element("input[type='password']", selector_type="css")
+type_text_at(x, y, "password", press_enter=True)
+browser_screenshot()  # verify login success
+```
+
+**Extract data from a page:**
+```
+navigate("https://example.com/data")
+wait(2)  # allow dynamic content to load
+browser_get_text()  # get all visible text — parse it to extract what you need
+```
+
+**Copy text from page to use elsewhere:**
+```
+browser_find_element("the text I want", selector_type="text")
+# Note the coordinates, then use key_combination to select
+click_at(x, y)
+key_combination(["control+a"])  # select all text in the field
+key_combination(["control+c"])  # copy
+```
+
+### Error recovery
+- **Page didn't load**: try `wait(3)` then `browser_screenshot()` to check
+- **Element not found by selector**: use `browser_get_text()` to find the exact text, then use `browser_find_element` with that text
+- **Click had no effect**: double-check coordinates from screenshot, try `browser_find_element` to get precise position
+- **Form submission failed**: `browser_get_text()` to read error messages, fix and resubmit
+- **Unexpected page**: `browser_get_url()` to confirm where you are, `go_back()` if needed
+"""
+
+
 def build_instruction(cfg: GemCodeConfig) -> str:
   base = f"""You are GemCode, an expert software engineering agent powered by Google Gemini.
 You run locally via the GemCode CLI. You are the same agent the user launched — not a hosted portal.
@@ -241,8 +378,11 @@ For tasks where quality matters:
 ## Workspace scope
 All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`."""
 
-  tool_manifest = build_tool_manifest(cfg)
+  # Inject computer use strategy when the browser is enabled.
+  if getattr(cfg, "enable_computer_use", False):
+    base = f"{base}\n\n{_build_computer_use_section(cfg)}"
 
+  tool_manifest = build_tool_manifest(cfg)
   if tool_manifest:
     base = f"{base}\n\n{tool_manifest}"
   extra = _load_gemini_md(cfg.project_root)

gemcode-0.3.24/src/gemcode/computer_use/browser_computer.py

@@ -0,0 +1,361 @@
+"""
+Playwright-backed browser automation (ADK ComputerUse).
+
+Implements Google ADK's BaseComputer so the LLM can call computer-use tools
+like navigate, click_at, type_text_at, scroll_at, key_combination, etc.
+
+Every action returns a ComputerState (viewport PNG screenshot + current URL)
+so the model always sees the current page state after each action.
+"""
+
+from __future__ import annotations
+
+import platform
+import sys
+from dataclasses import dataclass
+from typing import Literal
+from typing import Tuple
+
+from google.adk.tools.computer_use.base_computer import BaseComputer
+from google.adk.tools.computer_use.base_computer import ComputerEnvironment
+from google.adk.tools.computer_use.base_computer import ComputerState
+
+
+@dataclass(frozen=True)
+class BrowserComputerConfig:
+  headless: bool = True
+  viewport_width: int = 1280
+  viewport_height: int = 720
+  navigation_timeout_ms: int = 30_000
+  # Extra ms to wait after load for dynamic content (SPAs, lazy-loading, etc.)
+  post_load_wait_ms: int = 400
+
+
+_IS_MACOS = platform.system() == "Darwin"
+
+# On macOS, many "select all / copy / paste" shortcuts use Cmd (Meta) instead
+# of Ctrl.  In a Chromium browser Ctrl+A still works for web inputs, but some
+# OS-level UI elements need Meta.  We expose both and let the agent decide.
+_MOD_MAP = {
+    "control": "Control", "ctrl": "Control",
+    "shift": "Shift",
+    "alt": "Alt", "option": "Alt",
+    "meta": "Meta", "command": "Meta", "cmd": "Meta", "super": "Meta",
+}
+
+
+class BrowserComputer(BaseComputer):
+  """
+  A single Chromium page controlled by Playwright.
+
+  Usage flow:
+    1. LLM calls ``navigate(url)`` to open a page.
+    2. LLM reads the screenshot returned by each action.
+    3. LLM calls ``click_at``, ``type_text_at``, etc. to interact.
+    4. Each action returns a new ``ComputerState`` (screenshot + URL).
+  """
+
+  def __init__(
+    self,
+    *,
+    headless: bool = True,
+    viewport_size: Tuple[int, int] = (1280, 720),
+    navigation_timeout_ms: int = 30_000,
+    post_load_wait_ms: int = 400,
+  ):
+    self._cfg = BrowserComputerConfig(
+      headless=headless,
+      viewport_width=viewport_size[0],
+      viewport_height=viewport_size[1],
+      navigation_timeout_ms=navigation_timeout_ms,
+      post_load_wait_ms=post_load_wait_ms,
+    )
+    self._playwright = None
+    self._browser = None
+    self._context = None
+    self._page = None
+
+  # ── Lifecycle ─────────────────────────────────────────────────────────────
+
+  async def initialize(self) -> None:
+    """Lazy-start Playwright Chromium. Called automatically before every action."""
+    if self._page is not None:
+      return
+    try:
+      from playwright.async_api import async_playwright
+    except ImportError as exc:
+      raise RuntimeError(
+        "Browser computer requires Playwright.\n"
+        "  pip install playwright\n"
+        "  playwright install chromium"
+      ) from exc
+
+    self._playwright = await async_playwright().start()
+    self._browser = await self._playwright.chromium.launch(headless=self._cfg.headless)
+    self._context = await self._browser.new_context(
+      viewport={
+        "width": self._cfg.viewport_width,
+        "height": self._cfg.viewport_height,
+      }
+    )
+    self._page = await self._context.new_page()
+    self._page.set_default_navigation_timeout(self._cfg.navigation_timeout_ms)
+
+  async def close(self) -> None:
+    """Shut down the Playwright process (called by session_runtime on runner close)."""
+    for attr in ("_context", "_browser", "_playwright"):
+      obj = getattr(self, attr, None)
+      if obj is not None:
+        try:
+          await obj.close() if attr != "_playwright" else await obj.stop()
+        except Exception:
+          pass
+    self._playwright = None
+    self._browser = None
+    self._context = None
+    self._page = None
+
+  # ── ADK BaseComputer interface ─────────────────────────────────────────────
+
+  async def environment(self) -> ComputerEnvironment:
+    return ComputerEnvironment.ENVIRONMENT_BROWSER
+
+  async def screen_size(self) -> tuple[int, int]:
+    await self.initialize()
+    return (self._cfg.viewport_width, self._cfg.viewport_height)
+
+  async def current_state(self) -> ComputerState:
+    """Return viewport PNG + current URL (called after every action)."""
+    await self.initialize()
+    screenshot = await self._page.screenshot(type="png", full_page=False)
+    url = self._page.url
+    return ComputerState(screenshot=screenshot, url=url)
+
+  # ── Navigation ─────────────────────────────────────────────────────────────
+
+  async def open_web_browser(self) -> ComputerState:
+    await self.initialize()
+    await self._page.goto("about:blank")
+    return await self.current_state()
+
+  async def navigate(self, url: str) -> ComputerState:
+    """Navigate to a URL. Waits for DOM content, then an extra grace period."""
+    await self.initialize()
+    try:
+      await self._page.goto(url, wait_until="domcontentloaded")
+    except Exception:
+      # Best-effort on timeout/error; still return current state.
+      pass
+    await self._page.wait_for_timeout(self._cfg.post_load_wait_ms)
+    return await self.current_state()
+
+  async def go_back(self) -> ComputerState:
+    await self.initialize()
+    try:
+      await self._page.go_back(wait_until="domcontentloaded")
+    except Exception:
+      pass
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def go_forward(self) -> ComputerState:
+    await self.initialize()
+    try:
+      await self._page.go_forward(wait_until="domcontentloaded")
+    except Exception:
+      pass
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def search(self) -> ComputerState:
+    return await self.navigate("https://www.google.com")
+
+  # ── Mouse actions ──────────────────────────────────────────────────────────
+
+  async def click_at(self, x: int, y: int) -> ComputerState:
+    """Left-click at pixel coordinates (0,0 = top-left)."""
+    await self.initialize()
+    await self._page.mouse.click(x, y)
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def double_click_at(self, x: int, y: int) -> ComputerState:
+    """Double-click at pixel coordinates."""
+    await self.initialize()
+    await self._page.mouse.dblclick(x, y)
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def right_click_at(self, x: int, y: int) -> ComputerState:
+    """Right-click (context menu) at pixel coordinates."""
+    await self.initialize()
+    await self._page.mouse.click(x, y, button="right")
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def hover_at(self, x: int, y: int) -> ComputerState:
+    """Hover mouse (reveals tooltips and dropdowns)."""
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    await self._page.wait_for_timeout(200)
+    return await self.current_state()
+
+  async def drag_and_drop(
+    self, x: int, y: int, destination_x: int, destination_y: int
+  ) -> ComputerState:
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    await self._page.mouse.down()
+    await self._page.mouse.move(destination_x, destination_y, steps=10)
+    await self._page.mouse.up()
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  # ── Scroll ─────────────────────────────────────────────────────────────────
+
+  async def scroll_document(
+    self, direction: Literal["up", "down", "left", "right"]
+  ) -> ComputerState:
+    """Scroll the whole page by a fixed amount."""
+    await self.initialize()
+    dx, dy = self._direction_delta(direction, magnitude=700)
+    await self._page.mouse.wheel(dx=dx, dy=dy)
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def scroll_at(
+    self,
+    x: int,
+    y: int,
+    direction: Literal["up", "down", "left", "right"],
+    magnitude: int,
+  ) -> ComputerState:
+    """Scroll at a specific (x, y) coordinate (for scrollable panels)."""
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    dx, dy = self._direction_delta(direction, magnitude=abs(magnitude))
+    await self._page.mouse.wheel(dx=dx, dy=dy)
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  @staticmethod
+  def _direction_delta(
+    direction: str, magnitude: int
+  ) -> tuple[int, int]:
+    if direction == "up":
+      return 0, -magnitude
+    if direction == "down":
+      return 0, magnitude
+    if direction == "left":
+      return -magnitude, 0
+    return magnitude, 0
+
+  # ── Keyboard ───────────────────────────────────────────────────────────────
+
+  async def type_text_at(
+    self,
+    x: int,
+    y: int,
+    text: str,
+    press_enter: bool = True,
+    clear_before_typing: bool = True,
+  ) -> ComputerState:
+    """
+    Click a field, optionally clear it, then type text.
+
+    On macOS browsers Ctrl+A selects all text in web inputs correctly.
+    For native OS dialogs use key_combination(["Meta+a"]) instead.
+    """
+    await self.initialize()
+    await self._page.mouse.click(x, y)
+    await self._page.wait_for_timeout(100)
+    if clear_before_typing:
+      select_all = "Meta+A" if _IS_MACOS else "Control+A"
+      await self._page.keyboard.press(select_all)
+      await self._page.keyboard.press("Backspace")
+    await self._page.keyboard.type(text, delay=30)
+    if press_enter:
+      await self._page.keyboard.press("Enter")
+    return await self.current_state()
+
+  async def key_combination(self, keys: list[str]) -> ComputerState:
+    """
+    Press key combinations.
+
+    Each element in ``keys`` is a combo string like ``"control+c"`` or
+    ``"shift+enter"``.  Modifier names: control/ctrl, shift, alt/option,
+    meta/command/cmd.
+
+    Example: ``key_combination(["control+a", "control+c"])``
+    """
+    await self.initialize()
+    for combo in keys:
+      await self._press_combo(combo)
+    await self._page.wait_for_timeout(100)
+    return await self.current_state()
+
+  async def _press_combo(self, combo: str) -> None:
+    """Press a single key combination string (e.g. 'control+shift+t')."""
+    parts = combo.strip().lower().replace(" ", "").split("+")
+    if len(parts) == 1:
+      await self._page.keyboard.press(parts[0])
+      return
+    mods = parts[:-1]
+    key = parts[-1]
+    for m in mods:
+      pw = _MOD_MAP.get(m)
+      if pw:
+        await self._page.keyboard.down(pw)
+    await self._page.keyboard.press(key)
+    for m in reversed(mods):
+      pw = _MOD_MAP.get(m)
+      if pw:
+        await self._page.keyboard.up(pw)
+
+  # ── Waiting ────────────────────────────────────────────────────────────────
+
+  async def wait(self, seconds: int) -> ComputerState:
+    """Wait N seconds (use when page is loading dynamic content)."""
+    await self.initialize()
+    await self._page.wait_for_timeout(max(1, int(seconds)) * 1000)
+    return await self.current_state()
+
+  async def wait_for_text(self, text: str, timeout_seconds: int = 10) -> ComputerState:
+    """Wait until a specific text appears on the page."""
+    await self.initialize()
+    try:
+      await self._page.wait_for_function(
+        f"document.body.innerText.includes({repr(text)})",
+        timeout=timeout_seconds * 1000,
+      )
+    except Exception:
+      pass
+    return await self.current_state()
+
+  # ── Page inspection ────────────────────────────────────────────────────────
+
+  async def get_page_text(self) -> str:
+    """Extract all visible text from the current page (for data extraction)."""
+    await self.initialize()
+    try:
+      return await self._page.evaluate("() => document.body.innerText")
+    except Exception as e:
+      return f"(error reading page text: {e})"
+
+  async def get_page_title(self) -> str:
+    """Return the current page <title>."""
+    await self.initialize()
+    try:
+      return await self._page.title()
+    except Exception:
+      return ""
+
+  async def get_current_url(self) -> str:
+    """Return the current page URL."""
+    await self.initialize()
+    return self._page.url or ""
+
+  async def screenshot_bytes(self) -> bytes:
+    """Return the current viewport as a PNG bytes object (no action)."""
+    await self.initialize()
+    return await self._page.screenshot(type="png", full_page=False)

{gemcode-0.3.23 → gemcode-0.3.24}/src/gemcode/repl_commands.py

@@ -186,6 +186,9 @@ def slash_help_lines() -> list[str]:
       "  /mode <fast|balanced|quality|auto>  Set model selection strategy",
       "",
       "  Capabilities (all require runner rebuild — shown automatically):",
+      "  /computer             Show browser automation status (Playwright Chromium)",
+      "  /computer on|off      Enable/disable browser computer use",
+      "  /computer url         Show current browser URL",
       "  /research             Show deep-research status",
       "  /research on|off      Enable/disable Google Search + URL Context tools",
       "  /embeddings on|off    Enable/disable semantic file search (Embeddings API)",

{gemcode-0.3.23 → gemcode-0.3.24}/src/gemcode/repl_slash.py

@@ -190,7 +190,10 @@ async def process_repl_slash(
     out(f"  deep_research:  {'on  ✓' if cfg.enable_deep_research else 'off'}")
     out(f"  embeddings:     {'on  ✓' if cfg.enable_embeddings else 'off'}")
     out(f"  memory:         {'on  ✓' if cfg.enable_memory else 'off'}")
-    out(f"  computer_use:   {'on  ✓' if cfg.enable_computer_use else 'off'}")
+    _bc = getattr(cfg, "_browser_computer", None)
+    _bl = _bc is not None and getattr(_bc, "_page", None) is not None
+    out(f"  computer_use:   {'on  ✓' if cfg.enable_computer_use else 'off'}"
+        + (f"  [browser {'live' if _bl else 'ready/idle'}]" if cfg.enable_computer_use else ""))
     out(f"  maps_grounding: {'on  ✓' if cfg.enable_maps_grounding else 'off'}")
     out(f"  auto_routing:   {cfg.capability_mode}")
     out()
@@ -315,6 +318,86 @@ async def process_repl_slash(
   if name in ("exit", "quit"):
     return ReplSlashResult(exit_repl=True)
 
+  # ── /computer ────────────────────────────────────────────────────────────
+  if name in ("computer", "browser"):
+    args_s = (sc.args or "").strip().lower()
+    enabled = bool(cfg.enable_computer_use)
+    if not args_s or args_s in ("status", "show"):
+      out(f"computer_use: {'on  ✓' if enabled else 'off'}")
+      if enabled:
+        bc = getattr(cfg, "_browser_computer", None)
+        headless_env = os.environ.get("GEMCODE_COMPUTER_HEADLESS", "1").lower()
+        headless = headless_env in ("1", "true", "yes", "on")
+        out(f"  headless: {headless}")
+        w = int(os.environ.get("GEMCODE_BROWSER_WIDTH", "1280"))
+        h = int(os.environ.get("GEMCODE_BROWSER_HEIGHT", "720"))
+        out(f"  viewport: {w}×{h}")
+        out(f"  browser_initialized: {bc is not None and bc._page is not None}")
+        if bc is not None and bc._page is not None:
+          try:
+            import asyncio
+            url = asyncio.get_event_loop().run_until_complete(bc.get_current_url()) if not asyncio.get_event_loop().is_running() else "(running)"
+          except Exception:
+            url = "(check with /computer url)"
+          out(f"  model_computer_use: {cfg.model_computer_use}")
+        out()
+        out("Available slash commands:")
+        out("  /computer url     — show current browser URL")
+        out("  /computer off     — disable computer use")
+        out("  /computer show    — show browser window (GEMCODE_COMPUTER_HEADLESS=0 required at startup)")
+      else:
+        out()
+        out("Enable browser automation:")
+        out("  /computer on      — enable (rebuilds runner with Playwright Chromium)")
+        out("  GEMCODE_COMPUTER_HEADLESS=0  — show browser window (set before start)")
+        out()
+        out("Requirements: pip install playwright && playwright install chromium")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if args_s == "on":
+      cfg.enable_computer_use = True
+      out("computer_use: on — Playwright Chromium browser automation enabled")
+      out("  Runner will rebuild on the next turn to inject browser tools.")
+      out()
+      out("Browser tools available to the agent:")
+      out("  navigate, click_at, type_text_at, scroll_at, key_combination,")
+      out("  browser_screenshot, browser_get_text, browser_find_element, ...")
+      out()
+      out("Tip: set GEMCODE_COMPUTER_HEADLESS=0 to see the browser window.")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if args_s == "off":
+      cfg.enable_computer_use = False
+      out("computer_use: off")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if args_s == "url":
+      bc = getattr(cfg, "_browser_computer", None)
+      if bc is None or bc._page is None:
+        out("Browser not initialized yet. Send a message to the agent to start it.")
+      else:
+        try:
+          import asyncio
+          if asyncio.get_event_loop().is_running():
+            out("(run '/computer' to check browser status — URL read not available while async loop is running)")
+          else:
+            url = asyncio.get_event_loop().run_until_complete(bc.get_current_url())
+            title = asyncio.get_event_loop().run_until_complete(bc.get_page_title())
+            out(f"url:   {url}")
+            out(f"title: {title}")
+        except Exception as e:
+          out(f"Error reading URL: {e}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    out(f"Unknown /computer subcommand: '{args_s}'")
+    out("Usage: /computer [on|off|url|status]")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /research ────────────────────────────────────────────────────────────
   if name == "research":
     args_s = (sc.args or "").strip().lower()
@@ -475,6 +558,12 @@ async def process_repl_slash(
       out("enable_embeddings: on (runner rebuilding…)")
       out()
       return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    if args_s in ("computer", "browser"):
+      cfg.enable_computer_use = True
+      out("enable_computer_use: on (runner rebuilding…)")
+      out("Tip: set GEMCODE_COMPUTER_HEADLESS=0 before starting gemcode to see the browser window.")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
     if args_s == "all":
       cfg.enable_deep_research = True
       cfg.enable_embeddings = True