localcode 0.3.63__tar.gz → 0.3.64__tar.gz

{localcode-0.3.63/src/localcode.egg-info → localcode-0.3.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.63
+Version: 0.3.64
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.63 → localcode-0.3.64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.63"
+version = "0.3.64"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.63 → localcode-0.3.64}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.3.63"
+    __version__ = "0.3.64"

{localcode-0.3.63 → localcode-0.3.64}/src/localcode/mcp/__init__.py

@@ -51,7 +51,13 @@ is re-exported here so `from localcode.mcp import ...` is unchanged.
 from __future__ import annotations
 
 from ._bridge import _CONNECT_TIMEOUT, _DEFAULT_TIMEOUT, _EventLoopThread
-from ._config import MCP_CONFIG_PATH, _config_path, load_mcp_config
+from ._config import (
+    MCP_CONFIG_PATH,
+    _config_path,
+    add_mcp_server,
+    load_mcp_config,
+    remove_mcp_server,
+)
 from ._transports import _InMemoryTokenStorage, _build_oauth_provider
 from .client import (
     MCPClient,
@@ -72,6 +78,8 @@ __all__ = [
     # config
     "MCP_CONFIG_PATH",
     "load_mcp_config",
+    "add_mcp_server",
+    "remove_mcp_server",
     # client
     "MCPClient",
     # registry

localcode-0.3.64/src/localcode/mcp/_config.py

@@ -0,0 +1,79 @@
+"""Config loading for the MCP package.
+
+Reads `~/.localcode/mcp.json` (key `mcpServers`), honoring LOCALCODE_HOME
+like the rest of the app.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+MCP_CONFIG_PATH = Path.home() / ".localcode" / "mcp.json"
+
+
+def _config_path() -> Path:
+    """Resolve the mcp.json path, honoring LOCALCODE_HOME like the rest of
+    the app (config.get_home_dir). Falls back to ~/.localcode."""
+    override = os.environ.get("LOCALCODE_HOME")
+    if override:
+        return Path(override).expanduser() / "mcp.json"
+    return MCP_CONFIG_PATH
+
+
+def load_mcp_config() -> dict[str, dict]:
+    """Read ~/.localcode/mcp.json. Returns the `mcpServers` dict."""
+    path = _config_path()
+    if not path.is_file():
+        return {}
+    try:
+        return json.loads(path.read_text()).get("mcpServers", {})
+    except Exception:
+        return {}
+
+
+def _read_full_config(path: Path) -> dict:
+    """The whole mcp.json document (not just `mcpServers`), so a write preserves
+    any other keys the user keeps in the file. Empty dict if missing/invalid."""
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text())
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def add_mcp_server(name: str, entry: dict) -> Path:
+    """Add (or replace) one server under `mcpServers` and write mcp.json back,
+    creating the file and its parent directory if needed. Returns the path.
+
+    This is what the in-TUI "add server" form calls so a user never has to
+    hand-edit the JSON. The written shape is exactly what ``load_mcp_config``
+    reads and ``connect_all`` consumes.
+    """
+    path = _config_path()
+    data = _read_full_config(path)
+    servers = data.get("mcpServers")
+    if not isinstance(servers, dict):
+        servers = {}
+    servers[name] = entry
+    data["mcpServers"] = servers
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return path
+
+
+def remove_mcp_server(name: str) -> bool:
+    """Drop one server from mcp.json. True if it was there, False otherwise."""
+    path = _config_path()
+    data = _read_full_config(path)
+    servers = data.get("mcpServers")
+    if not isinstance(servers, dict) or name not in servers:
+        return False
+    del servers[name]
+    data["mcpServers"] = servers
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return True

{localcode-0.3.63 → localcode-0.3.64}/src/localcode/tui/screens/chat.py

@@ -1293,7 +1293,7 @@ class ChatScreen(Screen):
         # scroll the chat — these keys are how, so they must be discoverable.
         log.append_info(
             "Ctrl+U/D scroll · Shift+↑/↓ line · Home/End jump · "
-            "Shift+Enter newline · paste to attach an image"
+            "Shift+Enter newline · paste to attach an image · ! runs a shell command"
         )
         # If the user launched with --resume, the TUI app stored prior
         # messages in `_pending_resume_messages`. Replay them into the
@@ -2096,6 +2096,21 @@ class ChatScreen(Screen):
                 self._slash_window = 0
                 menu.remove_class("active")
                 status_bar.remove_class("hidden")
+        elif text.startswith("!"):
+            # Shell-mode affordance, mirroring the leading CLI agents' "! for
+            # shell" hint. `!cmd` runs in the user's shell (_run_bash) and the
+            # output lands in the log. Keep _slash_matches empty so Enter falls
+            # through to _submit_message (which runs the command) instead of
+            # the slash menu trying to select a row.
+            self._slash_matches = []
+            self._slash_selected = 0
+            self._slash_window = 0
+            menu.update(
+                "[bold]!  shell mode[/]  "
+                "[dim]Enter runs this command in your shell[/]"
+            )
+            menu.add_class("active")
+            status_bar.add_class("hidden")
         else:
             self._slash_matches = []
             self._slash_selected = 0

localcode-0.3.64/src/localcode/tui/screens/mcp_add.py

@@ -0,0 +1,163 @@
+"""Add-an-MCP-server modal — the in-TUI answer to `claude mcp add`.
+
+localcode has no CLI subcommands; everything happens in the TUI. So adding an
+MCP server is a small keyboard form here, not a shell command. It writes
+``~/.localcode/mcp.json`` for the user (via ``mcp.add_mcp_server``) so nobody
+has to hand-edit JSON.
+
+The common case is the one Codex/Claude make trivial: "use this MCP" + a URL.
+So the URL/command field comes first, and:
+
+  * a value starting with ``http://`` / ``https://`` becomes a remote
+    streamable-HTTP server (``{"transport": "http", "url": ...}``);
+  * anything else is a stdio server (``{"command": ..., "args": [...]}``),
+    with args split shell-style.
+
+Name is optional: left blank, it is derived from the URL host (``api.
+githubcopilot.com`` -> ``githubcopilot``) or the command/package basename.
+
+Resolves to ``{"name": str, "entry": dict}`` on save, or ``None`` on cancel.
+"""
+from __future__ import annotations
+
+import shlex
+from urllib.parse import urlparse
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static
+
+from ...theme import C
+
+
+def _derive_name_from_url(url: str) -> str:
+    """A short, sane server name from a URL host, e.g.
+    https://api.githubcopilot.com/mcp/ -> 'githubcopilot'."""
+    host = (urlparse(url).hostname or "").lower()
+    if not host:
+        return ""
+    labels = [p for p in host.split(".") if p]
+    # Drop leading noise and a trailing TLD so the meaningful label is left.
+    while labels and labels[0] in ("api", "mcp", "www", "app"):
+        labels.pop(0)
+    if len(labels) > 1:
+        labels = labels[:-1]  # strip TLD (.com/.dev/.ai/...)
+    return labels[0] if labels else host
+
+
+def _derive_name_from_command(command: str, args: list[str]) -> str:
+    """A name for a stdio server. Runners like npx/uvx carry the real name in
+    args (@scope/server), so prefer a package-looking arg over the runner."""
+    for a in args:
+        if a.startswith("-"):
+            continue
+        if "/" in a or a.startswith("@"):
+            base = a.rsplit("/", 1)[-1]  # @scope/server-foo -> server-foo
+            if base:
+                return base
+    base = command.rsplit("/", 1)[-1]
+    return base or command
+
+
+class AddMCPServerScreen(ModalScreen[dict | None]):
+    """Modal form to add one MCP server. Resolves to {name, entry} or None."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    AddMCPServerScreen {
+        align: center middle;
+    }
+    AddMCPServerScreen > #add-box {
+        width: 68;
+        max-width: 92%;
+        height: auto;
+        padding: 1 2;
+        border: round $accent;
+        background: $surface;
+    }
+    AddMCPServerScreen #add-title {
+        text-style: bold;
+        padding-bottom: 1;
+    }
+    AddMCPServerScreen #add-help {
+        color: $text-muted;
+        padding-bottom: 1;
+    }
+    AddMCPServerScreen Input {
+        margin-bottom: 1;
+    }
+    AddMCPServerScreen #add-hint {
+        color: $text-muted;
+        padding-top: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="add-box"):
+            yield Static("Add MCP server", id="add-title")
+            yield Static(
+                "Paste a URL for a remote server, or a command for a local one.",
+                id="add-help",
+            )
+            yield Input(
+                placeholder="https://… URL, or a command like: npx -y @scope/server /path",
+                id="add-target",
+            )
+            yield Input(placeholder="name (optional)", id="add-name")
+            yield Static(
+                "Enter save  ·  Tab next field  ·  Esc cancel", id="add-hint"
+            )
+
+    def on_mount(self) -> None:
+        self.query_one("#add-target", Input).focus()
+
+    # ── build / validate ────────────────────────────────────────────
+
+    def _build(self) -> dict | None:
+        target = self.query_one("#add-target", Input).value.strip()
+        name = self.query_one("#add-name", Input).value.strip()
+        if not target:
+            return None
+
+        if target.lower().startswith(("http://", "https://")):
+            entry: dict = {"transport": "http", "url": target}
+            if not name:
+                name = _derive_name_from_url(target)
+        else:
+            parts = shlex.split(target)
+            if not parts:
+                return None
+            command, args = parts[0], parts[1:]
+            entry = {"command": command}
+            if args:
+                entry["args"] = args
+            if not name:
+                name = _derive_name_from_command(command, args)
+
+        if not name:
+            return None
+        return {"name": name, "entry": entry}
+
+    def _flash(self, msg: str) -> None:
+        try:
+            self.query_one("#add-hint", Static).update(f"[{C.error}]{msg}[/]")
+        except Exception:
+            pass
+
+    # ── actions ─────────────────────────────────────────────────────
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        # Enter in either field tries to save.
+        result = self._build()
+        if result is None:
+            self._flash("Enter a URL or a command first.")
+            return
+        self.dismiss(result)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

{localcode-0.3.63 → localcode-0.3.64}/src/localcode/tui/screens/mcp_screen.py

@@ -52,6 +52,7 @@ class MCPScreen(Screen):
         Binding("enter", "expand_focused", "Expand / collapse", show=False),
         Binding("left", "back", "Back", show=False),
         Binding("h", "back", "Back", show=False),
+        Binding("a", "add", "Add server", show=False),
         Binding("r", "reload", "Reload all", show=False),
         Binding("d", "disconnect", "Disconnect server", show=False),
         Binding("escape", "close", "Close", show=False),
@@ -117,6 +118,7 @@ class MCPScreen(Screen):
         # Rows from mcp.server_status(); None = still loading (connecting).
         self._status: list[dict] | None = None
         self._busy = False  # True while a connect / reload worker is in flight
+        self._pending_focus_name: str | None = None  # focus this server post-reload
 
     # ── compose ─────────────────────────────────────────────────────
 
@@ -163,8 +165,18 @@ class MCPScreen(Screen):
             self._focused_idx = 0
             self._level = self._LEVEL_SERVERS
             self._open_idx = None
+        elif self._pending_focus_name is not None:
+            # A just-added server: land focus on it if we can find it.
+            for i, s in enumerate(status):
+                if s.get("name") == self._pending_focus_name:
+                    self._focused_idx = i
+                    break
+            else:
+                if self._focused_idx >= n:
+                    self._focused_idx = n - 1
         elif self._focused_idx >= n:
             self._focused_idx = n - 1
+        self._pending_focus_name = None
         self._refresh()
 
     # ── render dispatch ─────────────────────────────────────────────
@@ -180,7 +192,7 @@ class MCPScreen(Screen):
 
     def _footer_markup(self) -> str:
         if self._status is None or not self._status:
-            return f"[{C.primary}]LocalCode[/] [dim]· r reload · Esc close[/]"
+            return f"[{C.primary}]LocalCode[/] [dim]· a add · r reload · Esc close[/]"
         if self._level == self._LEVEL_TOOLS:
             row = self._status[self._open_idx] if self._open_idx is not None else None
             name = row["name"] if row else ""
@@ -193,7 +205,7 @@ class MCPScreen(Screen):
         keys = "Enter to expand" if n == 1 else f"↑/↓ + Enter, or 1-{n}"
         return (
             f"[{C.primary}]LocalCode[/] "
-            f"[dim]· {keys} · r reload · d disconnect · Esc close[/]"
+            f"[dim]· {keys} · a add · r reload · d disconnect · Esc close[/]"
         )
 
     # ── Level 1: servers ────────────────────────────────────────────
@@ -218,7 +230,7 @@ class MCPScreen(Screen):
             lines.append(f"       [dim]" + " · ".join(bits) + "[/]")
 
         lines.append("")
-        lines.append("[dim]Enter → tools · r reload · d disconnect · Esc close[/]")
+        lines.append("[dim]Enter → tools · a add · r reload · d disconnect · Esc close[/]")
         return "\n".join(lines)
 
     def _status_glyph_label(self, s: dict) -> tuple[str, str]:
@@ -271,27 +283,13 @@ class MCPScreen(Screen):
     # ── empty state ─────────────────────────────────────────────────
 
     def _render_empty(self) -> str:
-        from ...mcp import MCP_CONFIG_PATH
         return (
             "[bold]MCP servers[/]\n"
             "\n"
             "[dim]None configured. MCP lets the model call tools from external\n"
-            "programs you trust.[/]\n"
-            "\n"
-            f"[dim]Add one in[/] {MCP_CONFIG_PATH}[dim]:[/]\n"
-            "\n"
-            '[dim]{\n'
-            '  "mcpServers": {\n'
-            '    "files": {\n'
-            '      "command": "npx",\n'
-            '      "args": [\n'
-            '        "-y", "@modelcontextprotocol/server-filesystem", "/path"\n'
-            '      ]\n'
-            '    }\n'
-            '  }\n'
-            '}[/]\n'
+            "programs you trust: a remote server URL, or a local command.[/]\n"
             "\n"
-            "[dim]Then press r to connect.[/]"
+            f"[dim]Press[/] [bold]a[/] [dim]to add one.[/]"
         )
 
     # ── refresh / scroll ────────────────────────────────────────────
@@ -385,6 +383,32 @@ class MCPScreen(Screen):
             return
         self.dismiss(None)
 
+    # ── add (Level 1 only) ──────────────────────────────────────────
+
+    def action_add(self) -> None:
+        """Open the add-server form; on save, write mcp.json and reconnect."""
+        if self._busy or self._level != self._LEVEL_SERVERS:
+            return
+        from .mcp_add import AddMCPServerScreen
+
+        def _after(result: dict | None) -> None:
+            if result:
+                self._save_and_reload(result["name"], result["entry"])
+
+        self.app.push_screen(AddMCPServerScreen(), _after)
+
+    def _save_and_reload(self, name: str, entry: dict) -> None:
+        from ...mcp import add_mcp_server
+        try:
+            add_mcp_server(name, entry)
+        except Exception as e:  # pragma: no cover - disk error path
+            self._flash_footer(f"[{C.error}]Could not save {name}: {e}[/]")
+            return
+        # Reconnect so the new server appears with honest status, then land
+        # focus on it.
+        self._pending_focus_name = name
+        self.action_reload()
+
     # ── reload ──────────────────────────────────────────────────────
 
     def action_reload(self) -> None:

{localcode-0.3.63 → localcode-0.3.64/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.63
+Version: 0.3.64
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.63 → localcode-0.3.64}/src/localcode.egg-info/SOURCES.txt

@@ -1167,6 +1167,7 @@ src/localcode/tui/paste_collapse.py
 src/localcode/tui/screens/__init__.py
 src/localcode/tui/screens/chat.py
 src/localcode/tui/screens/confirm.py
+src/localcode/tui/screens/mcp_add.py
 src/localcode/tui/screens/mcp_screen.py
 src/localcode/tui/screens/mode_picker.py
 src/localcode/tui/screens/model_picker.py
@@ -1228,6 +1229,7 @@ tests/test_info_markup.py
 tests/test_inspect_symbol.py
 tests/test_kv_cap.py
 tests/test_loop_recovery_ladder.py
+tests/test_mcp_add.py
 tests/test_mcp_screen.py
 tests/test_model_arg_resolution.py
 tests/test_model_config.py

localcode-0.3.64/tests/test_mcp_add.py

@@ -0,0 +1,173 @@
+"""Add-an-MCP-server flow — writer, name derivation, and the modal build.
+
+Covers the in-TUI replacement for `claude mcp add`:
+  * `mcp.add_mcp_server` / `remove_mcp_server` write and prune mcp.json while
+    preserving other keys and honoring LOCALCODE_HOME;
+  * the URL-first `AddMCPServerScreen` turns a pasted URL into an http entry
+    and a command into a stdio entry, deriving a name when one is not given.
+
+CI-safe: no network, no npx, no real server.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+import localcode.mcp._config as cfg
+from localcode.tui.screens.mcp_add import (
+    AddMCPServerScreen,
+    _derive_name_from_command,
+    _derive_name_from_url,
+)
+
+
+# ── writer ──────────────────────────────────────────────────────────
+
+def test_add_and_remove_preserve_other_keys(tmp_path, monkeypatch):
+    monkeypatch.setenv("LOCALCODE_HOME", str(tmp_path))
+    path = tmp_path / "mcp.json"
+    # A file that already has an unrelated top-level key must survive a write.
+    path.write_text(json.dumps({"$comment": "keep me", "mcpServers": {}}))
+
+    cfg.add_mcp_server("files", {"command": "npx", "args": ["-y", "srv"]})
+    data = json.loads(path.read_text())
+    assert data["$comment"] == "keep me"
+    assert data["mcpServers"]["files"]["command"] == "npx"
+    assert data["mcpServers"]["files"]["args"] == ["-y", "srv"]
+
+    # Adding a second server keeps the first.
+    cfg.add_mcp_server("remote", {"transport": "http", "url": "https://x/mcp"})
+    data = json.loads(path.read_text())
+    assert set(data["mcpServers"]) == {"files", "remote"}
+
+    # Remove one; the other and the extra key remain.
+    assert cfg.remove_mcp_server("files") is True
+    data = json.loads(path.read_text())
+    assert list(data["mcpServers"]) == ["remote"]
+    assert data["$comment"] == "keep me"
+    # Removing a missing server is a no-op returning False.
+    assert cfg.remove_mcp_server("nope") is False
+
+
+def test_add_creates_file_when_absent(tmp_path, monkeypatch):
+    monkeypatch.setenv("LOCALCODE_HOME", str(tmp_path))
+    assert not (tmp_path / "mcp.json").exists()
+    cfg.add_mcp_server("remote", {"transport": "http", "url": "https://x/mcp"})
+    data = json.loads((tmp_path / "mcp.json").read_text())
+    assert data == {"mcpServers": {"remote": {"transport": "http", "url": "https://x/mcp"}}}
+
+
+# ── name derivation ─────────────────────────────────────────────────
+
+def test_derive_name_from_url():
+    assert _derive_name_from_url("https://api.githubcopilot.com/mcp/") == "githubcopilot"
+    assert _derive_name_from_url("https://mcp.sentry.dev/sse") == "sentry"
+    assert _derive_name_from_url("http://localhost:9000/mcp") == "localhost"
+
+
+def test_derive_name_from_command():
+    # Runner in command, real package in args -> name from the package.
+    assert _derive_name_from_command(
+        "npx", ["-y", "@modelcontextprotocol/server-filesystem", "/p"]
+    ) == "server-filesystem"
+    # Bare command -> its basename.
+    assert _derive_name_from_command("/usr/local/bin/my-server", []) == "my-server"
+
+
+# ── modal build logic ───────────────────────────────────────────────
+
+def _run(coro):
+    import asyncio
+    asyncio.run(coro)
+
+
+def _build_with(target: str, name: str = ""):
+    """Mount the modal, set field values, return what _build() produces."""
+    from textual.app import App
+    from textual.widgets import Input
+
+    result = {}
+
+    class _H(App):
+        async def on_mount(self) -> None:
+            self.push_screen(AddMCPServerScreen())
+
+    async def scenario():
+        app = _H()
+        async with app.run_test(size=(90, 30)) as pilot:
+            await pilot.pause(0.05)
+            scr = app.screen
+            scr.query_one("#add-target", Input).value = target
+            scr.query_one("#add-name", Input).value = name
+            result["out"] = scr._build()
+
+    _run(scenario())
+    return result["out"]
+
+
+def test_build_url_makes_http_entry():
+    out = _build_with("https://api.githubcopilot.com/mcp/")
+    assert out == {
+        "name": "githubcopilot",
+        "entry": {"transport": "http", "url": "https://api.githubcopilot.com/mcp/"},
+    }
+
+
+def test_build_command_makes_stdio_entry_with_split_args():
+    out = _build_with('npx -y "@scope/server foo" /path', name="myfiles")
+    assert out["name"] == "myfiles"
+    assert out["entry"]["command"] == "npx"
+    # shlex.split keeps the quoted package as one arg.
+    assert out["entry"]["args"] == ["-y", "@scope/server foo", "/path"]
+
+
+def test_build_blank_target_is_invalid():
+    assert _build_with("   ") is None
+
+
+# ── end-to-end: 'a' from /mcp opens the modal, save writes + reloads ──
+
+def test_add_key_opens_modal_and_saves(tmp_path, monkeypatch):
+    from unittest.mock import patch
+    from textual.widgets import Input
+    from localcode.tui.screens.mcp_screen import MCPScreen
+
+    monkeypatch.setenv("LOCALCODE_HOME", str(tmp_path))
+
+    async def scenario():
+        from textual.app import App
+
+        class _App(App):
+            async def on_mount(self) -> None:
+                self.push_screen(MCPScreen())
+
+        # Empty catalogue so the screen mounts in its empty state fast.
+        with patch("localcode.mcp.connect_all", return_value=(0, [])), \
+             patch("localcode.mcp.server_status", return_value=[]):
+            app = _App()
+            async with app.run_test(size=(100, 40)) as pilot:
+                mcp_scr = app.screen
+                for _ in range(50):
+                    await pilot.pause(0.02)
+                    if mcp_scr._status is not None:
+                        break
+                await pilot.press("a")
+                await pilot.pause(0.05)
+                assert isinstance(app.screen, AddMCPServerScreen), app.screen
+                app.screen.query_one("#add-target", Input).value = (
+                    "https://api.githubcopilot.com/mcp/"
+                )
+                await pilot.press("enter")
+                await pilot.pause(0.05)
+
+    _run(scenario())
+
+    # The save wrote the derived server into mcp.json.
+    data = json.loads((tmp_path / "mcp.json").read_text())
+    assert data["mcpServers"]["githubcopilot"] == {
+        "transport": "http",
+        "url": "https://api.githubcopilot.com/mcp/",
+    }

{localcode-0.3.63 → localcode-0.3.64}/tests/test_mcp_screen.py

@@ -132,8 +132,8 @@ def test_empty_state():
                 await _wait_status(scr, pilot)
                 body = scr._render_body()
                 assert "None configured" in body, body
-                assert "mcpServers" in body, body
-                assert "server-filesystem" in body, body
+                # New empty state points at the in-TUI add flow, not raw JSON.
+                assert "Press" in body and "to add one" in body, body
     _run(scenario())