djaploy 1.1.8__tar.gz → 1.2.1__tar.gz

{djaploy-1.1.8 → djaploy-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.1.8
+Version: 1.2.1
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License
@@ -236,6 +236,107 @@ Deployment flow:
 7. Collects static files
 8. Restarts services
 
+## Deployment Strategies
+
+djaploy supports three deployment strategies, configured via `deployment_strategy` on `HostConfig`.
+
+### In-place (`"in_place"`)
+
+The simplest strategy. Code is extracted directly into the app directory and services are restarted. Has brief downtime during restart.
+
+### Zero-downtime (`"zero_downtime"`)
+
+Uses a `releases/` directory with a `current` symlink. Each deploy creates a new immutable release, swaps the symlink atomically, and sends USR2 via gunicornherder to reload gunicorn. No downtime, but no pre-activation testing.
+
+### Blue-green (`"bluegreen"`)
+
+Two independent slots (blue and green), each running its own gunicorn process on a separate Unix socket. Traffic switching happens via nginx reload. Supports staging a release for testing before switching.
+
+```python
+HostConfig(
+    "my-server",
+    ssh_hostname="192.168.1.100",
+    app_name="myapp",
+    app_user="myapp-api",
+    deployment_strategy="bluegreen",
+    # ...
+)
+```
+
+#### Blue-green commands
+
+```bash
+# Deploy to inactive slot (does NOT switch traffic)
+python manage.py djaploy deploy --env production --latest
+
+# Activate: switch nginx to the staged slot (zero downtime)
+python manage.py djaploy activate --env production
+
+# Deploy + activate in one step
+python manage.py djaploy deploy --env production --latest --activate
+
+# Show both slots with release info, paths, service status
+python manage.py djaploy status --env production
+
+# Rollback: switch back to previous slot (instant)
+python manage.py djaploy rollback --env production
+```
+
+#### Blue-green deployment flow
+
+1. **Deploy** -- extracts artifact to inactive slot, installs dependencies, runs migrations, starts the slot's gunicorn service
+2. **Test** -- the staged slot is running and reachable via its socket (e.g. `curl --unix-socket /run/myapp-green/myapp.sock http://localhost/health/`)
+3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
+4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
+
+### Server directory layout comparison
+
+For `app_user="myapp-api"`, `app_name="myapp"`:
+
+| Path | `in_place` | `zero_downtime` | `bluegreen` |
+|------|-----------|-----------------|-------------|
+| App code | `.../apps/myapp/` | `.../apps/myapp/current/` | `.../apps/myapp/slots/{blue\|green}/` |
+| Virtualenv | Managed by Poetry | `.../shared/venv-{HASH}-py{ver}/` | `.../shared/venv-{HASH}-py{ver}/` |
+| Static files | `.../apps/myapp/staticfiles/` | `.../apps/myapp/shared/staticfiles/` | `.../apps/myapp/shared/staticfiles/` |
+| Media files | `.../apps/myapp/media/` | `.../apps/myapp/shared/media/` | `.../apps/myapp/shared/media/` |
+| Database | via `db_dir` | via `db_dir` | via `db_dir` |
+
+All paths are relative to `/home/{app_user}/`.
+
+#### Shared directory (`zero_downtime` and `bluegreen`)
+
+Both strategies use a `shared/` directory for resources that persist across deployments:
+
+| Content | Purpose |
+|---------|---------|
+| `venv-{HASH}-py{version}/` | Virtualenvs keyed by `poetry.lock` hash. Reused when dependencies haven't changed. |
+| `staticfiles/` | Output of `collectstatic`. Served by nginx. |
+| `media/` | User-uploaded files. Served by nginx. |
+| Custom paths via `shared_resources` | Project-specific shared directories (e.g. `bostad/public`). |
+
+#### Systemd services comparison
+
+| Strategy | Service name | Socket path | Process |
+|----------|-------------|-------------|---------|
+| `in_place` | `{app}.service` | `/run/{app}/{app}.sock` | `poetry run gunicorn` |
+| `zero_downtime` | `{app}.service` | `/run/{app}/{app}.sock` | gunicornherder wrapping gunicorn |
+| `bluegreen` | `{app}-blue.service`, `{app}-green.service` | `/run/{app}-blue/{app}.sock`, `/run/{app}-green/{app}.sock` | Plain gunicorn (`Type=notify`) |
+
+Blue-green uses `Type=notify` -- gunicorn has native systemd-notify support, so systemd knows when the process is ready without needing gunicornherder.
+
+#### Nginx configuration (bluegreen)
+
+Blue-green deploys the nginx upstream as a separate include file so it can be rewritten during activation without touching the site config:
+
+- Site config: `/etc/nginx/sites-available/{app_name}` (no inline upstream block)
+- Upstream config: `/etc/nginx/sites-available/{app_name}-upstream.conf`
+
+Activation rewrites the upstream file to point to the new slot's socket and reloads nginx.
+
+#### State tracking (bluegreen)
+
+Blue-green maintains a `state.json` file at `/home/{app_user}/apps/{app_name}/state.json` that tracks the active slot and deployment metadata (release name, commit, venv path, python interpreter) for each slot. This is printed during deploy, activate, and status commands.
+
 ### Certificate management
 
 ```bash

{djaploy-1.1.8 → djaploy-1.2.1}/README.md

@@ -174,6 +174,107 @@ Deployment flow:
 7. Collects static files
 8. Restarts services
 
+## Deployment Strategies
+
+djaploy supports three deployment strategies, configured via `deployment_strategy` on `HostConfig`.
+
+### In-place (`"in_place"`)
+
+The simplest strategy. Code is extracted directly into the app directory and services are restarted. Has brief downtime during restart.
+
+### Zero-downtime (`"zero_downtime"`)
+
+Uses a `releases/` directory with a `current` symlink. Each deploy creates a new immutable release, swaps the symlink atomically, and sends USR2 via gunicornherder to reload gunicorn. No downtime, but no pre-activation testing.
+
+### Blue-green (`"bluegreen"`)
+
+Two independent slots (blue and green), each running its own gunicorn process on a separate Unix socket. Traffic switching happens via nginx reload. Supports staging a release for testing before switching.
+
+```python
+HostConfig(
+    "my-server",
+    ssh_hostname="192.168.1.100",
+    app_name="myapp",
+    app_user="myapp-api",
+    deployment_strategy="bluegreen",
+    # ...
+)
+```
+
+#### Blue-green commands
+
+```bash
+# Deploy to inactive slot (does NOT switch traffic)
+python manage.py djaploy deploy --env production --latest
+
+# Activate: switch nginx to the staged slot (zero downtime)
+python manage.py djaploy activate --env production
+
+# Deploy + activate in one step
+python manage.py djaploy deploy --env production --latest --activate
+
+# Show both slots with release info, paths, service status
+python manage.py djaploy status --env production
+
+# Rollback: switch back to previous slot (instant)
+python manage.py djaploy rollback --env production
+```
+
+#### Blue-green deployment flow
+
+1. **Deploy** -- extracts artifact to inactive slot, installs dependencies, runs migrations, starts the slot's gunicorn service
+2. **Test** -- the staged slot is running and reachable via its socket (e.g. `curl --unix-socket /run/myapp-green/myapp.sock http://localhost/health/`)
+3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
+4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
+
+### Server directory layout comparison
+
+For `app_user="myapp-api"`, `app_name="myapp"`:
+
+| Path | `in_place` | `zero_downtime` | `bluegreen` |
+|------|-----------|-----------------|-------------|
+| App code | `.../apps/myapp/` | `.../apps/myapp/current/` | `.../apps/myapp/slots/{blue\|green}/` |
+| Virtualenv | Managed by Poetry | `.../shared/venv-{HASH}-py{ver}/` | `.../shared/venv-{HASH}-py{ver}/` |
+| Static files | `.../apps/myapp/staticfiles/` | `.../apps/myapp/shared/staticfiles/` | `.../apps/myapp/shared/staticfiles/` |
+| Media files | `.../apps/myapp/media/` | `.../apps/myapp/shared/media/` | `.../apps/myapp/shared/media/` |
+| Database | via `db_dir` | via `db_dir` | via `db_dir` |
+
+All paths are relative to `/home/{app_user}/`.
+
+#### Shared directory (`zero_downtime` and `bluegreen`)
+
+Both strategies use a `shared/` directory for resources that persist across deployments:
+
+| Content | Purpose |
+|---------|---------|
+| `venv-{HASH}-py{version}/` | Virtualenvs keyed by `poetry.lock` hash. Reused when dependencies haven't changed. |
+| `staticfiles/` | Output of `collectstatic`. Served by nginx. |
+| `media/` | User-uploaded files. Served by nginx. |
+| Custom paths via `shared_resources` | Project-specific shared directories (e.g. `bostad/public`). |
+
+#### Systemd services comparison
+
+| Strategy | Service name | Socket path | Process |
+|----------|-------------|-------------|---------|
+| `in_place` | `{app}.service` | `/run/{app}/{app}.sock` | `poetry run gunicorn` |
+| `zero_downtime` | `{app}.service` | `/run/{app}/{app}.sock` | gunicornherder wrapping gunicorn |
+| `bluegreen` | `{app}-blue.service`, `{app}-green.service` | `/run/{app}-blue/{app}.sock`, `/run/{app}-green/{app}.sock` | Plain gunicorn (`Type=notify`) |
+
+Blue-green uses `Type=notify` -- gunicorn has native systemd-notify support, so systemd knows when the process is ready without needing gunicornherder.
+
+#### Nginx configuration (bluegreen)
+
+Blue-green deploys the nginx upstream as a separate include file so it can be rewritten during activation without touching the site config:
+
+- Site config: `/etc/nginx/sites-available/{app_name}` (no inline upstream block)
+- Upstream config: `/etc/nginx/sites-available/{app_name}-upstream.conf`
+
+Activation rewrites the upstream file to point to the new slot's socket and reloads nginx.
+
+#### State tracking (bluegreen)
+
+Blue-green maintains a `state.json` file at `/home/{app_user}/apps/{app_name}/state.json` that tracks the active slot and deployment metadata (release name, commit, venv path, python interpreter) for each slot. This is printed during deploy, activate, and status commands.
+
 ### Certificate management
 
 ```bash

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/apps/nginx/infra/djaploy_hooks.py

@@ -34,6 +34,7 @@ def configure_nginx(host_data):
 def deploy_nginx(host_data, artifact_path):
     """Deploy NGINX configuration files and SSL certificates."""
     from pyinfra.operations import server, files
+    from djaploy.infra.utils import is_bluegreen
 
     server.shell(
         name="Clear default NGINX sites",
@@ -80,6 +81,18 @@ def deploy_nginx(host_data, artifact_path):
             _sudo=True,
         )
 
+        # For bluegreen, also enable the upstream config
+        if is_bluegreen(host_data):
+            server.shell(
+                name=f"Enable {app_name} NGINX upstream config",
+                commands=[
+                    f"test -f /etc/nginx/sites-available/{app_name}-upstream.conf && "
+                    f"ln -fs /etc/nginx/sites-available/{app_name}-upstream.conf "
+                    f"/etc/nginx/sites-enabled/{app_name}-upstream.conf || true",
+                ],
+                _sudo=True,
+            )
+
 
 @deploy_hook("deploy:start")
 def reload_nginx(host_data, artifact_path):

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/apps/systemd/infra/djaploy_hooks.py

@@ -21,13 +21,33 @@ def reload_systemd_daemon(host_data, artifact_path):
 @deploy_hook("deploy:start")
 def start_services(host_data, artifact_path):
     """Start or restart application services after deploy."""
+    from pyinfra import host
     from pyinfra.operations import systemd
 
-    from djaploy.infra.utils import is_zero_downtime
-    zero_downtime = is_zero_downtime(host_data)
+    from djaploy.infra.utils import is_zero_downtime, is_bluegreen, get_slot_service_name
+
+    if is_bluegreen(host_data):
+        # Start/restart only the target slot's service.
+        # The other slot may be empty (first deploy) so we must NOT
+        # try to start it — only enable the target slot's service.
+        target_slot = getattr(host.data, '_bluegreen_target_slot', None)
+        if not target_slot:
+            return
+
+        for service in getattr(host_data, "services", []):
+            app_name = getattr(host_data, 'app_name', service)
+            slot_service = get_slot_service_name(app_name, target_slot)
 
-    for service in getattr(host_data, "services", []):
-        if zero_downtime:
+            systemd.service(
+                name=f"Start and restart {slot_service} (target slot)",
+                service=slot_service,
+                running=True,
+                enabled=True,
+                restarted=True,
+                _sudo=True,
+            )
+    elif is_zero_downtime(host_data):
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Start and enable {service}",
                 service=service,
@@ -41,7 +61,8 @@ def start_services(host_data, artifact_path):
                 reloaded=True,
                 _sudo=True,
             )
-        else:
+    else:
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Restart and enable {service}",
                 service=service,
@@ -65,19 +86,23 @@ def start_services(host_data, artifact_path):
 def reload_services_on_rollback(host_data, release):
     """Reload or restart services after a rollback."""
     from pyinfra.operations import systemd
-    from djaploy.infra.utils import is_zero_downtime
-
-    zero_downtime = is_zero_downtime(host_data)
+    from djaploy.infra.utils import is_zero_downtime, is_bluegreen
 
-    for service in getattr(host_data, "services", []):
-        if zero_downtime:
+    if is_bluegreen(host_data):
+        # For bluegreen rollback, nginx switching is handled by the core
+        # rollback hook. We just need to ensure the target slot's service
+        # is running (it should already be from the previous deploy).
+        pass
+    elif is_zero_downtime(host_data):
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Reload {service} after rollback",
                 service=service,
                 reloaded=True,
                 _sudo=True,
             )
-        else:
+    else:
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Restart {service} after rollback",
                 service=service,

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/builtin_hooks.py

@@ -150,7 +150,7 @@ def _rollback_validate_strategy(context):
     _, data = hosts[0]
     strategy = (data.get("deployment_strategy") if isinstance(data, dict)
                 else getattr(data, "deployment_strategy", "zero_downtime"))
-    if strategy != "zero_downtime":
+    if strategy not in ("zero_downtime", "bluegreen"):
         raise ValueError(
-            "Rollback is only supported with deployment_strategy='zero_downtime'"
+            "Rollback is only supported with deployment_strategy='zero_downtime' or 'bluegreen'"
         )

djaploy-1.2.1/djaploy/commands/activate.py

@@ -0,0 +1,26 @@
+"""
+Pyinfra command: activate a blue-green deployment slot.
+
+Discovers and runs all @deploy_hook functions for the activate phase:
+
+    activate:pre  — verify target slot is healthy
+    activate      — switch nginx upstream, update state
+    activate:post — cleanup tasks
+
+Usage (via djaploy management command):
+    manage.py djaploy activate --env production
+"""
+
+from pyinfra import host
+from pyinfra.api import deploy as _deploy_decorator
+
+from djaploy.hooks import discover_hooks, get_registry
+
+discover_hooks()
+registry = get_registry()
+
+for phase in ("activate:pre", "activate", "activate:post"):
+    for hook in registry.get_remote_hooks(phase):
+        _deploy_decorator(hook.function.__name__)(hook.function)(
+            host.data
+        )

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/commands/deploy.py

@@ -29,3 +29,12 @@ for phase in ("deploy:upload", "deploy:configure", "deploy:pre", "deploy:start")
         _deploy_decorator(hook.function.__name__)(hook.function)(
             host.data, artifact_path
         )
+
+# If --activate flag is set, run activation phases after deploy
+_activate_val = getattr(host.data, "activate", None)
+if _activate_val in (True, "true", "True"):
+    for phase in ("activate:pre", "activate", "activate:post"):
+        for hook in registry.get_remote_hooks(phase):
+            _deploy_decorator(hook.function.__name__)(hook.function)(
+                host.data
+            )

djaploy-1.2.1/djaploy/commands/status.py

@@ -0,0 +1,62 @@
+"""
+Pyinfra command: show blue-green deployment status.
+
+Reads and displays the blue-green state from each host.
+
+Usage (via djaploy management command):
+    manage.py djaploy status --env production
+"""
+
+from pyinfra import host
+from pyinfra.api import deploy as _deploy_decorator
+from pyinfra.operations import server
+
+from djaploy.hooks import discover_hooks, get_registry
+from djaploy.infra.utils import is_bluegreen, get_app_path, get_slot_socket_path
+from djaploy.infra.bluegreen import print_status_cmd
+
+discover_hooks()
+registry = get_registry()
+
+if is_bluegreen(host.data):
+    app_name = getattr(host.data, 'app_name', 'unknown')
+    app_path = get_app_path(host.data)
+    state_file = f"{app_path}/state.json"
+
+    @_deploy_decorator("show_bluegreen_status")
+    def show_bluegreen_status(host_data):
+        server.shell(
+            name="Show blue-green status",
+            commands=[
+                print_status_cmd(state_file, app_name),
+                f'echo "Sockets:"',
+                f'echo "  Blue:  {get_slot_socket_path(app_name, "blue")}"',
+                f'echo "  Green: {get_slot_socket_path(app_name, "green")}"',
+                f'echo ""',
+                # Show systemd service status
+                f'echo "Services:"',
+                f'systemctl is-active {app_name}-blue.service 2>/dev/null && '
+                f'echo "  {app_name}-blue:  active" || '
+                f'echo "  {app_name}-blue:  inactive"',
+                f'systemctl is-active {app_name}-green.service 2>/dev/null && '
+                f'echo "  {app_name}-green: active" || '
+                f'echo "  {app_name}-green: inactive"',
+                f'echo ""',
+            ],
+            _sudo=True,
+        )
+
+    show_bluegreen_status(host.data)
+else:
+    @_deploy_decorator("show_status")
+    def show_status(host_data):
+        server.shell(
+            name="Show deployment status",
+            commands=[
+                f'echo "Deployment strategy: {getattr(host.data, "deployment_strategy", "zero_downtime")}"',
+                f'echo "Not a blue-green deployment. Use deploy/rollback commands."',
+            ],
+            _sudo=True,
+        )
+
+    show_status(host.data)

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/config.py

@@ -213,10 +213,10 @@ class HostConfig(tuple, metaclass=HostConfigMetaclass):
 
         # Validate deployment_strategy
         strategy = config.get("deployment_strategy", "zero_downtime")
-        if strategy not in ("in_place", "zero_downtime"):
+        if strategy not in ("in_place", "zero_downtime", "bluegreen"):
             raise ValueError(
                 f"Invalid deployment_strategy: {strategy!r}. "
-                f"Must be 'in_place' or 'zero_downtime'"
+                f"Must be 'in_place', 'zero_downtime', or 'bluegreen'"
             )
 
         # Expand SSH key path if provided

{djaploy-1.1.8 → djaploy-1.2.1}/djaploy/deploy.py

@@ -222,6 +222,30 @@ def rollback_project(inventory_file: str,
     })
 
 
+def activate_project(inventory_file: str, **kwargs):
+    """Activate the staged blue-green slot."""
+    env_name = Path(inventory_file).stem
+    run_command({
+        "command": "activate",
+        "env": env_name,
+        "command_file": str(_get_command_file("activate")),
+        "inventory_file": inventory_file,
+        "pyinfra_data": _build_pyinfra_data(env_name),
+    })
+
+
+def bluegreen_status(inventory_file: str, **kwargs):
+    """Show blue-green deployment status."""
+    env_name = Path(inventory_file).stem
+    run_command({
+        "command": "status",
+        "env": env_name,
+        "command_file": str(_get_command_file("status")),
+        "inventory_file": inventory_file,
+        "pyinfra_data": _build_pyinfra_data(env_name),
+    })
+
+
 # ------------------------------------------------------------------
 # Internal helpers (called by hooks in builtin_hooks.py)
 # ------------------------------------------------------------------

djaploy-1.2.1/djaploy/infra/bluegreen.py

@@ -0,0 +1,145 @@
+"""
+Blue-green deployment state management.
+
+Functions that generate shell commands for managing state.json on
+the remote server.  All functions return command strings to be run
+via pyinfra's server.shell().
+
+State file format (state.json):
+{
+    "active_slot": "blue" | "green" | null,
+    "slots": {
+        "blue":  { "release": "...", "commit": "...", "deployed_at": "...",
+                    "python_interpreter": "...", "venv_path": "..." } | null,
+        "green": { ... } | null
+    }
+}
+"""
+
+import json
+
+SLOTS = ("blue", "green")
+DEFAULT_STATE = {"active_slot": None, "slots": {"blue": None, "green": None}}
+
+
+def other_slot(slot: str) -> str:
+    """Return the other slot name."""
+    return "green" if slot == "blue" else "blue"
+
+
+def init_state_cmd(state_file: str) -> str:
+    """Shell command to create state.json if it doesn't exist."""
+    default = json.dumps(DEFAULT_STATE)
+    return (
+        f'test -f {state_file} || '
+        f"echo '{default}' > {state_file}"
+    )
+
+
+def read_active_slot_cmd(state_file: str) -> str:
+    """Shell command that prints the active slot name (or empty string).
+
+    Returns empty string if state.json doesn't exist yet (first deploy).
+    """
+    return (
+        f"python3 -c \""
+        f"import json, os; "
+        f"s=json.load(open('{state_file}')) if os.path.exists('{state_file}') else {json.dumps(DEFAULT_STATE)}; "
+        f"print(s.get('active_slot') or '')"
+        f"\""
+    )
+
+
+def read_state_cmd(state_file: str) -> str:
+    """Shell command that prints the full state.json contents."""
+    return f"cat {state_file}"
+
+
+def update_slot_info_cmd(
+    state_file: str,
+    slot: str,
+    release: str,
+    commit: str,
+    python_interpreter: str,
+    venv_path: str,
+) -> str:
+    """Shell command to update a slot's deployment metadata in state.json."""
+    return (
+        f"python3 -c \""
+        f"import json, datetime; "
+        f"s=json.load(open('{state_file}')); "
+        f"s['slots']['{slot}']={{"
+        f"'release':'{release}',"
+        f"'commit':'{commit}',"
+        f"'deployed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),"
+        f"'python_interpreter':'{python_interpreter}',"
+        f"'venv_path':'{venv_path}'"
+        f"}}; "
+        f"f=open('{state_file}.tmp','w'); "
+        f"json.dump(s,f,indent=2); f.close(); "
+        f"import os; os.rename('{state_file}.tmp','{state_file}')"
+        f"\""
+    )
+
+
+def set_active_slot_cmd(state_file: str, slot: str) -> str:
+    """Shell command to set the active_slot field in state.json."""
+    return (
+        f"python3 -c \""
+        f"import json; "
+        f"s=json.load(open('{state_file}')); "
+        f"s['active_slot']='{slot}'; "
+        f"f=open('{state_file}.tmp','w'); "
+        f"json.dump(s,f,indent=2); f.close(); "
+        f"import os; os.rename('{state_file}.tmp','{state_file}')"
+        f"\""
+    )
+
+
+def print_slot_info_cmd(state_file: str, slot: str) -> str:
+    """Shell command that prints deployment info for a slot."""
+    return (
+        f"python3 -c \""
+        f"import json; "
+        f"s=json.load(open('{state_file}')); "
+        f"info=s['slots'].get('{slot}'); "
+        f"active=s.get('active_slot'); "
+        f"status='active' if active=='{slot}' else 'inactive'; "
+        f"print(); "
+        f"print(f'=== Slot: {slot} ({{status}}) ==='); "
+        f"if info: ["
+        f"print(f'  Release:      {{info[\\\"release\\\"]}}'),"
+        f"print(f'  Commit:       {{info[\\\"commit\\\"]}}'),"
+        f"print(f'  Deployed:     {{info[\\\"deployed_at\\\"]}}'),"
+        f"print(f'  Python:       {{info[\\\"python_interpreter\\\"]}}'),"
+        f"print(f'  Venv:         {{info[\\\"venv_path\\\"]}}'),"
+        f"]; "
+        f"print() if not info else None; "
+        f"print('  (empty)') if not info else None"
+        f"\""
+    )
+
+
+def print_status_cmd(state_file: str, app_name: str) -> str:
+    """Shell command that prints full blue-green status."""
+    return (
+        f"python3 -c \""
+        f"import json; "
+        f"s=json.load(open('{state_file}')); "
+        f"active=s.get('active_slot') or 'none'; "
+        f"print(); "
+        f"print('Blue-Green Status for {app_name}'); "
+        f"print('=' * 40); "
+        f"print(f'Active slot: {{active}}'); "
+        f"print(); "
+        f"for slot in ('blue','green'): "
+        f"  info=s['slots'].get(slot); "
+        f"  tag='ACTIVE' if active==slot else 'inactive'; "
+        f"  print(f'{{slot.upper()}} ({{tag}}):'); "
+        f"  ["
+        f"    (print(f'  Release:  {{info[k]}}') for k in ('release','commit','deployed_at','python_interpreter','venv_path'))"
+        f"    if info else print('  (empty)')"
+        f"  ]; "
+        f"  print()"
+        f"\""
+    )