deepagents-cli 0.0.58__tar.gz → 0.1.0__tar.gz

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Deep Agents CLI Changelog
 
+From 0.1.0 onward, `deepagents-cli` only contains `deploy`, `dev`, and `init`.
+The coding agent (interactive TUI & headless CLI) moved to [`deepagents-code`](https://github.com/langchain-ai/deepagents/blob/main/libs/code/CHANGELOG.md).
+
+## [0.1.0](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.59...deepagents-cli==0.1.0) (2026-05-16)
+
+### ⚠ BREAKING CHANGES
+
+* Removes the interactive TUI / coding-agent surface from `deepagents-cli`. The package now only ships the `deploy` command and supporting config. Users relying on the chat REPL, sessions, MCP tooling, skills, and related widgets should migrate to `deepagents-code`.
+
+## [0.0.59](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.58...deepagents-cli==0.0.59) (2026-05-12)
+
+### Bug Fixes
+
+* Prevent import deadlock during skill discovery and prewarm ([#3385](https://github.com/langchain-ai/deepagents/issues/3385)) ([0bf8dd1](https://github.com/langchain-ai/deepagents/commit/0bf8dd1cfd680bd4d27ce19295f96c720f525787))
+
 ## [0.0.58](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.57...deepagents-cli==0.0.58) (2026-05-12)
 
 ### Features

deepagents_cli-0.1.0/DEV.md

@@ -0,0 +1,44 @@
+# CLI Development Guide
+
+`deepagents-cli` now contains only the deployment subcommands (`init`, `dev`,
+`deploy`). For interactive-REPL development guidance, see
+[`libs/code/DEV.md`](../code/DEV.md).
+
+## Local setup
+
+```bash
+cd libs/cli && uv sync --group test
+```
+
+Run the CLI from a checkout:
+
+```bash
+uv run python -m deepagents_cli init my-agent
+uv run python -m deepagents_cli dev --config my-agent/deepagents.toml
+uv run python -m deepagents_cli deploy --config my-agent/deepagents.toml --dry-run
+```
+
+## Tests
+
+```bash
+make test       # unit tests (no network)
+make lint       # ruff + ty
+```
+
+Integration tests in `tests/integration_tests/` exercise the LangSmith Hub
+seeding path and require `LANGSMITH_API_KEY` to be set.
+
+## `langgraph` subcommand interop
+
+`dev` and `deploy` shell out to the `langgraph` CLI (`langgraph-cli[inmem]`
+runtime dependency). When debugging dev-server startup failures, run the
+generated command manually from the build directory printed by
+`print_bundle_summary`:
+
+```bash
+cd /tmp/deepagents-dev-XXXX
+langgraph dev --port 2024 --allow-blocking
+```
+
+The bundle is self-contained — re-running `langgraph dev` from the build
+directory reproduces the failure without re-bundling.

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: format lint type typecheck test tests integration_test integration_tests test_watch benchmark bench bench-memory help run lint_package lint_tests check_imports coverage
+.PHONY: format lint type typecheck test tests integration_test integration_tests test_watch help run lint_package lint_tests check_imports coverage
 
 .DEFAULT_GOAL := help
 
@@ -18,7 +18,7 @@ PYTEST_EXTRA ?=
 
 test: ## Run unit tests
 test tests:
-	uv run --group test pytest -n auto --benchmark-disable --disable-socket --allow-unix-socket $(PYTEST_EXTRA) $(TEST_FILE) \
+	uv run --group test pytest -n auto --disable-socket --allow-unix-socket $(PYTEST_EXTRA) $(TEST_FILE) \
 		$(COV_ARGS)
 
 coverage: ## Run unit tests with coverage
@@ -30,20 +30,11 @@ coverage: ## Run unit tests with coverage
 
 integration_test: ## Run integration tests
 integration_test integration_tests:
-	uv run --group test pytest -n auto --benchmark-disable -vvv --timeout 30 $(TEST_FILE)
+	uv run --group test pytest -n auto -vvv --timeout 30 $(TEST_FILE)
 
 test_watch: ## Run tests in watch mode
 	uv run --group test ptw --now . -- -vv $(TEST_FILE)
 
-benchmark: ## Run benchmark tests
-	uv run --group test pytest ./tests -m benchmark
-
-bench: ## Run benchmarks under CodSpeed instrumentation
-	uv run --group test pytest ./tests -m benchmark --codspeed
-
-bench-memory: ## Run memory benchmarks under CodSpeed instrumentation
-	uv run --group test pytest ./tests -m memory_benchmark --codspeed
-
 run: ## Reinstall and run package
 	uvx --no-cache --reinstall .
 

deepagents_cli-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: deepagents-cli
+Version: 0.1.0
+Summary: Deployment tooling for Deep Agents - bundle, run, and ship agents to LangGraph Platform.
+Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
+Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
+Project-URL: Repository, https://github.com/langchain-ai/deepagents
+Project-URL: Issues, https://github.com/langchain-ai/deepagents/issues
+Project-URL: Changelog, https://github.com/langchain-ai/deepagents/blob/main/libs/cli/CHANGELOG.md
+Project-URL: Twitter, https://x.com/langchain_oss
+Project-URL: Slack, https://www.langchain.com/join-community
+Project-URL: Reddit, https://www.reddit.com/r/LangChain/
+License: MIT
+Keywords: agents,ai,cli,deep-agent,deploy,langchain,langgraph,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0,>=3.11
+Requires-Dist: deepagents>=0.6.1
+Requires-Dist: httpx<1.0.0,>=0.28.1
+Requires-Dist: langchain<2.0.0,>=1.3.0
+Requires-Dist: langgraph-cli[inmem]<1.0.0,>=0.4.24
+Requires-Dist: langgraph-runtime-inmem<1.0.0,>=0.28.1
+Requires-Dist: langgraph-sdk<1.0.0,>=0.3.13
+Requires-Dist: langgraph<2.0.0,>=1.2.0
+Requires-Dist: langsmith>=0.8.0
+Requires-Dist: python-dotenv<2.0.0,>=1.2.2
+Provides-Extra: agentcore
+Requires-Dist: langchain-agentcore-codeinterpreter>=0.0.2; extra == 'agentcore'
+Provides-Extra: all-sandboxes
+Requires-Dist: langchain-agentcore-codeinterpreter>=0.0.2; extra == 'all-sandboxes'
+Requires-Dist: langchain-daytona>=0.0.5; extra == 'all-sandboxes'
+Requires-Dist: langchain-modal>=0.0.3; extra == 'all-sandboxes'
+Requires-Dist: langchain-runloop>=0.0.4; extra == 'all-sandboxes'
+Provides-Extra: daytona
+Requires-Dist: langchain-daytona>=0.0.5; extra == 'daytona'
+Provides-Extra: modal
+Requires-Dist: langchain-modal>=0.0.3; extra == 'modal'
+Provides-Extra: runloop
+Requires-Dist: langchain-runloop>=0.0.4; extra == 'runloop'
+Description-Content-Type: text/markdown
+
+# Deep Agents CLI — Deployment Tooling
+
+[![PyPI - Version](https://img.shields.io/pypi/v/deepagents-cli?label=%20)](https://pypi.org/project/deepagents-cli/#history)
+[![PyPI - License](https://img.shields.io/pypi/l/deepagents-cli)](https://opensource.org/licenses/MIT)
+[![PyPI - Downloads](https://img.shields.io/pepy/dt/deepagents-cli)](https://pypistats.org/packages/deepagents-cli)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain_oss)
+
+## Install
+
+```bash
+uv tool install deepagents-cli
+```
+
+Or with optional sandbox providers:
+
+```bash
+uv tool install 'deepagents-cli[all-sandboxes]'
+```
+
+## Usage
+
+```bash
+# Scaffold a new project folder
+deepagents init my-agent
+
+# Run a local langgraph dev server against the project
+cd my-agent && deepagents dev
+
+# Bundle and ship to LangSmith Deployment
+deepagents deploy
+```
+
+## 📖 Resources
+
+- **[CLI Documentation](https://docs.langchain.com/oss/python/deepagents/cli/overview)**
+- **[Changelog](https://github.com/langchain-ai/deepagents/blob/main/libs/cli/CHANGELOG.md)**
+- **[Source code](https://github.com/langchain-ai/deepagents/tree/main/libs/cli)**
+- **[Deep Agents SDK](https://github.com/langchain-ai/deepagents)** — underlying agent harness
+- **[Deep Agents Code](https://pypi.org/project/deepagents-code/)** — coding agent
+
+## 📕 Releases & Versioning
+
+See our [Releases](https://docs.langchain.com/oss/python/release-policy) and [Versioning](https://docs.langchain.com/oss/python/versioning) policies.
+
+## 💁 Contributing
+
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+
+For detailed information on how to contribute, see the [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview).

deepagents_cli-0.1.0/README.md

@@ -0,0 +1,49 @@
+# Deep Agents CLI — Deployment Tooling
+
+[![PyPI - Version](https://img.shields.io/pypi/v/deepagents-cli?label=%20)](https://pypi.org/project/deepagents-cli/#history)
+[![PyPI - License](https://img.shields.io/pypi/l/deepagents-cli)](https://opensource.org/licenses/MIT)
+[![PyPI - Downloads](https://img.shields.io/pepy/dt/deepagents-cli)](https://pypistats.org/packages/deepagents-cli)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain_oss)
+
+## Install
+
+```bash
+uv tool install deepagents-cli
+```
+
+Or with optional sandbox providers:
+
+```bash
+uv tool install 'deepagents-cli[all-sandboxes]'
+```
+
+## Usage
+
+```bash
+# Scaffold a new project folder
+deepagents init my-agent
+
+# Run a local langgraph dev server against the project
+cd my-agent && deepagents dev
+
+# Bundle and ship to LangSmith Deployment
+deepagents deploy
+```
+
+## 📖 Resources
+
+- **[CLI Documentation](https://docs.langchain.com/oss/python/deepagents/cli/overview)**
+- **[Changelog](https://github.com/langchain-ai/deepagents/blob/main/libs/cli/CHANGELOG.md)**
+- **[Source code](https://github.com/langchain-ai/deepagents/tree/main/libs/cli)**
+- **[Deep Agents SDK](https://github.com/langchain-ai/deepagents)** — underlying agent harness
+- **[Deep Agents Code](https://pypi.org/project/deepagents-code/)** — coding agent
+
+## 📕 Releases & Versioning
+
+See our [Releases](https://docs.langchain.com/oss/python/release-policy) and [Versioning](https://docs.langchain.com/oss/python/versioning) policies.
+
+## 💁 Contributing
+
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+
+For detailed information on how to contribute, see the [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview).

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/THREAT_MODEL.md

@@ -2,6 +2,15 @@
 
 > Generated: 2026-03-28 | Commit: e859077f | Scope: libs/cli only
 
+> ⚠️ **(2026-05-15):** This document was generated before the
+> 0.1.0 split that moved the interactive REPL out of `deepagents-cli`. The
+> sections covering the Textual app, `non_interactive.py`, MCP, sandbox
+> bootstrap, sessions, server subprocess management, hooks, and skills no
+> longer apply to this package — those surfaces now live under
+> [`libs/code/`](../code/THREAT_MODEL.md). The remaining in-scope surface is
+> `deepagents_cli.deploy` (bundler, templates, hub seeding) and the slim
+> `_load_dotenv`/`resolve_env_var` helpers in `config.py`/`model_config.py`.
+
 > **Disclaimer:** This threat model is automatically generated to help developers and security researchers understand where trust is placed in this system and where boundaries exist. It is experimental, subject to change, and not an authoritative security reference — findings should be validated before acting on them. The analysis may be incomplete or contain inaccuracies. We welcome suggestions and corrections to improve this document.
 
 ## Scope

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/deepagents_cli/__init__.py

@@ -1,4 +1,7 @@
-"""Deep Agents CLI - Interactive AI coding assistant."""
+"""Deep Agents CLI - deployment tooling (`init`, `dev`, `deploy`).
+
+For the interactive coding agent, install the `deepagents-code` package.
+"""
 
 from __future__ import annotations
 
@@ -16,17 +19,16 @@ __all__ = [
 
 
 def __getattr__(name: str) -> Callable[[], None]:
-    """Lazy import for `cli_main` to avoid loading `main.py` at package import.
+    """Lazy import for `cli_main` to keep `import deepagents_cli` cheap.
 
-    `main.py` pulls in `argparse`, signal handling, and other startup machinery
-    that isn't needed when submodules like `config` or `widgets` are
-    imported directly.
+    Args:
+        name: Attribute being looked up on the package.
 
     Returns:
-        The requested callable.
+        The requested attribute (only `cli_main` is provided lazily).
 
     Raises:
-        AttributeError: If *name* is not a lazily-provided attribute.
+        AttributeError: If `name` is not a lazily-provided attribute.
     """
     if name == "cli_main":
         from deepagents_cli.main import cli_main

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/deepagents_cli/__main__.py

@@ -1,4 +1,4 @@
-"""Allow running the CLI as: python -m deepagents.cli."""
+"""Allow running the CLI as `python -m deepagents_cli`."""
 
 from deepagents_cli.main import cli_main
 

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/deepagents_cli/_version.py

@@ -1,6 +1,8 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.58"  # x-release-please-version
+# Keep the `x-release-please-version` annotation — release-please uses it to
+# bump `__version__` in sync with `pyproject.toml` on every release PR.
+__version__ = "0.1.0"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

deepagents_cli-0.1.0/deepagents_cli/config.py

@@ -0,0 +1,128 @@
+"""Project and global `.env` loading for the deploy CLI."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def _stderr(msg: str) -> None:
+    """Print a diagnostic to stderr without a trailing newline corruption.
+
+    The CLI does not configure logging handlers by default, so `logger.warning`
+    output is invisible to end users. Diagnostics that the user authored — like
+    a malformed `.env` they meant to load — should also surface on stderr.
+    """
+    sys.stderr.write(f"warning: {msg}\n")
+
+
+def _find_dotenv_from_start_path(start_path: Path) -> Path | None:
+    """Find the nearest `.env` file from an explicit start path upward.
+
+    Args:
+        start_path: Directory to start searching from.
+
+    Returns:
+        Path to the nearest `.env` file, or `None` if not found.
+    """
+    current = start_path.expanduser().resolve()
+    for parent in [current, *list(current.parents)]:
+        candidate = parent / ".env"
+        try:
+            if candidate.is_file():
+                return candidate
+        except OSError:
+            logger.warning("Could not inspect .env candidate %s", candidate)
+            continue
+    return None
+
+
+try:
+    _GLOBAL_DOTENV_PATH = Path.home() / ".deepagents" / ".env"
+except RuntimeError:
+    # `Path.home()` raises when `HOME` is unset/misconfigured (e.g. on some
+    # CI runners). Fall back to a path that won't exist so `is_file()`
+    # short-circuits cleanly, and surface the suppression on stderr so the
+    # user knows global defaults will not apply.
+    _GLOBAL_DOTENV_PATH = Path("/nonexistent/.deepagents/.env")
+    _stderr(
+        "could not resolve home directory; "
+        "global `~/.deepagents/.env` will not be loaded",
+    )
+    logger.warning(
+        "Could not resolve home directory; global .env will not be loaded",
+        exc_info=True,
+    )
+
+
+def _load_dotenv(*, start_path: Path) -> bool:
+    """Load environment variables from project and global `.env` files.
+
+    Loads in order (first write wins, `override=False`):
+
+    1. Project `.env` — discovered upward from `start_path`.
+    2. `~/.deepagents/.env` — global user defaults.
+
+    Both layers use `override=False` so that shell-exported variables always
+    take precedence over dotenv files. Because the project file loads first,
+    the effective precedence is:
+
+    ```text
+    shell env > project `.env` > global `.env`
+    ```
+
+    When a *resolved* dotenv path fails to parse the user is notified on
+    stderr in addition to the structured `logger.warning` (the CLI does not
+    install logging handlers by default).
+
+    Args:
+        start_path: Directory to use for project `.env` discovery. Searched
+            upward until either a `.env` is found or the filesystem root is
+            reached.
+
+    Returns:
+        `True` when at least one dotenv file was loaded, `False` otherwise.
+    """
+    import dotenv
+
+    loaded = False
+
+    dotenv_path = _find_dotenv_from_start_path(start_path)
+    if dotenv_path is not None:
+        try:
+            loaded = (
+                dotenv.load_dotenv(dotenv_path=dotenv_path, override=False) or loaded
+            )
+        except (OSError, ValueError) as exc:
+            _stderr(
+                f"could not read project .env at {dotenv_path}: {exc}. "
+                "Project env vars will not be loaded.",
+            )
+            logger.warning(
+                "Could not read project dotenv at %s; "
+                "project env vars will not be loaded",
+                dotenv_path,
+                exc_info=True,
+            )
+
+    try:
+        if _GLOBAL_DOTENV_PATH.is_file() and dotenv.load_dotenv(
+            dotenv_path=_GLOBAL_DOTENV_PATH, override=False
+        ):
+            loaded = True
+            logger.debug("Loaded global dotenv: %s", _GLOBAL_DOTENV_PATH)
+    except (OSError, ValueError) as exc:
+        _stderr(
+            f"could not read global .env at {_GLOBAL_DOTENV_PATH}: {exc}. "
+            "Global defaults will not be applied.",
+        )
+        logger.warning(
+            "Could not read global dotenv at %s; global defaults will not be applied",
+            _GLOBAL_DOTENV_PATH,
+            exc_info=True,
+        )
+
+    return loaded

{deepagents_cli-0.0.58 → deepagents_cli-0.1.0}/deepagents_cli/deploy/commands.py

@@ -46,6 +46,7 @@ def setup_deploy_parsers(
         "-h",
         "--help",
         action=make_help_action(lambda: init_parser.print_help()),
+        help="show this help message and exit",
     )
     init_parser.add_argument(
         "--force",
@@ -63,6 +64,7 @@ def setup_deploy_parsers(
         "-h",
         "--help",
         action=make_help_action(lambda: dev_parser.print_help()),
+        help="show this help message and exit",
     )
     dev_parser.add_argument(
         "--config",
@@ -93,6 +95,7 @@ def setup_deploy_parsers(
         "-h",
         "--help",
         action=make_help_action(lambda: deploy_parser.print_help()),
+        help="show this help message and exit",
     )
     deploy_parser.add_argument(
         "--config",

deepagents_cli-0.1.0/deepagents_cli/main.py

@@ -0,0 +1,167 @@
+"""Entry point for the `deepagents` CLI.
+
+As of `deepagents-cli==0.1.0` the interactive Textual REPL has moved to the
+[`deepagents-code`](https://pypi.org/project/deepagents-code/) package. This
+CLI now exposes only the deployment-oriented commands: `init`, `dev`, and
+`deploy`. Bare invocations print a deprecation notice and exit non-zero.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+from deepagents_cli._version import __version__
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+_REPL_REDIRECT_MESSAGE = (
+    "The interactive `deepagents` REPL has moved to the `deepagents-code` "
+    "package.\n"
+    "Install it with:\n\n"
+    "  pip install deepagents-code\n\n"
+    "Then run `deepagents-code` to start an interactive session.\n\n"
+    "The `deepagents` CLI now only provides the `init`, `dev`, and `deploy` "
+    "subcommands."
+)
+
+
+def _make_help_action(
+    help_fn: Callable[[], None],
+) -> type[argparse.Action]:
+    """Create an argparse Action that calls `help_fn` and exits.
+
+    argparse requires a *class* (not a callable) for custom actions; this
+    factory uses a closure so each subcommand can wire `-h` to its own
+    `print_help()`.
+
+    Args:
+        help_fn: Callable that prints help text to stdout.
+
+    Returns:
+        An argparse Action class wired to the given help function.
+    """
+
+    class _ShowHelp(argparse.Action):
+        def __init__(
+            self,
+            option_strings: list[str],
+            dest: str = argparse.SUPPRESS,
+            default: str = argparse.SUPPRESS,
+            **kwargs: Any,
+        ) -> None:
+            super().__init__(
+                option_strings=option_strings,
+                dest=dest,
+                default=default,
+                nargs=0,
+                **kwargs,
+            )
+
+        def __call__(
+            self,
+            parser: argparse.ArgumentParser,
+            namespace: argparse.Namespace,  # noqa: ARG002
+            values: str | Sequence[Any] | None,  # noqa: ARG002
+            option_string: str | None = None,  # noqa: ARG002
+        ) -> None:
+            with contextlib.suppress(BrokenPipeError):
+                help_fn()
+            parser.exit()
+
+    return _ShowHelp
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the top-level argparse parser for the deploy/dev/init CLI.
+
+    Returns:
+        Configured `ArgumentParser` with `init`, `dev`, and `deploy`
+        subparsers registered.
+    """
+    from deepagents_cli.deploy import setup_deploy_parsers
+
+    parser = argparse.ArgumentParser(
+        prog="deepagents",
+        description=(
+            "Deep Agents - deployment tooling.\n\n"
+            "For interactive chat, install `deepagents-code` instead."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,
+    )
+    parser.add_argument(
+        "-h",
+        "--help",
+        action=_make_help_action(parser.print_help),
+        help="show this help message and exit",
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"deepagents-cli {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    setup_deploy_parsers(subparsers, make_help_action=_make_help_action)
+    return parser
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    """Parse CLI arguments and return the resulting namespace.
+
+    Args:
+        argv: Optional argument list (defaults to `sys.argv[1:]`).
+
+    Returns:
+        Parsed argparse `Namespace`.
+    """
+    parser = _build_parser()
+    return parser.parse_args(argv)
+
+
+def cli_main() -> None:
+    """Entry point for the `deepagents` and `deepagents-cli` console scripts.
+
+    Raises:
+        SystemExit: On `--help`/`--version`, after a subcommand finishes,
+            on `KeyboardInterrupt`, when invoked without a subcommand (the
+            user is redirected to `deepagents-code`), or when a subcommand
+            handler raises `SystemExit` directly (e.g. config validation
+            failures in `execute_deploy_command`).
+    """
+    if sys.platform == "darwin":
+        # gRPC (pulled in transitively by LangSmith deps) crashes on macOS
+        # when the process forks after gRPC has been initialized. Disable
+        # fork support to avoid the abort; the current deploy/dev paths
+        # don't fork, so disabling fork support is a safe default —
+        # reconsider this env var if a future subcommand spawns workers.
+        os.environ.setdefault("GRPC_ENABLE_FORK_SUPPORT", "0")
+
+    args = parse_args()
+
+    try:
+        if args.command == "init":
+            from deepagents_cli.deploy import execute_init_command
+
+            execute_init_command(args)
+        elif args.command == "dev":
+            from deepagents_cli.deploy import execute_dev_command
+
+            execute_dev_command(args)
+        elif args.command == "deploy":
+            from deepagents_cli.deploy import execute_deploy_command
+
+            execute_deploy_command(args)
+        else:
+            sys.stderr.write(_REPL_REDIRECT_MESSAGE + "\n")
+            raise SystemExit(1)
+    except KeyboardInterrupt:
+        sys.stderr.write("\nInterrupted.\n")
+        raise SystemExit(130) from None