@mriekki/lean 0.4.4 → 0.4.5

package/assets/generated/deployment/src/lean_poc_deployment/teardown.py

@@ -1,4 +1,4 @@
-"""Scoped destructive tear-down for Kit-managed POC environments and local Docker state."""
+"""Scoped destructive tear-down for Kit-managed named environments and local Docker state."""
 
 from __future__ import annotations
 
@@ -17,7 +17,7 @@ from .teardown_remote import REMOTE_SCRIPT
 
 TEAR_DOWN_WRITE_PHRASE = "[POC TEAR DOWN]"
 PRODUCTION_DATA_DELETE_PHRASE = "[PRODUCTION DATA DELETE]"
-SUPPORTED_SCOPES = ("local", "staging", "production", "all")
+RESERVED_SCOPES = ("local", "all")
 
 _SLUG_RE = re.compile(r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$")
 _REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
@@ -50,8 +50,8 @@ def parse_environment_targets(items: Iterable[str]) -> dict[str, str]:
             raise DeploymentKitError("environment target bindings must use environment=target form.")
         environment, target = item.split("=", 1)
         environment = _slug(environment, "environment")
-        if environment not in {"staging", "production"}:
-            raise DeploymentKitError("tear-down supports only staging and production environment bindings.")
+        if environment in RESERVED_SCOPES:
+            raise DeploymentKitError(f"{environment!r} is reserved and cannot be a remote environment name.")
         if not target or _TARGET_RE.fullmatch(target) is None:
             raise DeploymentKitError("target profile names contain unsupported characters.")
         if environment in result:
@@ -60,14 +60,14 @@ def parse_environment_targets(items: Iterable[str]) -> dict[str, str]:
     return dict(sorted(result.items()))
 
 
-def _remote_environments(scope: str) -> tuple[str, ...]:
-    if scope == "staging":
-        return ("staging",)
-    if scope == "production":
-        return ("production",)
-    if scope == "all":
-        return ("staging", "production")
-    return ()
+def _normalize_production_environments(items: Iterable[str]) -> set[str]:
+    result = {"production"}
+    for item in items:
+        environment = _slug(item, "productionEnvironment")
+        if environment in RESERVED_SCOPES:
+            raise DeploymentKitError("local/all cannot be classified as Production environments.")
+        result.add(environment)
+    return result
 
 
 def normalize_teardown_spec(
@@ -77,39 +77,45 @@ def normalize_teardown_spec(
     scope: str,
     environment_targets: dict[str, str] | Iterable[tuple[str, str]],
     local_package: str | None,
+    production_environments: Iterable[str] = (),
 ) -> dict[str, Any]:
-    if scope not in SUPPORTED_SCOPES:
-        raise DeploymentKitError("scope must be one of: local, staging, production, all.")
-
+    scope = _slug(scope, "scope")
     pairs = environment_targets.items() if isinstance(environment_targets, dict) else environment_targets
     normalized_targets: dict[str, str] = {}
     for environment, target in pairs:
         environment = _slug(environment, "environment")
-        if environment not in {"staging", "production"}:
-            raise DeploymentKitError("tear-down supports only staging and production environment bindings.")
+        if environment in RESERVED_SCOPES:
+            raise DeploymentKitError(f"{environment!r} is reserved and cannot be a remote environment name.")
         if not isinstance(target, str) or _TARGET_RE.fullmatch(target) is None:
             raise DeploymentKitError("target profile names contain unsupported characters.")
         if environment in normalized_targets:
             raise DeploymentKitError(f"Duplicate environment target binding: {environment}")
         normalized_targets[environment] = target
 
-    selected_targets: dict[str, str] = {}
-    for environment in _remote_environments(scope):
-        if environment not in normalized_targets:
-            raise DeploymentKitError(f"scope {scope!r} requires an explicit {environment}=target binding.")
-        selected_targets[environment] = normalized_targets[environment]
+    if scope == "local":
+        selected_targets: dict[str, str] = {}
+    elif scope == "all":
+        selected_targets = dict(sorted(normalized_targets.items()))
+    else:
+        if scope not in normalized_targets:
+            raise DeploymentKitError(f"scope {scope!r} requires an explicit {scope}=target binding.")
+        selected_targets = {scope: normalized_targets[scope]}
 
     package = _package(local_package) if local_package is not None else None
-    if scope in {"local", "all"} and package is None:
-        raise DeploymentKitError(f"scope {scope!r} requires --local-package for exact local Docker ownership.")
+    if scope == "local" and package is None:
+        raise DeploymentKitError("scope 'local' requires --local-package for exact local Docker ownership.")
+
+    production_set = _normalize_production_environments(production_environments)
+    selected_production = sorted(set(selected_targets).intersection(production_set))
 
     return {
-        "schemaVersion": 1,
+        "schemaVersion": 2,
         "ownerRepo": _owner_repo(owner_repo),
         "appSlug": _slug(app_slug, "appSlug"),
         "scope": scope,
         "environmentTargets": selected_targets,
         "localPackage": package,
+        "productionEnvironments": selected_production,
     }
 
 
@@ -197,25 +203,30 @@ def tear_down_workstation_package(package: str) -> dict[str, Any]:
 
     listed = _run_local([docker, "ps", "-a", "--format", "{{.ID}}"])
     if listed.returncode != 0:
-        raise DeploymentKitError("Local Docker container inventory failed: " + (listed.stderr or listed.stdout).strip())
+        raise DeploymentKitError(
+            "Local Docker container inventory failed: " + (listed.stderr or listed.stdout).strip()
+        )
 
     containers: list[str] = []
     for container_id in [line.strip() for line in listed.stdout.splitlines() if line.strip()]:
         inspected = _run_local([docker, "inspect", "--format", "{{.Config.Image}}", container_id])
         if inspected.returncode != 0:
             raise DeploymentKitError(f"Local Docker inspect failed for container {container_id}.")
-        image = inspected.stdout.strip()
-        if _image_matches_package(image, package):
+        if _image_matches_package(inspected.stdout.strip(), package):
             containers.append(container_id)
 
     if containers:
         removed = _run_local([docker, "rm", "-f", "-v", *containers])
         if removed.returncode != 0:
-            raise DeploymentKitError("Local POC container removal failed: " + (removed.stderr or removed.stdout).strip())
+            raise DeploymentKitError(
+                "Local POC container removal failed: " + (removed.stderr or removed.stdout).strip()
+            )
 
     images_result = _run_local([docker, "images", "--format", "{{.Repository}}:{{.Tag}}"])
     if images_result.returncode != 0:
-        raise DeploymentKitError("Local Docker image inventory failed: " + (images_result.stderr or images_result.stdout).strip())
+        raise DeploymentKitError(
+            "Local Docker image inventory failed: " + (images_result.stderr or images_result.stdout).strip()
+        )
     image_refs = sorted(
         {
             line.strip()
@@ -226,8 +237,9 @@ def tear_down_workstation_package(package: str) -> dict[str, Any]:
     if image_refs:
         removed = _run_local([docker, "image", "rm", "-f", *image_refs])
         if removed.returncode != 0:
-            raise DeploymentKitError("Local POC image removal failed: " + (removed.stderr or removed.stdout).strip())
-
+            raise DeploymentKitError(
+                "Local POC image removal failed: " + (removed.stderr or removed.stdout).strip()
+            )
     return {
         "state": "removed" if containers or image_refs else "absent",
         "mutated": bool(containers or image_refs),
@@ -243,6 +255,7 @@ def tear_down_poc(spec: dict[str, Any]) -> dict[str, Any]:
         scope=spec.get("scope"),
         environment_targets=(spec.get("environmentTargets") or {}).items(),
         local_package=spec.get("localPackage"),
+        production_environments=spec.get("productionEnvironments") or (),
     )
 
     environments: list[dict[str, Any]] = []
@@ -266,18 +279,19 @@ def tear_down_poc(spec: dict[str, Any]) -> dict[str, Any]:
         )
 
     workstation: dict[str, Any] = {"state": "not-selected", "mutated": False}
-    if normalized["scope"] in {"local", "all"}:
+    if normalized["scope"] in {"local", "all"} and normalized["localPackage"] is not None:
         workstation = tear_down_workstation_package(normalized["localPackage"])
         mutated = mutated or workstation["mutated"]
 
     return {
-        "schemaVersion": 1,
+        "schemaVersion": 2,
         "ownerRepo": normalized["ownerRepo"],
         "appSlug": normalized["appSlug"],
         "scope": normalized["scope"],
         "environments": environments,
         "workstation": workstation,
-        "productionDataIncluded": normalized["scope"] in {"production", "all"},
+        "productionEnvironments": normalized["productionEnvironments"],
+        "productionDataIncluded": bool(normalized["productionEnvironments"]),
         "mutated": mutated,
     }
 

package/assets/generated/deployment/src/lean_poc_deployment/teardown_cli.py

@@ -8,7 +8,6 @@ import sys
 from .errors import DeploymentKitError
 from .teardown import (
     PRODUCTION_DATA_DELETE_PHRASE,
-    SUPPORTED_SCOPES,
     TEAR_DOWN_WRITE_PHRASE,
     normalize_teardown_spec,
     parse_environment_targets,
@@ -21,11 +20,15 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         prog="lean-poc-deploy tear-down",
         description=(
-            "Remove the selected Kit-managed POC environment(s) and/or exact-package local Docker state. "
-            "Remote tear-down deletes persistent application data for the selected environment."
+            "Remove one named Kit-managed environment, all explicitly bound environments, "
+            "and/or exact-package local Docker state. Remote tear-down deletes persistent "
+            "application data for selected environments."
         ),
     )
-    parser.add_argument("scope", choices=SUPPORTED_SCOPES)
+    parser.add_argument(
+        "scope",
+        help="local, all, or one exact named environment such as demo, staging, qa, or production",
+    )
     parser.add_argument("--owner-repo", required=True)
     parser.add_argument("--app-slug", required=True)
     parser.add_argument(
@@ -33,11 +36,24 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         action="append",
         default=[],
         metavar="ENV=TARGET",
-        help="Explicit staging/production environment-to-target binding; repeat as needed by the selected scope.",
+        help="Explicit named environment-to-target binding; repeat as needed.",
+    )
+    parser.add_argument(
+        "--production-environment",
+        action="append",
+        default=[],
+        metavar="ENV",
+        help=(
+            "Classify an additional named environment as Production for the stronger data-deletion gate. "
+            "The literal 'production' environment is always Production."
+        ),
     )
     parser.add_argument(
         "--local-package",
-        help="Exact local Docker package identity, e.g. ghcr.io/owner/package; required for local and all scopes.",
+        help=(
+            "Exact local Docker package identity, e.g. ghcr.io/owner/package. "
+            "Required for local; optional for all."
+        ),
     )
     parser.add_argument(
         "--authorization",
@@ -46,7 +62,7 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser.add_argument(
         "--production-data-authorization",
         help=(
-            "Additional phrase required for production/all because persistent Production data is deleted: "
+            "Additional phrase required whenever selected environments include Production data: "
             f"{PRODUCTION_DATA_DELETE_PHRASE}"
         ),
     )
@@ -54,14 +70,15 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
 
 
 def _preview(spec: dict[str, object]) -> dict[str, object]:
-    production = spec["scope"] in {"production", "all"}
+    production = bool(spec["productionEnvironments"])
     return {
-        "schemaVersion": 1,
+        "schemaVersion": 2,
         "ownerRepo": spec["ownerRepo"],
         "appSlug": spec["appSlug"],
         "scope": spec["scope"],
         "environmentTargets": spec["environmentTargets"],
         "localPackage": spec["localPackage"],
+        "productionEnvironments": spec["productionEnvironments"],
         "destructive": True,
         "deletesPersistentData": bool(spec["environmentTargets"]),
         "deletesProductionData": production,
@@ -83,13 +100,15 @@ def main(argv: list[str] | None = None) -> int:
             scope=args.scope,
             environment_targets=bindings,
             local_package=args.local_package,
+            production_environments=args.production_environment,
         )
         preview = _preview(spec)
 
         missing_general = args.authorization != TEAR_DOWN_WRITE_PHRASE
-        needs_production = args.scope in {"production", "all"}
-        missing_production = needs_production and (
-            args.production_data_authorization != PRODUCTION_DATA_DELETE_PHRASE
+        needs_production = bool(spec["productionEnvironments"])
+        missing_production = (
+            needs_production
+            and args.production_data_authorization != PRODUCTION_DATA_DELETE_PHRASE
         )
         if missing_general or missing_production:
             print("POC TEAR-DOWN PREVIEW")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mriekki/lean",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "Public consumer distribution and updater for Lean engineering assets.",
   "type": "module",
   "bin": {