f3491be63f
soak / runtime / topology 세 캡처는 같은 public host 의 겹치는 시간창이어야 하는데, 지금까지는 운영자가 세 명령을 따로 띄우고 시계를 손으로 맞춰야 했다. 50분짜리 실행에서 한 번 어긋나면 처음부터 다시 해야 하는 취약점이라 한 명령으로 묶었다. 세 캡처를 동시에 시작하고 전부 끝나면 human pack 을 더해 checker 까지 잇는다. 게이트를 약화시키지 않았다. CLI 로 실증한 fail-closed 경계 4종: - 동의/장치 없이 운영 실행 physical_microphone_consent_required exit 2 - human pack 없이 운영 실행 human_voice_gain_pack_required exit 2 - 50분 미만 시간창 production_window_too_short exit 2 - 세 캡처 host 불일치 hosts_must_match:[...] exit 2 --rehearse 는 마이크를 열지 않고(soak 을 --preflight-only 로) 배관만 확인하며 보고서의 gate_closed 는 항상 false 다. 실제 실행 전 실패를 먼저 뽑기 위한 모드다. 기대 provider 기본값은 2026-08-08 결정에 맞춰 local_whisper / melotts 다. 이것으로 G7 에서 기계로 할 수 있는 부분은 끝났다. 남은 것은 코드로 만들 수 없는 둘뿐이다. 명시 동의 하 물리 마이크 50분 발화, 그리고 참가자 30명·독립 평가자 2인의 blind human voice-gain pack. 검증: 오케스트레이터 20/20, SSOT FAIL 0, dashboard E2E 10/10, ruff clean.
335 lines
11 KiB
Python
335 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""G7 외부 종료 증거 3종을 하나의 겹치는 시간창에서 동시에 잡는 오케스트레이터.
|
|
|
|
`check-g7-external-proof.py` 는 네 artifact 를 요구하고, 그 중 세 개는 **같은 public host 의
|
|
겹치는 시간창**이어야 한다. 지금까지는 운영자가 세 명령을 따로 띄우고 시계를 손으로 맞춰야 했다.
|
|
50분짜리 실행에서 그건 한 번 어긋나면 처음부터 다시 해야 하는 종류의 취약점이다.
|
|
|
|
이 스크립트가 하는 일:
|
|
|
|
1. soak / runtime / topology 캡처를 **동시에** 시작하고 전부 끝날 때까지 기다린다.
|
|
2. 세 캡처가 같은 public host 를 보는지 시작 전에 확인한다(fail-closed).
|
|
3. 끝나면 human voice-gain pack 을 더해 `check-g7-external-proof.py` 를 그대로 돌린다.
|
|
|
|
이 스크립트는 게이트를 **약화시키지 않는다**. 물리 마이크 캡처는 `--confirm-physical-capture` 와
|
|
`--microphone-device` 가 둘 다 있어야 시작하고, human pack 은 만들어 주지 않는다. 네 번째 artifact 는
|
|
실제 참가자와 독립 평가자가 있어야 한다.
|
|
|
|
`--rehearse` 는 마이크·사람 없이 배관만 확인하는 모드다. 짧은 시간창으로 세 러너를 실제로 띄워
|
|
인자·경로·산출 파일까지 검증하되, soak 은 `--preflight-only` 로 돌려 장치를 열지 않는다. 실제 50분
|
|
실행 전에 이걸로 먼저 실패를 뽑아내라.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import subprocess
|
|
import sys
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
from typing import Any, Callable, Iterable, Sequence
|
|
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parents[1]
|
|
SCRIPTS = REPO_ROOT / "scripts"
|
|
|
|
SOAK_SCRIPT = SCRIPTS / "soak-public-voice-websocket.py"
|
|
RUNTIME_SCRIPT = SCRIPTS / "capture-g7-runtime-evidence.py"
|
|
TOPOLOGY_SCRIPT = SCRIPTS / "capture-g7-topology-evidence.py"
|
|
CHECKER_SCRIPT = SCRIPTS / "check-g7-external-proof.py"
|
|
|
|
MIN_PRODUCTION_SECONDS = 3_000.0
|
|
RUNTIME_SAMPLE_MARGIN = 1
|
|
|
|
|
|
class WindowError(RuntimeError):
|
|
"""Fail-closed 오케스트레이션 오류."""
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Leg:
|
|
name: str
|
|
argv: list[str]
|
|
output: Path
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class LegResult:
|
|
name: str
|
|
returncode: int
|
|
output: Path
|
|
|
|
@property
|
|
def ok(self) -> bool:
|
|
return self.returncode == 0
|
|
|
|
|
|
def host_of(url: str) -> str:
|
|
from urllib.parse import urlsplit
|
|
|
|
return (urlsplit(url).hostname or "").lower()
|
|
|
|
|
|
def assert_single_host(*urls: str) -> str:
|
|
"""세 캡처가 같은 public host 를 보는지 확인한다."""
|
|
|
|
hosts = {host_of(url) for url in urls if url}
|
|
hosts.discard("")
|
|
if len(hosts) != 1:
|
|
raise WindowError(f"hosts_must_match:{sorted(hosts)}")
|
|
return hosts.pop()
|
|
|
|
|
|
def sample_plan(duration_seconds: float, interval_seconds: float) -> int:
|
|
"""시간창을 덮기에 충분한 샘플 수. 모자라면 겹침 검증이 깨진다."""
|
|
|
|
if duration_seconds <= 0 or interval_seconds <= 0:
|
|
raise WindowError("invalid_sampling_plan")
|
|
return int(duration_seconds // interval_seconds) + RUNTIME_SAMPLE_MARGIN
|
|
|
|
|
|
def build_soak_leg(args: argparse.Namespace, output: Path) -> Leg:
|
|
argv = [
|
|
sys.executable,
|
|
"-X",
|
|
"utf8",
|
|
str(SOAK_SCRIPT),
|
|
"--wss-url",
|
|
args.wss_url,
|
|
"--origin",
|
|
args.origin,
|
|
"--expected-stt-provider",
|
|
args.expected_stt_provider,
|
|
"--expected-stt-model",
|
|
args.expected_stt_model,
|
|
"--expected-tts-provider",
|
|
args.expected_tts_provider,
|
|
"--expected-tts-model",
|
|
args.expected_tts_model,
|
|
"--evidence-output",
|
|
str(output),
|
|
]
|
|
if args.rehearse:
|
|
# 배관 확인 전용. 장치를 열지 않는다.
|
|
argv.append("--preflight-only")
|
|
return Leg("voice_soak_preflight", argv, output)
|
|
if not args.microphone_device or not args.confirm_physical_capture:
|
|
raise WindowError("physical_microphone_consent_required")
|
|
argv += [
|
|
"--microphone-device",
|
|
args.microphone_device,
|
|
"--confirm-physical-capture",
|
|
"--duration-seconds",
|
|
str(args.duration_seconds),
|
|
]
|
|
return Leg("voice_soak", argv, output)
|
|
|
|
|
|
def build_runtime_leg(args: argparse.Namespace, output: Path) -> Leg:
|
|
samples = sample_plan(args.duration_seconds, args.runtime_interval_seconds)
|
|
argv = [
|
|
sys.executable,
|
|
"-X",
|
|
"utf8",
|
|
str(RUNTIME_SCRIPT),
|
|
"--url",
|
|
args.admin_runtime_url,
|
|
"--samples",
|
|
str(samples),
|
|
"--interval-seconds",
|
|
str(args.runtime_interval_seconds),
|
|
"--evidence-output",
|
|
str(output),
|
|
]
|
|
return Leg("runtime", argv, output)
|
|
|
|
|
|
def build_topology_leg(args: argparse.Namespace, output: Path) -> Leg:
|
|
samples = sample_plan(args.duration_seconds, args.topology_interval_seconds)
|
|
argv = [
|
|
sys.executable,
|
|
"-X",
|
|
"utf8",
|
|
str(TOPOLOGY_SCRIPT),
|
|
"--compose-project",
|
|
args.compose_project,
|
|
"--public-host",
|
|
host_of(args.wss_url),
|
|
"--api-container",
|
|
args.api_container,
|
|
"--api-image-digest",
|
|
args.api_image_digest,
|
|
"--caddy-container",
|
|
args.caddy_container,
|
|
"--caddy-image-digest",
|
|
args.caddy_image_digest,
|
|
"--samples",
|
|
str(samples),
|
|
"--interval-seconds",
|
|
str(args.topology_interval_seconds),
|
|
"--evidence-output",
|
|
str(output),
|
|
]
|
|
return Leg("topology", argv, output)
|
|
|
|
|
|
def plan_legs(args: argparse.Namespace, out_dir: Path) -> list[Leg]:
|
|
assert_single_host(args.wss_url, args.origin, args.admin_runtime_url)
|
|
return [
|
|
build_soak_leg(args, out_dir / "voice-soak.json"),
|
|
build_runtime_leg(args, out_dir / "runtime.json"),
|
|
build_topology_leg(args, out_dir / "topology.json"),
|
|
]
|
|
|
|
|
|
def _run(leg: Leg, *, timeout: float, runner: Callable[..., Any]) -> LegResult:
|
|
completed = runner(
|
|
leg.argv,
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=timeout,
|
|
shell=False,
|
|
)
|
|
return LegResult(leg.name, int(completed.returncode), leg.output)
|
|
|
|
|
|
def run_window(
|
|
legs: Sequence[Leg],
|
|
*,
|
|
timeout: float,
|
|
runner: Callable[..., Any] | None = None,
|
|
) -> list[LegResult]:
|
|
"""세 캡처를 동시에 시작한다. 하나가 죽어도 나머지를 끝까지 돌린다."""
|
|
|
|
call = runner or subprocess.run
|
|
with ThreadPoolExecutor(max_workers=len(legs)) as pool:
|
|
futures = [
|
|
pool.submit(_run, leg, timeout=timeout, runner=call) for leg in legs
|
|
]
|
|
return [future.result() for future in futures]
|
|
|
|
|
|
def build_checker_argv(
|
|
results: Sequence[LegResult], human_pack: Path
|
|
) -> list[str]:
|
|
by_name = {result.name: result.output for result in results}
|
|
soak = by_name.get("voice_soak") or by_name.get("voice_soak_preflight")
|
|
if soak is None:
|
|
raise WindowError("soak_evidence_missing")
|
|
return [
|
|
sys.executable,
|
|
"-X",
|
|
"utf8",
|
|
str(CHECKER_SCRIPT),
|
|
"--voice-soak",
|
|
str(soak),
|
|
"--runtime",
|
|
str(by_name["runtime"]),
|
|
"--topology",
|
|
str(by_name["topology"]),
|
|
"--human-voice-gain",
|
|
str(human_pack),
|
|
"--json",
|
|
]
|
|
|
|
|
|
def summarize(
|
|
results: Sequence[LegResult],
|
|
*,
|
|
rehearse: bool,
|
|
checker_returncode: int | None,
|
|
) -> dict[str, Any]:
|
|
return {
|
|
"schema_version": "vignette.g7-external-proof-window.v1",
|
|
"mode": "rehearse" if rehearse else "production",
|
|
"legs": [
|
|
{"name": r.name, "returncode": r.returncode, "evidence": str(r.output)}
|
|
for r in results
|
|
],
|
|
"all_legs_passed": all(r.ok for r in results),
|
|
"checker_returncode": checker_returncode,
|
|
"gate_closed": checker_returncode == 0 and not rehearse,
|
|
"note": (
|
|
"rehearse 는 배관만 확인한다. 게이트는 실제 물리 마이크 50분 실행과 "
|
|
"독립 human voice-gain pack 이 있어야 닫힌다."
|
|
if rehearse
|
|
else "네 artifact 가 모두 통과해야 게이트가 닫힌다."
|
|
),
|
|
}
|
|
|
|
|
|
def build_parser() -> argparse.ArgumentParser:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--wss-url", required=True)
|
|
parser.add_argument("--origin", required=True)
|
|
parser.add_argument("--admin-runtime-url", required=True)
|
|
parser.add_argument("--compose-project", required=True)
|
|
parser.add_argument("--api-container", required=True)
|
|
parser.add_argument("--api-image-digest", required=True)
|
|
parser.add_argument("--caddy-container", required=True)
|
|
parser.add_argument("--caddy-image-digest", required=True)
|
|
parser.add_argument("--expected-stt-provider", default="local_whisper")
|
|
parser.add_argument("--expected-stt-model", default="large-v3")
|
|
parser.add_argument("--expected-tts-provider", default="melotts")
|
|
parser.add_argument("--expected-tts-model", default="melotts-korean")
|
|
parser.add_argument("--microphone-device", default="")
|
|
parser.add_argument("--confirm-physical-capture", action="store_true")
|
|
parser.add_argument("--duration-seconds", type=float, default=MIN_PRODUCTION_SECONDS)
|
|
parser.add_argument("--runtime-interval-seconds", type=float, default=100.0)
|
|
parser.add_argument("--topology-interval-seconds", type=float, default=100.0)
|
|
parser.add_argument("--human-voice-gain", type=Path)
|
|
parser.add_argument("--out-dir", type=Path, required=True)
|
|
parser.add_argument(
|
|
"--rehearse",
|
|
action="store_true",
|
|
help="마이크 없이 배관만 확인한다. 게이트를 닫지 않는다.",
|
|
)
|
|
return parser
|
|
|
|
|
|
def validate(args: argparse.Namespace) -> None:
|
|
if not args.rehearse and args.duration_seconds < MIN_PRODUCTION_SECONDS:
|
|
raise WindowError("production_window_too_short")
|
|
if not args.rehearse and args.human_voice_gain is None:
|
|
raise WindowError("human_voice_gain_pack_required")
|
|
|
|
|
|
def main(argv: Iterable[str] | None = None) -> int:
|
|
args = build_parser().parse_args(list(argv) if argv is not None else None)
|
|
try:
|
|
validate(args)
|
|
args.out_dir.mkdir(parents=True, exist_ok=True)
|
|
legs = plan_legs(args, args.out_dir)
|
|
except WindowError as exc:
|
|
print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False), file=sys.stderr)
|
|
return 2
|
|
|
|
results = run_window(legs, timeout=args.duration_seconds + 900)
|
|
|
|
checker_returncode: int | None = None
|
|
if all(result.ok for result in results) and args.human_voice_gain is not None:
|
|
checker = subprocess.run(
|
|
build_checker_argv(results, args.human_voice_gain),
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
shell=False,
|
|
)
|
|
checker_returncode = checker.returncode
|
|
|
|
report = summarize(
|
|
results, rehearse=args.rehearse, checker_returncode=checker_returncode
|
|
)
|
|
print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
|
|
return 0 if report["all_legs_passed"] else 1
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover - CLI
|
|
raise SystemExit(main())
|