aayi 0.1.1__py3-none-any.whl

aayi/__init__.py

@@ -0,0 +1,3 @@
+"""Aayi: A Python-native container deployment tool with zero-downtime Caddy proxying."""
+
+__version__ = "0.1.1"

aayi/cli/ci.py

@@ -0,0 +1,76 @@
+"""GitHub Actions CI/CD workflow generator for Aayi."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+GITHUB_WORKFLOW_TEMPLATE = """name: Deploy Application
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    name: Deploy to Production
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ secrets.DOCKER_REGISTRY || 'docker.io' }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Set up SSH Private Key
+        uses: webfactory/ssh-agent@v0.9.0
+        with:
+          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
+
+      - name: Add Known Hosts
+        run: |
+          mkdir -p ~/.ssh
+          # You can add: ssh-keyscan -H <YOUR_SERVER_IP> >> ~/.ssh/known_hosts
+
+      - name: Deploy with Aayi
+        env:
+          DOCKER_REGISTRY_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+        run: |
+          uvx aayi deploy
+"""
+
+
+def init_github_actions(force: bool = False) -> Path:
+    """Generate .github/workflows/deploy.yml for automated deployments."""
+    workflows_dir = Path(".github") / "workflows"
+    workflows_dir.mkdir(parents=True, exist_ok=True)
+    workflow_file = workflows_dir / "deploy.yml"
+
+    if workflow_file.exists() and not force:
+        console.print(f"[yellow]Skipped {workflow_file} (already exists). Use --force to overwrite.[/yellow]")
+    else:
+        workflow_file.write_text(GITHUB_WORKFLOW_TEMPLATE, encoding="utf-8")
+        console.print(f"[green]✓ Created GitHub Actions workflow at {workflow_file}[/green]")
+
+    console.print("\n[bold cyan]GitHub Actions setup tips:[/bold cyan]")
+    console.print("  Configure these repository secrets in GitHub ([bold]Settings > Secrets and variables > Actions[/bold]):")
+    console.print("  • [yellow]SSH_PRIVATE_KEY[/yellow]: The private SSH key authorized on your target servers.")
+    console.print("  • [yellow]DOCKER_USERNAME[/yellow]: Your Docker Hub or container registry username.")
+    console.print("  • [yellow]DOCKER_PASSWORD[/yellow]: Your container registry password or access token.\n")
+    return workflow_file

aayi/cli/init.py

@@ -0,0 +1,130 @@
+"""Project initialization and scaffolding generator for Aayi."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+DEPLOY_YML_TEMPLATE = """# Aayi Deployment Configuration
+service: myapp
+image: your-docker-user/myapp
+
+# Server topology
+servers:
+  web:
+    - 192.168.1.10
+  workers:
+    - 192.168.1.11
+  user: root
+  ssh_port: 22
+
+# Docker container registry
+registry:
+  server: docker.io
+  username: your-docker-user
+  password: ${DOCKER_REGISTRY_PASSWORD}
+
+# Caddy Reverse Proxy & Zero-Downtime Traffic Routing
+proxy:
+  domain: app.example.com
+  app_port: 8000
+  healthcheck_path: /healthz
+  healthcheck_timeout: 30
+  drain_timeout: 10
+  tls: true
+  email: admin@example.com
+
+# Environment variables
+env:
+  clear:
+    PORT: "8000"
+    ENVIRONMENT: production
+  secret:
+    - SECRET_KEY_BASE
+    - DATABASE_URL
+
+# Attached stateful accessories (optional)
+accessories:
+  postgres:
+    image: postgres:16-alpine
+    host: 192.168.1.10
+    port: "5432:5432"
+    env:
+      POSTGRES_DB: myapp_production
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7-alpine
+    host: 192.168.1.10
+    port: "6379:6379"
+    volumes:
+      - redis_data:/data
+"""
+
+DOCKERFILE_TEMPLATE = """# Multi-stage Dockerfile optimized with uv
+FROM python:3.13-slim AS builder
+
+WORKDIR /app
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+
+COPY pyproject.toml uv.lock* ./
+RUN uv sync --frozen --no-dev --no-install-project
+
+COPY . .
+RUN uv sync --frozen --no-dev
+
+FROM python:3.13-slim
+
+WORKDIR /app
+COPY --from=builder /app/.venv /app/.venv
+COPY . .
+
+ENV PATH="/app/.venv/bin:$PATH"
+EXPOSE 8000
+
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+"""
+
+DOCKERIGNORE_TEMPLATE = """.git
+.venv
+__pycache__
+*.pyc
+.env
+.pytest_cache
+dist
+build
+"""
+
+
+def init_project(force: bool = False) -> None:
+    """Scaffold initial deployment configuration and Dockerfile."""
+    config_dir = Path("config")
+    config_dir.mkdir(exist_ok=True)
+    deploy_yml = config_dir / "deploy.yml"
+
+    if deploy_yml.exists() and not force:
+        console.print(f"[yellow]Skipped {deploy_yml} (already exists). Use --force to overwrite.[/yellow]")
+    else:
+        deploy_yml.write_text(DEPLOY_YML_TEMPLATE, encoding="utf-8")
+        console.print(f"[green]✓ Created {deploy_yml}[/green]")
+
+    dockerfile = Path("Dockerfile")
+    if not dockerfile.exists() or force:
+        dockerfile.write_text(DOCKERFILE_TEMPLATE, encoding="utf-8")
+        console.print(f"[green]✓ Created {dockerfile}[/green]")
+
+    dockerignore = Path(".dockerignore")
+    if not dockerignore.exists() or force:
+        dockerignore.write_text(DOCKERIGNORE_TEMPLATE, encoding="utf-8")
+        console.print(f"[green]✓ Created {dockerignore}[/green]")
+
+    console.print("\n[bold green]Project initialized for Aayi![/bold green]")
+    console.print("Next steps:")
+    console.print("  1. Edit [cyan]config/deploy.yml[/cyan] with your server IP and domain.")
+    console.print("  2. Set up target servers: [bold]aayi setup[/bold]")
+    console.print("  3. Deploy your application: [bold]aayi deploy[/bold]\n")

aayi/cli/main.py

@@ -0,0 +1,276 @@
+"""Aayi CLI entrypoint powered by Typer and Rich."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from aayi import __version__
+from aayi.cli.ci import init_github_actions
+from aayi.cli.init import init_project
+from aayi.compose.parser import convert_compose_to_deploy_yaml, parse_compose_file
+from aayi.config.loader import load_config
+from aayi.orchestrator.accessories import AccessoryManager
+from aayi.orchestrator.deployer import Deployer
+from aayi.orchestrator.rollback import RollbackManager
+from aayi.proxy.caddy import CaddyManager
+from aayi.ssh.runner import SSHFleetRunner
+
+app = typer.Typer(
+    name="aayi",
+    help="Modern Python container deployment orchestrator with zero-downtime Caddy proxying.",
+    add_completion=True,
+    rich_markup_mode="rich",
+)
+proxy_app = typer.Typer(help="Manage Caddy reverse proxy on remote hosts.")
+accessory_app = typer.Typer(help="Manage attached stateful accessories (Postgres, Redis, etc.).")
+ci_app = typer.Typer(help="Manage CI/CD workflows (GitHub Actions, etc.).")
+compose_app = typer.Typer(help="Docker Compose file management and conversion.")
+
+app.add_typer(proxy_app, name="proxy")
+app.add_typer(accessory_app, name="accessory")
+app.add_typer(ci_app, name="ci")
+app.add_typer(compose_app, name="compose")
+
+console = Console()
+
+
+@app.command()
+def init(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing configuration files."),
+    ci: bool = typer.Option(False, "--ci", help="Also generate GitHub Actions deployment workflow."),
+) -> None:
+    """Initialize Aayi deployment configuration (config/deploy.yml) and Dockerfile."""
+    init_project(force=force)
+    if ci:
+        init_github_actions(force=force)
+
+
+@ci_app.command("init")
+def ci_init(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing workflow files."),
+) -> None:
+    """Generate .github/workflows/deploy.yml for GitHub Actions CI/CD."""
+    init_github_actions(force=force)
+
+
+@app.command()
+def setup(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+) -> None:
+    """Prepare target servers: verify Docker CE and start Caddy reverse proxy."""
+    cfg = load_config(config_path)
+    runner = SSHFleetRunner(
+        default_user=cfg.servers.user,
+        default_port=cfg.servers.ssh_port,
+        default_key=cfg.servers.ssh_key,
+    )
+    deployer = Deployer(cfg)
+
+    async def _run() -> None:
+        console.rule("[bold blue]Setting up target hosts[/bold blue]")
+        await deployer.remote_docker.ensure_docker(cfg.servers.all_hosts)
+        if cfg.servers.web:
+            await deployer.caddy.ensure_running(cfg.servers.web)
+        console.rule("[bold green]✓ Server setup complete[/bold green]")
+
+    asyncio.run(_run())
+
+
+@app.command()
+def deploy(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    compose: Optional[Path] = typer.Option(None, "--compose", help="Deploy directly from a docker-compose.yml file"),
+    service: Optional[str] = typer.Option(None, "--service", "-s", help="Deploy only a specific service container"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Custom image tag / git revision to deploy"),
+    build: bool = typer.Option(True, "--build/--no-build", help="Build image locally before deployment"),
+    push: bool = typer.Option(True, "--push/--no-push", help="Push image to registry after building"),
+    remote_build: bool = typer.Option(False, "--remote-build", "-r", help="Stream source in memory via tar and build natively on the VPS (no registry needed)."),
+) -> None:
+    """Run full zero-downtime deployment: build, push, healthcheck, and swap Caddy traffic."""
+    if compose:
+        cfg = parse_compose_file(compose)
+    else:
+        cfg = load_config(config_path)
+
+    deployer = Deployer(cfg)
+    asyncio.run(deployer.deploy(tag=tag, build=build, push=push, target_service=service, remote_build=remote_build))
+
+
+@app.command()
+def redeploy(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    compose: Optional[Path] = typer.Option(None, "--compose", help="Deploy directly from a docker-compose.yml file"),
+    service: Optional[str] = typer.Option(None, "--service", "-s", help="Redeploy only a specific service container"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Tag to redeploy without rebuilding"),
+) -> None:
+    """Redeploy an existing image tag on remote servers without rebuilding."""
+    if compose:
+        cfg = parse_compose_file(compose)
+    else:
+        cfg = load_config(config_path)
+
+    deployer = Deployer(cfg)
+    asyncio.run(deployer.deploy(tag=tag, build=False, push=False, target_service=service))
+
+
+@compose_app.command("convert")
+def compose_convert(
+    compose_path: Path = typer.Option("docker-compose.yml", "--compose", "-f", help="Path to docker-compose.yml"),
+    host: str = typer.Option("192.168.1.10", "--host", "-h", help="Target server IP for deploy.yml"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Write to file instead of stdout (e.g. config/deploy.yml)"),
+) -> None:
+    """Convert an existing docker-compose.yml into an Aayi config/deploy.yml."""
+    yaml_text = convert_compose_to_deploy_yaml(compose_path, web_host=host)
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(yaml_text, encoding="utf-8")
+        console.print(f"[green]✓ Successfully generated {output}[/green]")
+    else:
+        console.print(yaml_text)
+
+
+@app.command()
+def rollback(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    host: Optional[str] = typer.Option(None, "--host", "-h", help="Specific host to rollback (defaults to all web hosts)"),
+) -> None:
+    """Roll back Caddy traffic upstream to the previous healthy container."""
+    cfg = load_config(config_path)
+    manager = RollbackManager(cfg)
+    asyncio.run(manager.rollback(target_host=host))
+
+
+@app.command()
+def logs(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    role: str = typer.Option("web", "--role", "-r", help="Target server role ('web', 'workers', 'all')"),
+    tail: int = typer.Option(100, "--tail", "-n", help="Number of recent log lines to display"),
+    follow: bool = typer.Option(True, "--follow/--no-follow", help="Stream live logs in real time"),
+) -> None:
+    """Stream application logs concurrently across all target servers."""
+    cfg = load_config(config_path)
+    hosts = cfg.servers.hosts_for_role(role)
+    if not hosts:
+        console.print(f"[yellow]No hosts found for role '{role}'.[/yellow]")
+        return
+
+    runner = SSHFleetRunner(
+        default_user=cfg.servers.user,
+        default_port=cfg.servers.ssh_port,
+        default_key=cfg.servers.ssh_key,
+    )
+    cmd = f"docker logs {'-f' if follow else ''} --tail {tail} $(docker ps -q --filter 'label=aayi.service={cfg.service}' | head -n 1)"
+
+    async def _run() -> None:
+        if follow:
+            await runner.stream_logs(hosts, cmd)
+        else:
+            await runner.run_on_hosts(hosts, cmd)
+
+    asyncio.run(_run())
+
+
+@app.command()
+def exec(
+    command: str = typer.Argument(..., help="Command to execute inside the running service container"),
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    host: Optional[str] = typer.Option(None, "--host", "-h", help="Specific host (defaults to first web host)"),
+) -> None:
+    """Execute a command inside the currently running application container."""
+    cfg = load_config(config_path)
+    target_host = host or (cfg.servers.web[0] if cfg.servers.web else None)
+    if not target_host:
+        console.print("[red]No target host available.[/red]")
+        raise typer.Exit(1)
+
+    runner = SSHFleetRunner(
+        default_user=cfg.servers.user,
+        default_port=cfg.servers.ssh_port,
+        default_key=cfg.servers.ssh_key,
+    )
+    docker_cmd = f"docker exec -it $(docker ps -q --filter 'label=aayi.service={cfg.service}' | head -n 1) {command}"
+    asyncio.run(runner.run_on_host(target_host, docker_cmd))
+
+
+@proxy_app.command("status")
+def proxy_status(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+) -> None:
+    """View current Caddy proxy status and routing across web hosts."""
+    cfg = load_config(config_path)
+    runner = SSHFleetRunner(default_user=cfg.servers.user, default_port=cfg.servers.ssh_port, default_key=cfg.servers.ssh_key)
+    caddy = CaddyManager(runner, cfg.proxy)
+    asyncio.run(caddy.get_status(cfg.servers.web))
+
+
+@proxy_app.command("reload")
+def proxy_reload(
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    port: int = typer.Option(..., "--port", "-p", help="Target upstream port to route traffic to"),
+) -> None:
+    """Force Caddy to route traffic to a specific upstream port."""
+    cfg = load_config(config_path)
+    runner = SSHFleetRunner(default_user=cfg.servers.user, default_port=cfg.servers.ssh_port, default_key=cfg.servers.ssh_key)
+    caddy = CaddyManager(runner, cfg.proxy)
+    asyncio.run(caddy.update_upstream(cfg.servers.web, target_port=port))
+
+
+@accessory_app.command("boot")
+def accessory_boot(
+    name: str = typer.Argument(..., help="Name of the accessory to boot (e.g. postgres, redis)"),
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+) -> None:
+    """Start an accessory container defined in deploy.yml."""
+    cfg = load_config(config_path)
+    manager = AccessoryManager(cfg)
+    asyncio.run(manager.boot(name))
+
+
+@accessory_app.command("stop")
+def accessory_stop(
+    name: str = typer.Argument(..., help="Name of the accessory to stop"),
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+) -> None:
+    """Stop an accessory container."""
+    cfg = load_config(config_path)
+    manager = AccessoryManager(cfg)
+    asyncio.run(manager.stop(name))
+
+
+@accessory_app.command("reboot")
+def accessory_reboot(
+    name: str = typer.Argument(..., help="Name of the accessory to reboot"),
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+) -> None:
+    """Restart an accessory container."""
+    cfg = load_config(config_path)
+    manager = AccessoryManager(cfg)
+    asyncio.run(manager.reboot(name))
+
+
+@accessory_app.command("logs")
+def accessory_logs(
+    name: str = typer.Argument(..., help="Name of the accessory to stream logs for"),
+    config_path: Path = typer.Option("config/deploy.yml", "--config", "-c", help="Path to deploy.yml"),
+    tail: int = typer.Option(100, "--tail", "-n", help="Number of lines to tail"),
+    follow: bool = typer.Option(True, "--follow/--no-follow", help="Stream logs in real-time"),
+) -> None:
+    """View or stream logs from an accessory container."""
+    cfg = load_config(config_path)
+    manager = AccessoryManager(cfg)
+    asyncio.run(manager.logs(name, follow=follow, tail=tail))
+
+
+@app.command()
+def version() -> None:
+    """Display Aayi version information."""
+    console.print(f"[bold cyan]Aayi[/bold cyan] version [bold green]{__version__}[/bold green]")
+
+
+if __name__ == "__main__":
+    app()

aayi/compose/parser.py

@@ -0,0 +1,198 @@
+"""Docker Compose file parser and adapter for Aayi."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from aayi.config.models import DeployConfig, EnvConfig, ServerConfig, ServiceDefinition
+
+
+def _parse_compose_env(env_data: Any) -> EnvConfig:
+    """Parse environment block from Docker Compose into clear and secret env vars."""
+    clear: Dict[str, str] = {}
+    secret: List[str] = []
+
+    if isinstance(env_data, list):
+        for item in env_data:
+            if isinstance(item, str):
+                if "=" in item:
+                    k, v = item.split("=", 1)
+                    clear[k.strip()] = v.strip().strip("'\"")
+                else:
+                    secret.append(item.strip())
+    elif isinstance(env_data, dict):
+        for k, v in env_data.items():
+            if v is None or v == "":
+                secret.append(str(k))
+            else:
+                clear[str(k)] = str(v)
+
+    return EnvConfig(clear=clear, secret=secret)
+
+
+def _parse_compose_labels(labels_data: Any) -> Dict[str, str]:
+    """Parse labels block from Docker Compose into a dictionary."""
+    labels: Dict[str, str] = {}
+    if isinstance(labels_data, list):
+        for item in labels_data:
+            if isinstance(item, str) and "=" in item:
+                k, v = item.split("=", 1)
+                labels[k.strip()] = v.strip().strip("'\"")
+    elif isinstance(labels_data, dict):
+        for k, v in labels_data.items():
+            labels[str(k)] = str(v)
+    return labels
+
+
+def parse_compose_file(
+    compose_path: Path | str,
+    servers: Optional[ServerConfig] = None,
+) -> DeployConfig:
+    """Parse a docker-compose.yml into an Aayi DeployConfig with multi-service definitions."""
+    path = Path(compose_path)
+    if not path.is_file():
+        raise FileNotFoundError(f"Docker Compose file not found: {path}")
+
+    with open(path, "r", encoding="utf-8") as f:
+        data: Dict[str, Any] = yaml.safe_load(f) or {}
+
+    raw_services: Dict[str, Any] = data.get("services", {})
+    if not raw_services:
+        raise ValueError(f"No services found in compose file: {path}")
+
+    parsed_services: Dict[str, ServiceDefinition] = {}
+
+    for service_name, s_data in raw_services.items():
+        if not isinstance(s_data, dict):
+            continue
+
+        labels = _parse_compose_labels(s_data.get("labels", []))
+        env = _parse_compose_env(s_data.get("environment", {}))
+
+        # Check domain configuration
+        domain = labels.get("aayi.domain")
+        extra_domains_raw = labels.get("aayi.domains", "")
+        extra_domains = [d.strip() for d in extra_domains_raw.split(",") if d.strip()]
+
+        # Determine if public: default to True if domain is specified, or if aayi.public=true
+        if "aayi.public" in labels:
+            is_public = labels["aayi.public"].lower() in ("true", "1", "yes")
+        else:
+            is_public = bool(domain or extra_domains)
+
+        # Determine app port
+        port = 8000
+        if "aayi.port" in labels:
+            try:
+                port = int(labels["aayi.port"])
+            except ValueError:
+                port = 8000
+        elif s_data.get("ports"):
+            first_port = str(s_data["ports"][0])
+            # handle '8000:8000' or '8000'
+            parts = first_port.split(":")
+            try:
+                port = int(parts[-1].split("/")[0])
+            except ValueError:
+                port = 8000
+
+        # Build context / dockerfile
+        build_context: Optional[str] = None
+        dockerfile: Optional[str] = None
+        if "build" in s_data:
+            build_raw = s_data["build"]
+            if isinstance(build_raw, str):
+                build_context = build_raw
+                dockerfile = "Dockerfile"
+            elif isinstance(build_raw, dict):
+                build_context = build_raw.get("context", ".")
+                dockerfile = build_raw.get("dockerfile", "Dockerfile")
+
+        # Healthcheck
+        healthcheck_path = labels.get("aayi.healthcheck", "/")
+
+        # Roles
+        roles_raw = labels.get("aayi.roles", "web")
+        roles = [r.strip() for r in roles_raw.split(",") if r.strip()]
+
+        # Depends on
+        depends_on: List[str] = []
+        raw_deps = s_data.get("depends_on", [])
+        if isinstance(raw_deps, list):
+            depends_on = [str(d) for d in raw_deps]
+        elif isinstance(raw_deps, dict):
+            depends_on = [str(d) for d in raw_deps.keys()]
+
+        command = s_data.get("command")
+        if isinstance(command, list):
+            command = " ".join(command)
+
+        parsed_services[service_name] = ServiceDefinition(
+            name=service_name,
+            image=s_data.get("image"),
+            build_context=build_context,
+            dockerfile=dockerfile,
+            public=is_public,
+            domain=domain,
+            domains=extra_domains,
+            app_port=port,
+            healthcheck_path=healthcheck_path,
+            env=env,
+            roles=roles,
+            command=command,
+            depends_on=depends_on,
+        )
+
+    # If servers are not provided, default to localhost or placeholder
+    server_cfg = servers or ServerConfig(web=["127.0.0.1"])
+
+    return DeployConfig(
+        service=next(iter(parsed_services.keys())),
+        servers=server_cfg,
+        services=parsed_services,
+    )
+
+
+def convert_compose_to_deploy_yaml(
+    compose_path: Path | str,
+    web_host: str = "192.168.1.10",
+) -> str:
+    """Generate a clean config/deploy.yml string from a Docker Compose file."""
+    cfg = parse_compose_file(compose_path, servers=ServerConfig(web=[web_host]))
+
+    export_dict: Dict[str, Any] = {
+        "servers": {
+            "web": [web_host],
+            "user": "root",
+            "ssh_port": 22,
+        },
+        "services": {},
+    }
+
+    for s_name, s_def in cfg.services.items():
+        s_dict: Dict[str, Any] = {
+            "public": s_def.public,
+            "app_port": s_def.app_port,
+        }
+        if s_def.image:
+            s_dict["image"] = s_def.image
+        if s_def.build_context:
+            s_dict["build_context"] = s_def.build_context
+        if s_def.public and s_def.all_domains:
+            s_dict["domain"] = s_def.domain
+            if s_def.domains:
+                s_dict["domains"] = s_def.domains
+            s_dict["healthcheck_path"] = s_def.healthcheck_path
+        if s_def.env.clear:
+            s_dict["env"] = {"clear": s_def.env.clear}
+        if s_def.depends_on:
+            s_dict["depends_on"] = s_def.depends_on
+        if s_def.command:
+            s_dict["command"] = s_def.command
+
+        export_dict["services"][s_name] = s_dict
+
+    return yaml.dump(export_dict, sort_keys=False)