#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
1b1t-open-server — Minecraft 一键开服工具

向导流程: ①选择版本 ②选择目录 ③选择端口 ④常见配置(正版验证/命令方块/死亡不掉落等)
          ⑤高级选项(编辑 server.properties 全部项) → 自动下载核心并开服
子命令:   start [目录] | stop [目录] | restart [目录] | status [目录] | console <目录> <命令>
"""

import json
import os
import re
import select
import shlex
import shutil
import socket
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.parse
import urllib.request

# Windows 控制台兼容: 英文系统(cp1252)/管道重定向下中文不崩, 无法编码的字符替换
if hasattr(sys.stdout, "reconfigure"):
    try:
        sys.stdout.reconfigure(errors="replace")
        sys.stderr.reconfigure(errors="replace")
    except Exception:
        pass

# 本地安装包镜像目录 (下载过的文件缓存到这里, 下次直接从本地取)
MIRROR_DIR = os.path.expanduser("~/1b1t-mirror")
# 镜像的 HTTP 出口 (www.1b1t.cn/serverdown, 其他机器走隧道下载)
MIRROR_HTTP = "https://www.1b1t.cn/serverdown/"
S3_MIRROR = "https://cn-nb1.rains3.com/1b1t/serverdown"   # 存储桶镜像(直连高速)
# 软件设置文件 (settings 子命令修改)
SETTINGS_FILE = os.path.expanduser("~/.config/1b1t-open-server/settings.json")
SETTING_DEFAULTS = {
    "online_mode": "true", "difficulty": "normal", "motd": "1b1t Server",
    "keep_inventory": "false", "mirror_dir": "", "mirror_http": "",
}


def load_settings():
    try:
        with open(SETTINGS_FILE) as f:
            s = json.load(f)
        d = dict(SETTING_DEFAULTS)
        d.update(s)
        return d
    except (OSError, ValueError):
        return dict(SETTING_DEFAULTS)


def save_settings(s):
    os.makedirs(os.path.dirname(SETTINGS_FILE), exist_ok=True)
    with open(SETTINGS_FILE, "w") as f:
        json.dump(s, f, ensure_ascii=False, indent=2)


def mirror_dir():
    """镜像目录 (可在软件设置里改)"""
    st = load_settings()
    return os.path.expanduser(st.get("mirror_dir") or MIRROR_DIR)


def mirror_http():
    st = load_settings()
    return st.get("mirror_http") or MIRROR_HTTP

APP = "1b1t-open-server"
APP_VERSION = "2.0.7"  # 发版时更新 (version 子命令显示)
CACHE_DIR = os.path.expanduser("~/.cache/1b1t-open-server")
MANIFEST_URL = "https://bmclapi2.bangbang93.com/mc/game/version_manifest_v2.json"
BMCL_VERSION = "https://bmclapi2.bangbang93.com/version/{vid}/json"
BMCL_SERVER_JAR = "https://bmclapi2.bangbang93.com/version/{vid}/server"
RUNTIME_DIR = ".1b1t-open-server"      # 服务器目录下: pid/config/console.log
IS_WIN = (os.name == "nt")

# ---------- 子进程入口 (keeper / 收尾) ----------
# 冻结打包后 sys.executable 是自身二进制, "二进制 -c 代码" 跑不起来,
# 必须走 __sub 子命令 (见 main); 源码运行则用解释器跑本文件

def sub_cmd(name, arg):
    """__sub 子进程启动命令: 冻结版=自身二进制, 源码版=解释器跑本文件"""
    if getattr(sys, "frozen", False):
        return [sys.executable, "__sub", name, str(arg)]
    return [sys.executable, os.path.abspath(__file__), "__sub", name, str(arg)]


def run_keeper(port):
    """__sub keeper 子进程入口: 持有 java stdin 写端 + 监听本地 TCP 转发控制台命令
    注意: fd0 是管道写端(O_WRONLY), sys.stdin 会初始化失败, 必须用 os.write(0, ...)"""
    import socket as _s, select as _sel
    port = int(port)
    srv = _s.socket()
    srv.setsockopt(_s.SOL_SOCKET, _s.SO_REUSEADDR, 1)
    srv.bind(("127.0.0.1", port))
    srv.listen(4)
    try:  # Linux/macOS: poll 管道写端, java 退出(读端关闭)时 POLLERR 触发自杀
        poller = _sel.poll()
        poller.register(0, _sel.POLLERR | _sel.POLLHUP)
    except (AttributeError, OSError):
        poller = None
    while True:
        r, _, _ = _sel.select([srv], [], [], 0.2)
        if poller is not None:
            for _fd, ev in poller.poll(0):
                if ev & (_sel.POLLERR | _sel.POLLHUP):
                    sys.exit(0)  # java 已退出, 管道断裂
        if not r:
            continue
        c, _ = srv.accept()
        data = c.recv(65536).decode("utf-8", "ignore")
        c.close()
        for line in data.splitlines():
            try:
                os.write(0, (line + "\n").encode())
            except OSError:
                sys.exit(0)  # java 已退出, 管道断裂


def run_cleanup(server_dir):
    """__sub cleanup 子进程入口: 等服务器退出 → 必要时强杀进程组 → 杀 keeper → 删 pid.json
    (attach 里输 stop 后工具立即退出, 收尾交给这个分离进程, 保证关得干净)"""
    import signal
    rt = os.path.join(server_dir, RUNTIME_DIR)

    def load_pid():
        try:
            with open(os.path.join(rt, "pid.json")) as f:
                return json.load(f)
        except Exception:
            return None

    for _ in range(240):  # 最多等 4 分钟
        info = load_pid()
        if not info or not is_running(info["pid"]):
            break
        time.sleep(1)
    info = load_pid()
    if info and is_running(info["pid"]):  # 还没退, 强杀整个进程组
        try:
            os.killpg(info["pid"], 9)
        except (OSError, AttributeError):
            try:
                os.kill(info["pid"], 9)
            except OSError:
                pass
        time.sleep(2)
    if info:
        keeper = info.get("keeper")
        if keeper and is_running(keeper):
            try:
                os.kill(keeper, signal.SIGTERM)
            except OSError:
                pass
    try:
        os.remove(os.path.join(rt, "pid.json"))
    except OSError:
        pass

# 启动横幅 (figlet standard 字体)
BANNER = r"""
 _  _      _  _
/ || |__  / || |_    ___   _ __    ___  _ __          ___   ___  _ __ __   __ ___  _ __
| || '_ \ | || __|  / _ \ | '_ \  / _ \| '_ \  _____ / __| / _ \| '__|\ \ / // _ \| '__|
| || |_) || || |_  | (_) || |_) ||  __/| | | ||_____|\__ \|  __/| |    \ V /|  __/| |
|_||_.__/ |_| \__|  \___/ | .__/  \___||_| |_|       |___/ \___||_|     \_/  \___||_|
                          |_|
"""

# 版本 → 所需 Java 主版本 (>= 指该版本起)
JAVA_RULES = [
    ((1, 0, 0), (1, 16, 5), 8),
    ((1, 17, 0), (1, 17, 1), 16),
    ((1, 18, 0), (1, 20, 4), 17),
    ((1, 20, 5), (99, 0, 0), 21),
]

# 网络失败时的兜底版本列表
FALLBACK_VERSIONS = ["1.8.8", "1.12.2", "1.14.4", "1.16.5", "1.17.1", "1.18.2",
                     "1.19.4", "1.20.1", "1.20.4", "1.20.6", "1.21", "1.21.1", "1.21.4"]

# server.properties 全部键: (key, 默认值, 中文说明)
PROPS = [
    ("server-port", "25565", "服务器端口"),
    ("server-ip", "", "监听地址(空=全部)"),
    ("motd", "1b1t Server", "服务器列表显示的名称"),
    ("max-players", "20", "最大玩家数"),
    ("online-mode", "true", "正版验证"),
    ("white-list", "false", "白名单"),
    ("enforce-whitelist", "false", "强制白名单(踢出不在名单的在线玩家)"),
    ("pvp", "true", "玩家对战"),
    ("difficulty", "normal", "难度 peaceful/easy/normal/hard"),
    ("hardcore", "false", "极限模式"),
    ("gamemode", "survival", "默认游戏模式"),
    ("force-gamemode", "false", "强制默认游戏模式"),
    ("allow-flight", "false", "允许飞行"),
    ("allow-nether", "true", "允许下界"),
    ("view-distance", "10", "视距"),
    ("simulation-distance", "10", "模拟距离"),
    ("spawn-protection", "16", "出生点保护半径(0=关闭)"),
    ("spawn-animals", "true", "生成动物"),
    ("spawn-monsters", "true", "生成怪物"),
    ("spawn-npcs", "true", "生成村民"),
    ("generate-structures", "true", "生成结构(村庄/神殿等)"),
    ("level-name", "world", "世界文件夹名"),
    ("level-seed", "", "种子(空=随机)"),
    ("level-type", "minecraft\\:normal", "世界类型 normal/flat/largebiomes"),
    ("generator-settings", "{}", "超平坦自定义"),
    ("max-world-size", "29999984", "世界边界半径"),
    ("max-tick-time", "60000", "单 tick 超时毫秒(-1=禁用崩溃检测)"),
    ("max-chained-neighbor-updates", "1000000", "连锁方块更新上限"),
    ("sync-chunk-writes", "true", "同步写区块(true=防损坏 false=性能好)"),
    ("player-idle-timeout", "0", "挂机踢出分钟数(0=关闭)"),
    ("rate-limit", "0", "发包速率限制"),
    ("network-compression-threshold", "256", "网络压缩阈值"),
    ("use-native-transport", "true", "使用 epoll 网络传输"),
    ("prevent-proxy-connections", "false", "防代理(需正版)"),
    ("enforce-secure-profile", "true", "强制安全聊天签名"),
    ("log-ips", "true", "日志记录玩家 IP"),
    ("hide-online-players", "false", "隐藏在线人数"),
    ("enable-command-block", "false", "命令方块"),
    ("enable-jmx-monitoring", "false", "JMX 监控"),
    ("enable-query", "false", "GameSpy4 查询"),
    ("query.port", "25565", "查询端口"),
    ("enable-rcon", "false", "RCON 远程控制台"),
    ("rcon.port", "25575", "RCON 端口"),
    ("rcon.password", "", "RCON 密码"),
    ("broadcast-console-to-ops", "true", "控制台消息发给 OP"),
    ("broadcast-rcon-to-ops", "true", "RCON 消息发给 OP"),
    ("op-permission-level", "4", "OP 权限等级"),
    ("function-permission-level", "2", "函数权限等级"),
    ("enable-status", "true", "服务器列表在线状态"),
    ("require-resource-pack", "false", "强制资源包"),
    ("resource-pack", "", "资源包地址"),
    ("resource-pack-prompt", "", "资源包提示"),
    ("resource-pack-sha1", "", "资源包校验"),
    ("resource-pack-id", "", "资源包 UUID"),
    ("initial-enabled-packs", "vanilla", "初始启用的数据包"),
    ("initial-disabled-packs", "", "初始禁用的数据包"),
    ("text-filtering-config", "", "聊天过滤配置"),
    ("entity-broadcast-range-percentage", "100", "实体广播距离百分比"),
]


# ---------- 基础工具 ----------

def c(text, color="0"):
    """着色输出"""
    codes = {"red": "31", "green": "32", "yellow": "33", "blue": "34",
             "cyan": "36", "bold": "1", "dim": "2"}
    if not sys.stdout.isatty():
        return text
    return f"\033[{codes.get(color, '0')}m{text}\033[0m"


def ask(prompt, default=""):
    """带默认值的输入, 回车=默认"""
    tip = f" [{c(default, 'cyan')}]" if default != "" else ""
    ans = input(f"{prompt}{tip}: ").strip()
    return ans if ans != "" else default


def ask_bool(prompt, default=True):
    d = "y" if default else "n"
    while True:
        ans = ask(f"{prompt} (y/n)", d).lower()
        if ans in ("y", "yes", "true"):
            return True
        if ans in ("n", "no", "false"):
            return False
        print(c("  请输入 y 或 n", "red"))


def step(n, title):
    print(f"\n{c(f'[{n}]', 'cyan')} {c(title, 'bold')}")


def quit_ans(ans):
    """输入 0/q 退出"""
    if ans.strip() in ("0", "q", "quit", "exit"):
        sys.exit(c("已退出", "yellow"))


def vkey(ver):
    """版本号 → 可比较元组, 如 1.21.1 → (1,21,1)"""
    return tuple(int(x) for x in re.findall(r"\d+", ver)[:3] + [0, 0, 0])


def java_major_for(version):
    """根据 MC 版本返回所需 Java 主版本"""
    v = vkey(version)
    for lo, hi, major in JAVA_RULES:
        if lo <= v <= hi:
            return major
    return 21


# ---------- 版本清单 ----------

def load_manifest(force=False):
    """拉取版本清单(BMCLAPI), 24h 缓存, 失败用内置列表"""
    os.makedirs(CACHE_DIR, exist_ok=True)
    cache = os.path.join(CACHE_DIR, "versions.json")
    if not force and os.path.exists(cache):
        try:
            with open(cache) as f:
                data = json.load(f)
            if time.time() - data.get("ts", 0) < 86400:
                return data["versions"]
        except (OSError, ValueError):
            pass
    # 网络不稳时重试, 两个源轮换 (BMCLAPI 大响应易被截断)
    last_err = None
    for url in (MANIFEST_URL,
                "https://piston-meta.mojang.com/mc/game/version_manifest.json"):
        for attempt in range(3):
            try:
                req = urllib.request.Request(url, headers={"User-Agent": APP})
                with urllib.request.urlopen(req, timeout=30) as r:
                    data = json.loads(r.read().decode())
                versions = [{"id": v["id"], "type": v["type"], "url": v["url"]}
                            for v in data["versions"]]
                with open(cache, "w") as f:
                    json.dump({"ts": time.time(), "versions": versions}, f)
                return versions
            except Exception as e:
                last_err = e
                time.sleep(1)
    print(c(f"  在线清单获取失败({last_err}), 使用内置列表", "yellow"))
    return [{"id": v, "type": "release", "url": ""} for v in FALLBACK_VERSIONS]


# 版本特性参考: (版本范围, 优点, 缺点, 最低配置)
VERSION_INFO = [
    ("1.8.x", "经典PvP手感 插件生态最大 配置要求极低", "内容老 安全性较差(需防假人)", "1核/2G/10G"),
    ("1.12.x", "mod生态最大最成熟 配置低", "内容旧(无1.13海洋更新)", "2核/3G/20G"),
    ("1.16.x", "下界更新 mod双平台生态全", "资源占用较1.12明显提高", "2核/4G/30G"),
    ("1.17-1.19", "洞穴悬崖更新 内容新 活跃", "1.18起世界高度翻倍吃内存", "2核/4-6G/40G"),
    ("1.20.x", "社区活跃 插件/mod支持全", "1.20.5+必须Java21", "4核/6G/50G"),
    ("1.21.x+", "最新内容 长期更新", "最吃资源 部分老插件未适配", "4核/8G/60G"),
]


def dw(s):
    """字符串显示宽度(中日韩字符算2)"""
    return sum(2 if ord(ch) > 0x2E80 else 1 for ch in s)


def print_table(rows, indent="  "):
    """打印表格, rows 首行为表头 (自动处理中文宽度)"""
    widths = [max(dw(str(r[i])) for r in rows) + 2 for i in range(len(rows[0]))]
    line = indent + "+" + "+".join("-" * w for w in widths) + "+"
    print(line)
    for i, r in enumerate(rows):
        print(indent + "|" + "|".join(
            " " + str(r[j]) + " " * (widths[j] - dw(str(r[j])) - 1)
            for j in range(len(r))) + "|")
        if i == 0:
            print(line)
    print(line)


def version_table():
    """打印版本优点/缺点/最低配置表格"""
    print_table([("版本", "优点", "缺点", "最低配置")] + [list(r) for r in VERSION_INFO])


def pick_version():
    """① 选择版本: 版本特性表格 + 最近正式版列表, 也可直接输入任意版本号"""
    step(1, "选择 Minecraft 版本")
    print(c("  版本特性参考:", "cyan"))
    version_table()
    versions = load_manifest()
    releases = [v for v in versions if v["type"] == "release"]
    by_id = {v["id"]: v for v in versions}
    print(c("  最近正式版:", "cyan"))
    for i, v in enumerate(releases[:15]):
        print(f"    {i+1:>2}. {v['id']}")
    print(f"    也可以直接输入任意版本号(含快照), 如 {c('1.8.8', 'cyan')}")
    print(f"    {c('0 退出', 'dim')}")
    while True:
        ans = ask("  输入序号或版本号").strip()
        quit_ans(ans)
        if ans.isdigit() and 1 <= int(ans) <= len(releases[:15]):
            return releases[int(ans) - 1]
        if ans in by_id:
            return by_id[ans]
        print(c("  无效输入", "red"))


# ---------- Java ----------

def _java_major(java_bin):
    try:
        out = subprocess.run([java_bin, "-version"], capture_output=True,
                             text=True, timeout=10).stderr.splitlines()[0]
        m = re.search(r'version "(\d+)(?:\.(\d+))?', out)
        if m:
            return int(m.group(1)) if m.group(1) != "1" else int(m.group(2))
    except Exception:
        pass
    return None


def detect_javas():
    """扫描系统已装 Java (Linux/Windows/macOS), 返回 {主版本: [bin路径]}"""
    found = {}
    cands = set()
    exe = "java.exe" if IS_WIN else "java"
    jh = os.environ.get("JAVA_HOME")
    if jh:
        cands.add(os.path.join(jh, "bin", exe))
    for p in os.environ.get("PATH", "").split(os.pathsep):
        if p:
            cands.add(os.path.join(p, exe))
    if IS_WIN:
        # Windows: 常见 JDK 安装目录
        pf = [os.environ.get("ProgramFiles", r"C:\Program Files"),
              os.environ.get("ProgramFiles(x86)", ""),
              os.environ.get("ProgramW6432", "")]
        for root in pf:
            for sub in ("Java", "Eclipse Adoptium", "Microsoft", "Zulu",
                        "Amazon Corretto", "BellSoft", "Semeru"):
                d = os.path.join(root, sub)
                if os.path.isdir(d):
                    for entry in os.listdir(d):
                        cands.add(os.path.join(d, entry, "bin", exe))
    else:
        roots = ["/usr/lib/jvm", "/opt/java", "/usr/java",
                 os.path.expanduser("~/.jdks"), os.path.expanduser("~/sdkman")]
        if sys.platform == "darwin":  # macOS
            roots += ["/Library/Java/JavaVirtualMachines",
                      "/System/Library/Java/JavaVirtualMachines",
                      os.path.expanduser("~/Library/Java/JavaVirtualMachines")]
            # java_home -V 每行结尾是 JDK 路径, 用它补全所有 JDK
            try:
                out = subprocess.run(["/usr/libexec/java_home", "-V"],
                                     capture_output=True, text=True, timeout=10).stderr
                for line in out.splitlines():
                    m = re.search(r"(/[^()]*/Contents/Home)\s*$", line)
                    if m:
                        cands.add(os.path.join(m.group(1), "bin", "java"))
            except Exception:
                pass
        for root in roots:
            if os.path.isdir(root):
                for entry in os.listdir(root):
                    for cand in (os.path.join(root, entry, "bin", "java"),
                                 os.path.join(root, entry, "Contents", "Home",
                                              "bin", "java")):  # macOS 包结构
                        cands.add(cand)
    for p in sorted(cands):
        if not os.path.isfile(p):
            continue
        p = os.path.realpath(p)
        major = _java_major(p)
        if major and p not in found.setdefault(major, []):
            found[major].append(p)
    return found


def java_install_hint(need):
    """各平台安装 JDK 的提示"""
    if IS_WIN:
        return f"下载 JDK {need} 安装包: https://adoptium.net/zh-CN/temurin/"
    if sys.platform == "darwin":
        return f"brew install openjdk@{need}"
    return f"apt install openjdk-{need}-jdk"


def auto_install_java(need):
    """自动安装缺失的 JDK, 成功返回 java 路径, 失败返回 None"""
    print(c(f"  未找到 Java {need}, 尝试自动安装...", "yellow"))
    try:
        if IS_WIN:
            print(c(f"  Windows 请手动下载安装 (装完重开本工具即可): "
                    f"https://adoptium.net/zh-CN/temurin/ (JDK {need})", "yellow"))
            return None
        if sys.platform == "darwin":
            if shutil.which("brew"):
                print("  执行: brew install openjdk@" + str(need))
                subprocess.run(["brew", "install", f"openjdk@{need}"])
            else:
                print(c("  未找到 Homebrew, 请先装: https://brew.sh/", "red"))
                return None
        else:
            # Linux: 按发行版选包管理器
            pms = (("apt", ["sudo", "apt", "install", "-y", f"openjdk-{need}-jdk"]),
                   ("dnf", ["sudo", "dnf", "install", "-y", f"java-{need}-openjdk"]),
                   ("pacman", ["sudo", "pacman", "-S", "--noconfirm", f"jdk{need}-openjdk"]))
            ran = False
            for pm, cmd in pms:
                if shutil.which(pm):
                    print(f"  执行: {' '.join(cmd)}")
                    subprocess.run(cmd)
                    ran = True
                    break
            if not ran:
                print(c(f"  未找到 apt/dnf/pacman, 请手动安装: {java_install_hint(need)}", "red"))
                return None
        javas = detect_javas()
        if need in javas:
            print(c(f"  安装成功: {javas[need][0]}", "green"))
            return javas[need][0]
    except Exception as e:
        print(c(f"  自动安装失败: {e}", "red"))
    return None


def pick_java(version, java_major=None):
    """为 MC 版本找匹配的 Java (优先官方 javaVersion 字段), 缺则自动安装"""
    need = java_major or java_major_for(version)
    javas = detect_javas()
    if need in javas:
        return javas[need][0]
    got = "、".join(f"Java{k}" for k in sorted(javas)) or "无"
    print(c(f"\n[提示] {version} 需要 Java {need}, 本机只有: {got}", "yellow"))
    if sys.stdin.isatty() and ask_bool(f"  自动安装 Java {need}?", True):
        java = auto_install_java(need)
        if java:
            return java
    sys.exit(c(f"[错误] 缺少 Java {need}, 请手动安装: {java_install_hint(need)}", "red"))


# ---------- server.properties ----------

def render_properties(props):
    """props: {key: value}, 按 PROPS 顺序带中文注释输出"""
    lines = [f"# 由 {APP} 生成 {time.strftime('%Y-%m-%d %H:%M')}",
             "# 修改后可用: 1b1t-open-server start <目录> 重新开服"]
    for key, default, desc in PROPS:
        val = props.get(key, default)
        lines.append(f"\n# {desc}")
        lines.append(f"{key}={val}")
    return "\n".join(lines) + "\n"


def advanced_editor(props):
    """⑤ 高级选项: 列出全部项, 输入 '编号 值' 修改, 输入 done 结束"""
    step(5, "高级选项 (编辑 server.properties 全部项)")
    if not ask_bool("  要进入高级选项吗?", False):
        return props
    while True:
        print()
        for i, (key, default, desc) in enumerate(PROPS):
            val = props.get(key, default)
            print(f"  {c(str(i+1).rjust(2), 'cyan')}. {key:<38} = {c(val, 'green'):<20} {desc}")
        print(c("  用法: 输入 '编号 值' 修改该项, 回车/done 结束", "yellow"))
        ans = ask("  修改").strip()
        if ans in ("", "done", "q"):
            return props
        m = re.match(r"(\d+)\s+(.*)", ans)
        if m:
            i = int(m.group(1)) - 1
            if 0 <= i < len(PROPS):
                props[PROPS[i][0]] = m.group(2).strip()
                print(c(f"  已设置 {PROPS[i][0]} = {m.group(2).strip()}", "green"))
                continue
        print(c("  格式错误, 例如: 3 25567 或 12 hard", "red"))


# ---------- 下载 ----------

def _sha1(path):
    import hashlib
    h = hashlib.sha1()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()


def _mirror_path(url):
    """URL → 本地镜像文件路径 (域名/路径 结构)"""
    p = urllib.parse.urlparse(url)
    return os.path.join(mirror_dir(), p.netloc, p.path.lstrip("/"))


def _fetch_one(url, dest, expect_sha1=None, expect_size=None, quiet=False,
               min_speed=0):
    """单个 URL 下载, 显示进度, 支持续传, 失败返回 False
    min_speed: 最低平均速度(字节/秒), 5 秒后仍不达标放弃该源
    (隧道镜像太慢时自动切下一个源, 半截文件留给下一源续传)"""
    os.makedirs(os.path.dirname(dest), exist_ok=True)
    headers = {"User-Agent": APP}
    have = os.path.getsize(dest) if os.path.exists(dest) else 0
    if have:
        headers["Range"] = f"bytes={have}-"
    try:
        req = urllib.request.Request(url, headers=headers)
        with urllib.request.urlopen(req, timeout=60) as r:
            if not quiet:
                print(c(f"  下载源: {url}", "dim"))
            total = int(r.headers.get("Content-Length", 0)) + have
            mode = "ab" if have else "wb"
            started = time.time()
            with open(dest, mode) as f:
                while True:
                    # 限速源用小块读, 5 秒左右即可判定过慢并切源
                    chunk = r.read((64 << 10) if min_speed else (1 << 20))
                    if not chunk:
                        break
                    f.write(chunk)
                    if min_speed and time.time() - started > 5 \
                            and f.tell() / (time.time() - started) < min_speed:
                        if not quiet:
                            print(c("  该源速度过慢, 切换下一源", "yellow"))
                        return False
                    if not quiet:
                        done = f.tell()
                        pct = done * 100 // total if total else 0
                        print(f"\r  下载中 {done>>20}MB"
                              + (f"/{total>>20}MB {pct}%" if total else ""),
                              end="", flush=True)
            if not quiet:
                print()
    except urllib.error.HTTPError as e:
        if e.code == 416 and have:
            # Range 起点超出文件末尾 = 文件已下载完整
            if not quiet:
                print(c("  文件已完整, 跳过下载", "green"))
            return True
        if not quiet:
            print(c(f"  下载失败({e.code}): {url}", "red"))
        return False
    except Exception as e:
        if not quiet:
            print(c(f"  下载失败({e}): {url}", "red"))
        return False
    if expect_sha1 and _sha1(dest) != expect_sha1:
        if not quiet:
            print(c("  SHA1 校验失败, 文件可能损坏", "red"))
        return False
    return True


def fetch(url, dest, expect_sha1=None, expect_size=None):
    """下载文件: 本地镜像优先 → 多源依次尝试 → 成功后缓存到镜像"""
    urls = url if isinstance(url, (list, tuple)) else [url]
    # 1. 本地镜像命中直接复制
    for u in urls:
        mp = _mirror_path(u)
        if os.path.exists(mp) and os.path.getsize(mp) > 0:
            if expect_size and os.path.getsize(mp) != expect_size:
                continue
            if expect_sha1 and _sha1(mp) != expect_sha1:
                continue
            os.makedirs(os.path.dirname(dest), exist_ok=True)
            shutil.copy2(mp, dest)
            print(c(f"  本地镜像命中: {os.path.basename(dest)}", "green"))
            return True
    # 2. 网络下载: 自动切换源
    # 本机文件镜像与 serverdown 是同一份数据(bind mount), 文件未命中则 serverdown 也没有,
    # 直接走官方源; 其他机器(无本机镜像目录)先试存储桶(高速)再试隧道镜像
    # 注意镜像路径必须含域名段(与镜像物理结构一致), 否则永远 404
    s3_urls = [(S3_MIRROR + "/" + os.path.relpath(_mirror_path(u), mirror_dir()), 0)
               for u in urls]
    if os.path.isdir(mirror_dir()):
        net_urls = s3_urls + [(u, 0) for u in urls]
    else:
        # 存储桶优先(直连高速); 隧道镜像限速兜底(256KB/s): 太慢切官方/BMCLAPI
        net_urls = s3_urls + \
            [(mirror_http() + os.path.relpath(_mirror_path(u), mirror_dir()),
              256 << 10)
             for u in urls] + [(u, 0) for u in urls]
    for u, lim in net_urls:
        if _fetch_one(u, dest, expect_sha1, expect_size, min_speed=lim):
            # 3. 缓存到本地镜像, 下次秒取
            try:
                os.makedirs(os.path.dirname(_mirror_path(u)), exist_ok=True)
                shutil.copy2(dest, _mirror_path(u))
                print(c("  已缓存到本地镜像", "cyan"))
            except OSError:
                pass
            return True
    return False


# mod 服务器: Fabric/NeoForge/Forge 元数据源
FABRIC_META = "https://bmclapi2.bangbang93.com/fabric-meta/v2/versions/loader/{mc}"
NEOFORGE_META = "https://maven.neoforged.net/releases/net/neoforged/neoforge/maven-metadata.xml"
FORGE_META = "https://maven.minecraftforge.net/net/minecraftforge/forge/maven-metadata.xml"

_VERSION_INFO_CACHE = {}

UPDATE_URL = "https://www.1b1t.cn/latest.json"   # 更新检查端点


def _ver_tuple(v):
    """版本号转可比较元组 (非法返回空)"""
    try:
        return tuple(int(x) for x in str(v).split("."))
    except ValueError:
        return ()


def check_update(timeout=8):
    """检查官网最新版本号; 网络失败/异常返回 None"""
    try:
        data = json.loads(http_get(UPDATE_URL, timeout, retries=1))
        return data.get("version")
    except Exception:
        return None


def http_get(url, timeout=30, retries=3):
    """GET 返回文本, 失败自动重试"""
    last = None
    for i in range(retries):
        try:
            req = urllib.request.Request(url, headers={"User-Agent": APP})
            with urllib.request.urlopen(req, timeout=timeout) as r:
                return r.read().decode()
        except Exception as e:
            last = e
            time.sleep(1 + i)
    raise last


def http_json(url, timeout=30):
    return json.loads(http_get(url, timeout))


def pick_server_type():
    """选择服务器类型: Vanilla/Fabric/NeoForge/Forge"""
    print(c("  服务器类型:", "cyan"))
    print_table([
        ("编号", "类型", "说明"),
        ("1", "Vanilla", "原版纯净, 无 mod"),
        ("2", "Fabric", "轻量 mod 平台, 版本覆盖最广"),
        ("3", "NeoForge", "1.20.1+ 主流 mod 平台"),
        ("4", "Forge", "老牌 mod 平台, 1.20.1 及以下最成熟"),
    ])
    print(f"    {c('0 退出', 'dim')}")
    ans = ask("  选择", "1")
    quit_ans(ans)
    return {"1": "vanilla", "2": "fabric", "3": "neoforge", "4": "forge"}.get(ans, "vanilla")


def list_mod_versions(mc_ver, stype):
    """非交互: 返回该 MC 版本可用的 mod 加载器版本列表 (最新在前), 失败返回 []"""
    try:
        if stype == "fabric":
            loaders = http_json(FABRIC_META.format(mc=mc_ver))
            vers = [x["loader"]["version"] for x in loaders
                    if x["loader"].get("stable")]
        else:
            meta_url = NEOFORGE_META if stype == "neoforge" else FORGE_META
            meta = http_get(meta_url, 60)
            versions = re.findall(r"<version>([^<]+)</version>", meta)
            if stype == "neoforge":
                # 版本号 = MC 版本去掉开头 "1." (21.1.249 → MC 1.21.1)
                ver_key = mc_ver[2:] if mc_ver.startswith("1.") else mc_ver
                # 不锚定结尾: 兼容 -beta/-alpha 后缀 (21.2.0-beta)
                vers = [v for v in versions
                        if re.match(rf"^{re.escape(ver_key)}\.\d+", v)]
            else:  # Forge 带 MC 前缀: 1.21.1-52.1.16
                vers = [v for v in versions
                        if v.startswith(mc_ver + "-")]
    except Exception:
        return []
    if not vers:
        return []
    # 优先稳定版; 该 MC 版本只有 beta 时(如 1.21.2)显示 beta
    stable = [v for v in vers
              if not re.search(r"beta|alpha|rc", v, re.I)]
    if stable:
        vers = stable
    vers.reverse()  # 最新在前
    return vers


def pick_mod_version(mc_ver, stype):
    """列出该 MC 版本可用的 mod 加载器版本 (最新在前), 数字选择或直接输入"""
    print(c(f"  可用 {stype} 版本 (最新在前, 也可直接输入版本号):", "cyan"))
    vers = list_mod_versions(mc_ver, stype)
    if not vers:
        print(c(f"  获取版本列表失败或 {stype} 没有 {mc_ver} 的版本, 将自动使用最新版",
                "yellow"))
        return None
    show = vers[:10]
    for i, v in enumerate(show):
        mark = c("(默认)", "green") if i == 0 else ""
        print(f"    {i+1}. {v} {mark}")
    while True:
        ans = ask("  选择", "1")
        quit_ans(ans)
        if ans.isdigit() and 1 <= int(ans) <= len(show):
            return show[int(ans) - 1]
        if ans in vers:
            return ans
        print(c("  无效, 请输入序号或版本号", "red"))


def get_fabric_server_jar(mc_ver, server_dir, java_bin, loader=None):
    """Fabric: 官方安装器 server 模式, 生成 fabric-server-launch.jar + 依赖库"""
    try:
        loaders = http_json(FABRIC_META.format(mc=mc_ver))
        meta = http_get("https://maven.fabricmc.net/net/fabricmc/fabric-installer/maven-metadata.xml", 60)
    except Exception as e:
        print(c(f"  获取 Fabric 信息失败: {e}", "red"))
        return False
    if not loaders:
        print(c(f"  Fabric 没有 {mc_ver} 的 loader 版本", "yellow"))
        return False
    if not loader:
        loader = next((x["loader"]["version"] for x in loaders
                       if x["loader"].get("stable")), loaders[0]["loader"]["version"])
    iv = re.search(r"<release>([^<]+)</release>", meta)
    if not iv:
        return False
    iv = iv.group(1)
    path = f"net/fabricmc/fabric-installer/{iv}/fabric-installer-{iv}.jar"
    urls = [f"https://maven.fabricmc.net/{path}",
            f"https://bmclapi2.bangbang93.com/maven/{path}"]
    installer = os.path.join(server_dir, "fabric-installer.jar")
    print(f"  下载 Fabric 安装器 {iv} (loader {loader})...")
    if not fetch(urls, installer):
        return False
    print(f"  运行安装器 (server 模式, 下载依赖库, 稍等)...")
    try:
        subprocess.run([java_bin, "-jar", installer, "server",
                        "-mcversion", mc_ver, "-loader", loader,
                        "-downloadMinecraft", "-noprofile"],
                       cwd=server_dir, check=True)
    except subprocess.CalledProcessError as e:
        print(c(f"  安装器失败: {e}", "red"))
        return False
    return True


def get_mod_installer(mc_ver, stype, server_dir, java, mod_ver=None):
    """NeoForge/Forge: 下载安装器并 --installServer, 返回 True/False"""
    if stype == "neoforge":
        meta_url, mvn = NEOFORGE_META, "https://maven.neoforged.net/releases"
        group = "net/neoforged/neoforge"
    else:
        meta_url, mvn = FORGE_META, "https://maven.minecraftforge.net"
        group = "net/minecraftforge/forge"
    if not mod_ver:
        try:
            meta = http_get(meta_url, 60)
            versions = re.findall(r"<version>([^<]+)</version>", meta)
        except Exception as e:
            print(c(f"  获取版本列表失败: {e}", "red"))
            return False
        # 匹配该 MC 版本的正式版, 排除 beta/alpha/rc
        if stype == "neoforge":
            # NeoForge 版本号 = MC 版本去掉开头 "1." (21.1.249 → MC 1.21.1)
            ver_key = mc_ver[2:] if mc_ver.startswith("1.") else mc_ver
            cands = [v for v in versions
                     if re.match(rf"^{re.escape(ver_key)}\.\d+$", v)
                     and not re.search(r"beta|alpha|rc", v, re.I)]
        else:  # Forge: 1.21.1-52.1.16 带 MC 前缀
            cands = [v for v in versions
                     if v.startswith(mc_ver + "-")
                     and not re.search(r"beta|alpha|rc", v, re.I)]
        if not cands:
            print(c(f"  {stype} 没有 {mc_ver} 的版本", "yellow"))
            return False
        mod_ver = cands[-1]  # 最新正式版
    path = f"{group}/{mod_ver}/{stype}-{mod_ver}-installer.jar"
    urls = [f"{mvn}/{path}",   # 官方仓库
            f"https://bmclapi2.bangbang93.com/maven/{path}"]  # 国内镜像
    installer = os.path.join(server_dir, f"{stype}-installer.jar")
    print(f"  下载 {stype} {mod_ver} 安装器...")
    if not fetch(urls, installer):
        return False
    print(f"  运行安装器 (--installServer, 需下载依赖库, 稍等)...")
    for attempt in range(1, 4):
        try:
            subprocess.run([java, "-jar", installer, "--installServer"],
                           cwd=server_dir, check=True)
            break
        except subprocess.CalledProcessError as e:
            if attempt < 3:
                # 网络不稳: 从安装器日志解析失败依赖, 多源补下载后重试
                # (已下好的库校验通过会跳过, 重试只补缺)
                print(c(f"  安装器失败, 第 {attempt+1}/3 次重试...", "yellow"))
                _seed_failed_libs(server_dir)
                time.sleep(2)
            else:
                print(c(f"  安装器失败(已重试 3 次): {e}", "red"))
                return False
    return True


def _seed_failed_libs(server_dir):
    """安装器失败后: 解析安装器日志里失败的依赖库, 用多源(官方+BMCLAPI)
    直接下载补缺, 下次重试时安装器校验通过会跳过已下好的"""
    for log_name in ("neoforge-installer.jar.log", "installer.log",
                     "forge-installer.jar.log"):
        log = os.path.join(server_dir, log_name)
        try:
            txt = open(log, encoding="utf-8", errors="ignore").read()
        except OSError:
            continue
        tail = re.split(r"failed to download", txt, flags=re.I)
        if len(tail) < 2:
            continue
        for n in re.findall(
                r"^([\w.\-]+:[\w.\-]+:[\w.\-+]+(?::[\w.\-]+)?)$",
                tail[-1], re.M):
            parts = n.split(":")
            grp, art, ver = parts[0], parts[1], parts[2]
            fname = f"{art}-{ver}-{parts[3]}.jar" if len(parts) > 3 \
                else f"{art}-{ver}.jar"
            rel = "/".join(grp.split(".")) + f"/{art}/{ver}/{fname}"
            dest = os.path.join(server_dir, "libraries", rel)
            if os.path.exists(dest) and os.path.getsize(dest) > 0:
                continue
            urls = [f"https://maven.neoforged.net/releases/{rel}",
                    f"https://bmclapi2.bangbang93.com/maven/{rel}"]
            print(c(f"  补下载失败依赖: {n}", "yellow"))
            fetch(urls, dest)


def reuse_libraries(server_dir):
    """复用本机其他服务器目录已有的依赖库 libraries/ (加速安装, 不走网络)"""
    target = os.path.join(server_dir, "libraries")
    if os.path.isdir(target) and os.listdir(target):
        return
    home = os.path.expanduser("~")
    try:
        entries = os.listdir(home)
    except OSError:
        return
    for entry in entries:
        src = os.path.join(home, entry, "libraries")
        if not os.path.isdir(src):
            continue
        if os.path.realpath(src) == os.path.realpath(target):
            continue
        if not os.listdir(src):
            continue
        print(c(f"  复用本机依赖库: {src} → 本地复制(不走网络)", "green"))
        try:
            shutil.copytree(src, target, dirs_exist_ok=True)
        except OSError:
            continue
        return


def start_mod_server(server_dir, cfg, ram, java=None):
    """forge/neoforge: 改写内存参数, 用安装器生成的 run.sh/run.bat 启动
    java: 匹配到的 JDK 路径, 前置到 PATH (run.sh 里裸 java 会用 PATH 第一个,
    本机默认 java 21 会带崩需要 25 的 NeoForge 26.x)"""
    # user_jvm_args.txt 里替换内存参数
    uj = os.path.join(server_dir, "user_jvm_args.txt")
    if os.path.exists(uj):
        with open(uj) as f:
            lines = f.read().splitlines()
        out = []
        wrote = False
        for ln in lines:
            if ln.strip().startswith("-Xm"):
                if not wrote:
                    out.append(f"-Xms512M -Xmx{ram}")
                    wrote = True
                continue
            out.append(ln)
        if not wrote:
            out.append(f"-Xms512M -Xmx{ram}")
        with open(uj, "w") as f:
            f.write("\n".join(out) + "\n")
    if IS_WIN:
        # 把匹配的 Java 前置到 PATH, run.bat 里裸 java 才会用到它
        javadir = os.path.dirname(java) if java else ""
        if javadir:
            return ["cmd", "/c",
                    f'set "PATH={javadir};%PATH%" && run.bat nogui']
        return ["cmd", "/c", "run.bat", "nogui"]
    run = os.path.join(server_dir, "run.sh")
    # 把匹配的 Java 前置到 PATH (run.sh 里 exec java 用 PATH 第一个)
    # exec 链: bash → run.sh → java, 减少包装进程
    if java:
        javadir = os.path.dirname(java)
        return ["bash", "-c",
                f'export PATH="{javadir}:$PATH"; exec ./run.sh nogui']
    return ["bash", "-c", f"exec ./run.sh nogui"]


def get_version_info(version):
    """拉取版本详情 json (含 downloads/javaVersion), 内存缓存"""
    if version in _VERSION_INFO_CACHE:
        return _VERSION_INFO_CACHE[version]
    info = {}
    try:
        req = urllib.request.Request(BMCL_VERSION.format(vid=version),
                                     headers={"User-Agent": APP})
        with urllib.request.urlopen(req, timeout=20) as r:
            info = json.loads(r.read().decode())
    except Exception:
        pass
    _VERSION_INFO_CACHE[version] = info
    return info


def get_server_jar(version, dest, info=None):
    """下载对应版本的官方服务端, 优先 BMCLAPI 镜像, 失败回退 Mojang"""
    if info is None:
        info = get_version_info(version)
    sha1 = info.get("downloads", {}).get("server", {}).get("sha1")
    size = info.get("downloads", {}).get("server", {}).get("size")
    url = info.get("downloads", {}).get("server", {}).get("url") or ""
    # 已存在且大小一致就复用
    if os.path.exists(dest) and size and os.path.getsize(dest) == size:
        print(c(f"  server.jar 已存在, 跳过下载", "green"))
        return True
    print(f"  下载 {c(version, 'cyan')} 服务端核心...")
    if fetch(BMCL_SERVER_JAR.format(vid=version), dest, sha1, size):
        return True
    if url and url != BMCL_SERVER_JAR.format(vid=version):
        print(c("  镜像失败, 尝试官方源...", "yellow"))
        return fetch(url, dest, sha1, size)
    return False


# ---------- 服务器运行状态 ----------

def runtime_dir(server_dir):
    return os.path.join(server_dir, RUNTIME_DIR)


def load_cfg(server_dir):
    try:
        with open(os.path.join(runtime_dir(server_dir), "config.json")) as f:
            return json.load(f)
    except (OSError, ValueError):
        return None


def save_cfg(server_dir, cfg):
    os.makedirs(runtime_dir(server_dir), exist_ok=True)
    with open(os.path.join(runtime_dir(server_dir), "config.json"), "w") as f:
        json.dump(cfg, f, ensure_ascii=False, indent=2)


def read_pid(server_dir):
    try:
        with open(os.path.join(runtime_dir(server_dir), "pid.json")) as f:
            return json.load(f)
    except (OSError, ValueError):
        return None


def is_running(pid):
    """进程存活检测 (Windows 上 os.kill(pid,0) 会误杀进程, 必须用 API)"""
    if IS_WIN:
        try:
            import ctypes
            h = ctypes.windll.kernel32.OpenProcess(0x1000, False, pid)
            if not h:
                return False
            code = ctypes.c_ulong()
            alive = (ctypes.windll.kernel32.GetExitCodeProcess(
                h, ctypes.byref(code)) and code.value == 259)  # STILL_ACTIVE
            ctypes.windll.kernel32.CloseHandle(h)
            return bool(alive)
        except Exception:
            return False
    try:
        os.kill(pid, 0)
    except (OSError, ProcessLookupError):
        return False
    # Linux: 僵尸进程 os.kill(pid,0) 仍返回成功! java 是 GUI/CLI 的
    # 直接子进程(exec 链), 父进程不 waitpid 它就变僵尸 → 误判"运行中"
    # → 停止永远等满 60s 走"超时强杀" (其实服务器早已优雅退出)
    if pid > 0 and not IS_WIN:
        try:
            with open(f"/proc/{pid}/stat") as f:
                state = f.read().split(") ", 1)[-1].split()[0]
            return state != "Z"
        except OSError:
            pass
    return True


def free_port():
    """获取一个随机的本地空闲端口"""
    s = socket.socket()
    s.bind(("127.0.0.1", 0))
    port = s.getsockname()[1]
    s.close()
    return port


def send_console(server_dir, line, timeout=10):
    """通过 keeper 的本地 TCP 端口向服务器控制台发送命令"""
    info = read_pid(server_dir)
    if not info or not info.get("console_port"):
        return False
    try:
        s = socket.create_connection(("127.0.0.1", info["console_port"]), timeout)
        s.sendall((line + "\n").encode())
        s.close()
        return True
    except OSError:
        return False


def attach_console(server_dir):
    """接入服务器控制台: 全部启动日志 + 实时输出 + 命令直发, exit/Ctrl+C 退出"""
    rt = runtime_dir(server_dir)
    logs = [os.path.join(rt, "console.log"),        # 进程 stdout/stderr (即时)
            os.path.join(server_dir, "logs", "latest.log")]  # log4j 完整日志
    pos = {lg: 0 for lg in logs}
    # 先把已有日志全部显示出来 (从本次启动开始)
    for lg in logs:
        if os.path.exists(lg):
            with open(lg, errors="ignore") as f:
                sys.stdout.write(f.read())
            pos[lg] = os.path.getsize(lg)
    sys.stdout.flush()
    print(c("已接入控制台: 直接输入命令执行, exit 或 Ctrl+C 退出(服务器继续运行)",
            "green"))
    def flush_logs():
        for lg in logs:
            if not os.path.exists(lg):
                continue
            size = os.path.getsize(lg)
            if size < pos[lg]:  # log4j 轮转后大小重置, 从头读
                pos[lg] = 0
            if size > pos[lg]:
                with open(lg, errors="ignore") as f:
                    f.seek(pos[lg])
                    sys.stdout.write(f.read())
                sys.stdout.flush()
                pos[lg] = size

    sent_stop = False
    try:
        while True:
            flush_logs()
            if select.select([sys.stdin], [], [], 0.2)[0]:
                line = sys.stdin.readline()
                if not line:
                    break  # stdin EOF
                line = line.strip()
                if not line:
                    continue
                if line.lower() in ("exit", "quit"):
                    break
                if line.lower() == "stop":
                    # 关服: 发送后立即退出回 shell, 后台收尾进程负责等退出+清理
                    if send_console(server_dir, line):
                        sent_stop = True
                        flags = {"start_new_session": True} if not IS_WIN else {}
                        subprocess.Popen(
                            sub_cmd("cleanup", server_dir),
                            stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
                            stderr=subprocess.DEVNULL, **flags)
                        print(c("已发送关服命令, 服务器在后台保存退出, 回 shell...",
                                "yellow"))
                        break
                    print(c("命令发送失败(控制台通道不可用), 请用: "
                            f"1b1t stop {server_dir}", "red"))
                    continue
                send_console(server_dir, line)
            # 服务器停了 → 刷完剩余日志自动退出并清理 pid
            info = read_pid(server_dir)
            if not info or not is_running(info["pid"]):
                flush_logs()
                try:
                    os.remove(os.path.join(runtime_dir(server_dir), "pid.json"))
                except OSError:
                    pass
                print(c("服务器已停止, 退出控制台", "yellow"))
                break
    except KeyboardInterrupt:
        print()
        print(c("已退出控制台(服务器仍在运行)", "yellow"))
        return
    if not sent_stop:
        info = read_pid(server_dir)
        if info and is_running(info["pid"]):
            print(c("已退出控制台(服务器仍在运行)", "yellow"))


def wait_ready(server_dir, timeout=180):
    """等待服务器启动完成(日志出现 Done)"""
    log = os.path.join(server_dir, "logs", "latest.log")
    deadline = time.time() + timeout
    seen = 0
    while time.time() < deadline:
        if os.path.exists(log):
            size = os.path.getsize(log)
            if size > seen:
                with open(log, "r", errors="ignore") as f:
                    f.seek(seen)
                    text = f.read()
                seen = size
                if "Done (" in text:
                    return True
        time.sleep(0.5)
    return False


# ---------- 自主排查 ----------

# (日志特征, 问题, 修复建议)
LOG_PATTERNS = [
    ("Failed to bind to port", "日志显示端口绑定失败", "更换端口后重启"),
    ("already in use", "日志显示端口被占用", "更换端口后重启"),
    ("UnsupportedClassVersionError", "Java 版本不匹配", "安装匹配的 JDK 后重试"),
    ("Unsupported major.minor version", "Java 版本过低", "安装匹配的 JDK 后重试"),
    ("You need to agree to the EULA", "未同意 EULA", "把 eula.txt 改为 eula=true"),
    ("OutOfMemoryError", "内存不足崩溃", "调大内存上限(开服参数)或释放内存"),
    ("Invalid or corrupt jarfile", "server.jar 损坏", "删除 server.jar 重新开服"),
    ("No space left on device", "磁盘已满", "清理磁盘后重启"),
    ("A problem occurred running the Server", "服务器启动报错", "查看上方日志的完整错误输出"),
]


def parse_ram(ram):
    """'2G'/'1024M'/'2'(纯数字按G) → MB"""
    m = re.match(r"(\d+)([GM]?)", str(ram).upper())
    if not m:
        return None
    n = int(m.group(1))
    return n * 1024 if m.group(2) in ("G", "") else n


def total_mem_mb():
    """整机总内存 MB (Linux/Windows/macOS), 失败返回 None"""
    try:
        if os.path.exists("/proc/meminfo"):  # Linux
            with open("/proc/meminfo") as f:
                m = re.search(r"MemTotal:\s+(\d+)", f.read())
            return int(m.group(1)) // 1024 if m else None
        if IS_WIN:  # Windows
            import ctypes
            n = ctypes.c_ulonglong(0)
            ctypes.windll.kernel32.GetPhysicallyInstalledSystemMemory(
                ctypes.byref(n))
            return int(n.value) // 1024
        if sys.platform == "darwin":  # macOS
            out = subprocess.run(["sysctl", "-n", "hw.memsize"],
                                 capture_output=True, text=True,
                                 timeout=10).stdout.strip()
            return int(out) // 1048576
    except Exception:
        pass
    return None


def avail_mem_mb():
    """可用内存 MB (Linux/Windows/macOS), 失败返回 None"""
    try:
        if os.path.exists("/proc/meminfo"):  # Linux
            with open("/proc/meminfo") as f:
                m = re.search(r"MemAvailable:\s+(\d+)", f.read())
            return int(m.group(1)) // 1024 if m else None
        if IS_WIN:  # Windows: GlobalMemoryStatusEx
            import ctypes

            class MSX(ctypes.Structure):
                _fields_ = [("dwLength", ctypes.c_ulong),
                            ("dwMemoryLoad", ctypes.c_ulong),
                            ("ullTotalPhys", ctypes.c_ulonglong),
                            ("ullAvailPhys", ctypes.c_ulonglong),
                            ("ullTotalPageFile", ctypes.c_ulonglong),
                            ("ullAvailPageFile", ctypes.c_ulonglong),
                            ("ullTotalVirtual", ctypes.c_ulonglong),
                            ("ullAvailVirtual", ctypes.c_ulonglong),
                            ("ullAvailExtendedVirtual", ctypes.c_ulonglong)]
            m = MSX()
            m.dwLength = ctypes.sizeof(m)
            ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m))
            return m.ullAvailPhys // 1048576
        if sys.platform == "darwin":  # macOS: 空闲 + 可回收(inactive/speculative)
            pagesz = int(subprocess.run(["sysctl", "-n", "vm.pagesize"],
                                        capture_output=True, text=True,
                                        timeout=10).stdout.strip())
            vm = subprocess.run(["vm_stat"], capture_output=True, text=True,
                                timeout=10).stdout

            def _pages(label):
                m = re.search(label + r":\s+(\d+)", vm)
                return int(m.group(1)) if m else 0

            usable = (_pages("Pages free") + _pages("Pages inactive")
                      + _pages("Pages speculative") + _pages("Pages purgeable"))
            if usable:
                return usable * pagesz // 1048576
            free = int(subprocess.run(["sysctl", "-n", "vm.page_free_count"],
                                      capture_output=True, text=True,
                                      timeout=10).stdout.strip())
            return free * pagesz // 1048576
    except Exception:
        pass
    return None


def diagnose(server_dir, cfg=None):
    """自主排查: 检查 Java/端口/jar/EULA/磁盘/权限/内存/日志, 返回问题数"""
    print(f"\n{c('=== 自主排查 ===', 'bold')}")
    issues = 0

    def ok(msg):
        print(f"  {c('✓', 'green')} {msg}")

    def bad(msg, fix):
        nonlocal issues
        issues += 1
        print(f"  {c('✗', 'red')} {msg}\n      {c('→ ' + fix, 'yellow')}")

    def warn(msg, fix):
        print(f"  {c('!', 'yellow')} {msg}\n      {c('→ ' + fix, 'yellow')}")

    # 1. Java
    if cfg and cfg.get("version"):
        need = java_major_for(cfg["version"])
        javas = detect_javas()
        if need in javas:
            ok(f"Java {need} 已安装: {javas[need][0]}")
        else:
            got = "、".join(f"Java{k}" for k in sorted(javas)) or "无"
            bad(f"MC {cfg['version']} 需要 Java {need}, 本机只有 {got}",
                java_install_hint(need))

    # 2. 端口（自身运行中占用 = 正常）
    if cfg and cfg.get("port"):
        port = int(cfg["port"])
        _pi = read_pid(server_dir)
        _self = bool(_pi and is_running(_pi["pid"]))
        _s = socket.socket()
        try:
            _s.bind(("0.0.0.0", port))
            _s.close()
            ok(f"端口 {port} 空闲")
        except OSError:
            if _self:
                ok(f"端口 {port}（自身占用，运行中）")
            else:
                bad(f"端口 {port} 被其他进程占用",
                    f"更换端口, 或停掉占用进程: lsof -i :{port}  /  ss -tlnp | grep {port}")

    # 3. 核心文件（按类型检查，且看大小，能发现半截文件）
    stype = (cfg or {}).get("server_type", "vanilla")
    jar = os.path.join(server_dir, "server.jar")
    launch = os.path.join(server_dir, "fabric-server-launch.jar")
    if stype == "fabric":
        if not os.path.exists(launch):
            bad("缺少 fabric-server-launch.jar", "重新安装 Fabric 服务端")
        elif not os.path.exists(jar) or os.path.getsize(jar) < 1024 * 1024:
            bad("缺少/损坏原版核心 server.jar", "删除 server.jar 后重新开服自动下载")
        else:
            ok("fabric-server-launch.jar + server.jar 已就绪")
    elif stype in ("neoforge", "forge"):
        rs = os.path.join(server_dir, "run.sh")
        if os.path.exists(rs) and os.path.getsize(rs) > 100:
            ok("run.sh 已就绪")
        else:
            bad("缺少 run.sh（服务端未安装完成）", "重新安装服务端")
    else:
        if os.path.exists(jar) and os.path.getsize(jar) > 1024 * 1024:
            ok(f"server.jar 存在（{os.path.getsize(jar) >> 20} MB）")
        elif os.path.exists(jar):
            bad(f"server.jar 只有 {os.path.getsize(jar)} 字节，疑似未下载完",
                "删除 server.jar 后重新开服自动下载")
        else:
            warn("server.jar 不存在", "开服时会自动从 BMCLAPI 镜像下载")

    # 4. EULA
    eula_path = os.path.join(server_dir, "eula.txt")
    if os.path.exists(eula_path):
        with open(eula_path, errors="ignore") as f:
            if "eula=true" in f.read():
                ok("已同意 EULA")
            else:
                bad("未同意 EULA", "把 eula.txt 里的 eula 改为 true")
    else:
        warn("没有 eula.txt", "开服时会自动生成(默认同意)")

    # 5. 磁盘空间
    du = shutil.disk_usage(server_dir)
    if du.free > 1 << 30:
        ok(f"磁盘剩余 {du.free >> 30} GB")
    elif du.free > 200 << 20:
        warn(f"磁盘仅剩 {du.free >> 20} MB", "注意清理, 世界存档会持续增长")
    else:
        bad(f"磁盘空间不足 ({du.free >> 20} MB)", "清理磁盘后再开服")

    # 6. 目录权限
    if os.access(server_dir, os.W_OK):
        ok("服务器目录可写")
    else:
        bad("服务器目录不可写", f"chmod u+w {server_dir}")

    # 7. 内存
    avail_mb = avail_mem_mb()
    if avail_mb:
        if cfg and cfg.get("ram"):
            want = parse_ram(cfg["ram"])
            if want and want > avail_mb:
                bad(f"内存不足: 配置 {cfg['ram']} > 可用 {avail_mb}M",
                    "调小内存上限, 或释放内存后重试")
            else:
                ok(f"内存可用 {avail_mb}M (配置 {cfg.get('ram', '-')})")

    # 8. 模组一致性（原版服放 mods / Fabric 服放 plugins 都是"装了不生效"）
    def _count_jars(sub):
        d = os.path.join(server_dir, sub)
        try:
            return len([x for x in os.listdir(d) if x.lower().endswith(".jar")])
        except OSError:
            return 0
    _mods, _plugins = _count_jars("mods"), _count_jars("plugins")
    if stype == "vanilla" and _mods:
        bad(f"mods/ 里有 {_mods} 个模组，但这是原版服，不会加载",
            "改用 Fabric/NeoForge 服务端，或删掉 mods/")
    elif stype == "fabric" and _plugins:
        bad(f"plugins/ 里有 {_plugins} 个插件，但 Fabric 只加载 mods/",
            "换成 Paper 类服务端，或删掉 plugins/")
    else:
        ok(f"模组 {_mods} 个 / 插件 {_plugins} 个")

    # 9. 日志错误分析（最近 128KB）
    rt = runtime_dir(server_dir)
    for log in (os.path.join(server_dir, "logs", "latest.log"),
                os.path.join(rt, "console.log")):
        if not os.path.exists(log):
            continue
        with open(log, errors="ignore") as f:
            f.seek(0, 2)
            size = f.tell()
            f.seek(max(0, size - 131072))
            tail = f.read()
        hit = None
        for pattern, msg, fix in LOG_PATTERNS:
            if pattern in tail:
                hit = (msg, fix)
                break
        if hit:
            bad(hit[0], hit[1])
        else:
            ok("日志无已知错误特征")
        break

    print(c("=== 排查结束 ===\n", "bold"))
    return issues


# ---------- 开服 ----------

def start_server(server_dir, cfg, wait=True):
    """按配置启动服务器, 返回 Popen (Linux/Windows/macOS 通用)"""
    os.makedirs(os.path.join(server_dir, "logs"), exist_ok=True)
    rt = runtime_dir(server_dir)
    os.makedirs(rt, exist_ok=True)

    java = pick_java(cfg["version"], cfg.get("java"))
    ram = cfg.get("ram", "2G")
    # wb: 每次启动清空, console.log 只含本次进程输出(attach 时从头全显示)
    console_log = open(os.path.join(rt, "console.log"), "wb")

    flags = {}
    if IS_WIN:
        flags["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
    else:
        flags["start_new_session"] = True
    stype = cfg.get("server_type", "vanilla")
    if stype == "fabric":
        cmd = [java, "-Xms512M", f"-Xmx{ram}", "-jar",
               "fabric-server-launch.jar", "nogui"]
    elif stype in ("neoforge", "forge"):
        cmd = start_mod_server(server_dir, cfg, ram, java)
    else:
        cmd = [java, "-Xms512M", f"-Xmx{ram}", "-jar", "server.jar", "nogui"]
    p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=console_log,
                         stderr=subprocess.STDOUT, cwd=server_dir, **flags)
    console_log.close()
    # keeper: 持有 java stdin 写端 + 监听本地 TCP 转发控制台命令
    port = free_port()
    keeper = subprocess.Popen(
        sub_cmd("keeper", port),
        stdin=p.stdin, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        **flags)
    p.stdin.close()  # 写端只由 keeper 持有, java 永远不会读到 EOF
    time.sleep(1)
    if p.poll() is not None:
        keeper.terminate()
        print(c(f"[错误] 服务器进程启动失败(退出码 {p.returncode}), "
                f"详见 {rt}/console.log", "red"))
        diagnose(server_dir, cfg)
        sys.exit(1)
    with open(os.path.join(rt, "pid.json"), "w") as f:
        json.dump({"pid": p.pid, "keeper": keeper.pid, "console_port": port,
                   "start": int(time.time())}, f)
    save_cfg(server_dir, cfg)
    return p


def do_start(server_dir, dry_run=False, advanced=False):
    """start: 有配置直接开, 无配置走向导 (server_dir=None 时向导里选位置)"""
    cfg = load_cfg(server_dir) if server_dir else None
    if cfg is None:
        cfg = wizard(server_dir, advanced=advanced)
        server_dir = cfg.pop("dir")
    else:
        print(c(f"已找到配置: MC {cfg['version']} 端口 {cfg['port']} "
                f"内存 {cfg.get('ram','2G')}", "cyan"))

    # 检查是否已在运行
    old = read_pid(server_dir)
    if old and is_running(old["pid"]):
        sys.exit(c(f"[错误] 服务器已在运行 (PID {old['pid']})", "red"))

    # 版本详情: 用官方 javaVersion 字段精确匹配 Java
    info = get_version_info(cfg["version"])
    java_major = info.get("javaVersion", {}).get("majorVersion")
    if java_major:
        cfg["java"] = java_major

    # 写 eula + 配置
    with open(os.path.join(server_dir, "eula.txt"), "w") as f:
        f.write("# 继续使用即代表您同意 Minecraft EULA\n"
                "# https://aka.ms/MinecraftEULA\neula=true\n")
    with open(os.path.join(server_dir, "server.properties"), "w") as f:
        f.write(render_properties(cfg["props"]))
    save_cfg(server_dir, cfg)
    if dry_run:
        print(c("dry-run: 配置文件已生成, 未下载/未启动", "yellow"))
        return

    # 先确认 Java 匹配, 再下载
    java_bin = pick_java(cfg["version"], cfg.get("java"))

    # 按类型准备服务端
    stype = cfg.get("server_type", "vanilla")
    if stype == "fabric":
        jar = os.path.join(server_dir, "fabric-server-launch.jar")
        if not os.path.exists(jar) or os.path.getsize(jar) < 1000:
            if not get_fabric_server_jar(cfg["version"], server_dir, java_bin,
                                         cfg.get("mod_version")):
                sys.exit(c("[错误] Fabric 安装失败", "red"))
    elif stype in ("neoforge", "forge"):
        if not os.path.exists(os.path.join(server_dir, "run.sh")) and \
           not os.path.exists(os.path.join(server_dir, "run.bat")):
            reuse_libraries(server_dir)  # 复用本机已有依赖库, 加速安装
            if not get_mod_installer(cfg["version"], stype, server_dir,
                                     java_bin, cfg.get("mod_version")):
                sys.exit(c(f"[错误] {stype} 安装失败", "red"))
    else:
        jar = os.path.join(server_dir, "server.jar")
        if not get_server_jar(cfg["version"], jar, info):
            sys.exit(c("[错误] 服务端下载失败", "red"))

    print(c(f"\n正在启动: MC {cfg['version']} 端口 {cfg['port']} "
            f"内存 {cfg.get('ram','2G')}", "bold"))
    p = start_server(server_dir, cfg)
    print(c(f"  已启动! PID {p.pid}", "green"))
    print(f"  日志: {server_dir}/logs/latest.log")

    # 等服务器就绪后注入 gamerule (如死亡不掉落)
    if cfg.get("gamerules"):
        print(f"  等待服务器就绪...")
        if wait_ready(server_dir):
            for rule, val in cfg["gamerules"].items():
                send_console(server_dir, f"gamerule {rule} {val}")
            print(c(f"  已设置游戏规则: " + ", ".join(
                f"{k}={v}" for k, v in cfg["gamerules"].items()), "green"))
        else:
            print(c("  等待就绪超时, 游戏规则未注入(可用 console 命令手动设置)", "yellow"))
            diagnose(server_dir, cfg)
    print(c(f"\n完成! 关服: 1b1t-open-server stop {server_dir}", "green"))
    # 交互终端下自动接入控制台 (管道/脚本则跳过)
    if sys.stdin.isatty():
        attach_console(server_dir)


def _tail_error(server_dir, n=8):
    """读 console.log 尾部关键报错行, 用于启动失败提示"""
    try:
        path = os.path.join(runtime_dir(server_dir), "console.log")
        if not os.path.exists(path):
            return ""
        with open(path, errors="ignore") as f:
            f.seek(0, 2)
            size = f.tell()
            f.seek(max(0, size - 4096))
            lines = f.read().splitlines()
        errs = [ln for ln in lines
                if re.search(r"error|exception|fail|错误|失败|Unable|Could not",
                             ln, re.I)]
        return "\n".join(errs[-n:])
    except OSError:
        return ""


def api_start(server_dir, cfg, log=print):
    """非交互启动 (GUI 用): 按 cfg 下载并启动, 日志走 log 回调
    返回 (成功?, 失败原因) 供 GUI 弹窗提示"""
    def out(msg):
        log(re.sub(r"\x1b\[[0-9;]*m", "", msg))

    old = read_pid(server_dir)
    if old and is_running(old["pid"]):
        out(f"[错误] 服务器已在运行 (PID {old['pid']})")
        return False, f"服务器已在运行 (PID {old['pid']})"

    info = get_version_info(cfg["version"])
    java_major = info.get("javaVersion", {}).get("majorVersion")
    if java_major:
        cfg["java"] = java_major

    with open(os.path.join(server_dir, "eula.txt"), "w") as f:
        f.write("# 继续使用即代表您同意 Minecraft EULA\n"
                "# https://aka.ms/MinecraftEULA\neula=true\n")
    with open(os.path.join(server_dir, "server.properties"), "w") as f:
        f.write(render_properties(cfg["props"]))
    save_cfg(server_dir, cfg)

    java_bin = pick_java(cfg["version"], cfg.get("java"))
    stype = cfg.get("server_type", "vanilla")
    if stype == "fabric":
        jar = os.path.join(server_dir, "fabric-server-launch.jar")
        if not os.path.exists(jar) or os.path.getsize(jar) < 1000:
            out("正在安装 Fabric 服务端...")
            if not get_fabric_server_jar(cfg["version"], server_dir, java_bin,
                                         cfg.get("mod_version")):
                out("[错误] Fabric 安装失败")
                return False, "Fabric 服务端安装失败, 请检查网络后重试"
    elif stype in ("neoforge", "forge"):
        if not os.path.exists(os.path.join(server_dir, "run.sh")) and \
           not os.path.exists(os.path.join(server_dir, "run.bat")):
            out(f"正在安装 {stype} (下载依赖库, 可能需要几分钟)...")
            reuse_libraries(server_dir)
            if not get_mod_installer(cfg["version"], stype, server_dir,
                                     java_bin, cfg.get("mod_version")):
                out(f"[错误] {stype} 安装失败")
                return False, f"{stype} 安装失败, 请检查网络后重试"
    else:
        jar = os.path.join(server_dir, "server.jar")
        if not get_server_jar(cfg["version"], jar, info):
            out("[错误] 服务端下载失败")
            return False, "服务端核心下载失败, 请检查网络后重试"

    out(f"正在启动: MC {cfg['version']} 端口 {cfg['port']} "
        f"内存 {cfg.get('ram', '2G')}")
    p = start_server(server_dir, cfg)
    out(f"已启动! PID {p.pid}")

    if cfg.get("gamerules"):
        out("等待服务器就绪(注入游戏规则)...")
        if wait_ready(server_dir):
            for rule, val in cfg["gamerules"].items():
                send_console(server_dir, f"gamerule {rule} {val}")
            out("已设置游戏规则: " + ", ".join(
                f"{k}={v}" for k, v in cfg["gamerules"].items()))
        else:
            out("等待就绪超时, 游戏规则未注入(可用 console 命令手动设置)")
    return True, None


def kill_orphan_java(server_dir, log=print):
    """扫描命令行含本服务器目录的 java 进程并强杀
    (pid.json 丢失/损坏时的孤儿进程兜底, 防端口占用)"""
    real = os.path.realpath(server_dir)
    targets = []
    try:
        if IS_WIN:
            import subprocess as sp
            out = sp.run(["wmic", "process", "get",
                          "CommandLine,ProcessId"],
                         capture_output=True, text=True,
                         timeout=15).stdout
            for ln in out.splitlines():
                parts = ln.rsplit(None, 1)
                if len(parts) == 2 and real in parts[0] \
                        and "java" in parts[0] and parts[1].isdigit():
                    targets.append(int(parts[1]))
        else:
            for pid in os.listdir("/proc"):
                if not pid.isdigit():
                    continue
                try:
                    with open(f"/proc/{pid}/cmdline", "rb") as f:
                        cmd = f.read().decode(errors="ignore").replace(
                            "\x00", " ")
                except OSError:
                    continue
                if real in cmd and "java" in cmd:
                    targets.append(int(pid))
    except Exception:
        pass
    for pid in targets:
        try:
            if IS_WIN:
                import signal as _sig
                os.kill(pid, _sig.SIGTERM)  # Windows 上即 TerminateProcess
            else:
                os.killpg(pid, 9)
            log(c(f"  已清理残留进程 PID {pid}", "yellow"))
        except (OSError, ProcessLookupError):
            pass
    return targets


def _reap(pid):
    """回收僵尸子进程 (java 经 exec 链是工具的直接子进程,
    不 waitpid 就变僵尸; 非本进程子进程时静默忽略)"""
    try:
        os.waitpid(pid, os.WNOHANG)
    except (OSError, ChildProcessError):
        pass


def do_stop(server_dir):
    old = read_pid(server_dir)
    if not old or not is_running(old["pid"]):
        # pid.json 无效/丢失时仍扫描孤儿 java 进程 (用户"关不掉"根因)
        orphans = kill_orphan_java(server_dir)
        if orphans:
            print(c("已清理残留进程", "yellow"))
        else:
            print(c("服务器未在运行", "yellow"))
        return 0
    print(f"发送 stop 命令 (PID {old['pid']})...")
    if send_console(server_dir, "stop"):
        deadline = time.time() + 60
        waited = 0
        while is_running(old["pid"]) and time.time() < deadline:
            time.sleep(1)
            waited += 1
            if waited % 10 == 0:
                print(f"  等待服务器退出... {waited}s/60s")
    _reap(old["pid"])  # 回收僵尸, 避免下次 stop 又误判"超时强杀"
    if is_running(old["pid"]):
        print(c("优雅关闭超时, 结束进程...", "yellow"))
        try:
            if IS_WIN:
                import signal as _sig
                os.kill(old["pid"], _sig.SIGTERM)  # Windows 上即 TerminateProcess
            else:
                os.killpg(old["pid"], 15)  # 杀整个进程组(含 run.sh 包装)
        except (OSError, ImportError):
            pass
        time.sleep(10)
    if is_running(old["pid"]):
        print(c("强制结束进程", "red"))
        try:
            if IS_WIN:
                import signal as _sig
                os.kill(old["pid"], _sig.SIGTERM)  # Windows 上即 TerminateProcess
            else:
                os.killpg(old["pid"], 9)  # SIGKILL 整个进程组, 不残留孤儿
        except (OSError, ImportError):
            pass
    keeper = old.get("keeper")
    if keeper and is_running(keeper):
        try:
            import signal as _sig
            os.kill(keeper, _sig.SIGTERM)
            for _ in range(10):
                time.sleep(0.5)
                if not is_running(keeper):
                    break
            if is_running(keeper):
                os.kill(keeper, _sig.SIGTERM)  # Windows 上即 TerminateProcess
        except (OSError, ImportError):
            pass
    if keeper:
        _reap(keeper)  # 回收 keeper 僵尸 (同上, 不回收下次误判)
    try:
        os.remove(os.path.join(runtime_dir(server_dir), "pid.json"))
    except OSError:
        pass
    # 兜底: 扫描本服务器目录的 java 孤儿进程 (pid.json 丢失时也能清干净)
    kill_orphan_java(server_dir)
    print(c("已停止", "green"))


def do_kill(server_dir):
    """强制杀死服务器进程(不保存, 仅 stop 卡死时用)"""
    old = read_pid(server_dir)
    if not old or not is_running(old["pid"]):
        print(c("服务器未在运行", "yellow"))
        return 0
    print(c(f"强制杀死进程 PID {old['pid']} (不会保存世界!)", "red"))
    try:
        if IS_WIN:
            import signal as _sig
            os.kill(old["pid"], _sig.SIGTERM)
        else:
            os.kill(old["pid"], 9)
    except OSError:
        pass
    keeper = old.get("keeper")
    if keeper and is_running(keeper):
        try:
            import signal as _sig
            os.kill(keeper, _sig.SIGTERM)
        except OSError:
            pass
    try:
        os.remove(os.path.join(runtime_dir(server_dir), "pid.json"))
    except OSError:
        pass
    print(c("已杀死", "green"))


def world_dirs(server_dir, cfg):
    """该服务器需要备份的世界目录列表 (主世界/下界/末地)"""
    props = (cfg or {}).get("props", {})
    level = props.get("level-name", "world")
    names = [level, level + "_nether", level + "_the_end"]
    return [d for d in names
            if os.path.isdir(os.path.join(server_dir, d))]


def backup_world(server_dir, log=print):
    """备份存档到 server_dir/backups/<世界>_时间戳.tar.gz
    运行中自动 save-all + save-off → 打包 → save-on 保证文件一致
    按设置保留最近 N 份, 记录 last_backup 时间戳; 返回备份路径或 None"""
    cfg = load_cfg(server_dir)
    worlds = world_dirs(server_dir, cfg)
    if not worlds:
        log(c("[备份] 没有找到世界存档目录 (未开服过?)", "yellow"))
        return None
    running = False
    old = read_pid(server_dir)
    if old and is_running(old["pid"]):
        running = True
        send_console(server_dir, "save-all")
        send_console(server_dir, "save-off")  # 暂停自动保存保证文件一致
        time.sleep(3)
    level = (cfg or {}).get("props", {}).get("level-name", "world")
    stamp = time.strftime("%Y%m%d_%H%M%S")
    backups = os.path.join(server_dir, "backups")
    os.makedirs(backups, exist_ok=True)
    out = os.path.join(backups, f"{level}_{stamp}.tar.gz")
    try:
        import tarfile
        with tarfile.open(out, "w:gz") as tf:
            for d in worlds:
                tf.add(os.path.join(server_dir, d),
                       arcname=os.path.basename(d))
    except Exception as e:
        log(c(f"[备份] 打包失败: {e}", "red"))
        if running:
            send_console(server_dir, "save-on")
        return None
    if running:
        send_console(server_dir, "save-on")
    size = os.path.getsize(out)
    if size >= 1 << 20:
        size_txt = f"{size // (1 << 20)} MB"
    else:
        size_txt = f"{size >> 10} KB"  # 小存档别显示成 0 MB 吓人
    log(c(f"[备份] 完成: {os.path.basename(out)} ({size_txt})", "green"))
    if cfg:
        cfg["last_backup"] = int(time.time())
        save_cfg(server_dir, cfg)
    # 按保留份数清理旧备份 (防磁盘被备份塞满)
    st = load_settings()
    try:
        keep = max(1, int(st.get("backup_keep", 10) or 10))
    except (ValueError, TypeError):
        keep = 10
    names = sorted([f for f in os.listdir(backups) if f.endswith(".tar.gz")],
                   reverse=True)
    for old_f in names[keep:]:
        try:
            os.remove(os.path.join(backups, old_f))
            log(c(f"[备份] 清理旧备份: {old_f}", "dim"))
        except OSError:
            pass
    return out


def do_backup(server_dir):
    """backup 命令: 手动备份存档"""
    return 0 if backup_world(server_dir) else 1


def do_status(server_dir):
    old = read_pid(server_dir)
    cfg = load_cfg(server_dir)
    if not old or not is_running(old["pid"]):
        print(c("状态: 未运行", "yellow"))
        if cfg:
            print(f"配置: MC {cfg['version']} 端口 {cfg['port']} "
                  f"内存 {cfg.get('ram','2G')}")
        return 0
    uptime = int(time.time()) - old.get("start", 0)
    print(c("状态: 运行中", "green"))
    print(f"  PID: {old['pid']}  已运行: {uptime//3600}h{uptime%3600//60}m")
    if cfg:
        print(f"  MC: {cfg['version']}  端口: {cfg['port']}  内存: {cfg.get('ram','2G')}")
        try:
            s = socket.create_connection(("127.0.0.1", int(cfg["port"])), 2)
            s.close()
            print(c("  端口监听: 正常", "green"))
        except OSError:
            print(c("  端口监听: 未就绪", "yellow"))


# ---------- 向导 ----------

def pick_difficulty():
    """难度选择: 中文表格 + 数字"""
    print(c("  难度(数字选择):", "cyan"))
    print_table([
        ("编号", "难度", "说明"),
        ("1", "和平", "无怪物, 饥饿不减少, 适合纯建筑"),
        ("2", "简单", "怪物弱, 饥饿不掉到10心以下"),
        ("3", "普通", "标准体验(默认)"),
        ("4", "困难", "怪物强, 饥饿可致死, 僵尸破门"),
    ])
    while True:
        ans = ask("  选择", "3")
        quit_ans(ans)
        if ans in ("1", "2", "3", "4"):
            return ("peaceful", "easy", "normal", "hard")[int(ans) - 1]
        if ans.lower() in ("peaceful", "easy", "normal", "hard"):
            return ans.lower()
        print(c("  请输入 1-4 或英文难度名", "red"))


def default_ram():
    """不询问, 直接取空闲内存 70% 内的最大档位"""
    avail = avail_mem_mb()
    cap = int((avail or 2048) * 0.7)
    tiers = [1024, 2048, 4096, 8192, 16384, 32768, 65536]
    opts = [t for t in tiers if t <= cap][-4:] or [1024]
    return f"{opts[-1] // 1024}G"


def pick_ram():
    """内存上限选择: 整机空闲内存 70% 以下的档位, 可自定义"""
    total = total_mem_mb()
    avail = avail_mem_mb()
    cap = int((avail or 2048) * 0.7)  # 上限 = 空闲的70%
    tiers = [1024, 2048, 4096, 8192, 16384, 32768, 65536]
    opts = [t for t in tiers if t <= cap][-4:] or [1024]
    info = ""
    if total and avail:
        info = f"整机{total // 1024}G 空闲{avail // 1024}G"
    print(c(f"  内存上限 {info} (最大建议 = 空闲70%):", "cyan"))
    for i, t in enumerate(opts):
        mark = c("(推荐)", "green") if i == len(opts) - 1 else ""
        print(f"    {i+1}. {t // 1024}G {mark}")
    print(f"    也可以直接输入, 如 4G/512M (纯数字按G算)")
    while True:
        ans = ask("  选择", str(len(opts)))
        quit_ans(ans)
        if ans.isdigit() and 1 <= int(ans) <= len(opts):
            return f"{opts[int(ans) - 1] // 1024}G"
        if re.match(r"^\d+[GM]?$", ans, re.I):
            return ans.upper() + ("G" if not re.search(r"[GM]", ans, re.I) else "")
        print(c("  无效, 请输入序号或如 4G/512M", "red"))


def wizard(server_dir, advanced=False):
    """交互式向导, 返回配置 dict(含 dir 字段)
    简单模式(默认): 只问版本/类型/目录/端口 4 项, 无任何 y/n 询问, 直接开服
    高级模式(--advanced): 逐项询问 11 项配置 + 全项编辑 + 确认"""
    print(c(BANNER, "cyan"))

    ver = pick_version()["id"]
    stype = pick_server_type()
    mod_version = None
    if stype != "vanilla":
        mod_version = pick_mod_version(ver, stype)

    if server_dir is None:
        step(2, "选择服务器位置")
        d = ask("  服务器目录", os.path.expanduser(f"~/1b1t-{ver}"))
        quit_ans(d)
        server_dir = os.path.abspath(d)
    os.makedirs(server_dir, exist_ok=True)
    print(f"  目录: {c(server_dir, 'green')}")
    if os.listdir(server_dir):
        print(c("  注意: 目录非空, 已有文件不会被覆盖(server.properties 除外)", "yellow"))

    step(3, "选择端口")
    while True:
        port = ask("  端口", "25565")
        quit_ans(port)
        if not port.isdigit() or not 1 <= int(port) <= 65535:
            print(c("  端口无效, 请输入 1-65535 (0 退出)", "red"))
            continue
        # 端口占用检测: 被占用自动换空闲端口
        s = socket.socket()
        try:
            s.bind(("0.0.0.0", int(port)))
            s.close()
            break
        except OSError:
            free = free_port()
            print(c(f"  端口 {port} 已被占用(有服务器在跑), 自动改用空闲端口 {free}",
                    "yellow"))
            port = str(free)
            break

    props = {"server-port": port}
    keep = False
    if not advanced:  # 简单: 4 项重要选择后零询问, 用软件设置里的默认值直接开
        st = load_settings()
        props["online-mode"] = st["online_mode"]
        props["motd"] = st["motd"]
        props["difficulty"] = st["difficulty"]
        keep = st["keep_inventory"] == "true"
        ram = default_ram()
        print(c(f"  默认配置: 正版验证{'开' if props['online-mode'] == 'true' else '关'}"
                f" · {props['difficulty']}难度 · 死亡掉落{'开' if keep else '关'}"
                f" · 内存 {ram} (自动)", "cyan"))
    else:  # 高级: 逐项询问 11 项 + 全项编辑 + 确认
        step(4, "配置")
        props["online-mode"] = str(ask_bool("  正版验证", True)).lower()
        props["enable-command-block"] = str(ask_bool("  命令方块", False)).lower()
        keep = ask_bool("  死亡不掉落", False)
        props["motd"] = ask("  MOTD(服务器名)", "1b1t Server")
        props["difficulty"] = pick_difficulty()
        props["max-players"] = ask("  最大玩家数", "20")
        props["view-distance"] = ask("  视距", "10")
        props["white-list"] = str(ask_bool("  白名单", False)).lower()
        props["pvp"] = str(ask_bool("  PVP", True)).lower()
        props["level-seed"] = ask("  种子(空=随机)", "")
        ram = pick_ram()
        advanced_editor(props)

    cfg = {"dir": server_dir, "version": ver, "server_type": stype,
           "mod_version": mod_version, "port": int(port), "ram": ram,
           "props": props, "gamerules": {}}
    if keep:
        cfg["gamerules"]["keepInventory"] = "true"

    type_desc = stype + (f" {mod_version}" if mod_version else "")
    print(f"  类型: {c(type_desc, 'green')}    MC 版本: {c(ver, 'green')}    "
          f"端口: {c(port, 'green')}    内存: {c(ram, 'green')}")
    print(f"  目录: {c(server_dir, 'green')}")
    if advanced:
        if not ask_bool("  确认开服?", True):
            sys.exit("已取消")
    return cfg


# ---------- 入口 ----------

def _mirror_download(job):
    """并发下载任务: (描述, [urls], 镜像目标路径) → 结果描述或 None"""
    desc, urls, mp = job
    if os.path.exists(mp) and os.path.getsize(mp) > 0:
        return None  # 已缓存
    os.makedirs(os.path.dirname(mp), exist_ok=True)
    tmp = mp + ".part"
    for attempt in range(3):  # 限流/抖动时重试
        if os.path.exists(tmp):
            os.remove(tmp)
        for u in urls:
            if _fetch_one(u, tmp, quiet=True):
                os.replace(tmp, mp)
                return desc
        # 404 = 源上不存在(旧版本已被清理), 重试无意义, 直接放弃
        try:
            req = urllib.request.Request(urls[0], method="HEAD",
                                         headers={"User-Agent": APP})
            urllib.request.urlopen(req, timeout=20)
        except urllib.error.HTTPError as e:
            if e.code == 404:
                break
        except Exception:
            pass
        time.sleep(5)
    try:
        os.remove(tmp)
    except OSError:
        pass
    return f"失败: {desc}"


def do_mirror(versions):
    """预取安装包到镜像目录 (serverdown 直接可见)
    无参数 = 全部正式版 vanilla + 全部 NeoForge/Forge 安装器 + Fabric 安装器"""
    from concurrent.futures import ThreadPoolExecutor
    print(c(f"镜像目录: {mirror_dir()}", "cyan"))
    releases = [v["id"] for v in load_manifest(force=True)
                if v["type"] == "release"]
    if versions:
        releases = versions
        print(f"  预取版本: {', '.join(releases)}")
    else:
        print(f"  全量预取: {len(releases)} 个正式版 + 全部 mod 安装器")
    jobs = []
    # 1. vanilla 服务端 (BMCLAPI 优先, 官方 piston 回退)
    for mc in releases:
        u = BMCL_SERVER_JAR.format(vid=mc)
        urls = [u]
        try:
            off = get_version_info(mc).get("downloads", {}).get("server", {}).get("url")
            if off:
                urls.append(off)
        except Exception:
            pass
        jobs.append((f"vanilla {mc}", urls, _mirror_path(u)))
    # 2. mod 安装器
    for stype, meta_url, mvn, group in (
            ("neoforge", NEOFORGE_META, "https://maven.neoforged.net/releases",
             "net/neoforged/neoforge"),
            ("forge", FORGE_META, "https://maven.minecraftforge.net",
             "net/minecraftforge/forge")):
        try:
            meta = http_get(meta_url, 60)
            vers = [v for v in re.findall(r"<version>([^<]+)</version>", meta)
                    if not re.search(r"beta|alpha|rc", v, re.I)]
        except Exception as e:
            print(c(f"  {stype} 版本列表获取失败: {e}", "yellow"))
            continue
        if versions:  # 指定版本时只取该 MC 版本对应的安装器
            if stype == "neoforge":
                keys = [v[2:] for v in versions if v.startswith("1.")]
                vers = [v for v in vers
                        if any(re.match(rf"^{re.escape(k)}\.\d+$", v) for k in keys)]
            else:
                vers = [v for v in vers
                        if any(v.startswith(mc + "-") for mc in versions)]
        for v in vers:
            path = f"{group}/{v}/{stype}-{v}-installer.jar"
            u = f"{mvn}/{path}"
            jobs.append((f"{stype} {v}", [u, f"https://bmclapi2.bangbang93.com/maven/{path}"],
                         _mirror_path(u)))
    # 3. Fabric 安装器 (最新一个即可, 支持任意 loader 版本)
    try:
        meta = http_get("https://maven.fabricmc.net/net/fabricmc/fabric-installer/maven-metadata.xml", 60)
        iv = re.search(r"<release>([^<]+)</release>", meta).group(1)
        path = f"net/fabricmc/fabric-installer/{iv}/fabric-installer-{iv}.jar"
        u = f"https://maven.fabricmc.net/{path}"
        jobs.append(("fabric-installer " + iv, [u, f"https://bmclapi2.bangbang93.com/maven/{path}"],
                     _mirror_path(u)))
    except Exception as e:
        print(c(f"  fabric 列表获取失败: {e}", "yellow"))

    print(f"  共 {len(jobs)} 个文件, 30 线程并发下载...")
    done = 0
    failed = []
    with ThreadPoolExecutor(max_workers=30) as ex:
        for r in ex.map(_mirror_download, jobs):
            done += 1
            if r:
                failed.append(r)
            if done % 10 == 0 or done == len(jobs):
                print(f"\r  进度: {done}/{len(jobs)}", end="", flush=True)
    print()
    if failed:
        print(c(f"  失败 {len(failed)} 个: {', '.join(failed[:8])}{'...' if len(failed) > 8 else ''}",
                "red"))
    print(c(f"\n完成! 镜像已在 serverdown 可见: {mirror_http()}", "green"))


def do_config(server_dir):
    """修改服务器设置: 内存/端口/人数/全部项, 改完保存并提示重启生效"""
    cfg = load_cfg(server_dir)
    if not cfg:
        sys.exit(c(f"[错误] 没有找到配置: {server_dir}", "red"))
    props = dict(cfg["props"])
    while True:
        port_now = str(cfg.get("port") or props.get("server-port", "25565"))
        motd = props.get("motd", "")
        motd_lines = motd.split("\n") if motd else []
        name_now = motd_lines[0] if motd_lines else ""
        sub_now = motd_lines[1] if len(motd_lines) > 1 else ""
        print(c(f"\n[修改服务器设置] {server_dir}", "cyan"))
        print(c(f"  当前: 端口 {port_now} · 内存 {cfg.get('ram', '?')} · "
                f"人数 {props.get('max-players', '20')}", "dim"))
        print(f"  1. 内存上限      = {c(cfg.get('ram', '?'), 'green')}")
        print(f"  2. 端口          = {c(port_now, 'green')}")
        print(f"  3. 最大人数      = {c(props.get('max-players', '20'), 'green')}")
        print(f"  4. 服务器名字    = {c(name_now or '(未设置)', 'green')}"
              f"{('  副标题 = ' + c(sub_now, 'green')) if sub_now else ''}")
        print(f"  5. 高级选项(编辑全部项)")
        print(c("  输入 1-5 修改, 0 退出", "yellow"))
        ans = ask("  修改")
        changed = False
        if ans in ("", "0"):
            break
        if ans == "1":
            # 内存: 空闲70%以下档位, 可自定义, 0 取消 (不改动)
            total = total_mem_mb()
            avail = avail_mem_mb()
            cap = int((avail or 2048) * 0.7)
            tiers = [1024, 2048, 4096, 8192, 16384, 32768, 65536]
            opts = [t for t in tiers if t <= cap][-4:] or [1024]
            info = ""
            if total and avail:
                info = f"整机{total // 1024}G 空闲{avail // 1024}G"
            print(c(f"  内存上限 {info} (最大建议 = 空闲70%):", "cyan"))
            for i, t in enumerate(opts):
                mark = c("(推荐)", "green") if i == len(opts) - 1 else ""
                print(f"    {i+1}. {t // 1024}G {mark}")
            print("    也可以直接输入, 如 4G/512M (纯数字按G算, 0 取消)")
            while True:
                a = ask("  选择", str(len(opts)))
                if a == "0":
                    break
                if a.isdigit() and 1 <= int(a) <= len(opts):
                    cfg["ram"] = f"{opts[int(a) - 1] // 1024}G"
                    changed = True
                    break
                if re.match(r"^\d+[GM]?$", a, re.I):
                    cfg["ram"] = a.upper() + ("G" if not re.search(r"[GM]", a, re.I) else "")
                    changed = True
                    break
                print(c("  无效, 请输入序号或如 4G/512M (0 取消)", "red"))
        elif ans == "2":
            while True:
                port = ask("  新端口", port_now)
                if port == "0":
                    break
                if not port.isdigit() or not 1 <= int(port) <= 65535:
                    print(c("  端口无效, 请输入 1-65535 (0 取消)", "red"))
                    continue
                # 端口占用检测: 被占用自动换空闲端口
                s = socket.socket()
                try:
                    s.bind(("0.0.0.0", int(port)))
                    s.close()
                except OSError:
                    free = free_port()
                    print(c(f"  端口 {port} 已被占用(有服务器在跑), 自动改用空闲端口 {free}",
                            "yellow"))
                    port = str(free)
                cfg["port"] = int(port)
                props["server-port"] = port
                changed = True
                break
        elif ans == "3":
            while True:
                n = ask("  最大人数", str(props.get("max-players", "20")))
                if n == "0":
                    break
                if n.isdigit() and 1 <= int(n) <= 100000:
                    props["max-players"] = n
                    changed = True
                    break
                print(c("  无效, 请输入正整数 (0 取消)", "red"))
        elif ans == "4":
            # 服务器名字和副标题 (游戏内服务器列表看到的两行)
            print(c("  服务器名字 = 游戏界面看到的主标题", "dim"))
            print(c("  副标题 = 名字下面的一行小字 (留空 = 不要副标题, 0 = 取消)", "dim"))
            name = ask("  服务器名字", name_now or "1b1t Server")
            if name == "0":
                continue
            sub = ask("  副标题", sub_now)
            if sub == "0":
                continue
            props["motd"] = name + ("\n" + sub if sub else "")
            changed = True
        elif ans == "5":
            advanced_editor(props)
            changed = True
        else:
            print(c("  输入 1-5 修改, 0 退出", "red"))
            continue
        if not changed:
            continue
        cfg["props"] = props
        save_cfg(server_dir, cfg)
        with open(os.path.join(server_dir, "server.properties"), "w") as f:
            f.write(render_properties(props))
        print(c("已保存", "green"))
        old = read_pid(server_dir)
        if old and is_running(old["pid"]):
            print(c(f"服务器正在运行, 重启后生效: 1b1t restart {server_dir}", "yellow"))
    return 0


def do_settings():
    """软件设置: 默认配置值 / 镜像目录 / 镜像 HTTP 地址"""
    st = load_settings()
    print(c("[软件设置]", "bold"))
    print(c("  修改后新开服务器(简单模式)会使用这些默认值", "dim"))
    items = [
        ("1", "默认正版验证", st["online_mode"], "true/false"),
        ("2", "默认难度", st["difficulty"], "peaceful/easy/normal/hard"),
        ("3", "默认MOTD", st["motd"], "服务器显示名"),
        ("4", "默认死亡不掉落", st["keep_inventory"], "true/false"),
        ("5", "镜像目录", st.get("mirror_dir") or "(默认 ~/1b1t-mirror)",
         "留空=恢复默认"),
        ("6", "镜像HTTP地址", st.get("mirror_http") or MIRROR_HTTP,
         "其他机器的下载入口"),
        ("7", "定时备份间隔(分钟)", st.get("backup_interval_min", "0"),
         "0=关闭, GUI 开着时自动备份"),
        ("8", "备份保留份数", st.get("backup_keep", "10"),
         "超过自动删最旧的"),
    ]
    while True:
        print()
        print_table([("编号", "设置项", "当前值", "说明")] + items)
        print(c("  修改: 输入 '编号 值' (如 2 hard), 输入 0 退出", "yellow"))
        ans = ask("  修改", "")
        if ans in ("", "0"):
            break
        m = re.match(r"(\d+)\s+(.*)", ans)
        if not m:
            print(c("  格式: 编号 值, 如: 2 hard; 0 退出", "red"))
            continue
        i = int(m.group(1)) - 1
        if not 0 <= i < len(items):
            print(c("  编号无效", "red"))
            continue
        key = ("online_mode", "difficulty", "motd", "keep_inventory",
               "mirror_dir", "mirror_http", "backup_interval_min",
               "backup_keep")[i]
        val = m.group(2).strip()
        if key in ("online_mode", "keep_inventory"):
            val = str(val.lower() in ("true", "y", "yes", "1")).lower()
        if key == "mirror_dir":
            val = "" if val == "默认" else val
        if key in ("backup_interval_min", "backup_keep"):
            if not val.isdigit():
                print(c("  请输入非负整数", "red"))
                continue
            val = str(int(val))
        st[key] = val
        items = [
            ("1", "默认正版验证", st["online_mode"], "true/false"),
            ("2", "默认难度", st["difficulty"], "peaceful/easy/normal/hard"),
            ("3", "默认MOTD", st["motd"], "服务器显示名"),
            ("4", "默认死亡不掉落", st["keep_inventory"], "true/false"),
            ("5", "镜像目录", st.get("mirror_dir") or "(默认 ~/1b1t-mirror)",
             "留空=恢复默认"),
            ("6", "镜像HTTP地址", st.get("mirror_http") or MIRROR_HTTP,
             "其他机器的下载入口"),
            ("7", "定时备份间隔(分钟)", st.get("backup_interval_min", "0"),
             "0=关闭, GUI 开着时自动备份"),
            ("8", "备份保留份数", st.get("backup_keep", "10"),
             "超过自动删最旧的"),
        ]
        save_settings(st)
        print(c("已保存", "green"))
    return 0


def find_servers():
    """扫描 ~ 下含 .1b1t-open-server/config.json 的目录"""
    found = []
    seen = set()
    home = os.path.expanduser("~")
    try:
        entries = os.listdir(home)
    except OSError:
        return found
    for entry in entries:
        d = os.path.join(home, entry)
        if not os.path.isdir(d) or entry.startswith("."):
            continue
        if load_cfg(d):
            rp = os.path.realpath(d)
            if rp not in seen:
                seen.add(rp)
                found.append(d)
    return found


def main_menu():
    """无参数时的主菜单: 开服/启动/删除/状态"""
    print(c(BANNER, "cyan"))
    while True:
        servers = find_servers()
        print(c("\n[主菜单]", "bold"))
        print("  1. 开服向导 (新服务器)")
        print("  2. 启动服务器 (已有服务器)")
        print("  3. 删除服务器")
        print("  4. 查看状态")
        print("  5. 修改服务器设置 (server.properties)")
        print("  6. 软件设置")
        print("  7. 强制杀死进程 (不保存世界)")
        print("  0. 退出")
        ans = ask("  选择", "1")
        if ans == "1":
            do_start(None)
            return
        if ans == "0":
            sys.exit(0)
        if ans == "6":
            do_settings()
            continue
        if ans not in ("2", "3", "4", "5", "7"):
            print(c("  无效选择", "red"))
            continue
        if not servers:
            print(c("  没有找到已有服务器 (也可用: 1b1t start <目录>)", "yellow"))
            continue
        print(c("  已有服务器:", "cyan"))
        for i, d in enumerate(servers):
            c0 = load_cfg(d)
            print(f"    {i+1}. {d}  (MC {c0['version']})")
        print("    也可以直接输入目录路径")
        choice = ask("  选择")
        if choice.isdigit() and 1 <= int(choice) <= len(servers):
            d = servers[int(choice) - 1]
        else:
            d = os.path.abspath(os.path.expanduser(choice))
        if ans == "2":
            do_start(d)
            return
        if ans == "3":
            if ask_bool(c(f"  确认删除整个目录 {d}? 不可恢复!", "red"), False):
                # 目录里有服务器在运行则先关闭, 避免删目录后进程变孤儿
                old = read_pid(d)
                if old and is_running(old["pid"]):
                    print(c("  服务器正在运行, 先关闭...", "yellow"))
                    do_stop(d)
                shutil.rmtree(d, ignore_errors=True)
                print(c("已删除", "green"))
            continue
        if ans == "4":
            do_status(d)
            continue
        if ans == "5":
            do_config(d)
            continue
        if ans == "7":
            if ask_bool(c(f"  确认强制杀死 {d}? 不会保存世界!", "red"), False):
                do_kill(d)
            continue


def usage():
    print(f"""用法: {APP} [命令] [参数]

  无参数             主菜单: 开服向导/启动服务器/删除服务器/查看状态
  start              开服向导(选版本→目录→端口→配置, 简单/高级模式)
  start <目录>       按已有配置开服
  stop <目录>        关服(默认当前目录)
  restart <目录>     重启
  status <目录>      查看状态
  doctor <目录>      自主排查问题(开服失败时也会自动运行)
  console <目录> <命令>   向服务器控制台发送命令(如: console ./ say hello)
  kill <目录>          强制杀死服务器进程(不保存世界, stop 卡死时用)
  config <目录>        修改服务器设置(内存/端口/人数/全部项)
  settings             软件设置(默认配置/镜像目录/镜像HTTP地址)
  mirror [版本...]     预取安装包到本地镜像 ~/1b1t-mirror (之后开服不走网络)
  agent [--port N] [--token T]   启动本地 Agent 接口 (AI 通过 HTTP 控制,
                              接口 http://127.0.0.1:18999, 无 GUI 也能用)
  mcp                 以 MCP 协议运行 (stdio, 给 Claude Code 等 AI 工具用)
  mcp-install         把本程序注册到本机 AI 工具 (Claude Code/Cursor/桌面版)
  version             查看软件版本号
  其他: --dry-run 只生成配置, 不下载不启动; 开服后自动接入控制台(exit 退出)
        --advanced 高级向导(逐项询问 11 项配置+全项编辑); 默认简单模式零询问""")


def main():
    args = sys.argv[1:]
    if args and args[0] in ("-h", "--help", "help"):
        usage()
        return 0
    if args and args[0] in ("version", "-V", "--version"):
        print(f"{APP} v{APP_VERSION}")
        # 更新通知: 有新版时提示 (网络失败静默跳过)
        latest = check_update(timeout=3)
        if latest and _ver_tuple(latest) > _ver_tuple(APP_VERSION):
            print(c(f"  发现新版本 v{latest} → {UPDATE_URL}", "yellow"))
        return 0
    if args and args[0] == "__sub":
        # 内部子进程入口: keeper(TCP 控制台转发) / cleanup(stop 收尾)
        # 冻结打包后不能用 "二进制 -c 代码", 统一走 __sub
        if len(args) > 2 and args[1] == "keeper":
            run_keeper(args[2])
        elif len(args) > 2 and args[1] == "cleanup":
            run_cleanup(args[2])
        return 0

    cmd = "start"
    server_dir = None
    dry_run = "--dry-run" in args
    advanced = "--advanced" in args
    args = [a for a in args if a not in ("--dry-run", "--advanced")]
    if args and args[0] in ("start", "stop", "restart", "status", "doctor",
                            "console", "mirror", "config", "settings",
                            "kill", "agent", "mcp", "mcp-install", "mods"):
        cmd = args.pop(0)
    if cmd == "mcp":
        return do_mcp()
    if cmd == "mcp-install":
        return do_mcp_install()
    if cmd == "agent":
        return do_agent(args)
    if cmd == "mods":
        return do_mods(args)
    if cmd == "mirror":
        return do_mirror(args)
    if cmd == "settings":
        return do_settings()
    if args and not args[0].startswith("-"):
        server_dir = os.path.abspath(args.pop(0))
        if cmd == "console" and args:
            return do_console(server_dir, " ".join(args))
    elif cmd == "console":
        sys.exit("console 需要: console <目录> <命令>")

    if cmd == "start" and server_dir is None:
        # 纯 1b1t → 主菜单(开服/启动/删除/状态); 1b1t start → 向导里选位置
        if len(sys.argv) == 1:
            main_menu()
            return 0
        do_start(None, dry_run=dry_run, advanced=advanced)
        return 0

    if server_dir is None:
        server_dir = os.getcwd()

    if cmd == "start":
        do_start(server_dir, dry_run=dry_run, advanced=advanced)
    elif cmd == "stop":
        do_stop(server_dir)
    elif cmd == "restart":
        do_stop(server_dir)
        do_start(server_dir)
    elif cmd == "status":
        do_status(server_dir)
    elif cmd == "doctor":
        do_doctor(server_dir)
    elif cmd == "config":
        do_config(server_dir)
    elif cmd == "kill":
        do_kill(server_dir)
    return 0


# ==================== 模组 / 插件 (Modrinth) ====================
MODRINTH_API = "https://api.modrinth.com"
MODRINTH_MIRROR = "https://mcdown.cn-nb1.rains3.com/modrinth"
MODRINTH_CDN = "https://cdn.modrinth.com"
MOD_UA = "1b1t-open-server/" + APP_VERSION


def mod_json(path, timeout=20):
    """Modrinth API: 官方优先, 1B1T 镜像兜底"""
    last = None
    for base in (MODRINTH_API, MODRINTH_MIRROR):
        try:
            return http_json(base + path, timeout=timeout)
        except Exception as e:  # noqa: BLE001
            last = e
    raise last if last else RuntimeError("Modrinth 不可达")


def mod_server_info(server_dir):
    cfg = load_cfg(server_dir) or {}
    stype = cfg.get("server_type", "vanilla")
    loader = {"fabric": "fabric", "neoforge": "neoforge", "forge": "forge"}.get(stype, "")
    return cfg.get("version", ""), loader, stype


def mod_target_dir(server_dir, ptype):
    return os.path.join(server_dir, "plugins" if ptype == "plugin" else "mods")


def mod_download(url, dest):
    """镜像优先 -> 官方 CDN; 返回错误文本(空=成功)"""
    import urllib.request
    urls = []
    if url.startswith(MODRINTH_CDN):
        urls.append(MODRINTH_MIRROR + url[len(MODRINTH_CDN):])
    urls.append(url)
    os.makedirs(os.path.dirname(dest), exist_ok=True)
    last = ""
    for u in urls:
        try:
            req = urllib.request.Request(u, headers={"User-Agent": MOD_UA})
            with urllib.request.urlopen(req, timeout=120) as r, open(dest, "wb") as f:
                shutil.copyfileobj(r, f)
            return ""
        except Exception as e:  # noqa: BLE001
            last = str(e)
    return last


def mod_versions(project, mc, loader, ptype):
    """某项目适配当前 MC 版本/加载器的版本(新→旧), 只保留有主文件的"""
    import urllib.parse
    q = []
    if mc:
        q.append("game_versions=" + urllib.parse.quote(json.dumps([mc])))
    if ptype == "mod" and loader:
        q.append("loaders=" + urllib.parse.quote(json.dumps([loader])))
    path = "/v2/project/" + urllib.parse.quote(project) + "/version"
    if q:
        path += "?" + "&".join(q)
    data = mod_json(path)
    out = []
    for v in (data if isinstance(data, list) else []):
        files = v.get("files") or []
        f = next((x for x in files if x.get("primary")), files[0] if files else None)
        if not f or not f.get("url"):
            continue
        out.append({
            "id": v.get("id", ""), "num": v.get("version_number", ""), "file": f,
            "deps": [d.get("version_id") for d in (v.get("dependencies") or [])
                     if d.get("dependency_type") == "required" and d.get("version_id")],
        })
    return out


def do_mods(args):
    """1b1t mods <目录> list|search|install|remove [--type mod|plugin]"""
    if len(args) < 2:
        print(c("用法: 1b1t mods <目录> list", "yellow"))
        print(c("      1b1t mods <目录> search <关键词> [--type plugin]", "yellow"))
        print(c("      1b1t mods <目录> install <slug或项目ID> [--type plugin] [--version <版本ID>]", "yellow"))
        print(c("      1b1t mods <目录> remove <文件名> [--type plugin]", "yellow"))
        return 1
    server_dir = args[0]
    if not os.path.isdir(server_dir):
        found = agent_find(server_dir)
        if not found:
            sys.exit(c("[错误] 目录不存在: " + server_dir, "red"))
        server_dir = found
    action = args[1]
    ptype = "plugin" if "--type" in args and args[args.index("--type") + 1:args.index("--type") + 2] == ["plugin"] else "mod"
    version_id = ""
    if "--version" in args:
        i = args.index("--version")
        if i + 1 < len(args):
            version_id = args[i + 1]
    rest = []
    skip = False
    for i, a in enumerate(args[2:]):
        if skip:
            skip = False
            continue
        if a in ("--type", "--version"):
            skip = True
            continue
        rest.append(a)

    mc, loader, stype = mod_server_info(server_dir)
    if ptype == "mod" and not loader:
        print(c("原版(Vanilla)服务端不能加载模组: 用 --type plugin 装插件, 或换成 Fabric/NeoForge/Forge 服务端", "red"))
        return 1
    target = mod_target_dir(server_dir, ptype)

    if action == "list":
        names = []
        try:
            names = sorted(x for x in os.listdir(target) if x.lower().endswith(".jar"))
        except OSError:
            pass
        print(c("已装 %d 个%s  (%s)" % (len(names), "插件" if ptype == "plugin" else "模组", target), "cyan"))
        for n in names:
            print("  - " + n)
        return 0

    if action == "search":
        import urllib.parse
        q = rest[0] if rest else ""
        facets = [["project_type:" + ptype]]
        if mc:
            facets.append(["versions:" + mc])
        if ptype == "mod" and loader:
            facets.append(["categories:" + loader])
        qs = "query=%s&limit=12&facets=%s" % (
            urllib.parse.quote(q), urllib.parse.quote(json.dumps(facets)))
        data = mod_json("/v2/search?" + qs)
        hits = data.get("hits", []) if isinstance(data, dict) else []
        print(c("MC %s · %s · %s  (共 %s 个结果)" % (mc or "?", stype, "插件" if ptype == "plugin" else "模组", len(hits)), "cyan"))
        for h in hits:
            print("  %-28s %8s 下载  %s" % (h.get("slug", "")[:28], h.get("downloads", 0), h.get("title", "")))
        print(c("安装: 1b1t mods \"" + server_dir + "\" install <slug>" + (" --type plugin" if ptype == "plugin" else ""), "dim"))
        return 0

    if action == "install":
        if not rest:
            print(c("缺少项目名 (slug 或 project id)", "red"))
            return 1
        project = rest[0]
        if version_id:
            v = mod_json("/v2/version/" + version_id)
            files = v.get("files") or []
            f = next((x for x in files if x.get("primary")), files[0] if files else None)
            if not f:
                print(c("该版本没有可用文件", "red"))
                return 1
            pick = {"id": v.get("id", ""), "num": v.get("version_number", ""), "file": f, "deps": []}
        else:
            vers = mod_versions(project, mc, loader, ptype)
            if not vers:
                print(c("没有适配 MC %s 的版本" % (mc or "?"), "red"))
                return 1
            pick = vers[0]
        dest = os.path.join(target, pick["file"]["filename"])
        print(c("下载 %s (%s) -> %s" % (pick["file"]["filename"], pick["num"], target), "cyan"))
        err = mod_download(pick["file"]["url"], dest)
        if err:
            print(c("下载失败: " + err, "red"))
            return 1
        print(c("  ✓ 已安装 " + pick["file"]["filename"], "green"))
        for dep_id in pick["deps"][:5]:
            try:
                dv = mod_json("/v2/version/" + dep_id)
                dfs = dv.get("files") or []
                df = next((x for x in dfs if x.get("primary")), dfs[0] if dfs else None)
                if not df or not df.get("url"):
                    continue
                ddest = os.path.join(target, df["filename"])
                if os.path.exists(ddest):
                    continue
                if not mod_download(df["url"], ddest):
                    print(c("  ✓ 依赖 " + df["filename"], "green"))
            except Exception:  # noqa: BLE001
                pass
        print(c("重启服务器后生效", "dim"))
        return 0

    if action == "remove":
        if not rest:
            print(c("缺少文件名", "red"))
            return 1
        name = rest[0]
        if "/" in name or "\\" in name or ".." in name:
            print(c("文件名非法", "red"))
            return 1
        p = os.path.join(target, name)
        if not os.path.exists(p):
            print(c("文件不存在: " + name, "red"))
            return 1
        os.remove(p)
        print(c("已删除 " + name, "green"))
        return 0

    print(c("未知操作: " + action, "red"))
    return 1


def do_doctor(server_dir):
    """手动排查"""
    cfg = load_cfg(server_dir)
    print(f"服务器目录: {c(server_dir, 'cyan')}")
    old = read_pid(server_dir)
    if old and is_running(old["pid"]):
        print(c(f"服务器正在运行 (PID {old['pid']})", "green"))
    issues = diagnose(server_dir, cfg)
    if issues == 0:
        print(c("未发现问题", "green"))
    else:
        print(c(f"发现 {issues} 个问题, 按上方建议修复", "red"))
    return issues


def do_console(server_dir, line):
    if not send_console(server_dir, line):
        sys.exit(c("[错误] 无法连接控制台(服务器未运行?)", "red"))
    print(c(f"已发送: {line}", "green"))
    return 0


def do_agent(args):
    """CLI 版 Agent 接口: 无 GUI 环境下给 AI 控制"""
    port = AGENT_DEFAULT_PORT
    token = agent_token()
    i = 0
    while i < len(args):
        if args[i] == "--port" and i + 1 < len(args):
            port = int(args[i + 1]); i += 2
        elif args[i] == "--token" and i + 1 < len(args):
            token = args[i + 1]; i += 2
        else:
            i += 1

    def api(op, *a):
        if op == "list":
            return agent_list_servers()
        if op == "status":
            return agent_status(a[0])
        if op == "logs":
            return []
        if op == "action":
            name, act = a
            d = agent_find(name)
            if not d:
                return {"error": "server not found"}
            if act == "start":
                do_start(d)
            elif act == "stop":
                do_stop(d)
            elif act == "restart":
                do_stop(d)
                do_start(d)
            else:
                return {"error": "unknown action"}
            return {"ok": True}
        if op == "command":
            name, cmd = a
            d = agent_find(name)
            if not d:
                return {"error": "server not found"}
            return {"ok": send_console(d, cmd)}
        return {"error": "unknown op"}

    AgentServer(port, token, api, print).run()
    return 0


# ==================== Agent API (v2.0.2) ====================
# 本地 HTTP 接口: AI agent 通过它控制 1b1t (列服务器/启停/发指令/日志),
# 每个操作经 log 回调输出, GUI 中全部可视化
AGENT_DEFAULT_PORT = 18999


def agent_find(name):
    """按目录名找服务器"""
    for d in find_servers():
        if os.path.basename(d) == name:
            return d
    return None


def agent_list_servers():
    out = []
    for d in find_servers():
        cfg = load_cfg(d) or {}
        old = read_pid(d)
        out.append({
            "name": os.path.basename(d), "dir": d,
            "version": cfg.get("version", ""),
            "server_type": cfg.get("server_type", "vanilla"),
            "port": cfg.get("port", ""),
            "running": bool(old and is_running(old["pid"])),
            "pid": (old or {}).get("pid")})
    return out


def agent_status(name):
    d = agent_find(name)
    if not d:
        return {"error": "server not found"}
    old = read_pid(d)
    return {"name": name, "running": bool(old and is_running(old["pid"])),
            "pid": (old or {}).get("pid"),
            "console_port": (old or {}).get("console_port")}


class AgentServer(threading.Thread):
    """Agent HTTP 服务 (daemon 线程); api 回调: list/status/action/command/logs"""

    def __init__(self, port, token, api, log=print):
        threading.Thread.__init__(self, daemon=True)
        self.port, self.token, self.api, self.log = port, token, api, log

    def run(self):
        import http.server as _hs
        outer = self

        class H(_hs.BaseHTTPRequestHandler):
            def log_message(self, *a):
                pass

            def _auth(self):
                tok = self.headers.get("Authorization", "")
                tok = tok.replace("Bearer", "").strip()
                q = urllib.parse.parse_qs(
                    urllib.parse.urlparse(self.path).query)
                return tok == outer.token or q.get("token", [""])[0] == outer.token

            def _json(self, obj, code=200):
                b = json.dumps(obj, ensure_ascii=False).encode()
                self.send_response(code)
                self.send_header("Content-Type", "application/json")
                self.send_header("Content-Length", str(len(b)))
                self.end_headers()
                self.wfile.write(b)

            def do_GET(self):
                p = urllib.parse.urlparse(self.path).path.strip("/").split("/")
                if not self._auth():
                    outer.log("[Agent] 未授权请求被拒绝 (token 错误)")
                    return self._json({"error": "unauthorized"}, 401)
                if p[:2] == ["api", "servers"] and len(p) == 2:
                    outer.log("[Agent] 列出服务器")
                    return self._json({"servers": outer.api("list")})
                if p[:2] == ["api", "servers"] and len(p) == 4 \
                        and p[3] == "status":
                    outer.log(f"[Agent] 查询状态: {p[2]}")
                    return self._json(outer.api("status", p[2]))
                if p[:2] == ["api", "logs"]:
                    q = urllib.parse.parse_qs(
                        urllib.parse.urlparse(self.path).query)
                    n = int(q.get("n", ["50"])[0])
                    outer.log(f"[Agent] 读取日志 {n} 行")
                    return self._json({"lines": outer.api("logs", n)})
                return self._json({"error": "not found"}, 404)

            def do_POST(self):
                p = urllib.parse.urlparse(self.path).path.strip("/").split("/")
                if not self._auth():
                    outer.log("[Agent] 未授权请求被拒绝 (token 错误)")
                    return self._json({"error": "unauthorized"}, 401)
                n = int(self.headers.get("Content-Length", 0) or 0)
                try:
                    body = json.loads(self.rfile.read(n) or b"{}")
                except ValueError:
                    body = {}
                if p[:2] == ["api", "servers"] and len(p) == 4 \
                        and p[3] in ("start", "stop", "restart"):
                    outer.log(f"[Agent] {p[3]} 服务器: {p[2]}")
                    return self._json(outer.api("action", p[2], p[3]))
                if p[:2] == ["api", "servers"] and len(p) == 4 \
                        and p[3] == "command":
                    outer.log(f"[Agent] 发送指令到 {p[2]}: {body.get('cmd', '')}")
                    return self._json(outer.api("command", p[2],
                                                body.get("cmd", "")))
                return self._json({"error": "not found"}, 404)

        import http.server as _hs
        try:
            srv = _hs.HTTPServer(("127.0.0.1", self.port), H)
        except OSError as e:
            self.log(f"[Agent] 接口启动失败(端口被占?): {e}")
            return
        self.log(f"[Agent] 接口已启动 http://127.0.0.1:{self.port} "
                 f"(token: {self.token})")
        srv.serve_forever()


def agent_token():
    """读取/生成 agent token (settings 里持久化)"""
    st = load_settings()
    tok = st.get("agent_token")
    if not tok:
        import secrets
        tok = secrets.token_hex(8)
        st["agent_token"] = tok
        save_settings(st)
    return tok




# ==================== MCP 服务器 (v2.0.3) ====================
# 标准 MCP (Model Context Protocol) stdio 服务器:
# 客户机上的 AI (Claude Code/Cursor/Claude Desktop) 加一行配置即可原生调用
MCP_TOOLS = [
    {"name": "run_doctor",
     "description": "运行服务器自检 (Java/端口/核心文件/EULA/磁盘/权限/内存/模组一致性/日志 九项)",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string"}}}},
    {"name": "list_mods",
     "description": "列出服务器已装的模组与插件",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string"}}}},
    {"name": "search_mods",
     "description": "在 Modrinth 搜索模组或插件 (按服务器 MC 版本/加载器过滤)",
     "inputSchema": {"type": "object", "required": ["name", "query"],
                     "properties": {"name": {"type": "string"},
                                    "query": {"type": "string"},
                                    "type": {"type": "string", "enum": ["mod", "plugin"]}}}},
    {"name": "install_mod",
     "description": "安装模组/插件到服务器 (自动装必需依赖)",
     "inputSchema": {"type": "object", "required": ["name", "project"],
                     "properties": {"name": {"type": "string"},
                                    "project": {"type": "string"},
                                    "type": {"type": "string", "enum": ["mod", "plugin"]}}}},
    {"name": "list_servers",
     "description": "列出本机所有 1b1t Minecraft 服务器及运行状态"},
    {"name": "server_status",
     "description": "查询单个服务器状态",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string",
                               "description": "服务器目录名"}}}},
    {"name": "start_server",
     "description": "启动服务器(优雅, 后台执行)",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string"}}}},
    {"name": "stop_server",
     "description": "优雅关服(保存世界)",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string"}}}},
    {"name": "restart_server",
     "description": "重启服务器",
     "inputSchema": {"type": "object", "required": ["name"], "properties":
                     {"name": {"type": "string"}}}},
    {"name": "send_command",
     "description": "向服务器控制台发送指令 (如 list/say/save-all)",
     "inputSchema": {"type": "object", "required": ["name", "cmd"],
                     "properties": {
                         "name": {"type": "string"},
                         "cmd": {"type": "string"}}}},
    {"name": "get_logs",
     "description": "读取服务器最近日志行 (GUI 运行时含 agent 操作记录)",
     "inputSchema": {"type": "object",
                     "properties": {"n": {"type": "integer",
                                          "default": 50}}}},
]




def _mcp_server_dir(name):
    d = agent_find(name)
    return d


def _mods_install(server_dir, project, ptype="mod", version_id=""):
    mc, loader, _ = mod_server_info(server_dir)
    if ptype == "mod" and not loader:
        return {"ok": False, "error": "原版服不能装模组, 用 type=plugin 或换服务端"}
    target = mod_target_dir(server_dir, ptype)
    if version_id:
        v = mod_json("/v2/version/" + version_id)
        files = v.get("files") or []
        f = next((x for x in files if x.get("primary")), files[0] if files else None)
        if not f:
            return {"ok": False, "error": "该版本没有可用文件"}
        pick = {"id": v.get("id", ""), "num": v.get("version_number", ""), "file": f, "deps": []}
    else:
        vers = mod_versions(project, mc, loader, ptype)
        if not vers:
            return {"ok": False, "error": "没有适配 MC %s 的版本" % (mc or "?")}
        pick = vers[0]
    dest = os.path.join(target, pick["file"]["filename"])
    err = mod_download(pick["file"]["url"], dest)
    if err:
        return {"ok": False, "error": err}
    deps = []
    for dep_id in pick["deps"][:5]:
        try:
            dv = mod_json("/v2/version/" + dep_id)
            dfs = dv.get("files") or []
            df = next((x for x in dfs if x.get("primary")), dfs[0] if dfs else None)
            if not df or not df.get("url"):
                continue
            ddest = os.path.join(target, df["filename"])
            if os.path.exists(ddest):
                continue
            if not mod_download(df["url"], ddest):
                deps.append(df["filename"])
        except Exception:  # noqa: BLE001
            pass
    return {"ok": True, "file": pick["file"]["filename"], "deps": deps}


def mcp_call(name, args):
    if name == "list_servers":
        return {"servers": agent_list_servers()}
    if name == "server_status":
        return agent_status(args["name"])
    if name in ("start_server", "stop_server", "restart_server"):
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        act = name.split("_")[0]
        if act == "start":
            do_start(d)
        elif act == "stop":
            do_stop(d)
        else:
            do_stop(d)
            do_start(d)
        return {"ok": True}
    if name == "send_command":
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        return {"ok": send_console(d, args["cmd"])}
    if name == "run_doctor":
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        return {"issues": diagnose(d, load_cfg(d))}
    if name == "list_mods":
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        out = []
        for sub in ("mods", "plugins"):
            p = os.path.join(d, sub)
            try:
                for x in sorted(os.listdir(p)):
                    if x.lower().endswith(".jar"):
                        out.append({"type": sub, "file": x,
                                    "size": os.path.getsize(os.path.join(p, x))})
            except OSError:
                pass
        return {"mods": out}
    if name == "search_mods":
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        ptype = args.get("type", "mod")
        mc, loader, _t = mod_server_info(d)
        import urllib.parse as _up
        facets = [["project_type:" + ptype]]
        if mc:
            facets.append(["versions:" + mc])
        if ptype == "mod" and loader:
            facets.append(["categories:" + loader])
        qs = "query=%s&limit=10&facets=%s" % (_up.quote(args.get("query", "")), _up.quote(json.dumps(facets)))
        data = mod_json("/v2/search?" + qs)
        hits = data.get("hits", []) if isinstance(data, dict) else []
        return {"hits": [{"slug": h.get("slug"), "title": h.get("title"),
                          "downloads": h.get("downloads")} for h in hits]}
    if name == "install_mod":
        d = agent_find(args["name"])
        if not d:
            return {"error": "server not found"}
        return _mods_install(d, args["project"], args.get("type", "mod"))
    if name == "get_logs":
        d = agent_find(args.get("name", ""))
        n = int(args.get("n", 50) or 50)
        if not d:
            return {"lines": [], "error": "server not found"}
        p = os.path.join(runtime_dir(d), "console.log")
        try:
            with open(p, errors="ignore") as f:
                lines = f.read().splitlines()
            return {"lines": lines[-n:]}
        except OSError:
            return {"lines": []}
    return {"error": "unknown tool"}


def do_mcp_install():
    """把 1b1t MCP 注册到本机 AI 工具 (Claude Code/Cursor/Claude Desktop)"""
    exe = shutil.which("1b1t") or os.path.abspath(sys.argv[0])
    server = {"command": exe, "args": ["mcp"]}
    home = os.path.expanduser("~")
    targets = [os.path.join(home, ".claude.json")]  # Claude Code
    if IS_WIN:
        targets.append(os.path.join(os.environ.get("APPDATA", ""),
                                    "Claude", "claude_desktop_config.json"))
    else:
        targets.append(os.path.join(home, ".config", "Claude",
                                    "claude_desktop_config.json"))
    targets.append(os.path.join(home, ".cursor", "mcp.json"))
    installed = []
    for p in targets:
        if not p or not os.path.dirname(p):
            continue
        try:
            cfg = {}
            if os.path.isfile(p):
                with open(p) as f:
                    try:
                        cfg = json.load(f)
                    except ValueError:
                        cfg = {}
            cfg.setdefault("mcpServers", {})["1b1t"] = server
            os.makedirs(os.path.dirname(p), exist_ok=True)
            with open(p, "w") as f:
                json.dump(cfg, f, ensure_ascii=False, indent=2)
            installed.append(p)
        except OSError as e:
            print(c(f"  写入失败 {p}: {e}", "yellow"))
    for p in installed:
        print(c(f"  已注册: {p}", "green"))
    print(c("  AI 工具重启后即可使用 1b1t 工具 (list_servers 等)", "cyan"))
    return 0


def do_mcp():
    """stdio MCP 服务: 读 JSON-RPC 行, 响应 tools/list 与 tools/call"""
    import io
    out = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8",
                           line_buffering=True)
    for line in sys.stdin:
        line = line.strip()
        if not line:
            continue
        try:
            req = json.loads(line)
        except ValueError:
            continue
        rid = req.get("id")
        method = req.get("method")
        if method == "initialize":
            out.write(json.dumps({"jsonrpc": "2.0", "id": rid, "result": {
                "protocolVersion": "2024-11-05",
                "capabilities": {"tools": {}},
                "serverInfo": {"name": "1b1t", "version": APP_VERSION}}},
                ensure_ascii=False) + "\n")
        elif method == "notifications/initialized":
            pass
        elif method == "tools/list":
            out.write(json.dumps({"jsonrpc": "2.0", "id": rid,
                                  "result": {"tools": MCP_TOOLS}},
                                 ensure_ascii=False) + "\n")
        elif method == "tools/call":
            p = req.get("params", {})
            name = p.get("name", "")
            args = p.get("arguments", {}) or {}
            res = mcp_call(name, args)
            out.write(json.dumps({"jsonrpc": "2.0", "id": rid, "result": {
                "content": [{"type": "text",
                             "text": json.dumps(res, ensure_ascii=False)}]}},
                ensure_ascii=False) + "\n")
        else:
            out.write(json.dumps({"jsonrpc": "2.0", "id": rid,
                                  "error": {"code": -32601,
                                            "message": "unknown method"}},
                                 ensure_ascii=False) + "\n")
    return 0


if __name__ == "__main__":
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        print("\n已取消")
        sys.exit(130)
    except EOFError:
        print("\n已取消")
        sys.exit(130)




