fix: make challenge toggle actually work end-to-end (5 root-cause bugs)

Found by testing a real enable/disable cycle (art, fjb, gift-card):

1. compose_gen always swapped build->image, so a never-built challenge
   produced 'pull access denied for services-<name>'. Now it only reuses
   the image when it exists locally, otherwise keeps build: so
   'docker compose up --build' builds it.
2. Canonical templates use 'build: context: .' (written for the shared
   services/ tree). In the per-team compose that resolves to the team dir
   which has no Dockerfile -> 'failed to read dockerfile'. The renderer
   now rewrites the main service's context to ./<name>.
3. Teams created before the XVI/XVII import had no xvi/xvii subpackages
   under their local challenges/ dir, so the regenerated receiver main.py
   crash-looped on import. gen_receiver_main now mirrors ALL shared
   checkers (native + xvi + xvii) into every team receiver on each sync.
4. systemd Environment= keys can't contain hyphens, so
   CHALLENGE_PORT_GIFT-CARD was silently dropped. Keys are now
   normalized to underscores on both the writer and reader side.
5. Several checkers called 'docker exec' with no timeout; against a
   container with accumulated chall.py zombies that blocks forever and
   stalls the whole SLA loop. Added mandatory timeouts (Phew, Sheesh,
   Carbeat, Poke, Warmup).

Also: enabling a challenge now copies its source tree into each team's
services/ dir (team dirs only held challenges enabled at create_team
time), and the XVII checkers were rewritten to be protocol-aware
(gift-card/gift-voucher are socat TCP, not HTTP) with strict timeouts.

panel/compose_gen.py

@@ -18,6 +18,7 @@ anti-alchemy, tempest-poc) keep their sidecar services.
 """
 import json
 import re
+import subprocess
 from pathlib import Path
 
 BASE = Path("/opt/gemastik18-final")
@@ -47,6 +48,18 @@ def read_template(name: str) -> str:
         raise FileNotFoundError(f"Tidak ada template compose untuk {name} di {p}")
     return p.read_text()
 
+def _image_exists(image_name: str) -> bool:
+    """True if the docker image is already present locally.
+
+    The renderer only swaps a service's `build:` block for `image: services-<name>`
+    when that image actually exists. Otherwise compose would try to PULL a local
+    build artifact and fail with "pull access denied for services-<name>".
+    """
+    r = subprocess.run(["docker", "image", "inspect", image_name],
+                       capture_output=True, text=True, timeout=30)
+    return r.returncode == 0
+
+
 def _parse_services(text: str):
     names = []
     for line in text.splitlines():
@@ -93,10 +106,12 @@ def render_team_compose(idx: int, state: dict) -> str:
         text = re.sub(rf'"({org}):', f'"{tc}:', text)
         text = re.sub(rf'"({org + 22}):', f'"{ts}:', text)
 
-        # --- build: -> image for MAIN only ---
-        # Replace the main service's build block with image: services-<name>.
-        # NB we process by service names, not generic removal, so sidecar
-        # builds survive.
+        # --- build: -> image for MAIN only (only when the image exists) ---
+        # Replace the main service's build block with image: services-<name> so
+        # teams share one image. If that image was never built, KEEP the build
+        # block so `docker compose up --build` builds it instead of trying to
+        # pull a nonexistent local image.
+        use_image = _image_exists(f"services-{name}")
         lines = text.splitlines()
         i = 0
         in_main = False
@@ -112,7 +127,7 @@ def render_team_compose(idx: int, state: dict) -> str:
                 i += 1
                 continue
             # inside a service block
-            if in_main and line.strip() == "build:":
+            if in_main and use_image and line.strip() == "build:":
                 # skip build block (context/args/dockerfile...) until next key at same indent
                 out.append(f"    image: services-{name}")
                 i += 1
@@ -127,6 +142,15 @@ def render_team_compose(idx: int, state: dict) -> str:
         text = re.sub(r"\$PASSWORD_" + str(org) + r"\b", passwords[name], text)
         text = re.sub(r"PASSWORD_" + str(org) + r"\b", passwords[name], text)
 
+        # --- build context -> per-team challenge subdir ---
+        # Canonical templates are written for the SHARED services/ tree where a
+        # challenge's files sit in services/<name>/. The per-team compose lives in
+        # teamN/services/, so a bare `context: .` would resolve to the team dir
+        # (no Dockerfile). Point the MAIN service's build at ./<name>.
+        if re.search(r"^    build:$", text, re.M):
+            text = re.sub(r"^    build:\n      context: \.$",
+                          f"    build:\n      context: ./{name}", text, count=1, flags=re.M)
+
         # --- flag volume normalization ---
         # Replace any ./flag.txt / ../receiver/flags/<name>.txt with the per-team flag mount
         text = re.sub(r"\./flag\.txt(:\w+)?", f"../receiver/flags/{name}.txt", text)

panel/gen_receiver_main.py

@@ -11,6 +11,7 @@ from three packages:
 from __future__ import annotations
 
 import json
+import shutil
 from pathlib import Path
 
 from teams import TEAMS_DIR, load_registry
@@ -98,26 +99,33 @@ app = FastAPI()
 security = HTTPBasic()
 settings = get_settings()
 
+def _envkey(name: str) -> str:
+    # systemd Environment= keys can't contain hyphens; gen_receiver_services
+    # writes CHALLENGE_PORT_GIFT_CARD for the challenge "gift-card".
+    return name.upper().replace("-", "_")
+
 def _ch_port(name: str, default: int) -> int:
     # read from .env manually (pydantic settings has fixed fields)
-    val = os.environ.get(f"CHALLENGE_PORT_{{name.upper()}}")
+    key = _envkey(name)
+    val = os.environ.get(f"CHALLENGE_PORT_{{key}}")
     if not val:
         try:
             with open(os.path.join(os.path.dirname(__file__), ".env")) as f:
                 for line in f:
-                    if line.startswith(f"CHALLENGE_PORT_{{name.upper()}}="):
+                    if line.startswith(f"CHALLENGE_PORT_{{key}}="):
                         val = line.strip().split("=", 1)[1]
         except Exception:
             pass
     return int(val) if val else default
 
 def _ch_container(name: str, default: str) -> str:
-    val = os.environ.get(f"CHALLENGE_CONTAINER_{{name.upper()}}")
+    key = _envkey(name)
+    val = os.environ.get(f"CHALLENGE_CONTAINER_{{key}}")
     if not val:
         try:
             with open(os.path.join(os.path.dirname(__file__), ".env")) as f:
                 for line in f:
-                    if line.startswith(f"CHALLENGE_CONTAINER_{{name.upper()}}="):
+                    if line.startswith(f"CHALLENGE_CONTAINER_{{key}}="):
                         val = line.strip().split("=", 1)[1]
         except Exception:
             pass
@@ -253,6 +261,32 @@ def validate(credentials, challenge):
 """
 
 
+def _sync_checker_packages(recv_dir) -> None:
+    """Mirror the shared receiver's challenge checkers into a team receiver.
+
+    Two reasons this must run on every sync, not just at create_team time:
+      1. Teams created before the XVI/XVII import have no xvi/xvii subpackages,
+         so a regenerated main.py that imports them would crash-loop the receiver.
+      2. Native checkers (Blogpost/Phew/...) get bug fixes (e.g. mandatory
+         subprocess timeouts); a team copy made earlier keeps the stale version.
+    """
+    shared_challenges = Path("/opt/gemastik18-final/receiver/challenges")
+    dst_root = recv_dir / "challenges"
+    dst_root.mkdir(parents=True, exist_ok=True)
+    for src_file in sorted(shared_challenges.glob("*.py")):
+        if src_file.name == "__init__.py":
+            continue
+        shutil.copy2(src_file, dst_root / src_file.name)
+    for pkg in ("xvi", "xvii"):
+        src = shared_challenges / pkg
+        if not src.exists():
+            continue
+        dst = dst_root / pkg
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.copytree(src, dst, ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+
+
 def sync_team_receivers() -> None:
     """Regenerate main.py for every existing team from its state + registry."""
     for d in sorted(TEAMS_DIR.glob("team*")):
@@ -262,6 +296,7 @@ def sync_team_receivers() -> None:
         st = json.loads(sf.read_text())
         idx = st["index"]
         enabled = [c for c in load_registry()["challenges"] if c.get("enabled")]
+        _sync_checker_packages(d / "receiver")
         text = render_receiver_main(enabled, {c["name"]: st["ports"][c["name"]]["chall"] for c in enabled})
         (d / "receiver" / "main.py").write_text(text)
         print(f"team{idx}: receiver main.py regenerated ({len(enabled)} challenges)")

panel/gen_receiver_services.py

@@ -19,12 +19,16 @@ def write_unit(idx: int, st: dict):
     port = st["ports"]["receiver"]
     recv_dir = TEAMS_DIR / f"team{idx}" / "receiver"
     env = {}
-    # ports/containers for challenge classes
+    # ports/containers for challenge classes.
+    # NOTE: systemd Environment= keys must be [A-Za-z0-9_]+ — a hyphen in the
+    # challenge name (gift-card) would make systemd silently drop the line, so
+    # normalize the name to underscores here. main.py looks up the same key.
     for ch in st["ports"]:
         if ch in ("receiver", "panel"):
             continue
-        env[f"CHALLENGE_PORT_{ch.upper()}"] = str(st["ports"][ch]["chall"])
-        env[f"CHALLENGE_CONTAINER_{ch.upper()}"] = f"{ch}_container_team{idx}"
+        key = ch.upper().replace("-", "_")
+        env[f"CHALLENGE_PORT_{key}"] = str(st["ports"][ch]["chall"])
+        env[f"CHALLENGE_CONTAINER_{key}"] = f"{ch}_container_team{idx}"
         # SSH passwords: checker Challenge.credentials() reads PASSWORD_<self.port>
         # where self.port is the team challenge port.
         pwd = st.get("chall_passwords", {}).get(ch)

panel/teams.py

@@ -116,6 +116,20 @@ def sync_challenge_runtime(name: str, enabled: bool) -> dict:
                     name) or f"chall{idx}_{name}_{secrets.token_hex(4)}"
                 # write state BEFORE rendering (render needs ports[name])
                 (sf).write_text(json.dumps(st, indent=2))
+                # Copy the challenge source into the team's services tree so a
+                # `build: context: .` resolves (team dirs only hold challenges
+                # that were enabled at create_team time).
+                team_svc_src = svc_dir / name
+                if not team_svc_src.exists():
+                    src = SERVICES_SRC / name
+                    if not src.exists():
+                        raise FileNotFoundError(f"sumber service tidak ada: {src}")
+                    shutil.copytree(src, team_svc_src,
+                                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".git"))
+                # apt-insecure.conf is needed by every challenge build
+                shared_apt = SERVICES_SRC / "apt-insecure.conf"
+                if shared_apt.exists() and not (team_svc_src / "apt-insecure.conf").exists():
+                    shutil.copy2(shared_apt, team_svc_src / "apt-insecure.conf")
                 # regenerate whole compose (so enabled challenge included),
                 # then bring up just this service
                 new_text = compose_gen.render_team_compose(idx, st)