auto_update.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
GH Release Fetch（GitHub 发行版拉取工具）：按 GitHub Releases 解析版本并下载资产。
配置可为单文件 apps.json，或 apps/ 目录（root.json + windows|darwin|linux 分片目录）。
也可用 --apps-dir 指向另一套同级目录（如 VibeCodingToolsDown/，内含 root.json 与分片），与 apps/ 互不合并。
resolve_via=github_pages_manifest：从 root.json 的 vibecoding_manifest_url（本地路径或 https raw）读取 manifest.json，可与 CI 提交到 main 的 manifest 或 gh-pages 配套。
resolve_via=go_dev_json：从 https://go.dev/dl/?mode=json 解析 Go 官方稳定版与安装包（golang/go 仓库无 Release 资产）。
resolve_via=docker_desktop：从 docker/docs 发布说明解析 Docker Desktop 最新版与 desktop.docker.com 直链（非 GitHub Release）。
合并后仍使用 platforms.windows / darwin / linux；可用 --platform 覆盖当前系统。
条目的「简介」「分类」仅供人阅读，脚本不解析。
"""

import argparse
import json
import logging
import os
import re
import subprocess
import sys
import time
import urllib.parse

import requests
from bs4 import BeautifulSoup

try:
    import urllib3
except ImportError:
    urllib3 = None

def _script_dir():
    if getattr(sys, "frozen", False):
        return os.path.dirname(os.path.abspath(sys.executable))
    return os.path.dirname(os.path.abspath(__file__))


SCRIPT_DIR = _script_dir()
CONFIG_PATH = os.path.join(SCRIPT_DIR, "apps.json")
APPS_DIR = os.path.join(SCRIPT_DIR, "apps")
APPS_ROOT_FRAGMENT = os.path.join(APPS_DIR, "root.json")

def _logging_handlers():
    handlers = [logging.StreamHandler()]
    try:
        handlers.insert(0, logging.FileHandler(os.path.join(SCRIPT_DIR, "update_log.txt"), encoding="utf-8"))
    except OSError:
        # A read-only application directory must not prevent --help or startup.
        pass
    return handlers


logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=_logging_handlers(),
)
logger = logging.getLogger(__name__)

DEFAULT_RELEASE_PAGE_MIRRORS = [
    "https://github.com",
]

DEFAULT_NETWORK_PROBE_URLS = [
    "https://github.com",
    "https://api.github.com",
    "https://gh-proxy.com",
    "https://ghp.ci",
    "https://mirror.ghproxy.com",
]


def resolve_tls_verify(cfg, insecure_cli):
    """默认校验证书；--insecure 或 apps.json 根级 ssl_verify=false 时关闭（镜像证书过期等场景）。"""
    if insecure_cli:
        return False
    if cfg.get("ssl_verify") is False:
        return False
    return True


def configure_insecure_requests(verify):
    if verify or urllib3 is None:
        return
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


def _load_json_array_file(path, label):
    with open(path, encoding="utf-8") as f:
        data = json.load(f)
    if isinstance(data, dict) and "apps" in data:
        data = data["apps"]
    if not isinstance(data, list):
        raise ValueError("%s：必须是 JSON 数组，或 {\"apps\": []} 形式" % label)
    return data


def _merge_platform_json_dir(platform_dir, platform_label):
    """合并 apps/<platform>/*.json 分片；同一平台内 id 必须唯一。"""
    merged = []
    seen_ids = set()
    if not os.path.isdir(platform_dir):
        return merged
    for name in sorted(os.listdir(platform_dir)):
        if not name.endswith(".json"):
            continue
        path = os.path.join(platform_dir, name)
        chunk = _load_json_array_file(path, path)
        for app in chunk:
            aid = (app.get("id") or "").strip()
            if not aid:
                raise ValueError("%s 中有缺少 id 的条目" % path)
            if aid in seen_ids:
                raise ValueError(
                    "重复的 id %r（出现在多个 %s 分片中）" % (aid, platform_label)
                )
            seen_ids.add(aid)
        merged.extend(chunk)
    return merged


def _load_platform_apps(apps_dir, platform_key):
    """
    优先读取 apps/<platform_key>/*.json（按文件名排序合并）；
    若该目录不存在或无 .json 分片，则回退到 apps/<platform_key>.json 单文件。
    """
    dir_path = os.path.join(apps_dir, platform_key)
    single_path = os.path.join(apps_dir, "%s.json" % platform_key)
    if os.path.isdir(dir_path):
        json_names = [n for n in os.listdir(dir_path) if n.endswith(".json")]
        if json_names:
            return _merge_platform_json_dir(dir_path, platform_key)
    if os.path.isfile(single_path):
        return _load_json_array_file(single_path, single_path)
    return []


def load_config_from_apps_dir(apps_dir, only_platforms=None):
    root_path = os.path.join(apps_dir, "root.json")
    if not os.path.isfile(root_path):
        raise FileNotFoundError(f"缺少 {root_path}")
    with open(root_path, encoding="utf-8") as f:
        cfg = json.load(f)
    if not isinstance(cfg, dict):
        raise ValueError("apps/root.json 必须是 JSON 对象")
    cfg.setdefault("platforms", {})
    platform_keys = cfg.get("platform_keys") or ("windows", "darwin", "linux")
    if only_platforms:
        want = {normalize_platform_arg(p) or p for p in only_platforms if p}
        keys_to_load = [k for k in platform_keys if k in want]
        if not keys_to_load:
            keys_to_load = sorted(want)
    else:
        keys_to_load = list(platform_keys)
    for key in keys_to_load:
        cfg["platforms"][key] = _load_platform_apps(apps_dir, key)
    counts = ", ".join(
        "%s %s 项" % (k, len(cfg["platforms"].get(k) or [])) for k in keys_to_load
    )
    logger.info("已从配置目录合并：%s — %s", apps_dir, counts)
    cfg["_apps_config_root"] = os.path.abspath(apps_dir)
    return cfg


def load_config(apps_dir=None, only_platforms=None):
    """
    apps_dir: 可选，为含 root.json 的配置根目录（相对路径时相对本脚本所在目录）。
    only_platforms: 仅合并这些平台分片（如 ["windows"]），避免其它平台数据错误阻断本次任务。
    默认使用 apps/（存在 apps/root.json 时）或 apps.json。
    """
    if apps_dir:
        path = apps_dir
        if not os.path.isabs(path):
            path = os.path.normpath(os.path.join(SCRIPT_DIR, path))
        root_path = os.path.join(path, "root.json")
        if not os.path.isfile(root_path):
            raise FileNotFoundError("缺少 %s（--apps-dir 须指向含 root.json 的目录）" % root_path)
        return load_config_from_apps_dir(path, only_platforms=only_platforms)
    if os.path.isfile(APPS_ROOT_FRAGMENT):
        return load_config_from_apps_dir(APPS_DIR, only_platforms=only_platforms)
    if os.path.isfile(CONFIG_PATH):
        with open(CONFIG_PATH, encoding="utf-8") as f:
            return json.load(f)
    raise FileNotFoundError(
        "缺少配置：请放置 apps.json，或创建 apps/root.json 与 apps/windows/*.json"
    )


def probe_network(cfg, verify=True, per_url_timeout=6):
    """
    多端点网络探测：依次尝试 github.com / api.github.com / cfg.release_page_mirrors
    与内置镜像，任一可达即认为网络可用。全部失败只返回 False，不直接终止脚本。
    """
    candidates = []
    seen = set()

    def add(url):
        if not url:
            return
        normalized = normalize_release_mirror_base(url)
        if normalized and normalized not in seen:
            seen.add(normalized)
            candidates.append(normalized)

    for base in (cfg or {}).get("release_page_mirrors") or []:
        add(base)
    for base in DEFAULT_NETWORK_PROBE_URLS:
        add(base)

    last_error = None
    for url in candidates:
        try:
            requests.get(url, timeout=per_url_timeout, verify=verify, headers=github_headers())
            logger.info("网络探测通过：%s", url)
            return True, None
        except requests.exceptions.RequestException as e:
            last_error = (url, e)
            logger.debug("网络探测失败：%s -> %s", url, e)
    return False, last_error


def github_headers():
    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        )
    }
    token = (os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN") or "").strip()
    if token:
        headers["Authorization"] = f"Bearer {token}"
    return headers


def github_rate_limited(exc: BaseException) -> bool:
    if not isinstance(exc, requests.HTTPError) or exc.response is None:
        return False
    if exc.response.status_code != 403:
        return False
    body = (exc.response.text or "").lower()
    return "rate limit" in body or "api rate limit" in body


def uses_github_pages_manifest(app):
    return (app.get("resolve_via") or "").strip().lower() == "github_pages_manifest"


def uses_go_dev_json(app):
    return (app.get("resolve_via") or "").strip().lower() == "go_dev_json"


def uses_docker_desktop(app):
    return (app.get("resolve_via") or "").strip().lower() == "docker_desktop"


DOCKER_DESKTOP_RELEASE_NOTES_RAW = (
    "https://raw.githubusercontent.com/docker/docs/main/content/manuals/desktop/release-notes.md"
)

DOCKER_DESKTOP_ASSETS = {
    "windows_x64": ("win", "amd64", "Docker%20Desktop%20Installer.exe"),
    "windows_arm64": ("win", "arm64", "Docker%20Desktop%20Installer.exe"),
    "darwin_arm64": ("mac", "arm64", "Docker.dmg"),
    "darwin_amd64": ("mac", "amd64", "Docker.dmg"),
    "linux_amd64_deb": ("linux", "amd64", "docker-desktop-amd64.deb"),
    "linux_amd64_rpm": ("linux", "amd64", "docker-desktop-x86_64.rpm"),
    "linux_amd64_arch": ("linux", "amd64", "docker-desktop-x86_64.pkg.tar.zst"),
}


def _load_vibecoding_manifest(url_or_path, verify=True, apps_config_root=None):
    """加载 manifest.json（HTTPS URL；本地路径相对 --apps-dir 配置根，见 cfg _apps_config_root）。"""
    raw = (url_or_path or "").strip()
    if not raw:
        raise ValueError("manifest URL 为空")
    if raw.startswith("http://") or raw.startswith("https://"):
        response = requests.get(raw, headers=github_headers(), timeout=45, verify=verify)
        response.raise_for_status()
        return response.json()
    path = raw
    if not os.path.isabs(path):
        rel = path.lstrip("./\\")
        # 依次尝试：配置根(apps/)、配置根上一级(安装/仓库根)、脚本所在目录
        candidates = []
        if apps_config_root:
            candidates.append(os.path.normpath(os.path.join(apps_config_root, rel)))
            candidates.append(
                os.path.normpath(os.path.join(os.path.dirname(apps_config_root), rel))
            )
        candidates.append(os.path.normpath(os.path.join(SCRIPT_DIR, rel)))
        path = next((p for p in candidates if os.path.isfile(p)), candidates[0])
    with open(path, encoding="utf-8") as f:
        return json.load(f)


def _manifest_refresh_enabled(app, cfg) -> bool:
    """条目 refresh_manifest_before_resolve 优先；否则看 root 级（默认 true）。"""
    if "refresh_manifest_before_resolve" in app:
        return bool(app.get("refresh_manifest_before_resolve"))
    if isinstance(cfg, dict) and "refresh_manifest_before_resolve" in cfg:
        return bool(cfg.get("refresh_manifest_before_resolve"))
    return True


def _resolve_local_manifest_path(raw: str, apps_config_root=None) -> str | None:
    """若 vibecoding_manifest_url 指向本地文件则返回绝对路径，否则 None。"""
    raw = (raw or "").strip()
    if not raw or raw.startswith("http://") or raw.startswith("https://"):
        return None
    rel = raw.lstrip("./\\")
    candidates = []
    if apps_config_root:
        candidates.append(os.path.normpath(os.path.join(apps_config_root, rel)))
        candidates.append(
            os.path.normpath(os.path.join(os.path.dirname(apps_config_root), rel))
        )
    candidates.append(os.path.normpath(os.path.join(SCRIPT_DIR, rel)))
    for p in candidates:
        if os.path.isfile(p):
            return p
    # 即使尚未生成，也返回首选路径，便于 --only 写出
    return candidates[0] if candidates else None


def _refresh_manifest_item(mid: str, manifest_path: str) -> bool:
    """调用 build_manifest.py --only <id> 合并刷新本地 manifest。成功返回 True。

    打包成 exe（frozen）时 sys.executable 即本程序，不能把 --only 传给它；
    便携包应直接使用包内 snapshot。路径含空格时用 list 传参即可。
    """
    if getattr(sys, "frozen", False):
        logger.info(
            "[%s] 打包运行（frozen）跳过联网刷新 manifest，将使用已有 snapshot",
            mid,
        )
        return False
    script = os.path.join(
        SCRIPT_DIR, "VibeCodingToolsDown", "scripts", "build_manifest.py"
    )
    if not os.path.isfile(script):
        logger.warning("未找到 %s，跳过 manifest 实时刷新", script)
        return False
    out_root = os.path.dirname(os.path.dirname(manifest_path))  # .../dist
    cmd = [
        sys.executable,
        script,
        "--only",
        mid,
        "--output-dir",
        out_root,
    ]
    logger.info("[%s] 下载前刷新 manifest: %s", mid, " ".join(cmd))
    try:
        proc = subprocess.run(
            cmd,
            cwd=SCRIPT_DIR,
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            timeout=120,
        )
    except Exception as e:
        logger.warning("[%s] manifest 刷新异常，将使用已有快照: %s", mid, e)
        return False
    if proc.stdout:
        for line in proc.stdout.strip().splitlines()[-5:]:
            logger.info("[manifest] %s", line)
    if proc.returncode != 0:
        err = (proc.stderr or proc.stdout or "").strip()
        logger.warning(
            "[%s] manifest 刷新失败 (exit %s)，将使用已有快照: %s",
            mid,
            proc.returncode,
            err[-400:] if err else "(无输出)",
        )
        return False
    return True


def resolve_github_pages_manifest(app, verify, cfg, platform_key):
    raw = (app.get("manifest_url") or "").strip() or (cfg.get("vibecoding_manifest_url") or "").strip()
    mid = (app.get("manifest_item_id") or app["id"]).strip()
    local_path = _resolve_local_manifest_path(raw, cfg.get("_apps_config_root"))
    if local_path and _manifest_refresh_enabled(app, cfg):
        _refresh_manifest_item(mid, local_path)
    data = _load_vibecoding_manifest(
        raw, verify=verify, apps_config_root=cfg.get("_apps_config_root")
    )
    item = None
    for it in data.get("items") or []:
        if (it.get("id") or "").strip() == mid:
            item = it
            break
    if not item:
        raise RuntimeError("manifest 中找不到 id=%r" % mid)
    plat = platform_key or detect_platform_key()
    blk = (item.get("downloads") or {}).get(plat)
    if not blk or not (blk.get("url") or "").strip():
        raise RuntimeError("manifest 中 %s / %s 无可用下载地址（参见 manifest notes）" % (mid, plat))
    url = blk["url"].strip()
    vtag = (item.get("version_tag") or "").strip()
    vplain = (item.get("version") or "").strip()
    if app.get("version_tag_as_on_github") and vtag:
        version = vtag
    elif vplain and not str(vplain).startswith("v"):
        version = "v" + vplain.lstrip("v")
    else:
        version = vplain or "v0"
    return version, url


def resolve_go_dev_json(app, verify, platform_key):
    """从 go.dev/dl/?mode=json 取最新 stable 版本与指定 OS/arch/kind 的官方安装包。"""
    json_url = (app.get("go_dev_json_url") or "https://go.dev/dl/?mode=json").strip()
    response = requests.get(json_url, headers=github_headers(), timeout=45, verify=verify)
    response.raise_for_status()
    releases = response.json()
    if not isinstance(releases, list) or not releases:
        raise RuntimeError("go.dev JSON 为空或格式异常")

    picked = None
    for rel in releases:
        if rel.get("stable"):
            picked = rel
            break
    if not picked:
        picked = releases[0]

    version_full = (picked.get("version") or "").strip()
    if not version_full.startswith("go"):
        raise RuntimeError("go.dev 版本字段异常: %r" % version_full)
    version_num = version_full[2:]

    plat = platform_key or detect_platform_key()
    target_os = (app.get("go_dev_os") or plat).strip().lower()
    if target_os in ("mac", "macos", "osx"):
        target_os = "darwin"
    target_arch = (app.get("go_dev_arch") or "amd64").strip().lower()
    target_kind = (app.get("go_dev_kind") or "installer").strip().lower()

    match = None
    for f in picked.get("files") or []:
        if (
            (f.get("os") or "") == target_os
            and (f.get("arch") or "") == target_arch
            and (f.get("kind") or "") == target_kind
        ):
            match = f
            break
    if not match:
        raise RuntimeError(
            "go.dev 未找到 os=%s arch=%s kind=%s（版本 %s）"
            % (target_os, target_arch, target_kind, version_full)
        )

    filename = (match.get("filename") or "").strip()
    if not filename:
        raise RuntimeError("go.dev 匹配文件缺少 filename")
    download_url = "https://go.dev/dl/%s" % filename
    logger.info(
        "[%s] go.dev 解析: %s -> %s",
        app["id"],
        version_full,
        download_url,
    )
    return version_num, download_url


def resolve_docker_desktop(app, verify):
    """从 docker/docs release-notes.md 解析 Docker Desktop 版本、build 与 desktop.docker.com 直链。"""
    asset_key = (app.get("docker_desktop_asset") or "").strip()
    if not asset_key:
        plat = detect_platform_key()
        defaults = {
            "windows": "windows_x64",
            "darwin": "darwin_arm64",
            "linux": "linux_amd64_deb",
        }
        asset_key = defaults.get(plat, "windows_x64")
    spec = DOCKER_DESKTOP_ASSETS.get(asset_key)
    if not spec:
        raise RuntimeError("未知 docker_desktop_asset=%r" % asset_key)

    raw_url = (
        app.get("docker_desktop_release_notes_url") or DOCKER_DESKTOP_RELEASE_NOTES_RAW
    ).strip()
    response = requests.get(raw_url, headers=github_headers(), timeout=45, verify=verify)
    response.raise_for_status()
    md = response.text

    ver_m = re.search(r"##\s+(4\.\d+\.\d+)\s*$", md, re.M)
    if not ver_m:
        raise RuntimeError("无法从 Docker Desktop 发布说明解析版本")
    version = ver_m.group(1)

    build_m = re.search(
        r'version="' + re.escape(version) + r'"\s+build_path="/(\d+)/"',
        md,
    )
    if not build_m:
        build_m = re.search(r'build_path="/(\d+)/"', md)
    if not build_m:
        raise RuntimeError("无法从 Docker Desktop 发布说明解析 build 号")
    build = build_m.group(1)

    os_part, arch_part, filename = spec
    download_url = "https://desktop.docker.com/%s/main/%s/%s/%s" % (
        os_part,
        arch_part,
        build,
        filename,
    )
    logger.info(
        "[%s] Docker Desktop 解析: %s build=%s -> %s",
        app["id"],
        version,
        build,
        download_url,
    )
    return version, download_url


def canonical_releases_url(repo_path, base_url="https://github.com"):
    repo = repo_path.strip("/")
    return f"{base_url.rstrip('/')}/{repo}/releases"


def normalize_release_mirror_base(url):
    if not url:
        return None
    base = url.strip().rstrip("/")
    if not base.startswith("http://") and not base.startswith("https://"):
        base = "https://" + base
    return base


def release_page_candidates(app, cfg=None):
    urls = []
    seen = set()

    def add(url):
        if not url:
            return
        if url not in seen:
            seen.add(url)
            urls.append(url)

    add((app.get("releases_url") or "").strip())

    for base in (cfg or {}).get("release_page_mirrors") or []:
        normalized = normalize_release_mirror_base(base)
        if normalized:
            add(canonical_releases_url(app["repo_path"], normalized))

    for base in DEFAULT_RELEASE_PAGE_MIRRORS:
        add(canonical_releases_url(app["repo_path"], base))

    return urls


def request_release_page(app, verify=True, cfg=None):
    errors = []
    if cfg is None:
        cfg = load_config()
    for url in release_page_candidates(app, cfg):
        try:
            logger.info("[%s] 正在检查最新版本: %s", app["id"], url)
            response = requests.get(url, headers=github_headers(), timeout=30, verify=verify)
            response.raise_for_status()
            return url, response.text
        except Exception as e:
            errors.append((url, e))
            logger.warning("[%s] 发布页获取失败: %s -> %s", app["id"], url, e)

    detail = " | ".join(f"{url}: {err}" for url, err in errors) if errors else "无候选地址"
    raise RuntimeError(f"所有发布页来源均失败：{detail}")


def api_latest_release_url(app):
    repo = app["repo_path"].strip("/")
    return f"https://api.github.com/repos/{repo}/releases/latest"


def api_release_tag_url(app, version):
    repo = app["repo_path"].strip("/")
    encoded = urllib.parse.quote((version or "").strip(), safe="")
    return f"https://api.github.com/repos/{repo}/releases/tags/{encoded}"


def pinned_release_tag(app):
    return (app.get("pinned_release_tag") or app.get("release_tag_hint") or "").strip() or None


def extract_version_for_app(app, version):
    version = (version or "").strip()
    if not version:
        raise RuntimeError("版本号为空")
    if app.get("version_tag_as_on_github"):
        return version
    if not version.startswith("v"):
        return "v" + version
    return version


def asset_targets_app(asset_name, asset_url, app):
    href = asset_url or asset_name or ""
    text = asset_name or ""
    if link_targets_app(href, text, app):
        return True
    markers = app.get("installer_markers") or []
    if markers:
        return False
    hint = (app.get("url_hint") or app["id"]).lower()
    if hint not in href.lower() and hint not in text.lower():
        return False
    exts = installer_extensions(app)
    base = href.split("?", 1)[0].lower()
    if exts and not any(base.endswith(e.lower()) for e in exts):
        return False
    return href_allowed_for_app(href, app)


def fetch_release_via_api(app, verify=True, version_hint=None):
    version_hint = version_hint or pinned_release_tag(app)
    url = api_release_tag_url(app, version_hint) if version_hint else api_latest_release_url(app)
    logger.info("[%s] 尝试使用 GitHub API: %s", app["id"], url)
    response = requests.get(
        url,
        headers={
            **github_headers(),
            "Accept": "application/vnd.github+json",
            "X-GitHub-Api-Version": "2022-11-28",
        },
        timeout=30,
        verify=verify,
    )
    response.raise_for_status()
    payload = response.json()
    version = extract_version_for_app(app, payload.get("tag_name") or payload.get("name") or "")
    download_url = None
    for asset in payload.get("assets") or []:
        asset_url = asset.get("browser_download_url") or ""
        asset_name = asset.get("name") or ""
        if asset_targets_app(asset_name, asset_url, app):
            download_url = asset_url
            logger.info("[%s] 从 GitHub API 中找到下载链接: %s", app["id"], download_url)
            break
    if app.get("custom_update_mode") == "github" and not download_url:
        names = "、".join(str(a.get("name") or "") for a in (payload.get("assets") or [])[:12])
        raise RuntimeError("[%s] 新 Release 没有匹配该平台/架构/安装包类型的附件；可能尚未发布，或文件名规则已变化。请到自定义管理中重新识别。现有附件：%s" % (app["id"], names or "无"))
    logger.info("[%s] 通过 GitHub API 找到最新版本: %s", app["id"], version)
    return version, download_url


def find_release_version_from_page(soup, app):
    repo = app["repo_path"].strip("/")
    pattern = re.compile(rf"^/{re.escape(repo)}/releases/tag/([^/?#]+)$")
    for link in soup.find_all("a", href=True):
        href = link.get("href", "").strip()
        match = pattern.match(href)
        if not match:
            continue
        text = link.get_text(strip=True)
        tag_from_href = urllib.parse.unquote(match.group(1))
        if re.fullmatch(r"v?\d+(?:\.\d+){1,3}(?:[-+._a-zA-Z0-9]*)?", text or ""):
            version = text
        else:
            version = tag_from_href
        if not version:
            continue
        return extract_version_for_app(app, version)
    return None


def resolve_download_root(cfg):
    raw = (cfg.get("download_dir") or ".").strip()
    path = raw if os.path.isabs(raw) else os.path.normpath(os.path.join(SCRIPT_DIR, raw))
    if not os.path.isdir(path):
        os.makedirs(path)
        logger.info("创建下载目录: %s", path)
    return path


def app_target_dir(root, app):
    sub = (app.get("save_subdir") or "").strip().replace("\\", "/").strip("/")
    if not sub:
        return root
    d = os.path.join(root, *sub.split("/"))
    if not os.path.isdir(d):
        os.makedirs(d)
    return d


def detect_platform_key():
    if sys.platform == "win32":
        return "windows"
    if sys.platform == "darwin":
        return "darwin"
    if sys.platform.startswith("linux"):
        return "linux"
    return "windows"


def normalize_platform_arg(name):
    if not name:
        return None
    n = name.strip().lower()
    aliases = {
        "win": "windows",
        "mac": "darwin",
        "macos": "darwin",
        "osx": "darwin",
        "apk": "android",
    }
    return aliases.get(n, n)


def apps_list_from_config(cfg, platform_override=None):
    """
    优先使用 platforms.<windows|darwin|linux|android|ios> 分块；
    若仍使用根级 apps（旧版），则按条目的 only_on 过滤当前系统。
    """
    if isinstance(cfg.get("platforms"), dict):
        key = normalize_platform_arg(platform_override) or detect_platform_key()
        block = cfg["platforms"].get(key)
        if block is None:
            logger.warning(
                "配置 platforms 中无 %r 键，当前没有可处理的应用（可用 --platform 指定）",
                key,
            )
            return []
        if not isinstance(block, list):
            raise ValueError("platforms.%s 必须是 JSON 数组" % key)
        logger.info("使用 platforms.%s（共 %s 项）", key, len(block))
        return block
    legacy = cfg.get("apps") or []
    return _filter_legacy_apps_by_only_on(legacy)


def _filter_legacy_apps_by_only_on(apps):
    out = []
    for a in apps:
        only = (a.get("only_on") or "").strip().lower()
        if not only or only in ("any", "all", "*"):
            out.append(a)
            continue
        if only == "windows" and sys.platform == "win32":
            out.append(a)
        elif only == "darwin" and sys.platform == "darwin":
            out.append(a)
        elif only == "linux" and sys.platform.startswith("linux"):
            out.append(a)
    if len(out) != len(apps):
        logger.info("根级 apps：已按 only_on 过滤为 %s 项（旧版配置）", len(out))
    return out


def installer_extensions(app):
    if app.get("installer_extensions"):
        return list(app["installer_extensions"])
    if app.get("windows_installer"):
        return [".exe"]
    return []


def href_allowed_for_app(href, app):
    pattern = app.get("installer_filename_regex")
    if pattern:
        filename = urllib.parse.unquote(urllib.parse.urlparse(href).path.rsplit("/", 1)[-1])
        if not re.fullmatch(pattern, filename, re.IGNORECASE):
            return False
    for sub in app.get("href_exclude_substrings") or []:
        if sub in href:
            return False
    return True


def link_targets_app(href, text, app):
    if app.get("installer_filename_regex"):
        return href_allowed_for_app(href, app)
    markers = app.get("installer_markers") or []
    if not markers:
        return False
    if app.get("installer_markers_match_all"):
        if not all(m in href or m in text for m in markers):
            return False
    elif not any(m in href or m in text for m in markers):
        return False
    if not href_allowed_for_app(href, app):
        return False
    base = href.split("?", 1)[0].lower()
    if base.endswith(".blockmap") or base.endswith(".sig") or base.endswith(".digest"):
        return False
    exts = installer_extensions(app)
    if exts and not any(base.endswith(e.lower()) for e in exts):
        return False
    return True


def check_latest_version(app, debug_html_path, verify=True, cfg=None, platform_key=None):
    if app.get("fixed_download_url"):
        return "fixed", app["fixed_download_url"]
    if uses_github_pages_manifest(app):
        plat = platform_key or detect_platform_key()
        return resolve_github_pages_manifest(app, verify, cfg, plat)
    if uses_go_dev_json(app):
        plat = platform_key or detect_platform_key()
        return resolve_go_dev_json(app, verify, plat)
    if uses_docker_desktop(app):
        return resolve_docker_desktop(app, verify)

    api_rate_limited = False
    if app.get("prefer_api_assets"):
        try:
            return fetch_release_via_api(app, verify=verify)
        except requests.HTTPError as e:
            if github_rate_limited(e):
                api_rate_limited = True
                logger.warning(
                    "[%s] GitHub API 限流，改用发布页 HTML 解析（可设置 GITHUB_TOKEN 提高额度）",
                    app["id"],
                )
            else:
                raise

    try:
        used_url, page_html = request_release_page(app, verify=verify, cfg=cfg)
        with open(debug_html_path, "w", encoding="utf-8") as f:
            f.write(page_html)
        logger.info("[%s] 已保存发布页 HTML: %s", app["id"], debug_html_path)

        soup = BeautifulSoup(page_html, "html.parser")
        download_url = None
        logger.info("[%s] 尝试从页面中查找下载链接...", app["id"])

        for link in soup.find_all("a", href=True):
            href = link.get("href", "")
            text = link.get_text(strip=True)
            if not link_targets_app(href, text, app):
                continue
            if "release-assets.githubusercontent.com" in href:
                if not any(m in href for m in (app.get("installer_markers") or [])):
                    continue
            if href.startswith("/"):
                download_url = f"https://github.com{href}"
            elif href.startswith("http"):
                download_url = href
            else:
                download_url = f"https://github.com/{href}"
            logger.info("[%s] 从页面中找到下载链接: %s", app["id"], download_url)
            break

        if not download_url:
            for link in soup.find_all("a", href=True):
                href = link.get("href", "")
                data_href = link.get("data-href", "")
                text = link.get_text(strip=True)
                for url in (href, data_href):
                    if not url or not link_targets_app(url, text, app):
                        continue
                    if url.startswith("/"):
                        download_url = f"https://github.com{url}"
                    elif url.startswith("http"):
                        download_url = url
                    else:
                        download_url = f"https://github.com/{url}"
                    logger.info("[%s] 从链接属性中找到下载链接: %s", app["id"], download_url)
                    break
                if download_url:
                    break

        hint = (app.get("url_hint") or app["id"]).lower()
        exts_for_scan = installer_extensions(app)
        if not exts_for_scan and app.get("windows_installer"):
            exts_for_scan = [".exe"]
        if not download_url:
            for link in soup.find_all("a", href=True):
                href = link.get("href", "")
                text = link.get_text(strip=True)
                if exts_for_scan and not any(e in href or e in text for e in exts_for_scan):
                    continue
                if hint not in href.lower() and hint not in text.lower():
                    continue
                if not any(m in href or m in text for m in (app.get("installer_markers") or []) if len(m) >= 2):
                    continue
                if exts_for_scan:
                    base = href.split("?", 1)[0].lower()
                    if not any(base.endswith(e.lower()) for e in exts_for_scan):
                        continue
                if not href_allowed_for_app(href, app):
                    continue
                if href.startswith("/"):
                    download_url = f"https://github.com{href}"
                elif href.startswith("http"):
                    download_url = href
                else:
                    download_url = f"https://github.com/{href}"
                logger.info("[%s] 从通用搜索中找到下载链接: %s", app["id"], download_url)
                break

        version = find_release_version_from_page(soup, app)
        if not version and download_url:
            ver_in_url = re.search(r"(\d+\.\d+\.\d+(?:\.\d+)?)", download_url)
            if ver_in_url:
                version = extract_version_for_app(app, ver_in_url.group(1))
        if not version:
            latest_release = soup.find("div", class_="release-header")
            if not latest_release:
                latest_release = soup.select_one(".release")
            if not latest_release:
                latest_release = soup.select_one('[data-view-component="true"].Link--primary')
            if not latest_release:
                raise RuntimeError("无法找到最新版本信息")

            version_tag = None
            if hasattr(latest_release, "find"):
                version_tag = latest_release.find("a", class_="Link--primary")
            if not version_tag:
                version_tag = soup.select_one('a[data-view-component="true"].Link--primary')
            if not version_tag:
                for tag in soup.find_all("a"):
                    if tag.text and re.search(r"v?\d+\.\d+\.\d+", tag.text):
                        version_tag = tag
                        break
            if not version_tag:
                raise RuntimeError("无法找到版本标签")

            version = extract_version_for_app(app, version_tag.text.strip())
        if not download_url:
            try:
                api_version, api_download_url = fetch_release_via_api(
                    app,
                    verify=verify,
                    version_hint=version,
                )
                if not version:
                    version = api_version or version
                download_url = api_download_url or download_url
            except Exception as api_error:
                logger.warning("[%s] GitHub API 补充下载链接失败: %s", app["id"], api_error)

        logger.info("[%s] 找到最新版本: %s", app["id"], version)
        logger.info("[%s] 成功使用发布页来源: %s", app["id"], used_url)
        if download_url:
            logger.info("[%s] 同时找到下载链接: %s", app["id"], download_url)
        else:
            logger.warning("[%s] 未能在页面中找到下载链接，将使用拼接 URL", app["id"])

        return version, download_url

    except Exception as e:
        if api_rate_limited:
            logger.error("[%s] 发布页解析失败（API 已限流）: %s", app["id"], e)
            raise
        logger.warning("[%s] 发布页解析失败，准备回退 GitHub API: %s", app["id"], e)
        try:
            return fetch_release_via_api(app, verify=verify)
        except Exception as api_error:
            logger.error("[%s] 检查版本时出错: %s", app["id"], api_error)
            import traceback

            logger.error(traceback.format_exc())
            raise api_error


def build_fallback_urls(version, app):
    if uses_github_pages_manifest(app) or uses_go_dev_json(app) or uses_docker_desktop(app):
        return []
    version_plain = version.lstrip("v")
    # tag 形如 release-1.13.3 时，文件名通常只用 1.13.3
    if version_plain.lower().startswith("release-"):
        version_plain = version_plain[8:]
    repo = (app.get("repo_path") or "").strip("/")
    if not repo:
        return []
    names = app.get("download_names") or []
    out = []
    for tpl in (app.get("download_url_templates") or []):
        out.append(tpl.replace("{ver}", version).replace("{ver_plain}", version_plain))
    for tpl in names:
        fname = tpl.replace("{ver}", version_plain).replace("{ver_plain}", version_plain)
        out.append(f"https://github.com/{repo}/releases/download/{version}/{fname}")
    return out


def normalize_download_url_list(parsed_url, fallback_urls):
    def expand_url(url):
        if not url:
            return []
        if "release-assets.githubusercontent.com" in url:
            return [url]
        if "github.com" in url and "gh-proxy" not in url and "release-assets" not in url:
            return [
                f"https://gh-proxy.com/{url}",
                f"https://ghp.ci/{url}",
                f"https://mirror.ghproxy.com/{url}",
                url,
            ]
        # downloads.cursor.com / cursor-cdn.com 等厂商 CDN 不要套 gh-proxy
        # （反代只代理 GitHub，套上去会 60s 超时后再试官方）
        return [url]

    download_urls = []
    if parsed_url:
        logger.info("使用从页面解析的下载链接: %s", parsed_url)
        download_urls.extend(expand_url(parsed_url))

    for base_url in fallback_urls:
        download_urls.extend(expand_url(base_url))

    deduped = []
    seen = set()
    for url in download_urls:
        if url in seen:
            continue
        seen.add(url)
        deduped.append(url)
    return deduped


def describe_download_failure(error):
    if isinstance(error, requests.exceptions.SSLError):
        return "HTTPS 证书校验失败，请检查系统时间、证书或下载地址"
    if isinstance(error, requests.exceptions.Timeout):
        return "网络请求超时，请稍后重试或检查代理"
    if isinstance(error, requests.exceptions.HTTPError):
        response = error.response
        status = response.status_code if response is not None else None
        if status in (403, 429):
            return "服务器拒绝访问或限流（HTTP %s），请稍后重试" % status
        if status in (404, 410):
            return "下载地址失效（HTTP %s），请在自定义管理中更新来源" % status
        return "下载服务器返回 HTTP %s" % (status or "错误")
    if isinstance(error, requests.exceptions.ConnectionError):
        return "网络连接失败或中断，请检查网络和代理"
    return str(error)


def download_installer(
    version, parsed_url, app, local_filename, max_retries=3, verify=True, platform_key=None
):
    version_plain = version.lstrip("v")
    fallback = build_fallback_urls(version, app)
    download_urls = normalize_download_url_list(parsed_url, fallback)

    if app.get("use_download_filename") and parsed_url:
        parsed = urllib.parse.urlparse(parsed_url)
        bn = urllib.parse.unquote(os.path.basename(parsed.path))
        if bn and "." in bn:
            expected_name = bn
        else:
            tpl = app.get("save_name") or (app.get("download_names") or ["setup-{ver}.exe"])[0]
            expected_name = tpl.replace("{ver}", version_plain)
    else:
        tpl = app.get("save_name") or (app.get("download_names") or ["setup-{ver}.exe"])[0]
        expected_name = tpl.replace("{ver}", version_plain)
    if os.path.basename(local_filename) != expected_name:
        local_filename = os.path.join(os.path.dirname(local_filename), expected_name)

    if platform_key:
        logger.info("开始下载安装程序到: %s [平台: %s]", local_filename, platform_key)
    else:
        logger.info("开始下载安装程序到: %s", local_filename)
    if os.path.exists(local_filename):
        try:
            os.remove(local_filename)
            logger.info("已删除旧文件: %s", local_filename)
        except OSError as e:
            logger.warning("删除旧文件失败: %s", e)

    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        )
    }
    referer = (app.get("download_referer") or "").strip()
    if not referer and "oray.com" in urllib.parse.urlparse(download_urls[0]).netloc:
        referer = "https://sunlogin.oray.com/download"
    if referer:
        headers["Referer"] = referer

    failure_reasons = []
    for url_index, download_url in enumerate(download_urls):
        if download_url.startswith("https://gh-proxy"):
            if "https:/github.com" in download_url and "https://github.com" not in download_url:
                download_url = download_url.replace("https:/github.com", "https://github.com")
            download_url = download_url.replace("https://https://", "https://")

        logger.info("尝试下载源 %s/%s: %s", url_index + 1, len(download_urls), download_url)
        retries = 0
        while retries < max_retries:
            try:
                response = requests.get(
                    download_url, stream=True, timeout=60, headers=headers, verify=verify
                )
                response.raise_for_status()
                total_size = int(response.headers.get("content-length", 0))
                downloaded = 0
                with open(local_filename, "wb") as f:
                    for chunk in response.iter_content(chunk_size=8192):
                        if chunk:
                            f.write(chunk)
                            downloaded += len(chunk)
                            if total_size > 0:
                                percent = 100.0 * downloaded / total_size
                                mb_done = downloaded / (1024 * 1024)
                                mb_total = total_size / (1024 * 1024)
                                sys.stdout.write(
                                    f"\r下载进度: {percent:.1f}% "
                                    f"({mb_done:.1f}/{mb_total:.1f} MiB)"
                                )
                                sys.stdout.flush()

                if os.path.exists(local_filename) and os.path.getsize(local_filename) > 0:
                    file_size = os.path.getsize(local_filename)
                    if total_size > 0:
                        if file_size != total_size:
                            logger.warning(
                                "下载的文件大小(%s)与预期(%s)不匹配", file_size, total_size
                            )
                            if retries < max_retries - 1:
                                retries += 1
                                logger.info("重试下载 (%s/%s)...", retries, max_retries)
                                try:
                                    os.remove(local_filename)
                                except OSError:
                                    pass
                                continue
                            raise RuntimeError(f"文件大小不匹配 ({file_size} != {total_size})")
                        logger.info("\n下载完成: %s (%s 字节)", local_filename, file_size)
                        logger.info("成功使用下载源 %s", download_url)
                        return local_filename
                    if file_size > 1000:
                        logger.info("\n下载完成: %s (%s 字节)", local_filename, file_size)
                        logger.info("成功使用下载源 %s", download_url)
                        return local_filename
                    logger.warning("下载的文件太小(%s 字节)", file_size)
                    if retries < max_retries - 1:
                        retries += 1
                        try:
                            os.remove(local_filename)
                        except OSError:
                            pass
                        continue
                    raise RuntimeError(f"文件太小 ({file_size} 字节)")
                logger.error("下载的文件不存在或为空")
                if retries < max_retries - 1:
                    retries += 1
                    continue
                raise RuntimeError("文件不存在或为空")

            except requests.exceptions.RequestException as e:
                failure_reasons.append(describe_download_failure(e))
                logger.error("下载请求出错: %s", e)
                if retries < max_retries - 1:
                    time.sleep(2**retries)
                    retries += 1
                    continue
                logger.warning("当前下载源失败，尝试下一个")
                break
            except Exception as e:
                failure_reasons.append(describe_download_failure(e))
                logger.error("下载安装程序时出错: %s", e)
                import traceback

                logger.error(traceback.format_exc())
                logger.warning("当前下载源失败，尝试下一个")
                break

        if app.get("custom_update_mode") and os.path.exists(local_filename):
            os.remove(local_filename)
        if os.path.exists(local_filename) and os.path.getsize(local_filename) > 0:
            file_size = os.path.getsize(local_filename)
            if file_size > 1000:
                logger.info("下载源 %s 成功，文件大小: %s 字节", url_index + 1, file_size)
                return local_filename
            try:
                os.remove(local_filename)
            except OSError:
                pass

    details = "；".join(dict.fromkeys(failure_reasons))
    raise RuntimeError(f"所有下载源均失败（共 {len(download_urls)} 个）" + ("：" + details if details else ""))


def kill_process(process_name):
    if not process_name:
        return
    try:
        logger.info("尝试终止进程: %s", process_name)
        if sys.platform == "win32":
            try:
                subprocess.run(
                    ["taskkill", "/F", "/IM", process_name],
                    check=True,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                )
                logger.info("已终止进程: %s", process_name)
            except subprocess.CalledProcessError as e:
                if e.returncode == 128:
                    logger.info("进程未运行: %s", process_name)
                else:
                    logger.warning("终止进程警告: %s", e)
        else:
            logger.warning("非 Windows 环境，跳过 taskkill")
    except Exception as e:
        logger.error("终止进程时出错: %s", e)
        raise


_ARCHIVE_EXTS = frozenset(
    {
        ".7z",
        ".zip",
        ".rar",
        ".tar",
        ".tgz",
        ".tbz",
        ".tbz2",
        ".txz",
        ".gz",
        ".bz2",
        ".xz",
        ".zst",
        ".lz4",
        ".lzma",
        ".cab",
    }
)
_ARCHIVE_COMPOUND_SUFFIXES = (
    ".tar.gz",
    ".tar.bz2",
    ".tar.xz",
    ".tar.zst",
    ".tar.lz",
    ".tar.lz4",
    ".tar.lzma",
)
_MOBILE_PACKAGE_EXTS = frozenset({".apk", ".aab", ".ipa"})


def is_archive_filename(path):
    name = os.path.basename(path or "").lower()
    if any(name.endswith(suffix) for suffix in _ARCHIVE_COMPOUND_SUFFIXES):
        return True
    return os.path.splitext(name)[1] in _ARCHIVE_EXTS


def reveal_in_file_manager(path):
    path = os.path.abspath(path)
    folder = os.path.dirname(path) if os.path.isfile(path) else path
    if not os.path.isdir(folder):
        logger.warning("下载目录不存在，无法打开: %s", folder)
        return False
    try:
        if sys.platform == "win32":
            if os.path.isfile(path):
                subprocess.Popen(["explorer", "/select,", os.path.normpath(path)])
            else:
                subprocess.Popen(["explorer", os.path.normpath(folder)])
        elif sys.platform == "darwin":
            if os.path.isfile(path):
                subprocess.Popen(["open", "-R", path])
            else:
                subprocess.Popen(["open", folder])
        else:
            subprocess.Popen(["xdg-open", folder])
        logger.info("已在文件管理器中打开下载目录: %s", folder)
        return True
    except Exception as e:
        logger.warning("打开下载目录失败: %s", e)
        return False


def run_installer(installer_path):
    logger.info("开始运行安装程序: %s", installer_path)
    if not os.path.exists(installer_path):
        raise FileNotFoundError(f"安装程序不存在: {installer_path}")

    try:
        subprocess.Popen([installer_path], shell=True)
        logger.info("安装程序已启动 (Popen)")
        return
    except Exception as e1:
        logger.warning("Popen 失败: %s", e1)

    if sys.platform == "win32":
        try:
            os.startfile(installer_path)
            logger.info("安装程序已启动 (startfile)")
            return
        except Exception as e2:
            logger.warning("startfile 失败: %s", e2)

    cmd = f'powershell -Command "Start-Process \'{installer_path}\' -Verb RunAs"'
    subprocess.run(cmd, shell=True, check=True)
    logger.info("安装程序已启动 (PowerShell RunAs)")


def select_apps(cfg, only_ids, platform_override=None):
    apps = apps_list_from_config(cfg, platform_override)
    if not only_ids:
        return [a for a in apps if a.get("enabled", True)]
    by_id = {a.get("id", "").lower(): a for a in apps if a.get("id")}
    picked = []
    for raw in only_ids:
        key = raw.lower()
        app = by_id.get(key)
        if app:
            picked.append(app)
        else:
            logger.warning("未处理 id=%r：配置中不存在", raw)
    return picked


def update_one(app, download_root, verify=True, platform_key=None, cfg=None, download_only=False):
    cfg = cfg or {}
    aid = app["id"]
    plat = platform_key or detect_platform_key()
    debug_html = os.path.join(SCRIPT_DIR, f"github_page_{plat}_{aid}.html")

    root = download_root
    if cfg.get("download_subdir_by_platform"):
        root = os.path.join(download_root, plat)
        if not os.path.isdir(root):
            os.makedirs(root)

    target_dir = app_target_dir(root, app)

    logger.info("=== [%s] 开始 === [平台: %s] [下载目录: %s]", aid, plat, target_dir)
    version, dl_url = check_latest_version(
        app, debug_html, verify=verify, cfg=cfg, platform_key=plat
    )
    version_plain = version.lstrip("v")
    if version_plain.lower().startswith("release-"):
        version_plain = version_plain[8:]
    tpl_save = app.get("save_name") or (app.get("download_names") or ["setup-{ver}.exe"])[0]
    local_filename = os.path.join(
        target_dir,
        tpl_save.replace("{ver}", version_plain).replace("{ver_plain}", version_plain),
    )
    if app.get("use_download_filename") and dl_url:
        pu = urllib.parse.urlparse(dl_url)
        base = urllib.parse.unquote(os.path.basename(pu.path))
        if base and "." in base:
            local_filename = os.path.join(target_dir, base)

    installer_path = download_installer(
        version, dl_url, app, local_filename, verify=verify, platform_key=plat
    )
    logger.info("[%s] 安装包已下载: %s", aid, installer_path)
    if download_only:
        return 0

    ext = os.path.splitext(installer_path)[1].lower()
    archive = is_archive_filename(installer_path)
    mobile = ext in _MOBILE_PACKAGE_EXTS
    if archive or mobile or not app.get("run_installer", True):
        if archive:
            logger.info("[%s] 压缩包仅下载，不自动解压或打开压缩包本身；打开所在目录", aid)
        elif mobile:
            logger.info("[%s] 移动端安装包仅下载，不执行安装（%s）；打开所在目录", aid, ext)
        else:
            logger.info("[%s] 配置为仅下载，跳过结束进程与启动安装包；打开所在目录", aid)
        reveal_in_file_manager(installer_path)
        return 0

    if app.get("kill_before_install", True):
        kill_process(app.get("process_name") or "")
        time.sleep(2)

    run_installer(installer_path)
    logger.info("=== [%s] 完成 ===", aid)
    return 0


def main():
    parser = argparse.ArgumentParser(description="按 apps.json 按需下载/更新应用")
    parser.add_argument(
        "app_id",
        nargs="*",
        help="只处理这些 id（省略则仅处理 enabled=true 的项；指定 id 时不要求 enabled）",
    )
    parser.add_argument(
        "--platform",
        metavar="NAME",
        help="读取 platforms.<NAME>（windows|darwin|linux|android|ios），默认随当前系统",
    )
    parser.add_argument(
        "--insecure",
        action="store_true",
        help="跳过 HTTPS 证书校验（镜像站点证书过期/自签时使用，存在中间人风险）",
    )
    parser.add_argument(
        "--apps-dir",
        metavar="DIR",
        help="替代默认 apps/：指定含 root.json 的目录（如 VibeCodingToolsDown，相对项目根目录）",
    )
    parser.add_argument(
        "--batch-download-dir",
        help="仅下载到指定目录（按平台分组），不启动安装程序或打开文件管理器",
    )
    args = parser.parse_args()

    platform_key = normalize_platform_arg(args.platform) or detect_platform_key()

    try:
        cfg = load_config(apps_dir=args.apps_dir, only_platforms=[platform_key])
    except Exception as e:
        logger.error("%s", e)
        return 1

    if args.batch_download_dir:
        cfg = dict(cfg, download_dir=args.batch_download_dir, download_subdir_by_platform=True)
    download_root = resolve_download_root(cfg)
    apps = select_apps(cfg, args.app_id, args.platform)
    if not apps:
        logger.error("没有可处理的应用：请检查 enabled 或命令行指定的 id 是否存在")
        return 1

    verify = resolve_tls_verify(cfg, args.insecure)
    configure_insecure_requests(verify)
    if not verify:
        logger.warning("已关闭 TLS 证书校验（--insecure 或 apps.json ssl_verify=false）")

    ok, last_error = probe_network(cfg, verify=verify)
    if not ok:
        if last_error:
            url, err = last_error
            logger.warning(
                "网络探测全部失败（最后一次：%s -> %s），仍将继续；"
                "若有本地 manifest 或可用镜像，单个应用的重试与兜底逻辑会接管。",
                url,
                err,
            )
        else:
            logger.warning("网络探测无候选地址，仍将继续。")

    exit_code = int(bool(args.batch_download_dir) and len(apps) != len(args.app_id))
    for app in apps:
        if app.get("open_page_only") is True:
            url = (app.get("open_page_url") or "").strip()
            logger.info(
                "[%s] 仅打开官网，跳过自动下载%s",
                app.get("id"),
                (" → " + url) if url else "（请用 lookup_app --open）",
            )
            continue
        if uses_github_pages_manifest(app) or app.get("fixed_download_url"):
            missing = [k for k in ("id",) if not app.get(k)]
        else:
            missing = [k for k in ("id", "releases_url", "repo_path") if k not in app]
        if missing:
            logger.error("应用配置缺少字段 %s: %s", missing, app)
            exit_code = 1
            continue
        try:
            update_one(
                app,
                download_root,
                verify=verify,
                platform_key=platform_key,
                cfg=cfg,
                download_only=bool(args.batch_download_dir),
            )
        except Exception as e:
            logger.error("[%s] 失败: %s", app.get("id"), e)
            exit_code = 1
    return exit_code


if __name__ == "__main__":
    from tools.ghrf_runtime import run_cli
    sys.exit(run_cli(main))