textual-debugger 0.1.3__tar.gz → 0.1.4__tar.gz

{textual_debugger-0.1.3 → textual_debugger-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: textual-debugger
-Version: 0.1.3
+Version: 0.1.4
 Summary: A TUI Python debugger based on textual and debugpy
 Author-email: Al Danial <al.danial@gmail.com>
 License: textual-debugger is licensed to you under the MIT/X Consortium license:
@@ -51,6 +51,7 @@ Requires-Dist: debugpy>=1.8.0
 Requires-Dist: pygments>=2.17.0
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: mcp>=1.28.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -738,11 +739,12 @@ curl -s -X POST http://127.0.0.1:8150/rpc \
 | `set_breakpoint` | `["file:line"]` or `["file:line", "condition", "hit_condition"]` | Set a breakpoint |
 | `remove_breakpoint` | `["file:line"]` | Remove a breakpoint |
 | `list_breakpoints` | `[]` | Show all breakpoints |
-| `continue` | `[]` | Resume execution |
-| `next` | `[]` | Step over |
-| `step_in` | `[]` | Step into |
-| `step_out` | `[]` | Step out |
-| `pause` | `[]` | Pause execution |
+| `continue` | `[]` or `[timeout_s]` | Resume execution; on timeout returns `"still running — call pause or wait again"` (success) |
+| `next` | `[]` or `[timeout_s]` | Step over |
+| `step_in` | `[]` or `[timeout_s]` | Step into |
+| `step_out` | `[]` or `[timeout_s]` | Step out |
+| `pause` | `[]` | Pause execution; bypasses the dispatch lock so it can interrupt an in-flight blocking action |
+| `wait_for_stop` | `[]` or `[timeout_s]` | Wait for the next stop without issuing a step (use after `continue` returns `"still running"` to keep waiting) |
 | `inspect` | `["expr1", "expr2", ...]` | Evaluate multiple expressions |
 | `evaluate` | `["expression"]` | Evaluate a single expression |
 | `stack_up` | `[]` | Move up the call stack |
@@ -771,6 +773,89 @@ curl -N http://127.0.0.1:8150/events
 Events: `initialized`, `stopped`, `continued`, `terminated`, `exited`, `output`.
 Each is JSON with `event`, `data`, and `timestamp` fields.
 
+## MCP Integration
+
+tdb ships a Model Context Protocol (MCP) server (`tdb-mcp`) that exposes
+the debugger as a curated set of tools an AI agent can call. The MCP
+server is a third in-process consumer of the same dispatch handlers the
+TUI and the HTTP server use — so an agent gets the same lock semantics,
+including the pause-during-continue bypass, and the same DAP-backed
+inspection surface.
+
+For a worked end-to-end example (prompting an agent to find two
+runtime bugs in a sample program) see
+[docs/tutorial-mcp-debugging.md](docs/tutorial-mcp-debugging.md) and
+its companion `examples/sales_report_buggy.py`.
+
+### Running the MCP server
+
+Configure your MCP client (Claude Desktop, an IDE extension, etc.) to
+launch `tdb-mcp` over stdio. Example `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "tdb": {
+      "command": "tdb-mcp"
+    }
+  }
+}
+```
+
+Three equivalent invocation forms: `tdb-mcp` (the dedicated entry
+point), `tdb --mcp` (the main CLI with the `--mcp` switch), and
+`python -m tdb.mcp` (module form). Pick whichever matches how your MCP
+client expects to launch servers.
+
+### Tool surface (16 tools, curated)
+
+| Cluster | Tools |
+|---------|-------|
+| Lifecycle | `debug_launch`, `debug_attach`, `quit` |
+| Control | `control(action, timeout_s=30)` — `action ∈ {continue, next, step_in, step_out, pause, wait_for_stop}` |
+| Inspection | `inspect(expressions)`, `read_source(file_path)`, `stack_trace()`, `status()`, `get_output()` |
+| Breakpoints | `set_breakpoint(spec, condition?, hit_condition?)`, `remove_breakpoint(spec)`, `list_breakpoints()` |
+| Differentiators | `threads(thread_id?)`, `tasks(task_name?)`, `processes(name_or_pid?)`, `wait_graph()` |
+
+`control` is intentionally one tool that takes an action enum — the six
+underlying RPC actions share a return shape, and agents perform
+measurably better with a small surface than with one tool per action.
+`threads` / `tasks` / `processes` overload list-vs-inspect via a
+single optional argument for the same reason.
+
+### Agent flow for a long-running step
+
+```
+agent → control(action="continue", timeout_s=30)
+mcp   → "still running — call pause or wait again"
+agent → control(action="pause")        # OR: control(action="wait_for_stop", timeout_s=30)
+mcp   → "<file>:<line>"
+agent → inspect(["x", "len(buf)"])
+mcp   → "x = 7\nlen(buf) = 1024"
+```
+
+`pause` bypasses the dispatch lock so it can interrupt a `continue`
+that's still mid-flight (HTTP and MCP share the same `NO_LOCK_ACTIONS`
+policy — see `tdb/server/app.py`).
+
+### Security caveat
+
+`inspect` calls debugpy's `evaluate`, which is **arbitrary Python
+execution in the debuggee process**. This is inherent to a debugger and
+not a tdb-specific concern, but MCP clients (and the humans running
+them) should apply appropriate permission models: don't auto-approve
+`inspect` against untrusted expressions, and don't expose `tdb-mcp` on
+a network — stdio transport only by design.
+
+### Deferred / out of scope (v1)
+
+- SSE-style event push — `control` and `wait_for_stop` make polling
+  efficient enough; events would also need uneven MCP-client support.
+- HTTP / streamable-HTTP transports — would require auth (which the
+  HTTP RPC server also currently lacks); stdio inherits the trust of
+  the process that spawned it.
+- Multi-session — one debug session per MCP process.
+
 ## CLI Reference
 
 ```

{textual_debugger-0.1.3/src/tdb → textual_debugger-0.1.4}/README.md

@@ -673,11 +673,12 @@ curl -s -X POST http://127.0.0.1:8150/rpc \
 | `set_breakpoint` | `["file:line"]` or `["file:line", "condition", "hit_condition"]` | Set a breakpoint |
 | `remove_breakpoint` | `["file:line"]` | Remove a breakpoint |
 | `list_breakpoints` | `[]` | Show all breakpoints |
-| `continue` | `[]` | Resume execution |
-| `next` | `[]` | Step over |
-| `step_in` | `[]` | Step into |
-| `step_out` | `[]` | Step out |
-| `pause` | `[]` | Pause execution |
+| `continue` | `[]` or `[timeout_s]` | Resume execution; on timeout returns `"still running — call pause or wait again"` (success) |
+| `next` | `[]` or `[timeout_s]` | Step over |
+| `step_in` | `[]` or `[timeout_s]` | Step into |
+| `step_out` | `[]` or `[timeout_s]` | Step out |
+| `pause` | `[]` | Pause execution; bypasses the dispatch lock so it can interrupt an in-flight blocking action |
+| `wait_for_stop` | `[]` or `[timeout_s]` | Wait for the next stop without issuing a step (use after `continue` returns `"still running"` to keep waiting) |
 | `inspect` | `["expr1", "expr2", ...]` | Evaluate multiple expressions |
 | `evaluate` | `["expression"]` | Evaluate a single expression |
 | `stack_up` | `[]` | Move up the call stack |
@@ -706,6 +707,89 @@ curl -N http://127.0.0.1:8150/events
 Events: `initialized`, `stopped`, `continued`, `terminated`, `exited`, `output`.
 Each is JSON with `event`, `data`, and `timestamp` fields.
 
+## MCP Integration
+
+tdb ships a Model Context Protocol (MCP) server (`tdb-mcp`) that exposes
+the debugger as a curated set of tools an AI agent can call. The MCP
+server is a third in-process consumer of the same dispatch handlers the
+TUI and the HTTP server use — so an agent gets the same lock semantics,
+including the pause-during-continue bypass, and the same DAP-backed
+inspection surface.
+
+For a worked end-to-end example (prompting an agent to find two
+runtime bugs in a sample program) see
+[docs/tutorial-mcp-debugging.md](docs/tutorial-mcp-debugging.md) and
+its companion `examples/sales_report_buggy.py`.
+
+### Running the MCP server
+
+Configure your MCP client (Claude Desktop, an IDE extension, etc.) to
+launch `tdb-mcp` over stdio. Example `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "tdb": {
+      "command": "tdb-mcp"
+    }
+  }
+}
+```
+
+Three equivalent invocation forms: `tdb-mcp` (the dedicated entry
+point), `tdb --mcp` (the main CLI with the `--mcp` switch), and
+`python -m tdb.mcp` (module form). Pick whichever matches how your MCP
+client expects to launch servers.
+
+### Tool surface (16 tools, curated)
+
+| Cluster | Tools |
+|---------|-------|
+| Lifecycle | `debug_launch`, `debug_attach`, `quit` |
+| Control | `control(action, timeout_s=30)` — `action ∈ {continue, next, step_in, step_out, pause, wait_for_stop}` |
+| Inspection | `inspect(expressions)`, `read_source(file_path)`, `stack_trace()`, `status()`, `get_output()` |
+| Breakpoints | `set_breakpoint(spec, condition?, hit_condition?)`, `remove_breakpoint(spec)`, `list_breakpoints()` |
+| Differentiators | `threads(thread_id?)`, `tasks(task_name?)`, `processes(name_or_pid?)`, `wait_graph()` |
+
+`control` is intentionally one tool that takes an action enum — the six
+underlying RPC actions share a return shape, and agents perform
+measurably better with a small surface than with one tool per action.
+`threads` / `tasks` / `processes` overload list-vs-inspect via a
+single optional argument for the same reason.
+
+### Agent flow for a long-running step
+
+```
+agent → control(action="continue", timeout_s=30)
+mcp   → "still running — call pause or wait again"
+agent → control(action="pause")        # OR: control(action="wait_for_stop", timeout_s=30)
+mcp   → "<file>:<line>"
+agent → inspect(["x", "len(buf)"])
+mcp   → "x = 7\nlen(buf) = 1024"
+```
+
+`pause` bypasses the dispatch lock so it can interrupt a `continue`
+that's still mid-flight (HTTP and MCP share the same `NO_LOCK_ACTIONS`
+policy — see `tdb/server/app.py`).
+
+### Security caveat
+
+`inspect` calls debugpy's `evaluate`, which is **arbitrary Python
+execution in the debuggee process**. This is inherent to a debugger and
+not a tdb-specific concern, but MCP clients (and the humans running
+them) should apply appropriate permission models: don't auto-approve
+`inspect` against untrusted expressions, and don't expose `tdb-mcp` on
+a network — stdio transport only by design.
+
+### Deferred / out of scope (v1)
+
+- SSE-style event push — `control` and `wait_for_stop` make polling
+  efficient enough; events would also need uneven MCP-client support.
+- HTTP / streamable-HTTP transports — would require auth (which the
+  HTTP RPC server also currently lacks); stdio inherits the trust of
+  the process that spawned it.
+- Multi-session — one debug session per MCP process.
+
 ## CLI Reference
 
 ```

{textual_debugger-0.1.3 → textual_debugger-0.1.4}/pyproject.toml

@@ -25,7 +25,8 @@
       "pygments>=2.17.0",
       "fastapi>=0.115.0",
       "uvicorn>=0.30.0",
-  ]
+      "mcp>=1.28.0",
+]
 
   # extras needed to run the examples and tests
   [project.optional-dependencies]
@@ -43,6 +44,7 @@
 
   [project.scripts]
   tdb = "tdb.cli:main"
+  tdb-mcp = "tdb.mcp.server:main"
 
   [build-system]
   requires = ["setuptools>=68.0"]

{textual_debugger-0.1.3 → textual_debugger-0.1.4/src/tdb}/README.md

@@ -673,11 +673,12 @@ curl -s -X POST http://127.0.0.1:8150/rpc \
 | `set_breakpoint` | `["file:line"]` or `["file:line", "condition", "hit_condition"]` | Set a breakpoint |
 | `remove_breakpoint` | `["file:line"]` | Remove a breakpoint |
 | `list_breakpoints` | `[]` | Show all breakpoints |
-| `continue` | `[]` | Resume execution |
-| `next` | `[]` | Step over |
-| `step_in` | `[]` | Step into |
-| `step_out` | `[]` | Step out |
-| `pause` | `[]` | Pause execution |
+| `continue` | `[]` or `[timeout_s]` | Resume execution; on timeout returns `"still running — call pause or wait again"` (success) |
+| `next` | `[]` or `[timeout_s]` | Step over |
+| `step_in` | `[]` or `[timeout_s]` | Step into |
+| `step_out` | `[]` or `[timeout_s]` | Step out |
+| `pause` | `[]` | Pause execution; bypasses the dispatch lock so it can interrupt an in-flight blocking action |
+| `wait_for_stop` | `[]` or `[timeout_s]` | Wait for the next stop without issuing a step (use after `continue` returns `"still running"` to keep waiting) |
 | `inspect` | `["expr1", "expr2", ...]` | Evaluate multiple expressions |
 | `evaluate` | `["expression"]` | Evaluate a single expression |
 | `stack_up` | `[]` | Move up the call stack |
@@ -706,6 +707,89 @@ curl -N http://127.0.0.1:8150/events
 Events: `initialized`, `stopped`, `continued`, `terminated`, `exited`, `output`.
 Each is JSON with `event`, `data`, and `timestamp` fields.
 
+## MCP Integration
+
+tdb ships a Model Context Protocol (MCP) server (`tdb-mcp`) that exposes
+the debugger as a curated set of tools an AI agent can call. The MCP
+server is a third in-process consumer of the same dispatch handlers the
+TUI and the HTTP server use — so an agent gets the same lock semantics,
+including the pause-during-continue bypass, and the same DAP-backed
+inspection surface.
+
+For a worked end-to-end example (prompting an agent to find two
+runtime bugs in a sample program) see
+[docs/tutorial-mcp-debugging.md](docs/tutorial-mcp-debugging.md) and
+its companion `examples/sales_report_buggy.py`.
+
+### Running the MCP server
+
+Configure your MCP client (Claude Desktop, an IDE extension, etc.) to
+launch `tdb-mcp` over stdio. Example `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "tdb": {
+      "command": "tdb-mcp"
+    }
+  }
+}
+```
+
+Three equivalent invocation forms: `tdb-mcp` (the dedicated entry
+point), `tdb --mcp` (the main CLI with the `--mcp` switch), and
+`python -m tdb.mcp` (module form). Pick whichever matches how your MCP
+client expects to launch servers.
+
+### Tool surface (16 tools, curated)
+
+| Cluster | Tools |
+|---------|-------|
+| Lifecycle | `debug_launch`, `debug_attach`, `quit` |
+| Control | `control(action, timeout_s=30)` — `action ∈ {continue, next, step_in, step_out, pause, wait_for_stop}` |
+| Inspection | `inspect(expressions)`, `read_source(file_path)`, `stack_trace()`, `status()`, `get_output()` |
+| Breakpoints | `set_breakpoint(spec, condition?, hit_condition?)`, `remove_breakpoint(spec)`, `list_breakpoints()` |
+| Differentiators | `threads(thread_id?)`, `tasks(task_name?)`, `processes(name_or_pid?)`, `wait_graph()` |
+
+`control` is intentionally one tool that takes an action enum — the six
+underlying RPC actions share a return shape, and agents perform
+measurably better with a small surface than with one tool per action.
+`threads` / `tasks` / `processes` overload list-vs-inspect via a
+single optional argument for the same reason.
+
+### Agent flow for a long-running step
+
+```
+agent → control(action="continue", timeout_s=30)
+mcp   → "still running — call pause or wait again"
+agent → control(action="pause")        # OR: control(action="wait_for_stop", timeout_s=30)
+mcp   → "<file>:<line>"
+agent → inspect(["x", "len(buf)"])
+mcp   → "x = 7\nlen(buf) = 1024"
+```
+
+`pause` bypasses the dispatch lock so it can interrupt a `continue`
+that's still mid-flight (HTTP and MCP share the same `NO_LOCK_ACTIONS`
+policy — see `tdb/server/app.py`).
+
+### Security caveat
+
+`inspect` calls debugpy's `evaluate`, which is **arbitrary Python
+execution in the debuggee process**. This is inherent to a debugger and
+not a tdb-specific concern, but MCP clients (and the humans running
+them) should apply appropriate permission models: don't auto-approve
+`inspect` against untrusted expressions, and don't expose `tdb-mcp` on
+a network — stdio transport only by design.
+
+### Deferred / out of scope (v1)
+
+- SSE-style event push — `control` and `wait_for_stop` make polling
+  efficient enough; events would also need uneven MCP-client support.
+- HTTP / streamable-HTTP transports — would require auth (which the
+  HTTP RPC server also currently lacks); stdio inherits the trust of
+  the process that spawned it.
+- Multi-session — one debug session per MCP process.
+
 ## CLI Reference
 
 ```

{textual_debugger-0.1.3 → textual_debugger-0.1.4}/src/tdb/__init__.py

@@ -1,6 +1,6 @@
 from tdb.breakpoint_hook import breakpoint
 from tdb.post_mortem import exception_hook
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 
 __all__ = ["breakpoint", "exception_hook"]

{textual_debugger-0.1.3 → textual_debugger-0.1.4}/src/tdb/app_handlers/inspection.py

@@ -20,18 +20,11 @@ from __future__ import annotations
 import logging
 import os
 import re
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 from tdb.dap.types import Source, StackFrame
-from tdb.inspection import (
-    PROCESS_COLLECT_EXPR,
-    ProcessInfo,
-    TASK_COLLECT_EXPR,
-    TASK_LOCALS_EXPR,
-    parse_process_json,
-    parse_task_json,
-)
+from tdb.inspection import ProcessInfo
+from tdb.session.inspect_service import InspectService, SessionGateError
 from tdb.widgets.async_tasks_modal import AsyncTasksModal
 from tdb.widgets.menu_bar import MenuBar
 from tdb.widgets.processes_modal import ProcessesModal
@@ -48,10 +41,17 @@ log = logging.getLogger(__name__)
 
 
 class InspectionWorkflows:
-    """Drives the threads/processes/async-tasks UI flows."""
+    """Drives the threads/processes/async-tasks UI flows.
+
+    Fetch-and-parse mechanics live in `tdb.session.inspect_service.
+    InspectService` (shared with the JSON-RPC server); this collaborator
+    holds only the TUI presentation around them — gates rendered as
+    toasts, modal lifecycle, menu-bar labels.
+    """
 
     def __init__(self, app: TdbApp) -> None:
         self.app = app
+        self._svc = InspectService(lambda: self.app.controller)
 
     # --- Async tasks ----------------------------------------------------
 
@@ -82,19 +82,15 @@ class InspectionWorkflows:
         if ctrl.state.is_running:
             self.app.notify("Program is running — pause first", title="Async Tasks")
             return
-        raw = ""
         try:
-            raw = await ctrl.evaluate(TASK_COLLECT_EXPR)
-            tasks = parse_task_json(raw)
+            tasks = await self._svc.collect_tasks()
+        except SessionGateError:
+            return  # phase changed between our gate and the fetch
         except Exception:
             log.exception("Error fetching async tasks")
             tasks = []
 
         if not tasks:
-            log.warning(
-                "Async task collection returned no tasks. Raw: %s",
-                raw[:300] if raw else "(empty)",
-            )
             self.app.notify(
                 "No asyncio tasks found (program may not use asyncio)",
                 title="Async Tasks",
@@ -110,12 +106,10 @@ class InspectionWorkflows:
         self.app.panels.async_tasks = None
 
     async def refresh_async_tasks(self) -> None:
-        ctrl = self.app.controller
-        if ctrl.state.is_terminated or ctrl.state.is_running:
-            return
         try:
-            raw = await ctrl.evaluate(TASK_COLLECT_EXPR)
-            tasks = parse_task_json(raw)
+            tasks = await self._svc.collect_tasks()
+        except SessionGateError:
+            return
         except Exception:
             log.exception("Error refreshing async tasks")
             return
@@ -124,29 +118,15 @@ class InspectionWorkflows:
 
     async def load_task_variables(self, task_name: str) -> None:
         """Fetch a task's local variables via DAP and populate the tree."""
-        ctrl = self.app.controller
-        if ctrl.state.is_terminated or ctrl.state.is_running:
-            return
         modal = self.app.panels.async_tasks
         if modal is None:
             return
-        variables: list = []
         try:
-            expr = TASK_LOCALS_EXPR.format(task_name=task_name)
-            # Route around synthetic frame ids — see
-            # controller.resolve_evaluate_frame_id. Without this, after
-            # the user has navigated to a task once, state.current_frame_id
-            # is negative and debugpy rejects the evaluate request.
-            frame_id = await ctrl.resolve_evaluate_frame_id(ctrl.active_client)
-            _result, var_ref = await ctrl.active_client.evaluate(
-                expr,
-                frame_id=frame_id,
-                context="repl",
-            )
-            if var_ref > 0:
-                variables = await ctrl.active_client.variables(var_ref)
-        except Exception:
-            log.debug("Failed to load variables for task %s", task_name)
+            # Routes around synthetic frame ids and evaluates against the
+            # active client — see InspectService.task_locals.
+            variables = await self._svc.task_locals(task_name)
+        except SessionGateError:
+            return
         modal.show_task_variables(variables)
 
     def navigate_to_task(self, task_name: str) -> bool:
@@ -213,7 +193,9 @@ class InspectionWorkflows:
             self.app.notify("Program is running — pause first", title="Threads")
             return
         try:
-            threads = await ctrl.client.threads()
+            threads = await self._svc.list_threads()
+        except SessionGateError:
+            return
         except Exception:
             log.exception("Error fetching threads")
             self.app.notify("Failed to fetch threads", title="Threads")
@@ -230,29 +212,16 @@ class InspectionWorkflows:
 
     async def load_thread_detail(self, thread_id: int) -> None:
         """Fetch stack trace and variables for a thread."""
-        ctrl = self.app.controller
-        if ctrl.state.is_terminated or ctrl.state.is_running:
-            return
         modal = self.app.panels.threads
         if modal is None:
             return
         try:
-            frames = await ctrl.client.stack_trace(thread_id)
+            frames, scopes, variables = await self._svc.thread_stack(thread_id)
+        except SessionGateError:
+            return
         except Exception:
             log.debug("Failed to fetch stack trace for thread %d", thread_id)
-            frames = []
-        scopes: list = []
-        variables: dict = {}
-        if frames:
-            top_frame = frames[0]
-            try:
-                scopes = await ctrl.client.scopes(top_frame.id)
-                for scope in scopes:
-                    variables[scope.variables_reference] = await ctrl.client.variables(
-                        scope.variables_reference
-                    )
-            except Exception:
-                log.debug("Failed to fetch variables for thread %d", thread_id)
+            frames, scopes, variables = [], [], {}
         modal.show_thread_detail(thread_id, frames, scopes, variables)
 
     # --- Full-Contents (variable subtree pre-fetch) --------------------
@@ -315,55 +284,17 @@ class InspectionWorkflows:
 
     # --- Processes ------------------------------------------------------
 
-    def get_processes_from_pids(self) -> list[ProcessInfo]:
-        """Build ProcessInfo list from tracked child PIDs via /proc.
+    async def get_processes(self) -> list[ProcessInfo]:
+        """Get child process info, trying eval on parent first, then /proc.
 
-        Linux-only fallback used when DAP `evaluate` against the parent
-        is unavailable (e.g., the parent isn't the active process).
+        Maps a gate failure (phase changed mid-flight) to an empty list:
+        callers treat "nothing to show" and "can't look right now" the
+        same way.
         """
-        result = []
-        for pid in self.app.controller.get_child_pids():
-            try:
-                cmdline_path = Path(f"/proc/{pid}/cmdline")
-                if not cmdline_path.exists():
-                    continue
-                cmdline = (
-                    cmdline_path.read_bytes().replace(b"\x00", b" ").decode().strip()
-                )
-                status_path = Path(f"/proc/{pid}/status")
-                name = f"Process-{pid}"
-                if status_path.exists():
-                    for line in status_path.read_text().splitlines():
-                        if line.startswith("Name:"):
-                            name = line.split(":", 1)[1].strip()
-                            break
-                result.append(
-                    ProcessInfo(
-                        name=name,
-                        pid=pid,
-                        alive=True,
-                        exitcode=None,
-                        daemon=False,
-                        target=cmdline[:200] if cmdline else "unknown",
-                        args="()",
-                        kwargs="{}",
-                        start_method="",
-                    )
-                )
-            except Exception:
-                pass
-        return result
-
-    async def get_processes(self) -> list[ProcessInfo]:
-        """Get child process info, trying eval on parent first, then /proc."""
         try:
-            raw = await self.app.controller.evaluate_on_parent(PROCESS_COLLECT_EXPR)
-            processes = parse_process_json(raw)
-            if processes:
-                return processes
-        except Exception:
-            pass
-        return self.get_processes_from_pids()
+            return await self._svc.collect_processes()
+        except SessionGateError:
+            return []
 
     async def fetch_process_count(self) -> None:
         """Update the Processes label with child process count."""
@@ -470,25 +401,10 @@ class InspectionWorkflows:
         modal = self.app.panels.processes
         if modal is None:
             return
-        child = self.app.controller.get_child_client(pid)
-        if child is None:
+        detail = await self._svc.process_stack(pid)
+        if detail is None:
             # PIDs from /proc might not exactly match the controller's keys
             modal.show_process_detail(pid, [], [], {})
             return
-        frames: list = []
-        scopes: list = []
-        variables: dict = {}
-        try:
-            threads = await child.threads()
-            if threads:
-                frames = await child.stack_trace(threads[0].id)
-                if frames:
-                    top_frame = frames[0]
-                    scopes = await child.scopes(top_frame.id)
-                    for scope in scopes:
-                        variables[scope.variables_reference] = await child.variables(
-                            scope.variables_reference
-                        )
-        except Exception:
-            log.debug("Failed to fetch detail for child process %d", pid)
+        frames, scopes, variables = detail
         modal.show_process_detail(pid, frames, scopes, variables)

{textual_debugger-0.1.3 → textual_debugger-0.1.4}/src/tdb/cli.py

@@ -9,14 +9,9 @@ from pathlib import Path
 
 
 def _get_version() -> str:
-    try:
-        from importlib.metadata import version
-
-        return version("textual-debugger")
-    except Exception:
-        from tdb import __version__
+    from tdb import __version__
 
-        return __version__
+    return __version__
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -141,6 +136,14 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Run as a headless JSON-RPC debug server (no TUI)",
     )
+    parser.add_argument(
+        "--mcp",
+        action="store_true",
+        help="Run as a Model Context Protocol (MCP) server over stdio. "
+        "Equivalent to `python -m tdb.mcp`. The session is owned by the "
+        "MCP client (via debug_launch / debug_attach tools); no program "
+        "argument is needed on the CLI.",
+    )
     parser.add_argument(
         "-k",
         "--breakpoint",
@@ -417,7 +420,7 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     args = parser.parse_args(argv)
     _apply_flag_implications(args)
 
-    if args.doc or args.doc_text or args.post_mortem:
+    if args.doc or args.doc_text or args.post_mortem or args.mcp:
         return args
 
     _validate_terminal_choice(args, parser)
@@ -461,12 +464,21 @@ def main(argv: list[str] | None = None) -> None:
         _run_doc_text()
     elif args.post_mortem:
         _run_post_mortem(args)
+    elif args.mcp:
+        _run_mcp()
     elif args.headless:
         _run_headless(args)
     else:
         _run_tui(args)
 
 
+def _run_mcp() -> None:
+    """Launch the MCP server over stdio. Mirrors `python -m tdb.mcp`."""
+    from tdb.mcp.server import main as mcp_main
+
+    mcp_main()
+
+
 def _run_doc() -> None:
     """Display the bundled README.md in a Textual MarkdownViewer."""
     from tdb.app_helpers import find_readme