feat: update aws-lc to 5.1.0

Signed-off-by: sisungo <[email protected]>

hooks/__init__.py

@@ -1,9 +1,20 @@
 from typing import Callable, TypeAlias
 
-from . import autostrip
+from lib import pkgcomposer
 
+from . import autolink, autopatch, autostrip
+
+PreBuild: TypeAlias = Callable[[], None]
 PostBuild: TypeAlias = Callable[[], None]
+PostPack: TypeAlias = Callable[[pkgcomposer.PkgComposer], None]
 
-post_build: dict[str, PostBuild] = {
+pre_build: dict[str, PreBuild] = {
+    "autopatch": autopatch.autopatch,
+}
+
+post_build: dict[str, PostBuild] = {}
+
+post_pack: dict[str, PostPack] = {
+    "autolink": autolink.autolink,
     "autostrip": autostrip.autostrip,
 }

hooks/autolink.py

@@ -0,0 +1,31 @@
+import os
+
+from lib import arch, common, make, pkgcomposer
+
+
+def autolink(composer: pkgcomposer.PkgComposer):
+    os.chdir(composer.workdir + "/bundle/")
+
+    try:
+        for i in common.treedir("bin"):
+            if i.is_file():
+                make.link(f"bin/{i.name}", "/bin/" + i.name)
+    except Exception:
+        pass
+
+    try:
+        for i in common.treedir("lib"):
+            if i.is_file():
+                make.link(f"lib/{i.name}", "/lib/" + arch.get_target() + "/" + i.name)
+    except Exception:
+        pass
+
+    try:
+        for i in common.treedir("include"):
+            if i.is_file():
+                make.link(
+                    f"include/{i.name}",
+                    "/lib/" + arch.get_target() + "/include/" + i.name,
+                )
+    except Exception:
+        pass

hooks/autopatch.py

@@ -0,0 +1,29 @@
+import os
+import subprocess
+
+import lib.sources as sources
+
+
+def autopatch():
+    if not os.path.exists("patches"):
+        return
+
+    target_dir = os.getcwd() + "/target"
+    source_dir = sources.sources_dir_name()
+    patches_tag_file = f"{target_dir}/patches.tag"
+
+    patches_dir = os.getcwd() + "/patches"
+    patches = os.listdir(patches_dir)
+    patches.sort()
+
+    os.chdir(source_dir)
+    if not os.path.exists(patches_tag_file):
+        open(patches_tag_file, "+w").close()
+    for i in patches:
+        with open(patches_tag_file, "r") as file:
+            if i + "\n" in file.readlines():
+                continue
+        with open(f"{patches_dir}/{i}", "r") as file:
+            subprocess.run(["patch", "-p1"], stdin=file)
+        with open(patches_tag_file, "+a") as file:
+            file.write(i + "\n")

hooks/autostrip.py

@@ -1,2 +1,22 @@
-def autostrip():
-    pass
+import os
+import subprocess
+
+from lib import common
+
+strip = os.environ.get("STRIP", "strip")
+
+
+def _is_elf(filepath):
+    with open(filepath, "rb") as f:
+        return f.read(4) == b"\x7fELF"
+
+
+def autostrip(composer):
+    for ent in common.treedir(composer.workdir):
+        if not ent.is_file(follow_symlinks=False):
+            continue
+        if not (os.access(ent.path, os.X_OK) or ".so" in ent.name):
+            continue
+        if not _is_elf(ent.path):
+            continue
+        subprocess.run([strip, ent.path], check=True)

lib/arch.py

@@ -3,7 +3,18 @@ import os
 from . import packie
 
 all: dict[str, dict[str, str]] = {
-    "aarch64-semios-linux": {},
+    "aarch64-semios-linux": {
+        "CC": "clang -target aarch64-semios-linux-musl",
+        "CXX": "clang++ -target aarch64-semios-linux-musl",
+    },
+    "x86_64-semios-linux": {
+        "CC": "clang -target x86_64-semios-linux-musl",
+        "CXX": "clang++ -target x86_64-semios-linux-musl",
+    },
+    "riscv64-semios-linux": {
+        "CC": "clang -target riscv64-semios-linux-musl",
+        "CXX": "clang++ -target riscv64-semios-linux-musl",
+    },
 }
 _target: str = packie.host_arch()
 
@@ -15,5 +26,6 @@ def get_target():
 def set_target(arch: str):
     global _target
     _target = arch
-    for key, val in all[_target]:
-        os.environ[key] = val
+    for key in all[_target].keys():
+        if not os.environ.get(key):
+            os.environ[key] = all[_target][key]

lib/common.py

@@ -0,0 +1,21 @@
+import os
+import types
+
+
+def _wrap_treedir_entry(ent, prefix=""):
+    wrapped = types.SimpleNamespace()
+    wrapped.name = f"{prefix}/{ent.name}" if prefix else ent.name
+    wrapped.path = ent.path
+    wrapped.is_dir = ent.is_dir
+    wrapped.is_file = ent.is_file
+    wrapped.is_symlink = ent.is_symlink
+    return wrapped
+
+
+def treedir(root: str, prefix: str = ""):
+    with os.scandir(root) as entries:
+        for ent in entries:
+            wrapped = _wrap_treedir_entry(ent, prefix)
+            yield wrapped
+            if wrapped.is_dir(follow_symlinks=False):
+                yield from treedir(ent.path, wrapped.name)

lib/cpp.py

@@ -1,6 +1,8 @@
 import os
 import subprocess
 
+from lib.common import treedir
+
 from . import make as libmake
 from . import pkgcomposer
 
@@ -9,6 +11,23 @@ def configure(rem: list[str] = []):
     subprocess.run(["./configure"] + rem, check=True)
 
 
+def cmake(rem: list[str] = []):
+    source_dir = os.getcwd()
+    os.makedirs("../cmake_build", exist_ok=True)
+    os.chdir("../cmake_build")
+    subprocess.run(
+        [
+            "cmake",
+            "-GNinja",
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DCMAKE_INSTALL_PREFIX=/",
+            source_dir,
+        ]
+        + rem,
+        check=True,
+    )
+
+
 def make(rem: list[str] = []):
     subprocess.run(["make", f"-j{os.cpu_count()}"] + rem, check=True)
 
@@ -20,33 +39,79 @@ def make_install(rem: list[str] | None = None, chdir: bool = True):
         os.chdir("../cpp_install")
 
 
+def ninja(rem: list[str] = []):
+    subprocess.run(["ninja"] + rem, check=True)
+
+
+def ninja_install(rem: list[str] = [], chdir: bool = True):
+    if chdir:
+        os.environ["DESTDIR"] = os.getcwd() + "/../cpp_install"
+    subprocess.run(["ninja", "install"] + rem, check=True)
+    if chdir:
+        os.chdir(os.environ["DESTDIR"])
+
+
+def meson_setup(rem: list[str] = []):
+    subprocess.run(["meson", "setup", "_meson_build"] + rem, check=True)
+
+
+def meson_compile(rem: list[str] = []):
+    subprocess.run(["meson", "compile", "-C", "_meson_build"] + rem, check=True)
+
+
+def meson_install(rem: list[str] | None = None, chdir: bool = True):
+    default_rem = ["--destdir", f"{os.getcwd()}/../cpp_install"]
+    if not rem:
+        os.makedirs("../cpp_install", exist_ok=True)
+    subprocess.run(
+        ["meson", "install", "-C", "_meson_build"] + (rem or default_rem), check=True
+    )
+    if chdir:
+        os.chdir("../cpp_install")
+
+
 def _do_auto_pack(pc: pkgcomposer.PkgComposer, srcdir: str, dstdir: str, filter):
-    pc.makedir(dstdir)
-    with os.scandir(srcdir) as entries:
-        for ent in entries:
-            if filter(ent):
-                if ent.is_dir(follow_symlinks=False):
-                    pc.makedir(f"{dstdir}/{ent.name}")
-                elif ent.is_file(follow_symlinks=False):
-                    pc.addfile(ent.path, f"{dstdir}/{ent.name}")
-                elif ent.is_symlink() and not os.path.isabs(os.readlink(ent.path)):
+    if not os.path.exists(srcdir):
+        return
+    try:
+        pc.makedir(dstdir)
+    except Exception:
+        pass
+    for ent in treedir(srcdir):
+        if filter(ent):
+            if ent.is_file(follow_symlinks=False):
+                pc.makedirs(os.path.dirname(f"{dstdir}/{ent.name}"))
+                pc.addfile(ent.path, f"{dstdir}/{ent.name}")
+            elif ent.is_symlink() and not os.path.isabs(os.readlink(ent.path)):
+                try:
                     pc.addfile(ent.path, f"{dstdir}/{ent.name}")
+                except Exception:
+                    pass
+
+
+def _is_dev_file(ent) -> bool:
+    return (
+        ent.name.endswith(".o")
+        or ent.name.endswith(".a")
+        or ent.name.endswith(".la")
+        or ent.name.endswith(".pc")
+        or ent.name.endswith(".h")
+        or ent.name.endswith(".cmake")
+        or ent.name.endswith(".inc")
+        or ("Makefile" in ent.name)
+    )
 
 
 def _autopack_filter_lib(ent) -> bool:
-    if ent.name.endswith(".o") or ent.name.endswith(".a"):
-        return False
-    return True
+    return not _is_dev_file(ent)
 
 
 def _autopack_filter_bin(ent) -> bool:
-    return True
+    return os.access(ent.path, os.X_OK) and ent.is_file(follow_symlinks=False)
 
 
 def _autopack_filter_dev(ent):
-    if ".so" in ent.name:
-        return False
-    return True
+    return _is_dev_file(ent)
 
 
 def _auto_pack(profiles: list[str], pc: pkgcomposer.PkgComposer):

lib/make.py

@@ -1,5 +1,7 @@
 import typing
 
+from lib import arch
+
 from . import pkgcomposer, sources
 
 _key_global = "@global"
@@ -7,10 +9,17 @@ _key_version = "version"
 _key_description = "description"
 _key_on_pack = "on_pack"
 _key_arch_any = "arch_any"
+_key_links = "links"
+_key_dependencies = "dependencies"
+_key_provides = "provides"
 
 _current_pkgname: str = _key_global
 _pkginfo: dict[str, dict[str, typing.Any]] = {
-    _key_global: {},
+    _key_global: {
+        _key_links: [],
+        _key_dependencies: [],
+        _key_provides: [],
+    },
 }
 _supported_arch: typing.Callable[[str], bool] = lambda x: True
 _on_build: typing.Callable[[], None] | None = None
@@ -22,6 +31,9 @@ def package(s: str):
     global _current_pkgname
     _current_pkgname = s
     _pkginfo[s] = _pkginfo[_key_global].copy()
+    _pkginfo[s][_key_links] = _pkginfo[s][_key_links].copy()
+    _pkginfo[s][_key_dependencies] = _pkginfo[s][_key_dependencies].copy()
+    _pkginfo[s][_key_provides] = _pkginfo[s][_key_provides].copy()
 
 
 def version(s: str):
@@ -36,6 +48,30 @@ def arch_any():
     _pkginfo[_current_pkgname][_key_arch_any] = True
 
 
+def provide(s: str):
+    _pkginfo[_current_pkgname][_key_provides] += [
+        s.replace("@same-arch", f"@{arch.get_target()}")
+    ]
+
+
+def dep(s: str):
+    _pkginfo[_current_pkgname][_key_dependencies] += [
+        s.replace("(same)", "(same-version) @same-arch")
+        .replace("(same-version)", f"(={_pkginfo[_current_pkgname][_key_version]})")
+        .replace("@same-arch", f"@{arch.get_target()}")
+    ]
+
+
+def link(src: str, dst: str, default: bool = True):
+    _pkginfo[_current_pkgname][_key_links] += [
+        {
+            "from": src,
+            "to": dst,
+            "default": default,
+        }
+    ]
+
+
 def supported_arch(s: list[str] | typing.Callable[[str], bool]):
     global _supported_arch
     if isinstance(s, list):

lib/pkgcomposer.py

@@ -32,6 +32,9 @@ class PkgComposer:
     def makedir(self, name: str):
         os.mkdir(f"{self.workdir}/bundle/{name}")
 
+    def makedirs(self, name: str):
+        os.makedirs(f"{self.workdir}/bundle/{name}", exist_ok=True)
+
     def addfile(self, src: str, dst: str):
         shutil.copy2(src, f"{self.workdir}/bundle/{dst}", follow_symlinks=False)
 

lib/rust.py

@@ -22,6 +22,10 @@ def build(rem: list[str] = []):
     subprocess.run(cmdline)
 
 
+def artifacts_dir():
+    return f"target/{_rust_triple(arch.get_target())}/release"
+
+
 def _do_auto_pack(pc: pkgcomposer.PkgComposer, srcdir: str, dstdir: str, filter):
     pc.makedir(dstdir)
     with os.scandir(srcdir) as entries:
@@ -49,11 +53,10 @@ def _autopack_filter_bin(ent) -> bool:
 
 
 def _auto_pack(profiles: list[str], pc: pkgcomposer.PkgComposer):
-    target_dir = f"target/{_rust_triple(arch.get_target())}/release"
     if "lib" in profiles:
-        _do_auto_pack(pc, target_dir, "lib", _autopack_filter_lib)
+        _do_auto_pack(pc, artifacts_dir(), "lib", _autopack_filter_lib)
     if "bin" in profiles:
-        _do_auto_pack(pc, target_dir, "bin", _autopack_filter_bin)
+        _do_auto_pack(pc, artifacts_dir(), "bin", _autopack_filter_bin)
 
 
 def use_auto_pack(profiles: list[str]):

packages/airup/build_manifest.json

@@ -0,0 +1,9 @@
+{
+    "os_name": "\u001b[36;4mSemiOS\u001b[0m",
+    "config_dir": "/var/config/airup",
+    "service_dir": "/share/airup/services",
+    "milestone_dir": "/share/airup/milestones",
+    "runtime_dir": "/run/airup",
+    "env_vars": {},
+    "early_cmds": []
+}

packages/airup/pkgbuild.py

@@ -0,0 +1,30 @@
+import os
+import shutil
+
+from lib import rust
+from lib.make import *
+
+version("0.10.9")
+source_url("https://github.com/sisungo/airup/archive/refs/tags/v0.10.9.tar.gz")
+
+
+def build():
+    shutil.copy2("../../build_manifest.json", "build_manifest.json")
+    rust.build()
+
+
+on_build(build)
+
+
+def pack_airup(composer):
+    os.chdir(rust.artifacts_dir())
+    composer.makedir("bin")
+    composer.makedir("libexec")
+    composer.addfile("airup", "bin/airup")
+    composer.addfile("airupd", "bin/airupd")
+    composer.addfile("airup-fallback-logger", "libexec/airup-fallback-logger")
+
+
+package("airup")
+on_pack(pack_airup)
+dep("semi-libc @same-arch")

packages/aws-lc/pkgbuild.py

@@ -0,0 +1,50 @@
+import os
+
+import lib.cpp as cpp
+from lib.make import *
+
+version("5.1.0")
+source_url("https://github.com/aws/aws-lc/archive/refs/tags/v5.1.0.tar.gz")
+
+
+def build():
+    cpp.cmake(["-DBUILD_SHARED_LIBS=1"])
+    cpp.ninja()
+    cpp.ninja_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+
+def pack_libcrypto(composer):
+    composer.makedir("lib")
+    composer.addfile("lib/libcrypto.so", "lib/libcrypto.so")
+
+
+def pack_libssl(composer):
+    composer.makedir("lib")
+    composer.addfile("lib/libssl.so", "lib/libssl.so")
+
+
+package("aws-lc-libcrypto")
+on_pack(pack_libcrypto)
+dep("semi-libc @same-arch")
+provide("libcrypto@same-arch")
+
+package("aws-lc-libssl")
+on_pack(pack_libssl)
+dep("aws-lc-libcrypto (same)")
+provide("libssl@same-arch")
+
+package("aws-lc-tools")
+cpp.use_auto_pack(["bin"])
+dep("aws-lc-libcrypto (same)")
+dep("aws-lc-libssl (same)")
+
+package("aws-lc-dev")
+cpp.use_auto_pack(["dev"])
+dep("aws-lc-libcrypto (same)")
+dep("aws-lc-libssl (same)")
+provide("libcrypto-dev@same-arch")
+provide("libssl-dev@same-arch")

packages/bzip2/pkgbuild.py

@@ -0,0 +1,34 @@
+import os
+import shutil
+
+import lib.cpp as cpp
+from lib.make import *
+
+upstream_version = "1.0.8"
+
+version(f"{upstream_version}")
+source_url(f"https://sourceware.org/pub/bzip2/bzip2-{upstream_version}.tar.gz")
+
+
+def build():
+    cpp.make(["-f", "Makefile-libbz2_so"])
+    cpp.make_install(["PREFIX=../cpp_install"], chdir=False)
+    shutil.copy2(f"libbz2.so.{upstream_version}", "../cpp_install/lib/libbz2.so")
+    os.chdir("../cpp_install")
+
+
+on_build(build)
+
+package("libbzip2")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("bzip2")
+cpp.use_auto_pack(["bin"])
+dep("libbzip2 (same)")
+dep("sh")
+dep("coreutils")
+
+package("libbzip2-dev")
+cpp.use_auto_pack(["dev"])
+dep("libbzip2 (same)")

packages/coreutils/pkgbuild.py

@@ -3,14 +3,127 @@ from lib.make import *
 
 version("0.9.0")
 source_url("https://github.com/uutils/coreutils/archive/refs/tags/0.9.0.tar.gz")
+block_hook("autolink")
 
 
 def build():
-    rust.build()
+    rust.build(["--features", "unix"])
 
 
 on_build(build)
 
+functions = [
+    "[",
+    "arch",
+    "b2sum",
+    "base32",
+    "base64",
+    "basename",
+    "basenc",
+    "cat",
+    "chgrp",
+    "chmod",
+    "chown",
+    "chroot",
+    "cksum",
+    "comm",
+    "cp",
+    "csplit",
+    "cut",
+    "date",
+    "dd",
+    "df",
+    "dir",
+    "dircolors",
+    "dirname",
+    "du",
+    "echo",
+    "env",
+    "expand",
+    "expr",
+    "factor",
+    "false",
+    "fmt",
+    "fold",
+    "groups",
+    "head",
+    "hostid",
+    "hostname",
+    "id",
+    "install",
+    "join",
+    "kill",
+    "link",
+    "ln",
+    "logname",
+    "ls",
+    "md5sum",
+    "mkdir",
+    "mkfifo",
+    "mknod",
+    "mktemp",
+    "more",
+    "mv",
+    "nice",
+    "nl",
+    "nohup",
+    "nproc",
+    "numfmt",
+    "od",
+    "paste",
+    "pathchk",
+    "pinky",
+    "pr",
+    "printenv",
+    "printf",
+    "ptx",
+    "pwd",
+    "readlink",
+    "realpath",
+    "rm",
+    "rmdir",
+    "seq",
+    "sha1sum",
+    "sha224sum",
+    "sha256sum",
+    "sha384sum",
+    "sha512sum",
+    "shred",
+    "shuf",
+    "sleep",
+    "sort",
+    "split",
+    "stat",
+    "stdbuf",
+    "stty",
+    "sum",
+    "sync",
+    "tac",
+    "tail",
+    "tee",
+    "test",
+    "timeout",
+    "touch",
+    "tr",
+    "true",
+    "truncate",
+    "tsort",
+    "tty",
+    "uname",
+    "unexpand",
+    "uniq",
+    "unlink",
+    "uptime",
+    "users",
+    "vdir",
+    "wc",
+    "who",
+    "whoami",
+    "yes",
+]
 
 package("coreutils")
+for func in functions:
+    link(f"bin/coreutils", f"/bin/{func}")
 rust.use_auto_pack(["bin"])
+dep("semi-libc @same-arch")

packages/diffutils/pkgbuild.py

@@ -0,0 +1,20 @@
+import lib.rust as rust
+from lib.make import *
+
+version("0.5.0")
+source_url("https://github.com/uutils/diffutils/archive/refs/tags/v0.5.0.tar.gz")
+
+block_hook("autolink")
+
+
+def build():
+    rust.build()
+
+
+on_build(build)
+
+package("diffutils")
+rust.use_auto_pack(["bin"])
+link("bin/diffutils", "/bin/cmp")
+link("bin/diffutils", "/bin/diff")
+dep("semi-libc @same-arch")

packages/expat/pkgbuild.py

@@ -0,0 +1,31 @@
+import os
+
+import lib.cpp as cpp
+from lib.make import *
+
+version("2.8.1")
+source_url(
+    "https://github.com/libexpat/libexpat/releases/download/R_2_8_1/expat-2.8.1.tar.gz"
+)
+
+
+def build():
+    cpp.cmake()
+    cpp.ninja()
+    cpp.ninja_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+package("libexpat")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("libexpat-tools")
+cpp.use_auto_pack(["bin"])
+dep("libexpat (same)")
+
+package("libexpat-dev")
+cpp.use_auto_pack(["dev"])
+dep("libexpat (same)")

packages/findutils/pkgbuild.py

@@ -0,0 +1,17 @@
+import lib.rust as rust
+from lib.make import *
+
+version("0.9.0")
+source_url("https://github.com/uutils/findutils/archive/refs/tags/0.9.0.tar.gz")
+
+
+def build():
+    rust.build()
+
+
+on_build(build)
+
+
+package("findutils")
+rust.use_auto_pack(["bin"])
+dep("semi-libc @same-arch")

packages/gnu-make/patches/0001-musl-getenv.patch

@@ -0,0 +1,36 @@
+--- a/lib/fnmatch.c
++++ b/lib/fnmatch.c
+@@ -120,9 +120,6 @@
+ /* Avoid depending on library functions or files
+    whose names are inconsistent.  */
+
+-# if !defined _LIBC && !defined getenv
+-extern char *getenv ();
+-# endif
+
+ # ifndef errno
+ extern int errno;
+
+--- a/src/getopt.c
++++ b/src/getopt.c
+@@ -202,7 +202,7 @@ static char *posixly_correct;
+    whose names are inconsistent.  */
+ 
+ #ifndef getenv
+-extern char *getenv ();
++extern char *getenv (const char *);
+ #endif
+ 
+ static char *
+
+--- a/src/getopt.h
++++ b/src/getopt.h
+@@ -102,7 +102,7 @@ struct option
+    errors, only prototype getopt for the GNU C library.  */
+ extern int getopt (int argc, char *const *argv, const char *shortopts);
+ #else /* not __GNU_LIBRARY__ */
+-extern int getopt ();
++extern int getopt (int,  char * const*, const char *);
+ #endif /* __GNU_LIBRARY__ */
+ extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+                        const struct option *longopts, int *longind);

packages/gnu-make/pkgbuild.py

@@ -0,0 +1,18 @@
+import lib.cpp as cpp
+from lib.make import *
+
+version("4.4.1")
+source_url("https://ftp.gnu.org/gnu/make/make-4.4.1.tar.gz")
+
+
+def build():
+    cpp.configure(["--prefix=/"])
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("gnu-make")
+cpp.use_auto_pack(["bin"])
+dep("semi-libc @same-arch")

packages/iana-timezone/pkgbuild.py

@@ -0,0 +1,33 @@
+import os
+
+from lib import cpp
+from lib.make import *
+
+version("2026.4.22")
+source_url("https://data.iana.org/time-zones/releases/tzdb-2026b.tar.lz")
+
+
+def build():
+    cpp.make()
+    cpp.make_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+
+def pack_db(composer):
+    composer.makedir("share")
+    composer.add_dir("share/zoneinfo", "share/zoneinfo")
+
+
+package("iana-timezone-db")
+arch_any()
+on_pack(pack_db)
+
+package("iana-timezone-tools")
+dep("semi-libc @same-arch")
+cpp.use_auto_pack(["bin"])
+
+package("iana-timezone-dev")
+cpp.use_auto_pack(["dev"])

packages/icu4c/pkgbuild.py

@@ -0,0 +1,31 @@
+import os
+
+from lib import cpp
+from lib.make import *
+
+version("78.3")
+source_url(
+    "https://github.com/unicode-org/icu/releases/download/release-78.3/icu4c-78.3-sources.tgz"
+)
+
+
+def build():
+    os.chdir("source")
+    cpp.configure(["--enable-plugins", "--prefix=/"])
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("libicu4c")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("icu4c")
+cpp.use_auto_pack(["bin"])
+dep("libicu4c (same)")
+
+package("libicu4c-dev")
+cpp.use_auto_pack(["dev"])
+dep("libicu4c (same)")

packages/kmod/pkgbuild.py

@@ -0,0 +1,31 @@
+import os
+
+import lib.cpp as cpp
+from lib.make import *
+
+version("1.34")
+source_url("https://github.com/kmod-project/kmod/archive/refs/tags/v34.tar.gz")
+
+
+def build():
+    cpp.meson_setup()
+    cpp.meson_compile()
+    cpp.meson_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+package("libkmod")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+dep("libzstd @same-arch")
+dep("libcrypto @same-arch")
+
+package("kmod")
+cpp.use_auto_pack(["bin"])
+dep("libkmod (same)")
+
+package("libkmod-dev")
+cpp.use_auto_pack(["dev"])
+dep("libkmod (same)")

packages/libarchive/pkgbuild.py

@@ -0,0 +1,34 @@
+import lib.cpp as cpp
+from lib.make import *
+
+version("3.8.7")
+source_url(
+    "https://github.com/libarchive/libarchive/releases/download/v3.8.7/libarchive-3.8.7.tar.gz"
+)
+
+
+def build():
+    cpp.configure(["--prefix=/"])
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("libarchive")
+cpp.use_auto_pack(["lib"])
+dep("libcrypto@same-arch")
+dep("libzstd @same-arch")
+dep("libz @same-arch")
+dep("liblzma @same-arch")
+dep("semi-libc @same-arch")
+dep("libzstd @same-arch")
+
+package("libarchive-tools")
+cpp.use_auto_pack(["bin"])
+dep("libarchive (same)")
+provide("bsdtar")
+
+package("libarchive-dev")
+cpp.use_auto_pack(["dev"])
+dep("libarchive (same)")

packages/linenoise/pkgbuild.py

@@ -0,0 +1,17 @@
+from lib.make import *
+
+version("2.0")
+source_url("https://github.com/antirez/linenoise/archive/refs/tags/2.0.tar.gz")
+
+on_build(lambda: None)
+
+
+def pack_dev(composer):
+    composer.addfile("linenoise.c", "linenoise.c")
+    composer.addfile("linenoise.h", "linenoise.h")
+    composer.addfile("Makefile", "Makefile")
+
+
+package("linenoise-dev")
+arch_any()
+on_pack(pack_dev)

packages/linux/pkgbuild.py

@@ -0,0 +1,76 @@
+import os
+import shutil
+
+import lib.arch as arch
+import lib.cpp as cpp
+from lib.make import *
+
+upstream_version = "6.18.35"
+
+version(f"{upstream_version}")
+source_url(
+    f"https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-{upstream_version}.tar.xz"
+)
+
+
+def get_arch():
+    return arch.get_target().split("-")[0].replace("aarch64", "arm64")
+
+
+def build():
+    makeopts = [f"ARCH={get_arch()}", "LLVM=1"]
+    config_name = get_arch()
+    if os.environ.get("LINUX_VARIANT"):
+        config_name += "-" + os.environ["LINUX_VARIANT"]
+    config_file = "../../configs/config." + config_name
+
+    shutil.copy2(config_file, ".config")
+
+    cpp.make(makeopts + ["olddefconfig"])
+    cpp.make(makeopts)
+    cpp.make(["headers_install", "INSTALL_HDR_PATH=../kheaders_install"])
+    cpp.make(["install", "INSTALL_PATH=../kimage_install"])
+    cpp.make(
+        ["modules_install", "INSTALL_MOD_STRIP=1", "INSTALL_MOD_PATH=../kmod_install"]
+    )
+    os.remove(f"../kmod_install/lib/modules/{upstream_version}/build")
+
+
+on_build(build)
+
+base_name = "linux"
+if os.environ.get("LINUX_VARIANT"):
+    base_name += "-" + os.environ["LINUX_VARIANT"]
+
+
+def pack_linux_dev(composer):
+    composer.add_dir(
+        "../kheaders_install/include",
+        "include",
+    )
+
+
+package(f"{base_name}-dev")
+on_pack(pack_linux_dev)
+
+
+def pack_linux(composer):
+    try:
+        composer.addfile(f"../kimage_install/vmlinux-{upstream_version}", "vmlinux")
+    except Exception:
+        pass
+    try:
+        composer.addfile(f"../kimage_install/vmlinuz-{upstream_version}", "vmlinuz")
+    except Exception:
+        pass
+    try:
+        composer.addfile(
+            f"../kimage_install/System.map-{upstream_version}", "System.map"
+        )
+    except Exception:
+        pass
+    composer.add_dir(f"../kmod_install/lib/modules/{upstream_version}", "modules")
+
+
+package(f"{base_name}")
+on_pack(pack_linux)

packages/llvm-project/pkgbuild.py

@@ -0,0 +1,366 @@
+import os
+import subprocess
+
+import lib.cpp as cpp
+from lib import arch
+from lib.make import *
+
+version("22.1.7")
+source_url(
+    "https://github.com/llvm/llvm-project/releases/download/llvmorg-22.1.7/llvm-project-22.1.7.src.tar.xz"
+)
+
+
+def llvm_host_triple():
+    return arch.get_target().replace("-semios-linux", "-semios-linux-musl")
+
+
+def build():
+    subprocess.run(
+        [
+            "cmake",
+            "-G",
+            "Ninja",
+            "-S",
+            "llvm",
+            "-B",
+            "build",
+            "-DCMAKE_BUILD_TYPE=Release",
+            f"-DLLVM_DEFAULT_TARGET_TRIPLE={llvm_host_triple()}",
+            f"-DLLVM_HOST_TRIPLE={llvm_host_triple()}",
+            "-DLLVM_ENABLE_PROJECTS=clang;lldb;lld;bolt",
+            "-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi;libunwind;compiler-rt",
+            "-DLLVM_ENABLE_EH=ON",
+            "-DLLVM_ENABLE_RTTI=ON",
+            "-DCMAKE_INSTALL_PREFIX=/",
+            "-DLLVM_ENABLE_ASSERTIONS=OFF",
+            "-DLLVM_BUILD_LLVM_DYLIB=ON",
+            "-DLLVM_ENABLE_LIBCXX=ON",
+            "-DLLVM_ENABLE_LIBEDIT=ON",
+            "-DLLVM_LINK_LLVM_DYLIB=ON",
+            "-DLIBCXX_HAS_MUSL_LIBC=ON",
+            "-DCOMPILER_RT_BUILD_GWP_ASAN=OFF",
+        ],
+        check=True,
+    )
+    subprocess.run(["cmake", "--build", "build"], check=True)
+    os.environ["DESTDIR"] = os.getcwd() + "/cpp_install"
+    subprocess.run(["cmake", "--install", "build"], check=True)
+    os.chdir("cpp_install")
+
+
+on_build(build)
+
+
+def pack_runtime_lib(composer, files):
+    composer.makedir("lib")
+    for file in files:
+        composer.addfile(f"lib/{llvm_host_triple()}/{file}", f"lib/{file}")
+
+
+def pack_runtime_dev(composer, files: list[str]):
+    for file in files:
+        if file.startswith("lib/"):
+            composer.makedirs("lib")
+            composer.addfile(file.replace("lib/", f"lib/{llvm_host_triple()}/"), file)
+        elif file.startswith("include/"):
+            realpath = file.replace("include/", "usr/include/")
+            composer.makedirs(os.path.dirname(file))
+            if os.path.isfile(realpath):
+                composer.addfile(realpath, file)
+            elif os.path.isdir(realpath):
+                composer.add_dir(realpath, file)
+
+
+package("libunwind")
+on_pack(
+    lambda composer: pack_runtime_lib(
+        composer, ["libunwind.so.1.0", "libunwind.so.1", "libunwind.so"]
+    )
+)
+
+package("libunwind-dev")
+on_pack(
+    lambda composer: pack_runtime_dev(
+        composer,
+        [
+            "lib/libunwind.a",
+            "include/mach-o/compact_unwind_encoding.h",
+            "include/__libunwind_config.h",
+            "include/libunwind.h",
+            "include/libunwind.modulemap",
+            "include/unwind.h",
+            "include/unwind_arm_ehabi.h",
+            "include/unwind_itanium.h",
+        ],
+    )
+)
+
+package("libcxxabi")
+on_pack(
+    lambda composer: pack_runtime_lib(
+        composer, ["libc++abi.so", "libc++abi.so.1", "libc++abi.so.1.0"]
+    )
+)
+
+package("libcxxabi-dev")
+on_pack(lambda composer: pack_runtime_dev(composer, ["lib/libc++abi.a"]))
+
+
+package("libcxx")
+on_pack(
+    lambda composer: pack_runtime_lib(
+        composer, ["libc++.so", "libc++.so.1", "libc++.so.1.0"]
+    )
+)
+
+package("libcxx-dev")
+on_pack(
+    lambda composer: pack_runtime_dev(
+        composer,
+        [
+            "lib/libc++.a",
+            "lib/libc++experimental.a",
+            "lib/libc++.modules.json",
+            f"include/{llvm_host_triple()}/c++/v1",
+            "include/c++/v1",
+        ],
+    )
+)
+
+
+def pack_libllvm(composer):
+    LIBRARIES = [
+        "libLLVM.so.22.1",
+        "libLLVM.so",
+        "libLLVM-22.so",
+        "libLTO.so",
+        "libLTO.so.22.1",
+        "libRemarks.so",
+        "libRemarks.so.22.1",
+    ]
+    composer.makedir("lib")
+    for lib in LIBRARIES:
+        composer.addfile(f"lib/{lib}", f"lib/{lib}")
+
+
+package("libllvm")
+on_pack(pack_libllvm)
+
+
+def pack_llvm(composer):
+    BINARIES = [
+        "bugpoint",
+        "dsymutil",
+        "llc",
+        "lli",
+        "llvm-addr2line",
+        "llvm-ar",
+        "llvm-as",
+        "llvm-bcanalyzer",
+        "llvm-bitcode-strip",
+        "llvm-bolt",
+        "llvm-bolt-binary-analysis",
+        "llvm-bolt-heatmap",
+        "llvm-boltdiff",
+        "llvm-c-test",
+        "llvm-cas",
+        "llvm-cat",
+        "llvm-cfi-verify",
+        "llvm-cgdata",
+        "llvm-config",
+        "llvm-cov",
+        "llvm-ctxprof-util",
+        "llvm-cvtres",
+        "llvm-cxxdump",
+        "llvm-cxxfilt",
+        "llvm-cxxmap",
+        "llvm-debuginfo-analyzer",
+        "llvm-debuginfod",
+        "llvm-debuginfod-find",
+        "llvm-diff",
+        "llvm-dis",
+        "llvm-dlltool",
+        "llvm-dwarfdump",
+        "llvm-dwarfutil",
+        "llvm-dwp",
+        "llvm-exegesis",
+        "llvm-extract",
+        "llvm-gsymutil",
+        "llvm-ifs",
+        "llvm-install-name-tool",
+        "llvm-ir2vec",
+        "llvm-jitlink",
+        "llvm-lib",
+        "llvm-libtool-darwin",
+        "llvm-link",
+        "llvm-lipo",
+        "llvm-lto",
+        "llvm-lto2",
+        "llvm-mc",
+        "llvm-mca",
+        "llvm-ml",
+        "llvm-ml64",
+        "llvm-modextract",
+        "llvm-nm",
+        "llvm-objcopy",
+        "llvm-objdump",
+        "llvm-offload-binary",
+        "llvm-offload-wrapper",
+        "llvm-opt-report",
+        "llvm-otool",
+        "llvm-pdbutil",
+        "llvm-profdata",
+        "llvm-profgen",
+        "llvm-ranlib",
+        "llvm-rc",
+        "llvm-readelf",
+        "llvm-readobj",
+        "llvm-readtapi",
+        "llvm-reduce",
+        "llvm-remarkutil",
+        "llvm-rtdyld",
+        "llvm-sim",
+        "llvm-size",
+        "llvm-split",
+        "llvm-stress",
+        "llvm-strings",
+        "llvm-strip",
+        "llvm-symbolizer",
+        "llvm-tblgen",
+        "llvm-tli-checker",
+        "llvm-undname",
+        "llvm-windres",
+        "llvm-xray",
+        "merge-fdata",
+        "opt",
+        "perf2bolt",
+        "reduce-chunk-list",
+        "sancov",
+        "sanstats",
+        "verify-uselistorder",
+    ]
+    composer.makedir("bin")
+    for bin in BINARIES:
+        composer.addfile(f"usr/bin/{bin}", f"bin/{bin}")
+
+
+package("llvm")
+on_pack(pack_llvm)
+
+
+def pack_lld(composer):
+    BINARIES = ["lld", "lld-link", "ld.lld", "ld64.lld", "wasm-ld"]
+    composer.makedir("bin")
+    for bin in BINARIES:
+        composer.addfile(f"usr/bin/{bin}", f"bin/{bin}")
+
+
+package("lld")
+on_pack(pack_lld)
+
+
+def pack_liblldb(composer):
+    LIBRARIES = [
+        "liblldb.so",
+        "liblldb.so.22.1",
+        "liblldb.so.22.1.7",
+        "liblldbIntelFeatures.so",
+        "liblldbIntelFeatures.so.22.1",
+    ]
+    composer.makedir("lib")
+    for lib in LIBRARIES:
+        composer.addfile(f"lib/{lib}", f"lib/{lib}")
+
+
+package("liblldb")
+on_pack(pack_liblldb)
+
+
+def pack_lldb(composer):
+    BINARIES = [
+        "lldb",
+        "lldb-argdumper",
+        "lldb-dap",
+        "lldb-instr",
+        "lldb-mcp",
+        "lldb-server",
+        "yaml2macho-core",
+    ]
+    composer.makedir("bin")
+    for bin in BINARIES:
+        composer.addfile(f"bin/{bin}", f"bin/{bin}")
+
+
+package("lldb")
+on_pack(pack_lldb)
+
+
+def pack_libclang(composer):
+    LIBRARIES = [
+        "libclang.so",
+        "libclang-cpp.so",
+        "libclang-cpp.so.22.1",
+        "libclang.so.22.1",
+        "libclang.so.22.1.7",
+    ]
+    composer.makedir("lib")
+    for lib in LIBRARIES:
+        composer.addfile(f"lib/{lib}", f"lib/{lib}")
+
+
+package("libclang")
+on_pack(pack_libclang)
+
+
+def pack_clang(composer):
+    BINARIES = [
+        "clang",
+        "clang++",
+        "clang-22",
+        "clang-check",
+        "clang-cl",
+        "clang-cpp",
+        "clang-extdef-mapping",
+        "clang-format",
+        "clang-installapi",
+        "clang-linker-wrapper",
+        "clang-nvlink-wrapper",
+        "clang-offload-bundler",
+        "clang-offload-packager",
+        "clang-refactor",
+        "clang-repl",
+        "clang-scan-deps",
+        "clang-sycl-linker",
+        "clang-tblgen",
+        "diagtool",
+        "git-clang-format",
+        "hmaptool",
+        "intercept-build",
+        "amdgpu-arch",
+        "c-index-test",
+        "analyze-build",
+        "nvptx-arch",
+        "offload-arch",
+        "scan-build",
+        "scan-build-py",
+        "scan-view",
+    ]
+    LIBEXEC = [
+        "analyze-c++",
+        "analyze-cc",
+        "c++-analyzer",
+        "ccc-analyzer",
+        "intercept-c++",
+        "intercept-cc",
+    ]
+    composer.makedir("bin")
+    for bin in BINARIES:
+        composer.addfile(f"usr/bin/{bin}", f"bin/{bin}")
+    composer.makedir("libexec")
+    for libexec in LIBEXEC:
+        composer.addfile(f"usr/libexec/{libexec}", f"libexec/{libexec}")
+
+
+package("clang")
+on_pack(pack_clang)

packages/mandoc/pkgbuild.py

@@ -0,0 +1,22 @@
+import os
+import subprocess
+
+from lib import cpp
+from lib.make import *
+
+version("1.14.6")
+source_url("https://mandoc.bsd.lv/snapshots/mandoc-1.14.6.tar.gz")
+
+
+def build():
+    cpp.configure()
+    cpp.make([f"CC={os.environ['CC']}"])
+    cpp.make_install()
+    os.chdir("usr/local")
+    subprocess.run(["sh", "-c", "chmod +w bin/* sbin/*"], check=True)
+
+
+on_build(build)
+
+package("mandoc")
+cpp.use_auto_pack(["bin"])

packages/mksh/pkgbuild.py

@@ -0,0 +1,25 @@
+import os
+
+from lib.make import *
+
+version("1.59.2")
+source_git("https://github.com/mirabilos/mksh-cvs2git.git", "mksh-R59c")
+
+
+def build():
+    os.system("sh ./Build.sh")
+
+
+on_build(build)
+
+
+def pack_mksh(composer):
+    composer.makedir("bin")
+    composer.addfile("mksh", "bin/mksh")
+
+
+package("mksh")
+on_pack(pack_mksh)
+dep("semi-libc @same-arch")
+provide("sh")
+link("bin/mksh", "/bin/sh")

packages/ncurses/pkgbuild.py

@@ -0,0 +1,62 @@
+import os
+
+from lib import cpp
+from lib.make import *
+
+version("6.6")
+source_url("https://invisible-island.net/archives/ncurses/ncurses-6.6.tar.gz")
+
+
+def build():
+    cpp.configure(
+        [
+            "--prefix=/",
+            "--enable-pc-files",
+            "--with-shared",
+            "--with-terminfo-dirs=/share/terminfo",
+            "--enable-symlinks",
+            "--enable-sp-funcs",
+            "--enable-ext-colors",
+            "--enable-rgb-color",
+            "--enable-ext-mouse",
+            "--enable-ext-putwin",
+            "--enable-no-padding",
+            "--enable-sigwinch",
+            "--enable-tcap-names",
+            "--with-pthread",
+            "--enable-pthreads-eintr",
+            "--enable-weak-symbols",
+            "--enable-reentrant",
+            "--without-develop",
+        ]
+    )
+    cpp.make()
+    cpp.make_install()
+    os.unlink("lib/terminfo")
+    os.rename("usr/lib/pkgconfig", "lib/pkgconfig")
+
+
+on_build(build)
+
+package("libncurses")
+dep("semi-libc @same-arch")
+cpp.use_auto_pack(["lib"])
+
+package("ncurses-tools")
+dep("libncurses (same)")
+cpp.use_auto_pack(["bin"])
+
+package("libncurses-dev")
+dep("libncurses (same)")
+cpp.use_auto_pack(["dev"])
+
+
+def pack_terminfo(composer):
+    composer.makedir("share")
+    composer.add_dir("share/tabset", "share/tabset")
+    composer.add_dir("share/terminfo", "share/terminfo")
+
+
+package("ncurses-terminfo")
+arch_any()
+on_pack(pack_terminfo)

packages/nextvi/pkgbuild.py

@@ -0,0 +1,27 @@
+import os
+import subprocess
+
+from lib import cpp
+from lib.make import *
+
+version("5.3")
+source_url("https://github.com/kyx0r/nextvi/archive/refs/tags/5.3.tar.gz")
+
+
+def build():
+    os.environ["PREFIX"] = "/"
+    subprocess.run(["./cbuild.sh"])
+
+
+on_build(build)
+
+
+def pack(composer):
+    composer.makedir("bin")
+    composer.addfile("vi", "bin/vi")
+
+
+package("nextvi")
+on_pack(pack)
+dep("semi-libc @same-arch")
+provide("vi")

packages/nghttp2/pkgbuild.py

@@ -0,0 +1,27 @@
+import os
+
+from lib import cpp
+from lib.make import *
+
+version("1.69.0")
+source_url(
+    "https://github.com/nghttp2/nghttp2/releases/download/v1.69.0/nghttp2-1.69.0.tar.gz"
+)
+
+
+def build():
+    cpp.cmake()
+    cpp.ninja()
+    cpp.ninja_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+package("libnghttp2")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("libnghttp2-dev")
+cpp.use_auto_pack(["dev"])
+dep("libnghttp2 (same)")

packages/ninja/pkgbuild.py

@@ -0,0 +1,24 @@
+import os
+
+from lib.make import *
+
+version("1.13.2")
+source_url("https://github.com/ninja-build/ninja/archive/refs/tags/v1.13.2.tar.gz")
+
+
+def build():
+    os.system("./configure.py --bootstrap")
+
+
+on_build(build)
+
+
+def pack_ninja(composer):
+    composer.makedir("bin")
+    composer.addfile("ninja", "bin/ninja")
+
+
+package("ninja")
+on_pack(pack_ninja)
+dep("semi-libc @same-arch")
+dep("libcxx @same-arch")

packages/openssh/pkgbuild.py

@@ -0,0 +1,55 @@
+from lib import cpp
+from lib.make import *
+
+version("10.3.1")
+source_url("https://cdn.openbsd.org/pub/OpenBSD/OpenSSH/portable/openssh-10.3p1.tar.gz")
+
+
+def build():
+    cpp.configure(
+        [
+            "--prefix=/",
+            "--sysconfdir=/var/config",
+            "--disable-etc-default-login",
+            "--with-linux-memlock-onfault",
+            "--without-shadow",
+            "--with-pam",
+            "--with-pie",
+        ]
+    )
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+
+def pack_client(composer):
+    composer.add_dir("bin", "bin")
+    composer.makedir("libexec")
+    composer.addfile("libexec/ssh-sk-helper", "libexec/ssh-sk-helper")
+    composer.addfile("libexec/ssh-pkcs11-helper", "libexec/ssh-pkcs11-helper")
+
+
+package("openssh-client")
+dep("semi-libc @same-arch")
+dep("libcrypto @same-arch")
+dep("libz @same-arch")
+on_pack(pack_client)
+provide("ssh")
+
+
+def pack_server(composer):
+    composer.makedir("bin")
+    composer.addfile("sbin/sshd", "bin/sshd")
+    composer.makedir("libexec")
+    composer.addfile("libexec/sftp-server", "libexec/sftp-server")
+    composer.addfile("libexec/ssh-keysign", "libexec/ssh-keysign")
+    composer.addfile("libexec/sshd-auth", "libexec/sshd-auth")
+    composer.addfile("libexec/sshd-session", "libexec/sshd-session")
+
+
+package("openssh-server")
+dep("openssh-client (same)")
+dep("libpam @same-arch")
+on_pack(pack_server)

packages/pkgconf/pkgbuild.py

@@ -0,0 +1,34 @@
+import lib.cpp as cpp
+from lib import arch
+from lib.make import *
+
+version("2.5.1")
+source_url("https://distfiles.ariadne.space/pkgconf/pkgconf-2.5.1.tar.gz")
+
+
+def build():
+    cpp.configure(
+        [
+            "--prefix=/",
+            f"--with-system-libdir=/lib:/lib/{arch.get_target()}",
+            f"--with-system-includedir=/lib/{arch.get_target()}/include",
+            f"--with-pkg-config-dir=/lib/{arch.get_target()}/pkgconfig",
+        ]
+    )
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("libpkgconf")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("pkgconf")
+cpp.use_auto_pack(["bin"])
+dep("libpkgconf (same)")
+
+package("libpkgconf-dev")
+cpp.use_auto_pack(["dev"])
+dep("libpkgconf (same)")

packages/python/pkgbuild.py

@@ -0,0 +1,100 @@
+import os
+import shutil
+import subprocess
+
+from lib import arch, cpp
+from lib.make import *
+
+VERSION_BASE = "3.14"
+VERSION_APPEND = "6"
+
+VERSION_FULL = f"{VERSION_BASE}.{VERSION_APPEND}"
+
+version(VERSION_FULL)
+source_url(
+    f"https://www.python.org/ftp/python/{VERSION_FULL}/Python-{VERSION_FULL}.tar.xz"
+)
+
+
+def build():
+    cpp.configure(
+        [
+            "--prefix=/",
+            f"--with-platlibdir=lib/{arch.get_target()}",
+            "--enable-shared",
+            "--enable-safety",
+            "--enable-optimizations",
+            "--enable-loadable-sqlite-extensions",
+            "--enable-ipv6",
+            "--with-lto=thin",
+            "--with-tzpath=/share/zoneinfo",
+            "--with-system-expat",
+            "--with-system-libmpdec",
+            "--with-readline=editline",
+            "--with-tail-call-interp",
+            "--without-ensurepip",
+        ]
+    )
+    cpp.make()
+    try:
+        shutil.rmtree("../cpp_install")
+    except:
+        pass
+    cpp.make_install()
+    os.rename(
+        f"lib/{arch.get_target()}/python{VERSION_BASE}", f"lib/python{VERSION_BASE}"
+    )
+    os.rmdir(f"lib/{arch.get_target()}")
+
+
+on_build(build)
+
+
+def python_config_target():
+    return arch.get_target().replace("-semios-linux", "-linux-musl")
+
+
+def pack_libpython(composer):
+    # Pack the standard library
+    pystdpath = f"{composer.workdir}/bundle/lib/python{VERSION_BASE}"
+    composer.makedir("lib")
+    composer.add_dir(f"lib/python{VERSION_BASE}", f"lib/python{VERSION_BASE}")
+    shutil.rmtree(f"{pystdpath}/test")
+    os.remove(
+        f"{pystdpath}/config-{VERSION_BASE}-{python_config_target()}/libpython{VERSION_BASE}.a"
+    )
+    os.remove(f"{pystdpath}/config-{VERSION_BASE}-{python_config_target()}/python.o")
+
+    # Pack native libraries
+    composer.addfile(
+        f"lib/libpython{VERSION_BASE}.so", f"lib/libpython{VERSION_BASE}.so"
+    )
+    composer.addfile(
+        f"lib/libpython{VERSION_BASE}.so.1.0", f"lib/libpython{VERSION_BASE}.so.1.0"
+    )
+    composer.addfile("lib/libpython3.so", "lib/libpython3.so")
+
+
+package("libpython")
+dep("semi-libc @same-arch")
+on_pack(pack_libpython)
+
+package("python")
+dep("libpython (same)")
+cpp.use_auto_pack(["bin"])
+link(f"bin/python{VERSION_BASE}", "/bin/python3")
+link(f"bin/python{VERSION_BASE}", "/bin/python")
+
+package("libpython-dev")
+dep("libpython (same)")
+cpp.use_auto_pack(["dev"])
+
+
+def pack_test(composer):
+    composer.makedirs(f"lib/python{VERSION_BASE}")
+    composer.add_dir(f"lib/python{VERSION_BASE}/test", f"lib/python{VERSION_BASE}/test")
+
+
+package("python-test")
+dep("libpython (same)")
+on_pack(pack_test)

packages/ripgrep/pkgbuild.py

@@ -0,0 +1,16 @@
+from lib import rust
+from lib.make import *
+
+version("15.1.0")
+source_url("https://github.com/BurntSushi/ripgrep/archive/refs/tags/15.1.0.tar.gz")
+
+
+def build():
+    rust.build()
+
+
+on_build(build)
+
+package("ripgrep")
+dep("semi-libc @same-arch")
+rust.use_auto_pack(["bin"])

packages/sed/pkgbuild.py

@@ -0,0 +1,16 @@
+from lib import rust
+from lib.make import *
+
+version("0.1.1")
+source_url("https://github.com/uutils/sed/releases/download/0.1.1/source.tar.gz")
+
+
+def build():
+    rust.build()
+
+
+on_build(build)
+
+package("sed")
+dep("semi-libc @same-arch")
+rust.use_auto_pack(["bin"])

packages/semi-libc/pkgbuild.py

@@ -1,9 +1,10 @@
+import lib.arch as arch
 from lib.cpp import *
 from lib.make import *
 
-source_url("https://gitea.semilabs.org/semios/semi-libc/archive/v1.2.5.tar.gz")
-version("1.2.5")
 
+version("1.2.6")
+source_url("https://gitea.semilabs.org/semios/semi-libc/archive/v1.2.6.tar.gz")
 
 def build():
     configure(["--prefix=/"])
@@ -14,8 +15,14 @@ def build():
 on_build(build)
 
 
+def musl_target():
+    return arch.get_target().split("-")[0]
+
+
 package("semi-libc")
 use_auto_pack(["lib"])
+link("lib/libc.so", f"/lib/ld-musl-{musl_target()}.so.1")
 
 package("semi-libc-dev")
 use_auto_pack(["dev"])
+dep("semi-libc (same)")

packages/sqlite/pkgbuild.py

@@ -0,0 +1,33 @@
+import lib.cpp as cpp
+from lib.make import *
+
+version("3.53.2")
+source_url("https://sqlite.org/2026/sqlite-autoconf-3530200.tar.gz")
+
+
+def build():
+    cpp.configure(
+        [
+            "--prefix=/",
+            "--all",
+            "--with-linenoise=/pkg/linenoise-dev=2.0@any",
+            "--icu-collations",
+        ]
+    )
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("libsqlite")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("sqlite")
+cpp.use_auto_pack(["bin"])
+dep("libsqlite (same)")
+
+package("libsqlite-dev")
+cpp.use_auto_pack(["dev"])
+dep("libsqlite (same)")

packages/xz/pkgbuild.py

@@ -0,0 +1,28 @@
+from lib import cpp
+from lib.make import *
+
+version("5.8.3")
+source_url(
+    "https://github.com/tukaani-project/xz/releases/download/v5.8.3/xz-5.8.3.tar.gz"
+)
+
+
+def build():
+    cpp.configure(["--prefix=/"])
+    cpp.make()
+    cpp.make_install()
+
+
+on_build(build)
+
+package("liblzma")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("xz")
+cpp.use_auto_pack(["bin"])
+dep("liblzma (same)")
+
+package("liblzma-dev")
+cpp.use_auto_pack(["dev"])
+dep("liblzma (same)")

packages/zlib-ng/pkgbuild.py

@@ -0,0 +1,31 @@
+import os
+
+import lib.cpp as cpp
+from lib.make import *
+
+version("2.3.3")
+source_url("https://github.com/zlib-ng/zlib-ng/archive/refs/tags/2.3.3.tar.gz")
+
+
+def build():
+    cpp.cmake(["-DZLIB_COMPAT=ON", "-DINSTALL_UTILS=ON"])
+    cpp.ninja()
+    cpp.ninja_install()
+    os.chdir("usr")
+
+
+on_build(build)
+
+package("libz-ng")
+cpp.use_auto_pack(["lib"])
+provide("libz@same-arch")
+dep("semi-libc @same-arch")
+
+package("zlib-ng-tools")
+cpp.use_auto_pack(["bin"])
+dep("libz-ng (same)")
+
+package("libz-ng-dev")
+cpp.use_auto_pack(["dev"])
+dep("libz-ng (same)")
+provide("libz-dev@same-arch")

packages/zstd/pkgbuild.py

@@ -0,0 +1,30 @@
+import os
+
+import lib.cpp as cpp
+from lib.make import *
+
+version("1.5.7")
+source_url(
+    "https://github.com/facebook/zstd/releases/download/v1.5.7/zstd-1.5.7.tar.gz"
+)
+
+
+def build():
+    cpp.make(["HAVE_ZLIB=0", "HAVE_LZMA=0", "HAVE_LZ4=0"])
+    cpp.make_install()
+    os.chdir("usr/local")
+
+
+on_build(build)
+
+package("libzstd")
+cpp.use_auto_pack(["lib"])
+dep("semi-libc @same-arch")
+
+package("zstd")
+cpp.use_auto_pack(["bin"])
+dep("libzstd (same)")
+
+package("libzstd-dev")
+cpp.use_auto_pack(["dev"])
+dep("libzstd (same)")

x.py

@@ -3,6 +3,7 @@ import importlib
 import os
 import shutil
 import sys
+import typing
 
 import hooks
 import lib.arch
@@ -19,8 +20,13 @@ argparser = argparse.ArgumentParser(
 argparser.add_argument(
     "--target", type=str, help="Target architecture to build the package for"
 )
-argparser.add_argument("--build", type=str, help="Package to build")
-argparser.add_argument("--clean", type=str, help="Package to clean")
+subparsers = argparser.add_subparsers(dest="subcommand")
+parser_build = subparsers.add_parser("build")
+parser_build.add_argument("BUILD_PKGNAME")
+parser_clean = subparsers.add_parser("clean")
+parser_clean.add_argument("CLEAN_PKGNAME")
+parser_list = subparsers.add_parser("list")
+parser_list.add_argument("ITEM", choices=("all", "built", "new"))
 args = argparser.parse_args()
 
 if args.target:
@@ -29,6 +35,18 @@ else:
     lib.arch.set_target(lib.arch.get_target())
 
 
+def run_hooks(map, arg: typing.Any = None):
+    current_dir = os.getcwd()
+    for n in map.keys():
+        if n in lib.make._blocked_hooks:
+            continue
+        if arg:
+            map[n](arg)
+        else:
+            map[n]()
+        os.chdir(current_dir)
+
+
 def run_build_package(package: str):
     try:
         os.chdir(f"packages/{package}")
@@ -46,6 +64,9 @@ def run_build_package(package: str):
         print(f"Architecture {lib.arch.get_target()} is not supported for this package")
         exit(1)
 
+    # Run `pre_build` hooks
+    run_hooks(hooks.pre_build)
+
     # Build the package
     if lib.make._on_build:
         os.chdir(lib.sources.sources_dir_name())
@@ -54,13 +75,12 @@ def run_build_package(package: str):
         print("on_build(): Not defined")
 
     # Run `post_build` hooks
-    for n in hooks.post_build.keys():
-        if n in lib.make._blocked_hooks:
-            continue
-        hooks.post_build[n]()
+    run_hooks(hooks.post_build)
 
     # Pack packages
     for pkgname in lib.make._pkginfo.keys():
+        lib.make._current_pkgname = pkgname
+
         if pkgname == lib.make._key_global:
             continue
 
@@ -80,14 +100,24 @@ def run_build_package(package: str):
 
         pkginfo[lib.make._key_on_pack](composer)
 
+        # Run post_pack hooks
+        run_hooks(hooks.post_pack, composer)
+
         manifest = {
             "name": pkgname,
             "version": pkgver,
             "arch": pkgarch,
+            "links": pkginfo[lib.make._key_links],
+            "dependencies": pkginfo[lib.make._key_dependencies],
+            "provides": pkginfo[lib.make._key_provides],
         }
         composer.write_manifest(manifest)
         composer.compose()
 
+    # Build success
+    with open(f"{package_dir}/target/build-ok.tag", "wt+") as file:
+        file.write("OK")
+
 
 def run_clean_package(package: str):
     try:
@@ -96,7 +126,37 @@ def run_clean_package(package: str):
         pass
 
 
-if args.build:
-    run_build_package(args.build)
-if args.clean:
-    run_clean_package(args.clean)
+def run_list(item):
+    if item == "all":
+        for i in os.listdir("packages"):
+            if i.startswith("."):
+                continue
+            print(i)
+    elif item == "built":
+        for i in os.listdir("packages"):
+            if i.startswith("."):
+                continue
+            if os.path.exists(f"packages/{i}/target/build-ok.tag"):
+                print(i)
+    elif item == "new":
+        for i in os.listdir("packages"):
+            if i.startswith("."):
+                continue
+            try:
+                pkgbuild_mtime = os.path.getmtime(f"packages/{i}/pkgbuild.py")
+                target_mtime = os.path.getmtime(f"packages/{i}/target/build-ok.tag")
+                if target_mtime < pkgbuild_mtime:
+                    print(i)
+            except Exception:
+                print(i)
+
+
+if args.subcommand == "build":
+    run_build_package(args.BUILD_PKGNAME)
+elif args.subcommand == "clean":
+    run_clean_package(args.CLEAN_PKGNAME)
+elif args.subcommand == "list":
+    run_list(args.ITEM)
+else:
+    print("error: no action specified", file=sys.stderr)
+    exit(1)