minimal-agent 0.8.2 → 0.10.0

package/skills/ui-design/scripts/assemble_material.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+assemble_material.py —— 把摄取阶段的多份产物确定性合并成「用户原始材料」统一中间文件。
+
+为什么需要
+==========
+ppt 工作流摄取阶段分三步采集事实：① extract_source_assets.py 抽文字+图片+base manifest；
+② image-stats 算图像统计；③ 多模态逐图识图写 vision/*.json。这三份分散的事实必须**确定性**合并成
+一份下游全程都吃的统一材料（文字 + 每张图的 路径/识图详述/重点区/统计），不该再开 LLM 步去「复述拼接」
+（会改写、会丢字、会幻觉）。同 image_plan_lint / extract_source_assets 哲学：机械合并交脚本。
+
+合并什么 → 产出什么（都在 --build 目录，默认 ./build）
+====================================================
+读：source_assets.json（base manifest）+ source.md（文字主干）+ source_stats.json（image-stats --json 数组）
+   + vision/<file>.json（逐图识图，可缺）
+写：
+  - material.md   ：人/LLM 读——文字主干 + 每张图一块（路径+来源+朝向+识图详述+重点区+建议文字位+统计）
+  - material.json ：机读富 manifest——images[] 每条在 base 字段上并入 stats / vision（缺则 null）
+
+容缺：统计 / 识图 缺失时该图只记已有信息（标注「未完成」），绝不报错——识图依赖多模态模型，
+文本模型跑不了视觉时本步要能优雅产出「只有文字+统计」的材料。
+
+退出码：0（恒成功，缺源也写 has_source:false 的空材料）。只用标准库。
+
+用法
+====
+    python assemble_material.py [--build ./build]
+"""
+
+import argparse
+import json
+import os
+import sys
+
+
+def _load_json(path, default=None):
+    # utf-8-sig：既读普通 UTF-8，也容忍带 BOM 的产物（某些工具/重定向会写 BOM）。
+    try:
+        with open(path, encoding="utf-8-sig") as f:
+            return json.load(f)
+    except Exception:
+        return default
+
+
+def _stats_by_file(stats_list):
+    """image-stats --json 数组 → {basename(path): stats}。"""
+    out = {}
+    if isinstance(stats_list, list):
+        for s in stats_list:
+            if isinstance(s, dict) and isinstance(s.get("path"), str):
+                out[os.path.basename(s["path"])] = s
+    return out
+
+
+def _fmt_region(kr):
+    if not isinstance(kr, dict):
+        return None
+    try:
+        return (
+            f"x{float(kr.get('x', 0)):.2f} y{float(kr.get('y', 0)):.2f} "
+            f"w{float(kr.get('w', 0)):.2f} h{float(kr.get('h', 0)):.2f}"
+        )
+    except Exception:
+        return None
+
+
+def _fmt_stats_line(stats):
+    if not isinstance(stats, dict):
+        return "（统计缺失）"
+    parts = []
+    ac = stats.get("average_color")
+    if isinstance(ac, dict) and ac.get("hex"):
+        parts.append(f"平均色 {ac['hex']}")
+    doms = stats.get("dominant_colors")
+    if isinstance(doms, list) and doms:
+        hexes = " ".join(d.get("hex", "") for d in doms[:4] if isinstance(d, dict))
+        if hexes.strip():
+            parts.append(f"主色 {hexes}")
+    tone = stats.get("tone")
+    if isinstance(tone, dict) and tone.get("category"):
+        parts.append(f"色调 {tone['category']}")
+    bri = stats.get("brightness")
+    if isinstance(bri, dict) and bri.get("mean") is not None:
+        parts.append(f"平均亮度 {bri['mean']}/255")
+    return " ｜ ".join(parts) if parts else "（统计缺失）"
+
+
+def _image_md_block(n, img):
+    """单张图在 material.md 里的一块。"""
+    L = []
+    L.append(f"\n### 图 {n}：{img['path']}\n")
+    meta = (
+        f"- 来源：{img.get('origin', '?')} ｜ 章节：{img.get('section', '?')} ｜ "
+        f"朝向：{img.get('orient', '?')}（{img.get('w', '?')}×{img.get('h', '?')}，比例 {img.get('aspect_ratio', '?')}）"
+    )
+    L.append(meta)
+    if img.get("near_text"):
+        L.append(f"- 邻近文案：{img['near_text']}")
+    vision = img.get("vision")
+    if isinstance(vision, dict):
+        if vision.get("description"):
+            L.append(f"- 识图：{vision['description']}")
+        ke = vision.get("key_elements")
+        if isinstance(ke, list) and ke:
+            L.append(f"- 重点元素：{', '.join(str(x) for x in ke)}")
+        region = _fmt_region(vision.get("key_region"))
+        if region:
+            zone = vision.get("recommended_text_zone")
+            tail = f"（建议文字放 {zone}、勿压此区）" if zone else ""
+            L.append(f"- 重点区域（归一化）：{region}{tail}")
+        if vision.get("suitable_as_background") is not None:
+            L.append(f"- 适合做背景：{'是' if vision['suitable_as_background'] else '否'}")
+        if vision.get("palette_impression"):
+            L.append(f"- 配色印象：{vision['palette_impression']}")
+        if vision.get("key_message"):
+            L.append(f"- 🚨 图表核心结论（须体现在 draft.md 论点/证据里）：{vision['key_message']}")
+        dp = vision.get("data_points")
+        if isinstance(dp, list) and dp:
+            L.append(f"- 关键数据点：{', '.join(str(x) for x in dp)}")
+        et = vision.get("embedded_text")
+        if isinstance(et, list) and et:
+            quoted = "、".join(
+                f"「{it.get('text')}」" for it in et if isinstance(it, dict) and it.get("text")
+            )
+            if quoted:
+                L.append(f"- 图上原有文字（图生图阶段会被去除，写稿时若信息有价值应整合进正文）：{quoted}")
+        if vision.get("notes"):
+            L.append(f"- 备注：{vision['notes']}")
+    else:
+        L.append("- 识图：（未完成——无多模态模型或本图识图失败）")
+    L.append(f"- 图像统计：{_fmt_stats_line(img.get('stats'))}")
+    return "\n".join(L)
+
+
+def assemble(build_dir):
+    build_dir = os.path.abspath(build_dir)
+    manifest = _load_json(os.path.join(build_dir, "source_assets.json"), {})
+    has_source = bool(manifest.get("has_source"))
+    base_images = manifest.get("images") or []
+    stats_map = _stats_by_file(_load_json(os.path.join(build_dir, "source_stats.json"), []))
+
+    source_md = ""
+    p = os.path.join(build_dir, "source.md")
+    if os.path.isfile(p):
+        with open(p, encoding="utf-8") as f:
+            source_md = f.read().strip()
+
+    merged_images = []
+    for img in base_images:
+        if not isinstance(img, dict) or not img.get("file"):
+            continue
+        file = img["file"]
+        vision_path = os.path.join(build_dir, "vision", f"{file}.json")
+        vision = _load_json(vision_path)
+        # 识图 JSON 缺失/非法必须响亮（2026-07-02 事故：src_6 识图正确写出了「旧 PPT 截图勿覆盖文字」，
+        # 但 LLM 落盘的 JSON 引号未转义 → 这里静默吞成 None → 规划器盲态把整版截图当无字普通图铺背景）。
+        # 仍不阻断（识图是增强信息、盲态有保守分支），但逐图打 WARNING 让工作流日志/用户看得见。
+        if not isinstance(vision, dict):
+            if os.path.isfile(vision_path):
+                print(f"WARNING: {file}: vision JSON 非法（解析失败）——识图结论丢失，规划将按盲态保守处理")
+            else:
+                print(f"WARNING: {file}: vision JSON 缺失——识图未跑或未落盘，规划将按盲态保守处理")
+        merged = dict(img)
+        merged["path"] = f"assets/{file}"
+        merged["stats"] = stats_map.get(file)
+        merged["vision"] = vision if isinstance(vision, dict) else None
+        merged_images.append(merged)
+
+    material = {
+        "has_source": has_source,
+        "sources": manifest.get("sources") or [],
+        "text_file": "material.md",
+        "images": merged_images,
+    }
+    with open(os.path.join(build_dir, "material.json"), "w", encoding="utf-8") as f:
+        json.dump(material, f, ensure_ascii=False, indent=2)
+
+    # material.md
+    md = ["# 用户原始材料（统一中间形式）\n"]
+    md.append(
+        "> 确定性合并：文档/表格文字 + 每张图片（路径 + LLM 识图详述 + 图像统计）。"
+        "下游研究/设计/配图全程以此为准；**所有客户图片都必须用进 PPT**。\n"
+    )
+    md.append("\n## 一、文字内容\n")
+    md.append(source_md if source_md else "（无文档文字——纯图片 / 纯 topic 输入）")
+    md.append(f"\n\n## 二、图片素材（{len(merged_images)} 张，均须用进 PPT）\n")
+    if merged_images:
+        for i, img in enumerate(merged_images, 1):
+            md.append(_image_md_block(i, img))
+    else:
+        md.append("\n（无客户图片）")
+    with open(os.path.join(build_dir, "material.md"), "w", encoding="utf-8") as f:
+        f.write("\n".join(md).strip() + "\n")
+
+    return material
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="合并 source.md + manifest + 统计 + 识图 → material.md/json（确定性）"
+    )
+    parser.add_argument("--build", default="./build", help="摄取产物目录（默认 ./build）")
+    args = parser.parse_args()
+
+    material = assemble(args.build)
+    n_vision = sum(1 for im in material["images"] if im.get("vision"))
+    n_stats = sum(1 for im in material["images"] if im.get("stats"))
+    print(
+        f"MATERIAL_ASSEMBLED: {len(material['images'])} 张图（识图 {n_vision}、统计 {n_stats}）"
+        f"、has_source={material['has_source']} → {os.path.join(args.build, 'material.json')}"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/ui-design/scripts/assemble_material_test.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+assemble_material_test.py —— assemble_material.py 单测（合成 manifest/stats/vision 断言合并 + 容缺）。
+
+锁定：
+  - material.json：images[] 在 base 字段上并入 stats（按 basename 对齐）/ vision（按 file 对齐）。
+  - material.md：含文字主干 + 每图块（路径/朝向/识图详述/重点区/统计）。
+  - 容缺：某图缺 vision / 缺 stats 时该图 vision/stats=null、md 标注「未完成/缺失」，不报错。
+  - 无 source_assets.json → has_source:false 的空材料，退出 0。
+依赖：标准库。
+"""
+
+import json
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import assemble_material as am  # noqa: E402
+
+
+def _write(path, obj):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        if isinstance(obj, str):
+            f.write(obj)
+        else:
+            json.dump(obj, f, ensure_ascii=False)
+
+
+class TestAssemble(unittest.TestCase):
+    def setUp(self):
+        self.build = os.path.join(tempfile.mkdtemp(prefix="assemble-"), "build")
+        os.makedirs(self.build, exist_ok=True)
+
+    def _seed_full(self):
+        _write(os.path.join(self.build, "source.md"), "# 来源：brief.pptx\n## 产品概览\n相机很强。")
+        _write(os.path.join(self.build, "source_assets.json"), {
+            "has_source": True, "sources": ["brief.pptx"], "text_file": "source.md",
+            "images": [
+                {"file": "src_1.png", "w": 1920, "h": 1080, "aspect_ratio": 1.78,
+                 "orient": "landscape", "section": "产品概览", "near_text": "相机特写",
+                 "origin": "brief.pptx#slide3"},
+                {"file": "src_2.png", "w": 600, "h": 1000, "aspect_ratio": 0.6,
+                 "orient": "portrait", "section": "细节", "near_text": "", "origin": "brief.pptx#slide5"},
+            ],
+        })
+        _write(os.path.join(self.build, "source_stats.json"), [
+            {"path": "./build/assets/src_1.png",
+             "average_color": {"hex": "#334455"}, "tone": {"category": "cool"},
+             "brightness": {"mean": 88}, "dominant_colors": [{"hex": "#112233"}]},
+            {"path": "./build/assets/src_2.png",
+             "average_color": {"hex": "#AABBCC"}, "tone": {"category": "warm"},
+             "brightness": {"mean": 180}, "dominant_colors": [{"hex": "#FFAA00"}]},
+        ])
+        # 只给 src_1 识图（src_2 故意缺 → 测容缺）
+        _write(os.path.join(self.build, "vision", "src_1.png.json"), {
+            "description": "一块电路板特写", "key_elements": ["电容", "芯片"],
+            "key_region": {"x": 0.3, "y": 0.2, "w": 0.45, "h": 0.5},
+            "suitable_as_background": False, "recommended_text_zone": "right",
+            "palette_impression": "冷色金属", "notes": "右上留白",
+        })
+
+    def test_merge_full(self):
+        self._seed_full()
+        m = am.assemble(self.build)
+        self.assertTrue(m["has_source"])
+        self.assertEqual(len(m["images"]), 2)
+        i1 = m["images"][0]
+        self.assertEqual(i1["path"], "assets/src_1.png")
+        # stats 按 basename 对齐
+        self.assertEqual(i1["stats"]["average_color"]["hex"], "#334455")
+        # vision 按 file 对齐
+        self.assertEqual(i1["vision"]["description"], "一块电路板特写")
+        self.assertEqual(i1["vision"]["key_region"]["w"], 0.45)
+        # material.json / material.md 落盘
+        self.assertTrue(os.path.isfile(os.path.join(self.build, "material.json")))
+        with open(os.path.join(self.build, "material.md"), encoding="utf-8") as f:
+            md = f.read()
+        self.assertIn("产品概览", md)        # 文字主干
+        self.assertIn("assets/src_1.png", md)  # 图块路径
+        self.assertIn("一块电路板特写", md)    # 识图详述
+        self.assertIn("色调 cool", md)         # 统计
+
+    def test_graceful_missing_vision_and_stats(self):
+        self._seed_full()
+        m = am.assemble(self.build)
+        i2 = m["images"][1]  # src_2 缺 vision，但有 stats
+        self.assertIsNone(i2["vision"])
+        self.assertEqual(i2["stats"]["tone"]["category"], "warm")
+        with open(os.path.join(self.build, "material.md"), encoding="utf-8") as f:
+            md = f.read()
+        self.assertIn("（未完成", md)  # src_2 识图未完成标注
+
+    def test_chart_key_message_and_data_points_rendered(self):
+        # 2026-07-03 新增字段：图表核心结论 + 关键数据点，须渲染进 material.md 供 draft 阶段读到
+        # （治「客户图配不上」——图的价值此前只在识图内部，没往下游透传）。
+        self._seed_full()
+        with open(os.path.join(self.build, "vision", "src_1.png.json"), "w", encoding="utf-8") as f:
+            json.dump({
+                "description": "一块电路板特写", "content_type": "chart",
+                "key_message": "巡检效率提升三倍", "data_points": ["68% → 12%", "3 倍提速"],
+            }, f, ensure_ascii=False)
+        am.assemble(self.build)
+        with open(os.path.join(self.build, "material.md"), encoding="utf-8") as f:
+            md = f.read()
+        self.assertIn("巡检效率提升三倍", md)
+        self.assertIn("68% → 12%", md)
+        self.assertIn("3 倍提速", md)
+
+    def test_embedded_text_rendered(self):
+        # 2026-07-03：图上原有文字（图生图会去除）须透传进 material.md，供 draft 阶段判断是否要整合进正文
+        # （治「带字图去字后信息直接丢失」——src_6 真机事故：标题「AI全景相机优势」若有价值不能凭空消失）。
+        self._seed_full()
+        with open(os.path.join(self.build, "vision", "src_1.png.json"), "w", encoding="utf-8") as f:
+            json.dump({
+                "description": "一张完整的演示页截图", "content_type": "screenshot_slide",
+                "embedded_text": [
+                    {"text": "AI全景相机优势", "region": "顶部标题"},
+                    {"text": "多台监控", "region": "左箭头标签"},
+                ],
+            }, f, ensure_ascii=False)
+        am.assemble(self.build)
+        with open(os.path.join(self.build, "material.md"), encoding="utf-8") as f:
+            md = f.read()
+        self.assertIn("AI全景相机优势", md)
+        self.assertIn("多台监控", md)
+        self.assertIn("图生图阶段会被去除", md)
+
+    def test_no_source_writes_empty_material(self):
+        _write(os.path.join(self.build, "source_assets.json"), {
+            "has_source": False, "sources": [], "text_file": None, "images": [],
+        })
+        m = am.assemble(self.build)
+        self.assertFalse(m["has_source"])
+        self.assertEqual(m["images"], [])
+        self.assertTrue(os.path.isfile(os.path.join(self.build, "material.json")))
+
+    def test_no_manifest_at_all(self):
+        # 连 source_assets.json 都没有 → 不报错，写空材料
+        m = am.assemble(self.build)
+        self.assertFalse(m["has_source"])
+        self.assertEqual(m["images"], [])
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/skills/ui-design/scripts/browser_check_ui_artifact.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { chromium } from 'playwright-core';
+
+function parseArgs(argv) {
+  const args = {
+    html: '',
+    outDir: '',
+    screenshotsDir: '',
+    report: '',
+    desktop: '1440x980',
+    mobile: '390x844',
+    wait: 250,
+    requireTweaks: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (item === '--help' || item === '-h') {
+      console.log(`用法: browser_check_ui_artifact.mjs <html文件> --out-dir <输出目录>
+
+选项:
+  --screenshots-dir <目录>  截图输出目录，默认等于 --out-dir
+  --report <文件>           JSON 报告路径，默认写入 --out-dir/browser-check.json
+  --desktop 1440x980   桌面截图视口
+  --mobile 390x844     移动端截图视口
+  --wait 250           页面加载后等待毫秒数
+  --require-tweaks     要求存在唯一 EDITMODE block 与完整 Tweaks 消息（原型/变体页使用）
+
+输出:
+  desktop.png
+  mobile.png
+  browser-check.json`);
+      process.exit(0);
+    }
+    if (item === '--out-dir') {
+      args.outDir = argv[index + 1] || '';
+      index += 1;
+      continue;
+    }
+    if (item === '--screenshots-dir') {
+      args.screenshotsDir = argv[index + 1] || '';
+      index += 1;
+      continue;
+    }
+    if (item === '--report') {
+      args.report = argv[index + 1] || '';
+      index += 1;
+      continue;
+    }
+    if (item === '--desktop') {
+      args.desktop = argv[index + 1] || args.desktop;
+      index += 1;
+      continue;
+    }
+    if (item === '--mobile') {
+      args.mobile = argv[index + 1] || args.mobile;
+      index += 1;
+      continue;
+    }
+    if (item === '--wait') {
+      args.wait = Number(argv[index + 1] || args.wait);
+      index += 1;
+      continue;
+    }
+    if (item === '--require-tweaks') {
+      args.requireTweaks = true;
+      continue;
+    }
+    if (!args.html) {
+      args.html = item;
+      continue;
+    }
+    throw new Error(`未知参数: ${item}`);
+  }
+
+  if (!args.html || !args.outDir) {
+    throw new Error('必须提供 <html文件> 和 --out-dir。使用 --help 查看说明。');
+  }
+
+  return args;
+}
+
+function parseViewport(value) {
+  const match = /^(\d+)x(\d+)$/.exec(value);
+  if (!match) {
+    throw new Error(`视口格式错误: ${value}，应类似 1440x980。`);
+  }
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+
+async function inspectPage(page) {
+  return page.evaluate(() => {
+    const html = document.documentElement.outerHTML;
+    const buttons = Array.from(document.querySelectorAll('button, a[role="button"], .button, .btn, .cta'));
+    const smallTargets = buttons
+      .map((node) => {
+        const rect = node.getBoundingClientRect();
+        const text = (node.textContent || node.getAttribute('aria-label') || '').trim().slice(0, 40);
+        return { text, width: Math.round(rect.width), height: Math.round(rect.height) };
+      })
+      .filter((item) => item.width > 0 && item.height > 0 && (item.width < 44 || item.height < 44));
+
+    return {
+      title: document.title,
+      screenLabels: Array.from(document.querySelectorAll('[data-screen-label]')).map((node) =>
+        node.getAttribute('data-screen-label'),
+      ),
+      editModeBlocks: (html.match(/EDITMODE-BEGIN/g) || []).length,
+      hasEditModeAvailable: html.includes('__edit_mode_available'),
+      hasEditModeSetKeys: html.includes('__edit_mode_set_keys'),
+      hasEditsPayload: /\bedits\s*:|["']edits["']/.test(html),
+      documentWidth: document.documentElement.scrollWidth,
+      viewportWidth: window.innerWidth,
+      horizontalOverflow: document.documentElement.scrollWidth > window.innerWidth + 2,
+      smallTargets,
+    };
+  });
+}
+
+async function checkViewport(page, url, viewport, screenshotPath, waitMs) {
+  const consoleMessages = [];
+  const onConsole = (msg) => consoleMessages.push({ type: msg.type(), text: msg.text() });
+  const onPageError = (error) => consoleMessages.push({ type: 'pageerror', text: error.message });
+  page.on('console', onConsole);
+  page.on('pageerror', onPageError);
+  await page.setViewportSize(viewport);
+  await page.goto(url, { waitUntil: 'load' });
+  if (waitMs > 0) {
+    await page.waitForTimeout(waitMs);
+  }
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+  const inspection = await inspectPage(page);
+  page.off('console', onConsole);
+  page.off('pageerror', onPageError);
+  return { viewport, screenshot: screenshotPath, console: consoleMessages, inspection };
+}
+
+function collectIssues(result, options) {
+  const issues = [];
+  for (const key of ['desktop', 'mobile']) {
+    const item = result[key];
+    const badConsole = item.console.filter((entry) => entry.type === 'error' || entry.type === 'pageerror');
+    if (badConsole.length) {
+      issues.push(`${key}: 存在 console error 或 pageerror。`);
+    }
+    if (item.inspection.horizontalOverflow) {
+      issues.push(`${key}: 存在横向溢出。`);
+    }
+    if (!item.inspection.screenLabels.length) {
+      issues.push(`${key}: 缺少 data-screen-label。`);
+    }
+    if (options.requireTweaks) {
+      if (item.inspection.editModeBlocks !== 1) {
+        issues.push(`${key}: EDITMODE JSON block 数量不是 1。`);
+      }
+      if (!item.inspection.hasEditModeAvailable || !item.inspection.hasEditModeSetKeys) {
+        issues.push(`${key}: Tweaks 协议消息不完整。`);
+      }
+      if (!item.inspection.hasEditsPayload) {
+        issues.push(`${key}: Tweaks 未检测到 edits payload。`);
+      }
+    }
+  }
+  const smallMobileTargets = result.mobile.inspection.smallTargets;
+  if (smallMobileTargets.length) {
+    issues.push(`mobile: ${smallMobileTargets.length} 个可点击目标小于 44px。`);
+  }
+  return issues;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const htmlPath = resolve(args.html);
+  const outDir = resolve(args.outDir);
+  const screenshotsDir = resolve(args.screenshotsDir || args.outDir);
+  const reportPath = resolve(args.report || resolve(args.outDir, 'browser-check.json'));
+  await mkdir(outDir, { recursive: true });
+  await mkdir(screenshotsDir, { recursive: true });
+
+  const browser = await chromium.launch({ headless: true });
+  const url = pathToFileURL(htmlPath).href;
+  const result = { html: htmlPath, options: { requireTweaks: args.requireTweaks } };
+
+  try {
+    const desktopPage = await browser.newPage();
+    result.desktop = await checkViewport(
+      desktopPage,
+      url,
+      parseViewport(args.desktop),
+      resolve(screenshotsDir, 'desktop.png'),
+      args.wait,
+    );
+    await desktopPage.close();
+
+    const mobilePage = await browser.newPage();
+    result.mobile = await checkViewport(
+      mobilePage,
+      url,
+      parseViewport(args.mobile),
+      resolve(screenshotsDir, 'mobile.png'),
+      args.wait,
+    );
+    await mobilePage.close();
+  } finally {
+    await browser.close();
+  }
+
+  result.issues = collectIssues(result, args);
+  result.pass = result.issues.length === 0;
+  await writeFile(reportPath, JSON.stringify(result, null, 2));
+  console.log(JSON.stringify({ pass: result.pass, issues: result.issues }, null, 2));
+  process.exit(result.pass ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});