Skip to content
CAI
Software that uses CAICheck a score

juanfont/headscale

58.1

Adequate · 9 October 2026

52.2k

lines of production code

Go

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a self-hosted control plane for Tailscale networks, providing an open-source alternative to Tailscale SaaS. It manages node authentication, IP allocation, and access control policies while exposing both legacy and modern Tailscale-compatible APIs for integration with external tools. The platform includes a web interface, a CLI for administration, and robust tooling for local development and comprehensive integration testing.

How it got here

2020–2023 — gRPC migration and integration testing

17 changes.

The project migrated its CLI and core control plane to a robust v1 gRPC API, introducing new management capabilities for API keys, OAuth, and node authentication. This architectural shift was supported by a comprehensive new integration test framework using Docker containers to validate authentication, policy enforcement, and API contract parity. Concurrently, the codebase established standardized development tooling, dependency management, and internal utilities for IP allocation and configuration validation.

2024–2025 — Policy v2 and infrastructure modernization

16 changes.

This period focused on implementing the Tailscale-compatible Policy v2 engine with grants and autogroup support, while refining route auto-approval and network filter logic. Concurrently, the project modernized its infrastructure by introducing a new \hi\ integration test runner, a NixOS module, and hardened Debian packaging, alongside significant database and capability version updates.

2026 — API v2 migration and policy v2 validation

18 changes.

This period focused on implementing a Tailscale-compatible v2 HTTP API and migrating the v1 API to a code-first Huma implementation, enabling compatibility with existing ecosystem tools. Concurrently, the team established a robust validation framework for the new policy v2 engine by integrating golden test data derived from Tailscale SaaS and adding comprehensive in-process and integration test harnesses.

Features

Add TailscaleRustInContainer integration test helper

The integration suite now includes a new \tsric\ package that allows testing against a Rust-based Tailscale node implementation (tailscale-rs) running inside a Docker container. This helper spins up the \axum\ example from the tailscale-rs repository, configuring it via environment variables and command-line arguments to connect to a headscale control server. It supports custom CA certificates, network configurations, and authentication keys, enabling verification of peer connectivity and headscale API interactions for non-Go Tailscale implementations.

integration/tsric · high confidence

Added CLI tool to generate OpenAPI specifications

A new command-line utility, \cmd/gen-openapi\, has been added to generate OpenAPI specification documents from the code-first Huma definitions in the v1 and v2 API packages. This tool allows users to emit the full OpenAPI 3.1 spec for either API version or produce a downgraded OpenAPI 3.0.3 version suitable for generating typed clients, writing the output to specified paths or default locations.

cmd/gen-openapi · high confidence

Generated HTTP clients for API v1 and v2 added

The codebase now includes auto-generated Go HTTP clients for both the v1 and v2 API versions, created using oapi-codegen v2.7.1. These new packages (clientv1 and clientv2) provide the type-safe primitives and models required to interact with the respective OpenAPI endpoints, enabling applications to programmatically access the updated v2 API alongside the existing v1 interface.

gen · high confidence

Introduce \`hi\` integration test runner CLI

A new \hi\ command-line tool is available to orchestrate integration tests via Docker. It provides a \run\ subcommand to execute tests with pattern matching, a \doctor\ subcommand for pre-flight system checks (Docker, Go, images), and a \list-versions\ subcommand to output Tailscale versions. The runner supports concurrent execution through unique run IDs, detailed artifact collection (logs, DB snapshots, MapResponses), and resource monitoring with configurable memory limits for Headscale and Tailscale containers.

cmd/hi · high confidence

Introduce automated dependency and toolchain update bot

A new \tools/bump\ utility has been added to automate the maintenance of the repository's dependencies and build environment. The tool manages several update areas: it refreshes GitHub Action pins in workflows, updates the Nix flake lock (which drives the devShell toolchain), bumps Go module versions (handling lockstep pairs like \tailscale.com\/\gvisor\ and \sqlite\/\libc\), updates Go versions in Dockerfiles, and refreshes base images (Alpine, Debian, Node, Rust). It operates by applying changes in ordered areas, gating each with structural checks, and bisecting failures to isolate problematic updates. If a final gate check fails, it drops the newest commits to find a passing state, ensuring that the resulting pull request contains only verified changes.

tools/bump · high confidence

Introduce compact Change type for efficient MapResponse updates

The hscontrol mapper now uses a new \Change\ struct to describe incremental updates to node state, allowing it to build \tailcfg.MapResponse\ payloads by merging specific flags (such as DNS, DERP, policy, or peer changes) rather than sending full state dumps. This change enables smarter, targeted notifications where only relevant data is sent to each node, improving efficiency and reducing bandwidth usage for clients.

hscontrol/types/change · high confidence

Introduce typed testcapture package for policy v2 golden data

The new \hscontrol/types/testcapture\ package defines a structured, typed on-disk format (HuJSON) for storing golden data from Tailscale-hosted control plane captures used in policy v2 compatibility tests. By storing wire-format data (filter rules, netmap, SSH rules) as typed \tailcfg\/\netmap\/\filtertype\ values instead of opaque \json.RawMessage\, the package ensures that schema drift between the capture tool and Headscale results in compile-time errors rather than silent test failures. It provides \Read\ and \Write\ functions that handle atomic file writes, HuJSON parsing (stripping comments/trailing commas), and schema versioning (currently v1), along with a comment header for human-readable metadata like test ID, description, and capture statistics.

hscontrol/types/testcapture · high confidence

Introduce vendorhash tool to track vendor tree integrity

A new \cmd/vendorhash\ utility is added to maintain and verify the Nix SRI hash of the Go module vendor tree. It stores the hash in \flakehashes.json\ alongside a content fingerprint of \go.mod\ and \go.sum\, allowing developers to check for staleness or update the recorded hashes via \check\ and \update\ subcommands.

cmd/vendorhash · high confidence

New NixOS module and test kit for Headscale

This change introduces a dedicated NixOS module for Headscale, replacing the upstream module to ensure synchronization with the project's latest changes. It includes a comprehensive example configuration and a new NixOS test kit (testkit and testkit-peer) that allows Tailscale clients to join a test control server without manual trust setup, simplifying integration testing for projects embedding Tailscale.

nix · high confidence

New OAuth scope vocabulary and grant logic for API access control

The system now defines a specific set of OAuth capability scopes (such as auth\_keys, devices:core, and policy\_file) that mirror Tailscale's API vocabulary, along with the logic to determine if a token's granted scopes satisfy an operation's requirements. This includes support for read-only subsets (e.g., auth\_keys:read) and super-scopes (all, all:read), ensuring that credentials are validated against these specific permissions before API operations are executed.

hscontrol/scope · high confidence

New Tailscale-compatible v2 API surface

Headscale now exposes a new HTTP API at /api/v2 that implements a subset of the Tailscale API wire shapes, enabling existing Tailscale ecosystem tools (such as the Terraform/OpenTofu provider, tscli, and the official Go client) to manage Headscale without modification. This location introduces the core v2 API wiring, authentication middleware, and scope enforcement, along with specific endpoints for managing ACLs, devices, users, auth keys, OAuth clients, and tailnet settings. The API supports both admin API keys and OAuth 2.0 client-credentials authentication, with scope-based access control for OAuth tokens, and reuses Tailscale's error body format to ensure compatibility with downstream clients.

hscontrol/api/v2 · high confidence

New capver tool to auto-generate capability versions from Docker tags

A new Go tool at tools/capver has been added to automatically generate the capability version mapping file (capver\_generated.go). The tool fetches available Docker tags from GitHub Container Registry, parses semantic versions, and retrieves the corresponding capability version from the Tailscale source code for each minor version. This automation ensures the capability version data stays synchronized with the latest released container images.

tools/capver · high confidence

New code-first Huma implementation of the v1 API

The v1 API endpoints (users, nodes, auth, API keys, pre-auth keys, policy, and health) are now served by a new code-first Huma implementation. This replaces the previous gRPC-based handler with a Go-native HTTP server that automatically generates the OpenAPI 3.1 specification and provides a consistent JSON response format. The new API enforces bearer-token authentication for all operations, supports local-trust bypass for internal communication, and maps domain errors to standard HTTP status codes.

hscontrol/api/v1 · high confidence

New database layer for API keys, IP allocation, and node management

The database package now includes dedicated implementations for managing API keys (with bcrypt hashing and expiration), a thread-safe IP allocator supporting sequential and random strategies, and core node operations like listing, renaming, and expiry handling. This change introduces the underlying storage logic for these capabilities, including migrations for route consolidation and tag handling, along with comprehensive tests for concurrency, IP exhaustion, and data integrity.

hscontrol/db · high confidence

New integration test client abstraction for Tailscale containers

The integration test framework now includes a new \TailscaleInContainer\ client abstraction (tsic) that manages Tailscale instances running inside Docker containers. This allows tests to configure and control Tailscale nodes with options for custom CA certificates, network settings, tags, SSH, and specific DERP connection modes (including WebSocket and HTTP-over-DERP). The client provides methods for executing commands, pinging peers, and verifying status, enabling more robust and isolated integration testing of Tailscale features.

integration/tsic · high confidence

New local development server tool for headscale

A new \cmd/dev\ tool has been added to simplify local development. It automatically builds and starts a headscale server on localhost (default port 8080) with a pre-created user and a reusable 24-hour pre-auth key. The tool manages a temporary state directory (SQLite database) and provides a health check to ensure the server is ready before creating credentials. It also validates that the specified port is within a valid range to prevent port overflow for the derived metrics port.

cmd/dev · high confidence

New mapresponses tool for inspecting map response state

A new command-line utility, \cmd/mapresponses\, has been added to help inspect and compare map responses during integration testing. It reads map response files from a specified directory and outputs the expected online map state as JSON, allowing developers to verify the mapper's behavior against stored test data.

cmd/mapresponses · high confidence

New utility functions for IP parsing, DNS root domain generation, and username validation

The hscontrol/util package now includes new helper functions to support network and identity management: ParseIPSet in addr.go handles IP addresses, CIDRs, and ranges; GenerateIPv4DNSRootDomain and GenerateIPv6DNSRootDomain in dns.go create reverse DNS entries for MagicDNS based on IP prefixes; and ValidateUsername in dns.go enforces rules that usernames must be at least 2 characters long, start with a letter, and contain only valid characters. These utilities are accompanied by comprehensive tests to ensure correct behavior.

hscontrol/util · high confidence

New zlog utility for secure, consistent logging

A new \hscontrol/util/zlog\ package has been added to provide safe and consistent logging via zerolog. It introduces wrapper types (\SafeHostinfo\, \SafeMapRequest\) that intentionally redact sensitive data such as device fingerprints, client IP addresses, and full authentication keys, logging only safe aggregates like counts and prefixes. The package also includes a \zf\ sub-package with field name constants to prevent typos and ensure consistent log structure across the control plane.

hscontrol/util/zlog · high confidence

Policy v2 implementation with grants, autogroup:self, and SSH tests

The \hscontrol/policy/v2\ package introduces a new policy engine that supports the Tailscale-compatible \grants\ format (including \via\ exit-node routing and \autogroup:self\ destinations), validates and executes the \tests\ block for policy verification, and enforces stricter validation for \autogroup:self\ sources in ACLs. This location provides the core compilation logic, \PolicyManager\ for state management, and extensive compatibility tests against Tailscale SaaS captures to ensure behavioral parity for these advanced features.

hscontrol/policy/v2 · high confidence

Robust file-based extra DNS records with reliable shutdown handling

The DNS control plane now supports loading extra DNS records from an external file, automatically watching for changes and updating the records in real-time. This new file watcher includes robust error handling for file removal or renaming, using exponential backoff to retry, and ensures clean shutdown by cancelling retries and releasing locks immediately when the manager is closed, preventing goroutine leaks or deadlocks during restarts.

hscontrol/dns · high confidence

Standardize development tooling and repository configuration

This change introduces a standardized set of configuration files to streamline the development workflow and enforce consistent code quality. It adds a \.dockerignore\ file to optimize Docker build contexts by excluding integration tests and development artifacts, and an \.editorconfig\ to define consistent indentation and line-ending rules across editors. The project now uses \prek\ (pre-commit) with a \.pre-commit-config.yaml\ to automatically run linters, formatters (Prettier, mdformat), and hygiene checks before commits. Additionally, a \.golangci.yaml\ file configures the Go linter with specific rules and exclusions, while \.goreleaser.yml\ defines the release and packaging process for binaries and container images. Other files like \.envrc\ (for Nix flake integration), \.mcp.json\ (for AI agent configuration), and \AGENTS.md\ / \AI\_POLICY.md\ provide guidance for developers and AI tools.

(repo-wide) · high confidence

Type-safe SQLite configuration with validated pragma settings

The \hscontrol/db/sqliteconfig\ package now provides a type-safe configuration layer for the SQLite database, replacing ad-hoc settings with validated enums for \JournalMode\ (WAL, DELETE, TRUNCATE, PERSIST, MEMORY, OFF), \AutoVacuum\ (NONE, FULL, INCREMENTAL), \Synchronous\ (OFF, NORMAL, FULL, EXTRA), and \TxLock\ (DEFERRED, IMMEDIATE, EXCLUSIVE). Users benefit from strict validation that prevents invalid database parameters, while the default configuration optimizes for production use with WAL journaling, incremental vacuum, and a 10-second busy timeout. The package also handles URL generation for the \modernc.org/sqlite\ driver, ensuring pragmas like \foreign\_keys=ON\ are correctly applied via connection string parameters rather than separate SQL statements.

hscontrol/db/sqliteconfig · high confidence

Behavioural changes

CLI commands migrated to v1 gRPC API with new management capabilities

The CLI has been refactored to communicate with the Headscale server via the v1 gRPC API instead of the previous HTTP API, providing a more robust and consistent interface for all operations. This change introduces new commands for managing API keys (\apikeys\), OAuth clients (\oauth-clients\), and node authentication (\auth register/approve/reject\), while consolidating node management under the \nodes\ subcommand. Existing commands such as \preauthkeys\, \policy\, and \debug\ have also been updated to use the new gRPC client, ensuring that all CLI interactions benefit from the improved error handling and structured data exchange of the gRPC protocol.

cmd/headscale/cli · high confidence

CLI now accepts a custom config file path via the -c flag

Users can now specify a configuration file location explicitly using the -c flag (e.g., headscale -c /path/to/config.yaml). Previously, the CLI relied on default search paths; this change allows overriding the config source directly from the command line, with the test suite verifying that the loaded configuration values (such as server URL, listen address, and database type) are correctly applied from the specified file.

cmd/headscale · high confidence

Consolidate static assets and introduce dark mode support

Static assets (favicon, CSS, and SVG logo) are now embedded directly into the Go binary via the new hscontrol/assets package, centralizing management. The embedded style.css applies a Material for MkDocs design system and adds support for system-level dark mode, ensuring the interface adapts to the user's OS theme preference.

hscontrol/assets · high confidence

DERP map loading and merging logic refactored into dedicated module

The DERP map handling logic has been extracted into a new \hscontrol/derp\ module. This change introduces a prioritized loading order where custom DERP maps are loaded from URLs first, then from local file paths, and finally merged with any inline configuration. The merge process now explicitly clones region data to prevent shared-pointer aliasing issues during node shuffling, and the node shuffle algorithm has been hardened to ensure deterministic behavior by sorting region IDs before iteration.

hscontrol/derp · high confidence

DERP server now supports WebSocket connections

The embedded DERP server has been updated to handle WebSocket-based connections in addition to the standard DERP protocol. This change allows clients that only support WebSocket transport to connect to the DERP server, improving compatibility with environments where raw TCP DERP connections are blocked or where clients are restricted to WebSocket-only protocols. The server now inspects the HTTP Upgrade header to determine whether to serve a WebSocket connection or a plain DERP connection, ensuring that both connection types are handled correctly.

hscontrol/derp/server · high confidence

Hardened systemd service and refactored Debian packaging

The Debian package installation process has been refactored to use nFPM, introducing new postinst, postrm, and prerm scripts to manage the headscale user, group, and service lifecycle. The systemd unit file has been significantly hardened with security directives including DevicePolicy=closed, MemoryDenyWriteExecute=true, and a filtered system call list that excludes @privileged and @resources, while also removing the X-Restart-Triggers header and dropping dependencies on syslog.target and /var/run.

packaging · high confidence

Headscale now supports Tailscale capability versions up to 1.102

The Headscale control server has updated its supported Tailscale capability versions, adding support for Tailscale v1.102 (capability version 142) and dropping support for versions older than v1.62 (capability version 88). The minimum supported capability version is now 115 (Tailscale v1.82), meaning clients using older Tailscale versions will no longer be supported. This change ensures Headscale remains compatible with recent Tailscale releases while removing legacy compatibility code for older versions.

hscontrol/capver · high confidence

Headscale web pages now use a unified Go-based design system

The Headscale web interface has been rewritten to use the \elem-go\ library instead of raw HTML templates, establishing a consistent Material for MkDocs design system across all pages. This change introduces a shared visual language with standardized spacing, typography, and CSS variables, ensuring a uniform look and feel for configuration guides (Apple, Windows), authentication flows (success, error, OIDC confirmation), and the debug ping tool. Users will see improved accessibility, better dark-mode support, and consistent styling for feedback boxes (success, error, warning) and layout components like the 'or' divider and device registration table.

hscontrol/templates · high confidence

Introduce structured config validation and typed listener error handling

The types package now uses a structured ConfigError system for configuration validation, allowing operators to see all configuration issues at once rather than fixing them one startup attempt at a time. This includes specific validation for listener address collisions, ensuring that configured TCP listeners (like listen\_addr, grpc\_listen\_addr, metrics\_listen\_addr, and tls\_letsencrypt\_listen) do not bind to the same socket. Additionally, a new ListenerBindError type provides detailed context for bind failures, including the listener name and YAML key, while maintaining compatibility with standard error inspection via Unwrap.

hscontrol/types · high confidence

Introduces a batcher to coalesce and serialize map responses

The mapper now uses a Batcher to group node changes into timed batches, coalescing updates that arrive while a response is already in flight to prevent out-of-order delivery. It serializes per-node work to ensure ordered delivery, defers broadcast changes until a node's initial map is successfully delivered, and prevents phantom peer state by only tracking sent peers after actual delivery. This architecture reduces lock contention and improves scalability under reconnect storms.

hscontrol/mapper · high confidence

New integration test infrastructure for Docker operations

The integration/dockertestutil package has been consolidated into a new set of helper modules to improve reliability and diagnostics for Docker-based integration tests. Authentication for Docker Hub pulls is now handled via environment variables or config files, with automatic retries for transient network errors. Network operations (connect, disconnect, reconnect) include robust retry logic and explicit waits for libnetwork settlement to prevent race conditions. Command execution supports configurable timeouts that are doubled on CI runners, and build failures now produce detailed diagnostic output. Additionally, test containers are labeled with unique run IDs to facilitate cleanup and log collection.

integration/dockertestutil · high confidence

Refined network filter rule reduction for subnet routers and exit nodes

The policy engine now more accurately tailors global filter rules to individual nodes by introducing a dedicated \ReduceFilterRules\ utility. This change ensures that nodes advertising approved subnet routes receive the necessary filter rules to reach destinations within those subnets, and that exit nodes are granted access to the public internet required for forwarding traffic from \autogroup:internet\ sources. Additionally, capability grant (CapGrant) rules are now narrowed to match specific node IPs or overlapping subnet routes, preventing overly broad permission scopes.

hscontrol/policy/policyutil · high confidence

Route auto-approval now preserves previously approved routes

The policy engine in hscontrol/policy has been updated to ensure that routes previously approved by an administrator are never automatically removed, even if they are no longer advertised by the node or if the policy changes. The new \ApproveRoutesWithPolicy\ function and its accompanying tests verify that auto-approved routes are added to the existing set of approved routes without replacing or deleting them, ensuring that manual administrative decisions are respected and persistent.

hscontrol/policy · high confidence

Standardized test infrastructure with CI-aware timeouts and certificate generation

The integration test utilities now provide standardized, named constants for convergence and polling timeouts (such as HAConvergeTimeout and PolicyPropagationTimeout) that automatically scale to double their duration in CI environments to account for resource contention. Additionally, the package introduces helper functions for generating test CA and server certificates, as well as utilities for writing and fetching files within Docker containers, replacing previous ad-hoc implementations.

integration/integrationutil · high confidence

Fixes

Matcher now includes CapGrant destinations in peer visibility checks

The policy matcher in \hscontrol/policy/matcher\ has been updated to ensure that destinations specified in \CapGrant.Dsts\ are included when deriving peer visibility. Previously, cap-grant-only rules (such as those for \tailscale.com/cap/relay\) contributed nothing to the destination set, causing the cap target to be hidden from the source. This change fixes that behavior by unioning \CapGrant.Dsts\ with standard \DstPorts\ IPs, ensuring that peers can correctly see and connect to services granted via capabilities.

hscontrol/policy/matcher · high confidence

Test coverage

Added ACL policy golden test data for policy v2; Added NixOS module tests for headscale integration; Added SSH policy validation test data; Added SaaS-derived compatibility test data for node attributes and routes; Added SaaS-derived compatibility tests for nodeAttrs policy scenarios; Added policy test result captures for Tailscale SaaS; Contract tests for the v1 and v2 API implementations; New in-process control plane test harness for end-to-end validation; New integration test framework for running Headscale in Docker; New integration test suite for authentication, API, and policy features; New test coverage for state management and authentication logic; Updated SSH test result fixtures for policy v2.

Dependencies

Initial dependency and documentation setup

This change introduces the project's Go module definition (go.mod) and lock file (go.sum), establishing the base dependencies for the codebase, including the Tailscale library, database drivers, and CLI frameworks. It also adds a requirements.txt file for the documentation build system, specifying tools like MkDocs Material and Mike for versioned documentation generation.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 62 → 58 (-3.9)
  • Rubric changed (rubric-2026.09.15 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 98 → 78 (-19.9)
  • Architecture 86 (new)
  • Maturity 61 → 61 (-0.7)
  • Readiness 70 → 50 (-20.5)
  • Security 54 → 60 (+5.8)
  • Performance 80 (new)

Resolved (22)

  • Documentation: other issue (docs/requirements.txt)
  • Low CVE: [GHSA redacted] (go.mod)
  • Medium CVE: GO-2026-6179 (go.mod)
  • Off-boarding risk: anonymized user #1
  • Outdated: github.com/chasefleming/elem-go
  • Outdated: github.com/coder/websocket
  • Outdated: github.com/coreos/go-oidc/v3
  • Outdated: github.com/creachadair/flax
  • Outdated: github.com/danielgtaylor/huma/v2
  • Outdated: github.com/go-chi/chi/v5
  • Outdated: github.com/go-gormigrate/gormigrate/v2
  • Outdated: github.com/oapi-codegen/runtime
  • Outdated: github.com/stretchr/testify
  • Outdated: golang.org/x/oauth2
  • Outdated: gorm.io/driver/postgres
  • Outdated: gorm.io/gorm
  • TodoComment (hscontrol/db/db.go)
  • TodoComment (hscontrol/db/db_test.go)
  • TodoComment (hscontrol/state/state.go)
  • TodoComment (hscontrol/state/state.go)
  • …and 2 more

New (320)

  • AuthProviderOIDC.OIDCCallbackHandler (cognitive 25) (hscontrol/oidc.go)
  • AuthProviderOIDC.OIDCCallbackHandler (cyclomatic 26) (hscontrol/oidc.go)
  • Batcher.addToBatch (cognitive 22) (hscontrol/mapper/batcher.go)
  • Batcher.worker (cognitive 51) (hscontrol/mapper/batcher.go)
  • Batcher.worker (cyclomatic 18) (hscontrol/mapper/batcher.go)
  • Change.Merge (cyclomatic 18) (hscontrol/types/change/change.go)
  • Change.Type (cyclomatic 18) (hscontrol/types/change/change.go)
  • ClassTooLong: AuthProviderOIDC (hscontrol/oidc.go)
  • ClassTooLong: Headscale (hscontrol/app.go)
  • ClassTooLong: HeadscaleInContainer (integration/hsic/hsic.go)
  • ClassTooLong: PolicyManager (hscontrol/policy/v2/policy.go)
  • ClassTooLong: Scenario (integration/scenario.go)
  • ClassTooLong: State (hscontrol/state/state.go)
  • ClassTooLong: TailscaleInContainer (integration/tsic/tsic.go)
  • DERPServer.GenerateRegion (cognitive 19) (hscontrol/derp/server/derp_server.go)
  • Duplicated block (10 lines × 2) (cmd/hi/cleanup.go)
  • Duplicated block (10 lines × 2) (hscontrol/api/v1/policy.go)
  • Duplicated block (10 lines × 2) (hscontrol/policy/v2/types.go)
  • Duplicated block (10 lines × 3) (hscontrol/policy/v2/types.go)
  • Duplicated block (11 lines × 2) (hscontrol/handlers.go)
  • …and 300 more

Changes since last survey

  • 169 commits — 164 feature/other, 5 fixes

By area

  • (root) — 41 commits
  • hscontrol/policy — 22 commits
  • hscontrol/state — 17 commits
  • tools/bump — 15 commits
  • hscontrol/mapper — 10 commits
  • hscontrol/servertest — 10 commits
  • .github/workflows — 6 commits
  • hscontrol/db — 5 commits
  • docs/ref — 4 commits
  • hscontrol/noise_test.go — 4 commits
  • hscontrol/types — 4 commits
  • .github/VOUCHED.td — 3 commits
  • cmd/headscale — 3 commits
  • hscontrol/derp — 3 commits
  • hscontrol/noise.go — 3 commits
  • .github/CODEOWNERS — 2 commits
  • cmd/hi — 2 commits
  • integration/route_test.go — 2 commits
  • tools/capver — 2 commits
  • .github/actions — 1 commit

Notable commits

  • fix: CHANGELOG: note SSH rule removal fix
  • fix: CHANGELOG: note the own approved routes fix
  • fix: CHANGELOG: reword SSH check replay fix
  • fix: CHANGELOG: say audit-log clients stay down after the logtail fix
  • fix: tests: preserve SSH regressions after combining policy fixes
  • change: .github: bump 13 action pins
  • change: .github: delete the unused renovate config
  • change: .github: fold the action version updater into tools/bump
  • change: .github: gate CI on flake.lock and flakehashes.json
  • change: .github: gate PRs via mitchellh/vouch
  • change: .github: point CODEOWNERS at the real goreleaser file
  • change: .github: run the version bump daily
  • change: .github: run tools/bump on demand
  • change: .github: vouch recent contributors
  • change: .pre-commit-config: stop handing .toml files to prettier
  • change: AGENTS.md: document the version bump rules
  • change: CHANGELOG: link derp-admit to pull request
  • change: CHANGELOG: link logtail to pull request
  • change: CHANGELOG: link pak-revalidate to pull request
  • change: CHANGELOG: link ping-full to pull request
  • …and 149 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

juanfont/headscale was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 9 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a8d6f5be81e578a078001b908e41611ec03ce69e — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer preprod-fe8540b5da9b.