@hunter-harness/workflow-harness 0.2.11 → 0.2.12

package/harness/bundles/java/codex/scripts/harness_plan_finalize.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""Validate and publish a complete Harness plan artifact set transactionally."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import hashlib
+import io
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+import harness_events  # noqa: E402
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+if hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(encoding="utf-8")
+
+SCHEMA_VERSION = 1
+_LINK = re.compile(r"\[[^\]]+\]\(([^)]+)\)")
+
+
+def _result_error(code: str, message: str) -> dict[str, Any]:
+    return {"ok": False, "code": code, "error": message}
+
+
+def _atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, raw_tmp = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=str(path.parent)
+    )
+    tmp = Path(raw_tmp)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+            json.dump(payload, handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(tmp, path)
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+def _frontmatter(text: str) -> dict[str, str] | None:
+    lines = text.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return None
+    data: dict[str, str] = {}
+    for line in lines[1:]:
+        if line.strip() == "---":
+            return data
+        if ":" not in line:
+            return None
+        key, value = line.split(":", 1)
+        data[key.strip()] = value.strip()
+    return None
+
+
+def _artifact_files(staging: Path) -> list[Path]:
+    files: list[Path] = []
+    for path in staging.rglob("*"):
+        if path.is_symlink():
+            raise ValueError(f"PLAN_ARTIFACT_SYMLINK: {path}")
+        if path.is_file():
+            files.append(path)
+    return sorted(files, key=lambda item: item.relative_to(staging).as_posix())
+
+
+def validate_staging(staging: Path, change_name: str) -> dict[str, Any]:
+    staging = staging.resolve()
+    required = {
+        Path("spec") / f"{change_name}-design.md",
+        Path("plans") / f"{change_name}-plan.md",
+        Path("plans") / f"{change_name}-implementation-detail.md",
+        Path("plans") / f"{change_name}-test-scenarios.md",
+        Path("meta") / "gate-policy.json",
+        Path("meta") / "worktree.json",
+    }
+    try:
+        files = _artifact_files(staging)
+    except ValueError as exc:
+        code = str(exc).split(":", 1)[0]
+        return _result_error(code, str(exc))
+    rel_files = {path.relative_to(staging) for path in files}
+    missing = sorted(path.as_posix() for path in required - rel_files)
+    if missing:
+        return _result_error(
+            "PLAN_ARTIFACT_MISSING", "missing required artifacts: " + ", ".join(missing)
+        )
+
+    for path in files:
+        rel = path.relative_to(staging)
+        if rel.parts[0] not in {"spec", "plans", "meta"}:
+            return _result_error(
+                "PLAN_ARTIFACT_PATH_INVALID", f"unexpected artifact root: {rel.as_posix()}"
+            )
+        if path.suffix.lower() == ".json":
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8-sig"))
+            except (OSError, json.JSONDecodeError) as exc:
+                return _result_error(
+                    "PLAN_ARTIFACT_INVALID_JSON", f"{rel.as_posix()}: {exc}"
+                )
+            if not isinstance(payload, dict):
+                return _result_error(
+                    "PLAN_ARTIFACT_INVALID_JSON",
+                    f"{rel.as_posix()}: top-level JSON must be an object",
+                )
+        elif path.suffix.lower() == ".md":
+            try:
+                text = path.read_text(encoding="utf-8-sig")
+            except OSError as exc:
+                return _result_error("PLAN_ARTIFACT_UNREADABLE", str(exc))
+            frontmatter = _frontmatter(text)
+            if frontmatter is None or frontmatter.get("change-name") != change_name:
+                return _result_error(
+                    "PLAN_ARTIFACT_FRONTMATTER_INVALID",
+                    f"{rel.as_posix()}: change-name frontmatter mismatch",
+                )
+            for raw_link in _LINK.findall(text):
+                link = raw_link.strip().split("#", 1)[0]
+                if not link or "://" in link or link.startswith("mailto:"):
+                    continue
+                target = (path.parent / link).resolve()
+                try:
+                    target.relative_to(staging)
+                except ValueError:
+                    return _result_error(
+                        "PLAN_ARTIFACT_REFERENCE_INVALID",
+                        f"{rel.as_posix()}: reference escapes staging: {raw_link}",
+                    )
+                if not target.is_file():
+                    return _result_error(
+                        "PLAN_ARTIFACT_REFERENCE_MISSING",
+                        f"{rel.as_posix()}: missing reference {raw_link}",
+                    )
+
+    digest = hashlib.sha256()
+    artifact_names: list[str] = []
+    for path in files:
+        rel = path.relative_to(staging).as_posix()
+        artifact_names.append(rel)
+        digest.update(rel.encode("utf-8"))
+        digest.update(b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return {
+        "ok": True,
+        "files": artifact_names,
+        "artifactsHash": "sha256:" + digest.hexdigest(),
+    }
+
+
+def _terminal_exists(change_dir: Path, run_id: str, attempt: int) -> bool:
+    try:
+        events = harness_events.load_events(harness_events.events_path(change_dir))
+    except (OSError, ValueError):
+        return False
+    return any(
+        event.get("phase") == "plan"
+        and event.get("type") == "phase.end"
+        and event.get("run_id") == run_id
+        and event.get("attempt") == attempt
+        and str(event.get("status") or "").upper() == "OK"
+        for event in events
+    )
+
+
+def _append_terminal(change_dir: Path, run_id: str, attempt: int) -> tuple[int, str]:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+        code = harness_events.main(
+            [
+                "append",
+                "--change-dir",
+                str(change_dir),
+                "--phase",
+                "plan",
+                "--type",
+                "phase.end",
+                "--status",
+                "OK",
+                "--reason",
+                "plan artifacts validated and published",
+                "--run-id",
+                run_id,
+                "--attempt",
+                str(attempt),
+                "--json",
+            ]
+        )
+    return code, stderr.getvalue().strip()
+
+
+def finalize_plan(
+    change_dir: Path,
+    staging: Path,
+    *,
+    change_name: str,
+    run_id: str,
+    attempt: int,
+) -> dict[str, Any]:
+    change_dir = change_dir.resolve()
+    staging = staging.resolve()
+    validation = validate_staging(staging, change_name)
+    if not validation["ok"]:
+        return validation
+
+    receipt_path = change_dir / "meta" / "plan-finalization.json"
+    lock_path = change_dir / "meta" / "plan-finalize.lock"
+    receipt: dict[str, Any] | None = None
+    if receipt_path.is_file():
+        try:
+            loaded = json.loads(receipt_path.read_text(encoding="utf-8-sig"))
+            receipt = loaded if isinstance(loaded, dict) else None
+        except (OSError, json.JSONDecodeError) as exc:
+            return _result_error("PLAN_FINALIZATION_RECEIPT_INVALID", str(exc))
+        if receipt and receipt.get("artifactsHash") != validation["artifactsHash"]:
+            return _result_error(
+                "PLAN_FINALIZATION_HASH_CONFLICT",
+                "finalizer was already invoked with a different artifact set",
+            )
+        if (
+            receipt
+            and receipt.get("status") == "finalized"
+            and _terminal_exists(change_dir, run_id, attempt)
+        ):
+            return {
+                "ok": True,
+                "action": "finalize",
+                "idempotent": True,
+                "artifactsHash": validation["artifactsHash"],
+                "files": validation["files"],
+                "receiptPath": str(receipt_path),
+            }
+
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        lock_fd = os.open(str(lock_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+        os.close(lock_fd)
+    except FileExistsError:
+        return _result_error("PLAN_FINALIZATION_LOCKED", f"lock exists: {lock_path}")
+
+    created: list[Path] = []
+    terminal_committed = False
+    try:
+        for rel_text in validation["files"]:
+            source = staging / rel_text
+            target = change_dir / rel_text
+            if target.exists() and target.read_bytes() != source.read_bytes():
+                return _result_error(
+                    "PLAN_TARGET_CONFLICT", f"refusing to overwrite {rel_text}"
+                )
+
+        for rel_text in validation["files"]:
+            source = staging / rel_text
+            target = change_dir / rel_text
+            if target.exists():
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            fd, raw_tmp = tempfile.mkstemp(
+                prefix=f".{target.name}.", suffix=".tmp", dir=str(target.parent)
+            )
+            os.close(fd)
+            tmp = Path(raw_tmp)
+            try:
+                shutil.copyfile(source, tmp)
+                os.replace(tmp, target)
+                created.append(target)
+            finally:
+                tmp.unlink(missing_ok=True)
+
+        pending_receipt = {
+            "schemaVersion": SCHEMA_VERSION,
+            "changeName": change_name,
+            "status": "publishing",
+            "artifactsHash": validation["artifactsHash"],
+            "files": validation["files"],
+            "runId": run_id,
+            "attempt": attempt,
+        }
+        _atomic_write_json(receipt_path, pending_receipt)
+        terminal_code, terminal_error = _append_terminal(change_dir, run_id, attempt)
+        terminal_committed = _terminal_exists(change_dir, run_id, attempt)
+        if terminal_code != 0 and not terminal_committed:
+            for target in reversed(created):
+                target.unlink(missing_ok=True)
+            receipt_path.unlink(missing_ok=True)
+            return _result_error(
+                "PLAN_TERMINAL_APPEND_FAILED",
+                terminal_error or "phase.end append failed",
+            )
+        pending_receipt["status"] = "finalized"
+        _atomic_write_json(receipt_path, pending_receipt)
+        return {
+            "ok": True,
+            "action": "finalize",
+            "idempotent": False,
+            "artifactsHash": validation["artifactsHash"],
+            "files": validation["files"],
+            "receiptPath": str(receipt_path),
+            "executionLogPath": str(harness_events.execution_log_path(change_dir)),
+        }
+    except OSError as exc:
+        if terminal_committed or _terminal_exists(change_dir, run_id, attempt):
+            return _result_error(
+                "PLAN_FINALIZATION_RECOVERY_REQUIRED",
+                f"terminal committed; retry finalization to complete receipt: {exc}",
+            )
+        for target in reversed(created):
+            target.unlink(missing_ok=True)
+        receipt_path.unlink(missing_ok=True)
+        return _result_error("PLAN_FINALIZATION_IO_ERROR", str(exc))
+    finally:
+        lock_path.unlink(missing_ok=True)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="harness_plan_finalize.py")
+    sub = parser.add_subparsers(dest="command", required=True)
+    finalize = sub.add_parser("finalize")
+    finalize.add_argument("--change-dir", required=True)
+    finalize.add_argument("--staging-dir", required=True)
+    finalize.add_argument("--change", required=True)
+    finalize.add_argument("--run-id", required=True)
+    finalize.add_argument("--attempt", required=True, type=int)
+    finalize.add_argument("--json", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    result = finalize_plan(
+        Path(args.change_dir),
+        Path(args.staging_dir),
+        change_name=args.change,
+        run_id=args.run_id,
+        attempt=args.attempt,
+    )
+    stream = sys.stdout if result["ok"] else sys.stderr
+    if args.json:
+        stream.write(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
+    else:
+        stream.write((result.get("action") or result.get("code") or "error") + "\n")
+    return 0 if result["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/harness/bundles/java/codex/scripts/harness_profile.py

@@ -43,7 +43,9 @@ DEFAULT_EXCLUDED_ROOTS: tuple[str, ...] = (
     ".git",
     ".harness",
     ".claude/worktrees",
+    ".codex/worktrees",
     ".cursor/worktrees",
+    ".codebuddy/worktrees",
     ".codeium/worktrees",
     "target",
     "build",
@@ -134,6 +136,27 @@ def detect_project_type(project: Path) -> str:
     return "unknown"
 
 
+def discover_nested_components(
+    project: Path, excluded: tuple[str, ...] | list[str]
+) -> list[str]:
+    """Return deterministic type:path labels for supported nested projects."""
+    markers = {
+        "pyproject.toml": "python",
+        "package.json": "node",
+        "pom.xml": "java-maven",
+    }
+    found: list[tuple[str, str]] = []
+    for marker, kind in markers.items():
+        for path in project.rglob(marker):
+            if not path.is_file():
+                continue
+            rel = path.relative_to(project)
+            if rel.parent == Path(".") or is_path_excluded(rel.as_posix(), excluded):
+                continue
+            found.append((rel.parent.as_posix(), kind))
+    return [f"{kind}:{rel}" for rel, kind in sorted(set(found))]
+
+
 def which_tool(name: str) -> str:
     found = shutil.which(name)
     if found:
@@ -386,6 +409,32 @@ def detect(project: Path) -> dict[str, Any]:
     existing = load_profile(project)
     excluded = DEFAULT_EXCLUDED_ROOTS
     project_type = detect_project_type(project)
+    components = discover_nested_components(project, excluded)
+    component_types = {item.split(":", 1)[0] for item in components}
+    if project_type != "unknown":
+        component_types.add(project_type)
+    if (project_type == "unknown" and components) or len(component_types) > 1:
+        return {
+            "ok": False,
+            "code": "DETECTION_AMBIGUOUS",
+            "action": "detect",
+            "project": str(project),
+            "profilePath": str(project / PROFILE_REL),
+            "applied": False,
+            "detectedComponents": components,
+            "message": "multiple or nested project components require an explicit profile",
+        }
+    if project_type == "unknown" and existing:
+        return {
+            "ok": False,
+            "code": "DETECTION_INCONCLUSIVE",
+            "action": "detect",
+            "project": str(project),
+            "profilePath": str(project / PROFILE_REL),
+            "applied": False,
+            "detectedComponents": [],
+            "message": "detection was inconclusive; existing profile was preserved",
+        }
 
     profile = empty_profile_skeleton(excluded)
     profile["projectType"] = project_type
@@ -439,6 +488,7 @@ def detect(project: Path) -> dict[str, Any]:
         "profile": profile,
         "created": existing is None,
         "updated": True,
+        "applied": True,
     }
 
 

package/harness/bundles/java/codex/scripts/harness_runtime.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""Resolve Harness runtimes into a reusable, argv-based phase capsule."""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Callable
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+if hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(encoding="utf-8")
+
+SCHEMA_VERSION = 1
+_CHANGE_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+_ADAPTERS = {
+    "claude-code": (".claude/worktrees", "claude/"),
+    "codex": (".codex/worktrees", "codex/"),
+    "cursor": (".cursor/worktrees", "cursor/"),
+    "codebuddy": (".codebuddy/worktrees", "codebuddy/"),
+}
+
+
+def now_iso() -> str:
+    return dt.datetime.now().astimezone().isoformat(timespec="milliseconds")
+
+
+def atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(payload, ensure_ascii=False, indent=2) + "\n"
+    fd, raw_tmp = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=str(path.parent)
+    )
+    tmp = Path(raw_tmp)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(tmp, path)
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+def adapter_worktree(agent: str, change_id: str) -> dict[str, str]:
+    if agent not in _ADAPTERS:
+        raise ValueError(f"ADAPTER_UNKNOWN: {agent}")
+    if not _CHANGE_ID.fullmatch(change_id) or change_id in {".", ".."}:
+        raise ValueError(f"ADAPTER_CHANGE_ID_INVALID: {change_id}")
+    root, prefix = _ADAPTERS[agent]
+    return {
+        "agent": agent,
+        "worktreeRoot": root,
+        "path": f"{root}/{change_id}",
+        "branchPrefix": prefix,
+        "branch": f"{prefix}{change_id}",
+    }
+
+
+def _absolute_executable(value: str | Path) -> str:
+    return str(Path(value).expanduser().resolve())
+
+
+def _run_version(executable: str, *args: str) -> dict[str, Any]:
+    try:
+        proc = subprocess.run(
+            [executable, *args],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return {"available": False, "error": str(exc)}
+    version = (proc.stdout or proc.stderr).strip().splitlines()
+    return {
+        "available": proc.returncode == 0,
+        "version": version[0] if version else "",
+        "exitCode": proc.returncode,
+    }
+
+
+def probe_powershell(
+    executable: Path,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    """Probe Windows PowerShell/Pwsh without relying on PowerShell 6 Test-Json."""
+    script = (
+        "$value = [ordered]@{"
+        "edition = [string]$PSVersionTable.PSEdition;"
+        "version = [string]$PSVersionTable.PSVersion.ToString()"
+        "}; $value | ConvertTo-Json -Compress"
+    )
+    argv = [
+        _absolute_executable(executable),
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        script,
+    ]
+    try:
+        proc = runner(
+            argv,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            timeout=10,
+        )
+        if proc.returncode != 0:
+            return {
+                "available": False,
+                "executable": argv[0],
+                "argvPrefix": [argv[0], "-NoLogo", "-NoProfile", "-NonInteractive"],
+                "error": proc.stderr.strip(),
+                "jsonCapability": "convert-to-json",
+            }
+        raw = json.loads(proc.stdout.strip())
+        return {
+            "available": True,
+            "executable": argv[0],
+            "argvPrefix": [argv[0], "-NoLogo", "-NoProfile", "-NonInteractive"],
+            "edition": str(raw.get("edition") or "Desktop"),
+            "version": str(raw.get("version") or ""),
+            "jsonCapability": "convert-to-json",
+        }
+    except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError) as exc:
+        return {
+            "available": False,
+            "executable": argv[0],
+            "argvPrefix": [argv[0], "-NoLogo", "-NoProfile", "-NonInteractive"],
+            "error": str(exc),
+            "jsonCapability": "convert-to-json",
+        }
+
+
+def _optional_runtime(name: str, version_arg: str = "--version") -> dict[str, Any]:
+    found = shutil.which(name)
+    if not found:
+        return {"available": False, "executable": None, "argvPrefix": []}
+    executable = _absolute_executable(found)
+    return {
+        "executable": executable,
+        "argvPrefix": [executable],
+        **_run_version(executable, version_arg),
+    }
+
+
+def doctor(project: Path, change_dir: Path, *, agent: str) -> dict[str, Any]:
+    project = project.expanduser().resolve()
+    change_dir = change_dir.expanduser().resolve()
+    python_executable = _absolute_executable(sys.executable)
+    python_version = _run_version(python_executable, "--version")
+
+    powershell_path = shutil.which("pwsh") or shutil.which("powershell")
+    powershell = (
+        probe_powershell(Path(powershell_path))
+        if powershell_path
+        else {
+            "available": False,
+            "executable": None,
+            "argvPrefix": [],
+            "edition": None,
+            "version": None,
+            "jsonCapability": "python-json",
+        }
+    )
+    sample = {"path": "E:/示例/计划", "ok": True}
+    json_round_trip = json.loads(json.dumps(sample, ensure_ascii=False)) == sample
+    payload = {
+        "schemaVersion": SCHEMA_VERSION,
+        "generatedAt": now_iso(),
+        "projectRoot": str(project),
+        "changeDir": str(change_dir),
+        "adapter": adapter_worktree(agent, change_dir.name),
+        "runtimes": {
+            "python": {
+                "available": python_version.get("available", True),
+                "executable": python_executable,
+                "argvPrefix": [python_executable],
+                "version": python_version.get("version") or sys.version.split()[0],
+                "stdioEncoding": "utf-8",
+                "filesystemEncoding": sys.getfilesystemencoding(),
+            },
+            "node": _optional_runtime("node"),
+            "powershell": powershell,
+        },
+        "capabilities": {
+            "jsonRoundTrip": json_round_trip,
+            "argvArrays": True,
+            "utf8NoBom": True,
+        },
+    }
+    atomic_write_json(change_dir / "meta" / "runtime.json", payload)
+    return {"ok": True, "action": "doctor", **payload}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="harness_runtime.py")
+    sub = parser.add_subparsers(dest="command", required=True)
+    p_doctor = sub.add_parser("doctor")
+    p_doctor.add_argument("--project", required=True)
+    p_doctor.add_argument("--change-dir", required=True)
+    p_doctor.add_argument("--agent", choices=sorted(_ADAPTERS), required=True)
+    p_doctor.add_argument("--json", action="store_true")
+    p_adapter = sub.add_parser("adapter")
+    p_adapter.add_argument("--agent", choices=sorted(_ADAPTERS), required=True)
+    p_adapter.add_argument("--change", required=True)
+    p_adapter.add_argument("--json", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "doctor":
+            result = doctor(Path(args.project), Path(args.change_dir), agent=args.agent)
+        else:
+            result = {"ok": True, "action": "adapter", **adapter_worktree(args.agent, args.change)}
+    except (OSError, ValueError) as exc:
+        code = str(exc).split(":", 1)[0]
+        result = {"ok": False, "code": code, "error": str(exc)}
+        stream = sys.stderr
+        stream.write(json.dumps(result, ensure_ascii=False) + "\n")
+        return 1
+    if args.json:
+        sys.stdout.write(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
+    else:
+        sys.stdout.write(str(result.get("action")) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())