From dc059db6db67abad249fa153593a89a45fa37486 Mon Sep 17 00:00:00 2001
From: srdusr <99972264+srdusr@users.noreply.github.com>
Date: Mon, 25 May 2026 23:13:00 +0200
Subject: Version flag, Makefile, and honest cross-platform documentation

Neither binary had a -version flag - a basic expectation for any CLI
tool, and useful for anyone reporting a bug ("which build is this").
internal/version holds Version/Commit/Date, set via -ldflags "-X
mitmux/internal/version.X=..." at build time and defaulting to "dev"
for a plain `go build` with no ldflags, so -version is never blank or
misleading about whether a given binary is a tagged release or a local
build. Both mitmux and mitmuxd gained a -version flag that prints it
and exits.

Makefile: `make build` (both binaries for the current platform, version
info from `git describe`), `make test` (the same build/vet/gofmt/test
checks expected before every commit here), `make install` (a thin
wrapper over `go install`, respecting GOBIN/GOPATH as usual - not
reimplementing Go's own path resolution), `make release` (cross-compiles
both binaries for linux/darwin/windows/freebsd, amd64+arm64 where it
makes sense, into dist/). Every target is CGO_ENABLED=0:
modernc.org/sqlite is pure Go, so no C toolchain is needed anywhere,
cross-compiling included - this was already true before this commit,
just not verified or made easy to use.

Verified live, every target actually run rather than just written:
`make build` produces working binaries with version info correctly
picked up from git (confirmed against a real -version invocation, both
the "dev" default and an ldflags-injected release-style version
string); `make test` runs clean; `make release` was run for real and
produced 6 platform/arch binaries, each confirmed with `file` to be a
genuinely correctly-formatted executable for its target (Mach-O for
both macOS architectures, PE32+ for Windows, ELF for both Linux
architectures and FreeBSD) - not just "the command exited zero." `make
install`'s correctness rests on `go install` itself, Go's own
well-tested mechanism; deliberately not run for real here since it
writes into the real GOPATH/bin outside this repo, unprompted.

README gained an honest Platforms section: Linux is what's actually
been run and verified throughout this project's development; macOS,
Windows, and FreeBSD cross-compile cleanly and pass go vet, and the
code has nothing Linux-specific in it (CA/history storage already used
Go's own cross-platform os.UserConfigDir, not a hardcoded XDG path -
also fixed the README's install-directory example, which had been
Linux-only text), but they haven't run on real hardware, so they're
documented as "should work, not yet verified" rather than a claim this
session can't actually back up. Also flagged a concrete, real gotcha:
macOS's shorter Unix domain socket path limit combined with the deeper
~/Library/Application Support default control-socket location could
matter for a long username, with the existing -socket flag as the
workaround.

go build/vet/gofmt/test/mod tidy all clean.
---
 Makefile | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 Makefile

(limited to 'Makefile')

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..58f2f3f
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,59 @@
+# mitmux build automation. Plain `make` builds both binaries for the
+# current platform into bin/; `make release` cross-compiles every
+# binary for every platform in PLATFORMS into dist/. Every target here
+# is CGO_ENABLED=0 - modernc.org/sqlite is pure Go, so no C toolchain
+# is needed on any platform, cross-compiling included.
+
+BIN_DIR  := bin
+DIST_DIR := dist
+
+VERSION := $(shell git describe --tags --dirty --always 2>/dev/null || echo dev)
+COMMIT  := $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
+DATE    := $(shell date -u +%Y-%m-%d)
+LDFLAGS := -X mitmux/internal/version.Version=$(VERSION) -X mitmux/internal/version.Commit=$(COMMIT) -X mitmux/internal/version.Date=$(DATE)
+
+# darwin/amd64 and freebsd/amd64 cross-compile and pass `go vet` cleanly
+# (verified) but, unlike linux/amd64, have not been run on real hardware
+# - see README's Platforms section.
+PLATFORMS := linux/amd64 linux/arm64 darwin/amd64 darwin/arm64 windows/amd64 freebsd/amd64
+
+.PHONY: all build test check clean release install
+
+all: build
+
+build:
+	mkdir -p $(BIN_DIR)
+	CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o $(BIN_DIR)/mitmuxd ./cmd/mitmuxd
+	CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o $(BIN_DIR)/mitmux  ./cmd/mitmux
+
+# Same checks expected before every commit in this repo - see PLAN.md.
+test:
+	go build ./...
+	go vet ./...
+	test -z "$$(gofmt -l .)"
+	go test ./...
+
+check: test
+
+clean:
+	rm -rf $(BIN_DIR) $(DIST_DIR)
+
+install:
+	go install -ldflags "$(LDFLAGS)" ./cmd/mitmuxd
+	go install -ldflags "$(LDFLAGS)" ./cmd/mitmux
+
+# Cross-compiles both binaries for every platform in PLATFORMS into
+# dist/mitmux-<os>-<arch>/.
+release:
+	@for p in $(PLATFORMS); do \
+		os=$$(echo $$p | cut -d/ -f1); \
+		arch=$$(echo $$p | cut -d/ -f2); \
+		out=$(DIST_DIR)/mitmux-$$os-$$arch; \
+		ext=""; \
+		if [ "$$os" = "windows" ]; then ext=".exe"; fi; \
+		mkdir -p $$out; \
+		echo "building $$os/$$arch..."; \
+		CGO_ENABLED=0 GOOS=$$os GOARCH=$$arch go build -ldflags "$(LDFLAGS)" -o $$out/mitmuxd$$ext ./cmd/mitmuxd || exit 1; \
+		CGO_ENABLED=0 GOOS=$$os GOARCH=$$arch go build -ldflags "$(LDFLAGS)" -o $$out/mitmux$$ext  ./cmd/mitmux  || exit 1; \
+	done
+	@echo "release binaries in $(DIST_DIR)/"
-- 
cgit v1.2.3