Sonny N. Lans

A self-hosted, end-to-end encrypted messenger implementing the modern Signal protocol stack: X3DH key agreement and the Double Ratchet for 1:1 sessions, and Megolm sender-keys for efficient group chats. Cryptography runs through vodozemac (the Rust Olm/Megolm library used by Matrix).

The Flutter/Dart client (Riverpod) bridges via flutter_rust_bridge to a Rust core that owns crypto, encrypted storage (SQLCipher), and networking. A dedicated Rust Axum relay routes only ciphertext over WebSockets, with a PostgreSQL offline queue for delivery when a device is off. Multi-device linking is handled with QR-based session transfer. Verified by unit tests, a CI job that drives two clients through the full wire protocol against a live relay and Postgres, and a repeatable two-emulator runtime integration pass.

A 4X real-time strategy space game built in Rust on the Bevy 0.14 ECS. Players colonize planets, mine asteroids, research technologies, build fleets, send resource offers to rivals, and fight for galactic dominance across five victory conditions. Combat resolves once per clock-driven turn, with unit formations (line, wedge, circle, column), five activatable ship abilities (afterburner, shield, barrage, cloak, repair), weapon ranges, and positioning.

The crate ships four binaries — the Bevy game client, a dedicated game server, an egui-based map editor, and a lobby server — plus server-authoritative WebSocket multiplayer with delta compression, full replay record/playback, and player-to-player resource trading. Audio is procedurally synthesized through rodio. The main line is ~26k lines of Rust across those four binaries; a separate gameplay branch runs to ~78k while exploring further combat and UI systems, and the repo carries ~710 commits across all branches.

A private pnpm monorepo of 18 independent, production-grade TypeScript packages published under the @snlans scope and consumed across webshop, crawler-saas, cv-site, tool-sites, blog, and mail-service. Packages include @snlans/auth (JWT / OAuth / RBAC / API keys / TOTP / magic links), @snlans/stripe, @snlans/storage (S3 / Azure / GCS / local + media processing), @snlans/crawler, @snlans/queue (Memory / BullMQ / Postgres / SQLite backends), @snlans/observability, and a @snlans/ship deploy CLI.

The design philosophy is framework-agnostic cores with thin Express adapters and edge/Web-standard entry points that drop straight into Next.js middleware, explicit types everywhere, over 11,000 tests with 90% coverage thresholds configured, and TypeDoc-generated docs — a genuine "build once, extract, reuse" ecosystem. ~380 commits.

The first of two products in the gx10 repo: an agentic coding assistant for a private workstation, built from three decoupled services. A native Rust indexer watches the workspace with notify, parses a semantic AST with tree-sitter (Python + TypeScript), embeds chunks locally with FastEmbed and scrapes git history with git2 — writing vectors into LanceDB and a relational/graph layer into Parquet queried through DataFusion. A FastAPI + LangGraph engine enqueues each request onto an ARQ worker, checkpoints graph state in Postgres, and streams thoughts and tokens back over Redis Pub/Sub as Server-Sent Events. A Next.js 15 / React 19 hub renders the chat, an indexer dashboard, and a codebase graph (xyflow + d3-force).

The graph is compiled to interrupt before its tools node, so in the strictest autonomy mode a tool call — running a shell command, for example — pauses execution, persists state to Postgres, and waits for an Allow/Deny decision in the UI before resuming; two looser modes auto-approve read-only tools, or everything. The stack is designed for an on-prem NVIDIA box: an ASUS Ascent GX10 (GB10 Grace-Blackwell, 128 GB unified memory), with a compose file that ships SGLang serving Qwen/Qwen3-32B next to Postgres, Redis, and a self-hosted SearXNG. Honest caveat: fully local inference is the goal, not the shipped default — the model selector falls back to cloud gemini-2.5-flash unless a local SGLang endpoint is chosen.

~47 commits across the three services, in a repo shared with the Lanselot digital butler (~207 commits repo-wide). An early sibling prototype, Lanselot Pro Hybrid, is one commit deep: scaffolding for a legal-document RAG pipeline aimed at a hypothetical bilingual law firm — pytesseract and pdf2image baked into the worker image, bge-m3 embeddings behind a TEI container, LanceDB as the target and per-case row-level scoping injected as a prefilter — with the OCR worker itself still a simulated stub.

The second and most-developed product in the gx10 repo — not a newer version of the coding assistant but a separate system: an always-on personal assistant. A Starlette router exposes an OpenAI-compatible /v1 API in front of an SGLang container serving Qwen/Qwen3.5-35B-A3B-FP8 at 131k context; keeping inference in its own container means the Python layers can be restarted in seconds without paying the model cold-start again. OpenWebUI is the desktop frontend, and a Signal bridge (signal-cli REST API) puts the same assistant in a phone chat — voice notes transcribed locally by a Cohere ASR model, spoken replies synthesized with Kokoro.

Memory is three stores with different jobs: LanceDB for semantic search over an Obsidian vault that a watchdog re-embeds on every save, a Kuzu graph for durable facts, preferences and note-to-note links, and SQLite for the scheduler and chat history. Thirty registered tools cover vault read/write and auto-linking, memory CRUD, SearXNG search and page fetching, a news agent that tracks followed topics, Google Calendar, and Python execution inside a sandbox container with no host volumes and no published ports. Long jobs are spawned as sub-agents onto an ARQ/Redis swarm — the worker is capped at one CPU and 4 GB so background research cannot starve the inference container — and SQLite cron tasks let the system contact its owner on Signal unprompted.

Iterated as 51 versioned deployment directories, from V1 (Qwen 32B fp16) to the current V12.0.0 — every one a runnable compose stack, the later ones carrying the full config and app tree, and nothing pruned: the versions marked FAILED and ROLLBACK are still there. ~141 commits, on the same on-prem ASUS Ascent GX10 (NVIDIA GB10, 128 GB unified memory) as Lanselot Pro.

A web-crawling SaaS built as a pnpm/TypeScript monorepo: a Next.js 15 frontend with a seven-step visual job builder and live progress, and an Express + BullMQ backend running five specialized worker types (schedule, crawl, browser, export, cleanup). It leans heavily on the @snlans/crawler engine and other shared packages for auth, queues, storage, and billing.

Backed by PostgreSQL 16 (organization-scoped multi-tenancy) and Redis 7, with ethical-crawling defaults (robots.txt, politeness, rate limiting) and five pre-built schema extractors plus a custom-schema option. ~113k LOC of TypeScript — roughly half of it tests — across ~117 commits.

A Next.js App Router platform serving 107 single-purpose browser tools across 11 cluster hubs at lans.cloud — classroom utilities, generators, calculators, party and prank tools. Tool logic is client-side by design: the core of a tool runs without a server round-trip, which is what keeps the pages fast enough to compete on Core Web Vitals. Prisma over the shared PostgreSQL cluster backs everything that is not the tool itself — first-party page and referrer stats, tool link clicks and impressions, and a Google Search Console query ledger.

Every tool page carries its own metadata, JSON-LD, HowTo and FAQ blocks and an /llms.txt surface for AI crawlers, plus an Open Graph card generated offline by a headless-Chrome screenshot pipeline (puppeteer-core) on top of the owner's own @snlans/seo package. What gets built is decided from measured search data rather than intuition: a written targeting doctrine that screens a query on whether its SERP already has an incumbent — and that was rewritten when a Search Console pull falsified its first version, which had assumed phrase length and cluster depth drove ranking.

The entire third-party ad chain sits behind a single build-time killswitch, added after measuring the ad loader at roughly 31% of the homepage's served bytes while filling nothing (the ad account was never approved); re-enabling is a documented flag flip and rebuild rather than an archaeology exercise. A daily digest job mails the previous day's traffic, click and Search Console movement through the internal mail-service. Deployed as a locally built image streamed to the VPS behind Traefik. Roughly 210k lines of TypeScript across ~1,360 commits, with 4,015 tests in 302 files.

A commerce platform for digital goods, SaaS subscriptions, services, and software licenses, now running as the v2 rebuild after a MongoDB-to-Postgres cutover, with v1 archived under legacy/. Built on Next.js 16 / React 19 with Tailwind 4 + shadcn/ui, Prisma 7 over PostgreSQL 16, Redis, and MinIO for presigned, purchase-gated asset delivery.

Payments run through Stripe, with a provider-abstracted crypto path (CoinGate preferred; the Coinbase Commerce integration is kept as legacy after Coinbase closed to EU merchants) and all monetary values stored as integer cents. It consumes eight @snlans packages — auth, stripe, storage, security, seo, license, observability, ship — so effort concentrates on catalog, cart, checkout, fulfillment, and license delivery. The v2 rebuild is ~28k LOC across ~190 commits since the v1-final tag, next to the ~65k-LOC v1 archive, with Playwright + Vitest coverage.

A production Astro blog that generates posts from a mounted markdown directory with server-side Shiki syntax highlighting. It adds Fuse.js full-text search, series navigation, per-post Open Graph images rendered with Satori/resvg, JSON-LD, RSS, and an /llms.txt surface for AI crawlers.

Monetization runs through Stripe subscriptions with magic-link auth, gating premium posts, plus a double opt-in newsletter delivered via the internal mail-service. Deployed with Docker behind Traefik. ~16k LOC across ~106 commits.

The portfolio itself, built as a pnpm + Turborepo monorepo. The backend is NestJS 11 with a code-first GraphQL API (Apollo), MikroORM 6 over PostgreSQL, Redis, BullMQ for the live-lab job queue, and MinIO for the gated CV PDF. The frontend is Next.js 15 / React 19 styled with Panda CSS, featuring an interactive expertise graph (React Flow + d3-force) that visualizes skills, technologies, projects, and outcomes.

It includes a gated CV-download flow (magic-link approval), a Cloudflare Turnstile-protected contact form, a JWT-authenticated admin panel with CRUD for experience, skills, outcomes, and projects, and self-hosted Umami analytics.

A Python tool that indexes the written record of a whole multi-repo workspace, every git-tracked markdown file and every commit message across ~36 repositories, into a single SQLite database, and answers "have we hit this before" and "why did we choose X" by meaning rather than by keyword. The live index is 8,706 documents split into 47,354 chunks, every one embedded. Retrieval is hybrid: BM25 over FTS5 fused with cosine similarity over bge-m3 vectors held in sqlite-vec. Embeddings are computed locally through FastEmbed, so after the model is cached the tool makes no network call at all.

The fusion weights are measured, not assumed. On a 20-query golden set with strict path-matched scoring, keyword-only search reaches recall@5 of 0.05 and vector-only 0.35, meaning that on prose questions over this corpus semantic search does effectively all of the work, so the arms are fused 4:1 vector:keyword after a sweep showed equal weighting let the weak arm outvote the strong one's mid-ranks. Keyword-only survives as the right tool for an exact token (an error string, a sha, a package name) and is the only mode that loads no model.

The second half is exact rather than statistical: a dependency graph parsed from package.json, Cargo.toml, pyproject.toml and pnpm workspace members, so `deps` lists every repo pinning a package and `impact` reports who actually receives a given release. It encodes the rule that below 1.0.0 a caret does not float the minor, which means a publish can reach nobody until pins are bumped by hand.

The newest layer makes retrieval ambient rather than asked for. A long-lived daemon (`recall serve`, under launchd) holds the embedding model warm and serves HTTP over a unix domain socket beside the index, no TCP port and no auth token, because the filesystem is already the authorisation boundary for the database itself. A prompt hook asks that daemon a question on every prompt and injects at most three workspace pointers when the best hit clears a similarity threshold. The threshold was measured rather than guessed: 200 real prompts were harvested and scored, and τ = 0.71 was chosen as the lowest value whose precision interval clears 0.8 (precision 0.95, Wilson 95% [0.82, 0.99], firing on roughly one prompt in ten, with the irrelevant hits clustering just below it). The safety case is latency and reversibility: compute is 67 ms at the median and 130 ms at p95 against a 2 s hook budget, the hook fails open on any error so a broken daemon can never cost a prompt, and a single file toggles the whole thing off with no restart.

Three entry points share one engine: the CLI (`index`, `search`, `stats`, `doctor`, `serve`, `deps`, `impact`), an MCP stdio server exposing three read-only tools, and the daemon, which the MCP server also proxies its vector work to so the 2.27 GB model is loaded once on the machine rather than once per process. A nightly launchd job re-indexes incrementally by head sha and then runs `doctor`, because the index stage commits its freshness stamp before embedding finishes, so a run killed mid-embed would otherwise leave a stamped, fresh-looking, vectorless index. About 5k lines of Python behind 7.3k lines of tests (1,261 cases) across 96 commits.

An online raffle and lottery platform with a TypeScript + Express backend and a separate React 19 + Vite frontend, backed by MongoDB via Mongoose. Hourly and daily draws run unattended on node-cron — the job picks a ticket-weighted winner, closes the raffle, credits 90% of the pot, and opens the next period. Players top up an in-app balance by transferring a self-issued ERC-20 token on BSC testnet, which the backend verifies on-chain with ethers.js by parsing each deposit transaction's Transfer log.

Wired with JWT auth, bcrypt, helmet, rate limiting, and compression, and shipped as separate backend/frontend Docker images pushed by self-hosted CI. 377 commits over an intensive Feb–Apr 2025 build.

A full-stack portfolio site built for 2D designer Milen Dimitrov, with a distinctive circular, space-themed UI. The frontend is React 18 + Vite with Framer Motion; the backend is Node 20 + Express on MongoDB via Mongoose, with a Sharp-based image-processing pipeline and a secure admin dashboard for content management.

Deployed with Docker Compose behind Traefik and covered by a 120-test Playwright E2E suite. It answers on two hostnames — the artist's own milendimitrov.art and portfolio.lans.cloud — from a single router rule per service rather than a duplicated stack, so both domains serve the same containers and Let's Encrypt issues for both. ~25.8k lines of TypeScript (plus ~9k CSS) across ~188 commits.

A Model Context Protocol (MCP) server that exposes project management as native tools for AI assistants like Claude Code. Built on the official MCP Python SDK — stdio for local Claude Code use, SSE behind Traefik when Dockerized — it provides 35 tools: 24 for Plane, 8 for Git, and 3 for GitHub. A heuristic complexity engine scores tickets, parses "depends on / blocked by" references (with a topological sort over them), and proposes a sub-task breakdown the calling agent can then create through the sub-issue tools.

A companion Python CLI, md-to-plane, migrates structured markdown todo files into Plane as modules (epics) and AI-agent-ready issues. Dockerized for easy integration.

Five Docker Compose services on one VPS, attached to an already-running external Traefik network rather than owning the edge: MinIO for S3-compatible object storage (public API at s3.lans.cloud), PostgreSQL 16, Redis 7 with AOF + RDB persistence and AUTH, self-hosted Umami for cookieless analytics (analytics.lans.cloud, its own database on the shared Postgres), and Remark42 for blog comments (comments.lans.cloud, email-verified sign-in, anonymous commenting deliberately off). Webshop and the tool-sites platform run on the shared Postgres; cv-site keeps its own database and consumes only the shared object storage.

The security posture is deliberate. No database ports are published to the host at all — applications resolve infrastructure-postgres:5432 and infrastructure-redis:6379 over Docker DNS. Each app gets its own database and least-privilege user from an idempotent provisioning script that hands the app ownership of just that database and revokes CONNECT from PUBLIC. After a security audit the MinIO admin console was taken off the internet entirely (loopback bind, SSH tunnel only), while the S3 API stays public with browser-facing buckets on a custom GetObject-only anonymous policy instead of the listing-enabled preset.

Every service has a healthcheck, and Umami only starts once Postgres reports healthy. A nightly cron rotation keeps seven rolling day-of-week copies of a full pg_dumpall and a Redis snapshot — AES-256 encrypted before they enter a private offsite git repository — alongside an mc mirror of the buckets, where the private ones go in as an encrypted tar and the public site assets stay plain. A quarterly drill re-checks freshness and decrypts every artifact to verify integrity, emailing on failure. A load and runaway-process watchdog, written after an orphaned recursive search quietly pegged three and a half of four cores for five days, now runs every fifteen minutes.

A personal homelab VPS, run through 2025 and since decommissioned in favour of the current lans.cloud infrastructure. A central Nginx reverse proxy (sites-available/enabled discipline, Let's Encrypt TLS termination with HSTS, a 444 catch-all for unmatched hosts) exposed self-hosted Gitea, an htpasswd-authenticated private Docker registry, Nextcloud, and the deployed applications.

The registry anchored a real push-to-deploy chain: self-hosted CI built and pushed images, the registry's webhook notified a small PM2-managed Node receiver, and a lock-guarded deploy script pulled and restarted the containers. Remote access ran over two independent paths — WireGuard for encrypted network access, with self-hosted RustDesk as a GUI fallback.

A small, purpose-built microservice that fronts SMTP with an internal HTTP API, so the lans.cloud apps authenticate with a service key rather than sharing the mailbox password. Built with Fastify on top of @snlans/email.

It joins the Traefik network with no public exposure — siblings reach it internally — boots cleanly without SMTP credentials, and returns 503 until configured. Four applications now send through it: the tool-sites daily digest, the blog newsletter, webshop, and cv-site.

A documentation-and-templates toolkit that codifies standards, configs, and best practices for AI-assisted development, targeting Copilot / Claude Code / Cursor workflows. It includes reusable modules, worked examples, a showcase, and a setup wizard.

A content-first project capturing a repeatable method for getting high-quality output from AI coding tools. Four of the nine modules ship configs, templates, and examples; the other five are documentation-only guides with no installable assets yet. ~33 commits, paused since late 2025.

A focused Solidity ERC-20 token (MishCoin, symbol MISH) built on OpenZeppelin's ERC20 + Ownable. It supports owner minting, holder burning, and recovery of tokens sent to the contract address by mistake, and ships a small ethers deploy script targeting a BSC testnet.

Deliberately small in scope — a smart-contract exercise rather than a product.