So I have a few duct-taped scripts or software I made for my own needs, for which I’ve made PKGBUILD so that I can manage them pacman the package manager. And I’d like to host them somewhere so that I can easily install them on other machines.

The AUR certainly won’t accept such “packages”:

Make sure the package you want to upload is useful. Will anyone else want to use this package? Is it extremely specialized? If more than a few people would find this package useful, it is appropriate for submission.

The AUR and official repositories are intended for packages which install general software and software-related content, including one or more of the following: executable(s); configuration file(s); online or offline documentation for specific software or the Arch Linux distribution as a whole; media intended to be used directly by softwar ¹

# simple setup with paru

So I went on searching “selfhosted AUR repo” and found this:
https://github.com/Morganamilo/paru/issues/719#issuecomment-1236192075

The paru AUR helper supports a custom source, you simply need this in your paru.conf

[REPONAME]
Url = https://<URL TO MY PACKAGE REPO>

# if you don't provide .SRCINFO yourself,
# you may need GenerateSrcinfo option
GenerateSrcinfo

and a (git) repository that looks like this:

repo
    |
    +- pkg_1
    |    |- PKGBUILD
    |    |- .SRCINFO
    +- pkg_2
    |    |- PKGBUILD
    |    |- .SRCINFO
    +- pkg_3
         |- PKGBUILD
         |- .SRCINFO

run $ paru -Sya to synchronize the source. And you can install your packages with $ paru -S pkg_2

# the problem: VCS

So far so good, but the packages are already individually version controlled. That is, in the above example, I already have 3x git repositories for the packages. Now the problem is how can I merge 3 reposotories into one without losing too much sanity?

take 1. just fucking copy paste
I can simply have a script like this: this is very simple but you will lose all VCS history in each package repo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#!/usr/bin/bash

PKGS = (
    "local-path-to-pkg-1"
    "local-path-to-pkg-2"
    "local-path-to-pkg-3"
)

for pkg in "${PKGS[@]}"; do
    cp -r $pkg ./
    # SNIP: cleanup e.g. pkg/.git
    # and create a git commit
done

# SNIP git push

take 2. git submodules, but does it work?
this would be the easiest way, if it works.

You add the packages as git submodules and hopefully paru can resolve it. But I don’t think it does (to be tested).

Even it works, there is a downside: you have to push all the package repos to remote as well so that the submodules can be resolved: if I understand git submodles correctly, you don’t push the actual content of the submodules to the remote, you simply specify theier URLs, names, branch/commit refs, etc.

final take: some scripts
I’d like to invest some time writing a script to preserve my sanity:

So it does roughly these:

• define a list of packages (paths to local git repos)
• keep a json database of currently tracked version (commit hash) of each packages present in this repo
• sanity check:
  • does the list have duplicate package name?
  • is directory for target package clean (does not have uncommited changes)?
  • does my tracked version exist in the target commit history? (make sure our database is not corrupted)
• synchronize the package source: from many git repos into one git repo: for each package, the script will checkout the content and compile a git commit message from the target repo; git add and create a commit (with proper message)
• git push

what’s missing:

• support for remote package sources
• support for specifying branches
• support for on-file-system packages (that are not git-tracked)
• support for adhoc packages (that are directly commited to this repo)

# thoughts: am I solving an X-Y problem?

yes :-(
but writting this script is a nice practice.