meshcode 2.10.27__tar.gz → 2.10.29__tar.gz

{meshcode-2.10.27 → meshcode-2.10.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.27
+Version: 2.10.29
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.10.27 → meshcode-2.10.29}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.27"
+__version__ = "2.10.29"

{meshcode-2.10.27 → meshcode-2.10.29}/meshcode/meshcode_mcp/server.py

@@ -2811,24 +2811,45 @@ def run_server():
     # accidental stdout writes from corrupting the MCP protocol.
     sys.stdout = _REAL_STDOUT
 
-    # Claude Code cancels tool calls on ESC via TWO parallel channels:
-    #   (1) JSON-RPC `notifications/cancelled` over stdin (the correct path)
-    #   (2) SIGINT to the stdio subprocess (a destructive side-channel)
-    # anyio's asyncio backend installs its own SIGINT handler inside
-    # Runner.run() only if the current handler is `default_int_handler`
-    # (see anyio/_backends/_asyncio.py ~L197-210). That handler cancels the
-    # *main task* — which for a stdio server IS the whole server run —
-    # tearing the event loop down and killing the subprocess. Setting
-    # SIG_IGN before mcp.run() trips anyio's guard, so it leaves SIGINT
-    # alone; the kernel drops the signal; only the notifications/cancelled
-    # path remains, which cancels just the in-flight tool call as intended.
-    # SIGTERM is deliberately untouched so Claude Code can still force-shut
-    # the server on session end. stdin EOF remains the normal exit path.
+    # Claude Code cancels tool calls on ESC via multiple side channels that
+    # are destructive to the stdio subprocess. 2.10.26's SIG_IGN-on-SIGINT
+    # fix was incomplete in the wild (2.10.27 field test died anyway), so we
+    # widen the net: ignore every signal Claude Code is known to send on
+    # cancellation and log any that arrive so we can see what actually fires.
+    #
+    # SIGINT  — kernel default: terminate. asyncio Runner also installs a
+    #           cancel-main-task handler, but only if the current handler is
+    #           default_int_handler; SIG_IGN here trips that guard.
+    # SIGTERM — kernel default: terminate. Some Claude Code versions send
+    #           this after SIGINT if the subprocess didn't exit fast enough.
+    # SIGHUP  — kernel default: terminate. Sent when the controlling tty
+    #           detaches or the parent process restructures its session.
+    # SIGPIPE — kernel default: terminate. Fires when Claude Code closes its
+    #           side of stdout while we're mid-write. Ignoring makes the
+    #           write fail with EPIPE instead of killing us.
+    #
+    # SIGKILL and SIGSTOP cannot be caught — that is how the process is
+    # meant to be forcibly stopped (`kill -9 <pid>` still works). stdin EOF
+    # is untouched and remains the clean-shutdown signal for session end.
     import signal
-    try:
-        signal.signal(signal.SIGINT, signal.SIG_IGN)
-    except (ValueError, OSError):
-        # Non-main thread or platform that can't install handlers — harmless.
-        pass
+    def _diag_ignore(signum, frame):  # pragma: no cover - signal handler
+        try:
+            name = signal.Signals(signum).name
+        except Exception:
+            name = f"signal-{signum}"
+        try:
+            sys.stderr.write(f"[meshcode-mcp] received {name} ({signum}); ignored to keep MCP alive during tool cancellation\n")
+            sys.stderr.flush()
+        except Exception:
+            pass
+    for _sig_name in ("SIGINT", "SIGTERM", "SIGHUP", "SIGPIPE"):
+        _sig = getattr(signal, _sig_name, None)
+        if _sig is None:
+            continue
+        try:
+            signal.signal(_sig, _diag_ignore)
+        except (ValueError, OSError):
+            # Non-main thread or Windows doesn't expose the signal — harmless.
+            pass
 
     mcp.run()

{meshcode-2.10.27 → meshcode-2.10.29}/meshcode/run_agent.py

@@ -465,13 +465,17 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     print()
 
     if editor == "claude":
-        # Claude Code: pass --mcp-config to point at the workspace's .mcp.json
-        # and --strict-mcp-config so it ignores ~/.claude.json's mcpServers.
+        # Claude Code: run from inside the workspace and let Claude Code
+        # auto-discover .mcp.json as a PROJECT-scoped MCP. We used to pass
+        # --mcp-config + --strict-mcp-config here, but that categorises the
+        # server as a "Built-in" (session-injected) MCP, and Built-in MCPs
+        # are killed by Claude Code when the user presses ESC — a bug/quirk
+        # that caused our agents to die on every cancellation. Project-
+        # scoped MCPs (loaded from ./.mcp.json at cwd) live in the "Local
+        # MCP" bucket and survive ESC. Verified with a minimal FastMCP
+        # repro side-by-side: Built-in dies, Local survives, same SDK code.
         mode = resolve_permission_mode(permission_override)
-        cmd = [
-            editor,
-            "--mcp-config", str(ws / ".mcp.json"),
-        ]
+        cmd = [editor]
         if mode == "bypass":
             cmd.append("--dangerously-skip-permissions")
             print(f"[meshcode]   Permission mode: bypass (autonomous loop, no prompts)")

{meshcode-2.10.27 → meshcode-2.10.29}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.27
+Version: 2.10.29
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.10.27 → meshcode-2.10.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.10.27"
+version = "2.10.29"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}