typst-pkg-sync 0.1.0__py3-none-any.whl

typst_pkg_sync/__init__.py

@@ -0,0 +1 @@
+"""Local package manager for Typst."""

typst_pkg_sync/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

typst_pkg_sync/cli.py

@@ -0,0 +1,564 @@
+"""
+typst-pkg-sync — Local Package Manager for Typst
+
+Downloads tagged source files from GitHub, GitLab, and Codeberg
+and installs them into the local Typst package directory structure:
+
+    <base_dir>/<namespace>/<package-name>/<version>/
+
+The package name is read from the typst.toml file inside the
+downloaded archive. Version tags may carry a 'v' prefix (e.g. "v1.0.0"),
+which is stripped for the installation directory.
+
+Requires Python 3.14+ (uses tomllib from the standard library).
+No third-party dependencies.
+"""
+
+import argparse
+import http.client
+import json
+import os
+import re
+import shutil
+import sys
+import tarfile
+import tempfile
+import tomllib
+import urllib.error
+import urllib.parse
+import urllib.request
+import zipfile
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+CONFIG_DIR = Path.home() / ".config" / "lpmt"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+DEFAULT_BASE_DIR = Path.home() / ".local/share/typst/packages"
+
+# Version strings: optional 'v' prefix, then digits and dots,
+# at least major.minor. Capture group 1 = version without prefix.
+SEMVER_RE = re.compile(r"^v?(\d+\.\d+(?:\.\d+)?)$")
+
+PLATFORMS = {
+    "github": {
+        "tags_api": "https://api.github.com/repos/{owner}/{repo}/tags",
+        "archive": "https://github.com/{owner}/{repo}/archive/refs/tags/{tag}.tar.gz",
+        "archive_format": "tar",
+        "auth_env": "GITHUB_TOKEN",
+        "auth_header": "Authorization",
+        "auth_prefix": "token ",
+    },
+    "gitlab": {
+        "base_url": "https://gitlab.com",
+        "tags_api": "{base_url}/api/v4/projects/{project_path}/repository/tags",
+        "archive": "{base_url}/api/v4/projects/{project_path}/repository/archive.tar.gz?sha={tag}",
+        "archive_format": "tar",
+        "auth_env": "GITLAB_TOKEN",
+        "auth_header": "PRIVATE-TOKEN",
+        "auth_prefix": "",
+    },
+    "codeberg": {
+        "tags_api": "https://codeberg.org/api/v1/repos/{owner}/{repo}/tags",
+        "archive": "https://codeberg.org/{owner}/{repo}/archive/{tag}.tar.gz",
+        "archive_format": "tar",
+        "auth_env": "CODEBERG_TOKEN",
+        "auth_header": "Authorization",
+        "auth_prefix": "token ",
+    },
+}
+
+DEFAULT_CONFIG = """\
+# typst-pkg-sync — Local Package Manager for Typst
+#
+# Packages are installed to:
+#   <base_dir>/<namespace>/<package-name>/<version>/
+#
+# The <package-name> is read from the typst.toml file inside the
+# downloaded archive, NOT from the repository name.
+#
+# Tags may be written with or without a 'v' prefix (e.g. "v1.0.0"
+# or "1.0.0"). The prefix is stripped for the install directory.
+#
+# GitLab repositories may set base_url and token_env per repository.
+# base_url defaults to https://gitlab.com; token_env defaults to GITLAB_TOKEN.
+
+[settings]
+base_dir = "~/.local/share/typst/packages"
+namespace = "jp-packages"
+skip_existing = true
+verbose = true
+
+[[repositories]]
+platform = "gitlab"
+base_url = "https://gitlab.gwdg.de"
+owner = "ressler"
+repo = "jps-university-assignments"
+tags = ["0.2.0"]
+
+[[repositories]]
+platform = "codeberg"
+owner = "ressler"
+repo = "protokoll-template"
+tags = "all"
+"""
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+
+def log_info(msg: str) -> None:
+    print(f"\033[32m[INFO]\033[0m {msg}")
+
+
+def log_warn(msg: str) -> None:
+    print(f"\033[33m[WARN]\033[0m {msg}")
+
+
+def log_error(msg: str) -> None:
+    print(f"\033[31m[ERROR]\033[0m {msg}")
+
+
+def log_debug(msg: str) -> None:
+    print(f"\033[34m[DEBUG]\033[0m {msg}")
+
+
+# ---------------------------------------------------------------------------
+# Tag handling
+# ---------------------------------------------------------------------------
+
+
+def normalize_tag(tag: str) -> str | None:
+    """
+    Normalize a tag string.
+
+    Accepts an optional 'v' prefix followed by digits and dots
+    (at least major.minor). Returns the version without the prefix,
+    or None if the tag does not match the pattern.
+    """
+    m = SEMVER_RE.match(tag)
+    return m.group(1) if m else None
+
+
+def validate_tags(tags: object, repo: str) -> list[str] | str:
+    """
+    Validate the tags field from the config.
+
+    Allowed:
+      - the string "all"
+      - an array of version strings, with optional 'v' prefix
+        (e.g. "0.2.0", "v1.0.0", "1.0")
+
+    Returns either "all" or a list of normalized versions
+    (prefix stripped). Exits on invalid input.
+    """
+    if isinstance(tags, str):
+        if tags == "all":
+            return "all"
+        log_error(f'[{repo}] tags must be an array of versions or the string "all", got: "{tags}"')
+        sys.exit(1)
+
+    if isinstance(tags, list):
+        if not tags:
+            log_error(f"[{repo}] tags array is empty")
+            sys.exit(1)
+        normalized = []
+        for t in tags:
+            version = normalize_tag(t) if isinstance(t, str) else None
+            if version is None:
+                log_error(
+                    f"[{repo}] invalid tag {t!r}: tags must consist of an "
+                    f"optional 'v' prefix followed by digits and dots "
+                    f'(e.g. "0.2.0" or "v1.0.0")'
+                )
+                sys.exit(1)
+            normalized.append(version)
+        return normalized
+
+    log_error(f'[{repo}] tags must be an array of versions or "all"')
+    sys.exit(1)
+
+
+def filter_remote_tags(raw_tags: list[str], owner: str, repo: str) -> list[str]:
+    """
+    Filter remote tag names against the version pattern.
+
+    Tags that don't match (e.g. "release-candidate", "nightly")
+    are skipped with a warning. Matching tags are normalized
+    ('v' prefix stripped) and deduplicated while preserving order.
+    """
+    versions: list[str] = []
+    seen: set[str] = set()
+
+    for raw in raw_tags:
+        version = normalize_tag(raw)
+        if version is None:
+            log_warn(f"[{owner}/{repo}] skipping non-version tag: {raw!r}")
+            continue
+        if version in seen:
+            log_warn(
+                f"[{owner}/{repo}] tag {raw!r} maps to version {version!r}, "
+                f"which was already seen — skipping duplicate"
+            )
+            continue
+        seen.add(version)
+        versions.append(version)
+
+    return versions
+
+
+# ---------------------------------------------------------------------------
+# Config handling
+# ---------------------------------------------------------------------------
+
+
+def create_default_config(config_file: Path) -> None:
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    config_file.write_text(DEFAULT_CONFIG)
+    log_info(f"Created default config at {config_file}")
+    log_info("Edit it to add your repositories, then re-run.")
+    sys.exit(0)
+
+
+def load_config(config_file: Path = CONFIG_FILE) -> dict:
+    if not config_file.exists():
+        create_default_config(config_file)
+    try:
+        with open(config_file, "rb") as f:
+            return tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        log_error(f"Invalid TOML in {config_file}: {e}")
+        sys.exit(1)
+
+
+def resolve_platform_config(platform: str, repo_cfg: dict) -> dict | None:
+    """Apply per-repository overrides to a platform's request settings."""
+    plat = dict(PLATFORMS[platform])
+    plat["name"] = platform
+
+    token_env = repo_cfg.get("token_env", plat["auth_env"])
+    if not isinstance(token_env, str) or not token_env:
+        log_error(f"Invalid token_env for repository '{repo_cfg.get('repo', '')}'")
+        return None
+    plat["auth_env"] = token_env
+
+    if "base_url" in repo_cfg:
+        if platform != "gitlab":
+            log_error("The 'base_url' option is only supported for GitLab repositories")
+            return None
+        base_url = repo_cfg["base_url"]
+        if not isinstance(base_url, str) or not base_url or base_url != base_url.strip():
+            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            return None
+        try:
+            parsed = urllib.parse.urlsplit(base_url)
+            _ = parsed.port
+        except ValueError:
+            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            return None
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not parsed.hostname
+            or parsed.username is not None
+            or parsed.password is not None
+            or parsed.query
+            or parsed.fragment
+        ):
+            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            return None
+        plat["base_url"] = base_url.rstrip("/")
+
+    return plat
+
+
+# ---------------------------------------------------------------------------
+# HTTP helpers (stdlib only)
+# ---------------------------------------------------------------------------
+
+
+def make_request(url: str, plat: dict) -> bytes:
+    headers = {"User-Agent": "typst-pkg-sync/1.0"}
+
+    token = os.environ.get(plat["auth_env"], "")
+    if token:
+        headers[plat["auth_header"]] = plat["auth_prefix"] + token
+
+    req = urllib.request.Request(url, headers=headers)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        return resp.read()
+
+
+def fetch_tags(plat: dict, owner: str, repo: str) -> list[str]:
+    """Fetch all tag names from the remote repository."""
+    url = plat["tags_api"].format(
+        base_url=plat.get("base_url", ""),
+        owner=owner,
+        repo=repo,
+        project_path=urllib.parse.quote(f"{owner}/{repo}", safe=""),
+    )
+    try:
+        data = json.loads(make_request(url, plat))
+        return [tag["name"] for tag in data]
+    except (http.client.HTTPException, OSError, ValueError, KeyError, TypeError) as e:
+        log_warn(f"Could not fetch tags for {owner}/{repo}: {e}")
+        return []
+
+
+# ---------------------------------------------------------------------------
+# Archive handling
+# ---------------------------------------------------------------------------
+
+
+def extract_archive(archive_bytes: bytes, dest: Path, fmt: str) -> None:
+    """Extract a tar.gz or zip archive into dest, flattening the top dir."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_path = Path(tmp) / ("archive.tar.gz" if fmt == "tar" else "archive.zip")
+        tmp_path.write_bytes(archive_bytes)
+
+        extract_dir = Path(tmp) / "extracted"
+        extract_dir.mkdir()
+
+        if fmt == "tar":
+            with tarfile.open(tmp_path, "r:gz") as tf:
+                tf.extractall(extract_dir, filter="data")
+        else:
+            with zipfile.ZipFile(tmp_path) as zf:
+                zf.extractall(extract_dir)
+
+        entries = list(extract_dir.iterdir())
+        source = entries[0] if (len(entries) == 1 and entries[0].is_dir()) else extract_dir
+
+        for item in source.iterdir():
+            shutil.move(str(item), str(dest / item.name))
+
+
+def read_package_name(package_dir: Path) -> str | None:
+    """
+    Read the package name from typst.toml in the extracted package.
+
+    Expected structure in typst.toml:
+        [package]
+        name = "..."
+    """
+    typst_toml = package_dir / "typst.toml"
+    if not typst_toml.exists():
+        return None
+    try:
+        with open(typst_toml, "rb") as f:
+            data = tomllib.load(f)
+        name = data.get("package", {}).get("name")
+        return name if isinstance(name, str) and name else None
+    except (tomllib.TOMLDecodeError, OSError) as e:
+        log_warn(f"Could not parse typst.toml: {e}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Download & install
+# ---------------------------------------------------------------------------
+
+
+def download_and_install(
+    plat: dict,
+    owner: str,
+    repo: str,
+    tag: str,
+    base_dir: Path,
+    namespace: str,
+    skip_existing: bool,
+) -> bool:
+    """
+    Download one tag of one repository and install it.
+
+    'tag' must already be normalized (no 'v' prefix) — it is used both
+    to build the archive URL (with prefix re-added if the remote uses
+    one) and as the version directory name.
+
+    The package name is read from typst.toml inside the archive.
+    Returns True on success (including skip), False on failure.
+    """
+    platform = plat["name"]
+
+    # Try the plain tag first; if it 404s, retry with a 'v' prefix.
+    # This handles remotes that tag as "v1.0.0" while the config
+    # (or the filtered remote list) uses the normalized form.
+    candidates = [tag]
+    if not tag.startswith("v"):
+        candidates.append(f"v{tag}")
+
+    archive_bytes: bytes | None = None
+    used_tag: str | None = None
+
+    for candidate in candidates:
+        url = plat["archive"].format(
+            base_url=plat.get("base_url", ""),
+            owner=owner,
+            project_path=urllib.parse.quote(f"{owner}/{repo}", safe=""),
+            repo=urllib.parse.quote(repo, safe=""),
+            tag=urllib.parse.quote(candidate, safe=""),
+        )
+        try:
+            log_info(f"⬇  Downloading {owner}/{repo}@{candidate} from {platform}...")
+            archive_bytes = make_request(url, plat)
+            used_tag = candidate
+            break
+        except urllib.error.HTTPError as e:
+            if e.code == 404 and candidate != candidates[-1]:
+                log_debug(f"Tag '{candidate}' not found, trying next candidate...")
+                continue
+            log_error(f"HTTP {e.code} for {url}")
+            return False
+        except (http.client.HTTPException, OSError, ValueError) as e:
+            log_error(f"Download failed for {owner}/{repo}@{candidate}: {e}")
+            return False
+
+    if archive_bytes is None or used_tag is None:
+        log_error(f"Could not download {owner}/{repo}@{tag}")
+        return False
+
+    # Extract to a staging dir first so we can read typst.toml
+    with tempfile.TemporaryDirectory() as tmp:
+        staging = Path(tmp) / "staging"
+        staging.mkdir()
+
+        try:
+            extract_archive(archive_bytes, staging, plat["archive_format"])
+        except (
+            tarfile.TarError,
+            zipfile.BadZipFile,
+            OSError,
+            EOFError,
+        ) as e:
+            log_error(f"Extraction failed for {owner}/{repo}@{used_tag}: {e}")
+            return False
+
+        # Read the package name from typst.toml
+        package_name = read_package_name(staging)
+        if package_name is None:
+            log_error(
+                f"No valid typst.toml with [package] name found in "
+                f"{owner}/{repo}@{used_tag} — cannot determine package name"
+            )
+            return False
+
+        if package_name != repo:
+            log_debug(f"Package name '{package_name}' differs from repo '{repo}'")
+
+        # Final destination: normalized tag (no 'v' prefix) as version dir
+        dest = base_dir / namespace / package_name / tag
+
+        if dest.exists():
+            if skip_existing:
+                log_warn(f"⊘ Already exists: {dest}")
+                return True
+            log_warn(f"Overwriting existing: {dest}")
+            shutil.rmtree(dest)
+
+        dest.mkdir(parents=True, exist_ok=True)
+
+        try:
+            for item in staging.iterdir():
+                shutil.move(str(item), str(dest / item.name))
+        except OSError as e:
+            log_error(f"Install failed: {e}")
+            shutil.rmtree(dest, ignore_errors=True)
+            return False
+
+    log_info(f"✅ Installed {package_name}@{tag} → {dest}")
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Sync logic
+# ---------------------------------------------------------------------------
+
+
+def sync_repository(repo_cfg: dict, settings: dict) -> bool:
+    platform = repo_cfg.get("platform", "").lower()
+    owner = repo_cfg.get("owner", "")
+    repo = repo_cfg.get("repo", "")
+    raw_tags = repo_cfg.get("tags")
+
+    if platform not in PLATFORMS:
+        log_error(f"Unknown platform '{platform}' for repo '{repo}'")
+        return False
+    if not owner or not repo:
+        log_error(f"Missing 'owner' or 'repo' in config entry: {repo_cfg}")
+        return False
+
+    plat = resolve_platform_config(platform, repo_cfg)
+    if plat is None:
+        return False
+
+    tags = validate_tags(raw_tags, repo)
+
+    # "all": query remote tags and filter them for the version pattern
+    if tags == "all":
+        raw_remote = fetch_tags(plat, owner, repo)
+        if not raw_remote:
+            log_error(f"No tags found for {owner}/{repo}")
+            return False
+        tags = filter_remote_tags(raw_remote, owner, repo)
+        if not tags:
+            log_error(f"No tags matching the version pattern found for {owner}/{repo}")
+            return False
+        log_info(f'[{owner}/{repo}] tags = "all" → {len(tags)} version(s): {tags}')
+
+    base_dir = Path(settings.get("base_dir", str(DEFAULT_BASE_DIR))).expanduser()
+    namespace = settings.get("namespace", "preview")
+    skip_existing = settings.get("skip_existing", True)
+
+    ok = 0
+    for tag in tags:
+        if download_and_install(plat, owner, repo, tag, base_dir, namespace, skip_existing):
+            ok += 1
+
+    log_info(f"── {owner}/{repo}: {ok}/{len(tags)} version(s) synced")
+    return ok == len(tags)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Sync Typst packages from Git repositories")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=CONFIG_FILE,
+        help=f"config file path (default: {CONFIG_FILE})",
+    )
+    args = parser.parse_args(argv)
+    config_file = args.config.expanduser()
+
+    config = load_config(config_file)
+    settings = config.get("settings", {})
+    repos = config.get("repositories", [])
+
+    if not repos:
+        log_warn("No [[repositories]] defined in config.")
+        log_info(f"Edit {config_file} to add some.")
+        sys.exit(0)
+
+    namespace = settings.get("namespace", "preview")
+    base_dir = Path(settings.get("base_dir", str(DEFAULT_BASE_DIR))).expanduser()
+
+    log_info("📦 typst-pkg-sync — Typst Package Sync")
+    log_info(f"📁 Base:      {base_dir}")
+    log_info(f"🏷  Namespace: {namespace}")
+    print()
+
+    failures = 0
+    for repo_cfg in repos:
+        if not sync_repository(repo_cfg, settings):
+            failures += 1
+
+    print()
+    if failures:
+        log_error(f"{failures} repository(ies) had errors")
+        sys.exit(1)
+    log_info("🎉 All done!")
+
+
+if __name__ == "__main__":
+    main()

typst_pkg_sync-0.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: typst-pkg-sync
+Version: 0.1.0
+Summary: Sync tagged Typst packages from GitHub, GitLab, and Codeberg
+Author: Jan-Philipp Reßler
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Project-URL: Repository, https://codeberg.org/ressler/lpmt
+Project-URL: Issues, https://codeberg.org/ressler/lpmt/issues
+Description-Content-Type: text/markdown
+
+# typst-pkg-sync
+
+typst-pkg-sync downloads tagged Typst packages from GitHub, GitLab (including
+self-hosted instances), and Codeberg, then installs them in the local Typst
+package directory.
+
+Requires Python 3.14 or newer. typst-pkg-sync has no runtime third-party dependencies.
+
+## Install
+
+After typst-pkg-sync is published to PyPI, install it as a user tool with:
+
+```sh
+uv tool install typst-pkg-sync
+```
+
+To install from a local checkout while developing typst-pkg-sync:
+
+```sh
+uv tool install .
+```
+
+## Configure
+
+On its first run, typst-pkg-sync creates `~/.config/lpmt/config.toml` and exits.
+The `lpmt` config directory is retained for compatibility. Edit the file to add
+repositories, then run `typst-pkg-sync` again. Alternatively, select a config
+file explicitly:
+
+```sh
+typst-pkg-sync --config /path/to/config.toml
+```
+
+See the [example configuration](https://codeberg.org/ressler/lpmt/src/branch/main/config_example.toml)
+for examples, including a self-hosted GitLab repository. GitLab entries can
+set `base_url` and an optional `token_env` per repository.
+
+Packages are installed under:
+
+```text
+<base_dir>/<namespace>/<package-name>/<version>/
+```
+
+The package name is read from `typst.toml` in the downloaded archive. A `v`
+prefix on a tag is removed from the installed version directory.
+
+## Development
+
+Run the sample configuration with `just run` and the code-quality checks with
+`just check`.
+
+typst-pkg-sync is licensed under MIT; see [LICENSE](LICENSE).

typst_pkg_sync-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+typst_pkg_sync/__init__.py,sha256=ELTFeRb4DDajqZyzxzkPGXFMqwHpO_xc0yFXdW_6lC4,39
+typst_pkg_sync/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+typst_pkg_sync/cli.py,sha256=CeK39OZ3Ynt3tBuJxXoeRPlYs6cAt66x8E--c0h8gyM,18566
+typst_pkg_sync-0.1.0.dist-info/licenses/LICENSE,sha256=Og_MGJ76gr6KQjWSzcS6AVwFM2suJj6syvXrlYd-ytc,1076
+typst_pkg_sync-0.1.0.dist-info/WHEEL,sha256=cmC5s21ojypbVslldL7IJq3hjZH-tINy4rziKePFsG0,81
+typst_pkg_sync-0.1.0.dist-info/entry_points.txt,sha256=khquF574jW8TPJyO0xjed1MZVPYkVjxgLHL0AjFQxAc,60
+typst_pkg_sync-0.1.0.dist-info/METADATA,sha256=6jAnsW7lzpnGbw3VDmsG501SeWEDyns8x6WCnI-ZQTM,1866
+typst_pkg_sync-0.1.0.dist-info/RECORD,,

typst_pkg_sync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.23
+Root-Is-Purelib: true
+Tag: py3-none-any

typst_pkg_sync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+typst-pkg-sync = typst_pkg_sync.cli:main
+

typst_pkg_sync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jan-Philipp Reßler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.