Cyjan wip experiments

.cursor/environment.json

@@ -0,0 +1,4 @@
+{
+  "name": "simplybs",
+  "install": "./.cursor/install.sh"
+}

.cursor/install.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Idempotent environment bootstrap for simplybs.
+# Runs after the repository is checked out. The dev loop is just `go run .`,
+# so this only warms the Go module/build caches (which also validates the
+# toolchain). go and gh are provided by the base image.
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+echo "==> go version"
+go version
+
+echo "==> go mod download"
+go mod download
+
+echo "==> go build ./..."
+go build ./...
+
+# --- simplybs cache env vars --------------------------------------------
+# Make the cache settings available to every command on the box. Two places:
+#   * /etc/environment  -> picked up by PAM for all sessions (no shell
+#     expansion allowed, so we write resolved values).
+#   * /etc/profile.d/   -> sourced by login shells (keeps the dynamic form).
+configure_cache_env() {
+  local repo="mrcyjanek/simplybs_private"
+  local tag="v0-sbs-${USER}-$(go env GOOS)-$(go env GOARCH)"
+
+  echo "==> configuring SIMPLYBS_CACHE_* (tag=${tag}, repo=${repo})"
+
+  # /etc/environment: replace any prior entries, then append resolved values.
+  sudo touch /etc/environment
+  sudo sed -i '/^SIMPLYBS_CACHE_TAG=/d;/^SIMPLYBS_CACHE_REPO=/d' /etc/environment
+  printf 'SIMPLYBS_CACHE_TAG=%s\nSIMPLYBS_CACHE_REPO=%s\n' "$tag" "$repo" \
+    | sudo tee -a /etc/environment >/dev/null
+
+  # /etc/profile.d: dynamic exports for login shells (safe if go is missing).
+  sudo tee /etc/profile.d/simplybs-cache.sh >/dev/null <<'EOF'
+export SIMPLYBS_CACHE_REPO=mrcyjanek/simplybs_private
+if command -v go >/dev/null 2>&1; then
+  export SIMPLYBS_CACHE_TAG="v0-sbs-${USER}-$(go env GOOS)-$(go env GOARCH)"
+else
+  export SIMPLYBS_CACHE_TAG="v0-sbs-${USER}-linux-amd64"
+fi
+EOF
+}
+
+configure_cache_env
+
+echo "==> install complete"

.gitignore

@@ -1,2 +1,13 @@
 .buildlib
-*.tar.gz
+*.tar.gz
+.build
+ct-config
+.DS_Store
+logs
+
+*.log
+*.pid
+
+# Local Windows Cygwin+clang seed (keep README only)
+patches/native/_/windows_amd64_cygwin_clang/**
+!patches/native/_/windows_amd64_cygwin_clang/README.md

AGENTS.md

@@ -0,0 +1,104 @@
+# AGENTS.md
+
+`simplybs` is a cross-compilation build system written in Go. Package definitions
+live in `packages/*.json` (and `packages/native/*.json`); patches live in `patches/`.
+
+## Dev loop
+
+The tool is run directly from source — there is no separate build step for
+day-to-day work:
+
+```bash
+go run . <flags>
+```
+
+Common invocations:
+
+```bash
+go run . -host x86_64-linux-gnu -package zlib -list      # show a package + its dep tree
+go run . -host x86_64-linux-gnu -package zlib -download   # fetch sources (verifies sha256)
+go run . -host x86_64-linux-gnu -package zlib -build      # build a package (+ its deps)
+go run . -world -host <triplet> -build                    # build everything for a host
+```
+
+Supported host triplets are defined in `host/main.go` (e.g. `x86_64-linux-gnu`,
+`aarch64-linux-android`, `x86_64-w64-mingw32`, `aarch64-apple-darwin`).
+
+## rust-std (all platforms)
+
+`rust-std` builds the Rust standard library (`library/std`, stage 1) for a
+given `-host` triplet. **“All platforms”** means every entry in
+`host.SupportedHosts` — pass them as a comma-separated `-host` list:
+
+| `-host` (simplybs triplet) | Rust target (`$RUST_TRIPLET`) |
+| --- | --- |
+| `x86_64-linux-gnu` | `x86_64-unknown-linux-gnu` |
+| `aarch64-linux-gnu` | `aarch64-unknown-linux-gnu` |
+| `x86_64-w64-mingw32` | `x86_64-pc-windows-gnu` |
+| `aarch64-apple-darwin` | `aarch64-apple-darwin` |
+| `x86_64-apple-darwin` | `x86_64-apple-darwin` |
+| `aarch64-apple-ios` | `aarch64-apple-ios` |
+| `aarch64-apple-ios-simulator` | `aarch64-apple-ios-sim` |
+| `aarch64-linux-android` | `aarch64-linux-android` |
+| `x86_64-linux-android` | `x86_64-linux-android` |
+| `armv7a-linux-androideabi` | `armv7-linux-androideabi` |
+
+```bash
+go run . -host \
+  aarch64-apple-darwin,x86_64-apple-darwin,aarch64-apple-ios,aarch64-apple-ios-simulator,\
+  x86_64-w64-mingw32,x86_64-linux-gnu,aarch64-linux-gnu,aarch64-linux-android,\
+  x86_64-linux-android,armv7a-linux-androideabi \
+  -package rust-std -build
+```
+
+Each host build is independent (separate artifact under `.buildlib/<goos>_<goarch>/built/`).
+Requires `native/rust` (and the full native toolchain for that target) to already be built.
+
+## After editing packages — always run lint
+
+Whenever you add or change a package definition (new source, new git ref, bumped
+version, new dependency, etc.), regenerate metadata and validate with:
+
+```bash
+go run . -lint
+```
+
+`-lint` reformats every `packages/**.json`, checks for invalid/cyclic
+dependencies, and regenerates the checked-in `sources.json`. Commit the resulting
+`sources.json` changes together with your package edits.
+
+To generate git `download` entries from repos you've checked out locally:
+
+```bash
+go run ./cmd/gengitdeps        # prints download JSON to stdout
+```
+
+## Tests
+
+```bash
+go test ./...
+```
+
+Note: `host.TestHosts` is data-driven from `packages/native/_.json` and may
+already fail on a clean checkout — unrelated to environment setup.
+
+## Tooling
+
+`go` and `gh` are provided by the base image; there is nothing else to install.
+
+## Cache environment variables
+
+`install.sh` exports the shared cache settings box-wide (via `/etc/environment`
+and `/etc/profile.d/simplybs-cache.sh`), so every command sees them:
+
+- `SIMPLYBS_CACHE_TAG=v0-sbs-<user>-<goos>-<goarch>` (e.g. `v0-sbs-ubuntu-linux-amd64`)
+- `SIMPLYBS_CACHE_REPO=mrcyjanek/simplybs_private`
+
+When both are set, cache is enabled: `-build` auto-pulls needed artifacts and
+auto-pushes new/changed ones (see README). Explicit flags:
+
+```bash
+go run . -host x86_64-linux-gnu -package zlib -cache-pull
+go run . -host x86_64-linux-gnu -package zlib -build
+go run . -host x86_64-linux-gnu -package zlib -cache-push
+```

README.md

@@ -31,7 +31,7 @@ All package definitions live inside of this repo (this is going to change soon *
   // (soon) "source" indicationg a package that only contains source code (e.g. that was pulled using custom tools such as `repo` or are too complex for the built in system to handle)
   "type": "host",
   // where to find the source code
-  "download": {
+  "download": [{
     // "tar.gz" indicates a (who wouldn't have guessed) .tar.gz archive that will be extracted before build steps occur
     // "tar.bz2" indicares a (no way.. is it gonna be..) .tar.bz2 archive that will be extracted.. you get the drill
     // "git" indicates a Git repository being used
@@ -50,33 +50,79 @@ All package definitions live inside of this repo (this is going to change soon *
     // build all packages recursively but it won't inherit parent dependencies)
     "*-android*:native/android_ndk",
     // all is a magic keyword that works just like *
-    "all:native/make",
-    "all:native/libtool"
+    "*:native/make",
+    "*:native/libtool"
   ],
   "build": {
     "env": [
       // same logic as in dependencies applies, most variables are available during this phase (like $PREFIX or $HOST)
-      "all:CFLAGS=$CFLAGS -fPIC",
-      "all:config_opts=--prefix=$PREFIX --static",
-      "all:LIBTOOL=$PREFIX/native/bin/libtool",
-      "all:CROSS_PREFIX=$HOST-"
+      "*:CFLAGS=$CFLAGS -fPIC",
+      "*:config_opts=--prefix=$PREFIX --static",
+      "*:LIBTOOL=$NATIVEPREFIX/bin/libtool",
+      "*:CROSS_PREFIX=$HOST-"
     ],
     "steps": [
       // step-by-step instructions to build the package.
-      "all:./configure $config_opts",
-      "all:sed -i.bak s\\|^AR=.*\\|AR=$AR\\|g Makefile",
-      "all:sed -i.bak s\\|^ARFLAGS=.*\\|ARFLAGS=$ARFLAGS\\|g Makefile",
-      "all:make -j$NUM_CORES",
-      "all:make DESTDIR=$STAGING_DIR install"
+      "*:./configure $config_opts",
+      "*:sed -i.bak s\\|^AR=.*\\|AR=$AR\\|g Makefile",
+      "*:sed -i.bak s\\|^ARFLAGS=.*\\|ARFLAGS=$ARFLAGS\\|g Makefile",
+      "*:make -j$NUM_CORES",
+      "*:make DESTDIR=$STAGING_DIR install"
     ]
   }
 }
 ```
 
 ## Usage
 
-In order to build, let's say, `libtor` for armv7a-linux-androideabi you would run the following command (on either a Mac or Linux x64 device).
+In order to build, let's say, `tor` for armv7a-linux-androideabi you would run the following command (on either a Mac or Linux x64 device).
 
 ```
-$ go run . -host armv7a-linux-androideabi -package libtor -build
-```
+$ go run . -host armv7a-linux-androideabi -package tor -build
+```
+
+## Recommended / "official" cache settings
+
+```bash
+SIMPLYBS_ENV_DIR=/opt/_
+```
+
+## Build cache (GitHub Releases)
+
+Built package archives are content-addressed (`package-version-<8-char-hash>`).
+They can be shared via a rolling GitHub Release without downloading the whole
+cache on every run.
+
+Cache is enabled only when **both** required variables are set:
+
+| Variable | Required | Purpose |
+| --- | --- | --- |
+| `SIMPLYBS_CACHE_TAG` | yes | Release tag (e.g. `v0-sbs-$USER-$GOOS-$GOARCH`) |
+| `SIMPLYBS_CACHE_REPO` | yes | `owner/repo` hosting the release |
+| `SIMPLYBS_GH` | no | Optional path to `gh` |
+
+```bash
+# export SIMPLYBS_CACHE_TAG=v0-sbs-$USER-$(go env GOOS)-$(go env GOARCH)
+# export SIMPLYBS_CACHE_REPO=mrcyjanek/simplybs_private
+```
+
+With those set, `-build` auto-pulls the needed package tree up front, pulls
+per-package inside `EnsureBuilt` as a fallback, pushes each package after a
+successful local build, and runs a final tree push for anything still missing
+on the release:
+
+```bash
+go run . -host x86_64-linux-gnu -package zlib -build
+```
+
+Explicit pull/push still work:
+
+```bash
+go run . -host x86_64-linux-gnu -package zlib -cache-pull
+go run . -cache-push                                          # all local built/
+go run . -host x86_64-linux-gnu -package zlib -cache-push     # that package tree only
+```
+
+Push only uploads local artifacts that are not already on the release (a
+package rebuild with a new hash is a new asset name, so “changed” caches
+upload naturally).

builder/builder_darwin_arm64.go

@@ -1,17 +1 @@
 package builder
-
-var HostBuilder = Builder{
-	GlobalEnv: []string{
-		"all:HOST=aarch64-apple-darwin",
-		"all:TARGET=aarch64-apple-darwin",
-		"all:OSX_MIN_VERSION=10.15",
-		"all:CC=/usr/bin/clang",
-		"all:CXX=/usr/bin/clang++",
-		"all:AR=" + shellOutput("xcrun --sdk macosx --find ar"),
-		"all:RANLIB=" + shellOutput("xcrun --sdk macosx --find ranlib"),
-		"all:STRIP=" + shellOutput("xcrun --sdk macosx --find strip"),
-		"all:NM=" + shellOutput("xcrun --sdk macosx --find nm"),
-		"all:OTOOL=" + shellOutput("xcrun --sdk macosx --find otool"),
-		"all:INSTALL_NAME_TOOL=" + shellOutput("xcrun --sdk macosx --find install_name_tool"),
-	},
-}

builder/builder_linux_amd64.go

@@ -1,17 +1 @@
 package builder
-
-var HostBuilder = Builder{
-	GlobalEnv: []string{
-		"all:HOST=x86_64-linux-gnu",
-		"all:TARGET=x86_64-linux-gnu",
-		"all:CC=clang",
-		"all:CXX=clang++",
-		"all:AR=ar",
-		"all:RANLIB=ranlib",
-		"all:STRIP=strip",
-		"all:NM=nm",
-		"all:OTOOL=otool",
-		"all:AUTOMAKE=automake",
-		"all:INSTALL_NAME_TOOL=install_name_tool",
-	},
-}

builder/builder_linux_arm64.go

@@ -1,17 +1 @@
 package builder
-
-var HostBuilder = Builder{
-	GlobalEnv: []string{
-		"all:HOST=aarch64-linux-gnu",
-		"all:TARGET=aarch64-linux-gnu",
-		"all:CC=clang",
-		"all:CXX=clang++",
-		"all:AR=ar",
-		"all:RANLIB=ranlib",
-		"all:STRIP=strip",
-		"all:NM=nm",
-		"all:OTOOL=otool",
-		"all:AUTOMAKE=automake",
-		"all:INSTALL_NAME_TOOL=install_name_tool",
-	},
-}

builder/builder_windows_amd64.go

@@ -0,0 +1 @@
+package builder

builder/default.go

@@ -1,20 +1,28 @@
 package builder
 
 import (
-	"os/exec"
-	"strings"
+	"log"
+	"runtime"
 )
 
-type Builder struct {
-	GlobalEnv []string
+func GetName() string {
+	return runtime.GOOS + "_" + runtime.GOARCH
 }
 
-var Builders = []string{"darwin_arm64", "linux_amd64", "linux_arm64"}
-
-func shellOutput(cmd string) string {
-	output, err := exec.Command("bash", "-c", cmd).Output()
-	if err != nil {
-		return "$(" + cmd + ")"
+func NativeTriplet() string {
+	switch GetName() {
+	case "darwin_arm64":
+		return "aarch64-apple-darwin"
+	case "linux_amd64":
+		return "x86_64-linux-gnu"
+	case "linux_arm64":
+		return "aarch64-linux-gnu"
+	case "windows_amd64":
+		return "x86_64-pc-cygwin"
+	default:
+		log.Fatalf("unknown builder: %s", GetName())
+		return ""
 	}
-	return strings.TrimSpace(string(output))
 }
+
+var Builders = []string{"darwin_arm64", "linux_amd64", "linux_arm64", "windows_amd64"}