No description
  • Rust 81%
  • QML 18.2%
  • Shell 0.8%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
cosmo 81646d6b42 feat(build): per-package option to skip dependency checks (v0.4.4)
Add a "Skip dependency checks" option to tracked packages. Local builds of
such packages run makepkg with --nodeps and don't install dependencies
built in the same run, so packages whose build doesn't need their
dependencies (udev rules, config files) no longer require passwordless
sudo for pacman. Clean-chroot builds on a build server are unaffected.

The error when installing built dependencies fails now names the
packages involved.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-29 20:35:28 +01:00
src feat(build): per-package option to skip dependency checks (v0.4.4) 2026-10-29 20:35:28 +01:00
.gitignore fix(ui): dark console theme and real-time package build status tracking (v0.3.3) 2026-09-27 23:42:58 +02:00
auryn.svg feat: add KDE icon, fix Wayland app_id, restore sidebar menu, and bump to 0.3.2 2026-09-27 23:28:53 +02:00
Cargo.lock feat(build): per-package option to skip dependency checks (v0.4.4) 2026-10-29 20:35:28 +01:00
Cargo.toml feat(build): per-package option to skip dependency checks (v0.4.4) 2026-10-29 20:35:28 +01:00
gay.geeks.auryn.desktop feat: add KDE icon, fix Wayland app_id, restore sidebar menu, and bump to 0.3.2 2026-09-27 23:28:53 +02:00
gay.geeks.auryn.svg feat: add KDE icon, fix Wayland app_id, restore sidebar menu, and bump to 0.3.2 2026-09-27 23:28:53 +02:00
PKGBUILD feat(build): per-package option to skip dependency checks (v0.4.4) 2026-10-29 20:35:28 +01:00
README.md feat: build pipeline, SSH security and usability overhaul (v0.4.0) 2026-10-28 18:19:22 +01:00

AURYN

AURYN is a KDE Plasma desktop application (Rust + Qt 6 / Kirigami via qmetaobject) for building Arch Linux packages locally or on a remote build server, tracking AUR and custom packages, and publishing them to a custom pacman repository ("SimpleRepo").

It checks versions against the AUR (RPC v5) and your repository, resolves AUR dependency trees into a build order (DAG), builds in clean chroots with devtools, and uploads the results via SSH/SFTP drop or the SimpleRepo REST API.


Features

  • Tracked packages: status badges (Up to date, Update available, Building..., Failed, …), repo vs. upstream versions, last build time and result, filtering, edit dialog, and one-click rebuild / cancel.
  • Update checks: AUR versions are compared with vercmp semantics. VCS packages (-git, …) are checked with git ls-remote (honouring #branch=/#tag= fragments) against the commit of the last build, so stale AUR pkgvers don't cause phantom updates. Rebuild Outdated queues every package with an update (packages can opt out in their edit dialog).
  • Repository adoption: packages published in SimpleRepo but not tracked are listed and can be adopted if they exist on the AUR.
  • AUR search & import with relevance sorting.
  • Custom sources: arbitrary Git repositories, local PKGBUILDs (adjacent patches and .install files are uploaded too), or inline PKGBUILD text.
  • Build console: live output batched for performance, filterable per package; every build is also saved to $XDG_STATE_HOME/auryn/logs/<package>/ (last 20 runs kept).
  • Notifications for build results, update checks, and every error that used to only appear in the terminal.

Build pipeline

  1. Dependencies: AUR depends, makedepends and checkdepends are resolved recursively. Official packages are detected through the local pacman sync databases (including provides, restricted to core/extra/multilib); virtual dependencies are resolved via AUR provides search. Packages are cloned by pkgbase, and split packages are built once.
  2. Build: remotely with extra-x86_64-build in <build_dir>/<pkgbase>; dependencies built earlier in the same run are injected into the chroot with makechrootpkg -I, as are previous builds of dependencies that only exist in your repository. Locally the configured command (default makepkg -s --noconfirm) is used, and freshly built dependencies are installed with sudo -n pacman -U --asdeps.
  3. Artifacts: every package file produced by the build is uploaded (split packages included, -debug packages skipped), not just the newest file.
  4. Deploy: SFTP drop to <drop_dir> (written as .part and atomically renamed, so watchers never see partial files) followed by a repository rebuild request, or a multipart REST upload.

Builds run in parallel up to the configured concurrency (changeable without a restart); two builds sharing a dependency never build it in the same directory at once. Queued and running builds can be cancelled.

SSH

  • Authentication cascade: SSH agent (IdentityAgent from ~/.ssh/config, $SSH_AUTH_SOCK, Bitwarden/1Password/GnuPG/GNOME agent sockets), identity file, then password from the OS keyring.
  • Host keys are verified against ~/.ssh/known_hosts. Unknown hosts are trusted on first use and recorded (like StrictHostKeyChecking=accept-new); a changed key aborts the connection.
  • One authenticated session is reused for all commands of a build.
  • All remote commands quote their arguments; package names are validated.

Build server prerequisites

sudo pacman -S --needed base-devel devtools git openssh

The build user must be able to run extra-x86_64-build non-interactively (passwordless sudo for the devtools chroot commands). Use Build Server Health in the app menu to verify the setup.


Configuration

Settings are edited in Configure AURYN… (with Test Connection buttons) and stored in $XDG_CONFIG_HOME/auryn/config.toml (mode 0600, written atomically). SSH passwords and the SimpleRepo API token are stored in the OS keyring (Secret Service); the token only falls back to the config file if no keyring is available. If the file cannot be parsed, AURYN keeps a copy as config.toml.broken-<timestamp> and warns at startup.

[build_server]
enabled = true
host = "build.example.com"   # hostname or ~/.ssh/config alias
port = 22
user = "builder"
auth_method = "agent"        # "agent", "key", or "password"
key_path = "~/.ssh/id_ed25519"
build_dir = "~/auryn-builds" # "~/" is relative to the remote home directory
concurrency = 2
local_build_command = "makepkg -s --noconfirm"

[repo_server]
host = "repo.example.com"
port = 22
user = "repo"
auth_method = "agent"
key_path = "~/.ssh/id_ed25519"
upload_method = "ssh"        # "ssh" (recommended for large packages) or "api"
drop_dir = "/data/drop"
api_base_url = "https://repo.example.com"
api_token = ""               # normally kept in the OS keyring
target_arch = "x86_64"

[[tracked_packages]]
name = "paru-git"
source_type = "aur"          # "aur", "git_url", "pkgbuild_remote", "pkgbuild_local"
auto_rebuild = true          # include in "Rebuild Outdated"

Building and running

Requirements: Rust 1.80+, Qt 6 (qt6-base, qt6-declarative), kirigami, kirigami-addons, libssh2, openssl, pkgconf.

export QMAKE=/usr/bin/qmake6 LIBSSH2_SYS_USE_PKG_CONFIG=1
cargo test
cargo run --release

Or build the Arch package with makepkg -si (the PKGBUILD builds the v$pkgver tag).


Code structure

src/
├── main.rs              # Entry point: Tokio runtime, config loading, QML engine
├── config.rs            # TOML config, atomic saves, keyring-backed API token, update detection
├── util.rs              # Shell quoting, name validation, vercmp, UTF-8 helpers
├── ssh/
│   ├── auth.rs          # Agent / key / keyring password authentication cascade
│   ├── client.rs        # Session reuse, host key verification, streaming exec, SFTP
│   ├── config.rs        # ~/.ssh/config parsing and agent socket discovery
│   └── health.rs        # Build environment diagnostics
├── aur/
│   ├── client.rs        # AUR RPC v5 client (search, info, provides, PKGBUILD fetch)
│   ├── resolver.rs      # Dependency DAG and topological build order
│   └── vcs.rs           # git ls-remote, PKGBUILD parsing, package filename parsing
├── repo/
│   ├── api.rs           # SimpleRepo REST client
│   └── uploader.rs      # SSH drop / REST deployment
├── builder/
│   ├── task.rs          # Build status and event types
│   └── manager.rs       # Queue, cancellation, build pipeline, logs, update checks
└── ui/
    ├── backend.rs       # QObject controller exposed to QML
    ├── models.rs        # List models
    ├── ansi.rs          # ANSI escape stripping
    └── qml/             # Kirigami pages and dialogs