@leejungkiin/awkit 1.7.1 → 1.7.4

package/skills/hatch-pet/scripts/queue_pet_repairs.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Reopen failed Codex pet row jobs after frame QA."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def load_json(path: Path) -> dict[str, object]:
+    if not path.exists():
+        raise SystemExit(f"file not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def rows_to_repair(
+    review: dict[str, object], *, repair_on_warnings: bool
+) -> list[dict[str, object]]:
+    rows = review.get("rows")
+    if not isinstance(rows, list):
+        raise SystemExit("review does not contain row-level results")
+
+    repairs: list[dict[str, object]] = []
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("state"), str):
+            continue
+        errors = row.get("errors") if isinstance(row.get("errors"), list) else []
+        warnings = row.get("warnings") if isinstance(row.get("warnings"), list) else []
+        if errors or (repair_on_warnings and warnings):
+            repairs.append(
+                {
+                    "state": row["state"],
+                    "reason": "; ".join(str(item) for item in [*errors, *warnings])
+                    or "the row did not pass visual QA",
+                }
+            )
+    return repairs
+
+
+def append_repair_note(run_dir: Path, state: str, attempt: int, reason: str) -> None:
+    prompt_path = run_dir / "prompts" / "rows" / f"{state}.md"
+    if not prompt_path.exists():
+        raise SystemExit(f"row prompt not found: {prompt_path}")
+    existing = prompt_path.read_text(encoding="utf-8")
+    note = f"""
+
+Repair attempt {attempt}:
+- The previous `{state}` strip failed QA: {reason}
+- Regenerate the entire row, not just one pose.
+- Fill every requested frame slot with one complete centered full-body pet pose.
+- Keep large gaps of pure chroma key only between slots; do not leave a requested slot empty.
+- Avoid pose overlap, clipping, edge slivers, extra partial sprites, and detached fragments from neighboring poses.
+- Use the canonical base image and any original references listed in `imagegen-jobs.json` as grounding inputs.
+- Do not redesign the pet. Keep the exact same head shape, face design, markings, body proportions, palette, outline weight, materials, and props as the approved base pet.
+- If the contact sheet shows identity drift, repair only this row while preserving the canonical base identity.
+"""
+    prompt_path.write_text(existing.rstrip() + note.rstrip() + "\n", encoding="utf-8")
+
+
+def job_list(manifest: dict[str, object]) -> list[dict[str, object]]:
+    jobs = manifest.get("jobs")
+    if not isinstance(jobs, list):
+        raise SystemExit("invalid imagegen-jobs.json: jobs must be a list")
+    return [job for job in jobs if isinstance(job, dict)]
+
+
+def next_archive_path(archive_dir: Path, state: str, attempt: int, suffix: str) -> Path:
+    candidate = archive_dir / f"{state}-attempt-{attempt}-previous{suffix}"
+    if not candidate.exists():
+        return candidate
+    counter = 2
+    while True:
+        candidate = archive_dir / f"{state}-attempt-{attempt}-previous-{counter}{suffix}"
+        if not candidate.exists():
+            return candidate
+        counter += 1
+
+
+def archive_decoded_output(run_dir: Path, job: dict[str, object], state: str, attempt: int) -> str | None:
+    output_raw = job.get("output_path")
+    output = (
+        run_dir / output_raw
+        if isinstance(output_raw, str) and output_raw
+        else run_dir / "decoded" / f"{state}.png"
+    )
+    if not output.exists():
+        return None
+    archive_dir = run_dir / "decoded" / "repair-archive"
+    archive_dir.mkdir(parents=True, exist_ok=True)
+    archived = next_archive_path(archive_dir, state, attempt, output.suffix or ".png")
+    shutil.move(str(output), archived)
+    return str(archived.relative_to(run_dir))
+
+
+def queue_repair(manifest: dict[str, object], run_dir: Path, state: str, reason: str) -> dict[str, object]:
+    for job in job_list(manifest):
+        if job.get("id") != state:
+            continue
+        attempt = int(job.get("repair_attempt", 0)) + 1
+        archived_output = archive_decoded_output(run_dir, job, state, attempt)
+        job["status"] = "pending"
+        job["repair_attempt"] = attempt
+        job["repair_reason"] = reason
+        job["queued_at"] = datetime.now(timezone.utc).isoformat()
+        if archived_output is not None:
+            previous_outputs = job.setdefault("previous_outputs", [])
+            if not isinstance(previous_outputs, list):
+                previous_outputs = []
+                job["previous_outputs"] = previous_outputs
+            previous_outputs.append(
+                {
+                    "attempt": attempt,
+                    "path": archived_output,
+                    "archived_at": job["queued_at"],
+                }
+            )
+        for key in [
+            "source_path",
+            "source_provenance",
+            "source_sha256",
+            "output_sha256",
+            "completed_at",
+            "metadata",
+            "synthetic_test_source",
+            "secondary_fallback",
+            "derived_from",
+            "mirror_decision",
+        ]:
+            job.pop(key, None)
+        result: dict[str, object] = {"attempt": attempt}
+        if archived_output is not None:
+            result["archived_output"] = archived_output
+        return result
+    raise SystemExit(f"unknown row job id: {state}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run-dir", required=True)
+    parser.add_argument("--review", default="")
+    parser.add_argument("--repair-on-warnings", action="store_true")
+    args = parser.parse_args()
+
+    run_dir = Path(args.run_dir).expanduser().resolve()
+    review_path = (
+        Path(args.review).expanduser().resolve()
+        if args.review
+        else run_dir / "qa" / "review.json"
+    )
+    manifest_path = run_dir / "imagegen-jobs.json"
+    review = load_json(review_path)
+    manifest = load_json(manifest_path)
+
+    repairs = rows_to_repair(review, repair_on_warnings=args.repair_on_warnings)
+    queued: list[dict[str, object]] = []
+    for repair in repairs:
+        state = str(repair["state"])
+        reason = str(repair["reason"])
+        queued_repair = queue_repair(manifest, run_dir, state, reason)
+        attempt = int(queued_repair["attempt"])
+        append_repair_note(run_dir, state, attempt, reason)
+        queued.append({"state": state, "reason": reason, **queued_repair})
+
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"ok": True, "queued": queued}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/skills/hatch-pet/scripts/record_imagegen_result.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Record a selected $imagegen output for a Codex pet generation job."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+from PIL import Image
+
+CANONICAL_BASE_PATH = "references/canonical-base.png"
+
+
+def load_jobs(path: Path) -> dict[str, object]:
+    if not path.exists():
+        raise SystemExit(f"job manifest not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def job_list(manifest: dict[str, object]) -> list[dict[str, object]]:
+    jobs = manifest.get("jobs")
+    if not isinstance(jobs, list):
+        raise SystemExit("invalid imagegen-jobs.json: jobs must be a list")
+    return [job for job in jobs if isinstance(job, dict)]
+
+
+def find_job(manifest: dict[str, object], job_id: str) -> dict[str, object]:
+    for job in job_list(manifest):
+        if job.get("id") == job_id:
+            return job
+    raise SystemExit(f"unknown job id: {job_id}")
+
+
+def image_metadata(path: Path) -> dict[str, object]:
+    with Image.open(path) as image:
+        image.verify()
+    with Image.open(path) as image:
+        return {
+            "width": image.width,
+            "height": image.height,
+            "mode": image.mode,
+            "format": image.format,
+        }
+
+
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as file:
+        for chunk in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def manifest_relative(path: Path, run_dir: Path) -> str:
+    return str(path.resolve().relative_to(run_dir.resolve()))
+
+
+def completed_job_ids(manifest: dict[str, object]) -> set[str]:
+    return {
+        str(job["id"])
+        for job in job_list(manifest)
+        if job.get("status") == "complete" and isinstance(job.get("id"), str)
+    }
+
+
+def is_relative_to(path: Path, root: Path) -> bool:
+    try:
+        path.relative_to(root)
+    except ValueError:
+        return False
+    return True
+
+
+def default_generated_images_root() -> Path:
+    codex_home = Path(os.environ.get("CODEX_HOME") or "~/.codex").expanduser().resolve()
+    return codex_home / "generated_images"
+
+
+def validate_source_path(
+    *,
+    source: Path,
+    run_dir: Path,
+    allow_synthetic_test_source: bool,
+) -> str:
+    if allow_synthetic_test_source:
+        return "synthetic-test"
+    if is_relative_to(source, run_dir):
+        raise SystemExit(
+            "source image is inside the pet run directory; record the original "
+            "$imagegen output from $CODEX_HOME/generated_images/.../ig_*.png instead"
+        )
+    generated_root = default_generated_images_root()
+    if not is_relative_to(source, generated_root) or not source.name.startswith("ig_"):
+        raise SystemExit(
+            "source image does not look like a built-in $imagegen output; expected "
+            f"{generated_root}/.../ig_*.png. Do not ingest locally drawn or "
+            "post-processed row strips as visual job outputs."
+        )
+    return "built-in-imagegen"
+
+
+def validate_required_grounding(job: dict[str, object], run_dir: Path) -> None:
+    if job.get("allow_prompt_only_generation") is not False:
+        return
+    inputs = job.get("input_images")
+    if not isinstance(inputs, list) or not inputs:
+        raise SystemExit(
+            f"job {job.get('id')} does not list input_images; grounded row jobs must attach references"
+        )
+    missing = []
+    for item in inputs:
+        if not isinstance(item, dict) or not isinstance(item.get("path"), str):
+            raise SystemExit(f"job {job.get('id')} has an invalid input image entry")
+        path = run_dir / item["path"]
+        if not path.is_file():
+            missing.append(str(path))
+    if missing:
+        raise SystemExit(
+            f"job {job.get('id')} is missing required grounding image(s): "
+            + ", ".join(missing)
+        )
+
+
+def update_base_canonical_reference(
+    *,
+    run_dir: Path,
+    output: Path,
+    manifest: dict[str, object],
+    job: dict[str, object],
+    metadata: dict[str, object],
+) -> None:
+    if job.get("id") != "base":
+        return
+
+    canonical = run_dir / CANONICAL_BASE_PATH
+    canonical.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(output, canonical)
+    canonical_sha = file_sha256(canonical)
+    reference = {
+        "path": manifest_relative(canonical, run_dir),
+        "source_job": "base",
+        "sha256": canonical_sha,
+        "metadata": metadata,
+    }
+    job["canonical_reference_path"] = reference["path"]
+    manifest["canonical_identity_reference"] = reference
+
+    request_path = run_dir / "pet_request.json"
+    if request_path.exists():
+        request = json.loads(request_path.read_text(encoding="utf-8"))
+        request["canonical_identity_reference"] = reference
+        request_path.write_text(json.dumps(request, indent=2) + "\n", encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run-dir", required=True)
+    parser.add_argument("--job-id", required=True)
+    parser.add_argument("--source", required=True)
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument(
+        "--allow-synthetic-test-source", action="store_true", help=argparse.SUPPRESS
+    )
+    args = parser.parse_args()
+
+    run_dir = Path(args.run_dir).expanduser().resolve()
+    source = Path(args.source).expanduser().resolve()
+    if not source.is_file():
+        raise SystemExit(f"source image not found: {source}")
+    source_provenance = validate_source_path(
+        source=source,
+        run_dir=run_dir,
+        allow_synthetic_test_source=args.allow_synthetic_test_source,
+    )
+
+    manifest_path = run_dir / "imagegen-jobs.json"
+    manifest = load_jobs(manifest_path)
+    job = find_job(manifest, args.job_id)
+
+    missing_deps = [
+        dep
+        for dep in job.get("depends_on", [])
+        if isinstance(dep, str) and dep not in completed_job_ids(manifest)
+    ]
+    if missing_deps:
+        raise SystemExit(
+            f"job {args.job_id} is not ready; missing dependency result(s): {', '.join(missing_deps)}"
+        )
+    validate_required_grounding(job, run_dir)
+
+    output_raw = job.get("output_path")
+    if not isinstance(output_raw, str):
+        raise SystemExit(f"job {args.job_id} has no output_path")
+    output = run_dir / output_raw
+    if output.exists() and not args.force:
+        raise SystemExit(f"{output} already exists; pass --force to replace it")
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, output)
+    metadata = image_metadata(output)
+
+    job["status"] = "complete"
+    job["source_path"] = str(source)
+    job["source_provenance"] = source_provenance
+    job["source_sha256"] = file_sha256(source)
+    job["output_sha256"] = file_sha256(output)
+    if source_provenance == "synthetic-test":
+        job["synthetic_test_source"] = True
+    else:
+        job.pop("synthetic_test_source", None)
+    job["completed_at"] = datetime.now(timezone.utc).isoformat()
+    job["metadata"] = metadata
+    for key in [
+        "last_error",
+        "secondary_fallback",
+        "derived_from",
+        "mirror_decision",
+        "repair_reason",
+        "queued_at",
+    ]:
+        job.pop(key, None)
+    update_base_canonical_reference(
+        run_dir=run_dir,
+        output=output,
+        manifest=manifest,
+        job=job,
+        metadata=metadata,
+    )
+
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "job_id": args.job_id,
+                "output": str(output),
+                "metadata": metadata,
+            },
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

package/skills/hatch-pet/scripts/render_animation_videos.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Render Codex pet state videos from an atlas using ffmpeg."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+STATES = {
+    "idle": (0, [280, 110, 110, 140, 140, 320]),
+    "running-right": (1, [120, 120, 120, 120, 120, 120, 120, 220]),
+    "running-left": (2, [120, 120, 120, 120, 120, 120, 120, 220]),
+    "waving": (3, [140, 140, 140, 280]),
+    "jumping": (4, [140, 140, 140, 140, 280]),
+    "failed": (5, [140, 140, 140, 140, 140, 140, 140, 240]),
+    "waiting": (6, [150, 150, 150, 150, 150, 260]),
+    "running": (7, [120, 120, 120, 120, 120, 220]),
+    "review": (8, [150, 150, 150, 150, 150, 280]),
+}
+
+
+def checker(size: tuple[int, int], square: int = 16) -> Image.Image:
+    image = Image.new("RGB", size, "#ffffff")
+    draw = ImageDraw.Draw(image)
+    for y in range(0, size[1], square):
+        for x in range(0, size[0], square):
+            if (x // square + y // square) % 2:
+                draw.rectangle((x, y, x + square - 1, y + square - 1), fill="#e8e8e8")
+    return image
+
+
+def shell_quote_for_concat(path: Path) -> str:
+    return "'" + str(path).replace("'", "'\\''") + "'"
+
+
+def render_state(
+    atlas: Image.Image,
+    state: str,
+    row: int,
+    durations: list[int],
+    output_dir: Path,
+    loops: int,
+    scale: int,
+    ffmpeg: str,
+) -> None:
+    with tempfile.TemporaryDirectory(prefix=f"codex-pet-{state}-") as temp_raw:
+        temp = Path(temp_raw)
+        frame_paths: list[Path] = []
+        for column in range(len(durations)):
+            crop = atlas.crop(
+                (
+                    column * CELL_WIDTH,
+                    row * CELL_HEIGHT,
+                    (column + 1) * CELL_WIDTH,
+                    (row + 1) * CELL_HEIGHT,
+                )
+            ).convert("RGBA")
+            bg = checker((CELL_WIDTH, CELL_HEIGHT))
+            bg.paste(crop, (0, 0), crop)
+            frame_path = temp / f"{state}-{column:02d}.png"
+            bg.save(frame_path)
+            frame_paths.append(frame_path)
+
+        concat_path = temp / f"{state}.ffconcat"
+        lines = ["ffconcat version 1.0"]
+        sequence: list[tuple[Path, int]] = []
+        for _ in range(loops):
+            sequence.extend(zip(frame_paths, durations, strict=True))
+        for frame_path, duration_ms in sequence:
+            lines.append(f"file {shell_quote_for_concat(frame_path)}")
+            lines.append(f"duration {duration_ms / 1000:.3f}")
+        lines.append(f"file {shell_quote_for_concat(sequence[-1][0])}")
+        concat_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+        output = output_dir / f"{state}.mp4"
+        command = [
+            ffmpeg,
+            "-y",
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+            "-i",
+            str(concat_path),
+            "-vf",
+            f"scale={CELL_WIDTH * scale}:{CELL_HEIGHT * scale}:flags=lanczos,format=yuv420p",
+            "-movflags",
+            "+faststart",
+            str(output),
+        ]
+        subprocess.run(command, check=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--loops", type=int, default=4)
+    parser.add_argument("--scale", type=int, default=2)
+    parser.add_argument("--ffmpeg", default=shutil.which("ffmpeg") or "ffmpeg")
+    args = parser.parse_args()
+
+    output_dir = Path(args.output_dir).expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    with Image.open(Path(args.atlas).expanduser().resolve()) as opened:
+        atlas = opened.convert("RGBA")
+
+    for state, (row, durations) in STATES.items():
+        render_state(
+            atlas,
+            state,
+            row,
+            durations,
+            output_dir,
+            args.loops,
+            args.scale,
+            args.ffmpeg,
+        )
+    print(f"wrote videos to {output_dir}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/hatch-pet/scripts/render_animation_videos.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+python3 "$SCRIPT_DIR/render_animation_videos.py" "$@"

package/skills/hatch-pet/scripts/validate_atlas.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""Validate a Codex pet spritesheet atlas."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+from PIL import Image
+
+COLUMNS = 8
+ROWS = 9
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+ATLAS_WIDTH = COLUMNS * CELL_WIDTH
+ATLAS_HEIGHT = ROWS * CELL_HEIGHT
+ROW_BY_INDEX = {
+    0: ("idle", 6),
+    1: ("running-right", 8),
+    2: ("running-left", 8),
+    3: ("waving", 4),
+    4: ("jumping", 5),
+    5: ("failed", 8),
+    6: ("waiting", 6),
+    7: ("running", 6),
+    8: ("review", 6),
+}
+
+
+def alpha_nonzero_count(image: Image.Image) -> int:
+    alpha = image.getchannel("A")
+    return sum(alpha.histogram()[1:])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--json-out")
+    parser.add_argument("--min-used-pixels", type=int, default=50)
+    parser.add_argument("--near-opaque-threshold", type=float, default=0.95)
+    parser.add_argument("--allow-opaque", action="store_true")
+    parser.add_argument("--allow-near-opaque-used-cells", action="store_true")
+    args = parser.parse_args()
+
+    atlas_path = Path(args.atlas).expanduser().resolve()
+    errors: list[str] = []
+    warnings: list[str] = []
+    near_opaque_used_cells: dict[str, list[int]] = defaultdict(list)
+    cells: list[dict[str, object]] = []
+
+    try:
+        with Image.open(atlas_path) as opened:
+            source_mode = opened.mode
+            source_format = opened.format
+            image = opened.convert("RGBA")
+    except Exception as exc:  # noqa: BLE001
+        result = {"ok": False, "errors": [f"could not open atlas: {exc}"], "warnings": []}
+        print(json.dumps(result, indent=2))
+        raise SystemExit(1)
+
+    if image.size != (ATLAS_WIDTH, ATLAS_HEIGHT):
+        errors.append(f"expected {ATLAS_WIDTH}x{ATLAS_HEIGHT}, got {image.width}x{image.height}")
+
+    if source_format not in {"PNG", "WEBP"}:
+        errors.append(f"expected PNG or WebP, got {source_format}")
+
+    if "A" not in source_mode and not args.allow_opaque:
+        errors.append("atlas does not have an alpha channel")
+
+    for row_index in range(ROWS):
+        state, frame_count = ROW_BY_INDEX[row_index]
+        for column_index in range(COLUMNS):
+            left = column_index * CELL_WIDTH
+            top = row_index * CELL_HEIGHT
+            cell = image.crop((left, top, left + CELL_WIDTH, top + CELL_HEIGHT))
+            nontransparent = alpha_nonzero_count(cell)
+            used = column_index < frame_count
+            cell_info = {
+                "state": state,
+                "row": row_index,
+                "column": column_index,
+                "used": used,
+                "nontransparent_pixels": nontransparent,
+            }
+            cells.append(cell_info)
+            if used and nontransparent < args.min_used_pixels:
+                errors.append(
+                    f"{state} row {row_index} column {column_index} is empty or too sparse ({nontransparent} pixels)"
+                )
+            if used and nontransparent > CELL_WIDTH * CELL_HEIGHT * args.near_opaque_threshold:
+                near_opaque_used_cells[f"{state} row {row_index}"].append(column_index)
+            if not used and nontransparent != 0:
+                errors.append(
+                    f"{state} row {row_index} unused column {column_index} is not transparent ({nontransparent} pixels)"
+                )
+
+    for row_label, columns in near_opaque_used_cells.items():
+        message = (
+            f"{row_label} has {len(columns)} nearly opaque used cells; "
+            "this usually means the sprite has a non-transparent background"
+        )
+        if args.allow_near_opaque_used_cells:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    alpha_count = alpha_nonzero_count(image)
+    if alpha_count == ATLAS_WIDTH * ATLAS_HEIGHT:
+        message = "atlas is fully opaque; custom pets require a transparent sprite background"
+        if args.allow_opaque:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    result = {
+        "ok": not errors,
+        "file": str(atlas_path),
+        "format": source_format,
+        "mode": source_mode,
+        "width": image.width,
+        "height": image.height,
+        "errors": errors,
+        "warnings": warnings,
+        "cells": cells,
+    }
+
+    if args.json_out:
+        Path(args.json_out).expanduser().resolve().write_text(
+            json.dumps(result, indent=2) + "\n", encoding="utf-8"
+        )
+
+    print(json.dumps({k: v for k, v in result.items() if k != "cells"}, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()