gemcode 0.4.19__tar.gz → 0.4.20__tar.gz

{gemcode-0.4.19/src/gemcode.egg-info → gemcode-0.4.20}/PKG-INFO

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

{gemcode-0.4.19 → gemcode-0.4.20}/pyproject.toml

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

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/repl_slash.py

@@ -2584,7 +2584,13 @@ async def process_repl_slash(
 
     if first in ("status", "ps"):
       running, info = is_serve_running(cfg.project_root, host=host, port=port)
-      if running and info:
+      if info and info.get("project_mismatch"):
+        out("[serve] port in use by another GemCode API (different project)")
+        out(f"  url: {info.get('url') or serve_base_url(host, port)}")
+        out(f"  this project: {info.get('expected_root') or cfg.project_root}")
+        out(f"  server root: {info.get('actual_root') or '?'}")
+        out("  Stop the other server or run `gemcode serve -C ...` for the matching folder.")
+      elif running and info:
         out("[serve] running")
         out(f"  url: {info.get('url') or serve_base_url(host, port)}")
         out(f"  project: {info.get('project_root') or cfg.project_root}")
@@ -2617,19 +2623,30 @@ async def process_repl_slash(
       session_id=session_id,
     )
     if not result.get("ok"):
-      out(f"[serve] failed: {result.get('error') or 'unknown error'}")
+      if result.get("project_mismatch"):
+        out("[serve] port 3001 is used by GemCode for a different project:")
+        out(f"  expected: {result.get('expected_root')}")
+        out(f"  actual:   {result.get('actual_root')}")
+        out("  Stop that server first, or start this project's API on another port.")
+      else:
+        out(f"[serve] failed: {result.get('error') or 'unknown error'}")
       if result.get("log"):
         out(f"  log: {result.get('log')}")
     elif result.get("already_running"):
       out(f"[serve] already running at {result.get('url')}")
     else:
-      out(f"[serve] started at {result.get('url')}")
+      if result.get("port_fallback"):
+        pref = result.get("preferred_port") or DEFAULT_SERVE_PORT
+        out(f"[serve] port {pref} was busy — started at {result.get('url')}")
+        out(f"  Set NEXT_PUBLIC_API_URL={result.get('url')} in gemcode-web-ui/.env.local")
+      else:
+        out(f"[serve] started at {result.get('url')}")
       if result.get("warming"):
         out("[serve] warming up — retry /serve status in a moment")
       if result.get("log"):
         out(f"  log: {result.get('log')}")
     out(f"[serve] session_id: {session_id}")
-    out("Open the web UI (npm run dev) — it proxies to port 3001 by default.")
+    out("Web UI: npm run dev in gemcode-web-ui → http://localhost:3002")
     out()
     return ReplSlashResult(skip_model_turn=True)
 

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/hitl_bridge.py

@@ -4,16 +4,26 @@ from __future__ import annotations
 
 import asyncio
 import json
+import os
 import time
 import uuid
 from pathlib import Path
 from typing import Any, Callable
 
 _APPROVAL_DIR = Path.home() / ".gemcode" / "web_approvals"
-_DEFAULT_TIMEOUT_S = 300.0
+_DEFAULT_TIMEOUT_S = float(os.environ.get("GEMCODE_WEB_HITL_TIMEOUT_S", "3600"))
 _POLL_INTERVAL_S = 0.25
 # approval_ids currently blocked in wait_for_web_approval (same process)
 _active_waiters: set[str] = set()
+# emitted to the UI but wait_for_web_approval not started yet (preflight)
+_pending_approval_ids: set[str] = set()
+
+
+def register_pending_approval(approval_id: str) -> None:
+  """Mark an approval as expected so early UI clicks are not reported as late."""
+  aid = (approval_id or "").strip()
+  if aid:
+    _pending_approval_ids.add(aid)
 
 
 def _approval_path(approval_id: str) -> Path:
@@ -48,7 +58,7 @@ def resolve_web_approval(approval_id: str, *, confirmed: bool) -> dict[str, Any]
   path = _approval_path(approval_id)
   payload = {"confirmed": bool(confirmed), "resolved_ms": int(time.time() * 1000)}
   path.write_text(json.dumps(payload), encoding="utf-8")
-  late = approval_id not in _active_waiters
+  late = approval_id not in _active_waiters and approval_id not in _pending_approval_ids
   return {
     "ok": True,
     "approval_id": approval_id,
@@ -73,6 +83,7 @@ async def wait_for_web_approval(
   if existing is not None:
     return existing
 
+  _pending_approval_ids.discard(approval_id)
   _active_waiters.add(approval_id)
   try:
     deadline = time.monotonic() + max(1.0, timeout_s)
@@ -93,6 +104,7 @@ async def wait_for_web_approval(
     return False
   finally:
     _active_waiters.discard(approval_id)
+    _pending_approval_ids.discard(approval_id)
 
 
 def new_approval_id(session_id: str, fc_id: str | None) -> str:

gemcode-0.4.20/src/gemcode/web/serve_bind.py

@@ -0,0 +1,106 @@
+"""Bind helpers for ``gemcode serve`` (port scan + user-facing connection hints)."""
+
+from __future__ import annotations
+
+import errno
+import os
+import socket
+from http.server import ThreadingHTTPServer
+from typing import Callable, TypeVar
+
+from gemcode.web.serve_state import DEFAULT_SERVE_PORT, serve_base_url
+
+# Next.js dev server default — skip when auto-picking an API port.
+UI_RESERVED_PORTS: frozenset[int] = frozenset({3002})
+
+HandlerFactory = TypeVar("HandlerFactory", bound=Callable[..., type])
+
+
+def iter_candidate_ports(
+  preferred: int,
+  *,
+  max_attempts: int | None = None,
+  skip: frozenset[int] = UI_RESERVED_PORTS,
+) -> list[int]:
+  """Ports to try, starting at *preferred*, skipping reserved UI ports."""
+  attempts = max_attempts
+  if attempts is None:
+    attempts = int(os.environ.get("GEMCODE_WEB_PORT_SCAN", "30"))
+  ports: list[int] = []
+  port = preferred
+  while len(ports) < attempts:
+    while port in skip:
+      port += 1
+    ports.append(port)
+    port += 1
+  return ports
+
+
+def bind_http_server(
+  host: str,
+  handler_factory: HandlerFactory,
+  preferred_port: int,
+  *,
+  max_attempts: int | None = None,
+) -> tuple[ThreadingHTTPServer, int]:
+  """Bind ``ThreadingHTTPServer``, advancing to the next port if busy."""
+  last_err: OSError | None = None
+  for port in iter_candidate_ports(preferred_port, max_attempts=max_attempts):
+    try:
+      httpd = ThreadingHTTPServer((host, port), handler_factory)
+      return httpd, port
+    except OSError as exc:
+      if exc.errno != errno.EADDRINUSE:
+        raise
+      last_err = exc
+  raise OSError(
+    errno.EADDRINUSE,
+    f"No free port near {preferred_port} after {len(iter_candidate_ports(preferred_port, max_attempts=max_attempts))} attempts",
+  ) from last_err
+
+
+def port_is_free(host: str, port: int) -> bool:
+  try:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+      sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+      sock.bind((host, port))
+    return True
+  except OSError:
+    return False
+
+
+def find_available_port(
+  host: str,
+  preferred_port: int,
+  *,
+  max_attempts: int | None = None,
+) -> int:
+  """Return the first bindable port without starting a server."""
+  for port in iter_candidate_ports(preferred_port, max_attempts=max_attempts):
+    if port_is_free(host, port):
+      return port
+  raise OSError(
+    errno.EADDRINUSE,
+    f"No free port near {preferred_port}",
+  )
+
+
+def format_connection_lines(
+  host: str,
+  actual_port: int,
+  *,
+  preferred_port: int = DEFAULT_SERVE_PORT,
+) -> list[str]:
+  """Human-readable instructions for API + web UI wiring."""
+  url = serve_base_url(host, actual_port)
+  lines: list[str] = []
+  if actual_port != preferred_port:
+    lines.append(
+      f"Port {preferred_port} is busy — GemCode API is on {url} instead."
+    )
+  else:
+    lines.append(f"GemCode API listening on {url}")
+  lines.append("Web UI: run `npm run dev` in gemcode-web-ui → http://localhost:3002")
+  lines.append(f"Point the UI at this API (gemcode-web-ui/.env.local):")
+  lines.append(f"  NEXT_PUBLIC_API_URL={url}")
+  return lines

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/serve_state.py

@@ -90,6 +90,22 @@ def is_serve_running(
 
   health = probe_health(url)
   if health and health.get("status") == "ok":
+    expected = str(project_root.expanduser().resolve())
+    raw_root = health.get("project_root") or health.get("cwd")
+    if raw_root:
+      try:
+        actual = str(Path(str(raw_root)).expanduser().resolve())
+        if actual != expected:
+          return False, {
+            "url": url,
+            "health": health,
+            "external": True,
+            "project_mismatch": True,
+            "expected_root": expected,
+            "actual_root": actual,
+          }
+      except (OSError, ValueError):
+        pass
     return True, {"url": url, "health": health, "external": True}
   return False, state
 
@@ -103,9 +119,19 @@ def start_background_serve(
 ) -> dict[str, Any]:
   root = project_root.expanduser().resolve()
   running, info = is_serve_running(root, host=host, port=port)
+  if info and info.get("project_mismatch"):
+    return {"ok": False, "project_mismatch": True, **info}
   if running:
     return {"ok": True, "already_running": True, **(info or {})}
 
+  preferred_port = port
+  try:
+    from gemcode.web.serve_bind import find_available_port
+
+    port = find_available_port(host, preferred_port)
+  except OSError as exc:
+    return {"ok": False, "error": str(exc), "preferred_port": preferred_port}
+
   log_path = root / ".gemcode" / "web-serve.log"
   log_path.parent.mkdir(parents=True, exist_ok=True)
   log_fh = open(log_path, "a", encoding="utf-8")
@@ -147,7 +173,11 @@ def start_background_serve(
         "log": str(log_path),
       }
       write_serve_state(root, payload)
-      return {"ok": True, "started": True, **payload, "health": health}
+      result = {"ok": True, "started": True, **payload, "health": health}
+      if port != preferred_port:
+        result["preferred_port"] = preferred_port
+        result["port_fallback"] = True
+      return result
   if pid_alive(proc.pid):
     payload = {
       "pid": proc.pid,
@@ -160,7 +190,11 @@ def start_background_serve(
       "warming": True,
     }
     write_serve_state(root, payload)
-    return {"ok": True, "started": True, **payload}
+    result = {"ok": True, "started": True, **payload}
+    if port != preferred_port:
+      result["preferred_port"] = preferred_port
+      result["port_fallback"] = True
+    return result
   return {
     "ok": False,
     "error": f"Server failed to start — see {log_path}",

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/server.py

@@ -6,16 +6,19 @@ import argparse
 import json
 import os
 import platform
+import queue
 import re
 import signal
 import subprocess
 import sys
 import threading
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import time
+from http.server import BaseHTTPRequestHandler
 from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
+from gemcode.web.serve_bind import bind_http_server, format_connection_lines
 from gemcode.web.serve_state import (
   clear_serve_state,
   serve_base_url,
@@ -25,6 +28,10 @@ from gemcode.web.serve_state import (
 PYTHON = sys.executable
 SERVER_VERSION = "GemCodeServe/1.0"
 
+# SSE / long-turn limits (0 = no server-side turn cap).
+_SSE_KEEPALIVE_S = float(os.environ.get("GEMCODE_WEB_SSE_KEEPALIVE_S", "20"))
+_TURN_TIMEOUT_S = float(os.environ.get("GEMCODE_WEB_TURN_TIMEOUT_S", "0"))
+
 
 def _mock_allowed() -> bool:
   return os.environ.get("GEMCODE_WEB_ALLOW_MOCK", "").lower() in (
@@ -184,6 +191,8 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
             "mock_mode": _mock_mode_active(),
             "project_root": root,
             "cwd": root,
+            "port": self.server.server_address[1],
+            "url": serve_base_url(self.server.server_address[0], self.server.server_address[1]),
           }
         ).encode()
         self.send_response(200)
@@ -436,18 +445,67 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
 
       self.send_response(200)
       self.send_header("Content-Type", "text/event-stream; charset=utf-8")
-      self.send_header("Cache-Control", "no-cache")
+      self.send_header("Cache-Control", "no-cache, no-transform")
       self.send_header("Connection", "keep-alive")
+      self.send_header("X-Accel-Buffering", "no")
       self._cors()
       self.end_headers()
 
+      try:
+        self.connection.settimeout(None)
+      except Exception:
+        pass
+
+      out_q: queue.Queue[bytes | None] = queue.Queue()
+
+      def _stdout_reader() -> None:
+        try:
+          while proc.stdout is not None:
+            chunk = proc.stdout.read(4096)
+            if not chunk:
+              break
+            out_q.put(chunk)
+        except Exception:
+          pass
+        finally:
+          out_q.put(None)
+
+      threading.Thread(target=_stdout_reader, daemon=True).start()
+
       done_re = re.compile(rb'"type"\s*:\s*"done"')
       saw_done = False
       carry = b""
+      last_activity = time.monotonic()
+      turn_deadline = (
+        time.monotonic() + _TURN_TIMEOUT_S if _TURN_TIMEOUT_S > 0 else None
+      )
       try:
         while True:
-          chunk = proc.stdout.read(4096)
-          if not chunk:
+          if turn_deadline is not None and time.monotonic() > turn_deadline:
+            proc.kill()
+            if not saw_done:
+              payload = json.dumps(
+                {
+                  "type": "error",
+                  "error": (
+                    f"Turn exceeded server limit ({int(_TURN_TIMEOUT_S)}s). "
+                    "Set GEMCODE_WEB_TURN_TIMEOUT_S=0 for no cap."
+                  ),
+                }
+              )
+              self.wfile.write(f"data: {payload}\n\n".encode())
+              self.wfile.write(b'data: {"type": "done"}\n\n')
+              self.wfile.flush()
+            break
+          try:
+            chunk = out_q.get(timeout=5.0)
+          except queue.Empty:
+            if time.monotonic() - last_activity >= _SSE_KEEPALIVE_S:
+              self.wfile.write(b": keepalive\n\n")
+              self.wfile.flush()
+              last_activity = time.monotonic()
+            continue
+          if chunk is None:
             break
           window = carry + chunk
           if not saw_done and done_re.search(window):
@@ -455,11 +513,15 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
           carry = chunk[-64:]
           self.wfile.write(chunk)
           self.wfile.flush()
+          last_activity = time.monotonic()
       except (BrokenPipeError, ConnectionResetError):
         proc.kill()
       finally:
         try:
-          proc.wait(timeout=900)
+          if _TURN_TIMEOUT_S > 0:
+            proc.wait(timeout=max(30.0, _TURN_TIMEOUT_S))
+          else:
+            proc.wait()
         except subprocess.TimeoutExpired:
           proc.kill()
           proc.wait(timeout=5)
@@ -548,7 +610,8 @@ def run_server(
     print(f"[serve] Mesh scheduler bootstrap failed: {exc}", flush=True)
 
   handler = _build_handler(str(root))
-  httpd = ThreadingHTTPServer((host, bind_port), handler)
+  preferred_port = bind_port
+  httpd, bind_port = bind_http_server(host, handler, preferred_port)
   url = serve_base_url(host, bind_port)
 
   def _shutdown(*_args: Any) -> None:
@@ -578,7 +641,12 @@ def run_server(
   print(f"Project root: {root}", flush=True)
   if session_id:
     print(f"CLI session id: {session_id}", flush=True)
-  print("Connect the web UI to this URL (Settings → API URL or NEXT_PUBLIC_API_URL).", flush=True)
+  for line in format_connection_lines(host, bind_port, preferred_port=preferred_port):
+    print(line, flush=True)
+  if _TURN_TIMEOUT_S <= 0:
+    print("[serve] Long turns: no server-side turn timeout (GEMCODE_WEB_TURN_TIMEOUT_S=0)", flush=True)
+  else:
+    print(f"[serve] Long turns: server cap {int(_TURN_TIMEOUT_S)}s (set GEMCODE_WEB_TURN_TIMEOUT_S=0 to disable)", flush=True)
   if _mock_mode_active():
     print("[serve] WARNING: mock mode active (GEMCODE_WEB_ALLOW_MOCK=1)", flush=True)
   else:

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/sessions_api.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import uuid
 from pathlib import Path
 from typing import Any
 
@@ -25,22 +26,28 @@ def handle_sessions_post(project_root: str, data: dict[str, Any]) -> tuple[int,
     return 400, {"ok": False, "error": "Invalid project root"}
 
   action = str(data.get("action") or "").strip().lower()
-  session_id = str(data.get("session_id") or "").strip()
-  if not session_id:
-    return 400, {"ok": False, "error": "session_id is required"}
 
   try:
     from gemcode.session_store import name_session, touch_session
 
+    if action == "new":
+      session_id = str(data.get("session_id") or "").strip() or uuid.uuid4().hex
+      touch_session(root, session_id)
+      return 200, {"ok": True, "session_id": session_id, "action": "new"}
+
+    session_id = str(data.get("session_id") or "").strip()
+    if not session_id:
+      return 400, {"ok": False, "error": "session_id is required"}
+
     if action in ("name", "rename"):
       name = str(data.get("name") or "").strip()
       if not name:
         return 400, {"ok": False, "error": "name is required"}
       name_session(root, session_id, name)
       return 200, {"ok": True, "session_id": session_id, "name": name}
-    if action == "touch":
+    if action in ("touch", "resume"):
       touch_session(root, session_id)
-      return 200, {"ok": True, "session_id": session_id}
+      return 200, {"ok": True, "session_id": session_id, "action": action}
     return 400, {"ok": False, "error": f"Unknown action: {action}"}
   except Exception as exc:
     return 500, {"ok": False, "error": f"{type(exc).__name__}: {exc}"}

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/sse_adapter.py

@@ -357,10 +357,11 @@ async def _resolve_web_tool_permission(
   if getattr(cfg, "yes_to_all", False) or getattr(cfg, "super_mode", False):
     return True
 
-  from gemcode.web.hitl_bridge import new_approval_id, wait_for_web_approval
+  from gemcode.web.hitl_bridge import new_approval_id, register_pending_approval, wait_for_web_approval
 
   aid = (approval_id or "").strip() or new_approval_id(session_id, fc_id or tool_name)
   already_emitted = bool((approval_id or "").strip())
+  register_pending_approval(aid)
   if not already_emitted:
     _sse_emit(
       {
@@ -590,7 +591,7 @@ async def _stream_gemcode_turn(
       if not web_hitl:
         return emitted
       try:
-        from gemcode.web.hitl_bridge import new_approval_id
+        from gemcode.web.hitl_bridge import new_approval_id, register_pending_approval
 
         for fc in event.get_function_calls() or []:
           name = getattr(fc, "name", "") or ""
@@ -603,6 +604,7 @@ async def _stream_gemcode_turn(
             continue
           hint = format_tool_call_extras(fc) or ""
           approval_id = new_approval_id(session_id, tool_id)
+          register_pending_approval(approval_id)
           preflight_approvals.append((approval_id, name, hint, tool_id))
           _sse_emit(
             {
@@ -989,11 +991,19 @@ def _apply_web_request_options(cfg: GemCodeConfig, req: dict[str, Any], workspac
       cfg.enable_memory = bool(caps.get("enable_memory"))
     if "enable_web_search" in caps:
       cfg.enable_web_search = bool(caps.get("enable_web_search"))
-    if workspace_mode != "chat":
-      if "enable_deep_research" in caps:
-        cfg.enable_deep_research = bool(caps.get("enable_deep_research"))
-      if "enable_computer_use" in caps:
-        cfg.enable_computer_use = bool(caps.get("enable_computer_use"))
+    if "enable_deep_research" in caps:
+      cfg.enable_deep_research = bool(caps.get("enable_deep_research"))
+    if "enable_computer_use" in caps:
+      cfg.enable_computer_use = bool(caps.get("enable_computer_use"))
+    if "enable_embeddings" in caps:
+      cfg.enable_embeddings = bool(caps.get("enable_embeddings"))
+    if "enable_maps_grounding" in caps:
+      cfg.enable_maps_grounding = bool(caps.get("enable_maps_grounding"))
+    if "enable_code_executor" in caps:
+      cfg.enable_code_executor = bool(caps.get("enable_code_executor"))
+    cap_mode = caps.get("capability_mode")
+    if isinstance(cap_mode, str) and cap_mode.strip():
+      cfg.capability_mode = cap_mode.strip().lower()
     if bool(caps.get("proposal_mode")):
       object.__setattr__(cfg, "ide_proposal_mode", True)
       object.__setattr__(cfg, "ide_allow_write", True)
@@ -1021,6 +1031,17 @@ def _apply_web_request_options(cfg: GemCodeConfig, req: dict[str, Any], workspac
     except (TypeError, ValueError):
       pass
 
+  thinking_budget = req.get("thinking_budget")
+  if thinking_budget is not None:
+    try:
+      cfg.thinking_budget = int(thinking_budget)
+    except (TypeError, ValueError):
+      pass
+
+  thinking_level = req.get("thinking_level")
+  if isinstance(thinking_level, str) and thinking_level.strip():
+    cfg.thinking_level = thinking_level.strip().lower()
+
   return workspace_mode
 
 
@@ -1071,6 +1092,8 @@ async def run_adapter(req: dict[str, Any]) -> None:
     caps = req.get("capabilities")
     chat_research = isinstance(caps, dict) and bool(caps.get("enable_deep_research"))
     chat_computer = isinstance(caps, dict) and bool(caps.get("enable_computer_use"))
+    chat_embeddings = isinstance(caps, dict) and bool(caps.get("enable_embeddings"))
+    chat_maps = isinstance(caps, dict) and bool(caps.get("enable_maps_grounding"))
     if not chat_research:
       try:
         cfg.enable_deep_research = False
@@ -1082,6 +1105,16 @@ async def run_adapter(req: dict[str, Any]) -> None:
         cfg.enable_computer_use = False
       except Exception:
         pass
+    if not chat_embeddings:
+      try:
+        cfg.enable_embeddings = False
+      except Exception:
+        pass
+    if not chat_maps:
+      try:
+        cfg.enable_maps_grounding = False
+      except Exception:
+        pass
 
   workspace_mode = _apply_web_request_options(cfg, req, workspace_mode)
 

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/terminal_api.py

@@ -11,10 +11,9 @@ from typing import Any
 
 from gemcode.config import GemCodeConfig
 from gemcode.session_runtime import create_runner
-from gemcode.web.terminal_repl import run_mock_turn, run_single_turn
-
-
 from gemcode.web.project_root import resolve_web_project_root
+from gemcode.web.sse_adapter import _apply_web_permissions, _ensure_web_hitl
+from gemcode.web.terminal_repl import run_mock_turn, run_single_turn
 
 
 def _resolve_root(raw_path: str) -> Path:
@@ -27,18 +26,23 @@ async def _terminal_turn_async(
   prompt: str,
   session_id: str,
   user_id: str,
+  permissions: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
   from gemcode.cli import _initialize_gemcode_project
 
   cfg = GemCodeConfig(project_root=project_root)
   cfg.permission_mode = os.environ.get("GEMCODE_PERMISSION_MODE", cfg.permission_mode)
-  cfg.yes_to_all = os.environ.get("GEMCODE_WEB_YES_TO_ALL", "true").lower() in (
-    "1",
-    "true",
-    "yes",
-    "on",
-  )
+  cfg.yes_to_all = False
   cfg.interactive_permission_ask = False
+  object.__setattr__(cfg, "_gemcode_web_sse", False)
+  if isinstance(permissions, dict):
+    _apply_web_permissions(cfg, {"permissions": permissions})
+  _ensure_web_hitl(cfg)
+  # Terminal is one-shot (no SSE HITL bridge) — respect explicit auto-approve only.
+  if getattr(cfg, "_web_interactive_hitl", False):
+    cfg.yes_to_all = False
+    cfg.interactive_permission_ask = False
+    object.__setattr__(cfg, "_web_interactive_hitl", False)
   _initialize_gemcode_project(cfg)
 
   buf = io.StringIO()
@@ -76,6 +80,7 @@ def handle_terminal_post(data: dict[str, Any], raw_path: str) -> tuple[int, dict
 
   session_id = str(data.get("session_id") or "web-terminal")
   user_id = str(data.get("user_id") or "web-terminal")
+  permissions = data.get("permissions") if isinstance(data.get("permissions"), dict) else None
 
   if not os.environ.get("GEMCODE_WEB_MOCK_RESPONSE") and not (
     os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
@@ -87,7 +92,13 @@ def handle_terminal_post(data: dict[str, Any], raw_path: str) -> tuple[int, dict
 
   try:
     payload = asyncio.run(
-      _terminal_turn_async(root, prompt=prompt, session_id=session_id, user_id=user_id)
+      _terminal_turn_async(
+        root,
+        prompt=prompt,
+        session_id=session_id,
+        user_id=user_id,
+        permissions=permissions,
+      )
     )
     return 200, payload
   except Exception as exc:

{gemcode-0.4.19 → gemcode-0.4.20}/src/gemcode/web/workspace_panel_api.py

@@ -44,6 +44,12 @@ def handle_panel_get(
       lines = _format_status_lines(cfg, session_id=session_id)
       return 200, {"ok": True, "kind": k, "lines": lines, "text": "\n".join(lines)}
 
+    if k == "tools":
+      from gemcode.repl_commands import format_tools_lines
+
+      lines = format_tools_lines(cfg)
+      return 200, {"ok": True, "kind": k, "lines": lines, "text": "\n".join(lines)}
+
     if k == "hooks":
       from gemcode.repl_commands import format_hooks_lines
 

{gemcode-0.4.19 → gemcode-0.4.20/src/gemcode.egg-info}/PKG-INFO

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