@cteno/sdk-linux-x64 0.0.0-stage → 2.10.14

package/skills/pptx/scripts/pptx_from_template.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Build a deck from a .pptx template (brand deck) and fill placeholders.
+
+Two modes:
+  1) Token fill (default): open TEMPLATE, replace every {{token}} across
+     slides, tables, and notes using --values JSON ({"token": "value"}),
+     save to OUTPUT. Formatting of the token's run is preserved.
+  2) --add-slides SPEC.json: additionally append slides built from the
+     template's own layouts (referenced by layout name or index), so new
+     slides inherit the brand master. Spec:
+     {"slides": [{"layout": "Title and Content", "title": "New",
+                  "bullets": ["a", {"text": "b", "level": 1}],
+                  "notes": "presenter text"}]}
+"""
+import argparse
+import json
+import sys
+
+from pptx import Presentation
+
+
+def fill_tokens(prs, values):
+    from pptx_edit import replace_text  # same scripts/ directory
+    total = 0
+    for token, value in values.items():
+        total += replace_text(prs, f"{{{{{token}}}}}", str(value))
+    return total
+
+
+def find_layout(prs, ref):
+    if isinstance(ref, int):
+        return prs.slide_layouts[ref]
+    for layout in prs.slide_layouts:
+        if layout.name == ref:
+            return layout
+    raise SystemExit(f"layout {ref!r} not found; available: "
+                     f"{[la.name for la in prs.slide_layouts]}")
+
+
+def add_slides(prs, spec):
+    from pptx_create import add_bullets
+    for slide_spec in spec.get("slides", []):
+        layout = find_layout(prs, slide_spec.get("layout", 1))
+        slide = prs.slides.add_slide(layout)
+        if slide_spec.get("title") is not None and slide.shapes.title:
+            slide.shapes.title.text = slide_spec["title"]
+        if slide_spec.get("bullets"):
+            body = next((ph for ph in slide.placeholders
+                         if ph.placeholder_format.idx != 0), None)
+            if body is not None:
+                add_bullets(body.text_frame, slide_spec["bullets"])
+        if slide_spec.get("notes"):
+            slide.notes_slide.notes_text_frame.text = slide_spec["notes"]
+
+
+def main(argv=None):
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    parser = argparse.ArgumentParser(
+        description="Fill {{tokens}} in a .pptx template and optionally "
+                    "append slides using the template's own layouts.",
+        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("template", help="path to the template .pptx")
+    parser.add_argument("output", help="output .pptx path")
+    parser.add_argument("--values", metavar="JSON",
+                        help="JSON file mapping token -> replacement value")
+    parser.add_argument("--add-slides", metavar="SPEC_JSON",
+                        help="JSON spec of slides to append")
+    args = parser.parse_args(argv)
+
+    prs = Presentation(args.template)
+    filled = 0
+    if args.values:
+        with open(args.values, encoding="utf-8") as fh:
+            filled = fill_tokens(prs, json.load(fh))
+    if args.add_slides:
+        with open(args.add_slides, encoding="utf-8") as fh:
+            add_slides(prs, json.load(fh))
+    prs.save(args.output)
+    print(json.dumps({"ok": True, "output": args.output,
+                      "tokens_filled": filled}))
+    return 0
+
+
+if __name__ == "__main__":
+    import os
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    sys.exit(main())

package/skills/pptx/scripts/pptx_read.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Read a .pptx file: JSON outline, notes, or export embedded images.
+
+Modes:
+  --outline      JSON with per-slide layout, texts, tables, notes,
+                 chart data, and image inventory (default mode).
+  --notes        JSON list of speaker notes per slide.
+  --images DIR   Export every embedded picture to DIR as files.
+"""
+import argparse
+import json
+import os
+import sys
+
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from pptx.util import Emu
+
+
+def iter_shapes(shapes):
+    """Yield shapes, descending into groups."""
+    for shape in shapes:
+        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+            yield from iter_shapes(shape.shapes)
+        else:
+            yield shape
+
+
+def chart_info(chart):
+    info = {"type": str(chart.chart_type),
+            "categories": [str(c) for c in chart.plots[0].categories],
+            "series": []}
+    for plot in chart.plots:
+        for series in plot.series:
+            try:
+                name = series.name
+            except (AttributeError, KeyError):
+                name = None
+            info["series"].append({"name": name,
+                                   "values": list(series.values)})
+    return info
+
+
+def slide_record(index, slide):
+    rec = {"index": index, "layout": slide.slide_layout.name,
+           "texts": [], "tables": [], "images": [], "charts": [],
+           "notes": None}
+    for shape in iter_shapes(slide.shapes):
+        if shape.has_text_frame and shape.text_frame.text.strip():
+            rec["texts"].append(shape.text_frame.text)
+        if shape.has_table:
+            rec["tables"].append(
+                [[cell.text for cell in row.cells]
+                 for row in shape.table.rows])
+        if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+            try:
+                img = shape.image
+                rec["images"].append({"filename": img.filename,
+                                      "ext": img.ext,
+                                      "size_bytes": len(img.blob)})
+            except (KeyError, ValueError):
+                rec["images"].append({"filename": None, "ext": None,
+                                      "size_bytes": None,
+                                      "note": "linked or unreadable"})
+        if shape.has_chart:
+            rec["charts"].append(chart_info(shape.chart))
+    if slide.has_notes_slide:
+        rec["notes"] = slide.notes_slide.notes_text_frame.text
+    return rec
+
+
+def export_images(prs, out_dir):
+    os.makedirs(out_dir, exist_ok=True)
+    written = []
+    for i, slide in enumerate(prs.slides):
+        for j, shape in enumerate(iter_shapes(slide.shapes)):
+            if shape.shape_type != MSO_SHAPE_TYPE.PICTURE:
+                continue
+            try:
+                img = shape.image
+            except (KeyError, ValueError):
+                continue
+            path = os.path.join(out_dir, f"slide{i}_img{j}.{img.ext}")
+            with open(path, "wb") as fh:
+                fh.write(img.blob)
+            written.append(path)
+    return written
+
+
+def main(argv=None):
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    parser = argparse.ArgumentParser(
+        description="Read a .pptx: outline/notes as JSON, export images.")
+    parser.add_argument("pptx", help="path to the .pptx file")
+    parser.add_argument("--outline", action="store_true",
+                        help="print full JSON outline (default)")
+    parser.add_argument("--notes", action="store_true",
+                        help="print speaker notes only")
+    parser.add_argument("--images", metavar="DIR",
+                        help="export embedded images into DIR")
+    args = parser.parse_args(argv)
+
+    prs = Presentation(args.pptx)
+
+    if args.images:
+        written = export_images(prs, args.images)
+        print(json.dumps({"ok": True, "exported": written}, indent=2))
+        return 0
+    if args.notes:
+        notes = [slide.notes_slide.notes_text_frame.text
+                 if slide.has_notes_slide else None
+                 for slide in prs.slides]
+        print(json.dumps({"ok": True, "notes": notes},
+                         indent=2, ensure_ascii=True))
+        return 0
+
+    outline = {
+        "ok": True,
+        "slide_size_inches": [round(Emu(prs.slide_width).inches, 3),
+                              round(Emu(prs.slide_height).inches, 3)],
+        "slide_count": len(prs.slides._sldIdLst),
+        "layouts_available": [lay.name for lay in prs.slide_layouts],
+        "slides": [slide_record(i, s) for i, s in enumerate(prs.slides)],
+    }
+    print(json.dumps(outline, indent=2, ensure_ascii=True))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/pptx/scripts/pptx_render.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Render every slide of a .pptx to per-slide PNG images.
+
+Pipeline: LibreOffice (soffice --headless --convert-to pdf) turns the deck
+into a PDF, then poppler (pdftoppm, or pdftocairo as an alternate) splits
+the PDF into one PNG per slide.
+
+Output is JSON. When both tools are present:
+  {"rendered": true, "files": ["render/slide-1.png", ...]}
+When either tool is missing the script still exits 0 and reports:
+  {"rendered": false, "missing": ["soffice"], "guidance": "..."}
+so callers can degrade gracefully (fall back to pptx_read.py --outline).
+"""
+import argparse
+import glob
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from render import find_soffice  # also finds the standard Windows/macOS install, not only PATH
+
+
+def find_tools():
+    """Return (soffice, splitter, missing); soffice discovery is shared with render.py."""
+    soffice = find_soffice()
+    splitter = shutil.which("pdftoppm") or shutil.which("pdftocairo")
+    missing = []
+    if not soffice:
+        missing.append("soffice")
+    if not splitter:
+        missing.append("pdftoppm (or pdftocairo)")
+    return soffice, splitter, missing
+
+
+def render(pptx_path, out_dir, prefix, dpi):
+    soffice, splitter, missing = find_tools()
+    if missing:
+        return {
+            "rendered": False, "missing": missing,
+            "guidance": "Install LibreOffice (soffice) and poppler-utils "
+                        "(pdftoppm/pdftocairo) to render slides. Without "
+                        "them, verify decks with pptx_read.py --outline "
+                        "instead.",
+        }
+
+    os.makedirs(out_dir, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        proc = subprocess.run(
+            [soffice, "--headless", "--convert-to", "pdf",
+             "--outdir", tmp, pptx_path],
+            capture_output=True, text=True, encoding="utf-8",
+            errors="replace", timeout=300, check=False)
+        pdfs = glob.glob(os.path.join(tmp, "*.pdf"))
+        if proc.returncode != 0 or not pdfs:
+            raise SystemExit(f"soffice PDF conversion failed: {proc.stderr}")
+        pdf = pdfs[0]
+        out_prefix = os.path.join(out_dir, prefix)
+        proc = subprocess.run(
+            [splitter, "-png", "-r", str(dpi), pdf, out_prefix],
+            capture_output=True, text=True, encoding="utf-8",
+            errors="replace", timeout=300, check=False)
+        if proc.returncode != 0:
+            raise SystemExit(f"{os.path.basename(splitter)} failed: "
+                             f"{proc.stderr}")
+
+    files = sorted(glob.glob(out_prefix + "*.png"))
+    return {"rendered": True, "files": files}
+
+
+def main(argv=None):
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    parser = argparse.ArgumentParser(
+        description="Render each slide of a .pptx to a PNG via "
+                    "soffice + pdftoppm/pdftocairo.",
+        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("pptx", help="path to the .pptx file")
+    parser.add_argument("--outdir", default="render",
+                        help="directory for PNGs (default: ./render)")
+    parser.add_argument("--prefix", default="slide",
+                        help="PNG filename prefix (default: slide)")
+    parser.add_argument("--dpi", type=int, default=100,
+                        help="render resolution (default: 100)")
+    args = parser.parse_args(argv)
+
+    result = render(args.pptx, args.outdir, args.prefix, args.dpi)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/pptx/scripts/render.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Render an office file (or PDF) to page/slide PNGs so you can LOOK at the result.
+
+Usage:
+  python3 render.py FILE [--outdir DIR] [--dpi 110] [--pages 1-3] [--pdf-only]
+
+FILE may be .docx/.doc/.pptx/.ppt/.xlsx/.xls/.odt/.odp/.ods/.rtf/.csv or .pdf.
+Office files are converted to PDF with LibreOffice (soffice) in an isolated,
+throw-away user profile (so a running LibreOffice or a stale lock never hangs
+the conversion), then split into PNGs with pdftoppm, or pypdfium2 if poppler
+is missing.
+
+Prints JSON:
+  {"rendered": true, "pdf": "DIR/name.pdf", "pages": N, "files": ["DIR/name-01.png", ...]}
+  {"rendered": false, "missing": [...], "install": "..."}   (exit 0, nothing rendered)
+Exit 1 only when a tool was present but the conversion itself failed.
+
+This file is shared verbatim by the docx, pptx, xlsx and pdf skills.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+
+OFFICE_EXT = {".docx", ".doc", ".dotx", ".pptx", ".ppt", ".potx", ".xlsx", ".xlsm", ".xls",
+              ".odt", ".odp", ".ods", ".rtf", ".csv"}
+
+
+def find_soffice() -> str | None:
+    override = os.environ.get("SOFFICE")
+    if override is not None:  # explicit path, or "" to mean "no LibreOffice"
+        return override if override and os.path.exists(override) else None
+    for name in ("soffice", "libreoffice"):
+        p = shutil.which(name)
+        if p:
+            return p
+    for p in ("/Applications/LibreOffice.app/Contents/MacOS/soffice",
+              r"C:\Program Files\LibreOffice\program\soffice.exe",
+              r"C:\Program Files (x86)\LibreOffice\program\soffice.exe",
+              "/usr/lib/libreoffice/program/soffice", "/opt/libreoffice/program/soffice"):
+        if os.path.exists(p):
+            return p
+    return None
+
+
+def install_hint(missing: list[str]) -> str:
+    sysname = platform.system()
+    tips = []
+    if "soffice" in missing:
+        tips.append({"Darwin": "brew install --cask libreoffice (or download from libreoffice.org)",
+                     "Linux": "sudo apt-get install -y libreoffice-core libreoffice-writer libreoffice-calc libreoffice-impress",
+                     "Windows": "winget install TheDocumentFoundation.LibreOffice"}.get(sysname, "install LibreOffice"))
+    if "pdftoppm" in missing:
+        tips.append({"Darwin": "brew install poppler", "Linux": "sudo apt-get install -y poppler-utils",
+                     "Windows": "pip install pypdfium2"}.get(sysname, "pip install pypdfium2"))
+    return "; ".join(tips)
+
+
+# Windows/Office CJK font names -> fonts that actually exist on this machine, so the
+# preview shows real glyphs with similar metrics instead of empty boxes. Only the
+# throw-away LibreOffice profile used for rendering is changed; the document is not.
+CJK_SUBSTITUTES = {
+    "Darwin": {
+        "SimSun": "Songti SC", "宋体": "Songti SC", "NSimSun": "Songti SC", "SimSun-ExtB": "Songti SC",
+        "SimHei": "Heiti SC", "黑体": "Heiti SC", "Microsoft YaHei": "Hiragino Sans GB",
+        "微软雅黑": "Hiragino Sans GB", "Microsoft JhengHei": "Heiti TC", "PMingLiU": "Songti TC",
+        "FangSong": "STFangsong", "FangSong_GB2312": "STFangsong", "仿宋": "STFangsong", "仿宋_GB2312": "STFangsong",
+        "KaiTi": "Kaiti SC", "KaiTi_GB2312": "Kaiti SC", "楷体": "Kaiti SC", "楷体_GB2312": "Kaiti SC",
+        "DengXian": "Hiragino Sans GB", "等线": "Hiragino Sans GB",
+        "FZXiaoBiaoSong-B05S": "Songti SC", "方正小标宋简体": "Songti SC",
+    },
+    "Linux": {k: v for k, v in (
+        ("SimSun", "Noto Serif CJK SC"), ("宋体", "Noto Serif CJK SC"), ("NSimSun", "Noto Serif CJK SC"),
+        ("SimHei", "Noto Sans CJK SC"), ("黑体", "Noto Sans CJK SC"), ("Microsoft YaHei", "Noto Sans CJK SC"),
+        ("微软雅黑", "Noto Sans CJK SC"), ("FangSong", "Noto Serif CJK SC"), ("FangSong_GB2312", "Noto Serif CJK SC"),
+        ("KaiTi", "Noto Serif CJK SC"), ("KaiTi_GB2312", "Noto Serif CJK SC"), ("DengXian", "Noto Sans CJK SC"),
+        ("FZXiaoBiaoSong-B05S", "Noto Serif CJK SC"))},
+}
+
+
+SYSTEM_CJK_FONT_FILES = [
+    # LibreOffice on macOS does not see these system fonts; link them into the profile so CJK renders.
+    "/System/Library/Fonts/Hiragino Sans GB.ttc", "/System/Library/Fonts/STHeiti Medium.ttc",
+    "/System/Library/Fonts/STHeiti Light.ttc", "/System/Library/Fonts/Supplemental/Songti.ttc",
+    "/System/Library/Fonts/PingFang.ttc", "/System/Library/Fonts/Supplemental/Kaiti.ttc",
+    "/System/Library/Fonts/Supplemental/STFangsong.ttf", "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
+]
+
+
+def write_profile(prof: str) -> None:
+    fonts_dir = os.path.join(prof, "user", "fonts")
+    os.makedirs(fonts_dir, exist_ok=True)
+    for f in SYSTEM_CJK_FONT_FILES:
+        if os.path.exists(f):
+            try:
+                os.symlink(f, os.path.join(fonts_dir, os.path.basename(f)))
+            except OSError:
+                shutil.copy(f, fonts_dir)
+    pairs = CJK_SUBSTITUTES.get(platform.system())
+    if not pairs:
+        return  # Windows has the real fonts
+    from xml.sax.saxutils import quoteattr
+    nodes = "".join(
+        f'<item oor:path="/org.openoffice.VCL/FontSubstitutions"><node oor:name={quoteattr("p" + str(i))} oor:op="replace">'
+        f'<prop oor:name="ReplaceFont"><value>{src}</value></prop>'
+        f'<prop oor:name="SubstituteFont"><value>{dst}</value></prop>'
+        f'<prop oor:name="Always"><value>true</value></prop>'
+        f'<prop oor:name="OnScreenOnly"><value>false</value></prop></node></item>'
+        for i, (src, dst) in enumerate(pairs.items()))
+    nodes += ('<item oor:path="/org.openoffice.VCL"><prop oor:name="FontSubstitutionsEnabled" oor:op="fuse">'
+              '<value>true</value></prop></item>'
+              '<item oor:path="/org.openoffice.Office.Common/Font/Substitution"><prop oor:name="Replacement" oor:op="fuse">'
+              '<value>true</value></prop></item>'
+              '<item oor:path="/org.openoffice.Office.Common/Font/Substitution"><prop oor:name="FontPairs" oor:op="fuse">'
+              '<value>' + "".join(
+                  f'<it><prop oor:name="Always"><value>true</value></prop>'
+                  f'<prop oor:name="OnScreenOnly"><value>false</value></prop>'
+                  f'<prop oor:name="ReplaceFont"><value>{s}</value></prop>'
+                  f'<prop oor:name="SubstituteFont"><value>{d}</value></prop></it>'
+                  for s, d in pairs.items()) + '</value></prop></item>')
+    os.makedirs(os.path.join(prof, "user"), exist_ok=True)
+    with open(os.path.join(prof, "user", "registrymodifications.xcu"), "w", encoding="utf-8") as f:
+        f.write('<?xml version="1.0" encoding="UTF-8"?>\n<oor:items xmlns:oor="http://openoffice.org/2001/registry" '
+                'xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
+                + nodes + '</oor:items>\n')
+
+
+def to_pdf(src: str, outdir: str, timeout: int) -> str:
+    soffice = find_soffice()
+    if not soffice:
+        raise LookupError("soffice")
+    with tempfile.TemporaryDirectory(prefix="lo-profile-") as prof:
+        write_profile(prof)
+        profile_url = "file:///" + prof.replace("\\", "/").lstrip("/")
+        cmd = [soffice, f"-env:UserInstallation={profile_url}", "--headless", "--norestore",
+               "--nolockcheck", "--convert-to", "pdf", "--outdir", outdir, src]
+        proc = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8",
+                              errors="replace", timeout=timeout, check=False)
+    pdf = os.path.join(outdir, os.path.splitext(os.path.basename(src))[0] + ".pdf")
+    if proc.returncode != 0 or not os.path.exists(pdf):
+        raise RuntimeError(f"soffice conversion failed (rc={proc.returncode}): {proc.stderr.strip() or proc.stdout.strip()}")
+    return pdf
+
+
+def parse_pages(spec: str | None, n: int) -> list[int]:
+    if not spec:
+        return list(range(1, n + 1))
+    out: list[int] = []
+    for part in spec.split(","):
+        a, _, b = part.partition("-")
+        lo, hi = int(a), int(b or a)
+        out += [p for p in range(lo, hi + 1) if 1 <= p <= n]
+    return out
+
+
+def pdf_pages(pdf: str) -> int:
+    try:
+        from pypdf import PdfReader
+        return len(PdfReader(pdf).pages)
+    except Exception:
+        info = shutil.which("pdfinfo")
+        if info:
+            r = subprocess.run([info, pdf], capture_output=True, text=True, check=False)
+            for line in r.stdout.splitlines():
+                if line.startswith("Pages:"):
+                    return int(line.split()[1])
+    return 0
+
+
+def rasterize(pdf: str, outdir: str, stem: str, dpi: int, pages: list[int]) -> list[str]:
+    width = max(2, len(str(max(pages) if pages else 1)))
+    files = []
+    tool = shutil.which("pdftoppm")
+    if tool:
+        for p in pages:
+            prefix = os.path.join(outdir, f"{stem}-{p:0{width}d}")
+            subprocess.run([tool, "-png", "-r", str(dpi), "-f", str(p), "-l", str(p), "-singlefile", pdf, prefix],
+                           check=True, capture_output=True)
+            files.append(prefix + ".png")
+        return files
+    import pypdfium2 as pdfium  # raises ImportError -> reported as missing
+    doc = pdfium.PdfDocument(pdf)
+    for p in pages:
+        img = doc[p - 1].render(scale=dpi / 72).to_pil()
+        path = os.path.join(outdir, f"{stem}-{p:0{width}d}.png")
+        img.save(path)
+        files.append(path)
+    return files
+
+
+def main(argv=None) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0],
+                                 epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("file")
+    ap.add_argument("--outdir", default=None, help="default: <file dir>/render")
+    ap.add_argument("--dpi", type=int, default=110)
+    ap.add_argument("--pages", default=None, help="e.g. 1-3,7 (default: all)")
+    ap.add_argument("--pdf-only", action="store_true", help="convert to PDF, skip PNGs")
+    ap.add_argument("--timeout", type=int, default=240)
+    a = ap.parse_args(argv)
+
+    src = os.path.abspath(a.file)
+    outdir = os.path.abspath(a.outdir or os.path.join(os.path.dirname(src), "render"))
+    os.makedirs(outdir, exist_ok=True)
+    stem = os.path.splitext(os.path.basename(src))[0]
+    ext = os.path.splitext(src)[1].lower()
+    missing: list[str] = []
+    try:
+        if ext == ".pdf":
+            pdf = src
+        elif ext in OFFICE_EXT:
+            pdf = to_pdf(src, outdir, a.timeout)
+        else:
+            print(json.dumps({"rendered": False, "error": f"unsupported file type {ext}"}))
+            return 1
+    except LookupError:
+        missing.append("soffice")
+    except (RuntimeError, subprocess.TimeoutExpired) as e:
+        print(json.dumps({"rendered": False, "error": str(e)}, ensure_ascii=False))
+        return 1
+    if missing:
+        print(json.dumps({"rendered": False, "missing": missing, "install": install_hint(missing)}, ensure_ascii=False))
+        return 0
+    n = pdf_pages(pdf)
+    if a.pdf_only:
+        print(json.dumps({"rendered": True, "pdf": pdf, "pages": n, "files": []}, ensure_ascii=False))
+        return 0
+    try:
+        for old in glob.glob(os.path.join(outdir, f"{stem}-*.png")):
+            os.remove(old)
+        files = rasterize(pdf, outdir, stem, a.dpi, parse_pages(a.pages, n))
+    except ImportError:
+        print(json.dumps({"rendered": False, "pdf": pdf, "missing": ["pdftoppm"],
+                          "install": install_hint(["pdftoppm"])}, ensure_ascii=False))
+        return 0
+    print(json.dumps({"rendered": True, "pdf": pdf, "pages": n, "files": files}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())