alex/millerson-overlay.nix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c08c444a39762970b72c6ef72889c4fd8314c4f6
millerson-overlay.nix/README.md
T
alex 03337bc545
CI / check (push) Has been cancelled
Details
feat(codeaf): add CodeAF coding agent package 
CodeAF (Agent-Field/CodeAF) is a Go coding harness that ships one binary.
Pinned to v0.7.1; the flake's nixpkgs already carries go 1.26.7 and go.mod
asks for 1.26.5, so no extra nixpkgs input is needed.

Two things about this build are not obvious from the derivation:

- `make build` runs two host-side steps before compiling: `go generate
  ./internal/manual` packs the built-in manual into the pages.pack.gz and
  chat.pack.gz that the codeaf_packed_manual tag embeds, and
  internal/furrowbin/cmd/fetch stages the pinned Agent-Field/furrow release
  into internal/furrowbin/cache for go:embed. Both are run in preBuild with
  GOOS/GOARCH unset, the way the Makefile does it, so a cross build does not
  try to run a target binary on the build machine. buildGoModule runs preBuild
  in the vendoring derivation as well, before vendor/ exists and before the
  dependencies are in reach, so the two steps are gated on vendor/.
- The furrow step gets its bytes from fetchurl and `-from`, the offline road
  upstream documents. The fetcher still checks the sha256 in
  internal/furrowbin/pin.json, so the hashes here duplicate a pin that is
  already in the source; drop the furrow entirely and codeaf still builds and
  falls back to looking for the binary on PATH.

Tests are off: the upstream suite is a make/CI matrix with network and timing
assumptions, not a `go test ./...` that fits buildGoModule.

Verified with nix build .#codeaf, `codeaf --version` reporting 0.7.1 and
`codeaf manual` listing the packed manual pages.

Refs nix-overlay-m5y
2026-10-06 21:45:16 +03:00

236 lines
11 KiB
Markdown
Raw Blame History

# millerson.name Nix Overlay
A custom Nix overlay and flake providing additional packages not found in upstream nixpkgs, built using [numtide/blueprint](https://github.com/numtide/blueprint) for streamlined flake development.
## Features
- **Custom packages** - Additional software packaged for Nix
- **Two overlay strategies** - Choose between binary-cache-friendly or dependency-sharing overlays
- **Blueprint-based** - Uses modern Nix flake patterns with `numtide/blueprint`
## Available Packages
| Package | Description | Category |
|---------|-------------|----------|
| `awg-tool` | CLI for AmneziaWG self-hosting — generates 1.0/1.5/2.0/3.0 obfuscation parameters, exports .conf and vpn:// configs, installs servers over SSH | Networking |
| `aionui` | Free, open-source, Cowork app with AI Agents | AI Coding Agents |
| `codeaf` | Coding harness and software factory for open models: hand work off, then watch every project from one terminal | AI Coding Agents |
| `container-use` | Containerized environments for coding agents | AI Coding Agents |
| `desloppify` | Multi-language codebase health scanner and technical debt tracker for AI agents | AI Coding Agents |
| `ds4` | DeepSeek 4 Flash and PRO local inference engine for ROCm (Strix Halo) | AI Inference |
| `freebuff` | The world's strongest free coding agent | AI Coding Agents |
| `freetoken` | Local MoE-offload LLM inference runtime with OpenAI- and Anthropic-compatible APIs | AI Inference |
| `graphify` | Turn any folder of code, docs, papers, images, or videos into a queryable knowledge graph | AI Coding Agents |
| `g3` | AI coding agent that writes code and executes commands, with multi-provider LLM support, context compaction, and desktop automation | AI Coding Agents |
| `haivemind` | Multi-model AI consensus, aggregation, and fusion runner for popular AI CLIs | AI Coding Agents |
| `hipengine` | ROCm-native local LLM inference engine with torch-free runtime for AMD RDNA GPUs | AI Inference |
| `marmel` | Autonomous agentic coding assistant with Manager + specialist subagent orchestration over any OpenAI-compatible LLM backend | AI Coding Agents |
| `mcp-gateway` | Universal Model Context Protocol gateway that sits between AI client and MCP tools/servers | MCP Servers |
| `nftables-analyzer` | Analyze nftables firewall rules and evaluate traffic queries | Networking |
| `nftablesbuilder` | Web interface to manage nftables rules with drag-and-drop rule creation | Networking |
| `shardr` | Decentralized LLM repository: content-addressed model store, BitTorrent-based sync, OpenAI-compatible serving via llama-server | AI Inference |
| `skillsmcp` | MCP server that exposes Agent Skills to AI agents via the Model Context Protocol | MCP Servers |
| `kubernetes-mcp-server` | Model Context Protocol (MCP) server for Kubernetes and OpenShift | MCP Servers |
| `llama-cpp` | llama.cpp pinned to build b11439, built for Strix Halo (gfx1151) with ROCm + Vulkan backends | AI Inference |
| `loop` | Corporate messenger for your team | Communication |
| `radar` | Modern Kubernetes visibility — topology, event timeline, service traffic, resource browsing, Helm management, and GitOps support | Kubernetes |
| `omniroute` | Unified AI router with 160+ providers, auto fallback, MCP/A2A, OpenAI-compatible APIs | AI LLM Gateway |
| `open-code-review` | AI-powered code review CLI combining deterministic pipelines with an LLM agent for line-level review comments | AI Coding Agents |
| `relay-free-llm` | RESTful API to route user prompts to various AI model providers with automatic failover and intent-based routing | AI LLM Gateway |
| `stakpak` | DevOps AI agent that generates infrastructure code, debugs Kubernetes, configures CI/CD, and automates deployments | AI Agents |
| `traycer` | Open-source AI orchestration app for agentic coding | AI Coding Agents |
## Usage
### As a Flake
Add to your `flake.nix` inputs:
```nix
inputs.millerson-nix-overlay.url = "git+https://git.millerson.name/alex/millerson-overlay.nix.git";
```
Then use in your outputs:
```nix
outputs = { nixpkgs, millerson-nix-overlay, ... }: {
nixosConfigurations.your-host = nixpkgs.lib.nixosSystem {
system = "x86_64-linux";
modules = [
millerson-nix-overlay.nixosModules.default
# ... your other modules
];
};
};
```
### As an Overlay
#### Option 1: Default Overlay (Binary Cache Friendly)
Uses the packages built against this flake's nixpkgs revision. Binary cache hits work best when using the same nixpkgs revision.
```nix
nixpkgs.overlays = [ millerson-nix-overlay.overlays.default ];
```
#### Option 2: Shared Nixpkgs Overlay (Dependency Sharing)
Builds packages against your system's nixpkgs, sharing dependencies with the rest of your system. No second nixpkgs evaluation, but binary cache only hits when your nixpkgs revision matches ours.
```nix
nixpkgs.overlays = [ millerson-nix-overlay.overlays.shared-nixpkgs ];
```
### Installing Packages
With flakes enabled:
```bash
# Try a package
nix run git+https://git.millerson.name/alex/millerson-overlay.nix.git#mcp-gateway
# Install permanently
nix profile install git+https://git.millerson.name/alex/millerson-overlay.nix.git#mcp-gateway
```
### nftablesbuilder Runtime Notes
`nftablesbuilder` is a web interface for managing nftables. It consists of a
root-launcher (`nftablesbuilder`) that spawns the unprivileged `webserver`
binary and pipes encrypted commands between it and the `nft` binary.
Before running it you must:
1. Copy the settings template to `/etc/nftablesbuilder` (the only fixed path):
```bash
nix build .#nftablesbuilder
cp result/share/nftablesbuilder/settings.example /etc/nftablesbuilder
```
Adjust paths inside (html, webserver, nft, savepath, TLS files).
2. Create a TLS key/certificate pair at the paths referenced by
`tlskey`/`tlscert` (e.g. `openssl req -x509 -newkey rsa:2048 -nodes ...`).
3. Run the launcher as root (it needs to write `/etc/nftables.conf` and run
`nft`); the web interface listens on `https://<server>:1969`.
Note: upstream publishes the GUI only as a prebuilt tarball on
nftablesbuilder.eu (served with a self-signed certificate, hence the
`curlOpts = "-k"` in the derivation); the source repository is missing the
`settings` crate, which this overlay patches in.
### OpenCodeReview OpenCode Plugin (Home Manager)
The `open-code-review` package bundles its OpenCode plugin (the plugin file
plus runtime `node_modules`) as `passthru.opencode-plugin`, built from the
same source revision as the CLI. A Home Manager module symlinks it into
`~/.config/opencode/plugins/` and puts the `ocr` CLI on PATH:
```nix
inputs.millerson-nix-overlay.url = "git+https://git.millerson.name/alex/millerson-overlay.nix.git";
inputs.home-manager.url = "github:nix-community/home-manager";
```
```nix
# in your home-manager configuration
imports = [ millerson-nix-overlay.homeManagerModules.default ];
programs.open-code-review = {
enable = true;
opencode.enable = true; # symlink plugin into ~/.config/opencode
};
```
Without Home Manager, symlink manually:
```bash
plugin=$(nix build --print-out-paths \
git+https://git.millerson.name/alex/millerson-overlay.nix.git#open-code-review.passthru.opencode-plugin)
mkdir -p ~/.config/opencode/plugins
ln -sf $plugin/share/open-code-review/opencode/open-code-review.ts ~/.config/opencode/plugins/
ln -sfn $plugin/share/open-code-review/opencode/node_modules ~/.config/opencode/plugins/node_modules
```
Note: the `node_modules` symlink is shared across everything in the plugins
directory; other manually-installed plugins with conflicting npm dependencies
cannot coexist with it.
## Development
### Prerequisites
- Nix with flakes enabled
- [treefmt-nix](https://github.com/numtide/treefmt-nix) for formatting (optional)
### Building Packages
```bash
# Build all packages for current system
nix build .#packages
# Build specific package
nix build .#mcp-gateway
# Enter development shell
nix develop
```
### Project Structure
```
nix-overlay/
├── flake.nix # Flake definition
├── treefmt.toml # Code formatting configuration (nixfmt)
├── overlays/ # Overlay implementations
│ ├── default.nix # Binary-cache-friendly overlay
│ └── shared-nixpkgs.nix # Dependency-sharing overlay
├── packages/ # Package definitions
│ ├── awg-tool/ # AmneziaWG parameter generation and SSH deployment CLI
│ ├── aionui/ # AionUi - AI Cowork desktop app
│ ├── codeaf/ # Coding harness and software factory for open models
│ ├── container-use/ # Containerized environments for coding agents
│ ├── default/ # Meta-package listing all packages
│ ├── desloppify/ # Codebase health scanner for AI agents
│ ├── ds4/ # DeepSeek V4 Flash/PRO inference engine (ROCm)
│ ├── flake-inputs/ # Utility for caching flake inputs
│ ├── freebuff/ # Free coding agent (Codebuff)
│ ├── freetoken/ # Local MoE inference runtime (NVIDIA CUDA)
│ ├── graphify/ # Knowledge graph generator for code folders
│ ├── g3/ # AI coding agent (g3 + g3-studio)
│ ├── haivemind/ # Multi-model AI consensus runner
│ ├── hipengine/ # ROCm-native LLM inference engine for AMD GPUs
│ ├── kubernetes-mcp-server/ # MCP server for Kubernetes and OpenShift
│ ├── loop/ # Corporate messenger for your team
│ ├── mcp-gateway/ # MCP protocol gateway
│ ├── omniroute/ # Unified AI router with 160+ providers
│ ├── open-code-review/ # AI code review CLI (deterministic + LLM agent)
│ ├── radar/ # Kubernetes UI (topology, timeline, Helm, GitOps)
│ ├── relay-free-llm/ # AI model provider routing gateway
│ ├── skillsmcp/ # MCP server for Agent Skills
│ ├── stakpak/ # DevOps AI agent for infrastructure automation
│ └── traycer/ # AI orchestration desktop app (agentic coding)
└── README.md
```
### Adding New Packages
1. Create a new directory under `packages/<package-name>/`
2. Add a `package.nix` with the package definition
3. Create a `default.nix` that imports `package.nix` with proper arguments
4. The package will be automatically picked up by blueprint
Example structure:
```
packages/my-package/
├── default.nix # Import wrapper
└── package.nix # Actual package definition
```
## License
See [LICENSE](LICENSE) file for details.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
Reference in New Issue View Git Blame Copy Permalink