�[38;5;243m 1�[0m �[38;5;249mfix(deploy): make scaffolded main.py app fully-featured for uvicorn parity with agentomatic run�[0m

�[38;5;243m   2�[0m
�[38;5;243m   3�[0m   �[38;5;249m- main.py now builds an env-driven, fully-featured module-level `app` so a�[0m
�[38;5;243m   4�[0m   �[38;5;249m  deployed container (`uvicorn main:app`) serves the same surface as�[0m
�[38;5;243m   5�[0m   �[38;5;249m  `agentomatic run`: discovers all component dirs and enables Studio, docs,�[0m
�[38;5;243m   6�[0m   �[38;5;249m  health, and metrics by default�[0m
�[38;5;243m   7�[0m   �[38;5;249m- feature flags read from AGENTOMATIC_* env vars (ENABLE_STUDIO, ENABLE_METRICS,�[0m
�[38;5;243m   8�[0m   �[38;5;249m  ENABLE_AUTH, ENABLE_JWT, REQUIRE_AUTH -> implies JWT + zero-trust,�[0m
�[38;5;243m   9�[0m   �[38;5;249m  ENABLE_CONTROL_PLANE, ENABLE_RATE_LIMIT, TITLE, LOG_LEVEL) so the same file�[0m
�[38;5;243m  10�[0m   �[38;5;249m  works in dev and in the container without code edits�[0m
�[38;5;243m  11�[0m   �[38;5;249m- .env.example documents the deploy feature flags�[0m
�[38;5;243m  12�[0m   �[38;5;249m- deployment guide + 1.2.1 changelog (docs/changelog.md + CHANGELOG.md) note�[0m
�[38;5;243m  13�[0m   �[38;5;249m  the uvicorn main:app parity�[0m
�[38;5;243m  14�[0m   �[38;5;249m- new parity tests: build the scaffolded app and assert run-equivalent routes�[0m
�[38;5;243m  15�[0m   �[38;5;249m  (/health, /readiness, /docs, /openapi.json, /, /studio); env flags drive�[0m
�[38;5;243m  16�[0m   �[38;5;249m  features (studio toggle + title)�[0m
�[38;5;243m  17�[0m
�[38;5;243m  18�[0m   �[38;5;249mruff/format/mypy/pytest(1187)/mkdocs --strict/uv build all green.�[0m

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: piotrlaczkowski

CHANGELOG.md

@@ -40,6 +40,10 @@ Full detail lives in [`docs/changelog.md`](docs/changelog.md); highlights:
   skipped run is observable
 - CORS: wildcard origins auto-disable `allow_credentials` (safer default);
   configure explicit `cors_origins=[...]` to enable credentialed CORS
+- Deploy parity: scaffolded `main.py` builds a fully-featured, env-driven `app`
+  so `uvicorn main:app` in a container serves the same surface as
+  `agentomatic run` (Studio/docs/health/metrics on by default; auth, control
+  plane, and rate limiting toggle via `AGENTOMATIC_*` env vars)
 
 
 ## v1.2.0 (2026-07-14)

docs/changelog.md

@@ -58,6 +58,13 @@ breaking API changes.
 - **CORS hardening (P2)**: wildcard origins (`cors_origins=["*"]`) no longer
   send `Access-Control-Allow-Credentials: true` — credentials are auto-disabled
   (with a one-time warning) unless explicit origins are configured
+- **Deploy parity (`uvicorn main:app` == `agentomatic run`)**: the scaffolded
+  `main.py` now builds a fully-featured, env-driven `app` (Studio, docs, health,
+  metrics on by default; all component dirs discovered) so a deployed container
+  serves the exact same surface as `agentomatic run`. Feature flags read from
+  `AGENTOMATIC_*` env vars (`ENABLE_STUDIO`, `ENABLE_METRICS`, `ENABLE_AUTH`,
+  `ENABLE_JWT`, `REQUIRE_AUTH`, `ENABLE_CONTROL_PLANE`, `ENABLE_RATE_LIMIT`,
+  `TITLE`, `LOG_LEVEL`) so the same file works in dev and in the container
 
 ---
 

docs/guide/deployment.md

@@ -437,6 +437,17 @@ Run it:
     agentomatic run agents/ --host 0.0.0.0 --port 8000
     ```
 
+!!! tip "Scaffolded `main.py` matches `agentomatic run`"
+    Projects created with `agentomatic init --project` (and containers built by
+    `agentomatic deploy`) ship a `main.py` whose module-level `app` is **feature-
+    identical to `agentomatic run`**: it discovers every component directory and
+    turns Studio, docs, health, and metrics on by default. Auth, control plane,
+    and rate limiting are driven by `AGENTOMATIC_*` env vars
+    (`AGENTOMATIC_ENABLE_AUTH`, `AGENTOMATIC_ENABLE_JWT`, `AGENTOMATIC_REQUIRE_AUTH`,
+    `AGENTOMATIC_ENABLE_CONTROL_PLANE`, `AGENTOMATIC_ENABLE_RATE_LIMIT`,
+    `AGENTOMATIC_TITLE`, `AGENTOMATIC_LOG_LEVEL`), so `uvicorn main:app` in the
+    generated Dockerfile drops no functionality versus running the CLI.
+
 !!! warning "Workers and in-memory state"
     Connection pools and per-process caches live **per worker**. Keep shared
     state (threads, memory, cache) in external services (Postgres, redis) so it

src/agentomatic/cli/project.py

@@ -24,24 +24,69 @@ def _requirements() -> str:
 
 
 def _main_py(name: str) -> str:
-    """Return a starter ``main.py`` with an explicit AgentPlatform config."""
+    """Return a starter ``main.py`` whose module-level ``app`` matches ``run``.
+
+    The generated module exposes ``app = platform.build()`` so a deployed
+    container (``uvicorn main:app``) serves the exact same feature set as
+    ``agentomatic run`` (Studio, docs, health, metrics, all component dirs).
+    Every feature is driven from ``AGENTOMATIC_*`` env vars, so the same file
+    works unchanged in dev and in production without code edits.
+
+    Args:
+        name: Project directory / display name.
+
+    Returns:
+        Rendered ``main.py`` source.
+    """
     display = name.replace("_", " ").title()
     return f'''"""{name} — Agentomatic platform entrypoint.
 
-Edit the AgentPlatform kwargs below to enable auth, metrics, stores, etc.
-Stacks in ``stacks/`` supply LLM / embedding / DB defaults — switch with::
+Serves an identical feature set whether launched with ``agentomatic run``
+(dev) or ``uvicorn main:app`` (container). Toggle features with
+``AGENTOMATIC_*`` env vars — no code edits required. Stacks in ``stacks/``
+supply LLM / embedding / DB defaults — switch with::
 
     agentomatic stack use local   # or remote
 """
 from __future__ import annotations
 
+import os
+
 from agentomatic import AgentPlatform
 
 # Optional: SQLAlchemyStore, MemoryStore, connection configs, JWTConfig, …
 
 
+def _env_bool(var: str, default: bool) -> bool:
+    """Parse a boolean feature flag from the environment.
+
+    Args:
+        var: Environment variable name.
+        default: Value used when the variable is unset or empty.
+
+    Returns:
+        ``True`` for ``1/true/yes/on`` (case-insensitive), else ``False``.
+    """
+    raw = os.getenv(var)
+    if raw is None or raw == "":
+        return default
+    return raw.strip().lower() in {{"1", "true", "yes", "on"}}
+
+
 def create_platform() -> AgentPlatform:
-    """Build the platform from discovered agents/plugins/endpoints/ingestion."""
+    """Build a fully-featured platform matching ``agentomatic run`` defaults.
+
+    Discovers every component directory (agents, plugins, endpoints, ingestion,
+    pipelines, stacks) and enables Studio, docs, health, and metrics by default.
+    Auth, control plane, and rate limiting stay opt-in via ``AGENTOMATIC_*``
+    env vars so the deployed container is configurable without code changes.
+
+    Returns:
+        A configured :class:`AgentPlatform` ready to :meth:`build`.
+    """
+    # ``require_auth`` mirrors ``agentomatic run --require-auth-globally``:
+    # it implies zero-trust + JWT unless those are overridden individually.
+    require_auth = _env_bool("AGENTOMATIC_REQUIRE_AUTH", False)
     return AgentPlatform.from_folder(
         "agents/",
         plugins_dir="plugins/",
@@ -50,18 +95,21 @@ def create_platform() -> AgentPlatform:
         stacks_dir="stacks/",
         # Pipelines are auto-discovered from ../pipelines/ (sibling of agents/).
         # stack="local",              # or set via .agentomatic-stack / STACK env
-        title="{display} Platform",
+        title=os.getenv("AGENTOMATIC_TITLE", "{display} Platform"),
         description="Agentomatic multi-agent platform for {name}",
-        enable_studio=True,
-        enable_metrics=True,
-        # enable_auth=True,
-        # auth_api_key="${{API_KEY}}",  # prefer env / stack auth
-        # enable_jwt_auth=True,        # set jwt_config / JWKS via stack
-        # enable_zero_trust=True,
-        # require_auth_globally=False,  # needs JWT or API-key auth wired
-        # enable_control_plane=True,
-        # control_token="${{CONTROL_TOKEN}}",
-        # enable_rate_limit=True,
+        log_level=os.getenv("AGENTOMATIC_LOG_LEVEL", "INFO"),
+        # On by default — matches `agentomatic run` (Studio) + prod observability.
+        enable_studio=_env_bool("AGENTOMATIC_ENABLE_STUDIO", True),
+        enable_metrics=_env_bool("AGENTOMATIC_ENABLE_METRICS", True),
+        # Opt-in hardening — drive from env / stack; no code edits needed.
+        enable_auth=_env_bool("AGENTOMATIC_ENABLE_AUTH", False),
+        auth_api_key=os.getenv("AGENTOMATIC_API_KEY", ""),
+        enable_jwt_auth=_env_bool("AGENTOMATIC_ENABLE_JWT", require_auth),
+        enable_zero_trust=_env_bool("AGENTOMATIC_ENABLE_ZERO_TRUST", require_auth),
+        require_auth_globally=require_auth,
+        enable_control_plane=_env_bool("AGENTOMATIC_ENABLE_CONTROL_PLANE", False),
+        control_token=os.getenv("AGENTOMATIC_CONTROL_TOKEN", ""),
+        enable_rate_limit=_env_bool("AGENTOMATIC_ENABLE_RATE_LIMIT", False),
     )
 
 
@@ -70,7 +118,10 @@ def create_platform() -> AgentPlatform:
 
 
 if __name__ == "__main__":
-    _platform.run(host="0.0.0.0", port=8000)
+    _platform.run(
+        host=os.getenv("AGENTOMATIC_HOST", "0.0.0.0"),
+        port=int(os.getenv("AGENTOMATIC_PORT", "8000")),
+    )
 '''
 
 
@@ -130,6 +181,20 @@ def _env_example() -> str:
 # Active stack (optional; prefer: agentomatic stack use local)
 # AGENTOMATIC_STACK=local
 
+# --- Deploy feature flags (main.py reads these; parity with `agentomatic run`) ---
+# Studio + metrics are ON by default; auth/control-plane/rate-limit are opt-in.
+# AGENTOMATIC_TITLE=My Platform
+# AGENTOMATIC_LOG_LEVEL=INFO
+# AGENTOMATIC_ENABLE_STUDIO=1
+# AGENTOMATIC_ENABLE_METRICS=1
+# AGENTOMATIC_ENABLE_AUTH=0            # API-key auth (needs AGENTOMATIC_API_KEY)
+# AGENTOMATIC_ENABLE_JWT=0             # JWT auth (set JWKS via stack)
+# AGENTOMATIC_REQUIRE_AUTH=0           # implies JWT + zero-trust; needs auth wired
+# AGENTOMATIC_ENABLE_CONTROL_PLANE=0   # needs AGENTOMATIC_CONTROL_TOKEN
+# AGENTOMATIC_ENABLE_RATE_LIMIT=0
+# AGENTOMATIC_API_KEY=
+# AGENTOMATIC_CONTROL_TOKEN=
+
 # --- LLM providers ---
 OPENAI_API_KEY=
 AZURE_OPENAI_API_KEY=

tests/test_project_scaffold.py

@@ -58,6 +58,43 @@ def test_project_includes_package_inits(self) -> None:
         assert "plugins/__init__.py" in files
 
 
+class TestDeployRunParity:
+    """The deployed ``uvicorn main:app`` must expose the same surface as run."""
+
+    @staticmethod
+    def _build_scaffold_app(
+        tmp_path: Path,
+        monkeypatch,
+        env: dict[str, str] | None = None,
+    ):
+        """Scaffold a project, exec its ``main.py``, and return the built app."""
+        scaffold_project(tmp_path / "proj", "demo_app", force=True)
+        monkeypatch.chdir(tmp_path / "proj")
+        for key, value in (env or {}).items():
+            monkeypatch.setenv(key, value)
+        namespace: dict[str, object] = {}
+        source = (tmp_path / "proj" / "main.py").read_text()
+        exec(compile(source, "main.py", "exec"), namespace)  # noqa: S102
+        return namespace["app"]
+
+    def test_app_exposes_run_parity_routes(self, tmp_path: Path, monkeypatch) -> None:
+        app = self._build_scaffold_app(tmp_path, monkeypatch)
+        paths = {getattr(route, "path", None) for route in app.routes}
+        # Platform surface `agentomatic run` always mounts.
+        for expected in ("/health", "/readiness", "/docs", "/openapi.json", "/", "/studio"):
+            assert expected in paths, f"missing route: {expected}"
+
+    def test_env_flags_drive_features(self, tmp_path: Path, monkeypatch) -> None:
+        app = self._build_scaffold_app(
+            tmp_path,
+            monkeypatch,
+            env={"AGENTOMATIC_ENABLE_STUDIO": "0", "AGENTOMATIC_TITLE": "Env Title"},
+        )
+        paths = {getattr(route, "path", None) for route in app.routes}
+        assert "/studio" not in paths  # studio redirect only added when enabled
+        assert app.title == "Env Title"
+
+
 class TestClassTemplateAlias:
     def test_class_alias_matches_basic(self) -> None:
         basic = get_template_files("basic", "hello")