gemcode 0.4.20__tar.gz → 0.4.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.20
+Version: 0.4.22
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -221,6 +221,7 @@ All state lives under `.gemcode/` in the project root. No external services requ
 | Agent Mesh | In-process multi-agent orchestration (automatic) |
 | GemCode Runtime | Optional always-on background scheduler (`gemcode runtime`; alias `gemcode kaira`) |
 | HTTP API (`gemcode serve`) | Built-in web/custom UI backend on `http://127.0.0.1:3001` — chat SSE, sessions, panel, HITL |
+| Hosted multi-tenant | One `gemcode serve` per user with `GEMCODE_HOSTED_TENANT_ROOT` — see [`../docs/hosted.md`](../docs/hosted.md) |
 | A2A server | Cross-machine agent communication via Google A2A protocol |
 | Live audio (experimental) | Microphone-driven Gemini Live sessions |
 

{gemcode-0.4.20 → gemcode-0.4.22}/README.md

@@ -28,6 +28,7 @@ All state lives under `.gemcode/` in the project root. No external services requ
 | Agent Mesh | In-process multi-agent orchestration (automatic) |
 | GemCode Runtime | Optional always-on background scheduler (`gemcode runtime`; alias `gemcode kaira`) |
 | HTTP API (`gemcode serve`) | Built-in web/custom UI backend on `http://127.0.0.1:3001` — chat SSE, sessions, panel, HITL |
+| Hosted multi-tenant | One `gemcode serve` per user with `GEMCODE_HOSTED_TENANT_ROOT` — see [`../docs/hosted.md`](../docs/hosted.md) |
 | A2A server | Cross-machine agent communication via Google A2A protocol |
 | Live audio (experimental) | Microphone-driven Gemini Live sessions |
 

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

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

{gemcode-0.4.20 → gemcode-0.4.22}/src/gemcode/repl_commands.py

@@ -251,6 +251,8 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("kaira",       "Background jobs — gemcode runtime (alias: gemcode kaira)"),
     ("runtime",     "Fleet socket status · gemcode runtime · attach/connect"),
     ("serve",       "HTTP API for web/custom UIs — gemcode serve on :3001"),
+    ("hosted",      "Hosted multi-tenant lock — GEMCODE_HOSTED_TENANT_ROOT status"),
+    ("workspace",   "Workspace root + hosted file API routes"),
     ("bus",         "Runtime bus — send/publish lightweight messages over IPC"),
     ("inbox",       "Bus inbox filters for this UI (to/topics)"),
     ("fleet",       "Fleet inbox — /fleet show | digest (habits / mesh reports)"),
@@ -413,6 +415,7 @@ def slash_help_lines() -> list[str]:
       "  /live-audio           How to run gemcode live-audio (mic → Gemini Live)",
       "  /doctor               Environment sanity check",
       "  /serve [start|status|stop|url]  Start HTTP API for web UI (gemcode serve on :3001)",
+      "  /hosted [status]                Hosted tenant lock (GEMCODE_HOSTED_TENANT_ROOT)",
       "  /version              Print GemCode version hint",
       "  /exit                 Exit the REPL",
       "",

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

@@ -2650,6 +2650,67 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /hosted (multi-tenant serve lock) ───────────────────────────────────
+  if name == "hosted":
+    from gemcode.web.project_root import hosted_tenant_root
+
+    args_h = (sc.args or "").strip().lower()
+    first_h = args_h.split()[0] if args_h else "status"
+
+    if first_h in ("help", "?"):
+      out("Hosted multi-tenant mode (one workspace per gemcode serve process):")
+      out("  /hosted             Show lock status")
+      out("  /hosted status      Same")
+      out("")
+      out("Set GEMCODE_HOSTED_TENANT_ROOT to the tenant workspace path.")
+      out("Web API then rejects client path/project_root outside that directory.")
+      out("HITL approvals use {workspace}/.gemcode/web_approvals.")
+      out("")
+      out("Deployment guide: docs/hosted.md and deploy/gcp/ in the repo.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    locked = hosted_tenant_root()
+    if locked is not None:
+      out("[hosted] active — tenant workspace locked")
+      out(f"  GEMCODE_HOSTED_TENANT_ROOT={locked}")
+      out(f"  project_root: {cfg.project_root}")
+      out("  Client path params must stay inside the tenant root (HTTP 403 otherwise).")
+    else:
+      out("[hosted] not active (local mode)")
+      out("  Client path / project_root query params are honored.")
+      out("  Set GEMCODE_HOSTED_TENANT_ROOT in containers for multi-tenant hosting.")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
+  # ── /workspace (hosted tenant + file API) ───────────────────────────────
+  if name == "workspace":
+    from gemcode.web.project_root import hosted_tenant_root
+
+    args_w = (sc.args or "").strip().lower()
+    if args_w in ("help", "?"):
+      out("Workspace / hosted tenant:")
+      out("  /workspace          Show active workspace root and hosted lock")
+      out("  /workspace files    File API routes on gemcode serve")
+      out("")
+      out("Hosted tenants use /api/files, /api/files/read, /api/files/write on gemcode serve.")
+      out("See docs/hosted.md")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    locked = hosted_tenant_root()
+    out(f"  project_root: {cfg.project_root.resolve()}")
+    if locked is not None:
+      out(f"  hosted lock:  {locked}")
+    else:
+      out("  hosted lock:  (not set — local mode)")
+    if args_w == "files":
+      out("  GET  /api/files           — file tree")
+      out("  GET  /api/files/read      — read file")
+      out("  POST /api/files/write     — write file")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /runtime ────────────────────────────────────────────────────────────
   if name == "runtime":
     from gemcode.kaira_ipc import fleet_manager_ipc_path_for_workspace

gemcode-0.4.22/src/gemcode/web/files_api.py

@@ -0,0 +1,280 @@
+"""Workspace file browser API for web UIs (local and hosted tenants)."""
+
+from __future__ import annotations
+
+import base64
+import json
+import mimetypes
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from gemcode.web.project_root import HostedTenantPathError, resolve_web_project_root
+
+ALWAYS_HIDDEN = {
+  ".git",
+  "node_modules",
+  ".next",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".DS_Store",
+  "Thumbs.db",
+}
+
+MAX_READ_BYTES = 10 * 1024 * 1024
+MAX_WRITE_BYTES = 5 * 1024 * 1024
+MAX_TREE_DEPTH = 8
+
+
+def _resolve_root(raw_path: str | None) -> Path:
+  return resolve_web_project_root(raw_path)
+
+
+def _resolve_under_root(root: Path, relative: str) -> Path:
+  rel = (relative or "").strip().lstrip("/")
+  candidate = (root / rel).resolve()
+  try:
+    candidate.relative_to(root.resolve())
+  except ValueError as exc:
+    raise HostedTenantPathError(f"path is outside workspace: {candidate}") from exc
+  return candidate
+
+
+def _git_status_map(root: Path) -> dict[str, str]:
+  try:
+    proc = subprocess.run(
+      ["git", "status", "--porcelain", "-u"],
+      cwd=str(root),
+      capture_output=True,
+      text=True,
+      timeout=5,
+      check=False,
+    )
+  except (OSError, subprocess.TimeoutExpired):
+    return {}
+  out: dict[str, str] = {}
+  for line in (proc.stdout or "").splitlines():
+    if not line:
+      continue
+    xy = line[:2].strip()
+    file_path = line[3:].strip().strip('"')
+    if not xy or not file_path:
+      continue
+    status = xy[0] if xy[0] not in (" ", "?") else xy[1] if xy[1] != " " else "?"
+    out[file_path] = "?" if status == "?" else status
+  return out
+
+
+def _ignore_patterns(root: Path) -> list[str]:
+  p = root / ".gitignore"
+  if not p.is_file():
+    return []
+  try:
+    lines = p.read_text(encoding="utf-8", errors="replace").splitlines()
+  except OSError:
+    return []
+  return [ln.strip() for ln in lines if ln.strip() and not ln.strip().startswith("#")]
+
+
+def _matches_ignore(name: str, patterns: list[str]) -> bool:
+  for pattern in patterns:
+    p = pattern[1:] if pattern.startswith("/") else pattern
+    if p == name:
+      return True
+    if p.endswith("/") and p[:-1] == name:
+      return True
+    if "*" in p:
+      import re
+
+      rx = "^" + re.escape(p).replace(r"\*", "[^/]*") + "$"
+      if re.match(rx, name):
+        return True
+  return False
+
+
+def _build_tree(
+  dir_path: Path,
+  root: Path,
+  *,
+  git_map: dict[str, str],
+  ignore_patterns: list[str],
+  show_ignored: bool,
+  depth: int = 0,
+) -> list[dict[str, Any]]:
+  if depth > MAX_TREE_DEPTH:
+    return []
+  try:
+    entries = sorted(dir_path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+  except OSError:
+    return []
+  nodes: list[dict[str, Any]] = []
+  for entry in entries:
+    name = entry.name
+    if name in ALWAYS_HIDDEN:
+      continue
+    if not show_ignored and _matches_ignore(name, ignore_patterns):
+      continue
+    if not show_ignored and name.startswith(".") and name != ".env.example":
+      continue
+    rel = entry.relative_to(root).as_posix()
+    git_status = git_map.get(rel)
+    if entry.is_dir():
+      children = _build_tree(
+        entry,
+        root,
+        git_map=git_map,
+        ignore_patterns=ignore_patterns,
+        show_ignored=show_ignored,
+        depth=depth + 1,
+      )
+      nodes.append(
+        {
+          "name": name,
+          "path": rel,
+          "type": "directory",
+          "children": children,
+          "gitStatus": git_status,
+        }
+      )
+    elif entry.is_file():
+      nodes.append(
+        {
+          "name": name,
+          "path": rel,
+          "type": "file",
+          "gitStatus": git_status,
+        }
+      )
+  return nodes
+
+
+def handle_files_tree_get(
+  raw_path: str | None,
+  *,
+  cwd: str = "",
+  show_ignored: bool = False,
+) -> tuple[int, dict[str, Any]]:
+  try:
+    root = _resolve_root(raw_path)
+  except HostedTenantPathError as exc:
+    return 403, {"error": str(exc)}
+  if not root.is_dir():
+    return 400, {"error": "workspace is not a directory"}
+  try:
+    resolved_cwd = _resolve_under_root(root, cwd)
+  except HostedTenantPathError as exc:
+    return 403, {"error": str(exc)}
+  if not resolved_cwd.is_dir():
+    return 400, {"error": "Invalid cwd"}
+
+  git_map = _git_status_map(root)
+  ignore_patterns = _ignore_patterns(root)
+  tree = _build_tree(
+    resolved_cwd,
+    root,
+    git_map=git_map,
+    ignore_patterns=ignore_patterns,
+    show_ignored=show_ignored,
+  )
+  rel = resolved_cwd.relative_to(root)
+  segments = [] if str(rel) == "." else str(rel).split("/")
+  breadcrumbs = [root.name or str(root), *segments]
+  breadcrumb_rels = [""] + [
+    "/".join(segments[: i + 1]) for i in range(len(segments))
+  ]
+  return 200, {
+    "tree": tree,
+    "root": str(root),
+    "cwd": cwd,
+    "breadcrumbs": breadcrumbs,
+    "breadcrumbRels": breadcrumb_rels,
+  }
+
+
+def handle_files_read_get(
+  raw_path: str | None,
+  file_path: str,
+) -> tuple[int, dict[str, Any]]:
+  if not file_path.strip():
+    return 400, {"error": "path parameter required"}
+  try:
+    root = _resolve_root(raw_path)
+    resolved = _resolve_under_root(root, file_path)
+  except HostedTenantPathError as exc:
+    return 403, {"error": str(exc)}
+  if not resolved.is_file():
+    return 404 if not resolved.exists() else 400, {"error": "path is not a file"}
+  try:
+    size = resolved.stat().st_size
+  except OSError as exc:
+    return 404, {"error": str(exc)}
+  if size > MAX_READ_BYTES:
+    return 413, {"error": f"File exceeds maximum readable size ({MAX_READ_BYTES // 1024 // 1024} MB)"}
+
+  ext = resolved.suffix.lower().lstrip(".")
+  mime, _ = mimetypes.guess_type(str(resolved))
+
+  if ext in ("docx", "doc", "pdf"):
+    data = base64.b64encode(resolved.read_bytes()).decode("ascii")
+    kind = "pdf" if ext == "pdf" else "docx"
+    return 200, {
+      "content": data,
+      "isImage": False,
+      "kind": kind,
+      "mimeType": mime or "application/octet-stream",
+      "size": size,
+      "modified": resolved.stat().st_mtime,
+    }
+
+  if ext in ("png", "jpg", "jpeg", "gif", "webp", "bmp", "ico"):
+    mime = mime or f"image/{ext}"
+    data = base64.b64encode(resolved.read_bytes()).decode("ascii")
+    return 200, {
+      "content": f"data:{mime};base64,{data}",
+      "isImage": True,
+      "size": size,
+      "modified": resolved.stat().st_mtime,
+    }
+
+  try:
+    probe = resolved.read_bytes()[:512]
+    if b"\x00" in probe:
+      return 415, {"error": "Binary file cannot be read as text"}
+    content = resolved.read_text(encoding="utf-8")
+  except OSError as exc:
+    return 404, {"error": str(exc)}
+  except UnicodeDecodeError:
+    return 415, {"error": "Binary file cannot be read as text"}
+
+  return 200, {
+    "content": content,
+    "isImage": ext == "svg",
+    "size": size,
+    "modified": resolved.stat().st_mtime,
+  }
+
+
+def handle_files_write_post(data: dict[str, Any], raw_path: str | None) -> tuple[int, dict[str, Any]]:
+  file_path = str(data.get("path") or "").strip()
+  if not file_path:
+    return 400, {"ok": False, "error": "path is required"}
+  content = data.get("content")
+  if content is None:
+    content = ""
+  if not isinstance(content, str):
+    return 400, {"ok": False, "error": "content must be a string"}
+  if len(content.encode("utf-8")) > MAX_WRITE_BYTES:
+    return 413, {"ok": False, "error": "content too large"}
+  try:
+    root = _resolve_root(raw_path)
+    resolved = _resolve_under_root(root, file_path)
+  except HostedTenantPathError as exc:
+    return 403, {"ok": False, "error": str(exc)}
+  try:
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+    resolved.write_text(content, encoding="utf-8")
+  except OSError as exc:
+    return 500, {"ok": False, "error": str(exc)}
+  return 200, {"ok": True, "path": file_path}

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

@@ -10,7 +10,11 @@ import uuid
 from pathlib import Path
 from typing import Any, Callable
 
-_APPROVAL_DIR = Path.home() / ".gemcode" / "web_approvals"
+def _approval_dir() -> Path:
+  tenant = os.environ.get("GEMCODE_HOSTED_TENANT_ROOT", "").strip()
+  if tenant:
+    return Path(tenant).expanduser().resolve() / ".gemcode" / "web_approvals"
+  return Path.home() / ".gemcode" / "web_approvals"
 _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)
@@ -28,7 +32,7 @@ def register_pending_approval(approval_id: str) -> None:
 
 def _approval_path(approval_id: str) -> Path:
   safe = "".join(c if c.isalnum() or c in "-_:" else "_" for c in approval_id)
-  return _APPROVAL_DIR / f"{safe}.json"
+  return _approval_dir() / f"{safe}.json"
 
 
 def _read_approval_file(path: Path) -> bool | None:
@@ -54,7 +58,7 @@ def resolve_web_approval(approval_id: str, *, confirmed: bool) -> dict[str, Any]
   """Record the user's approve/deny decision (called from HTTP handler)."""
   if not approval_id.strip():
     return {"ok": False, "error": "approval_id is required"}
-  _APPROVAL_DIR.mkdir(parents=True, exist_ok=True)
+  _approval_dir().mkdir(parents=True, exist_ok=True)
   path = _approval_path(approval_id)
   payload = {"confirmed": bool(confirmed), "resolved_ms": int(time.time() * 1000)}
   path.write_text(json.dumps(payload), encoding="utf-8")
@@ -75,7 +79,7 @@ async def wait_for_web_approval(
   heartbeat_s: float = 15.0,
 ) -> bool:
   """Block until the user approves/denies or timeout (deny on timeout)."""
-  _APPROVAL_DIR.mkdir(parents=True, exist_ok=True)
+  _approval_dir().mkdir(parents=True, exist_ok=True)
   path = _approval_path(approval_id)
 
   # User may have approved before we started waiting (preflight UI is immediate).

gemcode-0.4.22/src/gemcode/web/project_root.py

@@ -0,0 +1,60 @@
+"""Shared workspace path resolution for GemCode web HTTP handlers."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+class HostedTenantPathError(ValueError):
+  """Client requested a path outside the locked tenant workspace."""
+
+
+def hosted_tenant_root() -> Path | None:
+  """When set, web handlers are locked to this directory (multi-tenant hosting)."""
+  raw = os.environ.get("GEMCODE_HOSTED_TENANT_ROOT", "").strip()
+  if not raw:
+    return None
+  return Path(raw).expanduser().resolve()
+
+
+def _is_within_root(root: Path, candidate: Path) -> bool:
+  try:
+    candidate.resolve().relative_to(root.resolve())
+    return True
+  except ValueError:
+    return False
+
+
+def resolve_web_project_root(raw_path: str | None) -> Path:
+  """
+  Resolve the active project/workspace root for a web API request.
+
+  Prefers an explicit ``path`` query/body param, then ``GEMCODE_WEB_PROJECT_ROOT``,
+  then the API process working directory.
+
+  When ``GEMCODE_HOSTED_TENANT_ROOT`` is set (hosted multi-tenant mode), client
+  paths must stay inside that root; otherwise the locked root is always used.
+  """
+  locked = hosted_tenant_root()
+  if locked is not None:
+    if raw_path and str(raw_path).strip():
+      candidate = Path(str(raw_path).strip()).expanduser().resolve()
+      if not _is_within_root(locked, candidate):
+        raise HostedTenantPathError(
+          f"path is outside tenant workspace: {candidate} (root={locked})"
+        )
+      return candidate
+    return locked
+
+  if raw_path and str(raw_path).strip():
+    return Path(str(raw_path).strip()).expanduser().resolve()
+  env = os.environ.get("GEMCODE_WEB_PROJECT_ROOT", "").strip()
+  if env:
+    return Path(env).expanduser().resolve()
+  return Path.cwd().resolve()
+
+
+def resolve_sse_project_root(raw_path: str | None) -> Path:
+  """Same rules as :func:`resolve_web_project_root` for SSE chat subprocess."""
+  return resolve_web_project_root(raw_path)

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

@@ -18,6 +18,7 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
+from gemcode.web.project_root import HostedTenantPathError
 from gemcode.web.serve_bind import bind_http_server, format_connection_lines
 from gemcode.web.serve_state import (
   clear_serve_state,
@@ -182,8 +183,10 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
         except Exception:
           pass
         has_key = bool(os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY"))
-        body = json.dumps(
-          {
+        from gemcode.web.project_root import hosted_tenant_root
+
+        locked = hosted_tenant_root()
+        health: dict[str, Any] = {
             "status": "ok",
             "service": "gemcode-serve",
             "gemcode": True,
@@ -193,8 +196,11 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
             "cwd": root,
             "port": self.server.server_address[1],
             "url": serve_base_url(self.server.server_address[0], self.server.server_address[1]),
-          }
-        ).encode()
+        }
+        if locked is not None:
+          health["hosted_mode"] = True
+          health["hosted_tenant_root"] = str(locked)
+        body = json.dumps(health).encode()
         self.send_response(200)
         self.send_header("Content-Type", "application/json; charset=utf-8")
         self.send_header("Content-Length", str(len(body)))
@@ -244,6 +250,38 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
         return
 
       parsed = urlparse(self.path)
+      if parsed.path in ("/api/files", "/api/files/read"):
+        params = parse_qs(parsed.query)
+        raw_path = (params.get("path") or [root])[0]
+        try:
+          from gemcode.web.files_api import handle_files_read_get, handle_files_tree_get
+
+          if parsed.path == "/api/files/read":
+            file_path = (params.get("path") or [""])[0]
+            ws = (params.get("root") or [root])[0]
+            status, payload = handle_files_read_get(ws, file_path)
+          else:
+            cwd = (params.get("cwd") or [""])[0]
+            show_ignored = (params.get("showIgnored") or ["false"])[0].lower() == "true"
+            ws = (params.get("root") or [root])[0]
+            status, payload = handle_files_tree_get(
+              ws,
+              cwd=cwd,
+              show_ignored=show_ignored,
+            )
+        except HostedTenantPathError as exc:
+          status, payload = 403, {"error": str(exc)}
+        except Exception as exc:
+          status, payload = 500, {"error": f"{type(exc).__name__}: {exc}"}
+        body = json.dumps(payload, default=str).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self._cors()
+        self.end_headers()
+        self.wfile.write(body)
+        return
+
       fleet_get = {
         "/api/org": "org",
         "/api/habits": "habits",
@@ -347,6 +385,7 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
         "/api/settings/credentials": ("gemcode.web.customize_api", "handle_credentials_post"),
         "/api/runtime": ("gemcode.web.runtime_api", "handle_runtime_post"),
         "/api/terminal": ("gemcode.web.terminal_api", "handle_terminal_post"),
+        "/api/files/write": ("gemcode.web.files_api", "handle_files_write_post"),
       }
 
       if self.path in post_routes:
@@ -368,9 +407,15 @@ def _build_handler(project_root: str) -> type[BaseHTTPRequestHandler]:
           elif self.path == "/api/sessions":
             raw_path = str(data.get("path") or root).strip()
             status, payload = handler(raw_path, data)
+          elif self.path == "/api/files/write":
+            raw_path = str(data.get("root") or data.get("path") or root).strip()
+            status, payload = handler(data, raw_path)
           else:
             raw_path = str(data.get("path") or root).strip()
             status, payload = handler(data, raw_path)
+        except HostedTenantPathError as exc:
+          payload = {"ok": False, "error": str(exc)}
+          status = 403
         except Exception as exc:
           payload = {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
           status = 500

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

@@ -1048,7 +1048,7 @@ def _apply_web_request_options(cfg: GemCodeConfig, req: dict[str, Any], workspac
 async def run_adapter(req: dict[str, Any]) -> None:
   messages = req.get("messages")
   requested_model = req.get("model")
-  model = requested_model or os.environ.get("GEMCODE_MODEL") or "gemini-2.5-flash"
+  model = requested_model or os.environ.get("GEMCODE_MODEL") or "gemini-3.1-pro-preview"
 
   if not isinstance(messages, list):
     raise ValueError("messages must be a list")
@@ -1061,14 +1061,17 @@ async def run_adapter(req: dict[str, Any]) -> None:
   if not prompt.strip():
     raise ValueError("No user message in request")
 
+  from gemcode.web.project_root import HostedTenantPathError, resolve_sse_project_root
+
   req_root = req.get("project_root")
-  if isinstance(req_root, str) and req_root.strip():
-    project_root = req_root.strip()
-  else:
-    project_root = os.environ.get("GEMCODE_WEB_PROJECT_ROOT") or os.getcwd()
-  root_path = Path(project_root).expanduser()
+  raw_root = req_root.strip() if isinstance(req_root, str) and req_root.strip() else None
+  try:
+    root_path = resolve_sse_project_root(raw_root)
+  except HostedTenantPathError as exc:
+    raise ValueError(str(exc)) from exc
   if not root_path.is_dir():
-    raise ValueError(f"project_root is not a directory: {project_root}")
+    raise ValueError(f"project_root is not a directory: {root_path}")
+  project_root = str(root_path)
   from gemcode.org import resolve_fleet_root
 
   fleet_root = resolve_fleet_root(root_path.resolve())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.20
+Version: 0.4.22
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -221,6 +221,7 @@ All state lives under `.gemcode/` in the project root. No external services requ
 | Agent Mesh | In-process multi-agent orchestration (automatic) |
 | GemCode Runtime | Optional always-on background scheduler (`gemcode runtime`; alias `gemcode kaira`) |
 | HTTP API (`gemcode serve`) | Built-in web/custom UI backend on `http://127.0.0.1:3001` — chat SSE, sessions, panel, HITL |
+| Hosted multi-tenant | One `gemcode serve` per user with `GEMCODE_HOSTED_TENANT_ROOT` — see [`../docs/hosted.md`](../docs/hosted.md) |
 | A2A server | Cross-machine agent communication via Google A2A protocol |
 | Live audio (experimental) | Microphone-driven Gemini Live sessions |
 

{gemcode-0.4.20 → gemcode-0.4.22}/src/gemcode.egg-info/SOURCES.txt

@@ -135,6 +135,7 @@ src/gemcode/tui/welcome_rich.py
 src/gemcode/web/__init__.py
 src/gemcode/web/chat_skills.py
 src/gemcode/web/customize_api.py
+src/gemcode/web/files_api.py
 src/gemcode/web/fleet_api.py
 src/gemcode/web/hitl_bridge.py
 src/gemcode/web/preview_api.py
@@ -166,7 +167,9 @@ tests/test_context_warning.py
 tests/test_credentials.py
 tests/test_eval_harness_layout.py
 tests/test_event_bus.py
+tests/test_files_api.py
 tests/test_fleet_reports.py
+tests/test_hosted_tenant.py
 tests/test_ide_stdio_attachments.py
 tests/test_interactive_permission_ask.py
 tests/test_kaira_ipc_paths.py