deepagents-cli 0.0.45__tar.gz → 0.0.46__tar.gz

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.0.46](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.45...deepagents-cli==0.0.46) (2026-04-30)
+
+### Features
+
+* Rework MCP integration and add OAuth login ([#2906](https://github.com/langchain-ai/deepagents/issues/2906)) ([6b7b0be](https://github.com/langchain-ai/deepagents/commit/6b7b0bef95db673fed23fc92803abaaa398b0a6d))
+* `allowedTools` and `disabledTools` filters in MCP config ([#2835](https://github.com/langchain-ai/deepagents/issues/2835)) ([eafd691](https://github.com/langchain-ai/deepagents/commit/eafd6912db637ab59085a0b05d6e36d6cdd10e1a))
+
 ## [0.0.45](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.44...deepagents-cli==0.0.45) (2026-04-30)
 
 ### Bug Fixes

deepagents_cli-0.0.46/DEV.md

@@ -0,0 +1,92 @@
+# CLI Development Guide
+
+## Live CSS development with Textual devtools
+
+Textual's devtools console enables CSS hot-reload and live `self.log()` output during development.
+
+### Prerequisites
+
+Sync the `test` dependency group (includes `textual-dev`):
+
+```bash
+cd libs/cli && uv sync --group test
+```
+
+Create the dev wrapper script (one-time):
+
+```bash
+cat > /tmp/dev_deepagents.py << 'PYEOF'
+"""Dev wrapper to run Deep Agents CLI with textual devtools."""
+import sys
+sys.argv = ["deepagents"] + sys.argv[1:]
+
+from deepagents_cli.main import cli_main
+cli_main()
+PYEOF
+```
+
+### Running
+
+**Terminal 1** — devtools console:
+
+```bash
+cd libs/cli && uv run --group test textual console
+```
+
+**Terminal 2** — CLI with live reload:
+
+```bash
+cd libs/cli && uv run --group test textual run --dev /tmp/dev_deepagents.py
+```
+
+Edit any `.tcss` file and save — changes appear immediately. Any `self.log()` calls in widget code show in the console.
+
+### Console options
+
+- `textual console -v` — verbose mode, shows all events (key presses, mouse, etc.)
+- `textual console -x EVENT` — exclude noisy event groups
+- `textual console --port 7342` — custom port (pass matching `--port` to `textual run`)
+
+### Why the wrapper script?
+
+`textual run --dev` handles the devtools connection, but it needs to run inside the project's virtualenv to import `deepagents_cli`. The wrapper script bridges the gap — `uv run --group test textual run --dev` ensures both `textual-dev` (from the `test` group) and `deepagents_cli` are available in the same environment.
+
+## Debugging
+
+The CLI runs a `langgraph dev` subprocess for every interactive session. When the subprocess crashes during startup, the TUI shows a one-line failure banner; the actual exception lives in the subprocess's stdout/stderr, which is captured to a temp file.
+
+### Environment variables
+
+| Variable | Effect |
+| --- | --- |
+| `DEEPAGENTS_CLI_DEBUG=1` | Preserves the server subprocess log on shutdown and prints its path to stderr. Without this, the log is deleted when the process stops. Also enables the CLI-process file handler below. Accepts `1`/`true`/`yes`/`on` (case-insensitive) as enabled; `0`/`false`/`no`/`off`/empty/unset as disabled. |
+| `DEEPAGENTS_CLI_DEBUG_FILE=<path>` | Overrides the default path (`/tmp/deepagents_debug.log`) for the CLI-process file handler, which attaches at `DEBUG` level to `textual_adapter` and `remote_client`. **Only takes effect when `DEEPAGENTS_CLI_DEBUG` is truthy.** Useful for diagnosing streaming/client-side issues; does **not** capture the server subprocess. |
+
+`DEEPAGENTS_CLI_DEBUG` is what you want for startup crashes (graph init, MCP config, sandbox): the preserved subprocess log contains the real traceback. The optional `DEEPAGENTS_CLI_DEBUG_FILE` override is for post-startup client-side debugging.
+
+### Finding the server subprocess log
+
+On macOS, `tempfile` resolves to `$TMPDIR` (a path under `/var/folders/.../T/`). Each `ServerProcess` writes its combined stdout+stderr to a file matching `deepagents_server_log_*.txt`:
+
+```bash
+# Newest first
+ls -lt ${TMPDIR:-/tmp}/deepagents_server_log_*.txt | head -5
+
+# Tail the latest while reproducing the crash
+tail -F "$(ls -t ${TMPDIR:-/tmp}/deepagents_server_log_*.txt | head -1)"
+```
+
+The interesting line is `Failed to initialize server graph: <exc>` followed by a traceback — everything above that is uvicorn/lifespan unwinding.
+
+### Triage flow for a startup crash
+
+1. **Rerun with `DEEPAGENTS_CLI_DEBUG=1`.** The log is preserved and a "Server log preserved at: ..." line is printed to stderr. Textual's fullscreen mode can hide that line, but the file itself is still on disk.
+2. **Locate the log** via the `ls` command above. Open it in your editor.
+3. **Search for `Failed to initialize server graph`.** The stack trace beneath names the concrete failure point (MCP config validation, sandbox init, model resolution, subagent load, etc.).
+4. **Pre-flight validators run in the CLI process** for the common failure modes (e.g., `--mcp-config` is validated in `start_server_and_get_agent` before the subprocess spawns). When the banner shows `MCPConfigError: <path>: <reason>`, the subprocess never started — fix the file and retry.
+
+### Common startup failure patterns
+
+- **`MCPConfigError: Invalid MCP config at <path>: ...`** — malformed `--mcp-config`. The pre-flight wraps the underlying `ValueError`/`TypeError` with the offending path. See `_preflight_validate_mcp_config` in `server_manager.py`.
+- **`Server 'X' missing required 'command' field`** (from a discovered project `.mcp.json`, not `--mcp-config`) — an stdio server config without `command`. For remote servers, just use `{"url": "..."}`; transport is inferred as `http` when no `type`/`transport` is present.
+- **Uncaught exception inside a bare `sys.exit(1)`** — usually means the surrounding `make_graph()` raised. Look one traceback up in the subprocess log for the real cause.

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.45
+Version: 0.0.46
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/deepagents_cli/_debug.py

@@ -12,7 +12,7 @@ import logging
 import os
 from pathlib import Path
 
-from deepagents_cli._env_vars import DEBUG, DEBUG_FILE
+from deepagents_cli._env_vars import DEBUG, DEBUG_FILE, is_env_truthy
 
 
 def configure_debug_logging(target: logging.Logger) -> None:
@@ -22,12 +22,12 @@ def configure_debug_logging(target: logging.Logger) -> None:
     with `DEEPAGENTS_CLI_DEBUG_FILE`. The handler appends so that multiple
     modules share the same log file across a session.
 
-    Does nothing when `DEEPAGENTS_CLI_DEBUG` is not set.
+    Does nothing when `DEEPAGENTS_CLI_DEBUG` is not truthy (see `is_env_truthy`).
 
     Args:
         target: Logger to configure.
     """
-    if not os.environ.get(DEBUG):
+    if not is_env_truthy(DEBUG):
         return
 
     debug_path = Path(

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/deepagents_cli/_env_vars.py

@@ -23,6 +23,8 @@ ever renamed, only the value here changes.
 
 from __future__ import annotations
 
+import os
+
 # ---------------------------------------------------------------------------
 # Constants — import these instead of bare string literals.
 # Keep alphabetically sorted by constant name.
@@ -32,7 +34,10 @@ AUTO_UPDATE = "DEEPAGENTS_CLI_AUTO_UPDATE"
 """Enable automatic CLI updates ('1', 'true', or 'yes')."""
 
 DEBUG = "DEEPAGENTS_CLI_DEBUG"
-"""Enable verbose debug logging to a file."""
+"""Enable verbose debug logging and preserve the server subprocess log.
+
+Parsed by `is_env_truthy`: accepts `1`, `true`, `yes`, `on` (case-insensitive)
+as enabled, and `0`, `false`, `no`, `off`, empty string, or unset as disabled."""
 
 DEBUG_FILE = "DEEPAGENTS_CLI_DEBUG_FILE"
 """Path for the debug log file (default: `/tmp/deepagents_debug.log`)."""
@@ -69,3 +74,35 @@ SHELL_ALLOW_LIST = "DEEPAGENTS_CLI_SHELL_ALLOW_LIST"
 
 USER_ID = "DEEPAGENTS_CLI_USER_ID"
 """Attach a user identifier to LangSmith trace metadata."""
+
+
+_TRUTHY_VALUES = frozenset({"1", "true", "yes", "on"})
+_FALSY_VALUES = frozenset({"0", "false", "no", "off", ""})
+
+
+def is_env_truthy(name: str, *, default: bool = False) -> bool:
+    """Return whether env var *name* is set to a recognizably truthy value.
+
+    Unlike `bool(os.environ.get(name))`, this does not treat `"0"` or
+    `"false"` as enabled. Use this for on/off flags where the user would
+    reasonably expect `VAR=0` to mean "disabled".
+
+    Args:
+        name: Environment variable name (typically a `DEEPAGENTS_CLI_*`
+            constant from this module).
+        default: Value returned when the variable is unset OR set to a
+            value that is neither recognizably truthy nor falsy.
+
+    Returns:
+        `True` for `1`/`true`/`yes`/`on` (case-insensitive), `False` for
+        `0`/`false`/`no`/`off`/empty string, or `default` otherwise.
+    """
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    lowered = raw.strip().lower()
+    if lowered in _TRUTHY_VALUES:
+        return True
+    if lowered in _FALSY_VALUES:
+        return False
+    return default

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/deepagents_cli/_version.py

@@ -1,6 +1,6 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.45"  # x-release-please-version
+__version__ = "0.0.46"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/deepagents_cli/app.py

@@ -428,6 +428,27 @@ def _truncate(text: str, *, limit: int) -> str:
     return text[: limit - 1].rstrip() + "…"
 
 
+def _format_startup_error(error: BaseException) -> str:
+    """Format a server-startup exception for the welcome banner.
+
+    `wait_for_server_healthy` appends a tail of the subprocess log to its
+    `RuntimeError` message (see `_LOG_TAIL_CHARS` in `server.py`), which
+    would overwhelm the banner. Trim to the headline so the user sees an
+    actionable line instead of a scrolling traceback; `DEEPAGENTS_CLI_DEBUG=1`
+    preserves the full log on disk for triage.
+
+    Args:
+        error: The exception raised during server startup.
+
+    Returns:
+        A single-line `Type: message` summary suitable for the banner.
+    """
+    first_line = str(error).splitlines()[0].strip() if str(error) else ""
+    if not first_line:
+        first_line = error.__class__.__name__
+    return f"{type(error).__name__}: {_truncate(first_line, limit=300)}"
+
+
 class TextualSessionState:
     """Session state for the Textual app."""
 
@@ -755,6 +776,19 @@ class DeepAgentsApp(App):
         self._mcp_tool_count = sum(len(s.tools) for s in (mcp_server_info or []))
         """Total tool count across MCP servers, displayed in the status bar."""
 
+        self._mcp_unauthenticated = sum(
+            1 for s in (mcp_server_info or []) if s.status == "unauthenticated"
+        )
+        """MCP servers awaiting a `deepagents mcp login` run."""
+
+        self._mcp_errored = sum(
+            1 for s in (mcp_server_info or []) if s.status == "error"
+        )
+        """MCP servers that failed to load (config or network error)."""
+
+        self._active_mcp_viewer: Any = None
+        """Handle to the `/mcp` modal so server-ready events can refresh it."""
+
         self._profile_override = profile_override
         """Extra profile fields from `--profile-override`, retained so later
         profile-aware behavior (model selection, offload budget display,
@@ -1090,6 +1124,8 @@ class DeepAgentsApp(App):
             yield WelcomeBanner(
                 thread_id=self._lc_thread_id,
                 mcp_tool_count=self._mcp_tool_count,
+                mcp_unauthenticated=self._mcp_unauthenticated,
+                mcp_errored=self._mcp_errored,
                 connecting=self._connecting,
                 resuming=self._resume_thread_intent is not None,
                 local_server=self._server_kwargs is not None,
@@ -1707,14 +1743,28 @@ class DeepAgentsApp(App):
         self._server_proc = event.server_proc
         self._mcp_server_info = event.mcp_server_info
         self._mcp_tool_count = sum(len(s.tools) for s in (event.mcp_server_info or []))
+        self._mcp_unauthenticated = sum(
+            1 for s in (event.mcp_server_info or []) if s.status == "unauthenticated"
+        )
+        self._mcp_errored = sum(
+            1 for s in (event.mcp_server_info or []) if s.status == "error"
+        )
 
         # Update welcome banner to show ready state
         try:
             banner = self.query_one("#welcome-banner", WelcomeBanner)
-            banner.set_connected(self._mcp_tool_count)
+            banner.set_connected(
+                self._mcp_tool_count,
+                mcp_unauthenticated=self._mcp_unauthenticated,
+                mcp_errored=self._mcp_errored,
+            )
         except NoMatches:
             logger.warning("Welcome banner not found during server ready transition")
 
+        if self._active_mcp_viewer is not None:
+            with suppress(Exception):
+                self._active_mcp_viewer.refresh_server_info(self._mcp_server_info or [])
+
         # Session-start sequence: load resumed history, run `--startup-cmd`
         # (if any), then dispatch the initial prompt/skill and drain
         # user-typed messages. Sequenced through a single task so the
@@ -1746,8 +1796,14 @@ class DeepAgentsApp(App):
 
     def on_deep_agents_app_server_start_failed(self, event: ServerStartFailed) -> None:
         """Handle background server startup failure."""
+        from deepagents_cli.mcp_tools import MCPConfigError
+
         self._connecting = False
-        self._server_startup_error = f"{type(event.error).__name__}: {event.error}"
+        if isinstance(event.error, MCPConfigError):
+            # Already carries the path + hint; showing the class name is noise.
+            self._server_startup_error = str(event.error)
+        else:
+            self._server_startup_error = _format_startup_error(event.error)
         logger.error("Server startup failed: %s", event.error, exc_info=event.error)
         # Update banner to show persistent failure state
         try:
@@ -5048,6 +5104,7 @@ class DeepAgentsApp(App):
         bar indicator and session state.
         """
         from deepagents_cli.widgets.agent_selector import AgentSelectorScreen
+        from deepagents_cli.widgets.mcp_viewer import MCPViewerScreen
         from deepagents_cli.widgets.notification_center import (
             NotificationCenterScreen,
         )
@@ -5074,6 +5131,9 @@ class DeepAgentsApp(App):
         ):
             self.screen.action_move_up()
             return
+        if isinstance(self.screen, MCPViewerScreen):
+            self.screen.action_move_up()
+            return
         # shift+tab is reused for navigation inside modal screens (e.g.
         # ModelSelectorScreen); skip the toggle so it doesn't fire through.
         if isinstance(self.screen, ModalScreen):
@@ -5645,7 +5705,11 @@ class DeepAgentsApp(App):
                 self._connecting = False
                 try:
                     banner = self.query_one("#welcome-banner", WelcomeBanner)
-                    banner.set_connected(self._mcp_tool_count)
+                    banner.set_connected(
+                        self._mcp_tool_count,
+                        mcp_unauthenticated=self._mcp_unauthenticated,
+                        mcp_errored=self._mcp_errored,
+                    )
                 except NoMatches:
                     pass
                 self.notify(
@@ -6221,9 +6285,14 @@ class DeepAgentsApp(App):
         """Show read-only MCP server/tool viewer as a modal screen."""
         from deepagents_cli.widgets.mcp_viewer import MCPViewerScreen
 
-        screen = MCPViewerScreen(server_info=self._mcp_server_info or [])
+        screen = MCPViewerScreen(
+            server_info=self._mcp_server_info or [],
+            connecting=self._connecting,
+        )
+        self._active_mcp_viewer = screen
 
         def handle_result(result: None) -> None:  # noqa: ARG001
+            self._active_mcp_viewer = None
             if self._chat_input:
                 self._chat_input.focus_input()
 

{deepagents_cli-0.0.45 → deepagents_cli-0.0.46}/deepagents_cli/main.py

@@ -388,6 +388,7 @@ def parse_args() -> argparse.Namespace:
         Parsed arguments namespace.
     """
     from deepagents_cli.deploy import setup_deploy_parsers
+    from deepagents_cli.mcp_commands import setup_mcp_parsers
     from deepagents_cli.output import add_json_output_arg
     from deepagents_cli.skills import setup_skills_parser
 
@@ -516,6 +517,10 @@ def parse_args() -> argparse.Namespace:
         subparsers,
         make_help_action=_make_help_action,
     )
+    setup_mcp_parsers(
+        subparsers,
+        make_help_action=_make_help_action,
+    )
 
     threads_parser = subparsers.add_parser(
         "threads",
@@ -1301,24 +1306,29 @@ def _print_session_stats(stats: Any, console: Any) -> None:  # noqa: ANN401
 
 
 def _check_mcp_project_trust(*, trust_flag: bool = False) -> bool | None:
-    """Check whether project-level MCP stdio servers should be trusted.
+    """Check whether project-level MCP servers should be trusted.
+
+    Both stdio and remote (http/sse) project entries require approval —
+    remote entries from an attacker-controlled `.mcp.json` can SSRF or
+    exfiltrate environment variables via `${VAR}` interpolation in their
+    `headers`, so they are gated identically to stdio commands.
 
-    When the project has no stdio servers in project-level configs, returns
-    `None` (no gate needed). When `--trust-project-mcp` was passed, returns
-    `True`. Otherwise checks the persistent trust store; if untrusted, shows
-    an interactive approval prompt.
+    When the project has no servers in project-level configs, returns
+    `None` (no gate needed). When `--trust-project-mcp` was passed,
+    returns `True`. Otherwise checks the persistent trust store; if
+    untrusted, shows an interactive approval prompt.
 
     Args:
         trust_flag: Whether `--trust-project-mcp` was passed.
 
     Returns:
-        `True` to allow project stdio servers, `False` to deny, or `None`
-            when no project stdio servers exist.
+        `True` to allow project servers, `False` to deny, or `None`
+            when no project servers exist.
     """
     from deepagents_cli.mcp_tools import (
         classify_discovered_configs,
         discover_mcp_configs,
-        extract_stdio_server_commands,
+        extract_project_server_summaries,
         load_mcp_config_lenient,
     )
     from deepagents_cli.project_utils import ProjectContext
@@ -1333,14 +1343,14 @@ def _check_mcp_project_trust(*, trust_flag: bool = False) -> bool | None:
     if not project_configs:
         return None
 
-    # Collect all stdio servers across project configs
-    all_stdio: list[tuple[str, str, list[str]]] = []
+    # Collect all servers (stdio + remote) across project configs
+    all_servers: list[tuple[str, str, str]] = []
     for path in project_configs:
         cfg = load_mcp_config_lenient(path)
         if cfg is not None:
-            all_stdio.extend(extract_stdio_server_commands(cfg))
+            all_servers.extend(extract_project_server_summaries(cfg))
 
-    if not all_stdio:
+    if not all_servers:
         return None
 
     if trust_flag:
@@ -1369,9 +1379,8 @@ def _check_mcp_project_trust(*, trust_flag: bool = False) -> bool | None:
     prompt_console.print(
         "[bold yellow]Project MCP servers require approval:[/bold yellow]"
     )
-    for name, cmd, args in all_stdio:
-        args_str = " ".join(args) if args else ""
-        prompt_console.print(f'  [bold]"{name}"[/bold]:  {cmd} {args_str}')
+    for name, kind, summary in all_servers:
+        prompt_console.print(f'  [bold]"{name}"[/bold] ({kind}):  {summary}')
     prompt_console.print()
 
     try:
@@ -1767,6 +1776,27 @@ def cli_main() -> None:
             from deepagents_cli.deploy import execute_deploy_command
 
             execute_deploy_command(args)
+        elif args.command == "mcp":
+            from deepagents_cli.mcp_commands import run_mcp_login
+            from deepagents_cli.ui import show_mcp_help
+
+            if args.mcp_command == "login":
+                if getattr(args, "mcp_config", None) and not args.config_path:
+                    print(  # noqa: T201
+                        "--mcp-config is not supported for 'mcp login'. "
+                        "Use: deepagents mcp login <server> --config <path>",
+                        file=sys.stderr,
+                    )
+                    sys.exit(2)
+                sys.exit(
+                    asyncio.run(
+                        run_mcp_login(
+                            server=args.server,
+                            config_path=args.config_path,
+                        )
+                    )
+                )
+            show_mcp_help()
         elif args.command == "threads":
             from deepagents_cli.sessions import (
                 delete_thread_command,