orzmc-app 2.0.0__tar.gz

orzmc_app-2.0.0/.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.DS_Store
+.vscode/
+
+# uv
+.venv/
+
+# pytest
+.pytest_cache/
+
+# PyInstaller build dir (scripts/build.py)
+.pybuild/
+
+# runtime artifacts (managed under game root, not repo)
+java/

orzmc_app-2.0.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.5
+Name: orzmc-app
+Version: 2.0.0
+Summary: OrzMC: CLI application for Minecraft client/server bootstrap
+Author: OrzMC
+License: MIT
+Keywords: cli,java,launcher,minecraft,server
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Requires-Dist: orzmc>=2.0.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# orzmc-app
+
+OrzMC application: typer CLI built on the `orzmc` library.
+
+- `orzmc` (no args) prints help
+- `orzmc client` / `orzmc server` bootstrap game instances
+- `orzmc remove` / `orzmc list` manage installed versions
+
+See the [project README](../README.md) for full documentation.

orzmc_app-2.0.0/README.md

@@ -0,0 +1,9 @@
+# orzmc-app
+
+OrzMC application: typer CLI built on the `orzmc` library.
+
+- `orzmc` (no args) prints help
+- `orzmc client` / `orzmc server` bootstrap game instances
+- `orzmc remove` / `orzmc list` manage installed versions
+
+See the [project README](../README.md) for full documentation.

orzmc_app-2.0.0/orzmc_app/__init__.py

@@ -0,0 +1,10 @@
+"""OrzMC application: typer CLI, built on the orzmc library.
+
+The app layer only calls the library's public API (``orzmc/__init__.py``).
+"""
+
+from __future__ import annotations
+
+__version__ = "2.0.0"
+
+__all__ = ["__version__"]

orzmc_app-2.0.0/orzmc_app/cli/__init__.py

@@ -0,0 +1,32 @@
+"""Typer CLI entry point for orzmc-app.
+
+The console script ``orzmc`` maps to :func:`main`.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+
+from orzmc_app.cli.app import app
+
+
+def main() -> int:
+    try:
+        app()
+        return 0
+    except typer.Exit as exc:
+        return exc.exit_code or 0
+    except KeyboardInterrupt:
+        print("已取消", file=sys.stderr)
+        return 130
+    except Exception:  # pragma: no cover - unexpected bug, keep a traceback
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

orzmc_app-2.0.0/orzmc_app/cli/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from orzmc_app.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

orzmc_app-2.0.0/orzmc_app/cli/app.py

@@ -0,0 +1,256 @@
+"""Typer CLI: subcommands that call only the orzmc library public API.
+
+``orzmc`` with no subcommand prints help; every subcommand works as a plain
+command line, with lightweight rich prompts when run interactively (version
+defaults to Mojang latest when neither ``-v`` nor a TTY prompt is available).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Annotated, NoReturn
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+from rich.table import Table
+
+from orzmc import (
+    GameType,
+    RuntimeOptions,
+    backup_world,
+    deploy_server,
+    launch_client,
+    list_versions,
+    remove_version,
+)
+from orzmc import (
+    __version__ as LIB_VERSION,
+)
+from orzmc.infra.log import RichReporter
+from orzmc.infra.progress import RichProgress
+from orzmc_app import __version__ as APP_VERSION
+from orzmc_app.cli.options import JvmOpts, MaxMem, MinMem, RootDir, Username, Verbose, Version, Yes
+from orzmc_app.cli.prompts import confirm_eula, confirm_java, is_interactive, resolve_version
+
+_console = Console(highlight=False)
+app = typer.Typer(add_completion=False, no_args_is_help=False, invoke_without_command=True)
+
+_MEM_RE = re.compile(r"^\d+[kKmMgGtT]$")
+
+
+def _fail(message: str) -> NoReturn:
+    _console.print(f"[error]错误:[/error] {message}")
+    raise typer.Exit(1)
+
+
+def _check_mem(name: str, value: str) -> None:
+    if not _MEM_RE.match(value):
+        _fail(f"无效内存: {name}={value} (例如 512M、2G)")
+
+
+def _parse_type(value: str, *, client: bool) -> GameType:
+    try:
+        game_type = GameType.parse(value)
+    except ValueError:
+        _fail(f"未知类型: {value}")
+    ok = game_type.is_client_capable if client else game_type.is_server_capable
+    if not ok:
+        _fail(f"类型 {value} 不能用于{'客户端' if client else '服务端'}")
+    return game_type
+
+
+@app.callback(invoke_without_command=True)
+def root(ctx: typer.Context, verbose: Verbose = False) -> None:
+    """OrzMC — Minecraft 客户端启动 / 服务端部署工具。
+
+    不带子命令时打印帮助;直接使用子命令(如 ``orzmc client -v 1.20.4``)。
+    """
+    ctx.obj = {"verbose": verbose}
+    if ctx.invoked_subcommand is None:
+        _console.print(ctx.get_help(), markup=False)
+        raise typer.Exit(0)
+
+
+@app.command()
+def client(
+    ctx: typer.Context,
+    version: Version = None,
+    username: Username = "guest",
+    game_type: Annotated[str, typer.Option("--type", "-t", help="类型: vanilla|fabric|forge")] = "vanilla",
+    min_mem: MinMem = "512M",
+    max_mem: MaxMem = "2G",
+    extract_music: Annotated[bool, typer.Option("--extract-music", help="提取客户端音乐后退出")] = False,
+    jvm_opts: JvmOpts = None,
+    root_dir: RootDir = None,
+) -> None:
+    """运行 Minecraft 客户端(缺失文件自动下载即安装)。"""
+    game_type_obj = _parse_type(game_type, client=True)
+    _check_mem("min", min_mem)
+    _check_mem("max", max_mem)
+    resolved = resolve_version(version, root_dir)
+    options = RuntimeOptions(
+        is_client=True,
+        version=resolved,
+        username=username,
+        game_type=game_type_obj.value,
+        min_mem=min_mem,
+        max_mem=max_mem,
+        extract_music=extract_music,
+        jvm_opts=jvm_opts,
+        root_dir=root_dir,
+    )
+    reporter = RichReporter(verbose=bool(ctx.obj.get("verbose")))
+    sink = RichProgress()
+    try:
+        launch_client(options, reporter=reporter, sink=sink, confirm_java=confirm_java if is_interactive() else None)
+    except Exception as exc:
+        _fail(str(exc))
+    finally:
+        sink.close()
+
+
+@app.command()
+def server(
+    ctx: typer.Context,
+    version: Version = None,
+    game_type: Annotated[str, typer.Option("--type", "-t", help="类型: vanilla|paper|fabric|forge")] = "vanilla",
+    min_mem: MinMem = "512M",
+    max_mem: MaxMem = "2G",
+    force_upgrade: Annotated[bool, typer.Option("--force-upgrade", help="服务端启动加 --forceUpgrade")] = False,
+    symlink: Annotated[bool, typer.Option("--symlink", help="软链接到备份世界")] = False,
+    force_download: Annotated[bool, typer.Option("--force-download", help="强制重新下载核心")] = False,
+    yes: Yes = False,
+    jvm_opts: JvmOpts = None,
+    server_args: Annotated[str | None, typer.Option("--server-args", help="服务端程序参数(如 '--port 25565')")] = None,
+    nogui: Annotated[
+        bool, typer.Option("--nogui", help="无窗口模式启动(不弹服务端 GUI);终端输入 stop 或 Ctrl-C 关闭")
+    ] = False,
+    root_dir: RootDir = None,
+) -> None:
+    """部署并运行 Minecraft 服务端(缺失文件自动下载即安装)。"""
+    game_type_obj = _parse_type(game_type, client=False)
+    _check_mem("min", min_mem)
+    _check_mem("max", max_mem)
+    resolved = resolve_version(version, root_dir)
+    options = RuntimeOptions(
+        is_client=False,
+        version=resolved,
+        game_type=game_type_obj.value,
+        min_mem=min_mem,
+        max_mem=max_mem,
+        force_upgrade=force_upgrade,
+        symlink=symlink,
+        force_download=force_download,
+        yes=yes,
+        jvm_opts=jvm_opts,
+        server_args=server_args,
+        nogui=nogui,
+        root_dir=root_dir,
+    )
+    reporter = RichReporter(verbose=bool(ctx.obj.get("verbose")))
+    sink = RichProgress()
+    try:
+        deploy_server(
+            options,
+            reporter=reporter,
+            sink=sink,
+            confirm_java=confirm_java if is_interactive() else None,
+            confirm_eula=confirm_eula if is_interactive() else None,
+        )
+    except Exception as exc:
+        _fail(str(exc))
+    finally:
+        sink.close()
+
+
+@app.command()
+def remove(
+    version: Annotated[str, typer.Option("--version", "-v", help="要移除的 Minecraft 版本")],
+    server: Annotated[bool, typer.Option("--server", help="移除服务端(默认移除客户端)")] = False,
+    game_type: Annotated[str | None, typer.Option("--type", "-t", help="服务端类型(移除服务端时必填)")] = None,
+    yes: Yes = False,
+    root_dir: RootDir = None,
+) -> None:
+    """移除已安装的版本(客户端或某类型的服务端)。"""
+    if server and not game_type:
+        _fail("移除服务端需要指定类型 (-t)")
+    try:
+        removed = remove_version(
+            version,
+            is_client=not server,
+            game_type=game_type,
+            root_dir=root_dir,
+            yes=yes,
+            # 非交互时无法确认,视为取消(不删除);交互时弹 rich 确认。
+            confirm=(
+                (lambda desc: bool(Confirm.ask(f"{desc}\n确定移除吗?", default=False)))
+                if is_interactive()
+                else (lambda desc: False)
+            ),
+        )
+    except Exception as exc:
+        _fail(str(exc))
+    if removed:
+        _console.print(f"[success]已移除 {version}[/success]")
+    else:
+        _console.print("[yellow]已取消移除[/yellow]")
+
+
+@app.command()
+def list(root_dir: RootDir = None) -> None:
+    """列出已安装的版本(客户端 / 服务端类型)。"""
+    items = list_versions(root_dir=root_dir)
+    if not items:
+        _console.print("[muted]尚未安装任何版本[/muted]")
+        return
+    table = Table(title="已安装版本", header_style="bold")
+    table.add_column("版本")
+    table.add_column("客户端", justify="center")
+    table.add_column("服务端")
+    for item in items:
+        table.add_row(item.version, "✓" if item.has_client else "", ", ".join(item.server_types))
+    _console.print(table)
+
+
+@app.command()
+def backup(
+    version: Annotated[str | None, typer.Option("--version", "-v", help="要备份的版本(缺省自动推断)")] = None,
+    game_type: Annotated[str, typer.Option("--type", "-t", help="服务端类型")] = "vanilla",
+    root_dir: RootDir = None,
+) -> None:
+    """备份服务端世界到 ``backup/worlds/``。"""
+    resolved = _infer_backup_version(version, root_dir)
+    try:
+        dest = backup_world(resolved, game_type=game_type, root_dir=root_dir)
+    except Exception as exc:
+        _fail(str(exc))
+    _console.print(f"[success]备份完成:[/success] {dest}")
+
+
+@app.command()
+def version() -> None:
+    """打印工具版本。"""
+    _console.print(f"orzmc {APP_VERSION} (库 {LIB_VERSION})")
+
+
+def _infer_backup_version(version: str | None, root_dir: str | None) -> str:
+    if version:
+        return version
+    installed = list_versions(root_dir=root_dir)
+    candidates = [item.version for item in installed if item.server_types]
+    if not candidates:
+        _fail("没有已安装的服务端,请用 -v 指定版本")
+    if len(candidates) == 1:
+        return candidates[0]
+    if is_interactive():
+        _console.print("[info]可备份的服务端版本:[/info]")
+        for i, item in enumerate(candidates, 1):
+            _console.print(f"  [muted]{i:>2}.[/muted] {item}")
+        from rich.prompt import Prompt
+
+        picked = Prompt.ask("选择版本", default="")
+        if picked.isdigit() and 1 <= int(picked) <= len(candidates):
+            return candidates[int(picked) - 1]
+        return picked or candidates[0]
+    _fail("有多个服务端版本,请用 -v 指定")

orzmc_app-2.0.0/orzmc_app/cli/options.py

@@ -0,0 +1,29 @@
+"""Shared typer option declarations reused across CLI subcommands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+# ── generic ──────────────────────────────────────────────────────────────────
+
+
+def _root_dir_help() -> str:
+    return "游戏根目录(默认 ~/minecraft)"
+
+
+def _version_help() -> str:
+    return "Minecraft 版本(缺省:TTY 交互选择,可搜索/切换正式版·测试版;非 TTY 用 Mojang 最新 release)"
+
+
+# ── option type aliases ──────────────────────────────────────────────────────
+
+RootDir = Annotated[str | None, typer.Option("--root-dir", help=_root_dir_help())]
+Version = Annotated[str | None, typer.Option("--version", "-v", help=_version_help())]
+Username = Annotated[str, typer.Option("--username", "-u", help="游戏用户名(默认 guest)")]
+MinMem = Annotated[str, typer.Option("--minmem", "-m", help="最小内存(如 512M)")]
+MaxMem = Annotated[str, typer.Option("--maxmem", "-x", help="最大内存(如 2G)")]
+JvmOpts = Annotated[str | None, typer.Option("--jvm-opts", help="附加 JVM 旗标(空格分隔,如 '-XX:+UseZGC')")]
+Verbose = Annotated[bool, typer.Option("--verbose", help="输出调试日志")]
+Yes = Annotated[bool, typer.Option("--yes", help="跳过交互确认(自动接受 EULA 等)")]

orzmc_app-2.0.0/orzmc_app/cli/picker.py

@@ -0,0 +1,493 @@
+"""Keyboard-navigable full-screen picker over the Mojang version catalog.
+
+The pure selection state machine (:class:`PickerState`), the responsive layout
+(:func:`_layout`) and the fragment renderers (``*_fragments``) have no I/O and
+are unit tested; :func:`run_picker` wires them to a prompt_toolkit full-screen
+app whose ``input``/``output`` are injectable so tests can drive it with a pipe
+and a dummy output.
+
+The layout adapts to the terminal: a status title, the item list, an up/down
+``还有 N 个`` scroll indicator pair, a search box and a multi-line help block
+are stacked, and slots that have no content collapse (``dont_extend_height``).
+The viewport row count and the number of help lines are recomputed on every
+render/keypress, so a mid-session resize is followed automatically
+(prompt_toolkit re-renders on SIGWINCH).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+from prompt_toolkit.application import Application, get_app
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.data_structures import Size
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.formatted_text import StyleAndTextTuples
+from prompt_toolkit.input.base import Input
+from prompt_toolkit.key_binding import KeyBindings, KeyBindingsBase, merge_key_bindings
+from prompt_toolkit.key_binding.defaults import load_key_bindings
+from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+from prompt_toolkit.output.base import Output
+from prompt_toolkit.styles import Style
+from prompt_toolkit.utils import get_cwidth
+
+from orzmc import VersionEntry
+
+_DEFAULT_VIEW_ROWS = 10
+_FALLBACK_TERM_ROWS = 24
+_FALLBACK_TERM_COLUMNS = 80
+
+_FIXED_ROWS = 4  # title + up indicator + down indicator + search box
+_MIN_VIEW_ROWS = 3  # the list keeps at least this many rows when help is shown
+
+# Bottom help. Each line is short enough for narrow terminals, ordered by
+# non-decreasing display width (so a leading slice always fits the column
+# budget), and explains what the keys DO rather than just listing them.
+_HELP_LINES = (
+    "↑↓ 选择版本 · ←→ 前后翻页",  # 25
+    "输入过滤 · t 切正式版/测试版 · x 清空",  # 37
+    "Enter 选中 · Esc 用最新 · Ctrl-C 取消",  # 37
+)
+_MAX_HELP_LINES = len(_HELP_LINES)
+
+_STYLES = {
+    "picker.title": "bold fg:ansicyan",
+    "picker.selected": "reverse bold",
+    "picker.match": "fg:ansiyellow bold",
+    "picker.muted": "fg:ansibrightblack",
+    "picker.hint": "fg:ansibrightblack",
+    "picker.scroll": "fg:ansibrightblack",
+    "picker.empty": "fg:ansiyellow",
+}
+
+
+def _channel_label(channel: str) -> str:
+    return "正式版" if channel == "release" else "测试版"
+
+
+@dataclass(frozen=True)
+class LayoutSpec:
+    """Responsive layout derived from the terminal size."""
+
+    view_rows: int  # item rows the list region can hold
+    help_lines: int  # how many of the bottom help lines fit
+
+
+def _layout(term_rows: int, term_columns: int) -> LayoutSpec:
+    """Pick a layout for the given terminal size.
+
+    Help lines (see :data:`_HELP_LINES`) are shown from the top until either
+    the column or the row budget runs out. Lines are ordered by non-decreasing
+    display width, so the leading slice ``_HELP_LINES[:help_lines]`` always
+    fits the column budget. The row budget stops adding help once the list
+    viewport would drop below :data:`_MIN_VIEW_ROWS`. The title, the two scroll
+    indicator slots and the search box are statically reserved
+    (:data:`_FIXED_ROWS`), so the scroll math never shifts as indicators
+    appear/disappear.
+    """
+    col_help = sum(1 for line in _HELP_LINES if get_cwidth(line) <= term_columns)
+    row_help = 0
+    for n in range(_MAX_HELP_LINES, 0, -1):
+        if term_rows - _FIXED_ROWS - n >= _MIN_VIEW_ROWS:
+            row_help = n
+            break
+    help_lines = min(col_help, row_help)
+    view_rows = max(1, min(_DEFAULT_VIEW_ROWS, term_rows - _FIXED_ROWS - help_lines))
+    return LayoutSpec(view_rows=view_rows, help_lines=help_lines)
+
+
+def _fit(text: str, width: int) -> str:
+    """Truncate ``text`` to display ``width`` columns, appending ``…`` when cut."""
+    if get_cwidth(text) <= width:
+        return text
+    used = 0
+    kept: list[str] = []
+    for ch in text:
+        w = max(get_cwidth(ch), 1)
+        if used + w > width - 1:  # reserve one column for the ellipsis
+            break
+        kept.append(ch)
+        used += w
+    return "".join(kept) + "…"
+
+
+@dataclass
+class PickerState:
+    """Pure selection state for the version picker (no I/O, unit-testable)."""
+
+    catalog: tuple[VersionEntry, ...]
+    channel: str = "release"
+    query: str = ""
+    index: int = 0  # absolute index of the highlighted item
+    start: int = 0  # index of the first visible row (scroll window)
+    rows: int = _DEFAULT_VIEW_ROWS
+
+    @property
+    def items(self) -> list[VersionEntry]:
+        """Filtered list: the current channel, narrowed by an active query.
+
+        Search is scoped to the list the user is currently looking at: a query
+        never reaches across channels, so switch channels (``t``) first to find
+        snapshot ids.
+        """
+        channel_items = [e for e in self.catalog if e.channel == self.channel]
+        if not self.query:
+            return channel_items
+        q = self.query.lower()
+        return [e for e in channel_items if q in e.id.lower()]
+
+    @property
+    def selected(self) -> str | None:
+        """Id of the highlighted item, or ``None`` for an empty list."""
+        items = self.items
+        return items[self.index].id if items else None
+
+    def move(self, delta: int) -> None:
+        """Move the highlight by ``delta``, clamped, keeping the cursor on screen."""
+        items = self.items
+        if not items:
+            self.index = 0
+            self.start = 0
+            return
+        self.index = min(max(self.index + delta, 0), len(items) - 1)
+        self._ensure_cursor_visible()
+
+    def jump(self, index: int) -> None:
+        """Jump to an absolute item index, clamped, keeping the cursor on screen."""
+        items = self.items
+        if not items:
+            self.index = 0
+            self.start = 0
+            return
+        self.index = min(max(index, 0), len(items) - 1)
+        self._ensure_cursor_visible()
+
+    def toggle(self) -> None:
+        """Switch release/snapshot, clearing the query and resetting the cursor."""
+        self.channel = "snapshot" if self.channel == "release" else "release"
+        self.query = ""
+        self.index = 0
+        self.start = 0
+
+    def set_query(self, query: str) -> None:
+        """Update the filter; reset the cursor so the first hit is highlighted."""
+        self.query = query
+        self.index = 0
+        self.start = 0
+
+    def clear_query(self) -> None:
+        """Drop the filter (keeps the channel)."""
+        self.set_query("")
+
+    def set_rows(self, rows: int) -> None:
+        """Resize the viewport, clamping cursor and scroll window to fit."""
+        self.rows = max(1, rows)
+        items = self.items
+        if not items:
+            self.index = 0
+            self.start = 0
+            return
+        self.index = min(self.index, len(items) - 1)
+        self._ensure_cursor_visible()
+
+    def visible_items(self) -> list[VersionEntry]:
+        """The slice of items currently on screen (the scroll window)."""
+        return self.items[self.start : self.start + self.rows]
+
+    def _ensure_cursor_visible(self) -> None:
+        if self.index < self.start:
+            self.start = self.index
+        elif self.index >= self.start + self.rows:
+            self.start = self.index - self.rows + 1
+
+
+def title_fragments(state: PickerState, columns: int) -> StyleAndTextTuples:
+    """One-line status title: channel/count, or the active in-channel search."""
+    if state.query:
+        title = f"搜索 “{state.query}” · {_channel_label(state.channel)} · {len(state.items)} 个"
+    else:
+        title = f"{_channel_label(state.channel)} · {len(state.items)} 个"
+    return [("class:picker.title", _fit(title, columns))]
+
+
+def list_fragments(state: PickerState, columns: int) -> StyleAndTextTuples:
+    """Item rows only (the up/down scroll indicators live in their own windows)."""
+    items = state.items
+    if not items:
+        msg = "无匹配版本 — 按 x 清空过滤" if state.query else "无匹配版本"
+        return [("class:picker.empty", msg)]
+    fragments: StyleAndTextTuples = []
+    for offset, entry in enumerate(state.visible_items()):
+        if fragments:
+            fragments.append(("", "\n"))
+        fragments.extend(_row_fragments(state, entry, state.start + offset == state.index, columns))
+    return fragments
+
+
+def up_fragments(state: PickerState) -> StyleAndTextTuples:
+    """'↑ 还有 N 个' shown when content is hidden above the viewport."""
+    if state.start == 0 or not state.items:
+        return []
+    return [("class:picker.scroll", f"↑ 还有 {state.start} 个")]
+
+
+def down_fragments(state: PickerState) -> StyleAndTextTuples:
+    """'↓ 还有 N 个' shown when content is hidden below the viewport."""
+    below = len(state.items) - (state.start + state.rows)
+    if below <= 0:
+        return []
+    return [("class:picker.scroll", f"↓ 还有 {below} 个")]
+
+
+def help_fragments(spec: LayoutSpec) -> StyleAndTextTuples:
+    """The keybinding help block: up to ``spec.help_lines`` rows, one per line."""
+    lines = _HELP_LINES[: spec.help_lines]
+    if not lines:
+        return []
+    fragments: StyleAndTextTuples = []
+    for i, line in enumerate(lines):
+        if i:
+            fragments.append(("", "\n"))
+        fragments.append(("class:picker.hint", line))
+    return fragments
+
+
+def _row_base(selected: bool) -> str:
+    return "picker.selected" if selected else "picker.item"
+
+
+def _highlight(text: str, query: str, base: str) -> StyleAndTextTuples:
+    """Split ``text`` and tag the case-insensitive matches with ``picker.match``."""
+    if not query:
+        return [(f"class:{base}", text)]
+    q = query.lower()
+    lower = text.lower()
+    fragments: StyleAndTextTuples = []
+    pos = 0
+    while True:
+        hit = lower.find(q, pos)
+        if hit < 0:
+            if pos < len(text):
+                fragments.append((f"class:{base}", text[pos:]))
+            break
+        if hit > pos:
+            fragments.append((f"class:{base}", text[pos:hit]))
+        fragments.append((f"class:{base} class:picker.match", text[hit : hit + len(q)]))
+        pos = hit + len(q)
+    return fragments
+
+
+def _row_fragments(state: PickerState, entry: VersionEntry, selected: bool, columns: int) -> StyleAndTextTuples:
+    """One list row: id (match-highlighted), muted type suffix; selection is
+    conveyed purely by the row's reverse-video style."""
+    base = _row_base(selected)
+    suffix = f" ({entry.type})" if not entry.is_release else ""
+    if get_cwidth(entry.id) + get_cwidth(suffix) > columns:
+        # Ultra-narrow fallback: drop the highlight, truncate a plain row.
+        return [(f"class:{base}", _fit(entry.id + suffix, columns))]
+    fragments = _highlight(entry.id, state.query, base)
+    if suffix:
+        fragments.append(("class:picker.muted", suffix))
+    return fragments
+
+
+def run_picker(
+    catalog: Sequence[VersionEntry],
+    *,
+    input: Input | None = None,
+    output: Output | None = None,
+) -> str | None:
+    """Full-screen keyboard picker over ``catalog``.
+
+    ↑↓ move the highlight one version at a time, ←→/PgUp/PgDn page through the
+    list, and Home/End jump to the ends (the default viewport shows the most
+    recent releases; scrolling reveals more, with ``↑/↓ 还有 N 个``
+    indicators). Like ``t``, the ←/→ page bindings only apply while the search
+    box is empty, so the arrows still move the text cursor inside a query.
+    Typing filters within the current channel's list and highlights the
+    matches, ``t`` toggles release/snapshot while the search box is empty,
+    ``x`` clears the filter, Enter returns the highlighted version, Escape
+    returns ``None`` so the caller falls back to the latest release, and
+    Ctrl-C raises ``KeyboardInterrupt``. The layout adapts to the terminal
+    size on every render and on resize.
+    """
+    initial = output.get_size() if output is not None else Size(_FALLBACK_TERM_ROWS, _FALLBACK_TERM_COLUMNS)
+    spec = _layout(initial.rows, initial.columns)
+    state = PickerState(catalog=tuple(catalog), rows=spec.view_rows)
+
+    def _sync_layout_with_columns() -> tuple[LayoutSpec, int]:
+        """Recompute the layout from the live terminal size and apply it."""
+        size = get_app().output.get_size()
+        spec = _layout(size.rows, size.columns)
+        state.set_rows(spec.view_rows)
+        return spec, size.columns
+
+    def _sync_layout() -> LayoutSpec:
+        return _sync_layout_with_columns()[0]
+
+    def _header_fragments() -> StyleAndTextTuples:
+        _, columns = _sync_layout_with_columns()
+        return title_fragments(state, columns)
+
+    def _up_fragments() -> StyleAndTextTuples:
+        _sync_layout()
+        return up_fragments(state)
+
+    def _list_fragments() -> StyleAndTextTuples:
+        _, columns = _sync_layout_with_columns()
+        return list_fragments(state, columns)
+
+    def _down_fragments() -> StyleAndTextTuples:
+        _sync_layout()
+        return down_fragments(state)
+
+    def _help_fragments() -> StyleAndTextTuples:
+        return help_fragments(_sync_layout())
+
+    search_buffer = Buffer(
+        multiline=False,
+        on_text_changed=lambda buf: state.set_query(buf.text),
+        accept_handler=lambda _buf: _accept(state),
+    )
+    bindings = _build_bindings(state, search_buffer, _sync_layout)
+
+    root = HSplit(
+        [
+            Window(
+                FormattedTextControl(_header_fragments),
+                height=1,
+                wrap_lines=False,
+                always_hide_cursor=True,
+            ),
+            Window(
+                FormattedTextControl(_up_fragments),
+                wrap_lines=False,
+                dont_extend_height=True,
+                always_hide_cursor=True,
+            ),
+            Window(
+                FormattedTextControl(_list_fragments),
+                wrap_lines=False,
+                dont_extend_height=True,
+                always_hide_cursor=True,
+            ),
+            Window(
+                FormattedTextControl(_down_fragments),
+                wrap_lines=False,
+                dont_extend_height=True,
+                always_hide_cursor=True,
+            ),
+            VSplit(
+                [
+                    Window(
+                        FormattedTextControl("搜索: "),
+                        height=1,
+                        dont_extend_width=True,
+                        always_hide_cursor=True,
+                    ),
+                    Window(BufferControl(search_buffer), height=1),
+                ]
+            ),
+            Window(
+                FormattedTextControl(_help_fragments),
+                wrap_lines=False,
+                dont_extend_height=True,
+                always_hide_cursor=True,
+            ),
+        ]
+    )
+
+    app: Application[str | None] = Application(
+        layout=Layout(root),
+        key_bindings=bindings,
+        style=Style.from_dict(_STYLES),
+        full_screen=True,
+        enable_page_navigation_bindings=False,
+        input=input,
+        output=output,
+    )
+    return app.run()
+
+
+def _accept(state: PickerState) -> bool:
+    """Buffer accept handler: return the highlighted version and quit."""
+    get_app().exit(result=state.selected)
+    return True
+
+
+def _build_bindings(
+    state: PickerState,
+    search_buffer: Buffer,
+    sync_layout: Callable[[], LayoutSpec],
+) -> KeyBindingsBase:
+    """Key bindings for the picker; merged with the defaults for buffer editing."""
+    kb = KeyBindings()
+
+    @kb.add("up", eager=True)
+    def _up(_event) -> None:
+        sync_layout()
+        state.move(-1)
+
+    @kb.add("down", eager=True)
+    def _down(_event) -> None:
+        sync_layout()
+        state.move(1)
+
+    @kb.add("pageup", eager=True)
+    def _page_up(_event) -> None:
+        sync_layout()
+        state.move(-state.rows)
+
+    @kb.add("pagedown", eager=True)
+    def _page_down(_event) -> None:
+        sync_layout()
+        state.move(state.rows)
+
+    # ←/→ page the list too, but only while the search box is empty: with a
+    # query the arrows stay in the search box for cursor movement (fixing
+    # typos), same gating as the `t` toggle below.
+    @kb.add("left", eager=True, filter=Condition(lambda: search_buffer.text == ""))
+    def _page_left(_event) -> None:
+        sync_layout()
+        state.move(-state.rows)
+
+    @kb.add("right", eager=True, filter=Condition(lambda: search_buffer.text == ""))
+    def _page_right(_event) -> None:
+        sync_layout()
+        state.move(state.rows)
+
+    @kb.add("home", eager=True)
+    def _home(_event) -> None:
+        sync_layout()
+        state.jump(0)
+
+    @kb.add("end", eager=True)
+    def _end(_event) -> None:
+        sync_layout()
+        state.jump(len(state.items) - 1)
+
+    @kb.add("escape", eager=True)
+    def _escape(event) -> None:
+        event.app.exit(result=None)
+
+    # Only toggle while the search box is empty, otherwise snapshot ids like
+    # "24w14potato" (which contain 't') could never be typed as a query.
+    @kb.add("t", eager=True, filter=Condition(lambda: search_buffer.text == ""))
+    def _toggle(_event) -> None:
+        search_buffer.text = ""
+        state.toggle()
+
+    # No Mojang version id contains 'x', so it is safe to reserve it for clearing.
+    @kb.add("x", eager=True)
+    def _clear(_event) -> None:
+        search_buffer.text = ""
+        state.clear_query()
+
+    # eager so it beats the merged defaults' no-op `c-c` (`_ignore`).
+    @kb.add("c-c", eager=True)
+    def _abort(_event) -> None:
+        raise KeyboardInterrupt
+
+    return merge_key_bindings([kb, load_key_bindings()])

orzmc_app-2.0.0/orzmc_app/cli/prompts.py

@@ -0,0 +1,57 @@
+"""Interactive TTY prompts for the CLI (only used when stdin is a TTY)."""
+
+from __future__ import annotations
+
+import sys
+
+from rich.console import Console
+from rich.prompt import Confirm
+
+from orzmc import remote_version_catalog
+
+from .picker import run_picker
+
+_console = Console(highlight=False)
+
+
+def is_interactive() -> bool:
+    """True when stdin+stdout are real terminals (safe for rich prompts)."""
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def resolve_version(version: str | None, root_dir: str | None) -> str | None:
+    """Resolve the Minecraft version for a command.
+
+    Explicit value → used as-is. TTY without value → interactive keyboard
+    picker over the full Mojang catalog (scroll, filter, release/snapshot
+    toggle, Escape → latest). Non-TTY without value → ``None``, letting the
+    library fall back to the latest release.
+    """
+    if version:
+        return version
+    if not is_interactive():
+        return None
+    try:
+        catalog = remote_version_catalog(root_dir=root_dir)
+    except Exception as exc:
+        _console.print(f"[yellow]无法获取版本列表({exc}),回车使用最新[/yellow]")
+        return None
+    if not catalog:
+        _console.print("[yellow]版本清单为空,回车使用最新[/yellow]")
+        return None
+    try:
+        return run_picker(catalog)
+    except Exception as exc:  # never crash the CLI on TUI trouble
+        _console.print(f"[yellow]版本选择器异常({exc}),回车使用最新[/yellow]")
+        return None
+
+
+def confirm_java(major: int, need_jdk: bool) -> bool:
+    """Ask before installing a sandboxed Java runtime into the app dir."""
+    kind = "JDK" if need_jdk else "JRE"
+    return Confirm.ask(f"需要安装 Java {major}({kind}) 到应用目录,继续?", default=True)
+
+
+def confirm_eula() -> bool:
+    """Ask the user to accept the Minecraft EULA before starting a server."""
+    return Confirm.ask("需要接受 Minecraft EULA 才能启动服务端,是否同意?", default=True)

orzmc_app-2.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "orzmc-app"
+version = "2.0.0"
+description = "OrzMC: CLI application for Minecraft client/server bootstrap"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "OrzMC" }]
+keywords = ["minecraft", "launcher", "server", "java", "cli"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Environment :: Console",
+    "Topic :: Games/Entertainment",
+]
+dependencies = [
+    "orzmc>=2.0.0",
+    "typer>=0.12",
+    "prompt_toolkit>=3.0",
+]
+
+[project.scripts]
+orzmc = "orzmc_app.cli:main"
+
+[tool.uv.sources]
+orzmc = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["orzmc_app"]
+
+[tool.hatch.build.targets.sdist]
+include = ["orzmc_app"]