diff --git a/contracts/python_runtime_gap_report.json b/contracts/python_runtime_gap_report.json index b135b3f8e..8c7270b80 100644 --- a/contracts/python_runtime_gap_report.json +++ b/contracts/python_runtime_gap_report.json @@ -1,8 +1,8 @@ { "version": 1, - "generated_at": "2026-07-06T17:49:55+00:00", - "matrix_generated_at": "2026-07-06T17:49:55+00:00", - "matrix_sha256": "19b3bb085a8392aa9e6f99856983555c06da3606d5e81a6d1f2be7d20022899d", + "generated_at": "2026-07-10T21:33:31+00:00", + "matrix_generated_at": "2026-07-10T21:30:49+00:00", + "matrix_sha256": "9968ef658488512f15c0ebda73d08c82da359ab389b1ff880b585dd47d5bb935", "summary": { "feature_count": 59, "gap_count": 0, diff --git a/contracts/runtime_feature_matrix.json b/contracts/runtime_feature_matrix.json index a29441403..44926b96c 100644 --- a/contracts/runtime_feature_matrix.json +++ b/contracts/runtime_feature_matrix.json @@ -1,6 +1,6 @@ { "version": 1, - "generated_at": "2026-07-06T17:49:55+00:00", + "generated_at": "2026-07-10T21:30:49+00:00", "inventory_sources": { "python_supported_commands": [ "blast-all", @@ -327,6 +327,7 @@ "--deps", "--deps-parallel", "--deps-sequential", + "--docker", "--doctor", "--entire-system", "--failed", diff --git a/docs/reference/commands.md b/docs/reference/commands.md index 394404e00..5787b12d4 100644 --- a/docs/reference/commands.md +++ b/docs/reference/commands.md @@ -312,6 +312,10 @@ High-value command families: - `plan` - `import` - `test` + +When `envctl pr` or `envctl ship` opens a pull request without an explicit +`ENVCTL_PR_BASE`, it selects the first branch that exists in this order: +`dev`, `main`, then `master`. Both remote branches and local refs are checked. - `logs` - `health` - `errors` diff --git a/docs/reference/configuration.md b/docs/reference/configuration.md index 8625ae8a0..0a7d02c42 100644 --- a/docs/reference/configuration.md +++ b/docs/reference/configuration.md @@ -378,6 +378,65 @@ The wizard saves accepted backend/frontend test suggestions to `ENVCTL_BACKEND_T | `ENVCTL_WORKTREE_CGC_DATABASE` | `kuzudb` | Backend passed as `--database ` to `cgc context create` for generated worktree contexts. | ## Execution Policy + +### Docker application runtime + +`envctl ... --docker` preserves normal project selection, port allocation, dependency startup, +service ordering, state, dashboard, logs, health, restart, and stop behavior, but launches every +selected app service in a managed container instead of as a host process. Managed dependencies such +as Postgres, Redis, Supabase, and n8n continue to use their existing Docker adapters. + +Settings resolve service-specific keys before global fallbacks. Additional service names are +uppercased and non-alphanumeric characters become underscores, so `voice-runtime` accepts the +standard `ENVCTL_SERVICE_VOICE_RUNTIME_*` prefix (and the shorter `ENVCTL_VOICE_RUNTIME_*` alias). + +| Variable | Default | Purpose | +| --- | --- | --- | +| `ENVCTL__DOCKER_IMAGE` / `ENVCTL_DOCKER_IMAGE` | unset | Existing image to run. Without a Dockerfile setting, no build runs. | +| `ENVCTL__DOCKERFILE` / `ENVCTL_DOCKERFILE` | discovered | Dockerfile to build; discovery checks the service directory and then project root. | +| `ENVCTL__DOCKER_CONTEXT` / `ENVCTL_DOCKER_CONTEXT` | Dockerfile directory | Build context relative to the project root. | +| `ENVCTL__DOCKER_TARGET` / `ENVCTL_DOCKER_TARGET` | unset | Optional multi-stage build target. | +| `ENVCTL__DOCKER_BUILD_ARGS` / `ENVCTL_DOCKER_BUILD_ARGS` | public frontend env keys | Comma-separated build-arg names or `NAME=value` entries. Named values come from the service env and are not placed on the Docker command line. | +| `ENVCTL__DOCKER_COMMAND` / `ENVCTL_DOCKER_COMMAND` | image command | Explicit command executed inside the container. | +| `ENVCTL__DOCKER_COMMAND_MODE` / `ENVCTL_DOCKER_COMMAND_MODE` | `image` | `image` keeps the image CMD/ENTRYPOINT; `service` translates and runs envctl's normal service command. | +| `ENVCTL__DOCKER_WORKDIR` / `ENVCTL_DOCKER_WORKDIR` | image default | Container working directory. | +| `ENVCTL__DOCKER_PORT` / `ENVCTL_DOCKER_PORT` | single exposed image port or allocated host port | Container-side listener port. | +| `ENVCTL__DOCKER_BUILD_POLICY` / `ENVCTL_DOCKER_BUILD_POLICY` | `cached` | `cached`, `missing`, or `never`. | +| `ENVCTL_DOCKER_BUILD_TIMEOUT_SECONDS` | `900` | Image build timeout. | +| `ENVCTL_DOCKER_RUN_TIMEOUT_SECONDS` | `120` | Container creation timeout. | + +The default `cached` policy invokes `docker build` with BuildKit enabled on every start. Docker +evaluates the context and reuses unchanged layers, while changed source cannot accidentally reuse a +stale whole image. Generated tags are stable for one checkout/worktree, preventing parallel trees +from racing on one tag. Use `missing` for immutable/prebuilt local tags and `never` when image +lifecycle is owned outside envctl. + +Containers publish only to `127.0.0.1`, carry `io.envctl.*` ownership labels, and persist their ID, +name, and image in runtime state. Internal URLs and host settings pointing at `localhost` map to +`host.docker.internal`; browser-facing `VITE_*`, `NEXT_PUBLIC_*`, `PUBLIC_*`, CORS, and frontend URL +values remain host-facing. Service env passes through a short-lived mode-`0600` file and is not +rendered into Docker command diagnostics. Normal logs are snapshotted from Docker on demand; +`logs --follow` creates followers only for that command and tears them down on exit, so application +runtime state does not depend on long-lived host helper processes. + +```dotenv +ENVCTL_BACKEND_DOCKER_IMAGE=acme/api-dev:latest +ENVCTL_BACKEND_DOCKER_COMMAND=uvicorn app.main:app --host 0.0.0.0 --port 8000 +ENVCTL_BACKEND_DOCKER_PORT=8000 + +ENVCTL_FRONTEND_DOCKERFILE=frontend/Dockerfile +ENVCTL_FRONTEND_DOCKER_CONTEXT=frontend +ENVCTL_FRONTEND_DOCKER_PORT=5173 +``` + +```bash +envctl start --trees --entire-system --docker --headless +envctl health --json +envctl logs --project feature-a-1 --service backend +envctl restart --project feature-a-1 --service backend --docker --headless +envctl stop --project feature-a-1 --entire-system +``` + | Variable | Default | Purpose | | --- | --- | --- | | `ENVCTL_SERVICE_ATTACH_PARALLEL` | `true` | Run backend+frontend service attach in parallel when both are selected. | diff --git a/docs/reference/important-flags.md b/docs/reference/important-flags.md index b15bdc3ed..c1026dcc0 100644 --- a/docs/reference/important-flags.md +++ b/docs/reference/important-flags.md @@ -89,12 +89,22 @@ Plan-agent handoff note: if `--plan --tmux/--omx --headless` starts the implemen | `--parallel-trees` | Enable parallel tree startup workers. | | `--parallel-trees-max ` | Max parallel tree startup workers. | | `--service-parallel` / `--service-sequential` | Run backend+frontend startup attach in parallel or sequential mode (default: parallel). | +| `--docker` | Build or reuse images and run backend, frontend, and additional app services as managed Docker containers. | | `--parallel` / `--sequential` | For `envctl test`, run backend/frontend test suites in parallel or sequential mode (default: parallel for multiple suites, with sequential fallback). Legacy aliases: `--test-parallel` / `--test-sequential`. | | `--test-parallel-max ` | Cap concurrent test suites in parallel mode and pytest-xdist workers when pytest-xdist is explicitly enabled (default suite cap: CPU-aware, max `4`; default pytest workers: current free CPU cores). | | `--clear-port-state` | Clear saved port reservations/state. | | `--force` | Free configured ports if needed. | | `ENVCTL_DOCKER_PREWARM=0\|1` | Enable/disable one-shot Docker daemon prewarm before requirements startup (default: `1`). | | `ENVCTL_DOCKER_PREWARM_TIMEOUT_SECONDS=` | Timeout for Docker prewarm command (default: `10`). | +| `ENVCTL__DOCKER_IMAGE=` | Use an existing image for one app service. `ENVCTL_DOCKER_IMAGE` is the global fallback. | +| `ENVCTL__DOCKERFILE=` | Build an app service image from a Dockerfile. `ENVCTL_DOCKERFILE` is the global fallback. | +| `ENVCTL__DOCKER_CONTEXT=` | Override the Docker build context; defaults to the Dockerfile directory. | +| `ENVCTL__DOCKER_BUILD_ARGS=` | Add comma-separated Docker build-arg names (or `NAME=value` entries); public frontend env keys are passed automatically. | +| `ENVCTL__DOCKER_COMMAND=` | Override the image command inside the container. | +| `ENVCTL__DOCKER_COMMAND_MODE=image\|service` | Keep image CMD/ENTRYPOINT (default) or run envctl's normal service command. | +| `ENVCTL__DOCKER_PORT=` | Override the container-side port while preserving envctl's allocated host port. | +| `ENVCTL__DOCKER_WORKDIR=` | Override the image working directory for the service command. | +| `ENVCTL__DOCKER_BUILD_POLICY=cached\|missing\|never` | `cached` (default) reuses Docker layers; `missing` builds only when absent; `never` requires an existing image. | | `ENVCTL_REQUIREMENTS_PORT_MISMATCH_POLICY=adopt_existing\|recreate` | On existing container port mismatch, adopt existing mapping (default) or force recreate. | ## Logs and Debugging diff --git a/docs/user/common-workflows.md b/docs/user/common-workflows.md index a4872cd3e..8c2b6f60c 100644 --- a/docs/user/common-workflows.md +++ b/docs/user/common-workflows.md @@ -218,6 +218,33 @@ This is especially useful: - before CI or agent automation - when debugging resume surprises +## Run the Same System in Docker + +Use `--docker` to preserve envctl's main/trees, selective-service, dependency, dashboard, health, +logs, restart, and stop workflows while replacing app host processes with managed containers: + +```bash +envctl start --main --entire-system --docker --headless +envctl start --trees --entire-system --isolated-deps --docker --headless +``` + +If a service directory contains a `Dockerfile`, envctl builds it with Docker's layer cache. Otherwise, +configure an existing image with `ENVCTL_BACKEND_DOCKER_IMAGE`, `ENVCTL_FRONTEND_DOCKER_IMAGE`, or +the corresponding prefix for an additional app service. Production-oriented images commonly need +`ENVCTL__DOCKER_COMMAND` and `ENVCTL__DOCKER_PORT` so the service listens on +`0.0.0.0` at the expected container port. + +```bash +envctl endpoints --json +envctl health --json +envctl logs --project Main --service backend +envctl restart --project Main --service backend --docker --headless +envctl stop --project Main --entire-system +``` + +See [Configuration: Docker application runtime](../reference/configuration.md#docker-application-runtime) +for image, Dockerfile, command, port, workdir, target, and cache-policy settings. + ## Debug a Bad Interactive Session Use this when the issue is in the dashboard, selector, spinner, or input flow. diff --git a/python/envctl_engine/actions/action_command_execution_support.py b/python/envctl_engine/actions/action_command_execution_support.py index f18734d8f..51e394167 100644 --- a/python/envctl_engine/actions/action_command_execution_support.py +++ b/python/envctl_engine/actions/action_command_execution_support.py @@ -18,6 +18,8 @@ "migrate": "run_migrate_action", } +_BULK_MUTATING_COMMANDS = frozenset({"commit", "migrate", "pr", "ship"}) + class ActionSpinner(Protocol): def start(self) -> None: ... @@ -59,6 +61,12 @@ def execute(self) -> int: self._emit_finish(1, error=error) return 1 + bulk_confirmation_error = self._bulk_confirmation_error(targets) + if bulk_confirmation_error is not None: + print(bulk_confirmation_error) + self._emit_finish(1, error=bulk_confirmation_error) + return 1 + handler = self._handler() if handler is None: return self.runtime.unsupported_command(self.route.command) @@ -70,6 +78,15 @@ def execute(self) -> int: self._emit_finish(code) return code + def _bulk_confirmation_error(self, targets: list[object]) -> str | None: + if self.route.command not in _BULK_MUTATING_COMMANDS: + return None + if not bool(self.route.flags.get("all")) or len(targets) <= 1: + return None + if bool(self.route.flags.get("yes")) or bool(self.route.flags.get("force")): + return None + return f"{self.route.command} --all targets {len(targets)} projects and requires --yes or --force" + def _execute_special_worktree_command(self) -> int | None: if self.route.command == "self-destruct-worktree": code = self.orchestrator.run_self_destruct_worktree_action(self.route) diff --git a/python/envctl_engine/actions/action_git_state_support.py b/python/envctl_engine/actions/action_git_state_support.py index 53928f91f..63d92262e 100644 --- a/python/envctl_engine/actions/action_git_state_support.py +++ b/python/envctl_engine/actions/action_git_state_support.py @@ -7,7 +7,10 @@ import subprocess from typing import Callable -from envctl_engine.shared.git_branch_support import detect_preferred_default_branch +from envctl_engine.shared.git_branch_support import ( + PREFERRED_PR_BASE_BRANCHES, + detect_preferred_default_branch, +) @dataclass(frozen=True, slots=True) @@ -87,6 +90,14 @@ def detect_default_branch(git_root: Path, *, git_output: Callable[[Path, list[st ) +def detect_pr_base_branch(git_root: Path, *, git_output: Callable[[Path, list[str]], str]) -> str: + for branch in PREFERRED_PR_BASE_BRANCHES: + for ref in (f"refs/remotes/origin/{branch}", f"refs/heads/{branch}"): + if git_output(git_root, ["rev-parse", "--verify", ref]).strip(): + return branch + return detect_default_branch(git_root, git_output=git_output) + + def existing_pull_request( git_root: Path, branch: str, diff --git a/python/envctl_engine/actions/project_action_domain.py b/python/envctl_engine/actions/project_action_domain.py index 5ff6e9206..0dea27444 100644 --- a/python/envctl_engine/actions/project_action_domain.py +++ b/python/envctl_engine/actions/project_action_domain.py @@ -337,7 +337,7 @@ def _resolve_pr_base_branch(context: ActionProjectContext, git_root: Path) -> st explicit = str(context.env.get("ENVCTL_PR_BASE", "")).strip() if explicit: return explicit - return detect_default_branch(git_root) + return git_state_support.detect_pr_base_branch(git_root, git_output=_git_output) _resolve_analyze_mode = review_iteration_support.resolve_analyze_mode diff --git a/python/envctl_engine/debug/debug_utils.py b/python/envctl_engine/debug/debug_utils.py index 83ddcbbd2..7511cee73 100644 --- a/python/envctl_engine/debug/debug_utils.py +++ b/python/envctl_engine/debug/debug_utils.py @@ -84,11 +84,6 @@ def file_lock(path: Path, *, timeout: float) -> Iterator[None]: except OSError: pass handle.close() - try: - if path.exists() and path.stat().st_size == 0: - path.unlink() - except OSError: - pass def debug_env_value(env: dict[str, str], key: str) -> str | None: diff --git a/python/envctl_engine/planning/worktree_setup_coordinator.py b/python/envctl_engine/planning/worktree_setup_coordinator.py index 21bc724fb..92d2292f2 100644 --- a/python/envctl_engine/planning/worktree_setup_coordinator.py +++ b/python/envctl_engine/planning/worktree_setup_coordinator.py @@ -28,9 +28,6 @@ def apply_setup_worktree_selection( ) -> list[ProjectContextLike]: if not setup_worktree_requested(route): return project_contexts - if bool(route.flags.get("docker")): - raise RuntimeError("setup-worktrees is not supported in Docker mode.") - multi_entries = coerce_setup_entries( route=route, flag_name="setup_worktrees", diff --git a/python/envctl_engine/runtime/cli.py b/python/envctl_engine/runtime/cli.py index 9ee0d43af..92831ea00 100644 --- a/python/envctl_engine/runtime/cli.py +++ b/python/envctl_engine/runtime/cli.py @@ -80,6 +80,8 @@ def _effective_prereq_mode(route: Route) -> str: def _requires_docker(mode: str, config: EngineConfig, *, route: Route | None = None) -> bool: + if route is not None and bool(route.flags.get("docker")): + return True if route is not None and route.flags.get("launch_dependencies") is False: return False if effective_dependency_scope(route, mode) == "shared" and mode == "trees": diff --git a/python/envctl_engine/runtime/docker_service_runtime.py b/python/envctl_engine/runtime/docker_service_runtime.py new file mode 100644 index 000000000..54be280e0 --- /dev/null +++ b/python/envctl_engine/runtime/docker_service_runtime.py @@ -0,0 +1,737 @@ +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import threading +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Mapping, Sequence + +from envctl_engine.shared.parsing import parse_bool + + +_HOST_ENV_KEYS = { + "HOME", + "OLDPWD", + "PATH", + "PWD", + "PYTHONHOME", + "PYTHONPATH", + "SHELL", + "SHLVL", + "TMPDIR", + "VIRTUAL_ENV", + "VIRTUAL_ENV_PROMPT", + "ZDOTDIR", + "_", +} +_PUBLIC_ENV_PREFIXES = ("VITE_", "NEXT_PUBLIC_", "PUBLIC_") +_PUBLIC_ENV_KEYS = { + "BACKEND_CORS_ORIGINS", + "CORS_ORIGINS", + "CORS_ORIGINS_RAW", + "ENVCTL_SOURCE_FRONTEND_URL", + "FRONTEND_BASE_URL", + "FRONTEND_URL", + "PUBLIC_URL", +} +_DOCKER_INFO_LOCK = threading.Lock() +_RUNTIME_SCOPE_LABEL = "io.envctl.runtime-scope" + + +def _docker_name(value: str, *, limit: int) -> str: + normalized = re.sub(r"[^a-z0-9_.-]+", "-", value.strip().lower()).strip("-._") + return (normalized or "service")[:limit] + + +def docker_service_container_name(*, project_name: str, project_root: Path, service_name: str) -> str: + digest = hashlib.sha256(str(project_root.resolve()).encode()).hexdigest()[:10] + prefix = _docker_name(f"envctl-app-{project_name}-{service_name}", limit=52) + return f"{prefix}-{digest}" + + +@dataclass(frozen=True, slots=True) +class DockerServiceLaunch: + container_id: str + container_name: str + image: str + log_path: str + + +def docker_service_mode_enabled(runtime: Any) -> bool: + env = getattr(runtime, "env", {}) + return parse_bool(str(env.get("DOCKER_MODE", "")), False) + + +def docker_service_container_command_source( + runtime: Any, + service_name: str, + *, + docker_mode: bool | None = None, +) -> str | None: + if not (docker_service_mode_enabled(runtime) if docker_mode is None else docker_mode): + return None + env = getattr(runtime, "env", {}) + raw = getattr(getattr(runtime, "config", None), "raw", {}) + suffix = re.sub(r"[^A-Z0-9]+", "_", service_name.upper()).strip("_") or "SERVICE" + + def setting(name: str) -> str: + for key in (f"ENVCTL_SERVICE_{suffix}_{name}", f"ENVCTL_{suffix}_{name}", f"ENVCTL_{name}"): + value = str(env.get(key) or raw.get(key) or "").strip() + if value: + return value + return "" + + if setting("DOCKER_COMMAND"): + return "docker_command" + if (setting("DOCKER_COMMAND_MODE") or "image").lower() in {"image", "default"}: + return "docker_image" + return None + + +def docker_service_uses_image_command( + runtime: Any, + service_name: str, + *, + docker_mode: bool | None = None, +) -> bool: + return docker_service_container_command_source( + runtime, + service_name, + docker_mode=docker_mode, + ) == "docker_image" + + +def state_uses_docker_services(state: object) -> bool: + metadata = getattr(state, "metadata", {}) + if isinstance(metadata, dict) and str(metadata.get("application_runtime", "")).lower() == "docker": + return True + services = getattr(state, "services", {}) + return isinstance(services, dict) and any( + str(getattr(service, "runtime_kind", "process") or "process").lower() == "docker" + for service in services.values() + ) + + +class DockerServiceRuntime: + """Build and run application services as managed Docker containers.""" + + def __init__(self, runtime: Any, process_runtime: Any, *, refresh_cache: bool = False) -> None: + self.runtime = runtime + self.process_runtime = process_runtime + self.refresh_cache = refresh_cache + + def launch( + self, + *, + project_name: str, + project_root: Path, + service_name: str, + cwd: Path, + command: Sequence[str], + env: Mapping[str, str], + host_port: int, + container_port: int, + listener_expected: bool, + log_path: str, + ) -> DockerServiceLaunch: + self._require_docker() + image = self._resolve_image( + project_root=project_root, + service_name=service_name, + cwd=cwd, + build_env=env, + ) + container_name = self._container_name( + project_name=project_name, + project_root=project_root, + service_name=service_name, + ) + self._prepare_container_name(container_name) + effective_container_port = self._container_port(service_name, container_port, image=image) + container_env = self._container_env(env) + if listener_expected and effective_container_port > 0: + container_env["PORT"] = str(effective_container_port) + env_file = self._write_env_file( + project_name=project_name, + service_name=service_name, + values=container_env, + ) + try: + docker_command = [ + "docker", + "run", + "--detach", + "--name", + container_name, + "--label", + "io.envctl.managed=true", + "--label", + f"io.envctl.project={project_name}", + "--label", + f"io.envctl.service={service_name}", + "--label", + f"{_RUNTIME_SCOPE_LABEL}={self._runtime_scope_identity()}", + "--add-host", + "host.docker.internal:host-gateway", + "--env-file", + str(env_file), + ] + if listener_expected and host_port > 0: + docker_command.extend(["--publish", f"127.0.0.1:{host_port}:{effective_container_port}"]) + workdir = self._setting(service_name, "DOCKER_WORKDIR") + if workdir: + docker_command.extend(["--workdir", workdir]) + docker_command.append(image) + docker_command.extend( + self._container_command( + service_name, + command, + project_root=project_root, + cwd=cwd, + host_port=host_port, + container_port=effective_container_port, + ) + ) + result = self.process_runtime.run( + docker_command, + cwd=project_root, + env={**os.environ, "DOCKER_BUILDKIT": "1"}, + timeout=self._timeout("ENVCTL_DOCKER_RUN_TIMEOUT_SECONDS", 120.0), + ) + finally: + env_file.unlink(missing_ok=True) + if result.returncode != 0: + detail = str(result.stderr or result.stdout or "docker run failed").strip() + raise RuntimeError(detail) + container_id = str(result.stdout or "").strip().splitlines()[-1] + if not container_id: + raise RuntimeError(f"docker run returned no container id for {project_name} {service_name}") + launch = DockerServiceLaunch( + container_id=container_id, + container_name=container_name, + image=image, + log_path=log_path, + ) + self.runtime._emit( + "service.container.start", + project=project_name, + service=service_name, + container_name=container_name, + image=image, + port=host_port if listener_expected else None, + ) + return launch + + def wait_until_ready(self, launch: DockerServiceLaunch, *, port: int, listener_expected: bool) -> bool: + if not self.container_running(launch.container_id): + self.snapshot_logs(launch.container_id, launch.log_path, tail=200) + return False + if not listener_expected: + return True + ready = bool( + self.process_runtime.wait_for_port( + port, + timeout=self._timeout("ENVCTL_SERVICE_LISTENER_TIMEOUT_SECONDS", 30.0), + ) + ) + if not ready: + self.snapshot_logs(launch.container_id, launch.log_path, tail=200) + return ready + + def snapshot_logs(self, container: str, log_path: str, *, tail: int) -> bool: + command = ["docker", "logs"] + since_marker = Path(f"{log_path}.docker-since") + if since_marker.is_file(): + try: + command.extend(["--since", str(since_marker.stat().st_mtime)]) + except OSError: + pass + command.extend(["--tail", str(max(tail, 0)), container]) + result = self.process_runtime.run( + command, + timeout=30.0, + ) + if result.returncode != 0: + return False + stdout = str(result.stdout or "") + stderr = str(result.stderr or "") + content = stdout + (("\n" if stdout and stderr and not stdout.endswith("\n") else "") + stderr) + path = Path(log_path) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(content, encoding="utf-8") + return True + + def follow_logs(self, container: str, log_path: str) -> int | None: + process = self.process_runtime.start_background( + ["docker", "logs", "--follow", "--since", "0s", container], + stdout_path=log_path, + stderr_path=log_path, + ) + pid = getattr(process, "pid", None) + return pid if isinstance(pid, int) and pid > 0 else None + + def stop( + self, + container: str, + *, + remove: bool = True, + verify_ownership: bool = False, + ) -> bool: + if not container: + return True + if verify_ownership and not self._container_owned_by_runtime_scope(container): + return False + command = ["docker", "rm", "--force", container] if remove else ["docker", "stop", container] + result = self.process_runtime.run(command, timeout=30.0) + return result.returncode == 0 or "No such container" in str(result.stderr or "") + + def _container_owned_by_runtime_scope(self, container: str) -> bool: + inspected = self.process_runtime.run( + [ + "docker", + "container", + "inspect", + "--format", + f"{{{{index .Config.Labels {json.dumps(_RUNTIME_SCOPE_LABEL)}}}}}", + container, + ], + timeout=10.0, + ) + if inspected.returncode != 0: + return "No such" in str(inspected.stderr or "") + return str(inspected.stdout or "").strip() == self._runtime_scope_identity() + + def container_running(self, container: str) -> bool: + if not container: + return False + result = self.process_runtime.run( + ["docker", "inspect", "--format", "{{.State.Running}}", container], + timeout=10.0, + ) + return result.returncode == 0 and str(result.stdout or "").strip().lower() == "true" + + def _resolve_image( + self, + *, + project_root: Path, + service_name: str, + cwd: Path, + build_env: Mapping[str, str], + ) -> str: + configured_image = self._setting(service_name, "DOCKER_IMAGE") + dockerfile_setting = self._setting(service_name, "DOCKERFILE") + dockerfile = self._resolve_path(dockerfile_setting, project_root) if dockerfile_setting else None + if dockerfile is None and not configured_image: + dockerfile = next( + (path for path in (cwd / "Dockerfile", project_root / "Dockerfile") if path.is_file()), + None, + ) + if dockerfile is None: + if configured_image: + return configured_image + raise RuntimeError( + f"Docker mode needs ENVCTL_{self._service_key(service_name)}_DOCKER_IMAGE, " + "ENVCTL_DOCKER_IMAGE, or a Dockerfile" + ) + if not dockerfile.is_file(): + raise RuntimeError(f"Configured Dockerfile does not exist: {dockerfile}") + context_setting = self._setting(service_name, "DOCKER_CONTEXT") + context = self._resolve_path(context_setting, project_root) if context_setting else dockerfile.parent + if context is None or not context.is_dir(): + raise RuntimeError(f"Configured Docker build context does not exist: {context}") + image = configured_image or self._generated_image_name(project_root, service_name) + self._build_image( + image=image, + dockerfile=dockerfile, + context=context, + service_name=service_name, + build_env=build_env, + ) + return image + + def _build_image( + self, + *, + image: str, + dockerfile: Path, + context: Path, + service_name: str, + build_env: Mapping[str, str], + ) -> None: + policy = (self._setting(service_name, "DOCKER_BUILD_POLICY") or "cached").strip().lower() + if policy in {"never", "image", "existing"}: + if not self._image_exists(image): + raise RuntimeError(f"Docker image {image!r} does not exist and build policy is {policy!r}") + return + if policy == "missing" and self._image_exists(image): + self.runtime._emit("service.container.build", service=service_name, image=image, cache="image") + return + command = ["docker", "build", "--file", str(dockerfile), "--tag", image] + if self.refresh_cache or parse_bool( + str(getattr(self.runtime, "env", {}).get("RUN_SH_REFRESH_CACHE", "")), + False, + ): + command.append("--pull") + target = self._setting(service_name, "DOCKER_TARGET") + if target: + command.extend(["--target", target]) + build_arguments = self._docker_build_arguments(service_name, build_env) + for key in sorted(build_arguments): + command.extend(["--build-arg", key]) + command.append(str(context)) + self.runtime._emit( + "service.container.build", + service=service_name, + image=image, + dockerfile=str(dockerfile), + context=str(context), + cache="docker_layer_cache", + ) + result = self.process_runtime.run( + command, + cwd=context, + env={**os.environ, **build_arguments, "DOCKER_BUILDKIT": "1"}, + timeout=self._timeout("ENVCTL_DOCKER_BUILD_TIMEOUT_SECONDS", 900.0), + ) + if result.returncode != 0: + detail = str(result.stderr or result.stdout or "docker build failed").strip() + raise RuntimeError(detail) + + def _image_exists(self, image: str) -> bool: + return self.process_runtime.run(["docker", "image", "inspect", image], timeout=10.0).returncode == 0 + + def _prepare_container_name(self, name: str) -> None: + inspect = self.process_runtime.run( + [ + "docker", + "container", + "inspect", + "--format", + f"{{{{.State.Running}}}}|{{{{index .Config.Labels {json.dumps(_RUNTIME_SCOPE_LABEL)}}}}}", + name, + ], + timeout=10.0, + ) + if inspect.returncode != 0: + if "No such" in str(inspect.stderr or "") or "not found" in str(inspect.stderr or "").lower(): + return + raise RuntimeError(str(inspect.stderr or inspect.stdout or f"failed to inspect {name}").strip()) + running_text, _separator, owner = str(inspect.stdout or "").strip().partition("|") + expected_owner = self._runtime_scope_identity() + if owner and owner != expected_owner: + raise RuntimeError( + f"Docker container {name!r} is managed by another envctl runtime scope; " + "stop it from that runtime before starting this one" + ) + if running_text.lower() == "true": + raise RuntimeError( + f"Docker container {name!r} is already running but was not resumed from current state; " + "run envctl stop for this project before starting it again" + ) + self._remove_container(name) + + def _remove_container(self, name: str) -> None: + result = self.process_runtime.run(["docker", "rm", "--force", name], timeout=30.0) + if result.returncode != 0 and "No such container" not in str(result.stderr or ""): + raise RuntimeError(str(result.stderr or result.stdout or f"failed to remove {name}").strip()) + + def _runtime_scope_identity(self) -> str: + config = getattr(self.runtime, "config", None) + scope = getattr(config, "runtime_scope_dir", None) + if scope is None: + scope = Path(self.runtime._run_dir_path("docker-scope")).parent + return hashlib.sha256(str(Path(scope).resolve()).encode()).hexdigest()[:16] + + def _require_docker(self) -> None: + command_exists = getattr(self.runtime, "_command_exists", None) + if callable(command_exists) and not command_exists("docker"): + raise RuntimeError("Docker mode requires the docker CLI") + with _DOCKER_INFO_LOCK: + if bool(getattr(self.runtime, "_docker_application_daemon_checked", False)): + return + result = self.process_runtime.run( + ["docker", "info", "--format", "{{.ServerVersion}}"], + timeout=15.0, + ) + if result.returncode != 0: + raise RuntimeError(str(result.stderr or "Docker daemon is unavailable").strip()) + setattr(self.runtime, "_docker_application_daemon_checked", True) + + def _container_command( + self, + service_name: str, + command: Sequence[str], + *, + project_root: Path, + cwd: Path, + host_port: int, + container_port: int, + ) -> list[str]: + override = self._setting(service_name, "DOCKER_COMMAND") + command_mode = (self._setting(service_name, "DOCKER_COMMAND_MODE") or "image").lower() + if override: + resolved = shlex.split(override) + elif command_mode in {"service", "envctl", "host"}: + resolved = [str(part) for part in command] + elif command_mode in {"image", "default"}: + return [] + else: + raise RuntimeError( + f"Invalid Docker command mode for {service_name}: {command_mode!r}; expected image or service" + ) + if not resolved: + return [] + executable = Path(resolved[0]) + if executable.is_absolute(): + try: + resolved[0] = str(executable.relative_to(cwd)) + except ValueError: + try: + resolved[0] = str(executable.relative_to(project_root)) + except ValueError: + pass + normalized: list[str] = [] + for part in resolved: + if part in {"127.0.0.1", "localhost"}: + normalized.append("0.0.0.0") + continue + if host_port > 0 and container_port > 0: + if part == str(host_port): + normalized.append(str(container_port)) + continue + part = re.sub( + rf"^(--port=){re.escape(str(host_port))}$", + rf"\g<1>{container_port}", + part, + ) + part = re.sub(r"^(--host=)(localhost|127\.0\.0\.1)$", r"\g<1>0.0.0.0", part) + normalized.append(part) + return normalized + + def _docker_build_arguments( + self, + service_name: str, + build_env: Mapping[str, str], + ) -> dict[str, str]: + arguments = { + str(key): str(value) + for key, value in build_env.items() + if str(key).startswith(_PUBLIC_ENV_PREFIXES) + } + configured = self._setting(service_name, "DOCKER_BUILD_ARGS") + for token in configured.split(","): + item = token.strip() + if not item: + continue + key, separator, configured_value = item.partition("=") + key = key.strip() + if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", key): + raise RuntimeError(f"Invalid Docker build argument name: {key!r}") + if separator: + arguments[key] = configured_value + elif key in build_env: + arguments[key] = str(build_env[key]) + else: + raise RuntimeError(f"Docker build argument {key!r} is not present in the service environment") + return arguments + + def _container_env(self, values: Mapping[str, str]) -> dict[str, str]: + result: dict[str, str] = {} + browser_facing_keys = self._browser_facing_env_keys() + for raw_key, raw_value in values.items(): + key = str(raw_key) + if key in _HOST_ENV_KEYS or key.startswith("TERM_") or key.startswith("LC_"): + continue + value = str(raw_value) + if key in {"HOST", "BIND_HOST", "LISTEN_HOST", "SERVER_HOST"} and value in { + "localhost", + "127.0.0.1", + }: + result[key] = "0.0.0.0" + continue + if key not in browser_facing_keys and not key.startswith(_PUBLIC_ENV_PREFIXES): + value = re.sub( + r"(://(?:[^/@\s]+@)?)(localhost|127\.0\.0\.1)(?=[:/]|$)", + r"\1host.docker.internal", + value, + ) + if key.endswith("_HOST") and value in {"localhost", "127.0.0.1"}: + value = "host.docker.internal" + result[key] = value + result["ENVCTL_CONTAINER_RUNTIME"] = "docker" + result["ENVCTL_HOST_GATEWAY"] = "host.docker.internal" + return result + + def _browser_facing_env_keys(self) -> set[str]: + keys = set(_PUBLIC_ENV_KEYS) + runtime_env = getattr(self.runtime, "env", {}) + config_raw = getattr(getattr(self.runtime, "config", None), "raw", {}) + cors_key = str( + runtime_env.get( + "ENVCTL_BACKEND_CORS_ENV_KEY", + config_raw.get("ENVCTL_BACKEND_CORS_ENV_KEY", ""), + ) + or "" + ).strip() + if cors_key: + keys.add(cors_key) + return keys + + def _write_env_file(self, *, project_name: str, service_name: str, values: Mapping[str, str]) -> Path: + run_dir = Path(self.runtime._run_dir_path(getattr(self.runtime, "_active_run_id", None) or "docker")) + run_dir.mkdir(parents=True, exist_ok=True) + digest = hashlib.sha256(f"{project_name}\0{service_name}".encode()).hexdigest()[:12] + path = run_dir / f".docker-env-{digest}" + lines = [f"{key}={str(value).replace(chr(10), '')}" for key, value in sorted(values.items())] + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + path.chmod(0o600) + return path + + def _setting(self, service_name: str, suffix: str) -> str: + env = getattr(self.runtime, "env", {}) + raw = getattr(getattr(self.runtime, "config", None), "raw", {}) + service_key = f"ENVCTL_{self._service_key(service_name)}_{suffix}" + additional_service_key = f"ENVCTL_SERVICE_{self._service_key(service_name)}_{suffix}" + global_key = f"ENVCTL_{suffix}" + for key in (additional_service_key, service_key, global_key): + value = str(env.get(key) or raw.get(key) or "").strip() + if value: + return value + return "" + + def _container_port(self, service_name: str, host_port: int, *, image: str) -> int: + value = self._setting(service_name, "DOCKER_PORT") + if not value: + self._ensure_image_available(image) + exposed = self._single_exposed_port(image) + return exposed if exposed is not None else host_port + try: + port = int(value) + except ValueError as exc: + raise RuntimeError(f"Invalid Docker container port for {service_name}: {value!r}") from exc + if port <= 0 or port > 65535: + raise RuntimeError(f"Invalid Docker container port for {service_name}: {value!r}") + return port + + def _ensure_image_available(self, image: str) -> None: + if self._image_exists(image): + return + self.runtime._emit("service.container.pull", image=image) + pulled = self.process_runtime.run( + ["docker", "pull", image], + timeout=self._timeout("ENVCTL_DOCKER_PULL_TIMEOUT_SECONDS", 300.0), + ) + if pulled.returncode != 0: + detail = str(pulled.stderr or pulled.stdout or f"failed to pull Docker image {image}").strip() + raise RuntimeError(detail) + + def _single_exposed_port(self, image: str) -> int | None: + result = self.process_runtime.run( + ["docker", "image", "inspect", "--format", "{{json .Config.ExposedPorts}}", image], + timeout=10.0, + ) + if result.returncode != 0: + return None + try: + payload = json.loads(str(result.stdout or "null")) + except json.JSONDecodeError: + return None + if not isinstance(payload, dict) or len(payload) != 1: + return None + raw_port = str(next(iter(payload))).partition("/")[0] + try: + port = int(raw_port) + except ValueError: + return None + return port if 0 < port <= 65535 else None + + def _container_name(self, *, project_name: str, project_root: Path, service_name: str) -> str: + return docker_service_container_name( + project_name=project_name, + project_root=project_root, + service_name=service_name, + ) + + def _generated_image_name(self, project_root: Path, service_name: str) -> str: + identity = self._repository_identity(project_root) + digest = hashlib.sha256(str(project_root.resolve()).encode()).hexdigest()[:10] + repo = _docker_name(identity.name, limit=32) + service = _docker_name(service_name, limit=24) + return f"envctl/{repo}-{service}:{digest}" + + @staticmethod + def _repository_identity(project_root: Path) -> Path: + dot_git = project_root / ".git" + if dot_git.is_file(): + try: + gitdir = dot_git.read_text(encoding="utf-8").strip().removeprefix("gitdir:").strip() + resolved = (project_root / gitdir).resolve() + if resolved.parent.name == "worktrees": + return resolved.parent.parent.parent + except OSError: + pass + return project_root.resolve() + + @staticmethod + def _service_key(service_name: str) -> str: + return re.sub(r"[^A-Z0-9]+", "_", service_name.upper()).strip("_") or "SERVICE" + + @staticmethod + def _resolve_path(value: str, project_root: Path) -> Path | None: + if not value: + return None + path = Path(value).expanduser() + return path.resolve() if path.is_absolute() else (project_root / path).resolve() + + def _timeout(self, key: str, default: float) -> float: + value = str(getattr(self.runtime, "env", {}).get(key, "") or "").strip() + try: + return max(float(value), 1.0) if value else default + except ValueError: + return default + + +def refresh_container_log_snapshots( + runtime: Any, + state: object, + *, + tail: int, + follow: bool, +) -> list[int]: + docker_services = [ + service + for service in getattr(state, "services", {}).values() + if str(getattr(service, "runtime_kind", "process") or "process").lower() == "docker" + ] + if not docker_services: + return [] + process_runner = getattr(runtime, "process_runner", None) + if process_runner is None: + return [] + docker_runtime = DockerServiceRuntime(runtime, process_runner) + follower_pids: list[int] = [] + for service in docker_services: + container = str( + getattr(service, "container_id", "") or getattr(service, "container_name", "") or "" + ).strip() + log_path = str(getattr(service, "log_path", "") or "").strip() + if not container or not log_path: + continue + docker_runtime.snapshot_logs(container, log_path, tail=tail) + if follow: + pid = docker_runtime.follow_logs(container, log_path) + if pid is not None: + follower_pids.append(pid) + return follower_pids + + +def stop_container_log_followers(runtime: Any, pids: Sequence[int]) -> None: + for pid in pids: + try: + runtime.process_runner.terminate_process_group(pid, term_timeout=1.0, kill_timeout=1.0) + except Exception: # noqa: BLE001 + continue diff --git a/python/envctl_engine/runtime/engine_runtime_artifacts.py b/python/envctl_engine/runtime/engine_runtime_artifacts.py index 349d2801d..085212d0b 100644 --- a/python/envctl_engine/runtime/engine_runtime_artifacts.py +++ b/python/envctl_engine/runtime/engine_runtime_artifacts.py @@ -243,12 +243,28 @@ def _runtime_readiness_async_enabled(runtime: Any) -> bool: def print_summary(_runtime: Any, state: object, contexts: Sequence[_SummaryContext]) -> None: - _ = state print("envctl Python engine run summary") for context in contexts: - backend = context.ports["backend"].final - frontend = context.ports["frontend"].final + backend = _summary_service_port(state, context.name, "backend") or context.ports["backend"].final + frontend = _summary_service_port(state, context.name, "frontend") or context.ports["frontend"].final db = context.ports["db"].final redis = context.ports["redis"].final n8n = context.ports["n8n"].final print(f"- {context.name}: backend={backend} frontend={frontend} db={db} redis={redis} n8n={n8n}") + + +def _summary_service_port(state: object, project_name: str, service_type: str) -> int | None: + for service_name, service in getattr(state, "services", {}).items(): + project = str(getattr(service, "project", "") or "").strip() + if not project: + suffix = f" {service_type}".lower() + rendered_name = str(service_name) + project = rendered_name[: -len(suffix)] if rendered_name.lower().endswith(suffix) else "" + if project.casefold() != project_name.casefold(): + continue + if str(getattr(service, "type", "") or "").casefold() != service_type.casefold(): + continue + port = getattr(service, "actual_port", None) or getattr(service, "requested_port", None) + if isinstance(port, int) and port > 0: + return port + return None diff --git a/python/envctl_engine/runtime/engine_runtime_commands.py b/python/envctl_engine/runtime/engine_runtime_commands.py index a50437637..996e84dd3 100644 --- a/python/envctl_engine/runtime/engine_runtime_commands.py +++ b/python/envctl_engine/runtime/engine_runtime_commands.py @@ -8,6 +8,7 @@ from typing import Any, Mapping from envctl_engine.runtime.command_resolution import resolve_requirement_start_command, resolve_service_start_command +from envctl_engine.runtime.docker_service_runtime import docker_service_container_command_source SERVICE_LAUNCH_ENV_REMOVALS = { "ACTIONS_CACHE_URL", @@ -106,6 +107,9 @@ def service_start_command_resolved( project_root: Path | None = None, port: int = 0, ) -> tuple[list[str], str]: + container_command_source = docker_service_container_command_source(runtime, service_name) + if container_command_source is not None: + return [], container_command_source result = resolve_service_start_command( service_name=service_name, project_root=(project_root or runtime.config.base_dir), diff --git a/python/envctl_engine/runtime/engine_runtime_hooks.py b/python/envctl_engine/runtime/engine_runtime_hooks.py index 2085ec347..4ba8394ad 100644 --- a/python/envctl_engine/runtime/engine_runtime_hooks.py +++ b/python/envctl_engine/runtime/engine_runtime_hooks.py @@ -148,6 +148,10 @@ def services_from_hook_payload( actual_port=(actual_port if actual_port > 0 else None), log_path=(str(log_path) if log_path else None), status=status, + runtime_kind=str(raw.get("runtime_kind") or "process"), + container_id=str(raw.get("container_id") or "") or None, + container_name=str(raw.get("container_name") or "") or None, + container_image=str(raw.get("container_image") or "") or None, ) records[name] = record if service_type == "backend" and actual_port > 0: diff --git a/python/envctl_engine/runtime/help_general.py b/python/envctl_engine/runtime/help_general.py index 0e7b00251..7451029a7 100644 --- a/python/envctl_engine/runtime/help_general.py +++ b/python/envctl_engine/runtime/help_general.py @@ -87,6 +87,7 @@ def render_general_help() -> str: " --only-backend launch only backend; skip frontend and dependencies/prep", " --no-deps skip managed dependencies and plan-agent dependency prep", " --no-infra skip backend, frontend, managed dependencies, and plan-agent prep", + " --docker run configured app services as managed Docker containers", "", "Important global flags:", " --headless / --batch do not prompt; use deterministic automation-friendly output", diff --git a/python/envctl_engine/runtime/help_topic_actions.py b/python/envctl_engine/runtime/help_topic_actions.py index 74e8f7e3b..efd4ac7ec 100644 --- a/python/envctl_engine/runtime/help_topic_actions.py +++ b/python/envctl_engine/runtime/help_topic_actions.py @@ -65,7 +65,7 @@ "pr": CommandHelpTopic( command="pr", summary="create a pull request for the selected branch/worktree", - usage=("envctl pr [--project ] [--pr-base ]",), + usage=("envctl pr [--project |--all --yes] [--pr-base ]",), what_it_does=( "resolves the current branch, checks for an existing PR, and creates one with gh or repo helper scripts", "defaults the PR base to dev, then main, then master, while --pr-base remains an explicit override", @@ -74,6 +74,7 @@ ), flags=( "--project create PR for selected worktree/project", + "--all --yes explicitly approve creating/updating PRs for every discovered target", "--pr-base set the target base branch", "--interactive opt into prompts/selection instead of default headless action mode", ), @@ -84,7 +85,7 @@ "commit": CommandHelpTopic( command="commit", summary="commit-only fallback that preserves envctl-local control artifacts", - usage=("envctl commit [--project |--main] [-m |--commit-message-file ]",), + usage=("envctl commit [--project |--main|--all --yes] [-m |--commit-message-file ]",), what_it_does=( "use envctl ship for normal AI handoff; reserve commit for commit-only maintenance or fallback flows", "stages normal changed paths and intentionally skips protected envctl-local artifacts", @@ -97,6 +98,7 @@ "--commit-message-file read commit message from a file", "--project commit inside selected worktree/project", "--main target the main checkout", + "--all --yes explicitly approve committing every discovered target", ), examples=( "envctl commit --main -m 'Ship focused fix'", @@ -108,7 +110,7 @@ "ship": CommandHelpTopic( command="ship", summary="commit, push, create/update PR, and report GitHub checks for the current or selected target", - usage=("envctl ship [--project ] [-m ] [--human]",), + usage=("envctl ship [--project |--all --yes] [-m ] [--human]",), what_it_does=( "when run inside a generated worktree, infers that worktree without requiring --project", "owns the normal AI handoff flow instead of requiring separate commit, push, or PR commands", @@ -124,6 +126,7 @@ ), flags=( "--project ship one worktree/project", + "--all --yes explicitly approve shipping every discovered target", "-m use explicit commit message text for the commit phase", "--json compatibility no-op; JSON is the default", "--human print compact terminal output instead of JSON", @@ -156,7 +159,7 @@ "migrate": CommandHelpTopic( command="migrate", summary="run backend database migrations for selected targets", - usage=("envctl migrate [--project |--main|--all]",), + usage=("envctl migrate [--project |--main|--all --yes]",), what_it_does=( "runs the configured/default backend migration command, usually Alembic upgrade head", "loads backend env files and reuses saved dependency URLs when a current run exists", @@ -165,7 +168,7 @@ flags=( "--project migrate one worktree/project", "--main migrate the main checkout", - "--all migrate all selected/discovered targets where supported", + "--all --yes explicitly approve migrating all discovered targets", ), examples=("envctl migrate --project feature-a-1", "envctl migrate --main"), aliases=("migration", "migrations", "m", "--migrate"), diff --git a/python/envctl_engine/runtime/help_topic_lifecycle.py b/python/envctl_engine/runtime/help_topic_lifecycle.py index 9d6b2c8a6..5cd01cbaf 100644 --- a/python/envctl_engine/runtime/help_topic_lifecycle.py +++ b/python/envctl_engine/runtime/help_topic_lifecycle.py @@ -26,6 +26,7 @@ "--deps-sequential|--sequential-deps force managed dependencies to start one at a time", "--project limit startup to selected project/worktree when supported", "--no-resume skip automatic resume of a compatible saved run", + "--docker build/use images and run app services in managed containers", ), examples=( "envctl", @@ -33,6 +34,7 @@ "envctl start --trees --entire-system --headless", "envctl start --project feature-a-1 --backend --headless", "envctl --trees --only-backend --headless", + "envctl start --trees --entire-system --docker --headless", ), related=("restart", "resume", "dashboard", "stop", "health"), ), diff --git a/python/envctl_engine/runtime/lifecycle_blast_docker.py b/python/envctl_engine/runtime/lifecycle_blast_docker.py index 73997ac0a..ab62412c1 100644 --- a/python/envctl_engine/runtime/lifecycle_blast_docker.py +++ b/python/envctl_engine/runtime/lifecycle_blast_docker.py @@ -10,7 +10,10 @@ def matches_blast_container(*, image: str, name: str) -> bool: image_l = image.lower() name_l = name.lower() - return any(token in name_l or token in image_l for token in ("supabase", "n8n", "redis", "postgres")) + return any( + token in name_l or token in image_l + for token in ("envctl-app-", "supabase", "n8n", "redis", "postgres") + ) class BlastDockerCleanupSupport: diff --git a/python/envctl_engine/runtime/lifecycle_cleanup_orchestrator.py b/python/envctl_engine/runtime/lifecycle_cleanup_orchestrator.py index 122df92c2..d3c6a4456 100644 --- a/python/envctl_engine/runtime/lifecycle_cleanup_orchestrator.py +++ b/python/envctl_engine/runtime/lifecycle_cleanup_orchestrator.py @@ -3,6 +3,7 @@ from collections.abc import Iterable from typing import Any, Callable, Mapping, cast +from envctl_engine.requirements.core import dependency_definitions from envctl_engine.runtime.lifecycle_blast_support import LifecycleBlastCleanupSupport from envctl_engine.runtime.engine_runtime_lifecycle_support import release_requirement_ports from envctl_engine.runtime.lifecycle_dependency_stop import ( @@ -10,6 +11,7 @@ release_selected_dependency_components, requirements_have_enabled_components, select_dependency_components_for_stop, + stop_requirement_component_containers, ) from envctl_engine.runtime.lifecycle_requirement_ports import requirement_component_port_owners from envctl_engine.runtime.lifecycle_service_stop_selection import ( @@ -349,6 +351,11 @@ def operation() -> int: return 0 for project in list(state.requirements): + requirements = state.requirements[project] + for definition in dependency_definitions(): + component = requirements.component(definition.id) + if bool(component.get("enabled", False)): + self._stop_requirement_component_containers(component) self._release_requirement_ports(state.requirements[project]) state.requirements.pop(project, None) @@ -379,8 +386,39 @@ def _release_selected_dependency_components( state, selected_dependencies, release_component_ports_fn=self._release_requirement_component_ports, + stop_component_fn=self._stop_requirement_component_containers, ) + def _stop_requirement_component_containers(self, component: Mapping[str, object]) -> None: + stop_requirement_component_containers(self.runtime, component) + + def _stop_requirement_component_containers_best_effort(self, component: Mapping[str, object]) -> None: + try: + self._stop_requirement_component_containers(component) + except Exception as exc: # noqa: BLE001 + component_id = str(component.get("id") or "dependency").strip() or "dependency" + detail = str(exc).strip() or exc.__class__.__name__ + self.runtime._emit( # type: ignore[attr-defined] + "cleanup.dependency_container.warning", + component=component_id, + detail=detail, + ) + print(f"Warning: could not stop {component_id} container during cleanup: {detail}") + + def _stop_requirement_containers( + self, + requirements: RequirementsResult, + *, + best_effort: bool = False, + ) -> None: + for definition in dependency_definitions(): + component = requirements.component(definition.id) + if bool(component.get("enabled", False)): + if best_effort: + self._stop_requirement_component_containers_best_effort(component) + else: + self._stop_requirement_component_containers(component) + def _release_requirement_component_ports( self, requirements: RequirementsResult, @@ -476,6 +514,11 @@ def clear_runtime_state(self, *, command: str, aggressive: bool = False, route: ) if not failed_services: requirements_to_release = list(state.requirements.values()) + for requirements in requirements_to_release: + self._stop_requirement_containers( + requirements, + best_effort=command in {"stop-all", "blast-all"}, + ) self._deactivate_runtime_state(state, release_session_when_empty=False) for requirements in requirements_to_release: self._release_requirement_ports(requirements) @@ -495,6 +538,11 @@ def clear_runtime_state(self, *, command: str, aggressive: bool = False, route: retained_requirements[project] = requirements else: requirements_to_release.append(requirements) + for requirements in requirements_to_release: + self._stop_requirement_containers( + requirements, + best_effort=command in {"stop-all", "blast-all"}, + ) state.requirements = {project: requirements for project, requirements in retained_requirements.items()} state_repository.save_selected_stop_state( state=state, diff --git a/python/envctl_engine/runtime/lifecycle_dependency_stop.py b/python/envctl_engine/runtime/lifecycle_dependency_stop.py index 909958e9a..617243eb0 100644 --- a/python/envctl_engine/runtime/lifecycle_dependency_stop.py +++ b/python/envctl_engine/runtime/lifecycle_dependency_stop.py @@ -10,6 +10,17 @@ def select_dependency_components_for_stop(state: RunState, route: Route) -> dict[str, set[str]]: + if route.flags.get("runtime_scope") == "entire-system": + requested_projects = {str(project).strip().casefold() for project in route.projects if str(project).strip()} + return { + project_name: { + definition.id + for definition in dependency_definitions() + if bool(requirements.component(definition.id).get("enabled", False)) + } + for project_name, requirements in state.requirements.items() + if not requested_projects or str(project_name).strip().casefold() in requested_projects + } raw_components = route.flags.get("stop_dependency_components") if not isinstance(raw_components, list): return {} @@ -39,6 +50,7 @@ def release_selected_dependency_components( selected_dependencies: dict[str, set[str]], *, release_component_ports_fn: Callable[[RequirementsResult, str, Mapping[str, object]], None], + stop_component_fn: Callable[[Mapping[str, object]], None] | None = None, ) -> None: for project_name, dependency_ids in selected_dependencies.items(): requirements = state.requirements.get(project_name) @@ -49,6 +61,8 @@ def release_selected_dependency_components( if not bool(component.get("enabled", False)): continue if not bool(component.get("external")): + if stop_component_fn is not None: + stop_component_fn(component) release_component_ports_fn(requirements, dependency_id, component) requirements.components[dependency_id] = {} if not requirements_have_enabled_components(requirements): @@ -75,3 +89,49 @@ def requirements_have_enabled_components(requirements: object) -> bool: return any( bool(component.get("enabled", False)) for component in components.values() if isinstance(component, Mapping) ) + + +def stop_requirement_component_containers(runtime: Any, component: Mapping[str, object]) -> None: + if bool(component.get("external")) or bool(component.get("simulated")): + return + container_name = str(component.get("container_name") or "").strip() + if not container_name: + return + process_runner = getattr(runtime, "process_runner", None) + if process_runner is None: + return + if str(component.get("id") or "").strip().lower() == "supabase": + compose_project = _supabase_compose_project(container_name) + listed = process_runner.run( + [ + "docker", + "ps", + "--all", + "--quiet", + "--filter", + f"label=com.docker.compose.project={compose_project}", + ], + timeout=30.0, + ) + if listed.returncode != 0: + raise RuntimeError(str(listed.stderr or listed.stdout or "failed listing Supabase containers").strip()) + container_ids = [line.strip() for line in str(listed.stdout or "").splitlines() if line.strip()] + if container_ids: + removed = process_runner.run(["docker", "rm", "--force", *container_ids], timeout=60.0) + if removed.returncode != 0: + detail = removed.stderr or removed.stdout or "failed stopping Supabase containers" + raise RuntimeError(str(detail).strip()) + return + # Native Supabase DB startup records the concrete container name and + # does not attach a Compose project label. Fall through to direct + # removal when the saved component is not a Compose stack. + removed = process_runner.run(["docker", "rm", "--force", container_name], timeout=30.0) + if removed.returncode != 0 and "No such container" not in str(removed.stderr or ""): + raise RuntimeError(str(removed.stderr or removed.stdout or f"failed stopping {container_name}").strip()) + + +def _supabase_compose_project(container_name: str) -> str: + db_container_suffix = "-supabase-db-1" + if container_name.endswith(db_container_suffix): + return container_name[: -len(db_container_suffix)] + return container_name diff --git a/python/envctl_engine/runtime/lifecycle_service_termination.py b/python/envctl_engine/runtime/lifecycle_service_termination.py index aac50d64c..092d863e2 100644 --- a/python/envctl_engine/runtime/lifecycle_service_termination.py +++ b/python/envctl_engine/runtime/lifecycle_service_termination.py @@ -121,6 +121,46 @@ def service_ports(service: object) -> tuple[int, ...]: def terminate_service_record(runtime: Any, service: object, *, aggressive: bool, verify_ownership: bool) -> bool: + if str(getattr(service, "runtime_kind", "process") or "process").lower() == "docker": + from envctl_engine.runtime.docker_service_runtime import DockerServiceRuntime + + container = str( + getattr(service, "container_id", "") or getattr(service, "container_name", "") or "" + ).strip() + stopped = DockerServiceRuntime(runtime, runtime.process_runner).stop( + container, + verify_ownership=verify_ownership, + ) + follower_stopped = True + pid = getattr(service, "pid", None) + if isinstance(pid, int) and pid > 0: + if pid in {os.getpid(), os.getppid()}: + runtime._emit( + "cleanup.skip", + service=getattr(service, "name", "unknown"), + pid=pid, + reason="self_or_parent", + ) + follower_stopped = False + else: + try: + runtime.process_runner.terminate_process_group( + pid, + term_timeout=0.5 if aggressive else 2.0, + kill_timeout=1.0, + ) + except Exception: # noqa: BLE001 + pass + follower_stopped = not _pid_is_running(runtime, pid) + runtime._emit( + "service.container.stop", + service=getattr(service, "name", "unknown"), + container_name=getattr(service, "container_name", None), + stopped=stopped, + follower_stopped=follower_stopped, + ) + return stopped and follower_stopped + recorded_pids = _recorded_service_pids(service) if not recorded_pids and str(getattr(service, "status", "") or "") == "termination_failed": return False diff --git a/python/envctl_engine/runtime/lifecycle_worktree_containers.py b/python/envctl_engine/runtime/lifecycle_worktree_containers.py index 55717aab7..6f796743b 100644 --- a/python/envctl_engine/runtime/lifecycle_worktree_containers.py +++ b/python/envctl_engine/runtime/lifecycle_worktree_containers.py @@ -7,6 +7,7 @@ from envctl_engine.requirements.common_contracts import build_container_name from envctl_engine.requirements.docker_runtime import run_docker, run_result_error from envctl_engine.requirements.supabase import build_supabase_project_name +from envctl_engine.runtime.docker_service_runtime import docker_service_container_name def legacy_container_name(*, prefix: str, project_name: str) -> str: @@ -36,6 +37,20 @@ def remove_tree_containers( legacy_container_name(prefix="envctl-redis", project_name=project_name): "redis", legacy_container_name(prefix="envctl-n8n", project_name=project_name): "n8n", } + app_service_names = ["backend", "frontend"] + app_service_names.extend( + str(getattr(service, "name", "") or "").strip() + for service in getattr(getattr(runtime, "config", None), "additional_services", ()) + if str(getattr(service, "name", "") or "").strip() + ) + for service_name in app_service_names: + exact_names[ + docker_service_container_name( + project_name=project_name, + project_root=resolved_root, + service_name=service_name, + ) + ] = service_name supabase_prefixes: set[str] = set() if include_supabase: supabase_prefixes = { diff --git a/python/envctl_engine/runtime/service_manager.py b/python/envctl_engine/runtime/service_manager.py index 20384feb9..ccaf3c5e3 100644 --- a/python/envctl_engine/runtime/service_manager.py +++ b/python/envctl_engine/runtime/service_manager.py @@ -43,6 +43,7 @@ class ServiceStartDescriptor: log_path: str | None = None public_url: str | None = None health_url: str | None = None + pid_required: bool = True class ServiceManager: @@ -60,6 +61,7 @@ def start_service_with_retry( reserve_next: Callable[[int], int], detect_actual: Callable[[int | None, int], int | None] | None = None, listener_expected: bool = True, + pid_required: bool = True, max_retries: int = 3, on_retry: Callable[[str, int, int, int, str | None], None] | None = None, ) -> ServiceRecord: @@ -69,7 +71,8 @@ def start_service_with_retry( while True: success, error, pid = start(current_port) if success: - if not isinstance(pid, int) or isinstance(pid, bool) or pid <= 0: + valid_pid = isinstance(pid, int) and not isinstance(pid, bool) and pid > 0 + if pid_required and not valid_pid: record = _failed_start_record( project=project, service_type=service_type, @@ -91,7 +94,7 @@ def start_service_with_retry( name=f"{project} {service_display_name(service_type)}", type=service_type, cwd=cwd, - pid=pid, + pid=pid if valid_pid else None, requested_port=requested_port if listener_expected else None, actual_port=actual_port, status="running", @@ -209,6 +212,7 @@ def start_record(descriptor: ServiceStartDescriptor) -> ServiceRecord: reserve_next=reserve_next, detect_actual=descriptor.detect_actual, listener_expected=descriptor.listener_expected, + pid_required=descriptor.pid_required, max_retries=descriptor.max_retries, on_retry=on_retry, ) diff --git a/python/envctl_engine/runtime/service_status_truth.py b/python/envctl_engine/runtime/service_status_truth.py index c5001a5a3..e2335c245 100644 --- a/python/envctl_engine/runtime/service_status_truth.py +++ b/python/envctl_engine/runtime/service_status_truth.py @@ -6,6 +6,33 @@ def service_truth_status(runtime: Any, service: object) -> str: + if str(getattr(service, "runtime_kind", "process") or "process").lower() == "docker": + from envctl_engine.runtime.docker_service_runtime import DockerServiceRuntime + + container = str( + getattr(service, "container_id", "") or getattr(service, "container_name", "") or "" + ).strip() + docker_runtime = DockerServiceRuntime(runtime, runtime.process_runner) + if not docker_runtime.container_running(container): + status = "stale" + elif not bool(getattr(service, "listener_expected", True)): + status = "running" + else: + port = getattr(service, "actual_port", None) or getattr(service, "requested_port", None) + try: + reachable = isinstance(port, int) and port > 0 and bool( + runtime.process_runner.wait_for_port(port, timeout=runtime._service_truth_timeout()) + ) + except Exception: # noqa: BLE001 + reachable = False + status = "running" if reachable else "unreachable" + runtime._emit( + "service.truth.check", + service=service_display_name(service), + status=status, + reason_code=f"container_truth_status_{status}", + ) + return status backend = getattr(runtime.process_probe, "backend", None) if isinstance(backend, ShellProbeBackend): backend.process_runner = runtime.process_runner diff --git a/python/envctl_engine/runtime/startup_inspection_support.py b/python/envctl_engine/runtime/startup_inspection_support.py index 2d07a1170..656a4298d 100644 --- a/python/envctl_engine/runtime/startup_inspection_support.py +++ b/python/envctl_engine/runtime/startup_inspection_support.py @@ -84,6 +84,9 @@ def build(self) -> dict[str, Any]: payload = { "command": getattr(self.startup_route, "command", "start"), "mode": self.runtime_mode, + "application_runtime": ( + "docker" if bool(getattr(self.startup_route, "flags", {}).get("docker")) else "process" + ), "headless": self.batch or not self.can_tty, "interactive_tty": self.can_tty, "selection": selection_info, diff --git a/python/envctl_engine/startup/finalization_run_state.py b/python/envctl_engine/startup/finalization_run_state.py index 8ca2f0c02..326e5850d 100644 --- a/python/envctl_engine/startup/finalization_run_state.py +++ b/python/envctl_engine/startup/finalization_run_state.py @@ -54,6 +54,9 @@ def build_planning_dashboard_state( ), } ) + metadata["application_runtime"] = ( + "docker" if bool(route.flags.get("docker")) else "process" + ) run_state = RunState( run_id=run_id, mode=runtime_mode, @@ -80,6 +83,9 @@ def _build_run_state(runtime: StartupRuntime, session: StartupSession, *, failed { "command": session.effective_route.command, "repo_scope_id": runtime.config.runtime_scope_id, + "application_runtime": ( + "docker" if bool(session.effective_route.flags.get("docker")) else "process" + ), } ) dependency_mode = effective_dependency_scope(session.effective_route, session.runtime_mode) diff --git a/python/envctl_engine/startup/restart_prestop_support.py b/python/envctl_engine/startup/restart_prestop_support.py index 639387cbd..ad978d581 100644 --- a/python/envctl_engine/startup/restart_prestop_support.py +++ b/python/envctl_engine/startup/restart_prestop_support.py @@ -4,6 +4,7 @@ from typing import Any, Callable, Iterable from envctl_engine.runtime.command_router import Route +from envctl_engine.runtime.docker_service_runtime import state_uses_docker_services from envctl_engine.runtime.lifecycle_requirement_ports import release_port_reservation from envctl_engine.state.lookup import call_state_loader from envctl_engine.runtime.runtime_context import resolve_port_allocator, resolve_process_runtime @@ -82,6 +83,9 @@ def restart_prestop_state(*, route: Route, runtime: Any) -> RestartPrestopState: run_id=resumed.run_id, ) resumed = None + if resumed is not None and state_uses_docker_services(resumed): + route.flags["docker"] = True + runtime.env["DOCKER_MODE"] = "true" fallback_route = None if resumed is None: fallback_route = restart_fallback_start_route(route, restart_lookup_mode=restart_lookup_mode) diff --git a/python/envctl_engine/startup/resume_restore_execution.py b/python/envctl_engine/startup/resume_restore_execution.py index 6367c0661..d5be89152 100644 --- a/python/envctl_engine/startup/resume_restore_execution.py +++ b/python/envctl_engine/startup/resume_restore_execution.py @@ -7,6 +7,7 @@ from typing import Callable, Mapping from envctl_engine.runtime.command_router import Route +from envctl_engine.runtime.docker_service_runtime import state_uses_docker_services from envctl_engine.state.models import RunState from envctl_engine.startup.resume_restore_project import ResumeProjectRestoreRunner, _round_ms from envctl_engine.startup.resume_restore_results import apply_restore_result @@ -113,6 +114,7 @@ def _execute_restore_missing( use_single_spinner = use_spinner and not use_project_spinner_group suppress_timing_output = use_project_spinner_group or use_single_spinner route_for_startup = _route_for_resume_restore(route, state=state, suppress_timing_output=suppress_timing_output) + _apply_restore_runtime_mode(rt, route_for_startup) if use_single_spinner: rt._emit( # type: ignore[attr-defined] "ui.spinner.lifecycle", @@ -240,6 +242,8 @@ def _route_for_resume_restore( **route_for_startup.flags, "_resume_restore": True, } + if state_uses_docker_services(state): + flags["docker"] = True if suppress_timing_output: flags["_suppress_timing_print"] = True return Route( @@ -252,6 +256,11 @@ def _route_for_resume_restore( ) +def _apply_restore_runtime_mode(runtime: object, route: Route) -> None: + if bool(route.flags.get("docker")): + getattr(runtime, "env")["DOCKER_MODE"] = "true" + + def _run_restore_jobs( *, sorted_projects: list[str], diff --git a/python/envctl_engine/startup/run_reuse_decision.py b/python/envctl_engine/startup/run_reuse_decision.py index b1470c2fd..fbb715981 100644 --- a/python/envctl_engine/startup/run_reuse_decision.py +++ b/python/envctl_engine/startup/run_reuse_decision.py @@ -8,6 +8,7 @@ from envctl_engine.state.lookup import call_state_loader from envctl_engine.state.models import RunState from envctl_engine.startup.run_reuse_identity import ( + ProjectIdentity, _auto_resume_start_enabled, _identity_keys, _root_mismatches, @@ -115,7 +116,7 @@ def _evaluate_candidate( self, *, candidate: RunState, - selected_identities: list[object], + selected_identities: list[ProjectIdentity], selected_payload: list[dict[str, str | None]], startup_enabled: bool, ) -> RunReuseDecision: @@ -218,7 +219,11 @@ def _initial_candidate_rejection( ) return None - def _startup_identity_mismatch(self, candidate: RunState, state_identities: list[object]) -> dict[str, object]: + def _startup_identity_mismatch( + self, + candidate: RunState, + state_identities: list[ProjectIdentity], + ) -> dict[str, object]: previous_identity = candidate.metadata.get("startup_identity") if not isinstance(previous_identity, dict): return {} @@ -335,8 +340,8 @@ def mark_run_reused(metadata: Mapping[str, object] | None, *, reason: str) -> di updated = dict(metadata or {}) raw_count = updated.get("run_reuse_count", 0) try: - count = int(raw_count) - except (TypeError, ValueError): + count = int(raw_count) if isinstance(raw_count, (bool, float, int, str)) else 0 + except (OverflowError, TypeError, ValueError): count = 0 updated["run_reuse_count"] = max(0, count) + 1 updated["last_reopened_at"] = datetime.now(tz=UTC).isoformat() diff --git a/python/envctl_engine/startup/run_reuse_fresh_start.py b/python/envctl_engine/startup/run_reuse_fresh_start.py index 6f395c571..0f91949cf 100644 --- a/python/envctl_engine/startup/run_reuse_fresh_start.py +++ b/python/envctl_engine/startup/run_reuse_fresh_start.py @@ -163,6 +163,43 @@ def replace(self) -> None: }, self.candidate_state, ) + self._rebind_replacement_ports(selected_services) + + def _rebind_replacement_ports(self, selected_services: set[str]) -> None: + port_planner = getattr(self.runtime, "port_planner", None) + release = getattr(port_planner, "release", None) + if not callable(release): + return + contexts = { + str(getattr(context, "name", "")).casefold(): context + for context in getattr(self.session, "selected_contexts", []) + } + for name in sorted(selected_services): + service = getattr(self.candidate_state, "services", {}).get(name) + if service is None or not bool(getattr(service, "listener_expected", True)): + continue + project = service_project_name(service) or self.runtime._project_name_from_service(name) + service_type = service_slug_from_record(service) + context = contexts.get(str(project).casefold()) + plans = getattr(context, "ports", {}) if context is not None else {} + plan = plans.get(service_type) if service_type else None + old_port = getattr(service, "actual_port", None) or getattr(service, "requested_port", None) + current_port = getattr(plan, "final", None) + if plan is None or not isinstance(old_port, int) or old_port <= 0: + continue + owner = f"{getattr(context, 'name', project)}:{service_type}" + if isinstance(current_port, int) and current_port > 0: + release(current_port, owner=owner) + plan.assigned = old_port + plan.final = old_port + plan.source = "fresh_start_replacement" + self.runtime._emit( + "port.rebound.after_fresh_start_cleanup", + project=project, + service=service_type, + previous_port=old_port, + port=old_port, + ) def replace_existing_project_services_for_fresh_start( diff --git a/python/envctl_engine/startup/run_reuse_identity.py b/python/envctl_engine/startup/run_reuse_identity.py index c26f5a8db..41d837485 100644 --- a/python/envctl_engine/startup/run_reuse_identity.py +++ b/python/envctl_engine/startup/run_reuse_identity.py @@ -77,7 +77,9 @@ def _startup_identity_mismatch(previous: Mapping[str, object], current: Mapping[ def _startup_identity_comparison_payload(identity: Mapping[str, object]) -> dict[str, object]: - return {str(key): value for key, value in identity.items() if str(key) != "fingerprint"} + payload = {str(key): value for key, value in identity.items() if str(key) != "fingerprint"} + payload.setdefault("application_runtime", "process") + return payload def project_identities_from_contexts(contexts: list[object]) -> list[ProjectIdentity]: @@ -178,6 +180,12 @@ def _startup_identity_payload( } payload = { "mode": runtime_mode, + "application_runtime": ( + "docker" + if bool(route is not None and route.flags.get("docker")) + or str(getattr(runtime, "env", {}).get("DOCKER_MODE", "")).strip().lower() == "true" + else "process" + ), "projects": identities_to_payload(project_identities_from_contexts(project_contexts)), "startup_enabled": startup_enabled, "services": services, diff --git a/python/envctl_engine/startup/run_reuse_resume.py b/python/envctl_engine/startup/run_reuse_resume.py index 248ee463b..3790ba759 100644 --- a/python/envctl_engine/startup/run_reuse_resume.py +++ b/python/envctl_engine/startup/run_reuse_resume.py @@ -5,6 +5,7 @@ from typing import Any, cast from envctl_engine.runtime.command_router import Route +from envctl_engine.runtime.docker_service_runtime import state_uses_docker_services from envctl_engine.runtime.engine_runtime_startup_support import mark_run_reused from envctl_engine.runtime.lifecycle_operation_lease import ( lifecycle_operation_active, @@ -131,6 +132,9 @@ def _resume_route(self) -> Route: } if self._attach_plan_agent_after_resume(): resume_flags["batch"] = True + if state_uses_docker_services(self.candidate_state): + resume_flags["docker"] = True + self.runtime.env["DOCKER_MODE"] = "true" return Route( command="resume", mode=self.runtime_mode, diff --git a/python/envctl_engine/startup/service_attach_execution.py b/python/envctl_engine/startup/service_attach_execution.py index c0e51fc24..5e24e1a2f 100644 --- a/python/envctl_engine/startup/service_attach_execution.py +++ b/python/envctl_engine/startup/service_attach_execution.py @@ -6,6 +6,12 @@ import time from typing import Any, cast +from envctl_engine.runtime.docker_service_runtime import ( + DockerServiceLaunch, + DockerServiceRuntime, + docker_service_container_command_source, + docker_service_mode_enabled, +) from envctl_engine.runtime.service_manager import ServiceCleanupError, ServiceStartDescriptor from envctl_engine.runtime.service_truth_diagnostics import service_listener_failure_class from envctl_engine.shared.reason_codes import ServiceFailureReason @@ -38,6 +44,9 @@ class ServiceAttachRunner: rebound_delta: int _active_service_ports: dict[str, int] = field(default_factory=dict, init=False, repr=False) _rebound_launch_ports: dict[str, int] = field(default_factory=dict, init=False, repr=False) + docker_mode: bool = False + refresh_cache: bool = False + _container_launches: dict[str, DockerServiceLaunch] = field(default_factory=dict, init=False, repr=False) def start( self, @@ -83,11 +92,19 @@ def release_failed_port_then_report( ) else: raise RuntimeError("Service manager does not support additional app services") + self._annotate_container_records(records) self._record_port_lock_session(records.values()) return records except Exception as exc: + container_cleanup_error: Exception | None = None + try: + self._cleanup_container_launches() + except Exception as cleanup_exc: # noqa: BLE001 + container_cleanup_error = cleanup_exc self._record_port_lock_session(dict(getattr(exc, "unterminated_services", {}) or {}).values()) self._release_failed_start_reservations(exc) + if container_cleanup_error is not None: + raise RuntimeError(f"{exc}; Docker cleanup error: {container_cleanup_error}") from exc raise def _record_port_lock_session(self, services: Iterable[object]) -> None: @@ -207,6 +224,7 @@ def _start_core_services_with_legacy_attach( def _service_descriptors(self) -> list[ServiceStartDescriptor]: descriptors: list[ServiceStartDescriptor] = [] + pid_required = not self._docker_mode_enabled() if "backend" in self.selected_service_types: descriptors.append( ServiceStartDescriptor( @@ -217,6 +235,7 @@ def _service_descriptors(self) -> list[ServiceStartDescriptor]: detect_actual=self.detect_backend_actual, listener_expected=self.backend_listener_expected, log_path=self.backend_log_path, + pid_required=pid_required, ) ) if "frontend" in self.selected_service_types: @@ -229,6 +248,7 @@ def _service_descriptors(self) -> list[ServiceStartDescriptor]: detect_actual=self.detect_frontend_actual, listener_expected=True, log_path=self.frontend_log_path, + pid_required=pid_required, ) ) for service in sorted(self.additional_services, key=lambda item: (item.start_order, item.name)): @@ -247,6 +267,7 @@ def _service_descriptors(self) -> list[ServiceStartDescriptor]: log_path=launch.log_path, public_url=launch.env.get(f"ENVCTL_SOURCE_SERVICE_{service.env_suffix}_PUBLIC_URL"), health_url=launch.env.get(f"ENVCTL_SOURCE_SERVICE_{service.env_suffix}_HEALTH_URL"), + pid_required=pid_required, ) ) return descriptors @@ -295,27 +316,65 @@ def _launch_prepared_process( env_extra: dict[str, str], ) -> tuple[bool, str | None, int | None]: launch_started = time.monotonic() + service_env = self.command_env_builder(port=launch_port, extra=env_extra) + if self._docker_mode_enabled(): + try: + container_launch = DockerServiceRuntime( + self.runtime, + self.process_runtime, + refresh_cache=self.refresh_cache, + ).launch( + project_name=self.project_name, + project_root=self.project_root, + service_name=service_name, + cwd=launch.cwd, + command=command, + env=service_env, + host_port=event_port, + container_port=launch_port, + listener_expected=launch.listener_expected, + log_path=launch.log_path, + ) + except (OSError, RuntimeError) as exc: + self._emit_attach_phase(service_name, "container_launch", launch_started) + detail = str(exc) + self.runtime._emit( + "service.failure", + project=self.project_name, + service=service_name, + failure_class="container_start_failed", + requested_port=event_port, + detail=detail, + ) + return False, detail, None + self._container_launches[service_name] = container_launch + process_pid = None + phase = "container_launch" + else: + try: + process = self._start_process( + command, + cwd=str(launch.cwd), + env=service_env, + log_path=launch.log_path, + ) + except OSError as exc: + executable = command[0] if command else "" + detail = f"process spawn failed for {executable}: {exc}" + self.runtime._emit( + "service.failure", + project=self.project_name, + service=service_name, + failure_class=ServiceFailureReason.PROCESS_SPAWN_FAILED.value, + requested_port=event_port, + detail=detail, + ) + return False, detail, None + pid = getattr(process, "pid", None) + process_pid = pid if isinstance(pid, int) and pid > 0 else None + phase = "process_launch" try: - process = self._start_process( - command, - cwd=str(launch.cwd), - env=self.command_env_builder(port=launch_port, extra=env_extra), - log_path=launch.log_path, - ) - except OSError as exc: - detail = f"process spawn failed for {command[0]}: {exc}" - self.runtime._emit( - "service.failure", - project=self.project_name, - service=service_name, - failure_class=ServiceFailureReason.PROCESS_SPAWN_FAILED.value, - requested_port=event_port, - detail=detail, - ) - return False, detail, None - pid = getattr(process, "pid", None) - try: - self._emit_attach_phase(service_name, "process_launch", launch_started) + self._emit_attach_phase(service_name, phase, launch_started) self.runtime._emit( "service.start", project=self.project_name, @@ -325,18 +384,80 @@ def _launch_prepared_process( ) except Exception: # noqa: BLE001 pass - return True, None, pid if isinstance(pid, int) and pid > 0 else None + return True, None, process_pid + + def _container_actual_port( + self, + service_name: str, + requested: int, + *, + listener_expected: bool = True, + ) -> int | None: + launch = self._container_launches.get(service_name) + if launch is None: + return None + ready = DockerServiceRuntime(self.runtime, self.process_runtime).wait_until_ready( + launch, + port=requested, + listener_expected=listener_expected, + ) + if ready: + return requested if listener_expected else None + detail = f"container {launch.container_name} exited or did not become ready" + cleanup_detail = self._remove_failed_container_launch(service_name, launch) + if cleanup_detail: + detail = f"{detail}; {cleanup_detail}" + self.runtime._emit( + "service.failure", + project=self.project_name, + service=service_name, + failure_class="container_not_ready", + requested_port=requested if listener_expected else None, + detail=detail, + ) + raise RuntimeError(detail) + + def _remove_failed_container_launch( + self, + service_name: str, + launch: DockerServiceLaunch, + ) -> str | None: + try: + removed = DockerServiceRuntime(self.runtime, self.process_runtime).stop(launch.container_id) + except Exception as exc: # noqa: BLE001 - preserve the launch in state for a later stop retry + return f"failed to remove container: {exc}" + if not removed: + return "failed to remove container" + if self._container_launches.get(service_name) == launch: + self._container_launches.pop(service_name, None) + return None + + def _docker_mode_enabled(self) -> bool: + return self.docker_mode or docker_service_mode_enabled(self.runtime) + + def _annotate_container_records(self, records: dict[str, ServiceRecord]) -> None: + for record in records.values(): + service_name = str(record.service_slug or record.type) + launch = self._container_launches.get(service_name) + if launch is None: + continue + record.runtime_kind = "docker" + record.container_id = launch.container_id + record.container_name = launch.container_name + record.container_image = launch.image + + def _cleanup_container_launches(self) -> None: + docker_runtime = DockerServiceRuntime(self.runtime, self.process_runtime) + for launch in tuple(self._container_launches.values()): + docker_runtime.stop(launch.container_id) + self._container_launches.clear() def start_backend(self, port: int) -> tuple[bool, str | None, int | None]: conflict_result = self._conflicting_start_result("backend", port) if conflict_result is not None: return conflict_result command_resolve_started = time.monotonic() - command, _resolved_source = self.runtime._service_start_command_resolved( - service_name="backend", - project_root=self.project_root, - port=port, - ) + command = self._core_service_command("backend", port) self._emit_attach_phase("backend", "command_resolution", command_resolve_started) return self._launch_prepared_process( service_name="backend", @@ -360,11 +481,7 @@ def start_frontend(self, port: int) -> tuple[bool, str | None, int | None]: self._rebound_launch_ports["frontend"] = launch_port try: command_resolve_started = time.monotonic() - command, _resolved_source = self.runtime._service_start_command_resolved( - service_name="frontend", - project_root=self.project_root, - port=launch_port, - ) + command = self._core_service_command("frontend", launch_port) self._emit_attach_phase("frontend", "command_resolution", command_resolve_started) result = self._launch_prepared_process( service_name="frontend", @@ -381,6 +498,21 @@ def start_frontend(self, port: int) -> tuple[bool, str | None, int | None]: self._release_rebound_launch_port("frontend") return result + def _core_service_command(self, service_name: str, port: int) -> list[str]: + container_command_source = docker_service_container_command_source( + self.runtime, + service_name, + docker_mode=self._docker_mode_enabled(), + ) + if container_command_source is not None: + return [] + command, _resolved_source = self.runtime._service_start_command_resolved( + service_name=service_name, + project_root=self.project_root, + port=port, + ) + return command + def start_additional_service(self, service_name: str, port: int) -> tuple[bool, str | None, int | None]: conflict_result = self._conflicting_start_result(service_name, port) if conflict_result is not None: @@ -390,16 +522,23 @@ def start_additional_service(self, service_name: str, port: int) -> tuple[bool, if service is None: return False, f"unknown additional service {service_name}", None command_resolve_started = time.monotonic() - command = self.runtime._split_command( - service.start_cmd, - port=port, - replacements={ - "project_root": str(self.project_root), - "service_dir": str(launch.cwd), - "service_name": service_name, - }, - cwd=launch.cwd, - ) + if docker_service_container_command_source( + self.runtime, + service_name, + docker_mode=self._docker_mode_enabled(), + ) is not None: + command = [] + else: + command = self.runtime._split_command( + service.start_cmd, + port=port, + replacements={ + "project_root": str(self.project_root), + "service_dir": str(launch.cwd), + "service_name": service_name, + }, + cwd=launch.cwd, + ) self._emit_attach_phase(service_name, "command_resolution", command_resolve_started) return self._launch_prepared_process( service_name=service_name, @@ -411,6 +550,12 @@ def start_additional_service(self, service_name: str, port: int) -> tuple[bool, ) def detect_backend_actual(self, pid: int | None, requested: int) -> int | None: + if "backend" in self._container_launches: + return self._container_actual_port( + "backend", + requested, + listener_expected=self.backend_listener_expected, + ) if not self.backend_listener_expected: self.runtime._emit( "service.bind.skipped", @@ -450,6 +595,9 @@ def detect_backend_actual(self, pid: int | None, requested: int) -> int | None: return actual def detect_frontend_actual(self, pid: int | None, requested: int) -> int | None: + container_actual = self._container_actual_port("frontend", requested) + if "frontend" in self._container_launches: + return container_actual self.runtime._emit( "service.bind.requested", project=self.project_name, @@ -490,6 +638,12 @@ def detect_frontend_actual(self, pid: int | None, requested: int) -> int | None: def detect_additional_actual(self, service_name: str, pid: int | None, requested: int) -> int | None: launch = self.prepared_launches[service_name] + if service_name in self._container_launches: + return self._container_actual_port( + service_name, + requested, + listener_expected=launch.listener_expected, + ) if not launch.listener_expected: self.runtime._emit( "service.bind.skipped", diff --git a/python/envctl_engine/startup/service_project_execution.py b/python/envctl_engine/startup/service_project_execution.py index 5602ed65c..89077ea3f 100644 --- a/python/envctl_engine/startup/service_project_execution.py +++ b/python/envctl_engine/startup/service_project_execution.py @@ -6,6 +6,10 @@ from typing import cast from envctl_engine.runtime.command_resolution import CommandExists, suggest_service_start_command +from envctl_engine.runtime.docker_service_runtime import ( + docker_service_container_command_source, + docker_service_mode_enabled, +) from envctl_engine.runtime.command_router import Route from envctl_engine.runtime.runtime_context import resolve_process_runtime from envctl_engine.startup.startup_selection_support import _restart_service_types_for_project @@ -281,12 +285,18 @@ def project_env_for_service(service_name: str) -> dict[str, str]: reason="all_services_disabled", ) return {} - if route is not None and route.command == "plan" and _no_local_app_system_configured( - rt, - mode=effective_mode, - project_root=context.root, - selected_service_types=selected_service_types, - configured_additional_services=configured_additional_services, + use_docker_services = bool(route is not None and route.flags.get("docker")) or docker_service_mode_enabled(rt) + if ( + route is not None + and route.command == "plan" + and not use_docker_services + and _no_local_app_system_configured( + rt, + mode=effective_mode, + project_root=context.root, + selected_service_types=selected_service_types, + configured_additional_services=configured_additional_services, + ) ): rt._emit( "service.attach.skipped", @@ -320,28 +330,34 @@ def project_env_for_service(service_name: str) -> dict[str, str]: def prepare_backend_runtime() -> float: started = time.monotonic() - rt._prepare_backend_runtime( - context=context, - backend_cwd=backend_cwd, - backend_log_path=backend_log_path, - project_env_base=project_env_internal, - route=route, - backend_env_file=backend_env_file, - backend_env_is_default=backend_env_is_default, - ) + if use_docker_services: + rt._emit("service.prepare.skipped", project=context.name, service="backend", reason="docker_image") + else: + rt._prepare_backend_runtime( + context=context, + backend_cwd=backend_cwd, + backend_log_path=backend_log_path, + project_env_base=project_env_internal, + route=route, + backend_env_file=backend_env_file, + backend_env_is_default=backend_env_is_default, + ) return round((time.monotonic() - started) * 1000.0, 2) def prepare_frontend_runtime() -> float: started = time.monotonic() - rt._prepare_frontend_runtime( - context=context, - frontend_cwd=frontend_cwd, - frontend_log_path=frontend_log_path, - project_env_base=frontend_project_env_base, - frontend_env_file=frontend_env_file, - backend_port=backend_plan.final, - route=route, - ) + if use_docker_services: + rt._emit("service.prepare.skipped", project=context.name, service="frontend", reason="docker_image") + else: + rt._prepare_frontend_runtime( + context=context, + frontend_cwd=frontend_cwd, + frontend_log_path=frontend_log_path, + project_env_base=frontend_project_env_base, + frontend_env_file=frontend_env_file, + backend_port=backend_plan.final, + route=route, + ) return round((time.monotonic() - started) * 1000.0, 2) if prepare_backend and prepare_frontend and prep_parallel: @@ -379,18 +395,30 @@ def prepare_frontend_runtime() -> float: rebound_delta = parse_int(rt.env.get("ENVCTL_TEST_FRONTEND_REBOUND_DELTA"), 0) backend_command_source = None if "backend" in selected_service_types: - backend_command_source = rt._service_command_source( - service_name="backend", - project_root=context.root, - port=backend_plan.final, + backend_command_source = docker_service_container_command_source( + rt, + "backend", + docker_mode=use_docker_services, ) + if backend_command_source is None: + backend_command_source = rt._service_command_source( + service_name="backend", + project_root=context.root, + port=backend_plan.final, + ) frontend_command_source = None if "frontend" in selected_service_types: - frontend_command_source = rt._service_command_source( - service_name="frontend", - project_root=context.root, - port=(frontend_plan.final + rebound_delta if rebound_delta > 0 else frontend_plan.final), + frontend_command_source = docker_service_container_command_source( + rt, + "frontend", + docker_mode=use_docker_services, ) + if frontend_command_source is None: + frontend_command_source = rt._service_command_source( + service_name="frontend", + project_root=context.root, + port=(frontend_plan.final + rebound_delta if rebound_delta > 0 else frontend_plan.final), + ) prepared_launches: dict[str, PreparedServiceLaunch] = {} command_env_builder = resolve_command_env_builder(rt) @@ -501,6 +529,8 @@ def prepare_frontend_runtime() -> float: additional_services=tuple(additional_services), backend_listener_expected=backend_listener_expected, rebound_delta=rebound_delta, + docker_mode=use_docker_services, + refresh_cache=bool(route is not None and route.flags.get("refresh_cache")), ).start(attach_parallel=attach_parallel, on_service_retry=on_service_retry) attach_duration_ms = round((time.monotonic() - attach_started) * 1000.0, 2) diff --git a/python/envctl_engine/startup/startup_selection_support.py b/python/envctl_engine/startup/startup_selection_support.py index d08ace792..1f9ba6f06 100644 --- a/python/envctl_engine/startup/startup_selection_support.py +++ b/python/envctl_engine/startup/startup_selection_support.py @@ -478,6 +478,13 @@ def _apply_startup_service_launch_flags(service_types: set[str], *, route: Route if route.flags.get("launch_backend") is False and route.flags.get("launch_frontend") is False: return set() selected = set(service_types) + if "launch_backend" in route.flags or "launch_frontend" in route.flags: + explicitly_selected: set[str] = set() + if route.flags.get("launch_backend") is True: + explicitly_selected.add("backend") + if route.flags.get("launch_frontend") is True: + explicitly_selected.add("frontend") + return selected.intersection(explicitly_selected) if route.flags.get("launch_backend") is False: selected.discard("backend") if route.flags.get("launch_frontend") is False: diff --git a/python/envctl_engine/state/__init__.py b/python/envctl_engine/state/__init__.py index 5a70281c1..23e9f890c 100644 --- a/python/envctl_engine/state/__init__.py +++ b/python/envctl_engine/state/__init__.py @@ -48,6 +48,10 @@ def load_state(path: str, *, allowed_root: str | None = None) -> RunState: failure_detail=str(svc.get("failure_detail") or "") or None, critical=parse_bool(svc.get("critical"), True), degraded=parse_bool(svc.get("degraded"), False), + runtime_kind=str(svc.get("runtime_kind") or "process"), + container_id=str(svc.get("container_id") or "") or None, + container_name=str(svc.get("container_name") or "") or None, + container_image=str(svc.get("container_image") or "") or None, ) for name, svc in data.get("services", {}).items() } @@ -188,6 +192,10 @@ def state_to_dict(state: RunState) -> dict[str, object]: "failure_detail": svc.failure_detail, "critical": svc.critical, "degraded": svc.degraded, + "runtime_kind": svc.runtime_kind, + "container_id": svc.container_id, + "container_name": svc.container_name, + "container_image": svc.container_image, } for name, svc in state.services.items() }, diff --git a/python/envctl_engine/state/action_command_support.py b/python/envctl_engine/state/action_command_support.py index c5e0708d4..690f28570 100644 --- a/python/envctl_engine/state/action_command_support.py +++ b/python/envctl_engine/state/action_command_support.py @@ -2,10 +2,17 @@ from dataclasses import dataclass, field from typing import Any, cast +from contextlib import contextmanager import json +import signal +import threading from envctl_engine.runtime.browser_diagnostics import build_runtime_diagnostics from envctl_engine.runtime.command_router import Route +from envctl_engine.runtime.docker_service_runtime import ( + refresh_container_log_snapshots, + stop_container_log_followers, +) from envctl_engine.shared.parsing import parse_float_or_none, parse_int from envctl_engine.state.action_log_support import DEFAULT_LOG_ISSUE_LIMIT from envctl_engine.state.models import RunState @@ -25,6 +32,26 @@ class StateActionReconciliation: reconciled: bool = False +@contextmanager +def _interrupt_log_follow_on_termination(enabled: bool): + if not enabled or threading.current_thread() is not threading.main_thread(): + yield + return + previous: dict[signal.Signals, Any] = {} + + def interrupt(_signum: int, _frame: object) -> None: + raise KeyboardInterrupt + + for signal_name in (signal.SIGHUP, signal.SIGTERM): + previous[signal_name] = signal.getsignal(signal_name) + signal.signal(signal_name, interrupt) + try: + yield + finally: + for signal_name, handler in previous.items(): + signal.signal(signal_name, handler) + + class StateActionCommandRunner: def __init__(self, orchestrator: Any) -> None: self.orchestrator = orchestrator @@ -200,6 +227,12 @@ def _run_logs(self, route: Route) -> int: if duration_seconds is not None and duration_seconds < 0: duration_seconds = 0.0 no_color = bool(route.flags.get("logs_no_color")) or self.orchestrator._human_output_no_color(route) + follower_pids = refresh_container_log_snapshots( + self.runtime.raw_runtime, + self.state, + tail=max(tail, 0), + follow=follow and not bool(route.flags.get("json")), + ) if bool(route.flags.get("json")): print( json.dumps( @@ -215,13 +248,17 @@ def _run_logs(self, route: Route) -> int: ) ) return self._finish_action(0) - self.runtime.print_logs( - self.state, - tail=max(tail, 0), - follow=follow, - duration_seconds=duration_seconds, - no_color=no_color, - ) + try: + with _interrupt_log_follow_on_termination(bool(follower_pids)): + self.runtime.print_logs( + self.state, + tail=max(tail, 0), + follow=follow, + duration_seconds=duration_seconds, + no_color=no_color, + ) + finally: + stop_container_log_followers(self.runtime.raw_runtime, follower_pids) return self._finish_action(0) def _run_clear_logs(self, route: Route) -> int: @@ -450,6 +487,12 @@ def _run_errors(self, route: Route) -> int: parse_int(str(route.flags.get("logs_tail", DEFAULT_LOG_ISSUE_LIMIT)), DEFAULT_LOG_ISSUE_LIMIT), 0, ) + refresh_container_log_snapshots( + self.runtime.raw_runtime, + self.state, + tail=log_issue_limit, + follow=False, + ) log_issues = self.orchestrator._service_log_issues(self.state, max_matches=log_issue_limit) has_errors = bool(failed or reconciliation.requirement_issues or reconciliation.recent_failures or log_issues) if bool(route.flags.get("json")): diff --git a/python/envctl_engine/state/action_health_support.py b/python/envctl_engine/state/action_health_support.py index d61667e3f..fae8e9f05 100644 --- a/python/envctl_engine/state/action_health_support.py +++ b/python/envctl_engine/state/action_health_support.py @@ -205,6 +205,10 @@ def _service_row(service: ServiceRecord) -> dict[str, object]: "failure_detail": getattr(service, "failure_detail", None), "critical": getattr(service, "critical", True), "degraded": getattr(service, "degraded", False), + "runtime_kind": getattr(service, "runtime_kind", "process"), + "container_id": getattr(service, "container_id", None), + "container_name": getattr(service, "container_name", None), + "container_image": getattr(service, "container_image", None), } rows = self._parallel_service_map( diff --git a/python/envctl_engine/state/action_log_support.py b/python/envctl_engine/state/action_log_support.py index 851e6646e..64d8f6fc7 100644 --- a/python/envctl_engine/state/action_log_support.py +++ b/python/envctl_engine/state/action_log_support.py @@ -204,7 +204,34 @@ def clear_one(service: ServiceRecord) -> tuple[int, int, int, int, str | None]: if not raw_path: return 0, 0, 1, 0, (None if quiet else f"{service.name}: log=n/a") log_path = Path(raw_path) + is_docker = str(getattr(service, "runtime_kind", "process") or "process").lower() == "docker" if not log_path.is_file(): + if is_docker: + try: + Path(f"{log_path}.docker-since").touch() + line = f"{service.name}: Docker log cursor advanced at {log_path}" + return 1, 0, 0, 0, ( + None + if quiet + else render_paths_in_terminal_text( + line, + paths=[log_path], + env=env, + interactive_tty=interactive_tty, + ) + ) + except OSError as exc: + line = f"{service.name}: failed to clear Docker logs at {log_path} ({exc})" + return 0, 0, 0, 1, ( + None + if quiet + else render_paths_in_terminal_text( + line, + paths=[log_path], + env=env, + interactive_tty=interactive_tty, + ) + ) line = f"{service.name}: log missing at {log_path}" return 0, 1, 0, 0, ( None @@ -219,6 +246,8 @@ def clear_one(service: ServiceRecord) -> tuple[int, int, int, int, str | None]: try: with log_path.open("w", encoding="utf-8"): pass + if is_docker: + Path(f"{log_path}.docker-since").touch() line = f"{service.name}: log cleared at {log_path}" return 1, 0, 0, 0, ( None diff --git a/python/envctl_engine/state/action_orchestrator.py b/python/envctl_engine/state/action_orchestrator.py index a0989e80c..1c65e2753 100644 --- a/python/envctl_engine/state/action_orchestrator.py +++ b/python/envctl_engine/state/action_orchestrator.py @@ -216,24 +216,31 @@ def _resolve_selected_services(self, route: Route, state: RunState) -> set[str] services_flag = route.flags.get("services") project_filters = {name.lower() for name in route.projects} project_filters.update(self.runtime.selectors_from_passthrough(route.passthrough_args)) - selected: set[str] = set() + service_selected: set[str] | None = None + project_selected: set[str] | None = None if isinstance(services_flag, list): + service_selected = set() for raw in services_flag: target = str(raw).strip() if not target: continue for name, service in state.services.items(): if service_matches_selector(service, target): - selected.add(name) + service_selected.add(name) if project_filters: + project_selected = set() for name in state.services: project = self.runtime.project_name_from_service(name).lower() if project and project in project_filters: - selected.add(name) - - if selected: - return selected + project_selected.add(name) + + if service_selected is not None and project_selected is not None: + return service_selected.intersection(project_selected) + if service_selected is not None: + return service_selected + if project_selected is not None: + return project_selected if project_filters or (isinstance(services_flag, list) and services_flag): return set() return None diff --git a/python/envctl_engine/state/models.py b/python/envctl_engine/state/models.py index 68bb3c4fd..68f045a7e 100644 --- a/python/envctl_engine/state/models.py +++ b/python/envctl_engine/state/models.py @@ -38,6 +38,10 @@ class ServiceRecord: failure_detail: str | None = None critical: bool = True degraded: bool = False + runtime_kind: str = "process" + container_id: str | None = None + container_name: str | None = None + container_image: str | None = None @dataclass(slots=True) diff --git a/python/envctl_engine/state/runtime_map.py b/python/envctl_engine/state/runtime_map.py index a3eac6dad..218974297 100644 --- a/python/envctl_engine/state/runtime_map.py +++ b/python/envctl_engine/state/runtime_map.py @@ -86,6 +86,10 @@ def build_runtime_map_without_projection(state: RunState, *, host: str = "localh "failure_detail": getattr(service, "failure_detail", None), "critical": getattr(service, "critical", True), "degraded": getattr(service, "degraded", False), + "runtime_kind": getattr(service, "runtime_kind", "process"), + "container_id": getattr(service, "container_id", None), + "container_name": getattr(service, "container_name", None), + "container_image": getattr(service, "container_image", None), } if service.type == "backend": project_entry["backend_port"] = port diff --git a/python/envctl_engine/ui/dashboard/pr_selection_support.py b/python/envctl_engine/ui/dashboard/pr_selection_support.py index cc6fa4c45..85cfad303 100644 --- a/python/envctl_engine/ui/dashboard/pr_selection_support.py +++ b/python/envctl_engine/ui/dashboard/pr_selection_support.py @@ -4,7 +4,7 @@ import subprocess from typing import Any, Callable, cast -from envctl_engine.actions.project_action_domain import detect_default_branch +from envctl_engine.actions.action_git_state_support import detect_pr_base_branch from envctl_engine.runtime.command_router import Route from envctl_engine.state.models import RunState from envctl_engine.ui.dashboard.pr_flow import run_pr_flow @@ -12,6 +12,20 @@ from envctl_engine.ui.selector_model import SelectorItem +def _dashboard_git_output(git_root: Path, args: list[str]) -> str: + result = subprocess.run( + ["git", "-C", str(git_root), *args], + text=True, + capture_output=True, + check=False, + ) + return result.stdout if result.returncode == 0 else "" + + +def _detect_pr_base_branch(git_root: Path) -> str: + return detect_pr_base_branch(git_root, git_output=_dashboard_git_output) + + def apply_pr_selection(owner: Any, route: Route, state: RunState, rt: object) -> Route | None: runtime_any = cast(Any, rt) default_branch = owner._default_pr_base_branch(runtime_any) @@ -83,7 +97,7 @@ def default_pr_base_branch( owner: Any, runtime: Any, *, - detect_default_branch_fn: Callable[[Path], str] = detect_default_branch, + detect_default_branch_fn: Callable[[Path], str] = _detect_pr_base_branch, pr_git_root_fn: Callable[[Any, Any], Path] = pr_git_root, ) -> str: git_root = pr_git_root_fn(owner, runtime) diff --git a/python/envctl_engine/ui/selection_support.py b/python/envctl_engine/ui/selection_support.py index 99ab5f157..b46efe457 100644 --- a/python/envctl_engine/ui/selection_support.py +++ b/python/envctl_engine/ui/selection_support.py @@ -110,9 +110,11 @@ def no_target_selected_message( return f"No {label} target selected." mode = str(route.mode).strip().lower() discovery = "envctl --list-trees --json" if mode == "trees" else "envctl --list-targets --main --json" + all_selector = "--all --yes" if command in {"commit", "migrate", "pr", "ship"} else "--all" return ( f"No {label} target selected. " - f"In headless mode, run '{discovery}' and retry with '--project ', '--service ', or '--all'." + f"In headless mode, run '{discovery}' and retry with '--project ', '--service ', " + f"or '{all_selector}'." ) diff --git a/tests/python/actions/test_action_command_execution_support.py b/tests/python/actions/test_action_command_execution_support.py index b982bfa98..bb8213ad8 100644 --- a/tests/python/actions/test_action_command_execution_support.py +++ b/tests/python/actions/test_action_command_execution_support.py @@ -44,6 +44,7 @@ def __init__(self) -> None: self.statuses: list[str] = [] self.restored = False self.spinner = _Spinner() + self.ship_calls = 0 def resolve_targets(self, _route, *, trees_only: bool) -> tuple[list[object], str | None]: return [SimpleNamespace(name="Main")], None @@ -66,6 +67,10 @@ def restore() -> None: def run_test_action(self, _route, _targets: list[object]) -> int: return 0 + def run_ship_action(self, _route, _targets: list[object]) -> int: + self.ship_calls += 1 + return 0 + class _DeferredOutputOrchestrator(_Orchestrator): def __init__(self) -> None: @@ -136,6 +141,55 @@ def test_execute_action_command_returns_target_resolution_error(self) -> None: orchestrator.runtime.events, ) + def test_execute_action_command_requires_confirmation_for_bulk_mutation(self) -> None: + orchestrator = _Orchestrator() + orchestrator.resolve_targets = lambda _route, trees_only: ( # type: ignore[assignment] + [SimpleNamespace(name="one"), SimpleNamespace(name="two")], + None, + ) + route = SimpleNamespace(command="ship", mode="trees", flags={"all": True}) + + code = execute_action_command( + orchestrator, + route, + spinner_factory=lambda *_args, **_kwargs: _policy_context(orchestrator.spinner), + resolve_spinner_policy_fn=lambda _env: SimpleNamespace(enabled=False), + emit_spinner_policy_fn=lambda *_args, **_kwargs: None, + use_spinner_policy_fn=_policy_context, + ) + + self.assertEqual(code, 1) + self.assertEqual(orchestrator.ship_calls, 0) + self.assertIn( + { + "event": "action.command.finish", + "command": "ship", + "code": 1, + "error": "ship --all targets 2 projects and requires --yes or --force", + }, + orchestrator.runtime.events, + ) + + def test_execute_action_command_allows_confirmed_bulk_mutation(self) -> None: + orchestrator = _Orchestrator() + orchestrator.resolve_targets = lambda _route, trees_only: ( # type: ignore[assignment] + [SimpleNamespace(name="one"), SimpleNamespace(name="two")], + None, + ) + route = SimpleNamespace(command="ship", mode="trees", flags={"all": True, "yes": True}) + + code = execute_action_command( + orchestrator, + route, + spinner_factory=lambda *_args, **_kwargs: _policy_context(orchestrator.spinner), + resolve_spinner_policy_fn=lambda _env: SimpleNamespace(enabled=False), + emit_spinner_policy_fn=lambda *_args, **_kwargs: None, + use_spinner_policy_fn=_policy_context, + ) + + self.assertEqual(code, 0) + self.assertEqual(orchestrator.ship_calls, 1) + def test_execute_action_command_flushes_deferred_output_before_finish(self) -> None: orchestrator = _DeferredOutputOrchestrator() route = SimpleNamespace(command="test", mode="main", flags={}) diff --git a/tests/python/actions/test_action_git_state_support.py b/tests/python/actions/test_action_git_state_support.py index 359253067..91cc6a6d4 100644 --- a/tests/python/actions/test_action_git_state_support.py +++ b/tests/python/actions/test_action_git_state_support.py @@ -104,6 +104,41 @@ def no_preferred_remote(_git_root: Path, args: list[str]) -> str: "feature/alpha", ) + def test_detect_pr_base_branch_uses_preferred_default_branch_contract(self) -> None: + def remote_trunk(_git_root: Path, args: list[str]) -> str: + if args[:3] == ["ls-remote", "--symref", "origin"]: + return "ref: refs/heads/trunk\tHEAD\ntrunk-sha\tHEAD\n" + return "" + + self.assertEqual( + git_state.detect_pr_base_branch(Path("/repo"), git_output=remote_trunk), + "trunk", + ) + + def test_detect_pr_base_branch_does_not_probe_origin_when_local_candidate_exists(self) -> None: + calls: list[list[str]] = [] + + def local_main(_git_root: Path, args: list[str]) -> str: + calls.append(args) + if args == ["rev-parse", "--verify", "refs/remotes/origin/main"]: + return "abc123\n" + if args[0] == "ls-remote": + raise AssertionError("remote must not be probed when a local base ref is available") + return "" + + self.assertEqual( + git_state.detect_pr_base_branch(Path("/repo"), git_output=local_main), + "main", + ) + self.assertEqual( + calls, + [ + ["rev-parse", "--verify", "refs/remotes/origin/dev"], + ["rev-parse", "--verify", "refs/heads/dev"], + ["rev-parse", "--verify", "refs/remotes/origin/main"], + ], + ) + def test_existing_pr_url_uses_gh_pr_list_for_open_branch(self) -> None: calls: list[tuple[list[str], str]] = [] diff --git a/tests/python/actions/test_actions_cli_pr.py b/tests/python/actions/test_actions_cli_pr.py index cf5522e0e..3ceae7fe1 100644 --- a/tests/python/actions/test_actions_cli_pr.py +++ b/tests/python/actions/test_actions_cli_pr.py @@ -32,7 +32,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch( "envctl_engine.actions.project_action_domain.existing_pull_request", @@ -97,7 +97,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.probe_dirty_worktree") as dirty_probe, @@ -148,7 +148,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.probe_dirty_worktree") as dirty_probe, @@ -225,7 +225,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -304,7 +304,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -371,7 +371,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -433,7 +433,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 with ( patch.dict(os.environ, {"ENVCTL_PR_BODY": "Typed PR body\n\nWith details."}, clear=False), - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -497,7 +497,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 patch.dict(os.environ, {"ENVCTL_ACTION_INTERACTIVE": "1"}, clear=False), patch("sys.stdin.isatty", return_value=True), patch("builtins.input", side_effect=AssertionError("input() should not be called for pr action")), - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -555,7 +555,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -604,7 +604,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), @@ -661,7 +661,7 @@ def fake_run(args: list[str], **_kwargs): # noqa: ANN001 return subprocess.CompletedProcess(args=command, returncode=1, stdout="", stderr="unexpected command") with ( - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain.existing_pull_request", return_value=None), patch("envctl_engine.actions.project_action_domain.shutil.which", side_effect=fake_which), diff --git a/tests/python/actions/test_actions_cli_ship.py b/tests/python/actions/test_actions_cli_ship.py index 166a90a6f..4332ec872 100644 --- a/tests/python/actions/test_actions_cli_ship.py +++ b/tests/python/actions/test_actions_cli_ship.py @@ -264,7 +264,7 @@ def fake_run(git_root: Path, args: list[str]): # noqa: ANN001 with ( patch("envctl_engine.actions.project_action_domain.shutil.which", return_value="/usr/bin/git"), - patch("envctl_engine.actions.project_action_domain.detect_default_branch", return_value="main"), + patch("envctl_engine.actions.project_action_domain.git_state_support.detect_pr_base_branch", return_value="main"), patch("envctl_engine.actions.project_action_domain._git_output", side_effect=fake_git_output), patch("envctl_engine.actions.project_action_domain._run_git", side_effect=fake_run), patch("envctl_engine.actions.project_action_domain.run_commit_action", return_value=0) as commit_action, diff --git a/tests/python/actions/test_actions_migrate_parity.py b/tests/python/actions/test_actions_migrate_parity.py index 84bc451e6..b2217f6b3 100644 --- a/tests/python/actions/test_actions_migrate_parity.py +++ b/tests/python/actions/test_actions_migrate_parity.py @@ -546,7 +546,7 @@ def test_migrate_action_uses_distinct_env_contracts_for_each_target_in_multi_tar fake_runner = _FakeRunner(returncode=0) engine.process_runner = fake_runner # type: ignore[assignment] - route = parse_route(["migrate", "--all"], env={"ENVCTL_DEFAULT_MODE": "trees"}) + route = parse_route(["migrate", "--all", "--yes"], env={"ENVCTL_DEFAULT_MODE": "trees"}) code = engine.dispatch(route) self.assertEqual(code, 0) @@ -567,4 +567,3 @@ def test_migrate_action_uses_distinct_env_contracts_for_each_target_in_multi_tar ) self.assertEqual(first_env.get("SQLALCHEMY_DATABASE_URL"), first_env.get("DATABASE_URL")) self.assertEqual(second_env.get("SQLALCHEMY_DATABASE_URL"), second_env.get("DATABASE_URL")) - diff --git a/tests/python/debug/test_debug_utils_file_lock.py b/tests/python/debug/test_debug_utils_file_lock.py new file mode 100644 index 000000000..46cb5a970 --- /dev/null +++ b/tests/python/debug/test_debug_utils_file_lock.py @@ -0,0 +1,14 @@ +from __future__ import annotations + +from pathlib import Path + +from envctl_engine.debug.debug_utils import file_lock + + +def test_file_lock_keeps_stable_inode_after_release(tmp_path: Path) -> None: + lock_path = tmp_path / "stable.lock" + + with file_lock(lock_path, timeout=1.0): + inode = lock_path.stat().st_ino + + assert lock_path.stat().st_ino == inode diff --git a/tests/python/runtime/test_docker_service_runtime.py b/tests/python/runtime/test_docker_service_runtime.py new file mode 100644 index 000000000..84ed397aa --- /dev/null +++ b/tests/python/runtime/test_docker_service_runtime.py @@ -0,0 +1,402 @@ +from __future__ import annotations + +import json +from pathlib import Path +from types import SimpleNamespace + +from envctl_engine.runtime.docker_service_runtime import ( + DockerServiceRuntime, + docker_service_container_name, + refresh_container_log_snapshots, + stop_container_log_followers, +) +from envctl_engine.runtime.lifecycle_service_termination import terminate_service_record +from envctl_engine.runtime.service_status_truth import service_truth_status +from envctl_engine.state.models import ServiceRecord + + +class _Runner: + def __init__(self) -> None: + self.calls: list[list[str]] = [] + self.env_file_payload = "" + self.running = True + self.port_ready = True + self.terminated: list[int] = [] + self.build_env: dict[str, str] = {} + self.existing_container: tuple[bool, str] | None = None + self.local_images: set[str] = set() + self.remote_exposed_ports: dict[str, dict[str, object]] = {} + + def run(self, command, **_kwargs): + argv = [str(part) for part in command] + self.calls.append(argv) + if argv[:2] == ["docker", "build"]: + self.build_env = dict(_kwargs.get("env", {})) + self.local_images.add(argv[argv.index("--tag") + 1]) + if argv[:2] == ["docker", "run"]: + env_file = Path(argv[argv.index("--env-file") + 1]) + self.env_file_payload = env_file.read_text(encoding="utf-8") + return SimpleNamespace(returncode=0, stdout="container-id\n", stderr="") + if argv[:3] == ["docker", "container", "inspect"]: + if self.existing_container is None: + return SimpleNamespace(returncode=1, stdout="", stderr="No such container") + running, owner = self.existing_container + format_value = argv[argv.index("--format") + 1] + if ".State.Running" not in format_value: + return SimpleNamespace(returncode=0, stdout=f"{owner}\n", stderr="") + return SimpleNamespace(returncode=0, stdout=f"{str(running).lower()}|{owner}\n", stderr="") + if argv[:3] == ["docker", "inspect", "--format"]: + return SimpleNamespace(returncode=0 if self.running else 1, stdout="true\n" if self.running else "", stderr="") + if argv[:3] == ["docker", "image", "inspect"]: + image = argv[-1] + if image not in self.local_images: + return SimpleNamespace(returncode=1, stdout="", stderr="missing") + if "--format" in argv: + payload = self.remote_exposed_ports.get(image, {}) + return SimpleNamespace(returncode=0, stdout=json.dumps(payload) + "\n", stderr="") + return SimpleNamespace(returncode=0, stdout="[]\n", stderr="") + if argv[:2] == ["docker", "pull"]: + self.local_images.add(argv[-1]) + return SimpleNamespace(returncode=0, stdout="pulled\n", stderr="") + if argv[:3] == ["docker", "rm", "--force"]: + return SimpleNamespace(returncode=0, stdout="", stderr="") + if argv[:2] == ["docker", "logs"]: + return SimpleNamespace(returncode=0, stdout="container log\n", stderr="") + return SimpleNamespace(returncode=0, stdout="ok\n", stderr="") + + def start_background(self, command, **_kwargs): + self.calls.append([str(part) for part in command]) + return SimpleNamespace(pid=4321) + + def wait_for_port(self, _port, **_kwargs): + return self.port_ready + + def terminate_process_group(self, pid, **_kwargs): + self.terminated.append(pid) + return True + + +def _runtime(tmp_path: Path, runner: _Runner, *, env: dict[str, str] | None = None): + events: list[tuple[str, dict[str, object]]] = [] + runtime = SimpleNamespace( + env={"DOCKER_MODE": "true", **(env or {})}, + config=SimpleNamespace(raw={}, runtime_scope_dir=tmp_path / "runtime-scope"), + process_runner=runner, + _command_exists=lambda command: command == "docker", + _run_dir_path=lambda run_id: tmp_path / "runs" / str(run_id), + _emit=lambda event, **payload: events.append((event, payload)), + _service_truth_timeout=lambda: 0.01, + ) + return runtime, events + + +def test_container_names_preserve_root_identity_for_long_project_names(tmp_path: Path) -> None: + first = docker_service_container_name( + project_name="feature-" + ("very-long-name-" * 8), + project_root=tmp_path / "one", + service_name="backend", + ) + second = docker_service_container_name( + project_name="feature-" + ("very-long-name-" * 8), + project_root=tmp_path / "two", + service_name="backend", + ) + + assert len(first) <= 63 + assert len(second) <= 63 + assert first != second + + +def test_builds_with_docker_layer_cache_and_runs_managed_container(tmp_path: Path) -> None: + runner = _Runner() + runtime, events = _runtime(tmp_path, runner, env={"ENVCTL_BACKEND_DOCKER_COMMAND_MODE": "service"}) + service_root = tmp_path / "backend" + service_root.mkdir() + (service_root / "Dockerfile").write_text("FROM python:3.12-slim\nWORKDIR /app\n", encoding="utf-8") + + launch = DockerServiceRuntime(runtime, runner).launch( + project_name="Feature One", + project_root=tmp_path, + service_name="backend", + cwd=service_root, + command=["python", "-m", "uvicorn", "app:api", "--host", "127.0.0.1", "--port", "8123"], + env={ + "PATH": "/host/bin", + "DATABASE_URL": "postgres://u:p@127.0.0.1:5432/db", + "PORT": "8123", + "VITE_API_URL": "http://localhost:8123/api/v1", + }, + host_port=8123, + container_port=8123, + listener_expected=True, + log_path=str(tmp_path / "backend.log"), + ) + + build_index = next(index for index, call in enumerate(runner.calls) if call[:2] == ["docker", "build"]) + run_index = next(index for index, call in enumerate(runner.calls) if call[:2] == ["docker", "run"]) + assert build_index < run_index + docker_build = runner.calls[build_index] + assert docker_build[docker_build.index("--build-arg") + 1] == "VITE_API_URL" + assert "http://localhost:8123/api/v1" not in docker_build + assert runner.build_env["VITE_API_URL"] == "http://localhost:8123/api/v1" + docker_run = runner.calls[run_index] + publish_index = docker_run.index("--publish") + assert docker_run[publish_index : publish_index + 2] == ["--publish", "127.0.0.1:8123:8123"] + assert "0.0.0.0" in docker_run + runtime_label_index = docker_run.index("io.envctl.service=backend") + 2 + assert docker_run[runtime_label_index].startswith("io.envctl.runtime-scope=") + assert "PATH=" not in runner.env_file_payload + assert "DATABASE_URL=postgres://u:p@host.docker.internal:5432/db" in runner.env_file_payload + assert launch.container_id == "container-id" + assert any(event == "service.container.build" and payload["cache"] == "docker_layer_cache" for event, payload in events) + + +def test_running_untracked_container_is_not_replaced_or_removed(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime(tmp_path, runner, env={"ENVCTL_BACKEND_DOCKER_IMAGE": "example/backend:dev"}) + docker_runtime = DockerServiceRuntime(runtime, runner) + runner.existing_container = (True, docker_runtime._runtime_scope_identity()) + + try: + docker_runtime.launch( + project_name="Main", + project_root=tmp_path, + service_name="backend", + cwd=tmp_path, + command=[], + env={}, + host_port=8123, + container_port=8123, + listener_expected=True, + log_path=str(tmp_path / "backend.log"), + ) + except RuntimeError as exc: + assert "already running" in str(exc) + else: + raise AssertionError("expected the untracked running container to block startup") + + assert not any(call[:3] == ["docker", "rm", "--force"] for call in runner.calls) + assert not any(call[:2] == ["docker", "run"] for call in runner.calls) + + +def test_container_owned_by_another_runtime_scope_is_not_replaced(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime(tmp_path, runner, env={"ENVCTL_BACKEND_DOCKER_IMAGE": "example/backend:dev"}) + runner.existing_container = (False, "another-runtime") + + try: + DockerServiceRuntime(runtime, runner).launch( + project_name="Main", + project_root=tmp_path, + service_name="backend", + cwd=tmp_path, + command=[], + env={}, + host_port=8123, + container_port=8123, + listener_expected=True, + log_path=str(tmp_path / "backend.log"), + ) + except RuntimeError as exc: + assert "another envctl runtime scope" in str(exc) + else: + raise AssertionError("expected the foreign runtime scope to block startup") + + assert not any(call[:3] == ["docker", "rm", "--force"] for call in runner.calls) + + +def test_stopped_container_from_same_runtime_scope_is_removed(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime(tmp_path, runner, env={"ENVCTL_BACKEND_DOCKER_IMAGE": "example/backend:dev"}) + docker_runtime = DockerServiceRuntime(runtime, runner) + runner.existing_container = (False, docker_runtime._runtime_scope_identity()) + + docker_runtime.launch( + project_name="Main", + project_root=tmp_path, + service_name="backend", + cwd=tmp_path, + command=[], + env={}, + host_port=8123, + container_port=8123, + listener_expected=True, + log_path=str(tmp_path / "backend.log"), + ) + + inspect_index = next(index for index, call in enumerate(runner.calls) if call[:3] == ["docker", "container", "inspect"]) + remove_index = next(index for index, call in enumerate(runner.calls) if call[:3] == ["docker", "rm", "--force"]) + run_index = next(index for index, call in enumerate(runner.calls) if call[:2] == ["docker", "run"]) + assert inspect_index < remove_index < run_index + + +def test_configured_image_runs_without_build_and_preserves_browser_public_url(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime( + tmp_path, + runner, + env={ + "ENVCTL_FRONTEND_DOCKER_IMAGE": "example/frontend:dev", + "ENVCTL_FRONTEND_DOCKER_COMMAND": "npm run dev -- --host 0.0.0.0 --port 9000", + "ENVCTL_FRONTEND_DOCKER_PORT": "9000", + }, + ) + + launch = DockerServiceRuntime(runtime, runner).launch( + project_name="Main", + project_root=tmp_path, + service_name="frontend", + cwd=tmp_path, + command=["host-only-command"], + env={ + "VITE_API_URL": "http://localhost:8000/api/v1", + "REDIS_URL": "redis://localhost:6379", + "PORT": "9100", + "HOST": "127.0.0.1", + }, + host_port=9100, + container_port=9100, + listener_expected=True, + log_path=str(tmp_path / "frontend.log"), + ) + + assert not any(call[:2] == ["docker", "build"] for call in runner.calls) + docker_run = next(call for call in runner.calls if call[:2] == ["docker", "run"]) + assert "example/frontend:dev" in docker_run + assert "127.0.0.1:9100:9000" in docker_run + assert docker_run[-8:] == ["npm", "run", "dev", "--", "--host", "0.0.0.0", "--port", "9000"] + assert "VITE_API_URL=http://localhost:8000/api/v1" in runner.env_file_payload + assert "REDIS_URL=redis://host.docker.internal:6379" in runner.env_file_payload + assert "PORT=9000" in runner.env_file_payload + assert "HOST=0.0.0.0" in runner.env_file_payload + assert launch.image == "example/frontend:dev" + + +def test_container_env_preserves_browser_contract_urls_and_rewrites_internal_urls(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime( + tmp_path, + runner, + env={"ENVCTL_BACKEND_CORS_ENV_KEY": "ALLOWED_BROWSER_ORIGINS"}, + ) + + projected = DockerServiceRuntime(runtime, runner)._container_env( + { + "FRONTEND_BASE_URL": "http://localhost:5173", + "ENVCTL_SOURCE_FRONTEND_URL": "http://127.0.0.1:5173", + "CORS_ORIGINS_RAW": "http://localhost:5173,http://127.0.0.1:5173", + "ALLOWED_BROWSER_ORIGINS": "http://localhost:5173", + "DATABASE_URL": "postgres://user:pass@localhost:5432/app", + "REDIS_URL": "redis://127.0.0.1:6379/0", + } + ) + + assert projected["FRONTEND_BASE_URL"] == "http://localhost:5173" + assert projected["ENVCTL_SOURCE_FRONTEND_URL"] == "http://127.0.0.1:5173" + assert projected["CORS_ORIGINS_RAW"] == "http://localhost:5173,http://127.0.0.1:5173" + assert projected["ALLOWED_BROWSER_ORIGINS"] == "http://localhost:5173" + assert projected["DATABASE_URL"] == "postgres://user:pass@host.docker.internal:5432/app" + assert projected["REDIS_URL"] == "redis://host.docker.internal:6379/0" + + +def test_remote_image_is_pulled_before_exposed_port_detection(tmp_path: Path) -> None: + runner = _Runner() + image = "example/frontend:remote" + runner.remote_exposed_ports[image] = {"80/tcp": {}} + runtime, _events = _runtime(tmp_path, runner, env={"ENVCTL_FRONTEND_DOCKER_IMAGE": image}) + + DockerServiceRuntime(runtime, runner).launch( + project_name="Main", + project_root=tmp_path, + service_name="frontend", + cwd=tmp_path, + command=[], + env={}, + host_port=9100, + container_port=9100, + listener_expected=True, + log_path=str(tmp_path / "frontend.log"), + ) + + pull_index = runner.calls.index(["docker", "pull", image]) + exposed_inspect_index = next( + index + for index, call in enumerate(runner.calls) + if call[:3] == ["docker", "image", "inspect"] and "--format" in call + ) + run_index = next(index for index, call in enumerate(runner.calls) if call[:2] == ["docker", "run"]) + assert pull_index < exposed_inspect_index < run_index + assert "127.0.0.1:9100:80" in runner.calls[run_index] + + +def test_verified_stop_refuses_container_from_another_runtime_scope(tmp_path: Path) -> None: + runner = _Runner() + runner.existing_container = (True, "another-runtime") + runtime, _events = _runtime(tmp_path, runner) + + stopped = terminate_service_record( + runtime, + ServiceRecord( + name="Main Backend", + type="backend", + cwd=str(tmp_path), + runtime_kind="docker", + container_id="reused-container-id", + ), + aggressive=False, + verify_ownership=True, + ) + + assert not stopped + assert not any(call[:3] == ["docker", "rm", "--force"] for call in runner.calls) + + +def test_container_state_drives_health_and_stop(tmp_path: Path) -> None: + runner = _Runner() + runtime, events = _runtime(tmp_path, runner) + service = ServiceRecord( + name="Main Backend", + type="backend", + cwd=str(tmp_path), + pid=4321, + requested_port=8123, + actual_port=8123, + status="running", + runtime_kind="docker", + container_id="container-id", + container_name="envctl-app-main-backend", + container_image="example/backend:dev", + ) + + assert service_truth_status(runtime, service) == "running" + runner.port_ready = False + assert service_truth_status(runtime, service) == "unreachable" + assert terminate_service_record(runtime, service, aggressive=False, verify_ownership=True) + assert ["docker", "rm", "--force", "container-id"] in runner.calls + assert runner.terminated == [4321] + assert any(event == "service.container.stop" for event, _payload in events) + + +def test_container_logs_are_snapshotted_and_followed_only_on_demand(tmp_path: Path) -> None: + runner = _Runner() + runtime, _events = _runtime(tmp_path, runner) + log_path = tmp_path / "backend.log" + service = ServiceRecord( + name="Main Backend", + type="backend", + cwd=str(tmp_path), + log_path=str(log_path), + runtime_kind="docker", + container_id="container-id", + ) + state = SimpleNamespace(services={service.name: service}) + + assert refresh_container_log_snapshots(runtime, state, tail=20, follow=False) == [] + assert log_path.read_text(encoding="utf-8") == "container log\n" + assert not any(call[:3] == ["docker", "logs", "--follow"] for call in runner.calls) + + followers = refresh_container_log_snapshots(runtime, state, tail=20, follow=True) + assert followers == [4321] + assert any(call[:3] == ["docker", "logs", "--follow"] for call in runner.calls) + stop_container_log_followers(runtime, followers) + assert runner.terminated == [4321] diff --git a/tests/python/runtime/test_engine_runtime_artifacts.py b/tests/python/runtime/test_engine_runtime_artifacts.py index 05c3f32e2..d858f314a 100644 --- a/tests/python/runtime/test_engine_runtime_artifacts.py +++ b/tests/python/runtime/test_engine_runtime_artifacts.py @@ -21,7 +21,7 @@ ) from envctl_engine.runtime.engine_runtime_event_support import persist_events_snapshot # noqa: E402 from envctl_engine.runtime.runtime_readiness import RuntimeReadinessResult # noqa: E402 -from envctl_engine.state.models import PortPlan, RunState # noqa: E402 +from envctl_engine.state.models import PortPlan, RunState, ServiceRecord # noqa: E402 class EngineRuntimeArtifactsTests(unittest.TestCase): @@ -59,6 +59,39 @@ def test_print_summary_includes_project_ports(self) -> None: self.assertIn("envctl Python engine run summary", rendered) self.assertIn("- Main: backend=8000 frontend=9000 db=5432 redis=6379 n8n=5678", rendered) + def test_print_summary_prefers_preserved_service_truth_over_unused_planned_port(self) -> None: + context = SimpleNamespace( + name="Main", + ports={ + name: PortPlan(project="Main", requested=port, assigned=port, final=port, source="fixed") + for name, port in { + "backend": 8001, + "frontend": 9001, + "db": 5432, + "redis": 6379, + "n8n": 5678, + }.items() + }, + ) + state = RunState( + run_id="run-restart", + mode="main", + services={ + "Main Backend": ServiceRecord( + name="Main Backend", type="backend", cwd="/repo/backend", actual_port=8001 + ), + "Main Frontend": ServiceRecord( + name="Main Frontend", type="frontend", cwd="/repo/frontend", actual_port=9000 + ), + }, + ) + + buffer = io.StringIO() + with redirect_stdout(buffer): + print_summary(SimpleNamespace(), state, [context]) + + self.assertIn("- Main: backend=8001 frontend=9000", buffer.getvalue()) + def test_write_artifacts_forwards_expected_state_repository_payload(self) -> None: captured: dict[str, object] = {} diff --git a/tests/python/runtime/test_engine_runtime_commands.py b/tests/python/runtime/test_engine_runtime_commands.py index 81cdd8cf5..0d58043d6 100644 --- a/tests/python/runtime/test_engine_runtime_commands.py +++ b/tests/python/runtime/test_engine_runtime_commands.py @@ -15,11 +15,77 @@ command_env, command_override_value, default_python_executable, + service_start_command_resolved, split_command, ) class EngineRuntimeCommandsTests(unittest.TestCase): + def test_docker_image_command_skips_host_command_resolution(self) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) + runtime = SimpleNamespace( + env={ + "DOCKER_MODE": "true", + "ENVCTL_FRONTEND_DOCKER_IMAGE": "example/frontend:dev", + }, + config=SimpleNamespace( + base_dir=root, + raw={"FRONTEND_DIR": "frontend"}, + ), + _command_exists=lambda _executable: self.fail("host command lookup must be skipped"), + ) + + command, source = service_start_command_resolved( + runtime, + service_name="frontend", + project_root=root, + port=8010, + ) + + self.assertEqual(command, []) + self.assertEqual(source, "docker_image") + + def test_explicit_docker_command_skips_host_command_resolution(self) -> None: + runtime = SimpleNamespace( + env={ + "DOCKER_MODE": "true", + "ENVCTL_BACKEND_DOCKER_COMMAND": "uvicorn app:api --port 8000", + }, + config=SimpleNamespace(base_dir=Path("/repo"), raw={}), + _command_exists=lambda _executable: self.fail("host command lookup must be skipped"), + ) + + command, source = service_start_command_resolved(runtime, service_name="backend", port=8000) + + self.assertEqual(command, []) + self.assertEqual(source, "docker_command") + + def test_docker_service_command_still_requires_executable_on_host(self) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) + (root / "frontend").mkdir() + runtime = SimpleNamespace( + env={ + "DOCKER_MODE": "true", + "ENVCTL_FRONTEND_DOCKER_COMMAND_MODE": "service", + "ENVCTL_FRONTEND_START_CMD": "missing-command --port {port}", + }, + config=SimpleNamespace( + base_dir=root, + raw={"FRONTEND_DIR": "frontend"}, + ), + _command_exists=lambda _executable: False, + ) + + with self.assertRaises(RuntimeError): + service_start_command_resolved( + runtime, + service_name="frontend", + project_root=root, + port=8010, + ) + def test_command_override_value_prefers_runtime_env(self) -> None: runtime = SimpleNamespace( env={"DB_HOST": "env-db"}, diff --git a/tests/python/runtime/test_engine_runtime_startup_support.py b/tests/python/runtime/test_engine_runtime_startup_support.py index 3c808f71a..05a5cb0e9 100644 --- a/tests/python/runtime/test_engine_runtime_startup_support.py +++ b/tests/python/runtime/test_engine_runtime_startup_support.py @@ -372,6 +372,41 @@ def test_run_reuse_rejects_startup_fingerprint_mismatch(self) -> None: self.assertEqual(decision.decision_kind, "fresh_run") self.assertEqual(decision.reason, "startup_fingerprint_mismatch") + def test_explicit_no_resume_retains_candidate_for_safe_replacement(self) -> None: + context = ProjectContext(name="Main", root=Path("/repo"), ports={}) + route = Route( + command="start", + mode="main", + raw_args=["start", "--no-resume"], + passthrough_args=[], + projects=[], + flags={"no_resume": True}, + ) + state = RunState( + run_id="run-existing", + mode="main", + services={ + "Main Backend": ServiceRecord( + name="Main Backend", + type="backend", + cwd="/repo/backend", + ) + }, + metadata={"project_roots": {"Main": "/repo"}}, + ) + runtime = self._reuse_runtime(state=state) + + decision = startup_support.evaluate_run_reuse( + runtime, + runtime_mode="main", + route=route, + contexts=[context], + ) + + self.assertEqual(decision.decision_kind, "fresh_run") + self.assertEqual(decision.reason, "explicit_no_resume") + self.assertIs(decision.candidate_state, state) + def test_run_reuse_rejects_dependency_external_mode_mismatch(self) -> None: context = ProjectContext(name="Main", root=Path("/repo"), ports={}) route = Route(command="start", mode="main", raw_args=[], passthrough_args=[], projects=[], flags={}) diff --git a/tests/python/runtime/test_lifecycle_cleanup_spinner_integration.py b/tests/python/runtime/test_lifecycle_cleanup_spinner_integration.py index 5e840ce43..9332c314f 100644 --- a/tests/python/runtime/test_lifecycle_cleanup_spinner_integration.py +++ b/tests/python/runtime/test_lifecycle_cleanup_spinner_integration.py @@ -142,6 +142,85 @@ def _terminate_services_from_state(self, *args, **kwargs): # noqa: ANN001, ARG0 class LifecycleCleanupSpinnerIntegrationTests(unittest.TestCase): + def test_clear_runtime_state_purges_after_dependency_container_cleanup_failure(self) -> None: + for command, aggressive in (("stop-all", False), ("blast-all", True)): + with self.subTest(command=command): + runtime = _RuntimeStub() + runtime._try_load_existing_state = lambda *args, **kwargs: RunState( # type: ignore[method-assign] + run_id="run-1", + mode="main", + requirements={ + "Main": RequirementsResult( + project="Main", + redis={ + "id": "redis", + "enabled": True, + "container_name": "envctl-redis-main", + }, + ) + }, + ) + orchestrator = LifecycleCleanupOrchestrator(runtime) + orchestrator.blast_all_ecosystem_enabled = lambda: False # type: ignore[method-assign] + orchestrator.blast_all_purge_legacy_state_artifacts = lambda: None # type: ignore[method-assign] + output = StringIO() + + with ( + patch( + "envctl_engine.runtime.lifecycle_cleanup_orchestrator.stop_requirement_component_containers", + side_effect=RuntimeError("Docker daemon is unavailable"), + ), + redirect_stdout(output), + ): + orchestrator.clear_runtime_state(command=command, aggressive=aggressive) + + self.assertEqual(runtime.state_repository.purge_calls, [aggressive]) + self.assertIn("could not stop redis container", output.getvalue()) + warnings = [ + event + for event in runtime.events + if event.get("event") == "cleanup.dependency_container.warning" + ] + self.assertEqual( + warnings, + [ + { + "event": "cleanup.dependency_container.warning", + "component": "redis", + "detail": "Docker daemon is unavailable", + } + ], + ) + + def test_targeted_runtime_cleanup_remains_fail_closed(self) -> None: + runtime = _RuntimeStub() + runtime._try_load_existing_state = lambda *args, **kwargs: RunState( # type: ignore[method-assign] + run_id="run-1", + mode="main", + requirements={ + "Main": RequirementsResult( + project="Main", + redis={ + "id": "redis", + "enabled": True, + "container_name": "envctl-redis-main", + }, + ) + }, + ) + orchestrator = LifecycleCleanupOrchestrator(runtime) + + with ( + patch( + "envctl_engine.runtime.lifecycle_cleanup_orchestrator.stop_requirement_component_containers", + side_effect=RuntimeError("Docker daemon is unavailable"), + ), + self.assertRaisesRegex(RuntimeError, "Docker daemon is unavailable"), + ): + orchestrator.clear_runtime_state(command="stop", aggressive=False) + + self.assertEqual(runtime.state_repository.purge_calls, []) + def test_stop_all_emits_spinner_policy_and_lifecycle(self) -> None: runtime = _RuntimeStub() orchestrator = LifecycleCleanupOrchestrator(runtime) diff --git a/tests/python/runtime/test_lifecycle_dependency_stop.py b/tests/python/runtime/test_lifecycle_dependency_stop.py index 7d1dca6df..590f941a6 100644 --- a/tests/python/runtime/test_lifecycle_dependency_stop.py +++ b/tests/python/runtime/test_lifecycle_dependency_stop.py @@ -11,6 +11,7 @@ release_selected_dependency_components, requirements_have_enabled_components, select_dependency_components_for_stop, + stop_requirement_component_containers, ) from envctl_engine.runtime.lifecycle_requirement_ports import requirement_component_port_owners from envctl_engine.shared.ports import PortPlanner @@ -18,6 +19,84 @@ class LifecycleDependencyStopTests(unittest.TestCase): + def test_entire_system_selects_all_enabled_dependencies_for_requested_project(self) -> None: + state = RunState( + run_id="run-entire", + mode="trees", + requirements={ + "Alpha": RequirementsResult(project="Alpha", redis={"enabled": True}, n8n={"enabled": True}), + "Beta": RequirementsResult(project="Beta", redis={"enabled": True}), + }, + ) + route = Route(command="stop", mode="trees", projects=["Alpha"], flags={"runtime_scope": "entire-system"}) + + self.assertEqual(select_dependency_components_for_stop(state, route), {"Alpha": {"redis", "n8n"}}) + + def test_stop_requirement_component_removes_direct_and_compose_containers(self) -> None: + calls: list[list[str]] = [] + + def run(command, **_kwargs): # noqa: ANN001 + argv = [str(part) for part in command] + calls.append(argv) + if argv[:3] == ["docker", "ps", "--all"]: + return SimpleNamespace(returncode=0, stdout="one\ntwo\n", stderr="") + return SimpleNamespace(returncode=0, stdout="", stderr="") + + runtime = SimpleNamespace(process_runner=SimpleNamespace(run=run)) + stop_requirement_component_containers( + runtime, + {"id": "redis", "enabled": True, "container_name": "envctl-redis-alpha"}, + ) + stop_requirement_component_containers( + runtime, + { + "id": "supabase", + "enabled": True, + "container_name": "envctl-supabase-alpha-supabase-db-1", + }, + ) + + self.assertIn(["docker", "rm", "--force", "envctl-redis-alpha"], calls) + self.assertIn( + ["docker", "ps", "--all", "--quiet", "--filter", "label=com.docker.compose.project=envctl-supabase-alpha"], + calls, + ) + self.assertIn(["docker", "rm", "--force", "one", "two"], calls) + + def test_stop_native_supabase_falls_back_to_saved_container_name(self) -> None: + calls: list[list[str]] = [] + + def run(command, **_kwargs): # noqa: ANN001 + argv = [str(part) for part in command] + calls.append(argv) + if argv[:3] == ["docker", "ps", "--all"]: + return SimpleNamespace(returncode=0, stdout="", stderr="") + return SimpleNamespace(returncode=0, stdout="", stderr="") + + stop_requirement_component_containers( + SimpleNamespace(process_runner=SimpleNamespace(run=run)), + { + "id": "supabase", + "enabled": True, + "container_name": "envctl-feature-supabase-db-1", + }, + ) + + self.assertEqual( + calls, + [ + [ + "docker", + "ps", + "--all", + "--quiet", + "--filter", + "label=com.docker.compose.project=envctl-feature", + ], + ["docker", "rm", "--force", "envctl-feature-supabase-db-1"], + ], + ) + def test_select_dependency_components_filters_unknown_projects_dependencies_and_disabled_components(self) -> None: state = RunState( run_id="run-1", @@ -61,6 +140,7 @@ def test_release_selected_dependency_components_releases_internal_ports_and_prun }, ) released: list[int] = [] + stopped: list[str] = [] release_selected_dependency_components( state, @@ -71,9 +151,11 @@ def test_release_selected_dependency_components_releases_internal_ports_and_prun port_planner=SimpleNamespace(release=released.append), ) ), + stop_component_fn=lambda component: stopped.append(str(component.get("id"))), ) self.assertEqual(released, [5432, 15432, 6543]) + self.assertEqual(stopped, ["postgres", "postgres"]) self.assertEqual(state.requirements, {}) def test_release_selected_dependency_components_preserves_projects_with_enabled_components(self) -> None: diff --git a/tests/python/runtime/test_lifecycle_worktree_cleanup.py b/tests/python/runtime/test_lifecycle_worktree_cleanup.py index 8f43617d8..8498d5f1e 100644 --- a/tests/python/runtime/test_lifecycle_worktree_cleanup.py +++ b/tests/python/runtime/test_lifecycle_worktree_cleanup.py @@ -4,6 +4,7 @@ from pathlib import Path from types import SimpleNamespace +from envctl_engine.runtime.docker_service_runtime import docker_service_container_name from envctl_engine.runtime.lifecycle_worktree_containers import legacy_container_name, remove_tree_containers from envctl_engine.runtime.lifecycle_worktree_cleanup import WorktreeCleanupDependencies, blast_worktree_before_delete from envctl_engine.runtime.lifecycle_worktree_metadata import cleanup_artifact_paths, prune_project_metadata @@ -12,6 +13,42 @@ class LifecycleWorktreeCleanupTests(unittest.TestCase): + def test_remove_tree_containers_removes_managed_application_container(self) -> None: + calls: list[list[str]] = [] + project_root = Path(".").resolve() + container_name = docker_service_container_name( + project_name="Feature", + project_root=project_root, + service_name="backend", + ) + + class Runner: + def run(self, command: list[str], **kwargs: object) -> SimpleNamespace: + calls.append(command) + if command[1:4] == ["ps", "-a", "--format"]: + return SimpleNamespace(returncode=0, stdout=f"app-id|{container_name}\n", stderr="") + return SimpleNamespace(returncode=0, stdout="", stderr="") + + runtime = SimpleNamespace( + process_runner=Runner(), + env={}, + config=SimpleNamespace(additional_services=()), + _emit=lambda event, **payload: None, + ) + warnings: list[str] = [] + + remove_tree_containers( + runtime, + project_name="Feature", + project_root=project_root, + include_supabase=False, + remove_named_volumes=False, + warnings=warnings, + ) + + self.assertEqual(warnings, []) + self.assertIn(["docker", "rm", "-f", "-v", "app-id"], calls) + def test_worktree_cleanup_persists_siblings_from_the_full_multi_project_run(self) -> None: loader_calls: list[dict[str, object]] = [] saved_states: list[RunState] = [] diff --git a/tests/python/runtime/test_prereq_policy.py b/tests/python/runtime/test_prereq_policy.py index eeab8e36a..e9bbab344 100644 --- a/tests/python/runtime/test_prereq_policy.py +++ b/tests/python/runtime/test_prereq_policy.py @@ -13,6 +13,37 @@ class PrereqPolicyTests(unittest.TestCase): + def test_docker_application_mode_requires_docker_without_dependencies(self) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + repo = Path(tmpdir) / "repo" + runtime = Path(tmpdir) / "runtime" + (repo / ".git").mkdir(parents=True, exist_ok=True) + config = load_config( + { + "RUN_REPO_ROOT": str(repo), + "RUN_SH_RUNTIME_DIR": str(runtime), + "POSTGRES_MAIN_ENABLE": "false", + "REDIS_ENABLE": "false", + "SUPABASE_MAIN_ENABLE": "false", + "N8N_ENABLE": "false", + } + ) + route = parse_route(["start", "--main", "--docker"], env={}) + + def fake_which(binary: str) -> str | None: + if binary == "docker": + return None + return f"/usr/bin/{binary}" + + with ( + patch("envctl_engine.runtime.cli.shutil.which", side_effect=fake_which), + patch("envctl_engine.runtime.cli._python_dependency_available", return_value=True), + ): + ok, reason = cli.check_prereqs(route, config) + + self.assertFalse(ok) + self.assertIn("docker", str(reason).lower()) + def test_main_start_without_requirements_does_not_require_docker(self) -> None: with tempfile.TemporaryDirectory() as tmpdir: repo = Path(tmpdir) / "repo" diff --git a/tests/python/startup/test_restart_prestop_support.py b/tests/python/startup/test_restart_prestop_support.py index b7c94dc3f..173475120 100644 --- a/tests/python/startup/test_restart_prestop_support.py +++ b/tests/python/startup/test_restart_prestop_support.py @@ -326,6 +326,27 @@ def test_restart_prestop_state_rejects_mode_mismatch_and_builds_fallback_route(s ], ) + def test_restart_prestop_state_inherits_docker_runtime_from_saved_state(self) -> None: + route = Route(command="restart", mode="main", raw_args=["restart"], flags={}) + state = SimpleNamespace( + mode="main", + run_id="run-docker", + metadata={"application_runtime": "docker"}, + services={}, + ) + runtime = SimpleNamespace( + env={}, + _effective_start_mode=lambda route: "main", + _try_load_existing_state=lambda *, mode: state, + _emit=lambda event, **payload: None, + ) + + result = restart_prestop_state(route=route, runtime=runtime) + + self.assertIs(result.state, state) + self.assertTrue(route.flags["docker"]) + self.assertEqual(runtime.env["DOCKER_MODE"], "true") + def test_restart_prestop_preservation_splits_services_and_requirements(self) -> None: state = SimpleNamespace( services={ diff --git a/tests/python/startup/test_resume_restore_policy.py b/tests/python/startup/test_resume_restore_policy.py index a5fa2b510..26c49ee52 100644 --- a/tests/python/startup/test_resume_restore_policy.py +++ b/tests/python/startup/test_resume_restore_policy.py @@ -6,6 +6,10 @@ from types import SimpleNamespace from envctl_engine.runtime.command_router import Route, parse_route +from envctl_engine.startup.resume_restore_execution import ( + _apply_restore_runtime_mode, + _route_for_resume_restore, +) from envctl_engine.startup.resume_restore_policy import ( _configured_restore_service_types, _requirements_reuse_decision, @@ -16,10 +20,39 @@ apply_ports_to_context, project_root, ) -from envctl_engine.state.models import RequirementsResult, ServiceRecord +from envctl_engine.state.models import RequirementsResult, RunState, ServiceRecord class ResumeRestorePolicyTests(unittest.TestCase): + def test_docker_state_forces_docker_mode_for_direct_resume_restore(self) -> None: + state = RunState( + run_id="run-docker", + mode="main", + services={ + "Main Backend": ServiceRecord( + name="Main Backend", + type="backend", + cwd="/repo/backend", + runtime_kind="docker", + container_id="stale-container", + ) + }, + ) + route = Route(command="resume", mode="main", flags={"batch": True}) + + restored_route = _route_for_resume_restore( + route, + state=state, + suppress_timing_output=False, + ) + + self.assertTrue(restored_route.flags["docker"]) + self.assertTrue(restored_route.flags["_resume_restore"]) + self.assertTrue(restored_route.flags["batch"]) + runtime = SimpleNamespace(env={}) + _apply_restore_runtime_mode(runtime, restored_route) + self.assertEqual(runtime.env["DOCKER_MODE"], "true") + def test_plan_resume_defaults_to_parallel_tree_restore(self) -> None: captured_routes: list[Route] = [] diff --git a/tests/python/startup/test_run_reuse_identity.py b/tests/python/startup/test_run_reuse_identity.py index 6496c5771..607bd4fd2 100644 --- a/tests/python/startup/test_run_reuse_identity.py +++ b/tests/python/startup/test_run_reuse_identity.py @@ -47,6 +47,7 @@ def test_build_startup_identity_metadata_records_roots_and_fingerprint_payload(s self.assertEqual(metadata["project_roots"], {"Main": normalize_project_root("/tmp/repo")}) identity = metadata["startup_identity"] self.assertEqual(identity["mode"], "main") + self.assertEqual(identity["application_runtime"], "process") self.assertEqual(identity["projects"], [{"name": "Main", "root": normalize_project_root("/tmp/repo")}]) self.assertEqual(identity["services"], {"backend": True, "frontend": False}) self.assertIn("fingerprint", identity) @@ -144,6 +145,21 @@ def test_startup_identity_mismatch_ignores_matching_fingerprints_and_reports_cha self.assertEqual(mismatch, {"fields": ["mode"]}) + self.assertEqual( + _startup_identity_mismatch( + {"mode": "main", "services": {"backend": True}}, + {"mode": "main", "services": {"backend": True}, "application_runtime": "process"}, + ), + {}, + ) + self.assertEqual( + _startup_identity_mismatch( + {"mode": "main", "application_runtime": "process"}, + {"mode": "main", "application_runtime": "docker"}, + ), + {"fields": ["application_runtime"]}, + ) + def test_root_mismatches_compare_only_strong_roots(self) -> None: selected = [ProjectIdentity("Main", "/repo"), ProjectIdentity("Weak", None)] state = [ProjectIdentity("Main", "/other"), ProjectIdentity("Weak", "/weak")] diff --git a/tests/python/startup/test_run_reuse_support.py b/tests/python/startup/test_run_reuse_support.py index d6ae837c6..687ff85bc 100644 --- a/tests/python/startup/test_run_reuse_support.py +++ b/tests/python/startup/test_run_reuse_support.py @@ -7,6 +7,7 @@ from envctl_engine.startup.run_reuse_support import ( dashboard_stopped_service_entries, fresh_start_replacement_services, + mark_run_reused, prepare_dashboard_stopped_service_restore, replace_existing_project_services_for_fresh_start, metadata_without_dashboard_stopped_services, @@ -15,6 +16,12 @@ class RunReuseSupportTests(unittest.TestCase): + def test_mark_run_reused_recovers_from_malformed_counter(self) -> None: + updated = mark_run_reused({"run_reuse_count": "not-a-number"}, reason="exact_match") + + self.assertEqual(updated["run_reuse_count"], 1) + self.assertEqual(updated["last_reuse_reason"], "exact_match") + def test_run_reuse_debug_orch_groups_only_apply_to_plan_commands(self) -> None: runtime = SimpleNamespace(env={"ENVCTL_DEBUG_PLAN_ORCH_GROUP": "alpha+ beta,gamma ,,"}) @@ -192,6 +199,74 @@ def test_fresh_start_replacement_services_selects_every_service_for_target_proje {"Main Backend", "Main Frontend"}, ) + def test_unfiltered_explicit_no_resume_replaces_tracked_removed_additional_services(self) -> None: + state = SimpleNamespace( + services={ + "Main Backend": SimpleNamespace(name="Main Backend", project="Main", type="backend"), + "Main Old Worker": SimpleNamespace( + name="Main Old Worker", + project="Main", + type="old-worker", + service_slug="old-worker", + ), + } + ) + + selected = fresh_start_replacement_services( + selected_contexts=[SimpleNamespace(name="Main")], + candidate_state=state, + project_name_from_service=lambda _name: "Main", + ) + + self.assertEqual(selected, {"Main Backend", "Main Old Worker"}) + + def test_fresh_start_replacement_services_respects_launch_only_filter(self) -> None: + state = SimpleNamespace( + services={ + "Main Backend": SimpleNamespace(project="Main", type="backend"), + "Main Frontend": SimpleNamespace(project="Main", type="frontend"), + "Main Old Worker": SimpleNamespace(project="Main", type="old-worker"), + } + ) + + cases = ( + ({"no_resume": True, "launch_backend": True, "launch_frontend": False}, {"Main Backend"}), + ({"no_resume": True, "launch_backend": False, "launch_frontend": True}, {"Main Frontend"}), + ({"no_resume": True, "launch_backend": False, "launch_frontend": False}, set()), + ) + for flags, expected in cases: + with self.subTest(flags=flags): + selected = fresh_start_replacement_services( + route=Route(command="start", mode="trees", raw_args=["start"], flags=flags), + selected_contexts=[SimpleNamespace(name="Main")], + candidate_state=state, + project_name_from_service=lambda _name: "Main", + ) + + self.assertEqual(selected, expected) + + def test_fresh_start_no_dependencies_flag_keeps_unfiltered_removed_service_cleanup(self) -> None: + state = SimpleNamespace( + services={ + "Main Backend": SimpleNamespace(project="Main", type="backend"), + "Main Old Worker": SimpleNamespace(project="Main", type="old-worker"), + } + ) + + selected = fresh_start_replacement_services( + route=Route( + command="start", + mode="trees", + raw_args=["start", "--no-resume", "--no-dependencies"], + flags={"no_resume": True, "launch_dependencies": False}, + ), + selected_contexts=[SimpleNamespace(name="Main")], + candidate_state=state, + project_name_from_service=lambda _name: "Main", + ) + + self.assertEqual(selected, {"Main Backend", "Main Old Worker"}) + def test_replace_existing_project_services_for_fresh_start_terminates_selected_services_and_orphans(self) -> None: route = Route(command="start", mode="trees", raw_args=["start"], flags={}) session = SimpleNamespace( @@ -306,6 +381,58 @@ def test_explicit_no_resume_replaces_matching_services_instead_of_leaking_a_seco self.assertEqual(terminated, [{"feature-a Backend"}]) self.assertEqual(progress, ["Auto-resume disabled; replacing 1 existing service(s)..."]) + def test_explicit_no_resume_rebinds_reserved_plan_to_released_service_port(self) -> None: + route = Route(command="start", mode="main", flags={"no_resume": True}) + backend_plan = SimpleNamespace(assigned=8001, final=8001, source="retry") + context = SimpleNamespace(name="Main", ports={"backend": backend_plan}) + service = SimpleNamespace( + name="Main Backend", + project="Main", + type="backend", + service_slug="backend", + listener_expected=True, + actual_port=8000, + requested_port=8000, + ) + session = SimpleNamespace( + effective_route=route, + runtime_mode="main", + selected_contexts=[context], + preserved_services={}, + preserved_requirements={}, + base_metadata={}, + ) + candidate_state = SimpleNamespace( + run_id="run-existing", + services={"Main Backend": service}, + requirements={}, + metadata={}, + ) + calls: list[tuple[str, int, str]] = [] + runtime = SimpleNamespace( + port_planner=SimpleNamespace( + release=lambda port, *, owner: calls.append(("release", port, owner)), + ), + _emit=lambda *_args, **_kwargs: None, + _project_name_from_service=lambda _name: "Main", + _terminate_services_from_state=lambda *_args, **_kwargs: None, + _release_requirement_ports=lambda _requirements: None, + ) + + replace_existing_project_services_for_fresh_start( + runtime=runtime, + session=session, + candidate_state=candidate_state, + reason="explicit_no_resume", + announce_session_identifiers=lambda _session: None, + report_progress=lambda _route, _message: None, + terminate_restart_orphan_listeners=lambda **_kwargs: None, + ) + + self.assertEqual(calls, [("release", 8001, "Main:backend")]) + self.assertEqual((backend_plan.assigned, backend_plan.final), (8000, 8000)) + self.assertEqual(backend_plan.source, "fresh_start_replacement") + def test_backend_scoped_fresh_start_preserves_frontend_and_existing_requirements(self) -> None: route = Route( command="start", diff --git a/tests/python/startup/test_service_attach_execution.py b/tests/python/startup/test_service_attach_execution.py index c737c976e..78eeafc16 100644 --- a/tests/python/startup/test_service_attach_execution.py +++ b/tests/python/startup/test_service_attach_execution.py @@ -7,7 +7,9 @@ from types import SimpleNamespace from typing import cast import unittest +from unittest.mock import patch +from envctl_engine.runtime.docker_service_runtime import DockerServiceLaunch from envctl_engine.runtime.service_manager import ServiceCleanupError, ServiceManager, ServiceStartDescriptor from envctl_engine.shared.ports import PortPlanner from envctl_engine.startup.service_attach_execution import ServiceAttachRunner @@ -268,6 +270,186 @@ def test_process_spawn_error_is_structured_without_listener_wait(self) -> None: failure_events = [payload for event, payload in events if event == "service.failure"] self.assertEqual(failure_events[0]["failure_class"], "process_spawn_failed") + def test_explicit_docker_mode_launches_and_annotates_container_service(self) -> None: + project_root = Path("/tmp/envctl-project") + runtime = SimpleNamespace( + env={}, + config=SimpleNamespace(raw={}), + services=ServiceManager(), + _conflict_remaining={}, + _emit=lambda _event, **_payload: None, + _service_start_command_resolved=lambda **kwargs: self.fail( + f"host command resolution must be skipped: {kwargs}" + ), + ) + runner = ServiceAttachRunner( + runtime=runtime, + process_runtime=SimpleNamespace(), + port_allocator=SimpleNamespace(reserve_next=lambda port, owner: port), + project_name="Main", + project_root=project_root, + backend_plan=port_plan(8000), + frontend_plan=port_plan(5173), + backend_cwd=project_root / "backend", + frontend_cwd=project_root / "frontend", + backend_log_path="/logs/backend.txt", + frontend_log_path="/logs/frontend.txt", + backend_env_extra={"PORT": "8000"}, + frontend_env_extra={}, + command_env_builder=lambda port, extra: {**extra, "PORT": str(port)}, + prepared_launches={ + "backend": PreparedServiceLaunch( + service_name="backend", + cwd=project_root / "backend", + log_path="/logs/backend.txt", + requested_port=8000, + env={"PORT": "8000"}, + command_source="configured", + ) + }, + selected_service_types={"backend"}, + additional_services=(), + backend_listener_expected=True, + rebound_delta=0, + docker_mode=True, + ) + launch = DockerServiceLaunch( + container_id="container-id", + container_name="envctl-app-main-backend", + image="example/backend:dev", + log_path="/logs/backend.txt", + ) + + with ( + patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.launch", + return_value=launch, + ) as docker_launch, + patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.wait_until_ready", + return_value=True, + ), + ): + records = runner.start(attach_parallel=False, on_service_retry=lambda *_args: None) + + record = records["Main Backend"] + self.assertEqual(record.runtime_kind, "docker") + self.assertEqual(record.container_id, "container-id") + self.assertEqual(record.container_name, "envctl-app-main-backend") + self.assertEqual(record.container_image, "example/backend:dev") + docker_launch.assert_called_once() + self.assertEqual(docker_launch.call_args.kwargs["command"], []) + + runtime.config.raw["ENVCTL_BACKEND_DOCKER_COMMAND"] = "uvicorn app:api --port 8000" + self.assertEqual(runner._core_service_command("backend", 8001), []) + + runtime.config.raw.pop("ENVCTL_BACKEND_DOCKER_COMMAND") + runtime.config.raw["ENVCTL_BACKEND_DOCKER_COMMAND_MODE"] = "service" + resolved_calls: list[dict[str, object]] = [] + runtime._service_start_command_resolved = lambda **kwargs: ( + resolved_calls.append(kwargs) or ["container-service", "--port", str(kwargs["port"])], + "configured", + ) + self.assertEqual( + runner._core_service_command("backend", 8001), + ["container-service", "--port", "8001"], + ) + self.assertEqual(resolved_calls, [{"service_name": "backend", "project_root": project_root, "port": 8001}]) + + def test_failed_optional_docker_readiness_removes_container_before_degrading(self) -> None: + project_root = Path("/tmp/envctl-project") + optional_service = SimpleNamespace( + name="voice-runtime", + start_cmd="python voice.py --port {port}", + depends_on=(), + start_order=25, + expect_listener=True, + critical=False, + env_suffix="VOICE_RUNTIME", + ) + runtime = SimpleNamespace( + env={"ENVCTL_VOICE_RUNTIME_DOCKER_IMAGE": "example/voice:dev"}, + config=SimpleNamespace( + raw={}, + app_service_by_name=lambda name: optional_service if name == "voice-runtime" else None, + ), + services=ServiceManager(), + _conflict_remaining={}, + _emit=lambda event, **payload: None, + _split_command=lambda *args, **kwargs: self.fail("host command resolution must be skipped"), + ) + runner = ServiceAttachRunner( + runtime=runtime, + process_runtime=SimpleNamespace(), + port_allocator=SimpleNamespace(reserve_next=lambda port, owner: port), + project_name="Main", + project_root=project_root, + backend_plan=port_plan(8000), + frontend_plan=port_plan(5173), + backend_cwd=project_root / "backend", + frontend_cwd=project_root / "frontend", + backend_log_path="/logs/backend.txt", + frontend_log_path="/logs/frontend.txt", + backend_env_extra={}, + frontend_env_extra={}, + command_env_builder=lambda port, extra: {**extra, "PORT": str(port)}, + prepared_launches={ + "voice-runtime": PreparedServiceLaunch( + service_name="voice-runtime", + cwd=project_root / "voice-runtime", + log_path="/logs/voice.txt", + requested_port=8010, + env={"PORT": "8010"}, + command_source="configured", + ) + }, + selected_service_types={"voice-runtime"}, + additional_services=(optional_service,), + backend_listener_expected=True, + rebound_delta=0, + docker_mode=True, + ) + launch = DockerServiceLaunch( + container_id="failed-container-id", + container_name="envctl-app-main-voice-runtime", + image="example/voice:dev", + log_path="/logs/voice.txt", + ) + + with ( + patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.launch", + return_value=launch, + ), + patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.wait_until_ready", + return_value=False, + ), + patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.stop", + return_value=True, + ) as stop_container, + ): + records = runner.start(attach_parallel=False, on_service_retry=lambda *args: None) + + record = records["Main Voice Runtime"] + self.assertEqual(record.status, "degraded") + self.assertTrue(record.degraded) + self.assertIsNone(record.container_id) + self.assertEqual(runner._container_launches, {}) + stop_container.assert_called_once_with("failed-container-id") + + runner._container_launches["voice-runtime"] = launch + with patch( + "envctl_engine.startup.service_attach_execution.DockerServiceRuntime.stop", + return_value=False, + ): + self.assertEqual( + runner._remove_failed_container_launch("voice-runtime", launch), + "failed to remove container", + ) + self.assertEqual(runner._container_launches, {"voice-runtime": launch}) + def test_runner_builds_layered_descriptors_and_preserves_additional_urls(self) -> None: project_root = Path("/tmp/envctl-project") events: list[tuple[str, dict[str, object]]] = [] diff --git a/tests/python/startup/test_service_manager.py b/tests/python/startup/test_service_manager.py index eaafd7182..1c126d3c8 100644 --- a/tests/python/startup/test_service_manager.py +++ b/tests/python/startup/test_service_manager.py @@ -17,6 +17,25 @@ class ServiceManagerTests(unittest.TestCase): + def test_pidless_runtime_descriptor_records_success_without_inventing_a_process(self) -> None: + records = ServiceManager().start_services_with_attach( + project="Main", + descriptors=( + ServiceStartDescriptor( + service_type="backend", + cwd="/tmp/main/backend", + requested_port=8000, + start=lambda _port: (True, None, None), + detect_actual=lambda pid, requested: requested if pid is None else self.fail("unexpected PID"), + pid_required=False, + ), + ), + reserve_next=lambda port: port, + ) + + self.assertIsNone(records["Main Backend"].pid) + self.assertEqual(records["Main Backend"].actual_port, 8000) + def test_backend_retries_bind_conflict_and_updates_final_port(self) -> None: manager = ServiceManager() attempts: list[int] = [] diff --git a/tests/python/startup/test_startup_orchestrator_profiles.py b/tests/python/startup/test_startup_orchestrator_profiles.py index a69b2e0e0..2fae84505 100644 --- a/tests/python/startup/test_startup_orchestrator_profiles.py +++ b/tests/python/startup/test_startup_orchestrator_profiles.py @@ -365,7 +365,7 @@ def test_startup_only_flags_select_individual_worktree_launch_parts(self) -> Non _restart_service_types_for_project( route=route, project_name="feature-a-1", - default_service_types={"backend", "frontend"}, + default_service_types={"backend", "frontend", "voice-runtime"}, ), {"frontend"}, ) @@ -376,7 +376,7 @@ def test_startup_only_flags_select_individual_worktree_launch_parts(self) -> Non _restart_service_types_for_project( route=route, project_name="feature-a-1", - default_service_types={"backend", "frontend"}, + default_service_types={"backend", "frontend", "voice-runtime"}, ), {"backend"}, ) @@ -387,7 +387,7 @@ def test_startup_only_flags_select_individual_worktree_launch_parts(self) -> Non _restart_service_types_for_project( route=route, project_name="feature-a-1", - default_service_types={"backend", "frontend"}, + default_service_types={"backend", "frontend", "voice-runtime"}, ), set(), ) diff --git a/tests/python/startup/test_support_module_decoupling.py b/tests/python/startup/test_support_module_decoupling.py index c2caae7df..6dc7215f4 100644 --- a/tests/python/startup/test_support_module_decoupling.py +++ b/tests/python/startup/test_support_module_decoupling.py @@ -1205,6 +1205,95 @@ def test_start_project_services_skips_default_backend_frontend_when_no_local_sys self.assertEqual(len(warnings), 1) self.assertIn("No local app system is configured", str(warnings[0])) + def test_start_project_services_does_not_skip_docker_only_plan_app_system(self) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) + project_root = root / "repo" + project_root.mkdir(parents=True, exist_ok=True) + run_dir = root / "runtime" / "run-1" + events: list[tuple[str, dict[str, object]]] = [] + prep_calls: list[str] = [] + + runtime = SimpleNamespace( + port_planner=_PortAllocatorStub(), + env={}, + config=SimpleNamespace( + raw={"ENVCTL_BACKEND_DOCKER_IMAGE": "example/backend:dev"}, + explicit_keys=("ENVCTL_BACKEND_DOCKER_IMAGE",), + backend_dir_name="backend", + frontend_dir_name="frontend", + additional_services=(), + backend_dependency_env_section_present=False, + frontend_dependency_env_section_present=False, + main_backend_dependency_env_section_present=False, + main_frontend_dependency_env_section_present=False, + trees_backend_dependency_env_section_present=False, + trees_frontend_dependency_env_section_present=False, + service_dependency_env_section_present={}, + mode_service_dependency_env_section_present={}, + all_app_service_names_for_mode=lambda mode, project_root=None: ("backend", "frontend"), + ), + services=SimpleNamespace(), + _invoke_envctl_hook=lambda **kwargs: SimpleNamespace(found=False, success=False, payload=None), + _run_dir_path=lambda run_id: run_dir, + _project_service_env=lambda context, requirements, route=None, service_name=None: {}, + _resolve_backend_env_file=lambda context, backend_cwd: (None, False), + _resolve_frontend_env_file=lambda context, frontend_cwd: None, + _service_env_from_file=lambda base_env, env_file, include_app_env_file, env_file_authoritative=False: dict(base_env), + _service_enabled_for_mode=lambda mode, service: True, + process_runner=SimpleNamespace(), + _prepare_backend_runtime=lambda **kwargs: prep_calls.append("backend"), + _prepare_frontend_runtime=lambda **kwargs: prep_calls.append("frontend"), + _service_command_source=lambda **kwargs: self.fail( + f"host command source must be skipped: {kwargs}" + ), + _command_exists=lambda command: False, + _emit=lambda event, **payload: events.append((event, payload)), + ) + orchestrator = SimpleNamespace( + runtime=runtime, + _restart_service_types_for_project=lambda **kwargs: {"backend", "frontend"}, + _suppress_timing_output=lambda route: True, + ) + context = SimpleNamespace( + name="Main", + root=project_root, + ports={ + "backend": SimpleNamespace(final=8000), + "frontend": SimpleNamespace(final=3000), + }, + ) + route = parse_route( + ["--plan", "feature-a", "--docker", "--entire-system", "--batch"], + env={}, + ) + + with mock.patch( + "envctl_engine.startup.service_project_execution.ServiceAttachRunner" + ) as runner_cls: + runner_cls.return_value.start.return_value = {} + records = start_project_services( + orchestrator, + context, + requirements=RequirementsResult(project="Main", components={}, health="healthy", failures=[]), + run_id="run-1", + route=route, + ) + + self.assertEqual(records, {}) + self.assertEqual(prep_calls, []) + self.assertTrue(runner_cls.call_args.kwargs["docker_mode"]) + self.assertEqual( + runner_cls.call_args.kwargs["prepared_launches"]["backend"].command_source, + "docker_image", + ) + self.assertFalse( + any( + event == "service.attach.skipped" and payload.get("reason") == "no_system_configured" + for event, payload in events + ) + ) + def test_start_project_services_keeps_missing_command_failure_for_explicit_enablement(self) -> None: with tempfile.TemporaryDirectory() as tmpdir: root = Path(tmpdir) diff --git a/tests/python/state/test_state_action_log_support.py b/tests/python/state/test_state_action_log_support.py index ee9500ab0..c58fef5d5 100644 --- a/tests/python/state/test_state_action_log_support.py +++ b/tests/python/state/test_state_action_log_support.py @@ -103,6 +103,30 @@ def test_clear_service_logs_truncates_available_files_and_reports_missing_paths( self.assertIn("Main Frontend: log missing", rendered) self.assertIn("Main Worker: log=n/a", rendered) + def test_clear_service_logs_advances_docker_cursor_without_snapshot_file(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + log_path = Path(tmp) / "docker-backend.log" + marker = Path(f"{log_path}.docker-since") + state = RunState( + run_id="run-docker", + mode="main", + services={ + "Main Backend": ServiceRecord( + name="Main Backend", + type="backend", + cwd=tmp, + log_path=str(log_path), + runtime_kind="docker", + ) + }, + ) + + summary = StateActionLogSupport.clear_service_logs(state, quiet=True) + + self.assertEqual(summary, (1, 0, 0, 0)) + self.assertFalse(log_path.exists()) + self.assertTrue(marker.is_file()) + if __name__ == "__main__": unittest.main() diff --git a/tests/python/state/test_state_action_orchestrator_logs.py b/tests/python/state/test_state_action_orchestrator_logs.py index fb6056b21..1da01021b 100644 --- a/tests/python/state/test_state_action_orchestrator_logs.py +++ b/tests/python/state/test_state_action_orchestrator_logs.py @@ -3,6 +3,7 @@ from contextlib import redirect_stdout from io import StringIO import json +import signal import tempfile import unittest from types import SimpleNamespace @@ -15,6 +16,7 @@ from envctl_engine.runtime.command_router import Route from envctl_engine.runtime.engine_runtime_runtime_support import normalize_log_line from envctl_engine.state.models import RequirementsResult, RunState, ServiceRecord +from envctl_engine.state.action_command_support import _interrupt_log_follow_on_termination from envctl_engine.state.action_orchestrator import StateActionOrchestrator from envctl_engine.test_output.parser_base import strip_ansi from envctl_engine.ui.target_selector import TargetSelection @@ -75,6 +77,17 @@ def _emit(self, event: str, **payload: object) -> None: class StateActionOrchestratorLogsTests(unittest.TestCase): + def test_log_follow_termination_signal_interrupts_for_finally_cleanup(self) -> None: + previous = signal.getsignal(signal.SIGTERM) + + with self.assertRaises(KeyboardInterrupt): + with _interrupt_log_follow_on_termination(True): + handler = signal.getsignal(signal.SIGTERM) + self.assertTrue(callable(handler)) + handler(signal.SIGTERM, None) # type: ignore[operator] + + self.assertIs(signal.getsignal(signal.SIGTERM), previous) + def test_runtime_facade_routes_state_dependencies(self) -> None: state = RunState(run_id="run-0", mode="main") runtime = _RuntimeStub(state) @@ -146,6 +159,39 @@ def test_logs_service_filter_accepts_additional_service_slug_and_display_forms(s assert runtime.seen_logs_state is not None self.assertEqual(set(runtime.seen_logs_state.services), {"Main Voice Runtime"}) + def test_logs_combined_project_and_service_filters_intersect(self) -> None: + state = RunState( + run_id="run-combined-filter", + mode="trees", + services={ + "Alpha Backend": ServiceRecord( + name="Alpha Backend", type="backend", cwd="/tmp/alpha", project="Alpha" + ), + "Alpha Frontend": ServiceRecord( + name="Alpha Frontend", type="frontend", cwd="/tmp/alpha", project="Alpha" + ), + "Beta Backend": ServiceRecord( + name="Beta Backend", type="backend", cwd="/tmp/beta", project="Beta" + ), + }, + ) + runtime = _RuntimeStub(state) + orchestrator = StateActionOrchestrator(runtime) + route = Route( + command="logs", + mode="trees", + projects=["Alpha"], + flags={"services": ["backend"], "json": True}, + ) + + output = StringIO() + with redirect_stdout(output): + code = orchestrator.execute(route) + + payload = json.loads(output.getvalue()) + self.assertEqual(code, 0) + self.assertEqual([service["name"] for service in payload["services"]], ["Alpha Backend"]) + def test_health_prints_enabled_dependency_statuses(self) -> None: state = RunState( run_id="run-1", diff --git a/tests/python/state/test_state_roundtrip.py b/tests/python/state/test_state_roundtrip.py index b130670f9..7275f464d 100644 --- a/tests/python/state/test_state_roundtrip.py +++ b/tests/python/state/test_state_roundtrip.py @@ -29,6 +29,10 @@ def test_json_state_roundtrip_preserves_services(self) -> None: listener_pids=[12345, 12346], status="running", started_at=1234.5, + runtime_kind="docker", + container_id="sha256:abc", + container_name="envctl-app-tree-alpha-backend", + container_image="envctl/example-backend:dev", ) }, requirements={ @@ -59,6 +63,16 @@ def test_json_state_roundtrip_preserves_services(self) -> None: loaded.requirements["Tree Alpha"].db["port_lock_session"], "planner-session-1", ) + self.assertEqual(loaded.services["Tree Alpha Backend"].runtime_kind, "docker") + self.assertEqual(loaded.services["Tree Alpha Backend"].container_id, "sha256:abc") + self.assertEqual( + loaded.services["Tree Alpha Backend"].container_name, + "envctl-app-tree-alpha-backend", + ) + self.assertEqual( + loaded.services["Tree Alpha Backend"].container_image, + "envctl/example-backend:dev", + ) self.assertEqual(loaded.metadata["source"], "python") def test_legacy_shell_state_is_loaded_without_source_execution(self) -> None: diff --git a/tests/python/ui/test_selection_support.py b/tests/python/ui/test_selection_support.py index bca70906e..a988856b0 100644 --- a/tests/python/ui/test_selection_support.py +++ b/tests/python/ui/test_selection_support.py @@ -108,6 +108,14 @@ def test_no_target_selected_message_and_explicit_target_detection_match_route_co "--project ", no_target_selected_message("restart", route=_route(mode="trees"), interactive_allowed=False), ) + self.assertIn( + "--all --yes", + no_target_selected_message("ship", route=_route(mode="trees"), interactive_allowed=False), + ) + self.assertNotIn( + "--all --yes", + no_target_selected_message("test", route=_route(mode="trees"), interactive_allowed=False), + ) self.assertTrue(route_has_explicit_target(_route(flags={"all": True}), runtime)) self.assertTrue(route_has_explicit_target(_route(projects=["Main"]), runtime))