yuanflow-cli 0.1.29 → 0.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuanflow-cli",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "YuanFlow 自媒体 API CLI 与 Skill 安装器。",
   "type": "module",
   "license": "MIT",

package/skills/yuanflow-skill//345/205/254/344/274/227/345/217/267/347/224/237/346/210/220/344/270/216/345/217/221/345/270/203/SKILL.md

@@ -15,9 +15,14 @@ description: 当用户需要公众号文章创作、文章改写、Markdown 排
 
 1. 用户是在已有文章上处理，还是完全重新创作。
 2. 用户本轮要做完整流程，还是只做写作、排版、封面建议、导出或草稿箱推送中的一部分。
-3. 排版结果使用 Markdown 还是 HTML。
+3. 开始输出正文之前，必须先和用户核对大概字数范围，例如 800-1200 字、1500-2000 字、3000 字以上；如果用户没有给出范围，先询问，不要直接写完整正文。
+4. 是否需要正文插图、插图数量、插图来源和大概插入位置。
+   - 用户提供图片时：先梳理每张图适合插入的段落位置，再进入排版、上传和草稿箱链路。
+   - 用户要求生成正文插图时：先使用 YuanFlow 内置生图技能生成图片，再把生成图片作为正文插图素材进入上传链路。
+   - 用户没有要求正文插图时：不要擅自生成插图；只处理文字正文和可选封面。
+5. 排版结果使用 Markdown 还是 HTML。
    - 如果选择 HTML，会把 Markdown 转成微信公众号编辑器可粘贴的内联样式 HTML。
-4. 是否需要推送到微信公众号草稿箱。草稿箱只负责生成草稿，正式发布必须由用户自行在公众号后台确认。
+6. 是否需要推送到微信公众号草稿箱。草稿箱只负责生成草稿，正式发布必须由用户自行在公众号后台确认。
 
 ## 内容创作流程
 
@@ -39,11 +44,57 @@ description: 当用户需要公众号文章创作、文章改写、Markdown 排
 Agent 在排版前应做结构化增强，但不能改变事实：
 
 - 连续对话内容转成 `dialogue` 容器。
-- 连续图片转成 `gallery` 容器。
+- 连续图片转成 `gallery` 容器；第一版如果脚本没有专门 gallery 渲染器，应退化为多张 Markdown 图片连续插入，不要丢图。
 - 金句、关键引用、核心观点转成 `callout` 容器。
 - 步骤、时间线、对比、清单转成对应结构容器。
 - 外部链接转脚注，避免微信编辑器粘贴后结构混乱。
 
+## 正文插图与草稿箱链路
+
+当用户要求正文插图或草稿箱推送时，必须区分三类图片：
+
+1. 正文插图：插入文章内容里的图片。进入草稿箱前必须上传到微信“图文消息图片”接口，拿到微信返回的 `url` 后替换 Markdown/HTML 中的图片地址。
+2. 封面图：草稿箱图文的 `thumb_media_id`。需要上传为永久图片素材，拿到 `media_id` 后写入草稿箱 payload。
+3. 本地预览图：只用于 YuanFlow 对话或工作台展示，不能直接当作微信公众号正文图片地址使用。
+
+正文插图来源规则：
+
+- 用户提供图片：读取用户给出的本地路径或已上传文件路径，按语义决定插入段落，并在 Markdown 中写成 `![说明](本地路径)`。
+- 用户要求生成插图：调用 `生图技能` 生成图片，使用工具返回的本地缓存路径插入 Markdown。
+- 用户只要求封面：只生成或使用封面，不在正文里额外插图。
+
+推送草稿箱时使用 `scripts/wechat_draft.py`：
+
+```bash
+python scripts/wechat_draft.py \
+  --credentials-file "D:\公众号token\新建文本文档.txt" \
+  --input article.md \
+  --theme newspaper \
+  --cover-image cover.png \
+  --output-dir dist \
+  --push-draft \
+  --json
+```
+
+执行顺序：
+
+1. 读取或生成 Markdown 正文，确保正文里的本地图片路径真实存在。
+2. 先用 `wechat_format.py` 完成主题排版和本地预览。
+3. 如果要推送草稿箱，再用 `wechat_draft.py`：
+   - 获取 `access_token`。
+   - 上传正文图片到 `/cgi-bin/media/uploadimg`，替换正文图片地址。
+   - 上传封面图到 `/cgi-bin/material/add_material`，取得 `thumb_media_id`。
+   - 调用 `/cgi-bin/draft/add` 创建草稿箱草稿。
+4. 返回草稿 `media_id`、本地 `draft_payload.json`、`wechat.html`、`preview.html` 和图片上传映射。
+
+接口细节需要确认时，读取 `references/wechat-official-api.md`，不要凭记忆改接口路径。
+
+安全要求：
+
+- 真实创建草稿必须显式传入 `--push-draft`，否则只生成本地 HTML 和草稿 payload。
+- 不要在对话、工作台或日志里输出 AppSecret、access_token。
+- 如果微信接口返回 IP 白名单、权限不足、未认证、额度不足等错误，要把错误原因原样归类说明，不要假装成功。
+
 ## 确定性排版脚本
 
 当前 Skill 内置 `scripts/wechat_format.py`，用于把 Markdown 转成微信可粘贴的内联样式 HTML。
@@ -54,20 +105,21 @@ Agent 在排版前应做结构化增强，但不能改变事实：
 
 除非用户在本轮已明确指定某个主题 ID，否则不得直接执行 `wechat_format.py --theme ... --output ...`。正确顺序是：
 
-1. 文章正文确认或生成后，先写入 Markdown 源文件。
-2. 执行主题画廊命令，基于正文生成 20 个核心主题预览：
+1. 文章正文确认或生成后，先准备 Markdown 正文。
+2. 如果当前 YuanFlow 主程序工具列表里存在 `wechat_theme_gallery_update`，必须优先调用这个受控工具，传入已确认的 `markdown` 正文或受控 `markdown_path`。该工具会直接运行主题画廊脚本并写入右侧内容创作工作台，避免 Agent 手动复制主题预览 HTML 时丢字段。
+3. 如果没有 `wechat_theme_gallery_update`，再执行主题画廊命令，基于正文生成 20 个核心主题预览：
 
 ```bash
 python scripts/wechat_format.py --input article.md --theme-gallery --gallery-limit 20 --json
 ```
 
-3. 使用 `content_workbench_update` 写入右侧 `内容创作` 工作台：
+4. 只有在没有受控工具时，才手动使用 `content_workbench_update` 写入右侧 `内容创作` 工作台：
    - `status`: `collecting`
    - `activeStep`: `theme_select`
    - `steps`: 必须包含 `主题选择`
-   - `views`: 至少包含脚本返回的 `option_grid` 主题卡片；可以同时附带 `editor_panel` 显示 Markdown 摘要。
-4. 明确告诉用户：请在右侧工作台选择一个主题，然后发送输入框上方出现的待执行任务。
-5. 只有拿到用户选择的主题后，才执行：
+   - `views`: 至少包含脚本返回的 `option_grid` 主题卡片；必须保留 `previewHtml`，不要省略主题预览；可以同时附带 `editor_panel` 显示 Markdown 摘要。
+5. 明确告诉用户：请在右侧工作台选择一个主题，然后发送输入框上方出现的待执行任务。
+6. 只有拿到用户选择的主题后，才执行：
 
 ```bash
 python scripts/wechat_format.py --input article.md --theme <selected_theme> --output dist/wechat.html --preview dist/preview.html --json
@@ -117,6 +169,8 @@ python scripts/wechat_format.py --input article.md --theme newspaper --output di
 - 官方入口：https://developers.weixin.qq.com/platform
 - 必需信息：AppID、AppSecret
 - 凭证由 YuanFlow Runtime 保存到用户数据目录的本地 secrets/config 中，Skill 不自行写入凭证文件，也不把密钥打印到对话里。
+- 官方迁移说明：https://developers.weixin.qq.com/doc/subscription/guide/dev/migration.html
+- 获取 `access_token` 前，必须确认已经在“微信开发者平台”官网配置 API IP 白名单，并把当前机器出口 IP 加入白名单；具体路径在微信开发者平台：我的业务 - 公众号/服务号 - 基础信息 - 开发密钥 - API IP 白名单。未配置时，接口通常返回 `40164 invalid ip ... not in whitelist`。
 
 如果当前环境没有可用的受控凭证保存工具，应提示用户先在程序设置或 Runtime 受控入口配置凭证，再继续草稿箱流程。
 

package/skills/yuanflow-skill//345/205/254/344/274/227/345/217/267/347/224/237/346/210/220/344/270/216/345/217/221/345/270/203/references/wechat-official-api.md

@@ -0,0 +1,68 @@
+# 微信公众号草稿箱接口参考
+
+本文只记录本 Skill 使用到的官方接口，便于 Agent 在执行公众号生成与发布时判断链路边界。
+
+官方迁移说明：
+
+- https://developers.weixin.qq.com/doc/subscription/guide/dev/migration.html
+
+## 开发者信息
+
+AppID、AppSecret 和 API IP 白名单已迁移到微信开发者平台管理：
+
+- 入口：https://developers.weixin.qq.com/platform
+- 路径：我的业务 - 公众号/服务号 - 基础信息 - 开发密钥
+- 如果当前机器出口 IP 不在 API IP 白名单内，接口会返回 `40164 invalid ip ... not in whitelist`。
+
+## 接口链路
+
+1. 获取 access_token
+
+```text
+GET https://api.weixin.qq.com/cgi-bin/token
+参数：grant_type=client_credential, appid, secret
+```
+
+2. 上传正文图片
+
+```text
+POST https://api.weixin.qq.com/cgi-bin/media/uploadimg?access_token=ACCESS_TOKEN
+multipart 字段：media
+返回：url
+```
+
+这个接口用于图文消息正文里的图片。草稿箱正文 HTML 中的 `<img src="">` 应使用该接口返回的 `url`。
+
+3. 上传封面素材
+
+```text
+POST https://api.weixin.qq.com/cgi-bin/material/add_material?access_token=ACCESS_TOKEN&type=image
+multipart 字段：media
+返回：media_id
+```
+
+草稿箱图文需要 `thumb_media_id`，本 Skill 默认先按 `type=image` 上传；如果微信账号侧要求 `thumb`，脚本会回退尝试 `type=thumb`。
+
+4. 新增草稿
+
+```text
+POST https://api.weixin.qq.com/cgi-bin/draft/add?access_token=ACCESS_TOKEN
+JSON：{"articles":[...]}
+```
+
+核心字段：
+
+- `title`
+- `author`
+- `digest`
+- `content`
+- `content_source_url`
+- `thumb_media_id`
+- `need_open_comment`
+- `only_fans_can_comment`
+
+## 执行约束
+
+- 真实创建草稿必须显式使用 `--push-draft`。
+- 不要输出 AppSecret 或 access_token。
+- 微信返回错误时保留 `errcode/errmsg`，并把错误归因到白名单、凭证、素材、草稿权限或额度。

package/skills/yuanflow-skill//345/205/254/344/274/227/345/217/267/347/224/237/346/210/220/344/270/216/345/217/221/345/270/203/scripts/wechat_draft.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import mimetypes
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from wechat_format import build_preview, markdown_to_wechat_html, _load_theme
+
+
+WECHAT_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token"
+WECHAT_UPLOAD_ARTICLE_IMAGE_URL = "https://api.weixin.qq.com/cgi-bin/media/uploadimg"
+WECHAT_ADD_MATERIAL_URL = "https://api.weixin.qq.com/cgi-bin/material/add_material"
+WECHAT_ADD_DRAFT_URL = "https://api.weixin.qq.com/cgi-bin/draft/add"
+
+
+class WechatApiError(RuntimeError):
+    def __init__(self, code: str, message: str, *, payload: dict[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+        self.payload = payload or {}
+
+
+def _redact_secret(value: str) -> str:
+    if not value:
+        return ""
+    if len(value) <= 8:
+        return "***"
+    return f"{value[:4]}***{value[-4:]}"
+
+
+def _load_credentials(path: Path | None, app_id: str, app_secret: str) -> dict[str, str]:
+    raw_app_id = app_id.strip()
+    raw_app_secret = app_secret.strip()
+    if path:
+        text = path.read_text(encoding="utf-8-sig")
+        id_match = re.search(r"AppID[：:\s]+([A-Za-z0-9_-]+)", text)
+        secret_match = re.search(r"AppSecret[：:\s]+([A-Za-z0-9_-]+)", text)
+        raw_app_id = raw_app_id or (id_match.group(1).strip() if id_match else "")
+        raw_app_secret = raw_app_secret or (secret_match.group(1).strip() if secret_match else "")
+    if not raw_app_id or not raw_app_secret:
+        raise WechatApiError("credentials-missing", "缺少 AppID 或 AppSecret。")
+    return {"app_id": raw_app_id, "app_secret": raw_app_secret}
+
+
+def _request_json(method: str, url: str, **kwargs: Any) -> dict[str, Any]:
+    response = requests.request(method, url, timeout=30, **kwargs)
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise WechatApiError("wechat-non-json-response", response.text[:500]) from exc
+    if response.status_code >= 400:
+        raise WechatApiError("wechat-http-error", f"HTTP {response.status_code}", payload=payload)
+    errcode = payload.get("errcode")
+    if errcode not in (None, 0):
+        raise WechatApiError(str(errcode), str(payload.get("errmsg") or "wechat api error"), payload=payload)
+    return payload
+
+
+def get_access_token(app_id: str, app_secret: str) -> str:
+    payload = _request_json(
+        "GET",
+        WECHAT_TOKEN_URL,
+        params={
+            "grant_type": "client_credential",
+            "appid": app_id,
+            "secret": app_secret,
+        },
+    )
+    token = str(payload.get("access_token") or "")
+    if not token:
+        raise WechatApiError("access-token-missing", "微信接口没有返回 access_token。", payload=payload)
+    return token
+
+
+def _guess_content_type(path: Path) -> str:
+    return mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+
+
+def upload_article_image(access_token: str, image_path: Path) -> str:
+    with image_path.open("rb") as image_file:
+        payload = _request_json(
+            "POST",
+            WECHAT_UPLOAD_ARTICLE_IMAGE_URL,
+            params={"access_token": access_token},
+            files={"media": (image_path.name, image_file, _guess_content_type(image_path))},
+        )
+    url = str(payload.get("url") or "")
+    if not url:
+        raise WechatApiError("article-image-url-missing", "正文图片上传成功但没有返回 url。", payload=payload)
+    return url
+
+
+def upload_cover_material(access_token: str, image_path: Path, material_type: str = "image") -> str:
+    with image_path.open("rb") as image_file:
+        files: dict[str, Any] = {"media": (image_path.name, image_file, _guess_content_type(image_path))}
+        data = None
+        if material_type == "video":
+            data = {"description": json.dumps({"title": image_path.stem, "introduction": ""}, ensure_ascii=False)}
+        payload = _request_json(
+            "POST",
+            WECHAT_ADD_MATERIAL_URL,
+            params={"access_token": access_token, "type": material_type},
+            files=files,
+            data=data,
+        )
+    media_id = str(payload.get("media_id") or "")
+    if not media_id:
+        raise WechatApiError("cover-media-id-missing", "封面素材上传成功但没有返回 media_id。", payload=payload)
+    return media_id
+
+
+def _is_remote_url(value: str) -> bool:
+    return re.match(r"^https?://", value, re.IGNORECASE) is not None
+
+
+def _resolve_markdown_image_path(src: str, markdown_dir: Path) -> Path:
+    normalized = src.strip().strip("\"'")
+    path = Path(normalized)
+    if not path.is_absolute():
+        path = markdown_dir / path
+    return path.resolve()
+
+
+def upload_and_replace_markdown_images(markdown: str, markdown_dir: Path, access_token: str) -> tuple[str, list[dict[str, str]]]:
+    uploads: list[dict[str, str]] = []
+
+    def replace(match: re.Match[str]) -> str:
+        alt = match.group(1)
+        src = match.group(2).strip()
+        if _is_remote_url(src):
+            return match.group(0)
+        image_path = _resolve_markdown_image_path(src, markdown_dir)
+        if not image_path.exists() or not image_path.is_file():
+            raise WechatApiError("article-image-not-found", f"正文图片不存在：{image_path}")
+        uploaded_url = upload_article_image(access_token, image_path)
+        uploads.append({"alt": alt, "source": str(image_path), "url": uploaded_url})
+        return f"![{alt}]({uploaded_url})"
+
+    updated = re.sub(r"!\[([^\]]*)\]\(([^)]+)\)", replace, markdown)
+    return updated, uploads
+
+
+def _extract_title(markdown: str, fallback: str) -> str:
+    for line in markdown.splitlines():
+        match = re.match(r"^#\s+(.+)$", line.strip())
+        if match:
+            return match.group(1).strip()[:64]
+    return fallback.strip()[:64] or "YuanFlow 公众号草稿"
+
+
+def _plain_text_digest(markdown: str) -> str:
+    text = re.sub(r"!\[[^\]]*\]\([^)]+\)", "", markdown)
+    text = re.sub(r"`{1,3}[^`]*`{1,3}", "", text)
+    text = re.sub(r"[#>*_\-\[\]()`]", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return _truncate_utf8(text, 54)
+
+
+def _truncate_utf8(value: str, max_bytes: int) -> str:
+    value = value.strip()
+    encoded = value.encode("utf-8")
+    if len(encoded) <= max_bytes:
+        return value
+    return encoded[:max_bytes].decode("utf-8", errors="ignore").rstrip()
+
+
+def build_draft_payload(
+    *,
+    title: str,
+    author: str,
+    digest: str,
+    content: str,
+    thumb_media_id: str,
+    content_source_url: str = "",
+) -> dict[str, Any]:
+    return {
+        "articles": [
+            {
+                "title": _truncate_utf8(title, 64),
+                "author": author,
+                "digest": _truncate_utf8(digest, 54),
+                "content": content,
+                "content_source_url": content_source_url,
+                "thumb_media_id": thumb_media_id,
+                "need_open_comment": 0,
+                "only_fans_can_comment": 0,
+            }
+        ]
+    }
+
+
+def add_draft(access_token: str, payload: dict[str, Any]) -> dict[str, Any]:
+    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    return _request_json(
+        "POST",
+        WECHAT_ADD_DRAFT_URL,
+        params={"access_token": access_token},
+        data=body,
+        headers={"Content-Type": "application/json; charset=utf-8"},
+    )
+
+
+def run(args: argparse.Namespace) -> dict[str, Any]:
+    input_path = Path(args.input).resolve()
+    output_dir = Path(args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    markdown = input_path.read_text(encoding="utf-8")
+    title = args.title.strip() or _extract_title(markdown, "YuanFlow 公众号草稿")
+    author = args.author.strip() or "YuanFlow"
+    theme = _load_theme(args.theme)
+    image_uploads: list[dict[str, str]] = []
+    cover_upload: dict[str, str] | None = None
+    draft_result: dict[str, Any] | None = None
+    access_token_status = "skipped"
+
+    credentials = {"app_id": "", "app_secret": ""}
+    if args.push_draft or args.credentials_file or args.app_id or args.app_secret:
+        credentials = _load_credentials(
+            Path(args.credentials_file).resolve() if args.credentials_file else None,
+            args.app_id,
+            args.app_secret,
+        )
+
+    if args.push_draft:
+        access_token = get_access_token(credentials["app_id"], credentials["app_secret"])
+        access_token_status = "ok"
+        markdown, image_uploads = upload_and_replace_markdown_images(markdown, input_path.parent, access_token)
+    else:
+        access_token = ""
+
+    html_body = markdown_to_wechat_html(markdown, theme)
+    html_path = output_dir / "wechat.html"
+    preview_path = output_dir / "preview.html"
+    uploaded_markdown_path = output_dir / "article.uploaded.md"
+    html_path.write_text(html_body, encoding="utf-8")
+    preview_path.write_text(build_preview(html_body, title), encoding="utf-8")
+    uploaded_markdown_path.write_text(markdown, encoding="utf-8")
+
+    cover_media_id = args.thumb_media_id.strip()
+    if args.push_draft and not cover_media_id:
+        cover_image = Path(args.cover_image).resolve() if args.cover_image else None
+        if not cover_image:
+            raise WechatApiError("cover-image-required", "推送草稿箱必须提供 --cover-image 或 --thumb-media-id。")
+        if not cover_image.exists() or not cover_image.is_file():
+            raise WechatApiError("cover-image-not-found", f"封面图片不存在：{cover_image}")
+        try:
+            cover_media_id = upload_cover_material(access_token, cover_image, args.cover_material_type)
+        except WechatApiError:
+            if args.cover_material_type == "image":
+                cover_media_id = upload_cover_material(access_token, cover_image, "thumb")
+            else:
+                raise
+        cover_upload = {"source": str(cover_image), "media_id": cover_media_id}
+
+    draft_payload: dict[str, Any] | None = None
+    if cover_media_id:
+        draft_payload = build_draft_payload(
+            title=title,
+            author=author,
+            digest=args.digest.strip() or _plain_text_digest(markdown),
+            content=html_body,
+            content_source_url=args.content_source_url.strip(),
+            thumb_media_id=cover_media_id,
+        )
+        draft_payload_path = output_dir / "draft_payload.json"
+        draft_payload_path.write_text(json.dumps(draft_payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    else:
+        draft_payload_path = None
+
+    if args.push_draft:
+        if not draft_payload:
+            raise WechatApiError("draft-payload-missing", "草稿 payload 未生成。")
+        draft_result = add_draft(access_token, draft_payload)
+
+    result = {
+        "ok": True,
+        "pushed": bool(args.push_draft),
+        "title": title,
+        "theme": args.theme,
+        "account": {
+            "app_id": credentials["app_id"],
+            "app_secret": _redact_secret(credentials["app_secret"]),
+        },
+        "access_token_status": access_token_status,
+        "files": {
+            "html": str(html_path),
+            "preview": str(preview_path),
+            "uploaded_markdown": str(uploaded_markdown_path),
+            "draft_payload": str(draft_payload_path) if draft_payload_path else "",
+        },
+        "article_images": image_uploads,
+        "cover": cover_upload,
+        "draft": draft_result,
+    }
+    return result
+
+
+def main() -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    if hasattr(sys.stderr, "reconfigure"):
+        sys.stderr.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description="YuanFlow 微信公众号草稿箱推送工具")
+    parser.add_argument("--input", required=True, help="Markdown 输入文件")
+    parser.add_argument("--theme", default="wechat-native", help="排版主题")
+    parser.add_argument("--title", default="", help="文章标题，默认从一级标题提取")
+    parser.add_argument("--author", default="YuanFlow", help="作者")
+    parser.add_argument("--digest", default="", help="摘要，默认从正文提取")
+    parser.add_argument("--content-source-url", default="", help="原文链接，可选")
+    parser.add_argument("--cover-image", default="", help="封面图片路径")
+    parser.add_argument("--thumb-media-id", default="", help="已上传封面素材 media_id")
+    parser.add_argument("--cover-material-type", default="image", choices=["image", "thumb"], help="封面上传素材类型")
+    parser.add_argument("--output-dir", default="dist", help="输出目录")
+    parser.add_argument("--credentials-file", default="", help="包含 AppID/AppSecret 的本地文件")
+    parser.add_argument("--app-id", default="", help="微信公众号 AppID")
+    parser.add_argument("--app-secret", default="", help="微信公众号 AppSecret")
+    parser.add_argument("--push-draft", action="store_true", help="显式创建草稿箱草稿；不传则只生成本地文件和 payload")
+    parser.add_argument("--json", action="store_true", help="输出 JSON")
+    args = parser.parse_args()
+
+    try:
+        result = run(args)
+    except WechatApiError as exc:
+        payload = {"ok": False, "error": {"code": exc.code, "message": str(exc), "payload": exc.payload}}
+        print(json.dumps(payload, ensure_ascii=False), file=sys.stderr)
+        return 2
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False))
+    else:
+        print(f"HTML: {result['files']['html']}")
+        if result.get("draft"):
+            print(f"Draft: {result['draft']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())