packspliter-cli 1.0.0__tar.gz

packspliter_cli-1.0.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: packspliter-cli
+Version: 1.0.0
+Summary: Convert Modrinth/CurseForge modpacks to server files from the command line
+License-Expression: MIT
+Project-URL: Homepage, https://packspliter.qzz.io
+Project-URL: Repository, https://github.com/packspliter/cli
+Project-URL: Issues, https://github.com/packspliter/cli/issues
+Keywords: minecraft,modpack,server,modrinth,curseforge
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: platformdirs>=4.2.0
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
+Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: packaging>=24.0
+
+# packspliter-cli
+
+Command-line interface for PackSpliter — convert client-side Minecraft modpacks (.mrpack) into server-ready ZIP packages by automatically stripping client-only mods.
+
+## Installation
+
+```bash
+pip install packspliter-cli
+```
+
+## Quickstart
+
+Configure the API key and server URL:
+```bash
+packspliter configure
+```
+
+Convert a modpack:
+```bash
+packspliter convert ATM10.mrpack
+```
+
+For full documentation, visit [https://packspliter.qzz.io/docs](https://packspliter.qzz.io/docs).

packspliter_cli-1.0.0/README.md

@@ -0,0 +1,23 @@
+# packspliter-cli
+
+Command-line interface for PackSpliter — convert client-side Minecraft modpacks (.mrpack) into server-ready ZIP packages by automatically stripping client-only mods.
+
+## Installation
+
+```bash
+pip install packspliter-cli
+```
+
+## Quickstart
+
+Configure the API key and server URL:
+```bash
+packspliter configure
+```
+
+Convert a modpack:
+```bash
+packspliter convert ATM10.mrpack
+```
+
+For full documentation, visit [https://packspliter.qzz.io/docs](https://packspliter.qzz.io/docs).

packspliter_cli-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "packspliter-cli"
+version = "1.0.0"
+description = "Convert Modrinth/CurseForge modpacks to server files from the command line"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+keywords = ["minecraft", "modpack", "server", "modrinth", "curseforge"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Games/Entertainment",
+]
+
+dependencies = [
+    "httpx>=0.27.0",          # async-capable HTTP client with streaming
+    "rich>=13.7.0",            # beautiful cross-platform terminal output
+    "typer>=0.12.0",           # type-annotated CLI framework
+    "platformdirs>=4.2.0",     # OS-correct config/data directories
+    "tomli>=2.0.1; python_version<'3.11'",   # TOML parser (stdlib in 3.11+)
+    "tomli-w>=1.0.0",          # TOML writer (no stdlib equivalent)
+    "packaging>=24.0",         # version comparison for update check
+]
+
+[project.scripts]
+packspliter = "packspliter.main:app"
+
+[project.urls]
+Homepage = "https://packspliter.qzz.io"
+Repository = "https://github.com/packspliter/cli"
+Issues = "https://github.com/packspliter/cli/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

packspliter_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

packspliter_cli-1.0.0/src/packspliter/api.py

@@ -0,0 +1,315 @@
+"""
+packspliter.api
+===============
+HTTP client for the PackSpliter REST API v1.
+Wraps httpx with retry logic, streaming upload/download, and structured error handling.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import Any, Dict, Generator, Iterator, Optional
+
+import httpx
+
+from packspliter.config import Config
+
+# Timeout config: connect fast, reads long (generation takes up to 60 min)
+_CONNECT_TIMEOUT = 10.0
+_READ_TIMEOUT = 120.0    # for status polls
+_UPLOAD_TIMEOUT = None   # no timeout for large file uploads (streaming)
+
+
+class APIError(Exception):
+    """Raised when the server returns an error response."""
+    def __init__(self, message: str, status_code: int = 0, body: Any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+class PackSpliterClient:
+    """
+    Stateless HTTP client for the PackSpliter API v1.
+    Create one per command invocation; not thread-safe.
+    """
+
+    def __init__(self, cfg: Config):
+        self._base = cfg.effective_server
+        self._key = cfg.effective_key
+        self._timeout = httpx.Timeout(
+            connect=_CONNECT_TIMEOUT,
+            read=_READ_TIMEOUT,
+            write=None,
+            pool=_CONNECT_TIMEOUT,
+        )
+
+    def _headers(self, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        h: Dict[str, str] = {}
+        if self._key:
+            h["X-Api-Key"] = self._key
+        if extra:
+            h.update(extra)
+        return h
+
+    def _url(self, path: str) -> str:
+        return f"{self._base}/api/v1/{path.lstrip('/')}"
+
+    def _raise_for_error(self, resp: httpx.Response) -> None:
+        if resp.status_code >= 400:
+            try:
+                body = resp.json()
+                msg = body.get("error", resp.text[:200])
+            except Exception:
+                msg = resp.text[:200]
+            raise APIError(msg, status_code=resp.status_code, body=body if "body" in dir() else None)
+
+    # -----------------------------------------------------------------------
+    # Key management
+    # -----------------------------------------------------------------------
+
+    def key_info(self) -> Dict[str, Any]:
+        """GET /api/v1/keys/me"""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.get(self._url("keys/me"), headers=self._headers())
+            self._raise_for_error(resp)
+            return resp.json()
+
+    def create_key(self, label: Optional[str] = None, daily_limit: Optional[int] = None) -> Dict[str, Any]:
+        """POST /api/v1/keys  (admin)"""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.post(
+                self._url("keys"),
+                json={"label": label, "daily_limit": daily_limit},
+                headers=self._headers({"X-Admin-Secret": os.environ.get("PACKSPLITER_ADMIN_SECRET", "")}),
+            )
+            self._raise_for_error(resp)
+            return resp.json()
+
+    # -----------------------------------------------------------------------
+    # Job submission
+    # -----------------------------------------------------------------------
+
+    def submit_job_file(
+        self,
+        file_path: Path,
+        *,
+        generation_mode: str = "server",
+        os_type: str = "linux",
+        eula: bool = False,
+        exclude_client_mods: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        POST /api/v1/jobs  (multipart file upload, streamed from disk).
+        Uses a long-lived httpx.Client so the upload isn't bounded by _READ_TIMEOUT.
+        """
+        with open(file_path, "rb") as fh:
+            files = {"file": (file_path.name, fh, "application/octet-stream")}
+            data = {
+                "generation_mode": generation_mode,
+                "os_type": os_type,
+                "eula": "true" if eula else "false",
+                "exclude_client_mods": "true" if exclude_client_mods else "false",
+            }
+            # No read timeout during upload — can be very large files
+            upload_timeout = httpx.Timeout(connect=_CONNECT_TIMEOUT, read=None, write=None, pool=_CONNECT_TIMEOUT)
+            with httpx.Client(timeout=upload_timeout) as client:
+                resp = client.post(
+                    self._url("jobs"),
+                    headers=self._headers(),
+                    files=files,
+                    data=data,
+                )
+        self._raise_for_error(resp)
+        return resp.json()
+
+    def submit_job_url(
+        self,
+        url: str,
+        *,
+        generation_mode: str = "server",
+        os_type: str = "linux",
+        eula: bool = False,
+        exclude_client_mods: bool = True,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/jobs  (JSON body with URL)."""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.post(
+                self._url("jobs"),
+                headers=self._headers(),
+                json={
+                    "url": url,
+                    "generation_mode": generation_mode,
+                    "os_type": os_type,
+                    "eula": eula,
+                    "exclude_client_mods": exclude_client_mods,
+                },
+            )
+        self._raise_for_error(resp)
+        return resp.json()
+
+    # -----------------------------------------------------------------------
+    # Job lifecycle
+    # -----------------------------------------------------------------------
+
+    def job_status(self, job_id: str) -> Dict[str, Any]:
+        """GET /api/v1/jobs/<id>"""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.get(self._url(f"jobs/{job_id}"), headers=self._headers())
+            self._raise_for_error(resp)
+            return resp.json()
+
+    def list_jobs(self, limit: int = 10, status: Optional[str] = None) -> Dict[str, Any]:
+        """GET /api/v1/jobs"""
+        params: Dict[str, Any] = {"limit": limit}
+        if status:
+            params["status"] = status
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.get(self._url("jobs"), params=params, headers=self._headers())
+            self._raise_for_error(resp)
+            return resp.json()
+
+    def cancel_job(self, job_id: str) -> Dict[str, Any]:
+        """DELETE /api/v1/jobs/<id>"""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.delete(self._url(f"jobs/{job_id}"), headers=self._headers())
+            self._raise_for_error(resp)
+            return resp.json()
+
+    def renew_job(self, job_id: str) -> Dict[str, Any]:
+        """POST /api/v1/jobs/<id>/renew"""
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.post(self._url(f"jobs/{job_id}/renew"), headers=self._headers())
+            self._raise_for_error(resp)
+            return resp.json()
+
+    # -----------------------------------------------------------------------
+    # Log history (JSON, non-streaming)
+    # -----------------------------------------------------------------------
+
+    def job_log_history(self, job_id: str) -> list[str]:
+        """GET /api/v1/jobs/<id>/logs?history=true  → list of log lines."""
+        try:
+            with httpx.Client(timeout=self._timeout) as client:
+                resp = client.get(
+                    self._url(f"jobs/{job_id}/logs"),
+                    params={"history": "true"},
+                    headers=self._headers(),
+                )
+                if resp.status_code == 200:
+                    return resp.json().get("logs", [])
+        except Exception:
+            pass
+        return []
+
+    # -----------------------------------------------------------------------
+    # Download (streaming, supports resume via Range header)
+    # -----------------------------------------------------------------------
+
+    def download_job(
+        self,
+        job_id: str,
+        dest: Path,
+        *,
+        resume: bool = False,
+        on_progress: Optional[callable] = None,
+    ) -> Path:
+        """
+        Stream the completed job ZIP to `dest`.
+
+        If `resume=True` and `dest` (or `dest.with_suffix('.part')`) already
+        exists, sends a Range header to resume from that byte offset.
+
+        `on_progress(downloaded_bytes, total_bytes)` is called periodically.
+
+        Returns the final path on success.
+        """
+        part_path = dest.with_suffix(dest.suffix + ".part") if dest.suffix else dest.parent / (dest.name + ".part")
+
+        resume_from = 0
+        if resume and part_path.exists():
+            resume_from = part_path.stat().st_size
+
+        headers = self._headers()
+        if resume_from:
+            headers["Range"] = f"bytes={resume_from}-"
+
+        dl_timeout = httpx.Timeout(connect=_CONNECT_TIMEOUT, read=300.0, write=None, pool=_CONNECT_TIMEOUT)
+
+        with httpx.Client(timeout=dl_timeout, follow_redirects=True) as client:
+            with client.stream(
+                "GET",
+                self._url(f"jobs/{job_id}/download"),
+                headers=headers,
+            ) as resp:
+                if resp.status_code == 404:
+                    raise APIError("File not found — it may have expired.", 404)
+                if resp.status_code == 410:
+                    raise APIError("File has been deleted from the server.", 410)
+                if resp.status_code == 409:
+                    raise APIError("Job is not yet complete.", 409)
+                if resp.status_code not in (200, 206):
+                    raise APIError(f"Download failed (HTTP {resp.status_code})", resp.status_code)
+
+                total = int(resp.headers.get("Content-Length", 0))
+                if resume_from:
+                    # Content-Range: bytes START-END/TOTAL
+                    cr = resp.headers.get("Content-Range", "")
+                    if cr and "/" in cr:
+                        try:
+                            total = int(cr.split("/")[-1])
+                        except ValueError:
+                            pass
+
+                downloaded = resume_from
+                mode = "ab" if (resume_from and resp.status_code == 206) else "wb"
+
+                with open(part_path, mode) as fh:
+                    for chunk in resp.iter_bytes(chunk_size=512 * 1024):  # 512 KB chunks
+                        fh.write(chunk)
+                        downloaded += len(chunk)
+                        if on_progress:
+                            on_progress(downloaded, total)
+
+        # Rename .part → final filename
+        part_path.replace(dest)
+        return dest
+
+    # -----------------------------------------------------------------------
+    # Preview
+    # -----------------------------------------------------------------------
+
+    def remote_preview(self, file_path: Path) -> Dict[str, Any]:
+        """POST /api/v1/preview — server-side pack parsing."""
+        with open(file_path, "rb") as fh:
+            files = {"file": (file_path.name, fh, "application/octet-stream")}
+            with httpx.Client(timeout=self._timeout) as client:
+                resp = client.post(
+                    self._url("preview"),
+                    headers=self._headers(),
+                    files=files,
+                )
+        self._raise_for_error(resp)
+        return resp.json()
+
+    # -----------------------------------------------------------------------
+    # Server health check (no auth required)
+    # -----------------------------------------------------------------------
+
+    def health_check(self) -> Optional[str]:
+        """
+        GET /health — returns server version string if reachable, None otherwise.
+        Tries up to 1 retry.
+        """
+        for _ in range(2):
+            try:
+                with httpx.Client(timeout=httpx.Timeout(5.0)) as client:
+                    resp = client.get(f"{self._base}/health")
+                    if resp.status_code == 200:
+                        data = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
+                        return data.get("version", "unknown")
+            except Exception:
+                time.sleep(0.5)
+        return None

packspliter_cli-1.0.0/src/packspliter/commands/configure.py

@@ -0,0 +1,168 @@
+"""
+packspliter.commands.configure
+================================
+packspliter configure
+  --key TEXT       Set API key
+  --server TEXT    Set server URL
+  --check          Verify key against server and exit
+  --show           Print current config and exit
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from packspliter.config import Config, config_file_path, load_config, save_config
+from packspliter import output as out
+
+app = typer.Typer(help="Configure API key and server settings.")
+
+
+@app.callback(invoke_without_command=True)
+def configure(
+    ctx: typer.Context,
+    key: Optional[str] = typer.Option(None, "--key", "-k", help="API key to save"),
+    server: Optional[str] = typer.Option(None, "--server", "-s", help="Server URL"),
+    check: bool = typer.Option(False, "--check", help="Verify key against server and exit"),
+    show: bool = typer.Option(False, "--show", help="Print current config and exit"),
+):
+    cfg = ctx.obj if (ctx and ctx.obj) else load_config()
+    json_mode = cfg.is_json_mode
+
+    # --show: print current config
+    if show:
+        if json_mode:
+            out.emit_json("config", {
+                "server_url": cfg.effective_server,
+                "api_key_prefix": (cfg.effective_key or "")[:12] or None,
+                "output_dir": cfg.output_dir,
+                "format": cfg.format,
+                "poll_interval": cfg.poll_interval,
+                "config_file": str(config_file_path()),
+            })
+        else:
+            out.print_separator()
+            typer.echo(f"  Server:       {cfg.effective_server}")
+            typer.echo(f"  API key:      {mask_key(cfg.effective_key)}")
+            typer.echo(f"  Output dir:   {cfg.output_dir}")
+            typer.echo(f"  Poll interval:{cfg.poll_interval}s")
+            typer.echo(f"  Format:       {cfg.format}")
+            typer.echo(f"  Config file:  {config_file_path()}")
+            out.print_separator()
+        return
+
+    # --check: verify key against server
+    if check:
+        _do_check(cfg, json_mode)
+        return
+
+    # Interactive mode: prompt for what's missing if not supplied via flags
+    if not key and not server:
+        _interactive(cfg, json_mode)
+        return
+
+    # Non-interactive: apply provided flags
+    changed = False
+    if server:
+        cfg.server_url = server.rstrip("/")
+        changed = True
+    if key:
+        cfg.api_key = key
+        changed = True
+
+    if changed:
+        if save_config(cfg):
+            if json_mode:
+                out.emit_json("configure_ok", {
+                    "server_url": cfg.effective_server,
+                    "key_prefix": (cfg.effective_key or "")[:12],
+                    "config_file": str(config_file_path()),
+                })
+            else:
+                out.print_ok(f"Saved to {config_file_path()}")
+                out.print_ok(f"Server:  {cfg.effective_server}")
+                out.print_ok(f"Key:     {mask_key(cfg.effective_key)}")
+        else:
+            out.print_err("Failed to save config (check permissions)")
+            raise typer.Exit(1)
+
+
+def _interactive(cfg: Config, json_mode: bool) -> None:
+    """Guided wizard — prompts for each field."""
+    if json_mode:
+        out.print_err("Use --key and --server flags in non-interactive (piped) mode.")
+        raise typer.Exit(1)
+
+    typer.echo()
+    typer.echo("  PackSpliter CLI Setup")
+    out.print_separator()
+
+    new_server = typer.prompt(
+        "  Server URL",
+        default=cfg.effective_server,
+    ).strip().rstrip("/")
+
+    new_key = typer.prompt(
+        "  API key (paste here — input hidden)",
+        default=cfg.api_key or "",
+        hide_input=True,
+    ).strip()
+
+    new_output = typer.prompt(
+        "  Default output directory",
+        default=cfg.output_dir,
+    ).strip() or "."
+
+    cfg.server_url = new_server
+    cfg.api_key = new_key or cfg.api_key
+    cfg.output_dir = new_output
+
+    if save_config(cfg):
+        out.print_separator()
+        out.print_ok(f"Saved to {config_file_path()}")
+        out.print_ok(f"Server:  {cfg.effective_server}")
+        out.print_ok(f"Key:     {mask_key(cfg.effective_key)}")
+        out.print_separator()
+        # Immediately verify
+        _do_check(cfg, json_mode)
+    else:
+        out.print_err("Could not write config file. Check permissions.")
+        raise typer.Exit(1)
+
+
+def _do_check(cfg: Config, json_mode: bool) -> None:
+    """Hit /api/v1/keys/me and report back."""
+    from packspliter.api import PackSpliterClient, APIError
+
+    if not cfg.effective_key:
+        if json_mode:
+            out.emit_json("config_error", {"error": "No API key configured."})
+        else:
+            out.print_err("No API key configured. Run: packspliter configure --key <key>")
+        raise typer.Exit(1)
+
+    client = PackSpliterClient(cfg)
+    try:
+        info = client.key_info()
+        if json_mode:
+            out.emit_json("key_ok", info)
+        else:
+            out.print_ok(f"Connected to {cfg.effective_server}")
+            out.print_ok(f"Key prefix:    {info.get('key_prefix', '?')}")
+            out.print_ok(f"Label:         {info.get('label') or '(no label)'}")
+            out.print_ok(f"Requests today:{info.get('requests_today', 0)} / {info.get('daily_limit') or '∞'}")
+            out.print_ok(f"Total requests:{info.get('total_requests', 0)}")
+    except APIError as e:
+        if json_mode:
+            out.emit_json("key_error", {"error": str(e), "status": e.status_code})
+        else:
+            out.print_err(f"Key check failed: {e}")
+        raise typer.Exit(1)
+
+
+def mask_key(key: Optional[str]) -> str:
+    if not key:
+        return "(not set)"
+    return key[:16] + "..." + key[-4:]