gemcode 0.4.21__tar.gz → 0.4.22__tar.gz

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

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

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

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

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

@@ -252,6 +252,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("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)"),

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

@@ -2683,6 +2683,34 @@ async def process_repl_slash(
     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.21 → gemcode-0.4.22}/src/gemcode/web/server.py

@@ -250,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",
@@ -353,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:
@@ -374,6 +407,9 @@ 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)

{gemcode-0.4.21 → 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")

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

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

{gemcode-0.4.21 → 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,6 +167,7 @@ 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

gemcode-0.4.22/tests/test_files_api.py

@@ -0,0 +1,54 @@
+"""Tests for workspace files API."""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from gemcode.web.files_api import (
+  handle_files_read_get,
+  handle_files_tree_get,
+  handle_files_write_post,
+)
+
+
+@pytest.fixture
+def workspace(tmp_path: Path) -> Path:
+  (tmp_path / "hello.txt").write_text("hi\n", encoding="utf-8")
+  (tmp_path / "src").mkdir()
+  (tmp_path / "src" / "main.py").write_text("print('ok')\n", encoding="utf-8")
+  return tmp_path
+
+
+def test_files_tree_lists_workspace(workspace: Path) -> None:
+  status, payload = handle_files_tree_get(str(workspace))
+  assert status == 200
+  names = {n["name"] for n in payload["tree"]}
+  assert "hello.txt" in names
+  assert "src" in names
+
+
+def test_files_read_and_write(workspace: Path) -> None:
+  status, payload = handle_files_read_get(str(workspace), "hello.txt")
+  assert status == 200
+  assert payload["content"] == "hi\n"
+
+  status, payload = handle_files_write_post(
+    {"path": "new.md", "content": "# test"},
+    str(workspace),
+  )
+  assert status == 200
+  assert payload["ok"] is True
+  assert (workspace / "new.md").read_text(encoding="utf-8") == "# test"
+
+
+def test_files_reject_path_outside_hosted_root(
+  workspace: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+  outside = tempfile.mkdtemp()
+  monkeypatch.setenv("GEMCODE_HOSTED_TENANT_ROOT", str(workspace))
+  status, payload = handle_files_read_get(str(workspace), f"../{Path(outside).name}/x")
+  assert status == 403