Set doc version to 0.24.3

Set doc version to 0.24.2
Set doc version to 0.24.1
2026-07-18 22:10:44 +09:00 · 2025-03-21 06:49:15 +01:00 · 2025-02-02 16:54:17 +01:00 · 2025-02-02 16:51:42 +01:00 · 2025-01-17 17:31:29 +01:00
1515 changed files with 40197 additions and 12170364 deletions
@@ -0,0 +1,15 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+language: "en-GB"
+early_access: false
+reviews:
+  profile: "chill"
+  request_changes_workflow: false
+  high_level_summary: true
+  poem: true
+  review_status: true
+  collapse_walkthrough: false
+  auto_review:
+    enabled: true
+    drafts: true
+chat:
+  auto_reply: true
@@ -17,7 +17,3 @@ LICENSE
 .vscode

 *.sock
-
-node_modules/
-package-lock.json
-package.json
@@ -1,16 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 2
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true
-max_line_length = 120
-
-[*.go]
-indent_style = tab
-
-[Makefile]
-indent_style = tab
@@ -6,16 +6,14 @@ body:
  - type: checkboxes
    attributes:
      label: Is this a support request?
-      description: This issue tracker is for bugs and feature requests only. If you need
-        help, please use ask in our Discord community
+      description: This issue tracker is for bugs and feature requests only. If you need help, please use ask in our Discord community
      options:
        - label: This is not a support request
          required: true
  - type: checkboxes
    attributes:
      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the bug you
-        encountered.
+      description: Please search to see if an issue already exists for the bug you encountered.
      options:
        - label: I have searched the existing issues
          required: true
@@ -46,19 +44,10 @@ body:
    attributes:
      label: Environment
      description: |
-        Please provide information about your environment.
-        If you are using a container, always provide the headscale version and not only the Docker image version.
-        Please do not put "latest".
-
-        Describe your "headscale network". Is there a lot of nodes, are the nodes all interconnected, are some subnet routers?
-
-        If you are experiencing a problem during an upgrade, please provide the versions of the old and new versions of Headscale and Tailscale.
-
        examples:
-          - **OS**: Ubuntu 24.04
-          - **Headscale version**: 0.24.3
-          - **Tailscale version**: 1.80.0
-          - **Number of nodes**: 20
+          - **OS**: Ubuntu 20.04
+          - **Headscale version**: 0.22.3
+          - **Tailscale version**: 1.64.0
      value: |
        - OS:
        - Headscale version:
@@ -76,31 +65,19 @@ body:
          required: false
  - type: textarea
    attributes:
-      label: Debug information
+      label: Anything else?
      description: |
-        Please have a look at our [Debugging and troubleshooting
-        guide](https://headscale.net/development/ref/debug/) to learn about
-        common debugging techniques.
-
-        Links? References? Anything that will give us more context about the issue you are encountering.
-        If **any** of these are omitted we will likely close your issue, do **not** ignore them.
+        Links? References? Anything that will give us more context about the issue you are encountering!

        - Client netmap dump (see below)
-        - Policy configuration
+        - ACL configuration
        - Headscale configuration
-        - Headscale log (with `trace` enabled)

        Dump the netmap of tailscale clients:
        `tailscale debug netmap > DESCRIPTIVE_NAME.json`

-        Dump the status of tailscale clients:
-        `tailscale status --json > DESCRIPTIVE_NAME.json`
-
-        Get the logs of a Tailscale client that is not working as expected.
-        `tailscale debug daemon-logs`
+        Please provide information describing the netmap, which client, which headscale version etc.

        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
-        **Ensure** you use formatting for files you attach.
-        Do **not** paste in long files.
    validations:
-      required: true
+      required: false
@@ -3,9 +3,9 @@ blank_issues_enabled: false

 # Contact links
 contact_links:
-  - name: "headscale Discord community"
-    url: "https://discord.gg/c84AZQhmpx"
-    about: "Please ask and answer questions about usage of headscale here."
  - name: "headscale usage documentation"
-    url: "https://headscale.net/"
+    url: "https://github.com/juanfont/headscale/blob/main/docs"
    about: "Find documentation about how to configure and run headscale."
+  - name: "headscale Discord community"
+    url: "https://discord.gg/xGj2TuqyxY"
+    about: "Please ask and answer questions about usage of headscale here."
@@ -1,80 +0,0 @@
-Thank you for taking the time to report this issue.
-
-To help us investigate and resolve this, we need more information. Please provide the following:
-
-> [!TIP]
-> Most issues turn out to be configuration errors rather than bugs. We encourage you to discuss your problem in our [Discord community](https://discord.gg/c84AZQhmpx) **before** opening an issue. The community can often help identify misconfigurations quickly, saving everyone time.
-
-## Required Information
-
-### Environment Details
-
- **Headscale version**: (run `headscale version`)
- **Tailscale client version**: (run `tailscale version`)
- **Operating System**: (e.g., Ubuntu 24.04, macOS 14, Windows 11)
- **Deployment method**: (binary, Docker, Kubernetes, etc.)
- **Reverse proxy**: (if applicable: nginx, Traefik, Caddy, etc. - include configuration)
-
-### Debug Information
-
-Please follow our [Debugging and Troubleshooting Guide](https://headscale.net/stable/ref/debug/) and provide:
-
-1. **Client netmap dump** (from affected Tailscale client):
-
-   ```bash
-   tailscale debug netmap > netmap.json
-   ```
-
-2. **Client status dump** (from affected Tailscale client):
-
-   ```bash
-   tailscale status --json > status.json
-   ```
-
-3. **Tailscale client logs** (if experiencing client issues):
-
-   ```bash
-   tailscale debug daemon-logs
-   ```
-
-   > [!IMPORTANT]
-   > We need logs from **multiple nodes** to understand the full picture:
-   >
-   > - The node(s) initiating connections
-   > - The node(s) being connected to
-   >
-   > Without logs from both sides, we cannot diagnose connectivity issues.
-
-4. **Headscale server logs** with `log.level: trace` enabled
-
-5. **Headscale configuration** (with sensitive values redacted - see rules below)
-
-6. **ACL/Policy configuration** (if using ACLs)
-
-7. **Proxy/Docker configuration** (if applicable - nginx.conf, docker-compose.yml, Traefik config, etc.)
-
-## Formatting Requirements
-
- **Attach long files** - Do not paste large logs or configurations inline. Use GitHub file attachments or GitHub Gists.
- **Use proper Markdown** - Format code blocks, logs, and configurations with appropriate syntax highlighting.
- **Structure your response** - Use the headings above to organize your information clearly.
-
-## Redaction Rules
-
-> [!CAUTION]
-> **Replace, do not remove.** Removing information makes debugging impossible.
-
-When redacting sensitive information:
-
- ✅ **Replace consistently** - If you change `alice@company.com` to `user1@example.com`, use `user1@example.com` everywhere (logs, config, policy, etc.)
- ✅ **Use meaningful placeholders** - `user1@example.com`, `bob@example.com`, `my-secret-key` are acceptable
- ❌ **Never remove information** - Gaps in data prevent us from correlating events across logs
- ❌ **Never redact IP addresses** - We need the actual IPs to trace network paths and identify issues
-
-**If redaction rules are not followed, we will be unable to debug the issue and will have to close it.**
-
---
-
-**Note:** This issue will be automatically closed in 3 days if no additional information is provided. Once you reply with the requested information, the `needs-more-info` label will be removed automatically.
-
-If you need help gathering this information, please visit our [Discord community](https://discord.gg/c84AZQhmpx).
@@ -1,15 +0,0 @@
-Thank you for reaching out.
-
-This issue tracker is used for **bug reports and feature requests** only. Your question appears to be a support or configuration question rather than a bug report.
-
-For help with setup, configuration, or general questions, please visit our [Discord community](https://discord.gg/c84AZQhmpx) where the community and maintainers can assist you in real-time.
-
-**Before posting in Discord, please check:**
-
- [Documentation](https://headscale.net/)
- [FAQ](https://headscale.net/stable/faq/)
- [Debugging and Troubleshooting Guide](https://headscale.net/stable/ref/debug/)
-
-If after troubleshooting you determine this is actually a bug, please open a new issue with the required debug information from the troubleshooting guide.
-
-This issue has been automatically closed.
@@ -5,26 +5,24 @@ on:
    branches:
      - main
  pull_request:
+    branches:
+      - main

 concurrency:
  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
 jobs:
  build-nix:
    runs-on: ubuntu-latest
    permissions: write-all
    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 2
      - name: Get changed files
        id: changed-files
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        uses: dorny/paths-filter@v3
        with:
          filters: |
            files:
@@ -33,24 +31,29 @@ jobs:
              - '**/*.go'
              - 'integration_test/'
              - 'config-example.yaml'
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
+      - uses: DeterminateSystems/nix-installer-action@main
        if: steps.changed-files.outputs.files == 'true'
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
        if: steps.changed-files.outputs.files == 'true'

-      - name: Check vendor hash
-        id: vendorhash
+      - name: Run nix build
+        id: build
        if: steps.changed-files.outputs.files == 'true'
        run: |
-          go run ./cmd/vendorhash check | tee check-result
-          {
-            grep '^expected_sri=' check-result || true
-            grep '^actual_sri='   check-result || true
-          } >> "$GITHUB_OUTPUT"
+          nix build |& tee build-result
+          BUILD_STATUS="${PIPESTATUS[0]}"

-      - name: Vendor hash diverging
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        if: failure() && steps.vendorhash.outcome == 'failure'
+          OLD_HASH=$(cat build-result | grep specified: | awk -F ':' '{print $2}' | sed 's/ //g')
+          NEW_HASH=$(cat build-result | grep got: | awk -F ':' '{print $2}' | sed 's/ //g')
+
+          echo "OLD_HASH=$OLD_HASH" >> $GITHUB_OUTPUT
+          echo "NEW_HASH=$NEW_HASH" >> $GITHUB_OUTPUT
+
+          exit $BUILD_STATUS
+
+      - name: Nix gosum diverging
+        uses: actions/github-script@v6
+        if: failure() && steps.build.outcome == 'failure'
        with:
          github-token: ${{secrets.GITHUB_TOKEN}}
          script: |
@@ -58,14 +61,10 @@ jobs:
              pull_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
-              body: 'Vendor hash in `flakehashes.json` is stale (was `${{ steps.vendorhash.outputs.expected_sri }}`, should be `${{ steps.vendorhash.outputs.actual_sri }}`). Run `go run ./cmd/vendorhash update` and commit the result.'
+              body: 'Nix build failed with wrong gosum, please update "vendorSha256" (${{ steps.build.outputs.OLD_HASH }}) for the "headscale" package in flake.nix with the new SHA: ${{ steps.build.outputs.NEW_HASH }}'
            })

-      - name: Run nix build
-        if: steps.changed-files.outputs.files == 'true'
-        run: nix build --fallback
-
-      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+      - uses: actions/upload-artifact@v4
        if: steps.changed-files.outputs.files == 'true'
        with:
          name: headscale-linux
@@ -75,21 +74,22 @@ jobs:
    strategy:
      matrix:
        env:
+          - "GOARCH=arm   GOOS=linux GOARM=5"
+          - "GOARCH=arm   GOOS=linux GOARM=6"
+          - "GOARCH=arm   GOOS=linux GOARM=7"
          - "GOARCH=arm64 GOOS=linux"
+          - "GOARCH=386   GOOS=linux"
          - "GOARCH=amd64 GOOS=linux"
          - "GOARCH=arm64 GOOS=darwin"
          - "GOARCH=amd64 GOOS=darwin"
    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
+      - uses: actions/checkout@v4
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

      - name: Run go cross compile
-        env:
-          CGO_ENABLED: 0
-        run: env ${{ matrix.env }} go build -o "headscale"
-          ./cmd/headscale
-      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        run: env ${{ matrix.env }} nix develop --command -- go build -o "headscale" ./cmd/headscale
+      - uses: actions/upload-artifact@v4
        with:
          name: "headscale-${{ matrix.env }}"
          path: "headscale"
@@ -1,54 +0,0 @@
-name: Check Generated Files
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
-jobs:
-  check-generated:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          fetch-depth: 2
-      - name: Get changed files
-        id: changed-files
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            files:
-              - '*.nix'
-              - 'go.*'
-              - '**/*.go'
-              - 'tools/**'
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-        if: steps.changed-files.outputs.files == 'true'
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-        if: steps.changed-files.outputs.files == 'true'
-
-      - name: Run make generate
-        if: steps.changed-files.outputs.files == 'true'
-        run: make generate
-
-      - name: Check for uncommitted changes
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          if ! git diff --exit-code; then
-            echo "❌ Generated files are not up to date!"
-            echo "Please run 'make generate' and commit the changes."
-            exit 1
-          else
-            echo "✅ All generated files are up to date."
-          fi
@@ -6,20 +6,16 @@ concurrency:
  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
 jobs:
  check-tests:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 2
      - name: Get changed files
        id: changed-files
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        uses: dorny/paths-filter@v3
        with:
          filters: |
            files:
@@ -28,15 +24,15 @@ jobs:
              - '**/*.go'
              - 'integration_test/'
              - 'config-example.yaml'
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
+      - uses: DeterminateSystems/nix-installer-action@main
        if: steps.changed-files.outputs.files == 'true'
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
        if: steps.changed-files.outputs.files == 'true'

      - name: Generate and check integration tests
        if: steps.changed-files.outputs.files == 'true'
        run: |
-          (cd .github/workflows && go generate)
+          nix develop --command bash -c "cd cmd/gh-action-integration-generator/ && go generate"
          git diff --exit-code .github/workflows/test-integration.yaml

      - name: Show missing tests
@@ -1,108 +0,0 @@
---
-name: Build (main)
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "*.nix"
-      - "go.*"
-      - "**/*.go"
-      - ".github/workflows/container-main.yml"
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.sha }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
-jobs:
-  container:
-    if: github.repository == 'juanfont/headscale'
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Login to DockerHub
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to GHCR
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-
-      - name: Set commit timestamp
-        run: echo "SOURCE_DATE_EPOCH=$(git log -1 --format=%ct)" >> $GITHUB_ENV
-
-      - name: Build and push to GHCR
-        env:
-          KO_DOCKER_REPO: ghcr.io/juanfont/headscale
-          KO_DEFAULTBASEIMAGE: gcr.io/distroless/base-debian13
-          CGO_ENABLED: "0"
-        run: |
-          ko build \
-            --bare \
-            --platform=linux/amd64,linux/arm64 \
-            --tags=main-${GITHUB_SHA::7},development \
-            ./cmd/headscale
-
-      - name: Push to Docker Hub
-        env:
-          KO_DOCKER_REPO: headscale/headscale
-          KO_DEFAULTBASEIMAGE: gcr.io/distroless/base-debian13
-          CGO_ENABLED: "0"
-        run: |
-          ko build \
-            --bare \
-            --platform=linux/amd64,linux/arm64 \
-            --tags=main-${GITHUB_SHA::7},development \
-            ./cmd/headscale
-
-  binaries:
-    if: github.repository == 'juanfont/headscale'
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - goos: linux
-            goarch: amd64
-          - goos: linux
-            goarch: arm64
-          - goos: darwin
-            goarch: amd64
-          - goos: darwin
-            goarch: arm64
-    steps:
-      - name: Checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-
-      - name: Build binary
-        env:
-          CGO_ENABLED: "0"
-          GOOS: ${{ matrix.goos }}
-          GOARCH: ${{ matrix.goarch }}
-        run: go build -o headscale ./cmd/headscale
-
-      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: headscale-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: headscale
@@ -21,15 +21,15 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Install python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5
        with:
          python-version: 3.x
      - name: Setup cache
-        uses: actions/cache@a7833574556fa59680c1b7cb190c1735db73ebf0 # v5.0.0
+        uses: actions/cache@v4
        with:
          key: ${{ github.ref }}
          path: .cache
@@ -11,13 +11,13 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v4
      - name: Install python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5
        with:
          python-version: 3.x
      - name: Setup cache
-        uses: actions/cache@a7833574556fa59680c1b7cb190c1735db73ebf0 # v5.0.0
+        uses: actions/cache@v4
        with:
          key: ${{ github.ref }}
          path: .cache
@@ -1,39 +0,0 @@
-name: Cache GC
-
-# Garbage collection for the hestia binary cache. Must run on the default
-# branch: a PR job's cache scope is read-only towards the default branch and
-# dies with the PR, but the default-branch scope grows forever without GC.
-
-concurrency:
-  group: hestia-gc
-  cancel-in-progress: false
-
-on:
-  schedule:
-    # Daily, off-peak (UTC).
-    - cron: "23 3 * * *"
-  workflow_dispatch:
-    inputs:
-      dry-run:
-        description: Plan only; do not repack, touch, or delete anything.
-        type: boolean
-        default: false
-
-permissions:
-  contents: read
-
-jobs:
-  gc:
-    runs-on: ubuntu-latest
-    permissions:
-      # REST cache deletes need actions:write.
-      actions: write
-      contents: read
-    steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: Run garbage collection
-        run: '"${HESTIA_BIN}" gc ${{ inputs.dry-run && ''--dry-run'' || '''' }}'
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
@@ -1,145 +0,0 @@
-package main
-
-//go:generate go run ./gh-action-integration-generator.go
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"os/exec"
-	"strings"
-)
-
-// testsToSplit defines tests that should be split into multiple CI jobs.
-// Key is the test function name, value is a list of subtest prefixes.
-// Each prefix becomes a separate CI job as "TestName/prefix".
-//
-// Example: [TestAutoApproveMultiNetwork] has subtests like:
-//   - TestAutoApproveMultiNetwork/authkey-tag-advertiseduringup-false-pol-database
-//   - TestAutoApproveMultiNetwork/webauth-user-advertiseduringup-true-pol-file
-//
-// Splitting by approver type (tag, user, group) creates 6 CI jobs with 4 tests each:
-//   - TestAutoApproveMultiNetwork/authkey-tag.* (4 tests)
-//   - TestAutoApproveMultiNetwork/authkey-user.* (4 tests)
-//   - TestAutoApproveMultiNetwork/authkey-group.* (4 tests)
-//   - TestAutoApproveMultiNetwork/webauth-tag.* (4 tests)
-//   - TestAutoApproveMultiNetwork/webauth-user.* (4 tests)
-//   - TestAutoApproveMultiNetwork/webauth-group.* (4 tests)
-//
-// This reduces load per CI job (4 tests instead of 12) to avoid infrastructure
-// flakiness when running many sequential Docker-based integration tests.
-var testsToSplit = map[string][]string{
-	"TestAutoApproveMultiNetwork": {
-		"authkey-tag",
-		"authkey-user",
-		"authkey-group",
-		"webauth-tag",
-		"webauth-user",
-		"webauth-group",
-	},
-}
-
-// expandTests takes a list of test names and expands any that need splitting
-// into multiple subtest patterns.
-func expandTests(tests []string) []string {
-	var expanded []string
-	for _, test := range tests {
-		if prefixes, ok := testsToSplit[test]; ok {
-			// This test should be split into multiple jobs.
-			// We append ".*" to each prefix because the CI runner wraps patterns
-			// with ^...$ anchors. Without ".*", a pattern like "authkey$" wouldn't
-			// match "authkey-tag-advertiseduringup-false-pol-database".
-			for _, prefix := range prefixes {
-				expanded = append(expanded, fmt.Sprintf("%s/%s.*", test, prefix))
-			}
-		} else {
-			expanded = append(expanded, test)
-		}
-	}
-	return expanded
-}
-
-func findTests() []string {
-	rgBin, err := exec.LookPath("rg")
-	if err != nil {
-		log.Fatalf("failed to find rg (ripgrep) binary")
-	}
-
-	args := []string{
-		"--type", "go",
-		"--regexp", "func (Test.+)\\(.*",
-		"--max-depth", "1",
-		"../../integration/",
-		"--replace", "$1",
-		"--sort", "path",
-		"--no-line-number",
-		"--no-filename",
-		"--no-heading",
-	}
-
-	cmd := exec.Command(rgBin, args...)
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	err = cmd.Run()
-	if err != nil {
-		log.Fatalf("failed to run command: %s", err)
-	}
-
-	tests := strings.Split(strings.TrimSpace(out.String()), "\n")
-	return tests
-}
-
-func updateYAML(tests []string, jobName string, testPath string) {
-	testsForYq := fmt.Sprintf("[%s]", strings.Join(tests, ", "))
-
-	yqCommand := fmt.Sprintf(
-		"yq eval '.jobs.%s.strategy.matrix.test = %s' %s -i",
-		jobName,
-		testsForYq,
-		testPath,
-	)
-	cmd := exec.Command("bash", "-c", yqCommand)
-
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-	if err != nil {
-		log.Printf("stdout: %s", stdout.String())
-		log.Printf("stderr: %s", stderr.String())
-		log.Fatalf("failed to run yq command: %s", err)
-	}
-
-	fmt.Printf("YAML file (%s) job %s updated successfully\n", testPath, jobName)
-}
-
-func main() {
-	tests := findTests()
-
-	// Expand tests that should be split into multiple jobs
-	expandedTests := expandTests(tests)
-
-	quotedTests := make([]string, len(expandedTests))
-	for i, test := range expandedTests {
-		quotedTests[i] = fmt.Sprintf("\"%s\"", test)
-	}
-
-	// Define selected tests for PostgreSQL
-	postgresTestNames := []string{
-		"TestACLAllowUserDst",
-		"TestPingAllByIP",
-		"TestEphemeral2006DeletedTooQuickly",
-		"TestPingAllByIPManyUpDown",
-		"TestSubnetRouterMultiNetwork",
-	}
-
-	quotedPostgresTests := make([]string, len(postgresTestNames))
-	for i, test := range postgresTestNames {
-		quotedPostgresTests[i] = fmt.Sprintf("\"%s\"", test)
-	}
-
-	// Update both SQLite and PostgreSQL job matrices
-	updateYAML(quotedTests, "sqlite", "./test-integration.yaml")
-	updateYAML(quotedPostgresTests, "postgres", "./test-integration.yaml")
-}
@@ -11,13 +11,13 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@v4
        with:
          # [Required] Access token with `workflow` scope.
          token: ${{ secrets.WORKFLOW_SECRET }}

      - name: Run GitHub Actions Version Updater
-        uses: saadmk11/github-actions-version-updater@d8781caf11d11168579c8e5e94f62b068038f442 # v0.9.0
+        uses: saadmk11/github-actions-version-updater@v0.8.1
        with:
          # [Required] Access token with `workflow` scope.
          token: ${{ secrets.WORKFLOW_SECRET }}
@@ -1,146 +0,0 @@
-name: Integration Test Template
-
-on:
-  workflow_call:
-    inputs:
-      test:
-        required: true
-        type: string
-      postgres_flag:
-        required: false
-        type: string
-        default: ""
-      database_name:
-        required: true
-        type: string
-
-jobs:
-  test:
-    runs-on: ubuntu-24.04-arm
-    env:
-      # Github does not allow us to access secrets in pull requests,
-      # so this env var is used to check if we have the secret or not.
-      # If we have the secrets, meaning we are running on push in a fork,
-      # there might be secrets available for more debugging.
-      # If TS_OAUTH_CLIENT_ID and TS_OAUTH_SECRET is set, then the job
-      # will join a debug tailscale network, set up SSH and a tmux session.
-      # The SSH will be configured to use the SSH key of the Github user
-      # that triggered the build.
-      HAS_TAILSCALE_SECRET: ${{ secrets.TS_OAUTH_CLIENT_ID }}
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          fetch-depth: 2
-      - name: Tailscale
-        if: ${{ env.HAS_TAILSCALE_SECRET }}
-        uses: tailscale/github-action@a392da0a182bba0e9613b6243ebd69529b1878aa # v4.1.0
-        with:
-          oauth-client-id: ${{ secrets.TS_OAUTH_CLIENT_ID }}
-          oauth-secret: ${{ secrets.TS_OAUTH_SECRET }}
-          tags: tag:gh
-      - name: Setup SSH server for Actor
-        if: ${{ env.HAS_TAILSCALE_SECRET }}
-        uses: alexellis/setup-sshd-actor@master
-      - name: Download headscale image
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: headscale-image
-          path: /tmp/artifacts
-      - name: Download tailscale HEAD image
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: tailscale-head-image
-          path: /tmp/artifacts
-      - name: Download tailscale released images
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: tailscale-released-images
-          path: /tmp/artifacts
-      - name: Download hi binary
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: hi-binary
-          path: /tmp/artifacts
-      - name: Download Go cache
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: go-cache
-          path: /tmp/artifacts
-      - name: Download postgres image
-        if: ${{ inputs.postgres_flag == '--postgres=1' }}
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: postgres-image
-          path: /tmp/artifacts
-      - name: Force overlay2 storage driver
-        run: |
-          sudo mkdir -p /etc/docker
-          echo '{"storage-driver":"overlay2"}' | sudo tee /etc/docker/daemon.json
-          sudo systemctl restart docker
-          docker version
-      - name: Load br_netfilter for in-cluster service routing
-        if: inputs.test == 'TestK8sOperator'
-        # TestK8sOperator runs k3s in a container; without br_netfilter on the
-        # host, bridged pod-to-pod traffic skips kube-proxy's ClusterIP DNAT and
-        # in-cluster DNS (kube-dns) is unreachable. The module cannot be loaded
-        # from inside the unprivileged-module rancher/k3s image, so load it here.
-        run: sudo modprobe br_netfilter
-      - name: Login to Docker Hub
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_CI_USERNAME }}
-          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_CI_TOKEN }}
-        if: env.DOCKERHUB_USERNAME != ''
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: ${{ env.DOCKERHUB_USERNAME }}
-          password: ${{ env.DOCKERHUB_TOKEN }}
-      - name: Load Docker images, Go cache, and prepare binary
-        run: |
-          gunzip -c /tmp/artifacts/headscale-image.tar.gz | docker load
-          gunzip -c /tmp/artifacts/tailscale-head-image.tar.gz | docker load
-          gunzip -c /tmp/artifacts/tailscale-released-images.tar.gz | docker load
-          if [ -f /tmp/artifacts/postgres-image.tar.gz ]; then
-            gunzip -c /tmp/artifacts/postgres-image.tar.gz | docker load
-          fi
-          chmod +x /tmp/artifacts/hi
-          docker images
-          # Extract Go cache to host directories for bind mounting
-          mkdir -p /tmp/go-cache
-          tar -xzf /tmp/artifacts/go-cache.tar.gz -C /tmp/go-cache
-          ls -la /tmp/go-cache/ /tmp/go-cache/.cache/
-      - name: Run Integration Test
-        env:
-          HEADSCALE_INTEGRATION_HEADSCALE_IMAGE: headscale:${{ github.sha }}
-          HEADSCALE_INTEGRATION_TAILSCALE_IMAGE: tailscale-head:${{ github.sha }}
-          HEADSCALE_INTEGRATION_POSTGRES_IMAGE: ${{ inputs.postgres_flag == '--postgres=1' && format('postgres:{0}', github.sha) || '' }}
-          HEADSCALE_INTEGRATION_GO_CACHE: /tmp/go-cache/go
-          HEADSCALE_INTEGRATION_GO_BUILD_CACHE: /tmp/go-cache/.cache/go-build
-          # Mirror the docker/login-action secrets into env so the
-          # dockertestutil.Credentials resolver picks them up directly
-          # (otherwise it falls back to parsing ~/.docker/config.json,
-          # which works but is one step further from the source).
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_CI_USERNAME }}
-          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_CI_TOKEN }}
-        run: /tmp/artifacts/hi run --stats --ts-memory-limit=300 --hs-memory-limit=1500 "^${{ inputs.test }}$" \
-          --timeout=120m \
-          ${{ inputs.postgres_flag }}
-      # Sanitize test name for artifact upload (replace invalid characters: " : < > | * ? \ / with -)
-      - name: Sanitize test name for artifacts
-        if: always()
-        id: sanitize
-        run: echo "name=${TEST_NAME//[\":<>|*?\\\/]/-}" >> $GITHUB_OUTPUT
-        env:
-          TEST_NAME: ${{ inputs.test }}
-      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        if: always()
-        with:
-          name: ${{ inputs.database_name }}-${{ steps.sanitize.outputs.name }}-logs
-          path: "control_logs/*/*.log"
-      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        if: always()
-        with:
-          name: ${{ inputs.database_name }}-${{ steps.sanitize.outputs.name }}-artifacts
-          path: control_logs/
-      - name: Setup a blocking tmux session
-        if: ${{ env.HAS_TAILSCALE_SECRET }}
-        uses: alexellis/block-with-tmux-action@master
@@ -0,0 +1,75 @@
+name: Lint
+
+on: [pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  golangci-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+      - name: Get changed files
+        id: changed-files
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            files:
+              - '*.nix'
+              - 'go.*'
+              - '**/*.go'
+              - 'integration_test/'
+              - 'config-example.yaml'
+      - uses: DeterminateSystems/nix-installer-action@main
+        if: steps.changed-files.outputs.files == 'true'
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+        if: steps.changed-files.outputs.files == 'true'
+
+      - name: golangci-lint
+        if: steps.changed-files.outputs.files == 'true'
+        run: nix develop --command -- golangci-lint run --new-from-rev=${{github.event.pull_request.base.sha}} --out-format=colored-line-number
+
+  prettier-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+      - name: Get changed files
+        id: changed-files
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            files:
+              - '*.nix'
+              - '**/*.md'
+              - '**/*.yml'
+              - '**/*.yaml'
+              - '**/*.ts'
+              - '**/*.js'
+              - '**/*.sass'
+              - '**/*.css'
+              - '**/*.scss'
+              - '**/*.html'
+      - uses: DeterminateSystems/nix-installer-action@main
+        if: steps.changed-files.outputs.files == 'true'
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+        if: steps.changed-files.outputs.files == 'true'
+
+      - name: Prettify code
+        if: steps.changed-files.outputs.files == 'true'
+        run: nix develop --command -- prettier --no-error-on-unmatched-pattern --ignore-unknown --check **/*.{ts,js,md,yaml,yml,sass,css,scss,html}
+
+  proto-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+
+      - name: Buf lint
+        run: nix develop --command -- buf lint proto
@@ -1,28 +0,0 @@
-name: Needs More Info - Post Comment
-
-on:
-  issues:
-    types: [labeled]
-
-jobs:
-  post-comment:
-    if: >-
-      github.event.label.name == 'needs-more-info' &&
-      github.repository == 'juanfont/headscale'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      contents: read
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          sparse-checkout: .github/label-response/needs-more-info.md
-          sparse-checkout-cone-mode: false
-
-      - name: Post instruction comment
-        run: gh issue comment "$NUMBER" --body-file .github/label-response/needs-more-info.md
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
@@ -1,99 +0,0 @@
-name: Needs More Info - Timer
-
-on:
-  schedule:
-    - cron: "0 0 * * *" # Daily at midnight UTC
-  issue_comment:
-    types: [created]
-  workflow_dispatch:
-
-jobs:
-  # When a non-bot user comments on a needs-more-info issue, remove the label.
-  remove-label-on-response:
-    if: >-
-      github.repository == 'juanfont/headscale' &&
-      github.event_name == 'issue_comment' &&
-      github.event.comment.user.type != 'Bot' &&
-      contains(github.event.issue.labels.*.name, 'needs-more-info')
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Remove needs-more-info label
-        run: gh issue edit "$NUMBER" --remove-label needs-more-info
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
-
-  # On schedule, close issues that have had no human response for 3 days.
-  close-stale:
-    if: >-
-      github.repository == 'juanfont/headscale' &&
-      github.event_name != 'issue_comment'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - uses: hustcer/setup-nu@920172d92eb04671776f3ba69d605d3b09351c30 # v3.22
-        with:
-          version: "*"
-
-      - name: Close stale needs-more-info issues
-        shell: nu {0}
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-        run: |
-          let issues = (gh issue list
-            --repo $env.GH_REPO
-            --label "needs-more-info"
-            --state open
-            --json number
-            | from json)
-
-          for issue in $issues {
-            let number = $issue.number
-            print $"Checking issue #($number)"
-
-            # Find when needs-more-info was last added
-            let events = (gh api $"repos/($env.GH_REPO)/issues/($number)/events"
-              --paginate | from json)
-            let label_event = ($events
-              | where event == "labeled"
-              | where label.name == "needs-more-info"
-              | last)
-            let label_added_at = ($label_event.created_at | into datetime)
-
-            # Check for non-bot comments after the label was added
-            let comments = (gh api $"repos/($env.GH_REPO)/issues/($number)/comments"
-              --paginate | from json)
-            let human_responses = ($comments
-              | where user.type != "Bot"
-              | where { ($in.created_at | into datetime) > $label_added_at })
-
-            if ($human_responses | length) > 0 {
-              print $"  Human responded, removing label"
-              gh issue edit $number --repo $env.GH_REPO --remove-label needs-more-info
-              continue
-            }
-
-            # Check if 3 days have passed
-            let elapsed = (date now) - $label_added_at
-            if $elapsed < 3day {
-              print $"  Only ($elapsed | format duration day) elapsed, skipping"
-              continue
-            }
-
-            print $"  No response for ($elapsed | format duration day), closing"
-            let message = [
-              "This issue has been automatically closed because no additional information was provided within 3 days."
-              ""
-              "If you have the requested information, please open a new issue and include the debug information requested above."
-              ""
-              "Thank you for your understanding."
-            ] | str join "\n"
-            gh issue comment $number --repo $env.GH_REPO --body $message
-            gh issue close $number --repo $env.GH_REPO --reason "not planned"
-            gh issue edit $number --repo $env.GH_REPO --remove-label needs-more-info
-          }
@@ -1,56 +0,0 @@
-name: Nix Flake Checks
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-# Each job only runs `nix build .#checks.<system>.<name>`; the check logic lives
-# in flake.nix via the flake-checks library. The fileset-filtered checks hit the
-# hestia cache when their inputs are unchanged, so no changed-files gating.
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: build
-        run: nix build -L .#checks.x86_64-linux.build
-
-  gotest:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: gotest
-        run: nix build -L .#checks.x86_64-linux.gotest
-
-  golangci-lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: golangci-lint
-        run: nix build -L .#checks.x86_64-linux.golangci-lint
-
-  formatting:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: formatting
-        run: nix build -L .#checks.x86_64-linux.formatting
@@ -1,51 +0,0 @@
-name: NixOS Module Tests
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  nix-module-check:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          fetch-depth: 2
-
-      - name: Get changed files
-        id: changed-files
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            nix:
-              - 'nix/**'
-              - 'flake.nix'
-              - 'flake.lock'
-            go:
-              - 'go.*'
-              - '**/*.go'
-              - 'cmd/**'
-              - 'hscontrol/**'
-
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-        if: steps.changed-files.outputs.nix == 'true' || steps.changed-files.outputs.go == 'true'
-
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-        if: steps.changed-files.outputs.nix == 'true' || steps.changed-files.outputs.go == 'true'
-
-      - name: Run NixOS module tests
-        if: steps.changed-files.outputs.nix == 'true' || steps.changed-files.outputs.go == 'true'
-        run: |
-          echo "Running NixOS module integration test..."
-          nix build .#checks.x86_64-linux.headscale -L --fallback
@@ -7,37 +7,33 @@ on:
      - "*" # triggers only if push new tag version
  workflow_dispatch:

-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
 jobs:
  goreleaser:
    if: github.repository == 'juanfont/headscale'
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Login to DockerHub
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Login to GHCR
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

      - name: Run goreleaser
-        run: goreleaser release --clean
+        run: nix develop --command -- goreleaser release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,36 +0,0 @@
-name: Server Tests
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-# hscontrol/servertest is excluded from the sandboxed gotest flake check: it is
-# slow (10s+ convergence cases) and timing-sensitive (race/stress/HA property
-# tests), so it runs here in the devShell with a generous timeout instead.
-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
-
-permissions:
-  contents: read
-
-jobs:
-  servertest:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-
-      - name: go test ./hscontrol/servertest
-        env:
-          CGO_ENABLED: "0"
-        run: go test -timeout=20m ./hscontrol/servertest/...
@@ -12,16 +12,14 @@ jobs:
      issues: write
      pull-requests: write
    steps:
-      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+      - uses: actions/stale@v9
        with:
          days-before-issue-stale: 90
          days-before-issue-close: 7
          stale-issue-label: "stale"
-          stale-issue-message: "This issue is stale because it has been open for 90 days with no
-            activity."
-          close-issue-message: "This issue was closed because it has been inactive for 14 days
-            since being marked as stale."
+          stale-issue-message: "This issue is stale because it has been open for 90 days with no activity."
+          close-issue-message: "This issue was closed because it has been inactive for 14 days since being marked as stale."
          days-before-pr-stale: -1
          days-before-pr-close: -1
-          exempt-issue-labels: "no-stale-bot,needs-more-info"
+          exempt-issue-labels: "no-stale-bot"
          repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -1,30 +0,0 @@
-name: Support Request - Close Issue
-
-on:
-  issues:
-    types: [labeled]
-
-jobs:
-  close-support-request:
-    if: >-
-      github.event.label.name == 'support-request' &&
-      github.repository == 'juanfont/headscale'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      contents: read
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          sparse-checkout: .github/label-response/support-request.md
-          sparse-checkout-cone-mode: false
-
-      - name: Post comment and close issue
-        run: |
-          gh issue comment "$NUMBER" --body-file .github/label-response/support-request.md
-          gh issue close "$NUMBER" --reason "not planned"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
@@ -1,4 +1,4 @@
-name: integration
+name: Integration Tests
 # To debug locally on a branch, and when needing secrets
 # change this to include `push` so the build is ran on
 # the main repository.
@@ -6,215 +6,9 @@ on: [pull_request]
 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true
-defaults:
-  run:
-    shell: nix develop --fallback --command bash -e {0}
 jobs:
-  # build: Builds binaries and Docker images once, uploads as artifacts for reuse.
-  # build-postgres: Pulls postgres image separately to avoid Docker Hub rate limits.
-  # build-tailscale-released: Pre-pulls released Tailscale images from ghcr.io
-  # so fork PRs (no DOCKERHUB_USERNAME secret) don't hit Docker Hub rate
-  # limits at test time.
-  # sqlite: Runs all integration tests with SQLite backend.
-  # postgres: Runs a subset of tests with PostgreSQL to verify database compatibility.
-  build:
-    runs-on: ubuntu-24.04-arm
-    outputs:
-      files-changed: ${{ steps.changed-files.outputs.files }}
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          fetch-depth: 2
-      - name: Get changed files
-        id: changed-files
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
-        with:
-          filters: |
-            files:
-              - '*.nix'
-              - 'go.*'
-              - '**/*.go'
-              - 'integration/**'
-              - 'config-example.yaml'
-              - '.github/workflows/test-integration.yaml'
-              - '.github/workflows/integration-test-template.yml'
-              - 'Dockerfile.*'
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-        if: steps.changed-files.outputs.files == 'true'
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-        if: steps.changed-files.outputs.files == 'true'
-      - name: Build binaries and warm Go cache
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          # Build all Go binaries in one nix shell to maximize cache reuse
-          go build -o hi ./cmd/hi
-          CGO_ENABLED=0 GOOS=linux go build -o headscale ./cmd/headscale
-          # Build integration test binary to warm the cache with all dependencies
-          go test -c ./integration -o /dev/null 2>/dev/null || true
-      - name: Upload hi binary
-        if: steps.changed-files.outputs.files == 'true'
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: hi-binary
-          path: hi
-          retention-days: 10
-      - name: Package Go cache
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          # Package Go module cache and build cache
-          tar -czf go-cache.tar.gz -C ~ go .cache/go-build
-      - name: Upload Go cache
-        if: steps.changed-files.outputs.files == 'true'
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: go-cache
-          path: go-cache.tar.gz
-          retention-days: 10
-      - name: Force overlay2 storage driver
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          # Docker 29 runner images default to overlayfs, which breaks
-          # docker build via Go SDK libraries and docker save/load
-          # tarball formats. overlay2 is the long-standing default.
-          # https://github.com/actions/runner-images/issues/13474
-          sudo mkdir -p /etc/docker
-          echo '{"storage-driver":"overlay2"}' | sudo tee /etc/docker/daemon.json
-          sudo systemctl restart docker
-          docker version
-      - name: Login to Docker Hub
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_CI_USERNAME }}
-          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_CI_TOKEN }}
-        if: env.DOCKERHUB_USERNAME != ''
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: ${{ env.DOCKERHUB_USERNAME }}
-          password: ${{ env.DOCKERHUB_TOKEN }}
-      - name: Build headscale image
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          docker build \
-            --file Dockerfile.integration-ci \
-            --tag headscale:${{ github.sha }} \
-            .
-          docker save headscale:${{ github.sha }} | gzip > headscale-image.tar.gz
-      - name: Build tailscale HEAD image
-        if: steps.changed-files.outputs.files == 'true'
-        run: |
-          docker build \
-            --file Dockerfile.tailscale-HEAD \
-            --tag tailscale-head:${{ github.sha }} \
-            .
-          docker save tailscale-head:${{ github.sha }} | gzip > tailscale-head-image.tar.gz
-      - name: Upload headscale image
-        if: steps.changed-files.outputs.files == 'true'
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: headscale-image
-          path: headscale-image.tar.gz
-          retention-days: 10
-      - name: Upload tailscale HEAD image
-        if: steps.changed-files.outputs.files == 'true'
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: tailscale-head-image
-          path: tailscale-head-image.tar.gz
-          retention-days: 10
-  build-postgres:
-    runs-on: ubuntu-24.04-arm
-    needs: build
-    if: needs.build.outputs.files-changed == 'true'
-    steps:
-      - name: Force overlay2 storage driver
-        shell: bash
-        run: |
-          sudo mkdir -p /etc/docker
-          echo '{"storage-driver":"overlay2"}' | sudo tee /etc/docker/daemon.json
-          sudo systemctl restart docker
-          docker version
-      - name: Login to Docker Hub
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_CI_USERNAME }}
-          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_CI_TOKEN }}
-        if: env.DOCKERHUB_USERNAME != ''
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: ${{ env.DOCKERHUB_USERNAME }}
-          password: ${{ env.DOCKERHUB_TOKEN }}
-      - name: Pull and save postgres image
-        shell: bash
-        run: |
-          docker pull postgres:latest
-          docker tag postgres:latest postgres:${{ github.sha }}
-          docker save postgres:${{ github.sha }} | gzip > postgres-image.tar.gz
-      - name: Upload postgres image
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: postgres-image
-          path: postgres-image.tar.gz
-          retention-days: 10
-  build-tailscale-released:
-    runs-on: ubuntu-24.04-arm
-    needs: build
-    if: needs.build.outputs.files-changed == 'true'
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: NixOS/nix-installer-action@6b8548fe06acfb0155a50ab5d561accb215764cc # main
-      - uses: Mic92/hestia/action@ff07bb902a9968ac0c3d0e51d90a606662a375d8 # main
-      - name: Force overlay2 storage driver
-        run: |
-          sudo mkdir -p /etc/docker
-          echo '{"storage-driver":"overlay2"}' | sudo tee /etc/docker/daemon.json
-          sudo systemctl restart docker
-          docker version
-      - name: Login to Docker Hub
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_CI_USERNAME }}
-          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_CI_TOKEN }}
-        if: env.DOCKERHUB_USERNAME != ''
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: ${{ env.DOCKERHUB_USERNAME }}
-          password: ${{ env.DOCKERHUB_TOKEN }}
-      - name: List Tailscale versions to pre-pull
-        id: versions
-        run: |
-          versions=$(go run ./cmd/hi list-versions --set=must --exclude=head)
-          echo "versions=${versions}" >> "$GITHUB_OUTPUT"
-          echo "Pre-pulling: ${versions}"
-      - name: Pull Tailscale images
-        run: |
-          # Releases come from ghcr.io (anonymous, unmetered). The
-          # "unstable" floating tag on ghcr.io has been stale since 2022,
-          # so it still needs to come from Docker Hub. xargs -P 0 fans
-          # out one process per tag and returns non-zero if any pull
-          # fails.
-          refs=""
-          for v in ${{ steps.versions.outputs.versions }}; do
-            if [ "${v}" = "unstable" ]; then
-              refs="${refs} tailscale/tailscale:${v}"
-            else
-              refs="${refs} ghcr.io/tailscale/tailscale:${v}"
-            fi
-          done
-          echo "${refs}" | tr ' ' '\n' | grep -v '^$' \
-            | xargs -P 0 -I{} docker pull "{}"
-          echo "REFS=${refs}" >> "$GITHUB_ENV"
-      - name: Save Tailscale images to tarball
-        run: |
-          # Single docker save with all refs: one consistent snapshot, no
-          # parallel-daemon race.
-          docker save ${REFS} | gzip > tailscale-released-images.tar.gz
-          ls -lh tailscale-released-images.tar.gz
-      - name: Upload Tailscale released images
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: tailscale-released-images
-          path: tailscale-released-images.tar.gz
-          retention-days: 10
-  sqlite:
-    needs: [build, build-tailscale-released]
-    if: needs.build.outputs.files-changed == 'true'
+  integration-test:
+    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
@@ -228,75 +22,35 @@ jobs:
          - TestACLNamedHostsCanReach
          - TestACLDevice1CanAccessDevice2
          - TestPolicyUpdateWhileRunningWithCLIInDatabase
-          - TestACLAutogroupMember
-          - TestACLAutogroupTagged
-          - TestACLAutogroupSelf
-          - TestACLPolicyPropagationOverTime
-          - TestACLTagPropagation
-          - TestACLTagPropagationPortSpecific
-          - TestACLGroupWithUnknownUser
-          - TestACLGroupAfterUserDeletion
-          - TestACLGroupDeletionExactReproduction
-          - TestACLDynamicUnknownUserAddition
-          - TestACLDynamicUnknownUserRemoval
-          - TestAPIAuthenticationBypass
-          - TestAPIAuthenticationBypassCurl
-          - TestRemoteCLIAuthenticationBypass
-          - TestCLIWithConfigAuthenticationBypass
-          - TestAuthKeyLogoutAndReloginSameUser
-          - TestAuthKeyLogoutAndReloginNewUser
-          - TestAuthKeyLogoutAndReloginSameUserExpiredKey
-          - TestAuthKeyDeleteKey
-          - TestAuthKeyLogoutAndReloginRoutesPreserved
          - TestOIDCAuthenticationPingAll
          - TestOIDCExpireNodesBasedOnTokenExpiry
          - TestOIDC024UserCreation
          - TestOIDCAuthenticationWithPKCE
-          - TestOIDCReloginSameNodeNewUser
-          - TestOIDCFollowUpUrl
-          - TestOIDCMultipleOpenedLoginUrls
-          - TestOIDCReloginSameNodeSameUser
-          - TestOIDCExpiryAfterRestart
-          - TestOIDCACLPolicyOnJoin
-          - TestOIDCReloginSameUserRoutesPreserved
          - TestAuthWebFlowAuthenticationPingAll
-          - TestAuthWebFlowLogoutAndReloginSameUser
-          - TestAuthWebFlowLogoutAndReloginNewUser
-          - TestApiKeyCommand
-          - TestApiKeyCommandValidation
-          - TestAuthCommandValidation
-          - TestNodeCommand
-          - TestNodeExpireCommand
-          - TestNodeRenameCommand
-          - TestPreAuthKeyCorrectUserLoggedInCommand
-          - TestTaggedNodesCLIOutput
-          - TestNodeExpireFlagsCommand
-          - TestNodeCommandValidation
-          - TestNodeTagCommand
-          - TestNodeRouteCommands
-          - TestNodeBackfillIPsCommand
-          - TestOAuthClientCommand
-          - TestOAuthClientCommandValidation
-          - TestPolicyCheckCommand
-          - TestSSHTestsRejectFailingPolicy
-          - TestPolicyCommand
-          - TestPolicyBrokenConfigCommand
+          - TestAuthWebFlowLogoutAndRelogin
+          - TestUserCommand
          - TestPreAuthKeyCommand
          - TestPreAuthKeyCommandWithoutExpiry
          - TestPreAuthKeyCommandReusableEphemeral
-          - TestPreAuthKeyDeleteCommand
-          - TestPreAuthKeyCommandValidation
-          - TestServerInfoCommands
-          - TestUserCommand
-          - TestUserCreateCommand
-          - TestUserCommandValidation
+          - TestPreAuthKeyCorrectUserLoggedInCommand
+          - TestApiKeyCommand
+          - TestNodeTagCommand
+          - TestNodeAdvertiseTagCommand
+          - TestNodeCommand
+          - TestNodeExpireCommand
+          - TestNodeRenameCommand
+          - TestNodeMoveCommand
+          - TestPolicyCommand
+          - TestPolicyBrokenConfigCommand
          - TestDERPVerifyEndpoint
          - TestResolveMagicDNS
          - TestResolveMagicDNSExtraRecordsPath
+          - TestValidateResolvConf
          - TestDERPServerScenario
          - TestDERPServerWebsocketScenario
          - TestPingAllByIP
          - TestPingAllByIPPublicDERP
+          - TestAuthKeyLogoutAndRelogin
          - TestEphemeral
          - TestEphemeralInAlternateTimezone
          - TestEphemeral2006DeletedTooQuickly
@@ -304,105 +58,97 @@ jobs:
          - TestTaildrop
          - TestUpdateHostnameFromClient
          - TestExpireNode
-          - TestSetNodeExpiryInFuture
-          - TestDisableNodeExpiry
          - TestNodeOnlineStatus
          - TestPingAllByIPManyUpDown
          - Test2118DeletingOnlineNodePanics
-          - TestGrantCapRelay
-          - TestGrantCapDrive
-          - TestK8sOperator
          - TestEnablingRoutes
          - TestHASubnetRouterFailover
+          - TestEnableDisableAutoApprovedRoute
+          - TestAutoApprovedSubRoute2068
          - TestSubnetRouteACL
-          - TestEnablingExitRoutes
-          - TestExitRoutesWithAutogroupInternetACL
-          - TestSubnetRouterMultiNetwork
-          - TestSubnetRouterMultiNetworkExitNode
-          - TestAutoApproveMultiNetwork/authkey-tag.*
-          - TestAutoApproveMultiNetwork/authkey-user.*
-          - TestAutoApproveMultiNetwork/authkey-group.*
-          - TestAutoApproveMultiNetwork/webauth-tag.*
-          - TestAutoApproveMultiNetwork/webauth-user.*
-          - TestAutoApproveMultiNetwork/webauth-group.*
-          - TestSubnetRouteACLFiltering
-          - TestGrantViaSubnetSteering
-          - TestHASubnetRouterPingFailover
-          - TestHASubnetRouterFailoverBothOffline
-          - TestHASubnetRouterFailoverBothOfflineCablePull
-          - TestHASubnetRouterFailoverDockerDisconnect
          - TestHeadscale
+          - TestCreateTailscale
          - TestTailscaleNodesJoiningHeadcale
          - TestSSHOneUserToAll
          - TestSSHMultipleUsersAllToAll
          - TestSSHNoSSHConfigured
          - TestSSHIsBlockedInACL
          - TestSSHUserOnlyIsolation
-          - TestSSHAutogroupSelf
-          - TestSSHOneUserToOneCheckModeCLI
-          - TestSSHOneUserToOneCheckModeOIDC
-          - TestSSHCheckModeUnapprovedTimeout
-          - TestSSHCheckModeCheckPeriodCLI
-          - TestSSHCheckModeAutoApprove
-          - TestSSHCheckModeSessionLossReDelegates
-          - TestSSHCheckModeNegativeCLI
-          - TestSSHLocalpart
-          - TestTagsAuthKeyWithTagRequestDifferentTag
-          - TestTagsAuthKeyWithTagNoAdvertiseFlag
-          - TestTagsAuthKeyWithTagCannotAddViaCLI
-          - TestTagsAuthKeyWithTagCannotChangeViaCLI
-          - TestTagsAuthKeyWithTagAdminOverrideReauthPreserves
-          - TestTagsAuthKeyWithTagCLICannotModifyAdminTags
-          - TestTagsAuthKeyWithoutTagCannotRequestTags
-          - TestTagsAuthKeyWithoutTagRegisterNoTags
-          - TestTagsAuthKeyWithoutTagCannotAddViaCLI
-          - TestTagsAuthKeyWithoutTagCLINoOpAfterAdminWithReset
-          - TestTagsAuthKeyWithoutTagCLINoOpAfterAdminWithEmptyAdvertise
-          - TestTagsAuthKeyWithoutTagCLICannotReduceAdminMultiTag
-          - TestTagsUserLoginOwnedTagAtRegistration
-          - TestTagsUserLoginNonExistentTagAtRegistration
-          - TestTagsUserLoginUnownedTagAtRegistration
-          - TestTagsUserLoginAddTagViaCLIReauth
-          - TestTagsUserLoginRemoveTagViaCLIReauth
-          - TestTagsUserLoginCLINoOpAfterAdminAssignment
-          - TestTagsUserLoginCLICannotRemoveAdminTags
-          - TestTagsAuthKeyWithTagRequestNonExistentTag
-          - TestTagsAuthKeyWithTagRequestUnownedTag
-          - TestTagsAuthKeyWithoutTagRequestNonExistentTag
-          - TestTagsAuthKeyWithoutTagRequestUnownedTag
-          - TestTagsAdminAPICannotSetNonExistentTag
-          - TestTagsAdminAPICanSetUnownedTag
-          - TestTagsAdminAPICannotRemoveAllTags
-          - TestTagsIssue2978ReproTagReplacement
-          - TestTagsAdminAPICannotSetInvalidFormat
-          - TestTagsUserLoginReauthWithEmptyTagsRemovesAllTags
-          - TestTagsAuthKeyWithoutUserInheritsTags
-          - TestTagsAuthKeyWithoutUserRejectsAdvertisedTags
-          - TestTagsAuthKeyConvertToUserViaCLIRegister
-          - TestTS2021WebSocketGET
-          - TestTS2021WASMClientUnderNode
-          - TestTailscaleRustAxum
-    uses: ./.github/workflows/integration-test-template.yml
-    secrets: inherit
-    with:
-      test: ${{ matrix.test }}
-      postgres_flag: "--postgres=0"
-      database_name: "sqlite"
-  postgres:
-    needs: [build, build-postgres, build-tailscale-released]
-    if: needs.build.outputs.files-changed == 'true'
-    strategy:
-      fail-fast: false
-      matrix:
-        test:
-          - TestACLAllowUserDst
-          - TestPingAllByIP
-          - TestEphemeral2006DeletedTooQuickly
-          - TestPingAllByIPManyUpDown
-          - TestSubnetRouterMultiNetwork
-    uses: ./.github/workflows/integration-test-template.yml
-    secrets: inherit
-    with:
-      test: ${{ matrix.test }}
-      postgres_flag: "--postgres=1"
-      database_name: "postgres"
+        database: [postgres, sqlite]
+    env:
+      # Github does not allow us to access secrets in pull requests,
+      # so this env var is used to check if we have the secret or not.
+      # If we have the secrets, meaning we are running on push in a fork,
+      # there might be secrets available for more debugging.
+      # If TS_OAUTH_CLIENT_ID and TS_OAUTH_SECRET is set, then the job
+      # will join a debug tailscale network, set up SSH and a tmux session.
+      # The SSH will be configured to use the SSH key of the Github user
+      # that triggered the build.
+      HAS_TAILSCALE_SECRET: ${{ secrets.TS_OAUTH_CLIENT_ID }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+      - name: Get changed files
+        id: changed-files
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            files:
+              - '*.nix'
+              - 'go.*'
+              - '**/*.go'
+              - 'integration_test/'
+              - 'config-example.yaml'
+      - name: Tailscale
+        if: ${{ env.HAS_TAILSCALE_SECRET }}
+        uses: tailscale/github-action@v2
+        with:
+          oauth-client-id: ${{ secrets.TS_OAUTH_CLIENT_ID }}
+          oauth-secret: ${{ secrets.TS_OAUTH_SECRET }}
+          tags: tag:gh
+      - name: Setup SSH server for Actor
+        if: ${{ env.HAS_TAILSCALE_SECRET }}
+        uses: alexellis/setup-sshd-actor@master
+      - uses: DeterminateSystems/nix-installer-action@main
+        if: steps.changed-files.outputs.files == 'true'
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+        if: steps.changed-files.outputs.files == 'true'
+      - uses: satackey/action-docker-layer-caching@main
+        if: steps.changed-files.outputs.files == 'true'
+        continue-on-error: true
+      - name: Run Integration Test
+        uses: Wandalen/wretry.action@master
+        if: steps.changed-files.outputs.files == 'true'
+        env:
+          USE_POSTGRES: ${{ matrix.database == 'postgres' && '1' || '0' }}
+        with:
+          attempt_limit: 5
+          command: |
+            nix develop --command -- docker run \
+              --tty --rm \
+              --volume ~/.cache/hs-integration-go:/go \
+              --name headscale-test-suite \
+              --volume $PWD:$PWD -w $PWD/integration \
+              --volume /var/run/docker.sock:/var/run/docker.sock \
+              --volume $PWD/control_logs:/tmp/control \
+              --env HEADSCALE_INTEGRATION_POSTGRES=${{env.USE_POSTGRES}} \
+              golang:1 \
+                go run gotest.tools/gotestsum@latest -- ./... \
+                  -failfast \
+                  -timeout 120m \
+                  -parallel 1 \
+                  -run "^${{ matrix.test }}$"
+      - uses: actions/upload-artifact@v4
+        if: always() && steps.changed-files.outputs.files == 'true'
+        with:
+          name: ${{ matrix.test }}-${{matrix.database}}-logs
+          path: "control_logs/*.log"
+      - uses: actions/upload-artifact@v4
+        if: always() && steps.changed-files.outputs.files == 'true'
+        with:
+          name: ${{ matrix.test }}-${{matrix.database}}-pprof
+          path: "control_logs/*.pprof.tar"
+      - name: Setup a blocking tmux session
+        if: ${{ env.HAS_TAILSCALE_SECRET }}
+        uses: alexellis/block-with-tmux-action@master
@@ -0,0 +1,43 @@
+name: Tests
+
+on: [push, pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-$${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Get changed files
+        id: changed-files
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            files:
+              - '*.nix'
+              - 'go.*'
+              - '**/*.go'
+              - 'integration_test/'
+              - 'config-example.yaml'
+
+      - uses: DeterminateSystems/nix-installer-action@main
+        if: steps.changed-files.outputs.files == 'true'
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+        if: steps.changed-files.outputs.files == 'true'
+
+      - name: Run tests
+        if: steps.changed-files.outputs.files == 'true'
+        env:
+          # As of 2025-01-06, these env vars was not automatically
+          # set anymore which breaks the initdb for postgres on
+          # some of the database migration tests.
+          LC_ALL: "en_US.UTF-8"
+          LC_CTYPE: "en_US.UTF-8"
+        run: nix develop --command -- gotestsum
@@ -0,0 +1,19 @@
+name: update-flake-lock
+on:
+  workflow_dispatch: # allows manual triggering
+  schedule:
+    - cron: "0 0 * * 0" # runs weekly on Sunday at 00:00
+
+jobs:
+  lockfile:
+    if: github.repository == 'juanfont/headscale'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+      - name: Update flake.lock
+        uses: DeterminateSystems/update-flake-lock@main
+        with:
+          pr-title: "Update flake.lock"
@@ -1,10 +1,6 @@
 ignored/
 tailscale/
 .vscode/
-.claude/
-logs/
-
-*.prof

 # Binaries for programs and plugins
 *.exe
@@ -24,12 +20,11 @@ vendor/

 dist/
 /headscale
+config.json
 config.yaml
 config*.yaml
-!config-example.yaml
 derp.yaml
 *.hujson
-!hscontrol/policy/v2/testdata/*/*.hujson
 *.key
 /db.sqlite
 *.sqlite3
@@ -46,15 +41,8 @@ result

 integration_test/etc/config.dump.yaml

-# OpenAPI spec is served live from the code and emitted on demand, not committed
-/openapi/v1/headscale.yaml
-
 # MkDocs
 .cache
 /site

 __debug_bin
-
-node_modules/
-package-lock.json
-package.json
@@ -1,120 +1,70 @@
 ---
-version: "2"
+run:
+  timeout: 10m
+  build-tags:
+    - ts2019
+
+issues:
+  skip-dirs:
+    - gen
 linters:
-  default: all
+  enable-all: true
  disable:
-    - cyclop
    - depguard
-    - dupl
-    - exhaustruct
-    - funcorder
-    - funlen
+
+    - revive
+    - lll
+    - gofmt
    - gochecknoglobals
    - gochecknoinits
    - gocognit
-    - godox
-    - gomodguard
-    - interfacebloat
-    - ireturn
-    - lll
-    - maintidx
-    - makezero
-    - mnd
-    - musttag
-    - nestif
-    - nolintlint
-    - paralleltest
-    - revive
+    - funlen
    - tagliatelle
-    - testpackage
-    - varnamelen
-    - wrapcheck
-    - wsl
-  settings:
-    goconst:
-      # Test fixtures repeat strings (IPs, tags, hostnames) by their
-      # nature; extracting them obscures the test rather than helping.
-      # Production code stays strict.
-      ignore-tests: true
-      # Default is 3. Bump so "happens thrice" cases that are not part
-      # of a shared vocabulary do not get extracted.
-      min-occurrences: 5
-      # Default is 3. Short literals ("set", "get", "new") read better
-      # at call sites than behind a named constant.
-      min-len: 6
-    forbidigo:
-      forbid:
-        # Forbid time.Sleep everywhere with context-appropriate alternatives
-        - pattern: 'time\.Sleep'
-          msg: >-
-            time.Sleep is forbidden.
-            In tests: use assert.EventuallyWithT for polling/waiting patterns.
-            In production code: use a backoff strategy (e.g., cenkalti/backoff) or proper synchronization primitives.
-        # Forbid inline string literals in zerolog field methods - use zf.* constants
-        - pattern: '\.(Str|Int|Int8|Int16|Int32|Int64|Uint|Uint8|Uint16|Uint32|Uint64|Float32|Float64|Bool|Dur|Time|TimeDiff|Strs|Ints|Uints|Floats|Bools|Any|Interface)\("[^"]+"'
-          msg: >-
-            Use zf.* constants for zerolog field names instead of string literals.
-            Import "github.com/juanfont/headscale/hscontrol/util/zlog/zf" and use
-            constants like zf.NodeID, zf.UserName, etc. Add new constants to
-            hscontrol/util/zlog/zf/fields.go if needed.
-        # Forbid ptr.To - use Go 1.26 new(expr) instead
-        - pattern: 'ptr\.To\('
-          msg: >-
-            ptr.To is forbidden. Use Go 1.26's new(expr) syntax instead.
-            Example: ptr.To(value) → new(value)
-        # Forbid tsaddr.SortPrefixes - use slices.SortFunc with netip.Prefix.Compare
-        - pattern: 'tsaddr\.SortPrefixes'
-          msg: >-
-            tsaddr.SortPrefixes is forbidden. Use Go 1.26's netip.Prefix.Compare instead.
-            Example: slices.SortFunc(prefixes, netip.Prefix.Compare)
-      analyze-types: true
-    gocritic:
-      disabled-checks:
-        - appendAssign
-        - ifElseChain
-    nlreturn:
-      block-size: 4
-    varnamelen:
-      ignore-names:
-        - err
-        - db
-        - id
-        - ip
-        - ok
-        - c
-        - tt
-        - tx
-        - rx
-        - sb
-        - wg
-        - pr
-        - p
-        - p2
-      ignore-type-assert-ok: true
-      ignore-map-index-ok: true
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-      - gen
+    - godox
+    - ireturn
+    - execinquery
+    - exhaustruct
+    - nolintlint
+    - musttag # causes issues with imported libs
+    - depguard
+    - exportloopref

-formatters:
-  enable:
-    - gci
-    - gofmt
-    - gofumpt
-    - goimports
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-      - gen
+    # We should strive to enable these:
+    - wrapcheck
+    - dupl
+    - makezero
+    - maintidx
+
+    # Limits the methods of an interface to 10. We have more in integration tests
+    - interfacebloat
+
+    # We might want to enable this, but it might be a lot of work
+    - cyclop
+    - nestif
+    - wsl # might be incompatible with gofumpt
+    - testpackage
+    - paralleltest
+
+linters-settings:
+  varnamelen:
+    ignore-type-assert-ok: true
+    ignore-map-index-ok: true
+    ignore-names:
+      - err
+      - db
+      - id
+      - ip
+      - ok
+      - c
+      - tt
+      - tx
+      - rx
+
+  gocritic:
+    disabled-checks:
+      - appendAssign
+      # TODO(kradalby): Remove this
+      - ifElseChain
+
+  nlreturn:
+    block-size: 4
@@ -2,16 +2,11 @@
 version: 2
 before:
  hooks:
-    - go mod tidy -compat=1.26
+    - go mod tidy -compat=1.22
    - go mod vendor

 release:
  prerelease: auto
-  draft: true
-  header: |
-    ## Upgrade
-
-    Please follow the steps outlined in the [upgrade guide](https://headscale.net/stable/setup/upgrade/) to update your existing Headscale installation.

 builds:
  - id: headscale
@@ -23,16 +18,23 @@ builds:
      - darwin_amd64
      - darwin_arm64
      - freebsd_amd64
+      - linux_386
      - linux_amd64
      - linux_arm64
+      - linux_arm_5
+      - linux_arm_6
+      - linux_arm_7
    flags:
      - -mod=readonly
+    ldflags:
+      - -s -w -X github.com/juanfont/headscale/cmd/headscale/cli.Version=v{{.Version}}
+    tags:
+      - ts2019

 archives:
  - id: golang-cross
    name_template: '{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ with .Arm }}v{{ . }}{{ end }}{{ with .Mips }}_{{ . }}{{ end }}{{ if not (eq .Amd64 "v1") }}{{ .Amd64 }}{{ end }}'
-    formats:
-      - binary
+    format: binary

 source:
  enabled: true
@@ -42,30 +44,24 @@ source:
    - "vendor/"

 nfpms:
-  # Configure nFPM for .deb releases
+  # Configure nFPM for .deb and .rpm releases
  #
-  # See https://goreleaser.com/customization/package/nfpm/
+  # See https://nfpm.goreleaser.com/configuration/
+  # and https://goreleaser.com/customization/nfpm/
  #
  # Useful tools for debugging .debs:
  # List file contents: dpkg -c dist/headscale...deb
  # Package metadata: dpkg --info dist/headscale....deb
  #
-  - ids:
+  - builds:
      - headscale
    package_name: headscale
    priority: optional
    vendor: headscale
    maintainer: Kristoffer Dalby <kristoffer@dalby.cc>
    homepage: https://github.com/juanfont/headscale
-    description: |-
-      Open source implementation of the Tailscale control server.
-      Headscale aims to implement a self-hosted, open source alternative to the
-      Tailscale control server. Headscale's goal is to provide self-hosters and
-      hobbyists with an open-source server they can use for their projects and
-      labs. It implements a narrow scope, a single Tailscale network (tailnet),
-      suitable for a personal use, or a small open-source organisation.
+    license: BSD
    bindir: /usr/bin
-    section: net
    formats:
      - deb
    contents:
@@ -74,41 +70,56 @@ nfpms:
        type: config|noreplace
        file_info:
          mode: 0644
-      - src: ./packaging/systemd/headscale.service
+      - src: ./docs/packaging/headscale.systemd.service
        dst: /usr/lib/systemd/system/headscale.service
      - dst: /var/lib/headscale
        type: dir
-      - src: ./config-example.yaml
-        dst: /usr/share/doc/headscale/examples/config-example.yaml
-      - src: LICENSE
-        dst: /usr/share/doc/headscale/copyright
+      - dst: /var/run/headscale
+        type: dir
    scripts:
-      postinstall: ./packaging/deb/postinst
-      postremove: ./packaging/deb/postrm
-      preremove: ./packaging/deb/prerm
-    deb:
-      lintian_overrides:
-        - no-changelog # Our CHANGELOG.md uses a different formatting
-        - no-manual-page
-        - statically-linked-binary
+      postinstall: ./docs/packaging/postinstall.sh
+      postremove: ./docs/packaging/postremove.sh

 kos:
  - id: ghcr
-    repositories:
-      - ghcr.io/juanfont/headscale
-      - headscale/headscale
+    repository: ghcr.io/juanfont/headscale

    # bare tells KO to only use the repository
    # for tagging and naming the container.
    bare: true
-    base_image: gcr.io/distroless/base-debian13
+    base_image: gcr.io/distroless/base-debian12
    build: headscale
    main: ./cmd/headscale
    env:
      - CGO_ENABLED=0
    platforms:
      - linux/amd64
+      - linux/386
      - linux/arm64
+      - linux/arm/v7
+    tags:
+      - "{{ if not .Prerelease }}latest{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}.{{ .Patch }}{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}.{{ .Minor }}.{{ .Patch }}{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}.{{ .Minor }}{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}{{ end }}"
+      - "{{ if not .Prerelease }}stable{{ else }}unstable{{ end }}"
+      - "{{ .Tag }}"
+      - '{{ trimprefix .Tag "v" }}'
+      - "sha-{{ .ShortCommit }}"
+
+  - id: dockerhub
+    build: headscale
+    base_image: gcr.io/distroless/base-debian12
+    repository: headscale/headscale
+    bare: true
+    platforms:
+      - linux/amd64
+      - linux/386
+      - linux/arm64
+      - linux/arm/v7
    tags:
      - "{{ if not .Prerelease }}latest{{ end }}"
      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}.{{ .Patch }}{{ end }}"
@@ -121,23 +132,43 @@ kos:
      - "{{ .Tag }}"
      - '{{ trimprefix .Tag "v" }}'
      - "sha-{{ .ShortCommit }}"
-    creation_time: "{{.CommitTimestamp}}"
-    ko_data_creation_time: "{{.CommitTimestamp}}"

  - id: ghcr-debug
-    repositories:
-      - ghcr.io/juanfont/headscale
-      - headscale/headscale
-
+    repository: ghcr.io/juanfont/headscale
    bare: true
-    base_image: gcr.io/distroless/base-debian13:debug
+    base_image: gcr.io/distroless/base-debian12:debug
    build: headscale
    main: ./cmd/headscale
    env:
      - CGO_ENABLED=0
    platforms:
      - linux/amd64
+      - linux/386
      - linux/arm64
+      - linux/arm/v7
+    tags:
+      - "{{ if not .Prerelease }}latest-debug{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}.{{ .Patch }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}{{ .Major }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}.{{ .Minor }}.{{ .Patch }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}.{{ .Minor }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}v{{ .Major }}-debug{{ end }}"
+      - "{{ if not .Prerelease }}stable-debug{{ else }}unstable-debug{{ end }}"
+      - "{{ .Tag }}-debug"
+      - '{{ trimprefix .Tag "v" }}-debug'
+      - "sha-{{ .ShortCommit }}-debug"
+
+  - id: dockerhub-debug
+    build: headscale
+    base_image: gcr.io/distroless/base-debian12:debug
+    repository: headscale/headscale
+    bare: true
+    platforms:
+      - linux/amd64
+      - linux/386
+      - linux/arm64
+      - linux/arm/v7
    tags:
      - "{{ if not .Prerelease }}latest-debug{{ end }}"
      - "{{ if not .Prerelease }}{{ .Major }}.{{ .Minor }}.{{ .Patch }}-debug{{ end }}"
@@ -1,34 +0,0 @@
-{
-  "mcpServers": {
-    "claude-code-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@steipete/claude-code-mcp@latest"],
-      "env": {}
-    },
-    "sequential-thinking": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
-      "env": {}
-    },
-    "nixos": {
-      "type": "stdio",
-      "command": "uvx",
-      "args": ["mcp-nixos"],
-      "env": {}
-    },
-    "context7": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@upstash/context7-mcp"],
-      "env": {}
-    },
-    "git": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@cyanheads/git-mcp-server"],
-      "env": {}
-    }
-  }
-}
@@ -1,2 +0,0 @@
-[plugin.mkdocs]
-align_semantic_breaks_in_lists = true
@@ -1,72 +0,0 @@
-# prek/pre-commit configuration for headscale
-# See: https://prek.j178.dev/quickstart/
-# See: https://prek.j178.dev/builtin/
-
-# Global exclusions - ignore generated code (proto output and emitted OpenAPI)
-# and recorded golden fixtures.
-exclude: ^(gen|openapi)/|^hscontrol/testdata/apiv1_golden/
-
-repos:
-  # Built-in hooks from pre-commit/pre-commit-hooks
-  # prek will use fast-path optimized versions automatically
-  # See: https://prek.j178.dev/builtin/
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
-    hooks:
-      - id: check-added-large-files
-        args: [--maxkb=1024]
-      - id: check-case-conflict
-      - id: check-executables-have-shebangs
-      - id: check-json
-      - id: check-merge-conflict
-      - id: check-symlinks
-      - id: check-toml
-      - id: check-xml
-      - id: check-yaml
-      - id: detect-private-key
-      - id: end-of-file-fixer
-      - id: fix-byte-order-marker
-      - id: mixed-line-ending
-      - id: trailing-whitespace
-
-  # Local hooks for project-specific tooling
-  - repo: local
-    hooks:
-      # nixpkgs-fmt for Nix files
-      - id: nixpkgs-fmt
-        name: nixpkgs-fmt
-        entry: nixpkgs-fmt
-        language: system
-        files: \.nix$
-
-      # Prettier for formatting
-      - id: prettier
-        name: prettier
-        entry: prettier --write --list-different
-        language: system
-        exclude: ^docs/
-        types_or: [javascript, jsx, ts, tsx, yaml, json, toml, html, css, scss, sass, markdown]
-
-      # mdformat for docs
-      - id: mdformat
-        name: mdformat
-        entry: mdformat
-        language: system
-        types_or: [markdown]
-        files: ^docs/
-
-      # golangci-lint for Go code quality
-      - id: golangci-lint
-        name: golangci-lint
-        entry: nix develop --command -- golangci-lint run --new-from-rev=HEAD~1 --timeout=5m --fix
-        language: system
-        types: [go]
-        pass_filenames: false
-
-      # vendor-hash keeps flakehashes.json in sync with go.mod/go.sum.
-      - id: vendor-hash
-        name: vendor-hash
-        entry: nix develop --command -- go run ./cmd/vendorhash check
-        language: system
-        files: ^(go\.mod|go\.sum|flakehashes\.json)$
-        pass_filenames: false
@@ -1,2 +1,4 @@
 .github/workflows/test-integration-v2*
-docs/
+docs/about/features.md
+docs/ref/configuration.md
+docs/ref/remote-cli.md
@@ -1,296 +0,0 @@
-# AGENTS.md
-
-Behavioural guidance for AI agents working in this repository. Reference
-material for complex procedures lives next to the code — integration
-testing is documented in [`cmd/hi/README.md`](cmd/hi/README.md) and
-[`integration/README.md`](integration/README.md). Read those files
-before running tests or writing new ones.
-
-Headscale is an open-source implementation of the Tailscale control server
-written in Go. It manages node registration, IP allocation, policy
-enforcement, and DERP routing for self-hosted tailnets.
-
-## Interaction Rules
-
-These rules govern how you work in this repo. They are listed first
-because they shape every other decision.
-
-### Ask with comprehensive multiple-choice options
-
-When you need to clarify intent, scope, or approach, use the
-`AskUserQuestion` tool (or a numbered list fallback) and present the user
-with a comprehensive set of options. Cover the likely branches explicitly
-and include an "other — please describe" escape.
-
- Bad: _"How should I handle expired nodes?"_
- Good: _"How should expired nodes be handled? (a) Remain visible to peers
-  but marked expired (current behaviour); (b) Hidden from peers entirely;
-  (c) Hidden from peers but visible in admin API; (d) Other."_
-
-This matters more than you think — open-ended questions waste a round
-trip and often produce a misaligned answer.
-
-### Read the documented procedure before running complex commands
-
-Before invoking any `hi` command, integration test, generator, or
-migration tool, read the referenced README in full —
-`cmd/hi/README.md` for running tests, `integration/README.md` for
-writing them. Never guess flags. If the procedure is not documented
-anywhere, ask the user rather than inventing one.
-
-### Map once, then act
-
-Use `Glob` / `Grep` to understand file structure, then execute. Do not
-re-explore the same area to "double-check" once you have a plan. Do not
-re-read files you edited in this session — the harness tracks state for
-you.
-
-### Fail fast, report up
-
-If a command fails twice with the same error, stop and report the exact
-error to the user with context. Do not loop through variants or
-"try one more thing". A repeated failure means your model of the problem
-is wrong.
-
-### Confirm scope for multi-file changes
-
-Before touching more than three files, show the user which files will
-change and why. Use plan mode (`ExitPlanMode`) for non-trivial work.
-
-### Prefer editing existing files
-
-Do not create new files unless strictly necessary. Do not generate helper
-abstractions, wrapper utilities, or "just in case" configuration. Three
-similar lines of code is better than a premature abstraction.
-
-## Quick Start
-
-```bash
-# Enter the nix dev shell (Go 1.26.1, buf, golangci-lint, prek)
-nix develop
-
-# Full development workflow: fmt + lint + test + build
-make dev
-
-# Individual targets
-make build           # build the headscale binary
-make test            # go test ./...
-make fmt             # format Go, docs, proto
-make lint            # lint Go, proto
-make generate        # regenerate protobuf code (after changes to proto/)
-make clean           # remove build artefacts
-
-# Direct go test invocations
-go test ./...
-go test -race ./...
-
-# Integration tests — read cmd/hi/README.md first
-go run ./cmd/hi doctor
-go run ./cmd/hi run "TestName"
-```
-
-Go 1.26.1 minimum (per `go.mod:3`). `nix develop` pins the exact toolchain
-used in CI.
-
-## Pre-Commit with prek
-
-`prek` installs git hooks that run the same checks as CI.
-
-```bash
-nix develop
-prek install            # one-time setup
-prek run                # run hooks on staged files
-prek run --all-files    # run hooks on the full tree
-```
-
-Hooks cover: file hygiene (trailing whitespace, line endings, BOM),
-syntax validation (JSON/YAML/TOML/XML), merge-conflict markers, private
-key detection, nixpkgs-fmt, prettier, and `golangci-lint` via
-`--new-from-rev=HEAD~1` (see `.pre-commit-config.yaml:59`). A manual
-invocation with an `upstream/main` remote is equivalent:
-
-```bash
-golangci-lint run --new-from-rev=upstream/main --timeout=5m --fix
-```
-
-`git commit --no-verify` is acceptable only for WIP commits on feature
-branches — never on `main`.
-
-## Project Layout
-
-```
-headscale/
-├── cmd/
-│   ├── headscale/    # Main headscale server binary
-│   └── hi/           # Integration test runner (see cmd/hi/README.md)
-├── hscontrol/        # Core control plane
-├── integration/      # End-to-end Docker-based tests (see integration/README.md)
-├── proto/            # Protocol buffer definitions
-├── gen/              # Generated code (buf output — do not edit)
-├── docs/             # User and ACL reference documentation
-└── packaging/        # Distribution packaging
-```
-
-### `hscontrol/` packages
-
- `app.go`, `handlers.go`, `grpcv1.go`, `noise.go`, `auth.go`, `oidc.go`,
-  `poll.go`, `metrics.go`, `debug.go`, `tailsql.go`, `platform_config.go`
-  — top-level server files
- `state/` — central coordinator (`state.go`) and the copy-on-write
-  `NodeStore` (`node_store.go`). All cross-subsystem operations go
-  through `State`.
- `db/` — GORM layer, migrations, schema. `node.go`, `users.go`,
-  `api_key.go`, `preauth_keys.go`, `ip.go`, `policy.go`.
- `mapper/` — streaming batcher that distributes MapResponses to
-  clients: `batcher.go`, `node_conn.go`, `builder.go`, `mapper.go`.
-  Performance-critical.
- `policy/` — `policy/v2/` is **the** policy implementation. The
-  top-level `policy.go` is thin wrappers. There is no v1 directory.
- `routes/`, `dns/`, `derp/`, `types/`, `util/`, `templates/`, `capver/`
-  — routing, MagicDNS, relay, core types, helpers, client templates,
-  capability versioning.
- `servertest/` — in-memory test harness for server-level tests that
-  don't need Docker. Prefer this over `integration/` when possible.
- `assets/` — embedded UI assets.
-
-### `cmd/hi/` files
-
-`main.go`, `run.go`, `doctor.go`, `docker.go`, `cleanup.go`, `stats.go`,
-`README.md`. **Read `cmd/hi/README.md` before running any `hi` command.**
-
-## Architecture Essentials
-
- **`hscontrol/state/state.go`** is the central coordinator. Cross-cutting
-  operations (node updates, policy evaluation, IP allocation) go through
-  the `State` type, not directly to the database.
- **`NodeStore`** in `hscontrol/state/node_store.go` is a copy-on-write
-  in-memory cache backed by `atomic.Pointer[Snapshot]`. Every read is a
-  pointer load; writes rebuild a new snapshot and atomically swap. It is
-  the hot path for `MapRequest` processing and peer visibility.
- **The map-request sync point** is
-  `State.UpdateNodeFromMapRequest()` in
-  `hscontrol/state/state.go:2351`. This is where Hostinfo changes,
-  endpoint updates, and route advertisements land in the NodeStore.
- **Mapper subsystem** streams MapResponses via `batcher.go` and
-  `node_conn.go`. Changes here affect all connected clients.
- **Node registration flow**: noise handshake (`noise.go`) → auth
-  (`auth.go`) → state/DB persistence (`state/`, `db/`) → initial map
-  (`mapper/`).
-
-## Database Migration Rules
-
-These rules are load-bearing — violating them corrupts production
-databases. The `migrationsRequiringFKDisabled` map in
-`hscontrol/db/db.go:962` is frozen as of 2025-07-02 (see the comment at
-`db.go:989`). All new migrations must:
-
-1. **Never reorder existing migrations.** Migration order is immutable
-   once committed.
-2. **Only add new migrations to the end** of the migrations array.
-3. **Never disable foreign keys.** No new entries in
-   `migrationsRequiringFKDisabled`.
-4. **Use the migration ID format** `YYYYMMDDHHMM-short-description`
-   (timestamp + descriptive suffix). Example: `202602201200-clear-tagged-node-user-id`.
-5. **Never rename columns** that later migrations reference. Let
-   `AutoMigrate` create a new column if needed.
-
-## Tags-as-Identity
-
-Headscale enforces **tags XOR user ownership**: every node is either
-tagged (owned by tags) or user-owned (owned by a user namespace), never
-both. This is a load-bearing architectural rule.
-
- **Use `node.IsTagged()`** (`hscontrol/types/node.go:221`) to determine
-  ownership, not `node.UserID().Valid()`. A tagged node may still have
-  `UserID` set for "created by" tracking — `IsTagged()` is authoritative.
- `IsUserOwned()` (`node.go:227`) returns `!IsTagged()`.
- Tagged nodes are presented to Tailscale as the special
-  `TaggedDevices` user (`hscontrol/types/users.go`, ID `2147455555`).
- `SetTags` validation is enforced by `validateNodeOwnership()` in
-  `hscontrol/state/tags.go`.
- Examples and edge cases live in `hscontrol/types/node_tags_test.go`
-  and `hscontrol/grpcv1_test.go` (`TestSetTags_*`).
-
-**Don't do this**:
-
-```go
-if node.UserID().Valid() { /* assume user-owned */ }       // WRONG
-if node.UserID().Valid() && !node.IsTagged() { /* ok */ }  // correct
-```
-
-## Policy Engine
-
-`hscontrol/policy/v2/policy.go` is the policy implementation. The
-top-level `hscontrol/policy/policy.go` contains only wrapper functions
-around v2. There is no v1 directory.
-
-Key concepts an agent will encounter:
-
- **Autogroups**: `autogroup:self`, `autogroup:member`, `autogroup:internet`
- **Tag owners**: IP-based authorization for who can claim a tag
- **Route approvals**: auto-approval of subnet routes by policy
- **SSH policies**: SSH access control via grants
- **HuJSON** parsing for policy files
-
-For usage examples, read `hscontrol/policy/v2/policy_test.go`. For ACL
-reference documentation, see `docs/`.
-
-## Integration Testing
-
-**Before running any `hi` command, read `cmd/hi/README.md` in full.**
-Guessing at `hi` flags leads to broken runs and stale containers.
-
-Test-authoring patterns (`EventuallyWithT`, `IntegrationSkip`, helper
-variants, scenario setup) are documented in `integration/README.md`.
-
-Key reminders:
-
- Integration test functions **must** start with `IntegrationSkip(t)`.
- External calls (`client.Status`, `headscale.ListNodes`, etc.) belong
-  inside `EventuallyWithT`; state-mutating commands (`tailscale set`)
-  must not.
- Tests generate ~100 MB of logs per run under `control_logs/{runID}/`.
-  Prune old runs if disk is tight.
- Flakes are almost always code, not infrastructure. Read `hs-*.stderr.log`
-  before blaming Docker.
-
-## Code Conventions
-
- **Commit messages** follow Go-style `package: imperative description`.
-  Recent examples from `git log`:
-  - `db: scope DestroyUser to only delete the target user's pre-auth keys`
-  - `state: fix policy change race in UpdateNodeFromMapRequest`
-  - `integration: fix ACL tests for address-family-specific resolve`
-
-  Not Conventional Commits. No `feat:`/`chore:`/`docs:` prefixes.
-
- **Protobuf regeneration**: changes under `proto/` require
-  `make generate` (which runs `buf generate`) and should land in a
-  **separate commit** from the callers that use the regenerated types.
- **Formatting** is enforced by `golangci-lint` with `golines` (width 88)
-  and `gofumpt`. Run `make fmt` or rely on the pre-commit hook.
- **Logging** uses `zerolog`. Prefer single-line chains
-  (`log.Info().Str(...).Msg(...)`). For 4+ fields or conditional fields,
-  build incrementally and **reassign** the event variable:
-  `e = e.Str("k", v)`. Forgetting to reassign silently drops the field.
- **Tests**: prefer `hscontrol/servertest/` for server-level tests that
-  don't need Docker — faster than full integration tests.
- **View types in read paths**: response serializers must read through
-  `NodeView`/`UserView`/`PreAuthKeyView` accessors. `AsStruct()` clones the
-  whole record on every read — it is only for DB-write/merge clones and mutable
-  working copies, never to build an API response. `grep AsStruct hscontrol/api`
-  must come back empty.
-
-## Gotchas
-
- **Database**: SQLite for local dev, PostgreSQL for integration-heavy
-  tests (`go run ./cmd/hi run "..." --postgres`). Some race conditions
-  only surface on one backend.
- **NodeStore writes** rebuild a full snapshot. Measure before changing
-  hot-path code.
- **`.claude/agents/` is deprecated.** Do not create new agent files
-  there. Put behavioural guidance in this file and procedural guidance
-  in the nearest README.
- **Do not edit `gen/`** — it is regenerated from `proto/` by
-  `make generate`.
- **Proto changes + code changes should be two commits**, not one.
@@ -1 +0,0 @@
-@AGENTS.md
@@ -1,6 +1,6 @@
 # For testing purposes only

-FROM golang:1.26.4-alpine AS build-env
+FROM golang:alpine AS build-env

 WORKDIR /go/src

@@ -12,7 +12,7 @@ WORKDIR /go/src/tailscale
 ARG TARGETARCH
 RUN GOARCH=$TARGETARCH go install -v ./cmd/derper

-FROM alpine:3.23
+FROM alpine:3.18
 RUN apk add --no-cache ca-certificates iptables iproute2 ip6tables curl

 COPY --from=build-env /go/bin/* /usr/local/bin/
@@ -2,43 +2,25 @@
 # and are in no way endorsed by Headscale's maintainers as an
 # official nor supported release or distribution.

-FROM docker.io/golang:1.26.4-trixie AS builder
+FROM docker.io/golang:1.23-bookworm
 ARG VERSION=dev
 ENV GOPATH /go
 WORKDIR /go/src/headscale

-# Install delve debugger first - rarely changes, good cache candidate
-RUN go install github.com/go-delve/delve/cmd/dlv@latest
+RUN apt-get update \
+  && apt-get install --no-install-recommends --yes less jq sqlite3 dnsutils \
+  && rm -rf /var/lib/apt/lists/* \
+  && apt-get clean
+RUN mkdir -p /var/run/headscale

-# Download dependencies - only invalidated when go.mod/go.sum change
 COPY go.mod go.sum /go/src/headscale/
 RUN go mod download

-# Copy source and build - invalidated on any source change
 COPY . .

-# Build debug binary with debug symbols for delve
-RUN CGO_ENABLED=0 GOOS=linux go build -gcflags="all=-N -l" -o /go/bin/headscale ./cmd/headscale
-
-# Runtime stage
-FROM debian:trixie-slim
-
-RUN apt-get --update install --no-install-recommends --yes \
-    bash ca-certificates curl dnsutils findutils iproute2 jq less procps python3 sqlite3 \
-  && apt-get dist-clean
-
-RUN mkdir -p /var/run/headscale
-
-# Copy binaries from builder
-COPY --from=builder /go/bin/headscale /usr/local/bin/headscale
-COPY --from=builder /go/bin/dlv /usr/local/bin/dlv
-
-# Copy source code for delve source-level debugging
-COPY --from=builder /go/src/headscale /go/src/headscale
-
-WORKDIR /go/src/headscale
+RUN CGO_ENABLED=0 GOOS=linux go install -ldflags="-s -w -X github.com/juanfont/headscale/cmd/headscale/cli.Version=$VERSION" -a ./cmd/headscale && test -e /go/bin/headscale

 # Need to reset the entrypoint or everything will run as a busybox script
 ENTRYPOINT []
-EXPOSE 8080/tcp 40000/tcp
-CMD ["dlv", "--listen=0.0.0.0:40000", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", "/usr/local/bin/headscale", "--"]
+EXPOSE 8080/tcp
+CMD ["headscale"]
@@ -1,17 +0,0 @@
-# Minimal CI image - expects pre-built headscale binary in build context
-# For local development with delve debugging, use Dockerfile.integration instead
-
-FROM debian:trixie-slim
-
-RUN apt-get --update install --no-install-recommends --yes \
-    bash ca-certificates curl dnsutils findutils iproute2 jq less procps python3 sqlite3 \
-  && apt-get dist-clean
-
-RUN mkdir -p /var/run/headscale
-
-# Copy pre-built headscale binary from build context
-COPY headscale /usr/local/bin/headscale
-
-ENTRYPOINT []
-EXPOSE 8080/tcp
-CMD ["/usr/local/bin/headscale"]
@@ -4,7 +4,7 @@
 # This Dockerfile is more or less lifted from tailscale/tailscale
 # to ensure a similar build process when testing the HEAD of tailscale.

-FROM golang:1.26.4-alpine AS build-env
+FROM golang:1.23-alpine AS build-env

 WORKDIR /go/src

@@ -36,10 +36,8 @@ RUN GOARCH=$TARGETARCH go install -tags="${BUILD_TAGS}" -ldflags="\
      -X tailscale.com/version.gitCommitStamp=$VERSION_GIT_HASH" \
      -v ./cmd/tailscale ./cmd/tailscaled ./cmd/containerboot

-FROM alpine:3.23
-# Upstream: ca-certificates ip6tables iptables iproute2
-# Tests: curl python3 (traceroute via BusyBox)
-RUN apk add --no-cache ca-certificates curl ip6tables iptables iproute2 python3
+FROM alpine:3.18
+RUN apk add --no-cache ca-certificates iptables iproute2 ip6tables curl

 COPY --from=build-env /go/bin/* /usr/local/bin/
 # For compat with the previous run.sh, although ideally you should be
@@ -1,26 +0,0 @@
-FROM rust:1.95-trixie AS builder
-
-ARG TAILSCALE_RS_REPO=https://github.com/tailscale/tailscale-rs.git
-ARG TAILSCALE_RS_REF=main
-
-WORKDIR /app
-RUN git clone --depth 1 --branch "$TAILSCALE_RS_REF" "$TAILSCALE_RS_REPO" .
-
-# Re-export ts_control's insecure-keyfetch feature through the tailscale
-# crate so the axum example can fetch the headscale control key over
-# plain HTTP. The integration harness serves the control plane without
-# TLS, and upstream only allows plain-HTTP key fetches when this Cargo
-# feature is compiled in.
-RUN sed -i '/^axum = \["dep:axum"\]/a insecure-keyfetch = ["ts_control/insecure-keyfetch"]' Cargo.toml
-
-RUN cargo build --release --features axum,insecure-keyfetch --example axum
-
-FROM debian:trixie-slim
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-    ca-certificates \
-    iproute2 \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=builder /app/target/release/examples/axum /usr/local/bin/axum
@@ -1,30 +0,0 @@
-# For integration testing only.
-#
-# Builds the Tailscale control client (integration/wasmic/wasmclient) for
-# GOOS=js/GOARCH=wasm and packages it with Go's wasm_exec Node runner. The
-# container idles; the integration test execs
-#   node /app/wasm_exec_node.js /app/client.wasm <control-url>
-# to drive a real browser-style WebSocket GET against headscale's /ts2021,
-# guarding the regression in issue #3357.
-
-FROM golang:1.26.4-alpine AS build
-
-WORKDIR /src
-
-# Only the module metadata and the wasm client package are needed to build the
-# js/wasm binary; its imports (tailscale.com/control/controlhttp, ...) resolve
-# from the module proxy.
-COPY go.mod go.sum ./
-COPY integration/wasmic/wasmclient ./integration/wasmic/wasmclient
-
-RUN GOOS=js GOARCH=wasm go build -o /out/client.wasm ./integration/wasmic/wasmclient \
-    && cp "$(go env GOROOT)/lib/wasm/wasm_exec.js" /out/wasm_exec.js \
-    && cp "$(go env GOROOT)/lib/wasm/wasm_exec_node.js" /out/wasm_exec_node.js
-
-FROM node:24-alpine
-
-WORKDIR /app
-COPY --from=build /out/ /app/
-
-# Idle; the test execs the client on demand with the headscale control URL.
-ENTRYPOINT ["tail", "-f", "/dev/null"]
@@ -1,149 +1,64 @@
-# Headscale Makefile
-# Modern Makefile following best practices
+# Calculate version
+version ?= $(shell git describe --always --tags --dirty)

-# Version calculation
-VERSION ?= $(shell git describe --always --tags --dirty)
+rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst *,%,$2),$d))

-# Build configuration
+# Determine if OS supports pie
 GOOS ?= $(shell uname | tr '[:upper:]' '[:lower:]')
-ifeq ($(filter $(GOOS), openbsd netbsd solaris plan9), )
-	PIE_FLAGS = -buildmode=pie
+ifeq ($(filter $(GOOS), openbsd netbsd soloaris plan9), )
+	pieflags = -buildmode=pie
+else
 endif

-# Tool availability check with nix warning
-define check_tool
-	@command -v $(1) >/dev/null 2>&1 || { \
-		echo "Warning: $(1) not found. Run 'nix develop' to ensure all dependencies are available."; \
-		exit 1; \
-	}
-endef
-
-# Source file collections using shell find for better performance
-GO_SOURCES := $(shell find . -name '*.go' -not -path './gen/*' -not -path './vendor/*')
-PRETTIER_SOURCES := $(shell find . \( -name '*.md' -o -name '*.yaml' -o -name '*.yml' -o -name '*.ts' -o -name '*.js' -o -name '*.html' -o -name '*.css' -o -name '*.scss' -o -name '*.sass' \) -not -path './gen/*' -not -path './vendor/*' -not -path './node_modules/*')
-
-# Default target
-.PHONY: all
-all: lint test build
-
-# Dependency checking
-.PHONY: check-deps
-check-deps:
-	$(call check_tool,go)
-	$(call check_tool,golangci-lint)
-	$(call check_tool,gofumpt)
-	$(call check_tool,mdformat)
-	$(call check_tool,prettier)
-
-# Build targets
-.PHONY: build
-build: check-deps $(GO_SOURCES) go.mod go.sum
-	@echo "Building headscale..."
-	go build $(PIE_FLAGS) -ldflags "-X main.version=$(VERSION)" -o headscale ./cmd/headscale
-
-# Test targets
-.PHONY: test
-test: check-deps $(GO_SOURCES) go.mod go.sum
-	@echo "Running Go tests..."
-	go test -race ./...
+# GO_SOURCES = $(wildcard *.go)
+# PROTO_SOURCES = $(wildcard **/*.proto)
+GO_SOURCES = $(call rwildcard,,*.go)
+PROTO_SOURCES = $(call rwildcard,,*.proto)


-# Formatting targets
-.PHONY: fmt
-fmt: fmt-go fmt-mdformat fmt-prettier
+build:
+	nix build

-.PHONY: fmt-go
-fmt-go: check-deps $(GO_SOURCES)
-	@echo "Formatting Go code..."
+dev: lint test build
+
+test:
+	gotestsum -- -short -race -coverprofile=coverage.out ./...
+
+test_integration:
+	docker run \
+		-t --rm \
+		-v ~/.cache/hs-integration-go:/go \
+		--name headscale-test-suite \
+		-v $$PWD:$$PWD -w $$PWD/integration \
+		-v /var/run/docker.sock:/var/run/docker.sock \
+		-v $$PWD/control_logs:/tmp/control \
+		golang:1 \
+		go run gotest.tools/gotestsum@latest -- -race -failfast ./... -timeout 120m -parallel 8
+
+lint:
+	golangci-lint run --fix --timeout 10m
+
+fmt: fmt-go fmt-prettier fmt-proto
+
+fmt-prettier:
+	prettier --write '**/**.{ts,js,md,yaml,yml,sass,css,scss,html}'
+	prettier --write --print-width 80 --prose-wrap always CHANGELOG.md
+
+fmt-go:
+	# TODO(kradalby): Reeval if we want to use 88 in the future.
+	# golines --max-len=88 --base-formatter=gofumpt -w $(GO_SOURCES)
 	gofumpt -l -w .
 	golangci-lint run --fix

-.PHONY: fmt-mdformat
-fmt-mdformat: check-deps
-	@echo "Formatting documentation..."
-	mdformat docs/
+fmt-proto:
+	clang-format -i $(PROTO_SOURCES)

-.PHONY: fmt-prettier
-fmt-prettier: check-deps $(PRETTIER_SOURCES)
-	@echo "Formatting markup and config files..."
-	prettier --write '**/*.{ts,js,md,yaml,yml,sass,css,scss,html}'
+proto-lint:
+	cd proto/ && go run github.com/bufbuild/buf/cmd/buf lint

-# Linting targets
-.PHONY: lint
-lint: lint-go
+compress: build
+	upx --brute headscale

-.PHONY: lint-go
-lint-go: check-deps $(GO_SOURCES) go.mod go.sum
-	@echo "Linting Go code..."
-	golangci-lint run --timeout 10m
-
-# Code generation
-.PHONY: generate
-generate: check-deps
-	@echo "Generating code..."
-	go generate ./...
-	$(MAKE) client
-
-# Emit the OpenAPI spec on demand. The server serves it live at /openapi.yaml;
-# this is for external consumers or inspection and is not committed.
-.PHONY: openapi
-openapi:
-	@echo "Emitting OpenAPI spec from code..."
-	go run ./cmd/gen-openapi
-
-# Generate the strongly-typed Go HTTP clients (v1 and v2). The served specs are
-# OpenAPI 3.1, but oapi-codegen v2 does not yet read 3.1, so each client is
-# generated from a transient 3.0.3 downgrade of its document. Pinned so the
-# committed clients are reproducible.
-.PHONY: client
-client:
-	@echo "Generating API clients..."
-	@tmp=$$(mktemp -t headscale-openapi-3.0.XXXXXX.yaml); \
-	go run ./cmd/gen-openapi -downgrade "$$tmp" && \
-	go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@v2.7.1 \
-		-generate types,client -package clientv1 -o gen/client/v1/client.gen.go "$$tmp" && \
-	go run ./cmd/gen-openapi -api v2 -downgrade "$$tmp" && \
-	go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@v2.7.1 \
-		-generate types,client -package clientv2 -o gen/client/v2/client.gen.go "$$tmp"; \
-	status=$$?; rm -f "$$tmp"; exit $$status
-
-# Clean targets
-.PHONY: clean
-clean:
-	rm -rf headscale gen/client
-
-# Development workflow
-.PHONY: dev
-dev: fmt lint test build
-
-# Start a local headscale dev server (use mts to add nodes)
-.PHONY: dev-server
-dev-server:
-	go run ./cmd/dev
-
-# Help target
-.PHONY: help
-help:
-	@echo "Headscale Development Makefile"
-	@echo ""
-	@echo "Main targets:"
-	@echo "  all          - Run lint, test, and build (default)"
-	@echo "  build        - Build headscale binary"
-	@echo "  test         - Run Go tests"
-	@echo "  fmt          - Format all code (Go, docs, markup)"
-	@echo "  lint         - Lint all code (Go)"
-	@echo "  generate     - Generate code (go generate + client)"
-	@echo "  dev          - Full development workflow (fmt + lint + test + build)"
-	@echo "  clean        - Clean build artifacts"
-	@echo ""
-	@echo "Specific targets:"
-	@echo "  fmt-go       - Format Go code only"
-	@echo "  fmt-mdformat - Format documentation only"
-	@echo "  fmt-prettier - Format markup and config files only"
-	@echo "  lint-go      - Lint Go code only"
-	@echo ""
-	@echo "Dependencies:"
-	@echo "  check-deps   - Verify required tools are available"
-	@echo ""
-	@echo "Note: If not running in a nix shell, ensure dependencies are available:"
-	@echo "  nix develop"
+generate:
+	rm -rf gen
+	buf generate proto
@@ -1,4 +1,4 @@
-![headscale logo](./docs/assets/logo/headscale3_header_stacked_left.png)
+![headscale logo](./docs/logo/headscale3_header_stacked_left.png)

 ![ci](https://github.com/juanfont/headscale/actions/workflows/test.yml/badge.svg)

@@ -7,12 +7,8 @@ An open source, self-hosted implementation of the Tailscale control server.
 Join our [Discord server](https://discord.gg/c84AZQhmpx) for a chat.

 **Note:** Always select the same GitHub tag as the released version you use
-to ensure you have the correct example configuration. The `main` branch might
-contain unreleased changes. The documentation is available for stable and
-development versions:
-
- [Documentation for the stable version](https://headscale.net/stable/)
- [Documentation for the development version](https://headscale.net/development/)
+to ensure you have the correct example configuration and documentation.
+The `main` branch might contain unreleased changes.

 ## What is Tailscale

@@ -30,18 +26,18 @@ nodes in the Tailscale network. It assigns the IP addresses of the clients,
 creates the boundaries between each user, enables sharing machines between users,
 and exposes the advertised routes of your nodes.

-A [Tailscale network (tailnet)](https://tailscale.com/docs/concepts/tailnet) is
-private network which Tailscale assigns to a user in terms of private users or an
+A [Tailscale network (tailnet)](https://tailscale.com/kb/1136/tailnet/) is private
+network which Tailscale assigns to a user in terms of private users or an
 organisation.

 ## Design goal

-Headscale aims to implement a self-hosted, open source alternative to the
-[Tailscale](https://tailscale.com/) control server. Headscale's goal is to
-provide self-hosters and hobbyists with an open-source server they can use for
-their projects and labs. It implements a narrow scope, a _single_ Tailscale
-network (tailnet), suitable for a personal use, or a small open-source
-organisation.
+Headscale aims to implement a self-hosted, open source alternative to the Tailscale
+control server.
+Headscale's goal is to provide self-hosters and hobbyists with an open-source
+server they can use for their projects and labs.
+It implements a narrow scope, a single Tailnet, suitable for a personal use, or a small
+open-source organisation.

 ## Supporting Headscale

@@ -63,18 +59,8 @@ and container to run Headscale.**

 Please have a look at the [`documentation`](https://headscale.net/stable/).

-For NixOS users, a module is available in [`nix/`](./nix/).
-
-## Builds from `main`
-
-Development builds from the `main` branch are available as container images and
-binaries. See the [development builds](https://headscale.net/stable/setup/install/main/)
-documentation for details.
-
 ## Talks

- Fosdem 2026 (video): [Headscale & Tailscale: The complementary open source clone](https://fosdem.org/2026/schedule/event/KYQ3LL-headscale-the-complementary-open-source-clone/)
-  - presented by Kristoffer Dalby
 - Fosdem 2023 (video): [Headscale: How we are using integration testing to reimplement Tailscale](https://fosdem.org/2023/schedule/event/goheadscale/)
  - presented by Juan Font Alonso and Kristoffer Dalby

@@ -113,8 +99,6 @@ run `make lint` and `make fmt` before committing any code.
 The **Proto** code is linted with [`buf`](https://docs.buf.build/lint/overview) and
 formatted with [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html).

-The **docs** are formatted with [`mdformat`](https://mdformat.readthedocs.io).
-
 The **rest** (Markdown, YAML, etc) is formatted with [`prettier`](https://prettier.io).

 Check out the `.golangci.yaml` and `Makefile` to see the specific configuration.
@@ -151,30 +135,15 @@ make test
 To build the program:

 ```shell
-make build
+nix build
 ```

-### Development workflow
-
-We recommend using Nix for dependency management to ensure you have all required tools. If you prefer to manage dependencies yourself, you can use Make directly:
-
-**With Nix (recommended):**
+or

 ```shell
-nix develop
-make test
 make build
 ```

-**With your own dependencies:**
-
-```shell
-make test
-make build
-```
-
-The Makefile will warn you if any required tools are missing and suggest running `nix develop`. Run `make help` to see all available targets.
-
 ## Contributors

 <a href="https://github.com/juanfont/headscale/graphs/contributors">
@@ -0,0 +1,21 @@
+version: v1
+plugins:
+  - name: go
+    out: gen/go
+    opt:
+      - paths=source_relative
+  - name: go-grpc
+    out: gen/go
+    opt:
+      - paths=source_relative
+  - name: grpc-gateway
+    out: gen/go
+    opt:
+      - paths=source_relative
+      - generate_unbound_methods=true
+  # - name: gorm
+  #   out: gen/go
+  #   opt:
+  #     - paths=source_relative,enums=string,gateway=true
+  - name: openapiv2
+    out: gen/openapiv2
@@ -1,95 +0,0 @@
-# cmd/dev -- Local Development Environment
-
-Starts a headscale server on localhost with a pre-created user and
-pre-auth key. Pair with `mts` to add real tailscale nodes.
-
-## Quick start
-
-```bash
-# Terminal 1: start headscale
-go run ./cmd/dev
-
-# Terminal 2: start mts server
-go tool mts server run
-
-# Terminal 3: add and connect nodes
-go tool mts server add node1
-go tool mts server add node2
-
-# Disable logtail (avoids startup delays, see "Known issues" below)
-for n in node1 node2; do
-  cat > ~/.config/multi-tailscale-dev/$n/env.txt << 'EOF'
-TS_NO_LOGS_NO_SUPPORT=true
-EOF
-done
-
-# Restart nodes so env.txt takes effect
-go tool mts server stop node1 && go tool mts server start node1
-go tool mts server stop node2 && go tool mts server start node2
-
-# Connect to headscale (use the auth key printed by cmd/dev)
-go tool mts node1 up --login-server=http://127.0.0.1:8080 --authkey=<KEY> --reset
-go tool mts node2 up --login-server=http://127.0.0.1:8080 --authkey=<KEY> --reset
-
-# Verify
-go tool mts node1 status
-```
-
-## Flags
-
-| Flag     | Default | Description                  |
-| -------- | ------- | ---------------------------- |
-| `--port` | 8080    | Headscale listen port        |
-| `--keep` | false   | Keep state directory on exit |
-
-The metrics/debug port is `port + 1010` (default 9090).
-
-## What it does
-
-1. Builds the headscale binary into a temp directory
-2. Writes a minimal dev config (SQLite, public DERP, debug logging)
-3. Starts `headscale serve` as a subprocess
-4. Creates a "dev" user and a reusable 24h pre-auth key via the CLI
-5. Prints a banner with server URL, auth key, and usage instructions
-6. Blocks until Ctrl+C, then kills headscale
-
-State lives in `/tmp/headscale-dev-*/`. Pass `--keep` to preserve it
-across restarts (useful for inspecting the database or reusing keys).
-
-## Useful endpoints
-
- `http://127.0.0.1:8080/health` -- health check
- `http://127.0.0.1:9090/debug/ping` -- interactive ping UI
- `http://127.0.0.1:9090/debug/ping?node=1` -- quick-ping a node
- `POST http://127.0.0.1:9090/debug/ping` with `node=<id>` -- trigger ping
-
-## Managing headscale
-
-The banner prints the full path to the built binary and config. Use it
-for any headscale CLI command:
-
-```bash
-/tmp/headscale-dev-*/headscale -c /tmp/headscale-dev-*/config.yaml nodes list
-/tmp/headscale-dev-*/headscale -c /tmp/headscale-dev-*/config.yaml users list
-```
-
-## Known issues
-
-### Logtail delays on mts nodes
-
-Freshly created `mts` instances may take 30+ seconds to start if
-`~/.local/share/tailscale/` contains stale logtail cache from previous
-tailscaled runs. The daemon blocks trying to upload old logs before
-creating its socket.
-
-Fix: write `TS_NO_LOGS_NO_SUPPORT=true` to each instance's `env.txt`
-before starting (or restart after writing). See the quick start above.
-
-### mts node cleanup
-
-`mts` stores state in `~/.config/multi-tailscale-dev/`. Old instances
-accumulate over time. Clean them with:
-
-```bash
-go tool mts server rm <name>
-```
@@ -1,312 +0,0 @@
-// cmd/dev starts a local headscale development server with a pre-created
-// user and pre-auth key, ready for connecting tailscale nodes via mts.
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"strconv"
-	"syscall"
-	"time"
-)
-
-var (
-	port = flag.Int("port", 8080, "headscale listen port")
-	keep = flag.Bool("keep", false, "keep state directory on exit")
-)
-
-var errHealthTimeout = errors.New("health check timed out")
-
-var errEmptyAuthKey = errors.New("empty auth key in response")
-
-// maxDevPort is the highest --port value that keeps the derived metrics
-// port (port+1010) inside the valid 1..65535 TCP range.
-const maxDevPort = 64525
-
-const devConfig = `---
-server_url: http://127.0.0.1:%d
-listen_addr: 127.0.0.1:%d
-metrics_listen_addr: 127.0.0.1:%d
-
-noise:
-  private_key_path: %s/noise_private.key
-
-prefixes:
-  v4: 100.64.0.0/10
-  v6: fd7a:115c:a1e0::/48
-  allocation: sequential
-
-database:
-  type: sqlite
-  sqlite:
-    path: %s/db.sqlite
-    write_ahead_log: true
-
-derp:
-  server:
-    enabled: false
-  urls:
-    - https://controlplane.tailscale.com/derpmap/default
-  auto_update_enabled: false
-
-dns:
-  magic_dns: true
-  base_domain: headscale.dev
-  override_local_dns: false
-
-log:
-  level: debug
-  format: text
-
-policy:
-  mode: database
-
-unix_socket: %s/headscale.sock
-unix_socket_permission: "0770"
-`
-
-func main() {
-	flag.Parse()
-	log.SetFlags(0)
-
-	if *port < 1 || *port > maxDevPort {
-		log.Fatalf(
-			"--port must be in 1..%d (higher values overflow the derived metrics port); got %d",
-			maxDevPort, *port,
-		)
-	}
-
-	http.DefaultClient.Timeout = 2 * time.Second
-	http.DefaultClient.CheckRedirect = func(*http.Request, []*http.Request) error {
-		return http.ErrUseLastResponse
-	}
-
-	err := run()
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-func run() error {
-	metricsPort := *port + 1010 // default 9090
-
-	tmpDir, err := os.MkdirTemp("", "headscale-dev-")
-	if err != nil {
-		return fmt.Errorf("creating temp dir: %w", err)
-	}
-
-	if !*keep {
-		defer os.RemoveAll(tmpDir)
-	}
-
-	// Write config.
-	configPath := filepath.Join(tmpDir, "config.yaml")
-	configContent := fmt.Sprintf(
-		devConfig,
-		*port, *port, metricsPort,
-		tmpDir, tmpDir, tmpDir,
-	)
-
-	err = os.WriteFile(configPath, []byte(configContent), 0o600)
-	if err != nil {
-		return fmt.Errorf("writing config: %w", err)
-	}
-
-	// Build headscale.
-	fmt.Println("Building headscale...")
-
-	hsBin := filepath.Join(tmpDir, "headscale")
-
-	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
-	defer stop()
-
-	build := exec.CommandContext(ctx, "go", "build", "-o", hsBin, "./cmd/headscale")
-	build.Stdout = os.Stdout
-	build.Stderr = os.Stderr
-
-	err = build.Run()
-	if err != nil {
-		return fmt.Errorf("building headscale: %w", err)
-	}
-
-	// Start headscale serve.
-	fmt.Println("Starting headscale server...")
-
-	serve := exec.CommandContext(ctx, hsBin, "serve", "-c", configPath)
-	serve.Stdout = os.Stdout
-	serve.Stderr = os.Stderr
-
-	err = serve.Start()
-	if err != nil {
-		return fmt.Errorf("starting headscale: %w", err)
-	}
-
-	// Wait for server to be ready.
-	healthURL := fmt.Sprintf("http://127.0.0.1:%d/health", *port)
-
-	err = waitForHealth(ctx, healthURL, 30*time.Second)
-	if err != nil {
-		return fmt.Errorf("waiting for headscale: %w", err)
-	}
-
-	// Create user.
-	fmt.Println("Creating user and pre-auth key...")
-
-	userJSON, err := runHS(ctx, hsBin, configPath, "users", "create", "dev", "-o", "json")
-	if err != nil {
-		return fmt.Errorf("creating user: %w", err)
-	}
-
-	userID, err := extractUserID(userJSON)
-	if err != nil {
-		return fmt.Errorf("parsing user: %w", err)
-	}
-
-	// Create pre-auth key.
-	keyJSON, err := runHS(
-		ctx, hsBin, configPath,
-		"preauthkeys", "create",
-		"-u", strconv.FormatUint(userID, 10),
-		"--reusable",
-		"-e", "24h",
-		"-o", "json",
-	)
-	if err != nil {
-		return fmt.Errorf("creating pre-auth key: %w", err)
-	}
-
-	authKey, err := extractAuthKey(keyJSON)
-	if err != nil {
-		return fmt.Errorf("parsing pre-auth key: %w", err)
-	}
-
-	// Print banner.
-	fmt.Printf(
-		`
-=== Headscale Dev Environment ===
-  Server:  http://127.0.0.1:%d
-  Metrics: http://127.0.0.1:%d
-  Debug:   http://127.0.0.1:%d/debug/ping
-  Config:  %s
-  State:   %s
-
-Pre-auth key: %s
-
-Connect nodes with mts:
-  go tool mts server run                  # start mts (once, another terminal)
-  go tool mts server add node1            # create a node
-  go tool mts node1 up --login-server=http://127.0.0.1:%d --authkey=%s
-  go tool mts node1 status                # check connection
-
-Manage headscale:
-  %s -c %s nodes list
-  %s -c %s users list
-
-Press Ctrl+C to stop.
-`,
-		*port, metricsPort, metricsPort,
-		configPath, tmpDir,
-		authKey,
-		*port, authKey,
-		hsBin, configPath,
-		hsBin, configPath,
-	)
-
-	// Wait for headscale to exit.
-	err = serve.Wait()
-	if err != nil {
-		// Context cancellation is expected on Ctrl+C.
-		if ctx.Err() != nil {
-			fmt.Println("\nShutting down...")
-
-			return nil
-		}
-
-		return fmt.Errorf("headscale exited: %w", err)
-	}
-
-	return nil
-}
-
-// waitForHealth polls the health endpoint until it returns 200 or the
-// timeout expires.
-func waitForHealth(ctx context.Context, url string, timeout time.Duration) error {
-	deadline := time.Now().Add(timeout)
-
-	for time.Now().Before(deadline) {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-		if err != nil {
-			return fmt.Errorf("creating request: %w", err)
-		}
-
-		resp, err := http.DefaultClient.Do(req)
-		if err == nil {
-			resp.Body.Close()
-
-			if resp.StatusCode == http.StatusOK {
-				return nil
-			}
-		}
-
-		// Busy-wait is acceptable for a dev tool polling a local server.
-		time.Sleep(200 * time.Millisecond) //nolint:forbidigo
-	}
-
-	return errHealthTimeout
-}
-
-// runHS executes a headscale CLI command and returns its stdout.
-func runHS(ctx context.Context, bin, config string, args ...string) ([]byte, error) {
-	fullArgs := append([]string{"-c", config}, args...)
-	cmd := exec.CommandContext(ctx, bin, fullArgs...)
-	cmd.Stderr = os.Stderr
-
-	return cmd.Output()
-}
-
-// extractUserID parses the JSON output of "users create" and returns the
-// user ID.
-func extractUserID(data []byte) (uint64, error) {
-	var user struct {
-		ID uint64 `json:"id"`
-	}
-
-	err := json.Unmarshal(data, &user)
-	if err != nil {
-		return 0, fmt.Errorf("unmarshalling user JSON: %w (raw: %s)", err, data)
-	}
-
-	return user.ID, nil
-}
-
-// extractAuthKey parses the JSON output of "preauthkeys create" and
-// returns the key string.
-func extractAuthKey(data []byte) (string, error) {
-	var key struct {
-		Key string `json:"key"`
-	}
-
-	err := json.Unmarshal(data, &key)
-	if err != nil {
-		return "", fmt.Errorf("unmarshalling key JSON: %w (raw: %s)", err, data)
-	}
-
-	if key.Key == "" {
-		return "", errEmptyAuthKey
-	}
-
-	return key.Key, nil
-}
@@ -1,75 +0,0 @@
-// Command gen-openapi emits a Headscale OpenAPI document from the authoritative
-// Huma definitions in hscontrol/api/v1 and hscontrol/api/v2. The server also
-// serves each spec live (at /openapi.yaml and /api/v2/openapi); this tool emits
-// them on demand, and with -downgrade the 3.0.3 form used to generate the typed
-// client. The output is not committed.
-//
-// Usage:
-//
-//	go run ./cmd/gen-openapi                       # write the v1 3.1 spec to its default path
-//	go run ./cmd/gen-openapi -api v2               # write the v2 3.1 spec to its default path
-//	go run ./cmd/gen-openapi -downgrade <path>     # write the v1 3.0.3 downgrade (for client gen)
-//	go run ./cmd/gen-openapi -api v2 -downgrade <path>  # the v2 3.0.3 downgrade
-package main
-
-import (
-	"flag"
-	"log"
-	"os"
-	"path/filepath"
-
-	apiv1 "github.com/juanfont/headscale/hscontrol/api/v1"
-	apiv2 "github.com/juanfont/headscale/hscontrol/api/v2"
-)
-
-// spec bundles a version's full (3.1) and downgraded (3.0.3) generators with the
-// committed output path. outPath is relative to the repository root.
-type spec struct {
-	full    func() ([]byte, error)
-	down    func() ([]byte, error)
-	outPath string
-}
-
-// specs maps the -api value to its generators.
-var specs = map[string]spec{
-	"v1": {apiv1.Spec, apiv1.Spec30, "openapi/v1/headscale.yaml"},
-	"v2": {apiv2.Spec, apiv2.Spec30, "openapi/v2/headscale.yaml"},
-}
-
-func main() {
-	api := flag.String("api", "v1", "which API spec to emit: v1 or v2")
-	downgrade := flag.String("downgrade", "", "write the OpenAPI 3.0.3 downgrade to this path instead of the committed 3.1 spec")
-	flag.Parse()
-
-	s, ok := specs[*api]
-	if !ok {
-		log.Fatalf("unknown -api %q (want v1 or v2)", *api)
-	}
-
-	if *downgrade != "" {
-		writeSpec(*downgrade, s.down)
-
-		return
-	}
-
-	writeSpec(s.outPath, s.full)
-}
-
-func writeSpec(path string, gen func() ([]byte, error)) {
-	spec, err := gen()
-	if err != nil {
-		log.Fatalf("generating OpenAPI spec: %v", err)
-	}
-
-	err = os.MkdirAll(filepath.Dir(path), 0o755)
-	if err != nil {
-		log.Fatalf("creating output directory: %v", err)
-	}
-
-	err = os.WriteFile(path, spec, 0o600)
-	if err != nil {
-		log.Fatalf("writing %s: %v", path, err)
-	}
-
-	log.Printf("wrote %s", path)
-}
@@ -0,0 +1,69 @@
+package main
+
+//go:generate go run ./main.go
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os/exec"
+	"strings"
+)
+
+func findTests() []string {
+	rgBin, err := exec.LookPath("rg")
+	if err != nil {
+		log.Fatalf("failed to find rg (ripgrep) binary")
+	}
+
+	args := []string{
+		"--regexp", "func (Test.+)\\(.*",
+		"../../integration/",
+		"--replace", "$1",
+		"--sort", "path",
+		"--no-line-number",
+		"--no-filename",
+		"--no-heading",
+	}
+
+	cmd := exec.Command(rgBin, args...)
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err = cmd.Run()
+	if err != nil {
+		log.Fatalf("failed to run command: %s", err)
+	}
+
+	tests := strings.Split(strings.TrimSpace(out.String()), "\n")
+	return tests
+}
+
+func updateYAML(tests []string) {
+	testsForYq := fmt.Sprintf("[%s]", strings.Join(tests, ", "))
+
+	yqCommand := fmt.Sprintf(
+		"yq eval '.jobs.integration-test.strategy.matrix.test = %s' ../../.github/workflows/test-integration.yaml -i",
+		testsForYq,
+	)
+	cmd := exec.Command("bash", "-c", yqCommand)
+
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		log.Fatalf("failed to run yq command: %s", err)
+	}
+
+	fmt.Println("YAML file updated successfully")
+}
+
+func main() {
+	tests := findTests()
+
+	quotedTests := make([]string, len(tests))
+	for i, test := range tests {
+		quotedTests[i] = fmt.Sprintf("\"%s\"", test)
+	}
+
+	updateYAML(quotedTests)
+}
@@ -1,18 +1,21 @@
 package cli

 import (
-	"context"
 	"fmt"
-	"net/http"
 	"strconv"
+	"time"

-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
 	"github.com/juanfont/headscale/hscontrol/util"
+	"github.com/prometheus/common/model"
+	"github.com/pterm/pterm"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )

 const (
-	// DefaultAPIKeyExpiry is 90 days.
+	// 90 days.
 	DefaultAPIKeyExpiry = "90d"
 )

@@ -26,11 +29,15 @@ func init() {
 	apiKeysCmd.AddCommand(createAPIKeyCmd)

 	expireAPIKeyCmd.Flags().StringP("prefix", "p", "", "ApiKey prefix")
-	expireAPIKeyCmd.Flags().Uint64P("id", "i", 0, "ApiKey ID")
+	if err := expireAPIKeyCmd.MarkFlagRequired("prefix"); err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	apiKeysCmd.AddCommand(expireAPIKeyCmd)

 	deleteAPIKeyCmd.Flags().StringP("prefix", "p", "", "ApiKey prefix")
-	deleteAPIKeyCmd.Flags().Uint64P("id", "i", 0, "ApiKey ID")
+	if err := deleteAPIKeyCmd.MarkFlagRequired("prefix"); err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	apiKeysCmd.AddCommand(deleteAPIKeyCmd)
 }

@@ -41,45 +48,58 @@ var apiKeysCmd = &cobra.Command{
 }

 var listAPIKeys = &cobra.Command{
-	Use:     cmdList,
+	Use:     "list",
 	Short:   "List the Api keys for headscale",
-	Aliases: []string{"ls", cmdShow},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		resp, err := client.ListApiKeysWithResponse(ctx)
+	Aliases: []string{"ls", "show"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		request := &v1.ListApiKeysRequest{}
+
+		response, err := client.ListApiKeys(ctx, request)
 		if err != nil {
-			return fmt.Errorf("listing api keys: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting the list of keys: %s", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
+		if output != "" {
+			SuccessOutput(response.GetApiKeys(), "", output)
 		}

-		apiKeys := resp.JSON200.ApiKeys
+		tableData := pterm.TableData{
+			{"ID", "Prefix", "Expiration", "Created"},
+		}
+		for _, key := range response.GetApiKeys() {
+			expiration := "-"

-		return printListOutput(cmd, apiKeys, func() error {
-			rows := make([][]string, 0, len(apiKeys))
-			for _, key := range apiKeys {
-				expiration := "-"
-				if key.Expiration != nil {
-					expiration = ColourTime(*key.Expiration)
-				}
-
-				var created string
-				if key.CreatedAt != nil {
-					created = key.CreatedAt.Format(HeadscaleDateTimeFormat)
-				}
-
-				rows = append(rows, []string{
-					key.Id,
-					key.Prefix,
-					expiration,
-					created,
-				})
+			if key.GetExpiration() != nil {
+				expiration = ColourTime(key.GetExpiration().AsTime())
 			}

-			return renderTable([]string{"ID", "Prefix", colExpiration, colCreated}, rows)
-		})
-	}),
+			tableData = append(tableData, []string{
+				strconv.FormatUint(key.GetId(), util.Base10),
+				key.GetPrefix(),
+				expiration,
+				key.GetCreatedAt().AsTime().Format(HeadscaleDateTimeFormat),
+			})
+
+		}
+		err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to render pterm table: %s", err),
+				output,
+			)
+		}
+	},
 }

 var createAPIKeyCmd = &cobra.Command{
@@ -88,136 +108,115 @@ var createAPIKeyCmd = &cobra.Command{
 	Long: `
 Creates a new Api key, the Api key is only visible on creation
 and cannot be retrieved again.
-If you lose a key, create a new one and revoke (expire) the old one.`,
-	Aliases: []string{"c", cmdNew},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		expiryTime, err := expirationFromFlag(cmd)
+If you loose a key, create a new one and revoke (expire) the old one.`,
+	Aliases: []string{"c", "new"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		request := &v1.CreateApiKeyRequest{}
+
+		durationStr, _ := cmd.Flags().GetString("expiration")
+
+		duration, err := model.ParseDuration(durationStr)
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Could not parse duration: %s\n", err),
+				output,
+			)
 		}

-		resp, err := client.CreateApiKeyWithResponse(ctx, clientv1.CreateApiKeyJSONRequestBody{
-			Expiration: &expiryTime,
-		})
+		expiration := time.Now().UTC().Add(time.Duration(duration))
+
+		request.Expiration = timestamppb.New(expiration)
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		response, err := client.CreateApiKey(ctx, request)
 		if err != nil {
-			return fmt.Errorf("creating api key: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create Api Key: %s\n", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200.ApiKey, resp.JSON200.ApiKey)
-	}),
-}
-
-// apiKeyIDOrPrefix reads --id and --prefix from cmd and validates that
-// exactly one is provided.
-func apiKeyIDOrPrefix(cmd *cobra.Command) (uint64, string, error) {
-	id, _ := cmd.Flags().GetUint64("id")
-	prefix, _ := cmd.Flags().GetString("prefix")
-
-	switch {
-	case id == 0 && prefix == "":
-		return 0, "", fmt.Errorf("either --id or --prefix must be provided: %w", errMissingParameter)
-	case id != 0 && prefix != "":
-		return 0, "", fmt.Errorf("only one of --id or --prefix can be provided: %w", errMissingParameter)
-	}
-
-	return id, prefix, nil
+		SuccessOutput(response.GetApiKey(), response.GetApiKey(), output)
+	},
 }

 var expireAPIKeyCmd = &cobra.Command{
-	Use:     cmdExpire,
+	Use:     "expire",
 	Short:   "Expire an ApiKey",
-	Aliases: []string{"revoke", aliasExp, "e"},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		id, prefix, err := apiKeyIDOrPrefix(cmd)
+	Aliases: []string{"revoke", "exp", "e"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		prefix, err := cmd.Flags().GetString("prefix")
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting prefix from CLI flag: %s", err),
+				output,
+			)
 		}

-		body := clientv1.ExpireApiKeyJSONRequestBody{}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-		if id != 0 {
-			idStr := strconv.FormatUint(id, util.Base10)
-			body.Id = &idStr
+		request := &v1.ExpireApiKeyRequest{
+			Prefix: prefix,
 		}

-		if prefix != "" {
-			body.Prefix = &prefix
-		}
-
-		resp, err := client.ExpireApiKeyWithResponse(ctx, body)
+		response, err := client.ExpireApiKey(ctx, request)
 		if err != nil {
-			return fmt.Errorf("expiring api key: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot expire Api Key: %s\n", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Key expired")
-	}),
+		SuccessOutput(response, "Key expired", output)
+	},
 }

 var deleteAPIKeyCmd = &cobra.Command{
-	Use:     cmdDelete,
+	Use:     "delete",
 	Short:   "Delete an ApiKey",
-	Aliases: []string{"remove", aliasDel},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		id, prefix, err := apiKeyIDOrPrefix(cmd)
+	Aliases: []string{"remove", "del"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		prefix, err := cmd.Flags().GetString("prefix")
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting prefix from CLI flag: %s", err),
+				output,
+			)
 		}

-		// The DELETE route addresses the key by its prefix in the path. When the
-		// user deletes by --id we resolve the id to its (masked) prefix first,
-		// since the path segment is required and a query-only id cannot be routed.
-		if prefix == "" {
-			prefix, err = apiKeyPrefixForID(ctx, client, id)
-			if err != nil {
-				return err
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		request := &v1.DeleteApiKeyRequest{
+			Prefix: prefix,
 		}

-		resp, err := client.DeleteApiKeyWithResponse(ctx, prefix, &clientv1.DeleteApiKeyParams{})
+		response, err := client.DeleteApiKey(ctx, request)
 		if err != nil {
-			return fmt.Errorf("deleting api key: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot delete Api Key: %s\n", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Key deleted")
-	}),
-}
-
-// apiKeyPrefixForID resolves an API key id to its display prefix by listing the
-// keys. The DELETE endpoint addresses keys by prefix in the URL path, so a
-// delete by --id needs the prefix; the returned masked prefix is accepted by
-// the server's lookup.
-func apiKeyPrefixForID(
-	ctx context.Context,
-	client *clientv1.ClientWithResponses,
-	id uint64,
-) (string, error) {
-	resp, err := client.ListApiKeysWithResponse(ctx)
-	if err != nil {
-		return "", fmt.Errorf("listing api keys: %w", err)
-	}
-
-	if resp.StatusCode() != http.StatusOK {
-		return "", apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-	}
-
-	idStr := strconv.FormatUint(id, util.Base10)
-	for _, key := range resp.JSON200.ApiKeys {
-		if key.Id == idStr {
-			return key.Prefix, nil
-		}
-	}
-
-	return "", fmt.Errorf("%w: api key %d not found", errMissingParameter, id)
+		SuccessOutput(response, "Key deleted", output)
+	},
 }
@@ -1,99 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	rootCmd.AddCommand(authCmd)
-
-	authRegisterCmd.Flags().StringP("user", "u", "", "User")
-	authRegisterCmd.Flags().String("auth-id", "", "Auth ID")
-	mustMarkRequired(authRegisterCmd, "user", "auth-id")
-	authCmd.AddCommand(authRegisterCmd)
-
-	authApproveCmd.Flags().String("auth-id", "", "Auth ID")
-	mustMarkRequired(authApproveCmd, "auth-id")
-	authCmd.AddCommand(authApproveCmd)
-
-	authRejectCmd.Flags().String("auth-id", "", "Auth ID")
-	mustMarkRequired(authRejectCmd, "auth-id")
-	authCmd.AddCommand(authRejectCmd)
-}
-
-var authCmd = &cobra.Command{
-	Use:   "auth",
-	Short: "Manage node authentication and approval",
-}
-
-var authRegisterCmd = &cobra.Command{
-	Use:   "register",
-	Short: "Register a node to your network",
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		user, _ := cmd.Flags().GetString("user")
-		authID, _ := cmd.Flags().GetString("auth-id")
-
-		resp, err := client.AuthRegisterWithResponse(ctx, clientv1.AuthRegisterJSONRequestBody{
-			AuthId: &authID,
-			User:   &user,
-		})
-		if err != nil {
-			return fmt.Errorf("registering node: %w", err)
-		}
-
-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		node := resp.JSON200.Node
-
-		return printOutput(
-			cmd,
-			node,
-			fmt.Sprintf("Node %s registered", node.GivenName),
-		)
-	}),
-}
-
-var authApproveCmd = &cobra.Command{
-	Use:   "approve",
-	Short: "Approve a pending authentication request",
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		authID, _ := cmd.Flags().GetString("auth-id")
-
-		resp, err := client.AuthApproveWithResponse(ctx, clientv1.AuthApproveJSONRequestBody{AuthId: &authID})
-		if err != nil {
-			return fmt.Errorf("approving auth request: %w", err)
-		}
-
-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Auth request approved")
-	}),
-}
-
-var authRejectCmd = &cobra.Command{
-	Use:   "reject",
-	Short: "Reject a pending authentication request",
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		authID, _ := cmd.Flags().GetString("auth-id")
-
-		resp, err := client.AuthRejectWithResponse(ctx, clientv1.AuthRejectJSONRequestBody{AuthId: &authID})
-		if err != nil {
-			return fmt.Errorf("rejecting auth request: %w", err)
-		}
-
-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Auth request rejected")
-	}),
-}
@@ -1,8 +1,7 @@
 package cli

 import (
-	"fmt"
-
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 )

@@ -14,12 +13,10 @@ var configTestCmd = &cobra.Command{
 	Use:   "configtest",
 	Short: "Test the configuration.",
 	Long:  "Run a test of the configuration and exit.",
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
 		_, err := newHeadscaleServerWithConfig()
 		if err != nil {
-			return fmt.Errorf("configuration error: %w", err)
+			log.Fatal().Caller().Err(err).Msg("Error initializing")
 		}
-
-		return nil
 	},
 }
@@ -1,23 +1,48 @@
 package cli

 import (
-	"context"
 	"fmt"
-	"net/http"

-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/juanfont/headscale/hscontrol/types"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+	"google.golang.org/grpc/status"
+	"tailscale.com/types/key"
 )

+const (
+	errPreAuthKeyMalformed = Error("key is malformed. expected 64 hex characters with `nodekey` prefix")
+)
+
+// Error is used to compare errors as per https://dave.cheney.net/2016/04/07/constant-errors
+type Error string
+
+func (e Error) Error() string { return string(e) }
+
 func init() {
 	rootCmd.AddCommand(debugCmd)

 	createNodeCmd.Flags().StringP("name", "", "", "Name")
+	err := createNodeCmd.MarkFlagRequired("name")
+	if err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	createNodeCmd.Flags().StringP("user", "u", "", "User")
-	createNodeCmd.Flags().StringP("key", "k", "", "Key")
-	mustMarkRequired(createNodeCmd, "name", "user", "key")

+	createNodeCmd.Flags().StringP("namespace", "n", "", "User")
+	createNodeNamespaceFlag := createNodeCmd.Flags().Lookup("namespace")
+	createNodeNamespaceFlag.Deprecated = deprecateNamespaceMessage
+	createNodeNamespaceFlag.Hidden = true
+
+	err = createNodeCmd.MarkFlagRequired("user")
+	if err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
+	createNodeCmd.Flags().StringP("key", "k", "", "Key")
+	err = createNodeCmd.MarkFlagRequired("key")
+	if err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	createNodeCmd.Flags().
 		StringSliceP("route", "r", []string{}, "List (or repeated flags) of routes to advertise")

@@ -32,33 +57,72 @@ var debugCmd = &cobra.Command{

 var createNodeCmd = &cobra.Command{
 	Use:   "create-node",
-	Short: "Create a node that can be registered with `auth register <>` command",
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		user, _ := cmd.Flags().GetString("user")
-		name, _ := cmd.Flags().GetString("name")
-		registrationID, _ := cmd.Flags().GetString("key")
+	Short: "Create a node that can be registered with `nodes register <>` command",
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")

-		_, err := types.AuthIDFromString(registrationID)
+		user, err := cmd.Flags().GetString("user")
 		if err != nil {
-			return fmt.Errorf("parsing machine key: %w", err)
+			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
 		}

-		routes, _ := cmd.Flags().GetStringSlice("route")
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-		resp, err := client.DebugCreateNodeWithResponse(ctx, clientv1.DebugCreateNodeJSONRequestBody{
-			Key:    &registrationID,
-			Name:   &name,
-			User:   &user,
-			Routes: &routes,
-		})
+		name, err := cmd.Flags().GetString("name")
 		if err != nil {
-			return fmt.Errorf("creating node: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting node from flag: %s", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
+		machineKey, err := cmd.Flags().GetString("key")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting key from flag: %s", err),
+				output,
+			)
 		}

-		return printOutput(cmd, resp.JSON200.Node, "Node created")
-	}),
+		var mkey key.MachinePublic
+		err = mkey.UnmarshalText([]byte(machineKey))
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to parse machine key from flag: %s", err),
+				output,
+			)
+		}
+
+		routes, err := cmd.Flags().GetStringSlice("route")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting routes from flag: %s", err),
+				output,
+			)
+		}
+
+		request := &v1.DebugCreateNodeRequest{
+			Key:    machineKey,
+			Name:   name,
+			User:   user,
+			Routes: routes,
+		}
+
+		response, err := client.DebugCreateNode(ctx, request)
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create node: %s", status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		SuccessOutput(response.GetNode(), "Node created", output)
+	},
 }
@@ -15,12 +15,14 @@ var dumpConfigCmd = &cobra.Command{
 	Use:    "dumpConfig",
 	Short:  "dump current config to /etc/headscale/config.dump.yaml, integration test only",
 	Hidden: true,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		err := viper.WriteConfigAs("/etc/headscale/config.dump.yaml")
-		if err != nil {
-			return fmt.Errorf("dumping config: %w", err)
-		}
-
+	Args: func(cmd *cobra.Command, args []string) error {
 		return nil
 	},
+	Run: func(cmd *cobra.Command, args []string) {
+		err := viper.WriteConfigAs("/etc/headscale/config.dump.yaml")
+		if err != nil {
+			//nolint
+			fmt.Println("Failed to dump config")
+		}
+	},
 }
@@ -21,17 +21,22 @@ var generateCmd = &cobra.Command{
 var generatePrivateKeyCmd = &cobra.Command{
 	Use:   "private-key",
 	Short: "Generate a private key for the headscale server",
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
 		machineKey := key.NewMachine()

 		machineKeyStr, err := machineKey.MarshalText()
 		if err != nil {
-			return fmt.Errorf("marshalling machine key: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting machine key from flag: %s", err),
+				output,
+			)
 		}

-		return printOutput(cmd, map[string]string{
+		SuccessOutput(map[string]string{
 			"private_key": string(machineKeyStr),
 		},
-			string(machineKeyStr))
+			string(machineKeyStr), output)
 	},
 }
@@ -1,32 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	rootCmd.AddCommand(healthCmd)
-}
-
-var healthCmd = &cobra.Command{
-	Use:   "health",
-	Short: "Check the health of the Headscale server",
-	Long:  "Check the health of the Headscale server. This command will return an exit code of 0 if the server is healthy, or 1 if it is not.",
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		resp, err := client.HealthWithResponse(ctx)
-		if err != nil {
-			return fmt.Errorf("checking health: %w", err)
-		}
-
-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "")
-	}),
-}
@@ -1,9 +1,7 @@
 package cli

 import (
-	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -11,21 +9,18 @@ import (
 	"strconv"
 	"time"

-	"github.com/juanfont/headscale/hscontrol/util/zlog/zf"
 	"github.com/oauth2-proxy/mockoidc"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 )

-var (
-	errMockOidcClientIDNotDefined     = errors.New("MOCKOIDC_CLIENT_ID not defined")
-	errMockOidcClientSecretNotDefined = errors.New("MOCKOIDC_CLIENT_SECRET not defined")
-	errMockOidcPortNotDefined         = errors.New("MOCKOIDC_PORT not defined")
-	errMockOidcUsersNotDefined        = errors.New("MOCKOIDC_USERS not defined")
+const (
+	errMockOidcClientIDNotDefined     = Error("MOCKOIDC_CLIENT_ID not defined")
+	errMockOidcClientSecretNotDefined = Error("MOCKOIDC_CLIENT_SECRET not defined")
+	errMockOidcPortNotDefined         = Error("MOCKOIDC_PORT not defined")
+	refreshTTL                        = 60 * time.Minute
 )

-const refreshTTL = 60 * time.Minute
-
 var accessTTL = 2 * time.Minute

 func init() {
@@ -36,13 +31,12 @@ var mockOidcCmd = &cobra.Command{
 	Use:   "mockoidc",
 	Short: "Runs a mock OIDC server for testing",
 	Long:  "This internal command runs a OpenID Connect for testing purposes",
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
 		err := mockOIDC()
 		if err != nil {
-			return fmt.Errorf("running mock OIDC server: %w", err)
+			log.Error().Err(err).Msgf("Error running mock OIDC server")
+			os.Exit(1)
 		}
-
-		return nil
 	},
 }

@@ -51,47 +45,41 @@ func mockOIDC() error {
 	if clientID == "" {
 		return errMockOidcClientIDNotDefined
 	}
-
 	clientSecret := os.Getenv("MOCKOIDC_CLIENT_SECRET")
 	if clientSecret == "" {
 		return errMockOidcClientSecretNotDefined
 	}
-
 	addrStr := os.Getenv("MOCKOIDC_ADDR")
 	if addrStr == "" {
 		return errMockOidcPortNotDefined
 	}
-
 	portStr := os.Getenv("MOCKOIDC_PORT")
 	if portStr == "" {
 		return errMockOidcPortNotDefined
 	}
-
 	accessTTLOverride := os.Getenv("MOCKOIDC_ACCESS_TTL")
 	if accessTTLOverride != "" {
 		newTTL, err := time.ParseDuration(accessTTLOverride)
 		if err != nil {
 			return err
 		}
-
 		accessTTL = newTTL
 	}

 	userStr := os.Getenv("MOCKOIDC_USERS")
 	if userStr == "" {
-		return errMockOidcUsersNotDefined
+		return fmt.Errorf("MOCKOIDC_USERS not defined")
 	}

 	var users []mockoidc.MockUser
-
 	err := json.Unmarshal([]byte(userStr), &users)
 	if err != nil {
 		return fmt.Errorf("unmarshalling users: %w", err)
 	}

-	log.Info().Interface(zf.Users, users).Msg("loading users from JSON")
+	log.Info().Interface("users", users).Msg("loading users from JSON")

-	log.Info().Msgf("access token TTL: %s", accessTTL)
+	log.Info().Msgf("Access token TTL: %s", accessTTL)

 	port, err := strconv.Atoi(portStr)
 	if err != nil {
@@ -103,7 +91,7 @@ func mockOIDC() error {
 		return err
 	}

-	listener, err := new(net.ListenConfig).Listen(context.Background(), "tcp", fmt.Sprintf("%s:%d", addrStr, port))
+	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", addrStr, port))
 	if err != nil {
 		return err
 	}
@@ -112,10 +100,8 @@ func mockOIDC() error {
 	if err != nil {
 		return err
 	}
-
-	log.Info().Msgf("mock OIDC server listening on %s", listener.Addr().String())
-	log.Info().Msgf("issuer: %s", mock.Issuer())
-
+	log.Info().Msgf("Mock OIDC server listening on %s", listener.Addr().String())
+	log.Info().Msgf("Issuer: %s", mock.Issuer())
 	c := make(chan struct{})
 	<-c

@@ -146,13 +132,12 @@ func getMockOIDC(clientID string, clientSecret string, users []mockoidc.MockUser
 		ErrorQueue:                    &mockoidc.ErrorQueue{},
 	}

-	_ = mock.AddMiddleware(func(h http.Handler) http.Handler {
+	mock.AddMiddleware(func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			log.Info().Msgf("request: %+v", r)
+			log.Info().Msgf("Request: %+v", r)
 			h.ServeHTTP(w, r)
-
 			if r.Response != nil {
-				log.Info().Msgf("response: %+v", r.Response)
+				log.Info().Msgf("Response: %+v", r.Response)
 			}
 		})
 	})
@@ -1,271 +0,0 @@
-package cli
-
-import (
-	"context"
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"net"
-	"net/http"
-	"strings"
-
-	clientv2 "github.com/juanfont/headscale/gen/client/v2"
-	"github.com/juanfont/headscale/hscontrol/types"
-	"github.com/spf13/cobra"
-)
-
-// oauthTailnet is the single Headscale tailnet the v2 API addresses as "-".
-const oauthTailnet = "-"
-
-func init() {
-	rootCmd.AddCommand(oauthClientsCmd)
-
-	oauthClientsCmd.AddCommand(listOAuthClientsCmd)
-
-	createOAuthClientCmd.Flags().
-		StringArrayP("scope", "s", nil, "Scope the client's tokens are granted (repeatable): auth_keys, oauth_keys, devices:core, devices:routes, policy_file, feature_settings (each with a :read variant), or all/all:read")
-	createOAuthClientCmd.Flags().
-		StringArrayP("tag", "t", nil, "Tag the client's tokens may assign to devices (repeatable), e.g. tag:k8s-operator")
-	createOAuthClientCmd.Flags().StringP("description", "d", "", "Human-readable description")
-	oauthClientsCmd.AddCommand(createOAuthClientCmd)
-
-	deleteOAuthClientCmd.Flags().StringP("id", "i", "", "OAuth client id")
-	oauthClientsCmd.AddCommand(deleteOAuthClientCmd)
-}
-
-var oauthClientsCmd = &cobra.Command{
-	Use:     "oauth-clients",
-	Short:   "Manage OAuth clients",
-	Aliases: []string{"oauth-client", "oauthclients", "oauthclient", "oauth"},
-}
-
-var createOAuthClientCmd = &cobra.Command{
-	Use:   "create",
-	Short: "Create an OAuth client",
-	Long: `Create a general-purpose OAuth client. It authenticates with the OAuth 2.0
-client-credentials grant and mints short-lived, scope-limited access tokens.
-The wire format is compatible with Tailscale tooling (the Terraform provider,
-the Kubernetes operator, tscli, ...), so those can drive Headscale unchanged.
-
-The client secret is shown ONCE on creation and cannot be retrieved again; if
-you lose it, delete the client and create a new one.
-
-Scopes gate what the client's tokens may do; tags are the device tags those
-tokens may assign and are required when the scopes include devices:core or
-auth_keys.`,
-	Aliases: []string{"c", cmdNew},
-	RunE: func(cmd *cobra.Command, _ []string) error {
-		scopes, _ := cmd.Flags().GetStringArray("scope")
-		tags, _ := cmd.Flags().GetStringArray("tag")
-		description, _ := cmd.Flags().GetString("description")
-
-		if len(scopes) == 0 {
-			return fmt.Errorf("at least one --scope is required: %w", errMissingParameter)
-		}
-
-		ctx, client, cancel, err := newV2Client()
-		if err != nil {
-			return err
-		}
-		defer cancel()
-
-		keyType := "client"
-
-		resp, err := client.CreateKeyWithResponse(ctx, oauthTailnet, clientv2.CreateKeyRequest{
-			KeyType:     &keyType,
-			Scopes:      &scopes,
-			Tags:        &tags,
-			Description: &description,
-		})
-		if err != nil {
-			return fmt.Errorf("creating oauth client: %w", err)
-		}
-
-		err = v2Error(resp.HTTPResponse.StatusCode, resp.Body)
-		if err != nil {
-			return err
-		}
-
-		key := resp.JSON200
-
-		return printOutput(cmd, key,
-			fmt.Sprintf("OAuth client %s created.\nSecret (shown once, store it now): %s", key.Id, ptrStr(key.Key)))
-	},
-}
-
-var listOAuthClientsCmd = &cobra.Command{
-	Use:     cmdList,
-	Short:   "List OAuth clients",
-	Aliases: []string{"ls", cmdShow},
-	RunE: func(cmd *cobra.Command, _ []string) error {
-		ctx, client, cancel, err := newV2Client()
-		if err != nil {
-			return err
-		}
-		defer cancel()
-
-		resp, err := client.ListKeysWithResponse(ctx, oauthTailnet, nil)
-		if err != nil {
-			return fmt.Errorf("listing oauth clients: %w", err)
-		}
-
-		err = v2Error(resp.HTTPResponse.StatusCode, resp.Body)
-		if err != nil {
-			return err
-		}
-
-		// The keys endpoint is multiplexed; keep only OAuth clients.
-		clients := make([]clientv2.Key, 0, len(resp.JSON200.Keys))
-
-		for _, k := range resp.JSON200.Keys {
-			if k.KeyType == "client" {
-				clients = append(clients, k)
-			}
-		}
-
-		return printListOutput(cmd, clients, func() error {
-			rows := make([][]string, 0, len(clients))
-			for _, c := range clients {
-				rows = append(rows, []string{
-					c.Id,
-					strings.Join(ptrStrs(c.Scopes), ","),
-					strings.Join(ptrStrs(c.Tags), ","),
-					ptrStr(c.Description),
-					c.Created.Format(HeadscaleDateTimeFormat),
-				})
-			}
-
-			return renderTable([]string{"ID", "Scopes", "Tags", "Description", colCreated}, rows)
-		})
-	},
-}
-
-var deleteOAuthClientCmd = &cobra.Command{
-	Use:     cmdDelete,
-	Short:   "Delete an OAuth client",
-	Aliases: []string{"remove", aliasDel},
-	RunE: func(cmd *cobra.Command, _ []string) error {
-		id, _ := cmd.Flags().GetString("id")
-		if id == "" {
-			return fmt.Errorf("--id is required: %w", errMissingParameter)
-		}
-
-		ctx, client, cancel, err := newV2Client()
-		if err != nil {
-			return err
-		}
-		defer cancel()
-
-		resp, err := client.DeleteKeyWithResponse(ctx, oauthTailnet, id)
-		if err != nil {
-			return fmt.Errorf("deleting oauth client: %w", err)
-		}
-
-		err = v2Error(resp.HTTPResponse.StatusCode, resp.Body)
-		if err != nil {
-			return err
-		}
-
-		return printOutput(cmd, map[string]string{"id": id}, "OAuth client "+id+" deleted")
-	},
-}
-
-// newV2Client builds a generated v2 API client, selecting the transport the same
-// way the v1 client does: over the local unix socket it is unauthenticated
-// (local trust); a remote address injects the configured API key as a bearer
-// token.
-func newV2Client() (context.Context, *clientv2.ClientWithResponses, context.CancelFunc, error) {
-	cfg, err := types.LoadCLIConfig()
-	if err != nil {
-		return nil, nil, nil, fmt.Errorf("loading configuration: %w", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), cfg.CLI.Timeout)
-
-	if cfg.CLI.Address == "" {
-		socketPath := cfg.UnixSocket
-
-		httpClient := &http.Client{Transport: &http.Transport{
-			DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
-				return dialHeadscaleSocket(ctx, socketPath)
-			},
-		}}
-
-		client, err := clientv2.NewClientWithResponses("http://local", clientv2.WithHTTPClient(httpClient))
-		if err != nil {
-			cancel()
-
-			return nil, nil, nil, err
-		}
-
-		return ctx, client, cancel, nil
-	}
-
-	if cfg.CLI.APIKey == "" {
-		cancel()
-
-		return nil, nil, nil, errAPIKeyNotSet
-	}
-
-	transport := &http.Transport{}
-	if cfg.CLI.Insecure {
-		//nolint:gosec // intentionally honouring the insecure flag
-		transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-	}
-
-	apiKey := cfg.CLI.APIKey
-
-	client, err := clientv2.NewClientWithResponses(
-		clientBaseURL(cfg.CLI.Address),
-		clientv2.WithHTTPClient(&http.Client{Transport: transport}),
-		clientv2.WithRequestEditorFn(func(_ context.Context, req *http.Request) error {
-			req.Header.Set("Authorization", "Bearer "+apiKey)
-
-			return nil
-		}),
-	)
-	if err != nil {
-		cancel()
-
-		return nil, nil, nil, err
-	}
-
-	return ctx, client, cancel, nil
-}
-
-// v2Error turns a non-2xx v2 response into an error. The v2 API emits the
-// Tailscale error body ({"message":...}) rather than RFC 7807, so it reads the
-// "message" field instead of the generated problem+json types.
-func v2Error(status int, body []byte) error {
-	if status >= http.StatusOK && status < http.StatusMultipleChoices {
-		return nil
-	}
-
-	var e struct {
-		Message string `json:"message"`
-	}
-
-	if json.Unmarshal(body, &e) == nil && e.Message != "" {
-		//nolint:err113 // surfacing the server's message
-		return fmt.Errorf("api error (%d): %s", status, e.Message)
-	}
-
-	//nolint:err113 // surfacing the server's body
-	return fmt.Errorf("api error (%d): %s", status, strings.TrimSpace(string(body)))
-}
-
-func ptrStr(s *string) string {
-	if s == nil {
-		return ""
-	}
-
-	return *s
-}
-
-func ptrStrs(s *[]string) []string {
-	if s == nil {
-		return nil
-	}
-
-	return *s
-}
@@ -1,67 +1,24 @@
 package cli

 import (
-	"context"
-	"errors"
 	"fmt"
-	"net/http"
+	"io"
 	"os"

-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/juanfont/headscale/hscontrol/db"
-	"github.com/juanfont/headscale/hscontrol/policy"
-	"github.com/juanfont/headscale/hscontrol/types"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-	"tailscale.com/types/views"
 )

-const (
-	bypassFlag = "bypass-server-and-access-database-directly" //nolint:gosec // not a credential
-)
-
-var errAborted = errors.New("command aborted by user")
-
-// bypassDatabase opens the database directly, bypassing the running server.
-// The caller must close the returned handle.
-func bypassDatabase() (*db.HSDatabase, error) {
-	cfg, err := types.LoadServerConfig()
-	if err != nil {
-		return nil, fmt.Errorf("loading config: %w", err)
-	}
-
-	d, err := db.NewHeadscaleDatabase(cfg)
-	if err != nil {
-		return nil, fmt.Errorf("opening database: %w", err)
-	}
-
-	return d, nil
-}
-
-// openBypassDB confirms the destructive bypass action and opens the database
-// directly. The caller is responsible for closing the returned handle.
-func openBypassDB(cmd *cobra.Command) (*db.HSDatabase, error) {
-	if !confirmAction(cmd, "DO NOT run this command if an instance of headscale is running, are you sure headscale is not running?") {
-		return nil, errAborted
-	}
-
-	return bypassDatabase()
-}
-
 func init() {
 	rootCmd.AddCommand(policyCmd)
-
-	getPolicy.Flags().BoolP(bypassFlag, "", false, "Uses the headscale config to directly access the database, bypassing the API and does not require the server to be running")
 	policyCmd.AddCommand(getPolicy)

 	setPolicy.Flags().StringP("file", "f", "", "Path to a policy file in HuJSON format")
-	setPolicy.Flags().BoolP(bypassFlag, "", false, "Uses the headscale config to directly access the database, bypassing the API and does not require the server to be running")
-	mustMarkRequired(setPolicy, "file")
+	if err := setPolicy.MarkFlagRequired("file"); err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	policyCmd.AddCommand(setPolicy)
-
-	checkPolicy.Flags().StringP("file", "f", "", "Path to a policy file in HuJSON format")
-	checkPolicy.Flags().BoolP(bypassFlag, "", false, "Open the database directly (no running server required) to resolve user references and to evaluate the policy's tests and sshTests blocks. Required when those checks are needed.")
-	mustMarkRequired(checkPolicy, "file")
-	policyCmd.AddCommand(checkPolicy)
 }

 var policyCmd = &cobra.Command{
@@ -72,48 +29,24 @@ var policyCmd = &cobra.Command{
 var getPolicy = &cobra.Command{
 	Use:     "get",
 	Short:   "Print the current ACL Policy",
-	Aliases: []string{cmdShow, "view", "fetch"},
-	RunE: func(cmd *cobra.Command, args []string) error {
-		var policyData string
+	Aliases: []string{"show", "view", "fetch"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-		if bypass, _ := cmd.Flags().GetBool(bypassFlag); bypass {
-			d, err := openBypassDB(cmd)
-			if err != nil {
-				return err
-			}
-			defer d.Close()
+		request := &v1.GetPolicyRequest{}

-			pol, err := d.GetPolicy()
-			if err != nil {
-				return fmt.Errorf("loading policy from database: %w", err)
-			}
-
-			policyData = pol.Data
-		} else {
-			err := withClient(func(ctx context.Context, client *clientv1.ClientWithResponses) error {
-				resp, err := client.GetPolicyWithResponse(ctx)
-				if err != nil {
-					return fmt.Errorf("loading ACL policy: %w", err)
-				}
-
-				if resp.StatusCode() != http.StatusOK {
-					return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-				}
-
-				policyData = resp.JSON200.Policy
-
-				return nil
-			})
-			if err != nil {
-				return err
-			}
+		response, err := client.GetPolicy(ctx, request)
+		if err != nil {
+			ErrorOutput(err, fmt.Sprintf("Failed loading ACL Policy: %s", err), output)
 		}

-		// This does not pass output format as we don't support yaml, json or
-		// json-line output for this command. It is HuJSON already.
-		fmt.Println(policyData)
-
-		return nil
+		// TODO(pallabpain): Maybe print this better?
+		// This does not pass output as we dont support yaml, json or json-line
+		// output for this command. It is HuJSON already.
+		SuccessOutput("", response.GetPolicy(), "")
 	},
 }

@@ -124,137 +57,31 @@ var setPolicy = &cobra.Command{
 	Updates the existing ACL Policy with the provided policy. The policy must be a valid HuJSON object.
 	This command only works when the acl.policy_mode is set to "db", and the policy will be stored in the database.`,
 	Aliases: []string{"put", "update"},
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
 		policyPath, _ := cmd.Flags().GetString("file")

-		policyBytes, err := os.ReadFile(policyPath)
+		f, err := os.Open(policyPath)
 		if err != nil {
-			return fmt.Errorf("reading policy file: %w", err)
+			ErrorOutput(err, fmt.Sprintf("Error opening the policy file: %s", err), output)
+		}
+		defer f.Close()
+
+		policyBytes, err := io.ReadAll(f)
+		if err != nil {
+			ErrorOutput(err, fmt.Sprintf("Error reading the policy file: %s", err), output)
 		}

-		if bypass, _ := cmd.Flags().GetBool(bypassFlag); bypass {
-			d, err := openBypassDB(cmd)
-			if err != nil {
-				return err
-			}
-			defer d.Close()
+		request := &v1.SetPolicyRequest{Policy: string(policyBytes)}

-			users, err := d.ListUsers(nil)
-			if err != nil {
-				return fmt.Errorf("loading users for policy validation: %w", err)
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-			_, err = policy.NewPolicyManager(policyBytes, users, views.Slice[types.NodeView]{})
-			if err != nil {
-				return fmt.Errorf("parsing policy file: %w", err)
-			}
-
-			_, err = d.SetPolicy(string(policyBytes))
-			if err != nil {
-				return fmt.Errorf("setting ACL policy: %w", err)
-			}
-		} else {
-			policyStr := string(policyBytes)
-
-			err := withClient(func(ctx context.Context, client *clientv1.ClientWithResponses) error {
-				resp, err := client.SetPolicyWithResponse(ctx, clientv1.SetPolicyJSONRequestBody{
-					Policy: &policyStr,
-				})
-				if err != nil {
-					return fmt.Errorf("setting ACL policy: %w", err)
-				}
-
-				if resp.StatusCode() != http.StatusOK {
-					return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-				}
-
-				return nil
-			})
-			if err != nil {
-				return err
-			}
+		if _, err := client.SetPolicy(ctx, request); err != nil {
+			ErrorOutput(err, fmt.Sprintf("Failed to set ACL Policy: %s", err), output)
 		}

-		fmt.Println("Policy updated.")
-
-		return nil
-	},
-}
-
-var checkPolicy = &cobra.Command{
-	Use:   "check",
-	Short: "Check the Policy file for errors",
-	Long: `
-	Check validates the policy against the server's live users and nodes,
-	running any "tests" or "sshTests" block. By default the command calls a
-	running headscale over its API; pass --` + bypassFlag + ` to
-	open the database directly when headscale is not running.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		policyPath, _ := cmd.Flags().GetString("file")
-
-		policyBytes, err := os.ReadFile(policyPath)
-		if err != nil {
-			return fmt.Errorf("reading policy file: %w", err)
-		}
-
-		if bypass, _ := cmd.Flags().GetBool(bypassFlag); bypass {
-			d, err := openBypassDB(cmd)
-			if err != nil {
-				return err
-			}
-			defer d.Close()
-
-			users, err := d.ListUsers(nil)
-			if err != nil {
-				return fmt.Errorf("loading users: %w", err)
-			}
-
-			nodes, err := d.ListNodes()
-			if err != nil {
-				return fmt.Errorf("loading nodes: %w", err)
-			}
-
-			// [policy.NewPolicyManager] validates structure and user references
-			// but intentionally skips test evaluation (boot path).
-			// [policy.PolicyManager.SetPolicy] is the user-write boundary and is what runs the
-			// tests and sshTests blocks.
-			pm, err := policy.NewPolicyManager(policyBytes, users, nodes.ViewSlice())
-			if err != nil {
-				return fmt.Errorf("parsing policy file: %w", err)
-			}
-
-			_, err = pm.SetPolicy(policyBytes)
-			if err != nil {
-				return err
-			}
-
-			fmt.Println("Policy is valid")
-
-			return nil
-		}
-
-		policyStr := string(policyBytes)
-
-		err = withClient(func(ctx context.Context, client *clientv1.ClientWithResponses) error {
-			resp, err := client.CheckPolicyWithResponse(ctx, clientv1.CheckPolicyJSONRequestBody{
-				Policy: &policyStr,
-			})
-			if err != nil {
-				return err
-			}
-
-			if resp.StatusCode() != http.StatusOK {
-				return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-			}
-
-			return nil
-		})
-		if err != nil {
-			return err
-		}
-
-		fmt.Println("Policy is valid")
-
-		return nil
+		SuccessOutput(nil, "Policy updated.", "")
 	},
 }
@@ -1,15 +1,17 @@
 package cli

 import (
-	"context"
 	"fmt"
-	"net/http"
 	"strconv"
 	"strings"
+	"time"

-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/juanfont/headscale/hscontrol/util"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/prometheus/common/model"
+	"github.com/pterm/pterm"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )

 const (
@@ -18,10 +20,20 @@ const (

 func init() {
 	rootCmd.AddCommand(preauthkeysCmd)
+	preauthkeysCmd.PersistentFlags().StringP("user", "u", "", "User")
+
+	preauthkeysCmd.PersistentFlags().StringP("namespace", "n", "", "User")
+	pakNamespaceFlag := preauthkeysCmd.PersistentFlags().Lookup("namespace")
+	pakNamespaceFlag.Deprecated = deprecateNamespaceMessage
+	pakNamespaceFlag.Hidden = true
+
+	err := preauthkeysCmd.MarkPersistentFlagRequired("user")
+	if err != nil {
+		log.Fatal().Err(err).Msg("")
+	}
 	preauthkeysCmd.AddCommand(listPreAuthKeys)
 	preauthkeysCmd.AddCommand(createPreAuthKeyCmd)
 	preauthkeysCmd.AddCommand(expirePreAuthKeyCmd)
-	preauthkeysCmd.AddCommand(deletePreAuthKeyCmd)
 	createPreAuthKeyCmd.PersistentFlags().
 		Bool("reusable", false, "Make the preauthkey reusable")
 	createPreAuthKeyCmd.PersistentFlags().
@@ -30,9 +42,6 @@ func init() {
 		StringP("expiration", "e", DefaultPreAuthKeyExpiry, "Human-readable expiration of the key (e.g. 30m, 24h)")
 	createPreAuthKeyCmd.Flags().
 		StringSlice("tags", []string{}, "Tags to automatically assign to node")
-	createPreAuthKeyCmd.PersistentFlags().Uint64P("user", "u", 0, "User identifier (ID)")
-	expirePreAuthKeyCmd.PersistentFlags().Uint64P("id", "i", 0, "Authkey ID")
-	deletePreAuthKeyCmd.PersistentFlags().Uint64P("id", "i", 0, "Authkey ID")
 }

 var preauthkeysCmd = &cobra.Command{
@@ -42,161 +51,184 @@ var preauthkeysCmd = &cobra.Command{
 }

 var listPreAuthKeys = &cobra.Command{
-	Use:     cmdList,
-	Short:   "List all preauthkeys",
-	Aliases: []string{"ls", cmdShow},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		resp, err := client.ListPreAuthKeysWithResponse(ctx)
+	Use:     "list",
+	Short:   "List the preauthkeys for this user",
+	Aliases: []string{"ls", "show"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		user, err := cmd.Flags().GetString("user")
 		if err != nil {
-			return fmt.Errorf("listing preauthkeys: %w", err)
+			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		request := &v1.ListPreAuthKeysRequest{
+			User: user,
 		}

-		preAuthKeys := resp.JSON200.PreAuthKeys
+		response, err := client.ListPreAuthKeys(ctx, request)
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting the list of keys: %s", err),
+				output,
+			)

-		return printListOutput(cmd, preAuthKeys, func() error {
-			rows := make([][]string, 0, len(preAuthKeys))
-			for _, key := range preAuthKeys {
-				expiration := ColourTime(key.Expiration)
+			return
+		}

-				owner := "-"
+		if output != "" {
+			SuccessOutput(response.GetPreAuthKeys(), "", output)
+		}

-				switch {
-				case len(key.AclTags) > 0:
-					owner = strings.Join(key.AclTags, "\n")
-				case key.User.Id != "":
-					owner = key.User.Name
-				}
-
-				rows = append(rows, []string{
-					key.Id,
-					key.Key,
-					strconv.FormatBool(key.Reusable),
-					strconv.FormatBool(key.Ephemeral),
-					strconv.FormatBool(key.Used),
-					expiration,
-					key.CreatedAt.Format(HeadscaleDateTimeFormat),
-					owner,
-				})
-			}
-
-			return renderTable([]string{
+		tableData := pterm.TableData{
+			{
 				"ID",
-				"Key/Prefix",
+				"Key",
 				"Reusable",
 				"Ephemeral",
 				"Used",
-				colExpiration,
-				colCreated,
-				"Owner",
-			}, rows)
-		})
-	}),
+				"Expiration",
+				"Created",
+				"Tags",
+			},
+		}
+		for _, key := range response.GetPreAuthKeys() {
+			expiration := "-"
+			if key.GetExpiration() != nil {
+				expiration = ColourTime(key.GetExpiration().AsTime())
+			}
+
+			aclTags := ""
+
+			for _, tag := range key.GetAclTags() {
+				aclTags += "," + tag
+			}
+
+			aclTags = strings.TrimLeft(aclTags, ",")
+
+			tableData = append(tableData, []string{
+				key.GetId(),
+				key.GetKey(),
+				strconv.FormatBool(key.GetReusable()),
+				strconv.FormatBool(key.GetEphemeral()),
+				strconv.FormatBool(key.GetUsed()),
+				expiration,
+				key.GetCreatedAt().AsTime().Format("2006-01-02 15:04:05"),
+				aclTags,
+			})
+
+		}
+		err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to render pterm table: %s", err),
+				output,
+			)
+		}
+	},
 }

 var createPreAuthKeyCmd = &cobra.Command{
 	Use:     "create",
-	Short:   "Creates a new preauthkey",
-	Aliases: []string{"c", cmdNew},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		user, _ := cmd.Flags().GetUint64("user")
+	Short:   "Creates a new preauthkey in the specified user",
+	Aliases: []string{"c", "new"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		user, err := cmd.Flags().GetString("user")
+		if err != nil {
+			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
+		}
+
 		reusable, _ := cmd.Flags().GetBool("reusable")
 		ephemeral, _ := cmd.Flags().GetBool("ephemeral")
 		tags, _ := cmd.Flags().GetStringSlice("tags")

-		expiryTime, err := expirationFromFlag(cmd)
+		request := &v1.CreatePreAuthKeyRequest{
+			User:      user,
+			Reusable:  reusable,
+			Ephemeral: ephemeral,
+			AclTags:   tags,
+		}
+
+		durationStr, _ := cmd.Flags().GetString("expiration")
+
+		duration, err := model.ParseDuration(durationStr)
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Could not parse duration: %s\n", err),
+				output,
+			)
 		}

-		userStr := strconv.FormatUint(user, util.Base10)
+		expiration := time.Now().UTC().Add(time.Duration(duration))

-		request := clientv1.CreatePreAuthKeyJSONRequestBody{
-			User:       &userStr,
-			Reusable:   &reusable,
-			Ephemeral:  &ephemeral,
-			AclTags:    &tags,
-			Expiration: &expiryTime,
-		}
+		log.Trace().
+			Dur("expiration", time.Duration(duration)).
+			Msg("expiration has been set")

-		resp, err := client.CreatePreAuthKeyWithResponse(ctx, request)
+		request.Expiration = timestamppb.New(expiration)
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		response, err := client.CreatePreAuthKey(ctx, request)
 		if err != nil {
-			return fmt.Errorf("creating preauthkey: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create Pre Auth Key: %s\n", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		preAuthKey := resp.JSON200.PreAuthKey
-
-		return printOutput(cmd, preAuthKey, preAuthKey.Key)
-	}),
-}
-
-// preAuthKeyID reads the required --id flag for preauthkey commands.
-func preAuthKeyID(cmd *cobra.Command) (uint64, error) {
-	id, _ := cmd.Flags().GetUint64("id")
-	if id == 0 {
-		return 0, fmt.Errorf("missing --id parameter: %w", errMissingParameter)
-	}
-
-	return id, nil
+		SuccessOutput(response.GetPreAuthKey(), response.GetPreAuthKey().GetKey(), output)
+	},
 }

 var expirePreAuthKeyCmd = &cobra.Command{
-	Use:     cmdExpire,
+	Use:     "expire KEY",
 	Short:   "Expire a preauthkey",
-	Aliases: []string{"revoke", aliasExp, "e"},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		id, err := preAuthKeyID(cmd)
+	Aliases: []string{"revoke", "exp", "e"},
+	Args: func(cmd *cobra.Command, args []string) error {
+		if len(args) < 1 {
+			return errMissingParameter
+		}
+
+		return nil
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+		user, err := cmd.Flags().GetString("user")
 		if err != nil {
-			return err
+			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
 		}

-		idStr := strconv.FormatUint(id, util.Base10)
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-		resp, err := client.ExpirePreAuthKeyWithResponse(ctx, clientv1.ExpirePreAuthKeyJSONRequestBody{
-			Id: &idStr,
-		})
+		request := &v1.ExpirePreAuthKeyRequest{
+			User: user,
+			Key:  args[0],
+		}
+
+		response, err := client.ExpirePreAuthKey(ctx, request)
 		if err != nil {
-			return fmt.Errorf("expiring preauthkey: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot expire Pre Auth Key: %s\n", err),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Key expired")
-	}),
-}
-
-var deletePreAuthKeyCmd = &cobra.Command{
-	Use:     cmdDelete,
-	Short:   "Delete a preauthkey",
-	Aliases: []string{aliasDel, "rm", "d"},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		id, err := preAuthKeyID(cmd)
-		if err != nil {
-			return err
-		}
-
-		idStr := strconv.FormatUint(id, util.Base10)
-
-		resp, err := client.DeletePreAuthKeyWithResponse(ctx, &clientv1.DeletePreAuthKeyParams{
-			Id: &idStr,
-		})
-		if err != nil {
-			return fmt.Errorf("deleting preauthkey: %w", err)
-		}
-
-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200, "Key deleted")
-	}),
+		SuccessOutput(response, "Key expired", output)
+	},
 }
@@ -7,7 +7,7 @@ import (
 )

 func ColourTime(date time.Time) string {
-	dateStr := date.Format(HeadscaleDateTimeFormat)
+	dateStr := date.Format("2006-01-02 15:04:05")

 	if date.After(time.Now()) {
 		dateStr = pterm.LightGreen(dateStr)
@@ -1,10 +1,9 @@
 package cli

 import (
+	"fmt"
 	"os"
 	"runtime"
-	"slices"
-	"strings"

 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/rs/zerolog"
@@ -14,6 +13,10 @@ import (
 	"github.com/tcnksm/go-latest"
 )

+const (
+	deprecateNamespaceMessage = "use --user"
+)
+
 var cfgFile string = ""

 func init() {
@@ -29,34 +32,25 @@ func init() {
 		StringP("output", "o", "", "Output format. Empty for human-readable, 'json', 'json-line' or 'yaml'")
 	rootCmd.PersistentFlags().
 		Bool("force", false, "Disable prompts and forces the execution")
-
-	// Re-enable usage output only for flag-parsing errors; runtime errors
-	// from [cobra.Command.RunE] should never dump usage text.
-	rootCmd.SetFlagErrorFunc(func(cmd *cobra.Command, err error) error {
-		cmd.SilenceUsage = false
-
-		return err
-	})
 }

 func initConfig() {
 	if cfgFile == "" {
 		cfgFile = os.Getenv("HEADSCALE_CONFIG")
 	}
-
 	if cfgFile != "" {
 		err := types.LoadConfig(cfgFile, true)
 		if err != nil {
-			log.Fatal().Caller().Err(err).Msgf("error loading config file %s", cfgFile)
+			log.Fatal().Caller().Err(err).Msgf("Error loading config file %s", cfgFile)
 		}
 	} else {
 		err := types.LoadConfig("", false)
 		if err != nil {
-			log.Fatal().Caller().Err(err).Msgf("error loading config")
+			log.Fatal().Caller().Err(err).Msgf("Error loading config")
 		}
 	}

-	machineOutput := hasMachineOutputFlag()
+	machineOutput := HasMachineOutputFlag()

 	// If the user has requested a "node" readable format,
 	// then disable login so the output remains valid.
@@ -64,63 +58,32 @@ func initConfig() {
 		zerolog.SetGlobalLevel(zerolog.Disabled)
 	}

-	logFormat := viper.GetString("log.format")
-	if logFormat == types.JSONLogFormat {
-		log.Logger = log.Output(os.Stdout)
-	}
+	// logFormat := viper.GetString("log.format")
+	// if logFormat == types.JSONLogFormat {
+	// 	log.Logger = log.Output(os.Stdout)
+	// }

 	disableUpdateCheck := viper.GetBool("disable_check_updates")
 	if !disableUpdateCheck && !machineOutput {
-		versionInfo := types.GetVersionInfo()
 		if (runtime.GOOS == "linux" || runtime.GOOS == "darwin") &&
-			!versionInfo.Dirty {
+			Version != "dev" {
 			githubTag := &latest.GithubTag{
-				Owner:         "juanfont",
-				Repository:    "headscale",
-				TagFilterFunc: filterPreReleasesIfStable(func() string { return versionInfo.Version }),
+				Owner:      "juanfont",
+				Repository: "headscale",
 			}
-
-			res, err := latest.Check(githubTag, versionInfo.Version)
+			res, err := latest.Check(githubTag, Version)
 			if err == nil && res.Outdated {
 				//nolint
 				log.Warn().Msgf(
 					"An updated version of Headscale has been found (%s vs. your current %s). Check it out https://github.com/juanfont/headscale/releases\n",
 					res.Current,
-					versionInfo.Version,
+					Version,
 				)
 			}
 		}
 	}
 }

-var prereleases = []string{"alpha", "beta", "rc", "dev"}
-
-func isPreReleaseVersion(version string) bool {
-	return slices.ContainsFunc(prereleases, func(unstable string) bool {
-		return strings.Contains(version, unstable)
-	})
-}
-
-// filterPreReleasesIfStable returns a function that filters out
-// pre-release tags if the current version is stable.
-// If the current version is a pre-release, it does not filter anything.
-// versionFunc is a function that returns the current version string, it is
-// a func for testability.
-func filterPreReleasesIfStable(versionFunc func() string) func(string) bool {
-	return func(tag string) bool {
-		version := versionFunc()
-
-		// If we are on a pre-release version, then we do not filter anything
-		// as we want to recommend the user the latest pre-release.
-		if isPreReleaseVersion(version) {
-			return false
-		}
-
-		// If we are on a stable release, filter out pre-releases.
-		return isPreReleaseVersion(tag)
-	}
-}
-
 var rootCmd = &cobra.Command{
 	Use:   "headscale",
 	Short: "headscale - a Tailscale control server",
@@ -128,15 +91,11 @@ var rootCmd = &cobra.Command{
 headscale is an open source implementation of the Tailscale control server

 https://github.com/juanfont/headscale`,
-	SilenceErrors: true,
-	SilenceUsage:  true,
 }

 func Execute() {
-	cmd, err := rootCmd.ExecuteC()
-	if err != nil {
-		outputFormat, _ := cmd.Flags().GetString("output")
-		printError(err, outputFormat)
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }
@@ -1,308 +0,0 @@
-package cli
-
-import (
-	"testing"
-)
-
-const (
-	v23       = "0.23.0"
-	v23Alpha1 = "0.23.0-alpha.1"
-	v23Beta1  = "0.23.0-beta.1"
-	v23RC1    = "0.23.0-rc.1"
-	v23Dev    = "0.23.0-dev"
-	v231      = "0.23.1"
-
-	v24Alpha1Tag = "v0.24.0-alpha.1"
-	v24RCTag     = "v0.24.0-rc.1"
-	v24Tag       = "v0.24.0"
-)
-
-func TestFilterPreReleasesIfStable(t *testing.T) {
-	tests := []struct {
-		name           string
-		currentVersion string
-		tag            string
-		expectedFilter bool
-		description    string
-	}{
-		{
-			name:           "stable version filters alpha tag",
-			currentVersion: v23,
-			tag:            v24Alpha1Tag,
-			expectedFilter: true,
-			description:    "When on stable release, alpha tags should be filtered",
-		},
-		{
-			name:           "stable version filters beta tag",
-			currentVersion: v23,
-			tag:            "v0.24.0-beta.2",
-			expectedFilter: true,
-			description:    "When on stable release, beta tags should be filtered",
-		},
-		{
-			name:           "stable version filters rc tag",
-			currentVersion: v23,
-			tag:            v24RCTag,
-			expectedFilter: true,
-			description:    "When on stable release, rc tags should be filtered",
-		},
-		{
-			name:           "stable version allows stable tag",
-			currentVersion: v23,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "When on stable release, stable tags should not be filtered",
-		},
-		{
-			name:           "alpha version allows alpha tag",
-			currentVersion: v23Alpha1,
-			tag:            "v0.24.0-alpha.2",
-			expectedFilter: false,
-			description:    "When on alpha release, alpha tags should not be filtered",
-		},
-		{
-			name:           "alpha version allows beta tag",
-			currentVersion: v23Alpha1,
-			tag:            "v0.24.0-beta.1",
-			expectedFilter: false,
-			description:    "When on alpha release, beta tags should not be filtered",
-		},
-		{
-			name:           "alpha version allows rc tag",
-			currentVersion: v23Alpha1,
-			tag:            v24RCTag,
-			expectedFilter: false,
-			description:    "When on alpha release, rc tags should not be filtered",
-		},
-		{
-			name:           "alpha version allows stable tag",
-			currentVersion: v23Alpha1,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "When on alpha release, stable tags should not be filtered",
-		},
-		{
-			name:           "beta version allows alpha tag",
-			currentVersion: v23Beta1,
-			tag:            v24Alpha1Tag,
-			expectedFilter: false,
-			description:    "When on beta release, alpha tags should not be filtered",
-		},
-		{
-			name:           "beta version allows beta tag",
-			currentVersion: "0.23.0-beta.2",
-			tag:            "v0.24.0-beta.3",
-			expectedFilter: false,
-			description:    "When on beta release, beta tags should not be filtered",
-		},
-		{
-			name:           "beta version allows rc tag",
-			currentVersion: v23Beta1,
-			tag:            v24RCTag,
-			expectedFilter: false,
-			description:    "When on beta release, rc tags should not be filtered",
-		},
-		{
-			name:           "beta version allows stable tag",
-			currentVersion: v23Beta1,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "When on beta release, stable tags should not be filtered",
-		},
-		{
-			name:           "rc version allows alpha tag",
-			currentVersion: v23RC1,
-			tag:            v24Alpha1Tag,
-			expectedFilter: false,
-			description:    "When on rc release, alpha tags should not be filtered",
-		},
-		{
-			name:           "rc version allows beta tag",
-			currentVersion: v23RC1,
-			tag:            "v0.24.0-beta.1",
-			expectedFilter: false,
-			description:    "When on rc release, beta tags should not be filtered",
-		},
-		{
-			name:           "rc version allows rc tag",
-			currentVersion: "0.23.0-rc.2",
-			tag:            "v0.24.0-rc.3",
-			expectedFilter: false,
-			description:    "When on rc release, rc tags should not be filtered",
-		},
-		{
-			name:           "rc version allows stable tag",
-			currentVersion: v23RC1,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "When on rc release, stable tags should not be filtered",
-		},
-		{
-			name:           "stable version with patch filters alpha",
-			currentVersion: v231,
-			tag:            v24Alpha1Tag,
-			expectedFilter: true,
-			description:    "Stable version with patch number should filter alpha tags",
-		},
-		{
-			name:           "stable version with patch allows stable",
-			currentVersion: v231,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "Stable version with patch number should allow stable tags",
-		},
-		{
-			name:           "tag with alpha substring in version number",
-			currentVersion: v23,
-			tag:            "v1.0.0-alpha.1",
-			expectedFilter: true,
-			description:    "Tags with alpha in version string should be filtered on stable",
-		},
-		{
-			name:           "tag with beta substring in version number",
-			currentVersion: v23,
-			tag:            "v1.0.0-beta.1",
-			expectedFilter: true,
-			description:    "Tags with beta in version string should be filtered on stable",
-		},
-		{
-			name:           "tag with rc substring in version number",
-			currentVersion: v23,
-			tag:            "v1.0.0-rc.1",
-			expectedFilter: true,
-			description:    "Tags with rc in version string should be filtered on stable",
-		},
-		{
-			name:           "empty tag on stable version",
-			currentVersion: v23,
-			tag:            "",
-			expectedFilter: false,
-			description:    "Empty tags should not be filtered",
-		},
-		{
-			name:           "dev version allows all tags",
-			currentVersion: v23Dev,
-			tag:            v24Alpha1Tag,
-			expectedFilter: false,
-			description:    "Dev versions should not filter any tags (pre-release allows all)",
-		},
-		{
-			name:           "stable version filters dev tag",
-			currentVersion: v23,
-			tag:            "v0.24.0-dev",
-			expectedFilter: true,
-			description:    "When on stable release, dev tags should be filtered",
-		},
-		{
-			name:           "dev version allows dev tag",
-			currentVersion: v23Dev,
-			tag:            "v0.24.0-dev.1",
-			expectedFilter: false,
-			description:    "When on dev release, dev tags should not be filtered",
-		},
-		{
-			name:           "dev version allows stable tag",
-			currentVersion: v23Dev,
-			tag:            v24Tag,
-			expectedFilter: false,
-			description:    "When on dev release, stable tags should not be filtered",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := filterPreReleasesIfStable(func() string { return tt.currentVersion })(tt.tag)
-			if result != tt.expectedFilter {
-				t.Errorf(
-					"%s: got %v, want %v\nDescription: %s\nCurrent version: %s, Tag: %s",
-					tt.name,
-					result,
-					tt.expectedFilter,
-					tt.description,
-					tt.currentVersion,
-					tt.tag,
-				)
-			}
-		})
-	}
-}
-
-func TestIsPreReleaseVersion(t *testing.T) {
-	tests := []struct {
-		name        string
-		version     string
-		expected    bool
-		description string
-	}{
-		{
-			name:        "stable version",
-			version:     v23,
-			expected:    false,
-			description: "Stable version should not be pre-release",
-		},
-		{
-			name:        "alpha version",
-			version:     v23Alpha1,
-			expected:    true,
-			description: "Alpha version should be pre-release",
-		},
-		{
-			name:        "beta version",
-			version:     v23Beta1,
-			expected:    true,
-			description: "Beta version should be pre-release",
-		},
-		{
-			name:        "rc version",
-			version:     v23RC1,
-			expected:    true,
-			description: "RC version should be pre-release",
-		},
-		{
-			name:        "version with alpha substring",
-			version:     "0.23.0-alphabetical",
-			expected:    true,
-			description: "Version containing 'alpha' should be pre-release",
-		},
-		{
-			name:        "version with beta substring",
-			version:     "0.23.0-betamax",
-			expected:    true,
-			description: "Version containing 'beta' should be pre-release",
-		},
-		{
-			name:        "dev version",
-			version:     v23Dev,
-			expected:    true,
-			description: "Dev version should be pre-release",
-		},
-		{
-			name:        "empty version",
-			version:     "",
-			expected:    false,
-			description: "Empty version should not be pre-release",
-		},
-		{
-			name:        "version with patch number",
-			version:     v231,
-			expected:    false,
-			description: "Stable version with patch should not be pre-release",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isPreReleaseVersion(tt.version)
-			if result != tt.expected {
-				t.Errorf(
-					"%s: got %v, want %v\nDescription: %s\nVersion: %s",
-					tt.name,
-					result,
-					tt.expected,
-					tt.description,
-					tt.version,
-				)
-			}
-		})
-	}
-}
@@ -0,0 +1,266 @@
+package cli
+
+import (
+	"fmt"
+	"log"
+	"net/netip"
+	"strconv"
+
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc/status"
+	"tailscale.com/net/tsaddr"
+)
+
+const (
+	Base10 = 10
+)
+
+func init() {
+	rootCmd.AddCommand(routesCmd)
+	listRoutesCmd.Flags().Uint64P("identifier", "i", 0, "Node identifier (ID)")
+	routesCmd.AddCommand(listRoutesCmd)
+
+	enableRouteCmd.Flags().Uint64P("route", "r", 0, "Route identifier (ID)")
+	err := enableRouteCmd.MarkFlagRequired("route")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	routesCmd.AddCommand(enableRouteCmd)
+
+	disableRouteCmd.Flags().Uint64P("route", "r", 0, "Route identifier (ID)")
+	err = disableRouteCmd.MarkFlagRequired("route")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	routesCmd.AddCommand(disableRouteCmd)
+
+	deleteRouteCmd.Flags().Uint64P("route", "r", 0, "Route identifier (ID)")
+	err = deleteRouteCmd.MarkFlagRequired("route")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	routesCmd.AddCommand(deleteRouteCmd)
+}
+
+var routesCmd = &cobra.Command{
+	Use:     "routes",
+	Short:   "Manage the routes of Headscale",
+	Aliases: []string{"r", "route"},
+}
+
+var listRoutesCmd = &cobra.Command{
+	Use:     "list",
+	Short:   "List all routes",
+	Aliases: []string{"ls", "show"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		machineID, err := cmd.Flags().GetUint64("identifier")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting machine id from flag: %s", err),
+				output,
+			)
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		var routes []*v1.Route
+
+		if machineID == 0 {
+			response, err := client.GetRoutes(ctx, &v1.GetRoutesRequest{})
+			if err != nil {
+				ErrorOutput(
+					err,
+					fmt.Sprintf("Cannot get nodes: %s", status.Convert(err).Message()),
+					output,
+				)
+			}
+
+			if output != "" {
+				SuccessOutput(response.GetRoutes(), "", output)
+			}
+
+			routes = response.GetRoutes()
+		} else {
+			response, err := client.GetNodeRoutes(ctx, &v1.GetNodeRoutesRequest{
+				NodeId: machineID,
+			})
+			if err != nil {
+				ErrorOutput(
+					err,
+					fmt.Sprintf("Cannot get routes for node %d: %s", machineID, status.Convert(err).Message()),
+					output,
+				)
+			}
+
+			if output != "" {
+				SuccessOutput(response.GetRoutes(), "", output)
+			}
+
+			routes = response.GetRoutes()
+		}
+
+		tableData := routesToPtables(routes)
+		if err != nil {
+			ErrorOutput(err, fmt.Sprintf("Error converting to table: %s", err), output)
+		}
+
+		err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to render pterm table: %s", err),
+				output,
+			)
+		}
+	},
+}
+
+var enableRouteCmd = &cobra.Command{
+	Use:   "enable",
+	Short: "Set a route as enabled",
+	Long:  `This command will make as enabled a given route.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		routeID, err := cmd.Flags().GetUint64("route")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting machine id from flag: %s", err),
+				output,
+			)
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		response, err := client.EnableRoute(ctx, &v1.EnableRouteRequest{
+			RouteId: routeID,
+		})
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot enable route %d: %s", routeID, status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		if output != "" {
+			SuccessOutput(response, "", output)
+		}
+	},
+}
+
+var disableRouteCmd = &cobra.Command{
+	Use:   "disable",
+	Short: "Set as disabled a given route",
+	Long:  `This command will make as disabled a given route.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		routeID, err := cmd.Flags().GetUint64("route")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting machine id from flag: %s", err),
+				output,
+			)
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		response, err := client.DisableRoute(ctx, &v1.DisableRouteRequest{
+			RouteId: routeID,
+		})
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot disable route %d: %s", routeID, status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		if output != "" {
+			SuccessOutput(response, "", output)
+		}
+	},
+}
+
+var deleteRouteCmd = &cobra.Command{
+	Use:   "delete",
+	Short: "Delete a given route",
+	Long:  `This command will delete a given route.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		routeID, err := cmd.Flags().GetUint64("route")
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting machine id from flag: %s", err),
+				output,
+			)
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		response, err := client.DeleteRoute(ctx, &v1.DeleteRouteRequest{
+			RouteId: routeID,
+		})
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot delete route %d: %s", routeID, status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		if output != "" {
+			SuccessOutput(response, "", output)
+		}
+	},
+}
+
+// routesToPtables converts the list of routes to a nice table.
+func routesToPtables(routes []*v1.Route) pterm.TableData {
+	tableData := pterm.TableData{{"ID", "Node", "Prefix", "Advertised", "Enabled", "Primary"}}
+
+	for _, route := range routes {
+		var isPrimaryStr string
+		prefix, err := netip.ParsePrefix(route.GetPrefix())
+		if err != nil {
+			log.Printf("Error parsing prefix %s: %s", route.GetPrefix(), err)
+
+			continue
+		}
+		if tsaddr.IsExitRoute(prefix) {
+			isPrimaryStr = "-"
+		} else {
+			isPrimaryStr = strconv.FormatBool(route.GetIsPrimary())
+		}
+
+		tableData = append(tableData,
+			[]string{
+				strconv.FormatUint(route.GetId(), Base10),
+				route.GetNode().GetGivenName(),
+				route.GetPrefix(),
+				strconv.FormatBool(route.GetAdvertised()),
+				strconv.FormatBool(route.GetEnabled()),
+				isPrimaryStr,
+			})
+	}
+
+	return tableData
+}
@@ -2,11 +2,10 @@ package cli

 import (
 	"errors"
-	"fmt"
 	"net/http"

+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-	"github.com/tailscale/squibble"
 )

 func init() {
@@ -16,22 +15,18 @@ func init() {
 var serveCmd = &cobra.Command{
 	Use:   "serve",
 	Short: "Launches the headscale server",
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Args: func(cmd *cobra.Command, args []string) error {
+		return nil
+	},
+	Run: func(cmd *cobra.Command, args []string) {
 		app, err := newHeadscaleServerWithConfig()
 		if err != nil {
-			if squibbleErr, ok := errors.AsType[squibble.ValidationError](err); ok {
-				fmt.Printf("SQLite schema failed to validate:\n")
-				fmt.Println(squibbleErr.Diff)
-			}
-
-			return fmt.Errorf("initializing: %w", err)
+			log.Fatal().Caller().Err(err).Msg("Error initializing")
 		}

 		err = app.Serve()
 		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			return fmt.Errorf("headscale ran into an error and had to shut down: %w", err)
+			log.Fatal().Caller().Err(err).Msg("Headscale ran into an error and had to shut down.")
 		}
-
-		return nil
 	},
 }
@@ -1,23 +0,0 @@
-package cli
-
-// Shared CLI vocabulary used across multiple command definitions in this
-// package. Centralising the strings prevents goconst drift and ensures a
-// typo in a subcommand name fails to compile rather than silently
-// breaking the binding.
-const (
-	// Subcommand verbs (cobra Use field).
-	cmdList   = "list"
-	cmdShow   = "show"
-	cmdNew    = "new"
-	cmdDelete = "delete"
-	cmdExpire = "expire"
-
-	// Subcommand aliases.
-	aliasDel = "del"
-	aliasExp = "exp"
-
-	// Output table column headers and printOutput map keys.
-	colResult     = "Result"
-	colCreated    = "Created"
-	colExpiration = "Expiration"
-)
@@ -1,24 +1,16 @@
 package cli

 import (
-	"context"
 	"errors"
 	"fmt"
-	"net/http"
 	"net/url"
-	"strconv"

-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
-	"github.com/juanfont/headscale/hscontrol/util"
-	"github.com/juanfont/headscale/hscontrol/util/zlog/zf"
+	survey "github.com/AlecAivazis/survey/v2"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/pterm/pterm"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-)
-
-// CLI user errors.
-var (
-	errFlagRequired       = errors.New("--name or --identifier flag is required")
-	errMultipleUsersMatch = errors.New("multiple users match query, specify an ID")
+	"google.golang.org/grpc/status"
 )

 func usernameAndIDFlag(cmd *cobra.Command) {
@@ -27,58 +19,23 @@ func usernameAndIDFlag(cmd *cobra.Command) {
 }

 // usernameAndIDFromFlag returns the username and ID from the flags of the command.
-func usernameAndIDFromFlag(cmd *cobra.Command) (uint64, string, error) {
+// If both are empty, it will exit the program with an error.
+func usernameAndIDFromFlag(cmd *cobra.Command) (uint64, string) {
 	username, _ := cmd.Flags().GetString("name")
-
 	identifier, _ := cmd.Flags().GetInt64("identifier")
 	if username == "" && identifier < 0 {
-		return 0, "", errFlagRequired
+		err := errors.New("--name or --identifier flag is required")
+		ErrorOutput(
+			err,
+			fmt.Sprintf(
+				"Cannot rename user: %s",
+				status.Convert(err).Message(),
+			),
+			"",
+		)
 	}

-	// Normalise unset/negative identifiers to 0 so the uint64
-	// conversion does not produce a bogus large value.
-	identifier = max(identifier, 0)
-
-	return uint64(identifier), username, nil //nolint:gosec // identifier is clamped to >= 0 above
-}
-
-// resolveSingleUser resolves exactly one user from the --name/--id flags,
-// returning the raw flag id and the matched user.
-func resolveSingleUser(
-	ctx context.Context,
-	client *clientv1.ClientWithResponses,
-	cmd *cobra.Command,
-) (uint64, *clientv1.User, error) {
-	id, username, err := usernameAndIDFromFlag(cmd)
-	if err != nil {
-		return 0, nil, err
-	}
-
-	params := &clientv1.ListUsersParams{}
-	if username != "" {
-		params.Name = &username
-	}
-
-	if id != 0 {
-		idStr := strconv.FormatUint(id, util.Base10)
-		params.Id = &idStr
-	}
-
-	resp, err := client.ListUsersWithResponse(ctx, params)
-	if err != nil {
-		return 0, nil, fmt.Errorf("listing users: %w", err)
-	}
-
-	if resp.StatusCode() != http.StatusOK {
-		return 0, nil, apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-	}
-
-	users := resp.JSON200.Users
-	if len(users) != 1 {
-		return 0, nil, errMultipleUsersMatch
-	}
-
-	return id, &users[0], nil
+	return uint64(identifier), username
 }

 func init() {
@@ -95,19 +52,21 @@ func init() {
 	userCmd.AddCommand(renameUserCmd)
 	usernameAndIDFlag(renameUserCmd)
 	renameUserCmd.Flags().StringP("new-name", "r", "", "New username")
-	mustMarkRequired(renameUserCmd, "new-name")
+	renameNodeCmd.MarkFlagRequired("new-name")
 }

+var errMissingParameter = errors.New("missing parameters")
+
 var userCmd = &cobra.Command{
 	Use:     "users",
 	Short:   "Manage the users of Headscale",
-	Aliases: []string{"user"},
+	Aliases: []string{"user", "namespace", "namespaces", "ns"},
 }

 var createUserCmd = &cobra.Command{
 	Use:     "create NAME",
 	Short:   "Creates a new user",
-	Aliases: []string{"c", cmdNew},
+	Aliases: []string{"c", "new"},
 	Args: func(cmd *cobra.Command, args []string) error {
 		if len(args) < 1 {
 			return errMissingParameter
@@ -115,80 +74,143 @@ var createUserCmd = &cobra.Command{

 		return nil
 	},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
 		userName := args[0]

-		log.Trace().Interface(zf.Client, client).Msg("obtained API client")
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()

-		request := clientv1.CreateUserJSONRequestBody{Name: &userName}
+		log.Trace().Interface("client", client).Msg("Obtained gRPC client")
+
+		request := &v1.CreateUserRequest{Name: userName}

 		if displayName, _ := cmd.Flags().GetString("display-name"); displayName != "" {
-			request.DisplayName = &displayName
+			request.DisplayName = displayName
 		}

 		if email, _ := cmd.Flags().GetString("email"); email != "" {
-			request.Email = &email
+			request.Email = email
 		}

 		if pictureURL, _ := cmd.Flags().GetString("picture-url"); pictureURL != "" {
-			if _, err := url.Parse(pictureURL); err != nil { //nolint:noinlineerr
-				return fmt.Errorf("invalid picture URL: %w", err)
+			if _, err := url.Parse(pictureURL); err != nil {
+				ErrorOutput(
+					err,
+					fmt.Sprintf(
+						"Invalid Picture URL: %s",
+						err,
+					),
+					output,
+				)
 			}
-
-			request.PictureUrl = &pictureURL
+			request.PictureUrl = pictureURL
 		}

-		log.Trace().Interface(zf.Request, request).Msg("sending CreateUser request")
-
-		resp, err := client.CreateUserWithResponse(ctx, request)
+		log.Trace().Interface("request", request).Msg("Sending CreateUser request")
+		response, err := client.CreateUser(ctx, request)
 		if err != nil {
-			return fmt.Errorf("creating user: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf(
+					"Cannot create user: %s",
+					status.Convert(err).Message(),
+				),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200.User, "User created")
-	}),
+		SuccessOutput(response.GetUser(), "User created", output)
+	},
 }

 var destroyUserCmd = &cobra.Command{
 	Use:     "destroy --identifier ID or --name NAME",
 	Short:   "Destroys a user",
-	Aliases: []string{cmdDelete},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		_, user, err := resolveSingleUser(ctx, client, cmd)
+	Aliases: []string{"delete"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		id, username := usernameAndIDFromFlag(cmd)
+		request := &v1.ListUsersRequest{
+			Name: username,
+			Id:   id,
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		users, err := client.ListUsers(ctx, request)
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error: %s", status.Convert(err).Message()),
+				output,
+			)
 		}

-		if !confirmAction(cmd, fmt.Sprintf(
-			"Do you want to remove the user %q (%s) and any associated preauthkeys?",
-			user.Name, user.Id,
-		)) {
-			return printOutput(cmd, map[string]string{colResult: "User not destroyed"}, "User not destroyed")
+		if len(users.GetUsers()) != 1 {
+			err := fmt.Errorf("Unable to determine user to delete, query returned multiple users, use ID")
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error: %s", status.Convert(err).Message()),
+				output,
+			)
 		}

-		resp, err := client.DeleteUserWithResponse(ctx, user.Id)
-		if err != nil {
-			return fmt.Errorf("destroying user: %w", err)
+		user := users.GetUsers()[0]
+
+		confirm := false
+		force, _ := cmd.Flags().GetBool("force")
+		if !force {
+			prompt := &survey.Confirm{
+				Message: fmt.Sprintf(
+					"Do you want to remove the user %q (%d) and any associated preauthkeys?",
+					user.GetName(), user.GetId(),
+				),
+			}
+			err := survey.AskOne(prompt, &confirm)
+			if err != nil {
+				return
+			}
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
+		if confirm || force {
+			request := &v1.DeleteUserRequest{Id: user.GetId()}

-		return printOutput(cmd, resp.JSON200, "User destroyed")
-	}),
+			response, err := client.DeleteUser(ctx, request)
+			if err != nil {
+				ErrorOutput(
+					err,
+					fmt.Sprintf(
+						"Cannot destroy user: %s",
+						status.Convert(err).Message(),
+					),
+					output,
+				)
+			}
+			SuccessOutput(response, "User destroyed", output)
+		} else {
+			SuccessOutput(map[string]string{"Result": "User not destroyed"}, "User not destroyed", output)
+		}
+	},
 }

 var listUsersCmd = &cobra.Command{
-	Use:     cmdList,
+	Use:     "list",
 	Short:   "List all the users",
-	Aliases: []string{"ls", cmdShow},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		params := &clientv1.ListUsersParams{}
+	Aliases: []string{"ls", "show"},
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		request := &v1.ListUsersRequest{}

 		id, _ := cmd.Flags().GetInt64("identifier")
 		username, _ := cmd.Flags().GetString("name")
@@ -197,66 +219,107 @@ var listUsersCmd = &cobra.Command{
 		// filter by one param at most
 		switch {
 		case id > 0:
-			idStr := strconv.FormatInt(id, util.Base10)
-			params.Id = &idStr
+			request.Id = uint64(id)
+			break
 		case username != "":
-			params.Name = &username
+			request.Name = username
+			break
 		case email != "":
-			params.Email = &email
+			request.Email = email
+			break
 		}

-		resp, err := client.ListUsersWithResponse(ctx, params)
+		response, err := client.ListUsers(ctx, request)
 		if err != nil {
-			return fmt.Errorf("listing users: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot get users: %s", status.Convert(err).Message()),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
+		if output != "" {
+			SuccessOutput(response.GetUsers(), "", output)
 		}

-		users := resp.JSON200.Users
-
-		return printListOutput(cmd, users, func() error {
-			rows := make([][]string, 0, len(users))
-			for _, user := range users {
-				rows = append(
-					rows,
-					[]string{
-						user.Id,
-						user.DisplayName,
-						user.Name,
-						user.Email,
-						user.CreatedAt.Format(HeadscaleDateTimeFormat),
-					},
-				)
-			}
-
-			return renderTable([]string{"ID", "Name", "Username", "Email", colCreated}, rows)
-		})
-	}),
+		tableData := pterm.TableData{{"ID", "Name", "Username", "Email", "Created"}}
+		for _, user := range response.GetUsers() {
+			tableData = append(
+				tableData,
+				[]string{
+					fmt.Sprintf("%d", user.GetId()),
+					user.GetDisplayName(),
+					user.GetName(),
+					user.GetEmail(),
+					user.GetCreatedAt().AsTime().Format("2006-01-02 15:04:05"),
+				},
+			)
+		}
+		err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to render pterm table: %s", err),
+				output,
+			)
+		}
+	},
 }

 var renameUserCmd = &cobra.Command{
 	Use:     "rename",
 	Short:   "Renames a user",
 	Aliases: []string{"mv"},
-	RunE: clientRunE(func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error {
-		id, _, err := resolveSingleUser(ctx, client, cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		id, username := usernameAndIDFromFlag(cmd)
+		listReq := &v1.ListUsersRequest{
+			Name: username,
+			Id:   id,
+		}
+
+		users, err := client.ListUsers(ctx, listReq)
 		if err != nil {
-			return err
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error: %s", status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		if len(users.GetUsers()) != 1 {
+			err := fmt.Errorf("Unable to determine user to delete, query returned multiple users, use ID")
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error: %s", status.Convert(err).Message()),
+				output,
+			)
 		}

 		newName, _ := cmd.Flags().GetString("new-name")

-		resp, err := client.RenameUserWithResponse(ctx, strconv.FormatUint(id, util.Base10), newName)
+		renameReq := &v1.RenameUserRequest{
+			OldId:   id,
+			NewName: newName,
+		}
+
+		response, err := client.RenameUser(ctx, renameReq)
 		if err != nil {
-			return fmt.Errorf("renaming user: %w", err)
+			ErrorOutput(
+				err,
+				fmt.Sprintf(
+					"Cannot rename user: %s",
+					status.Convert(err).Message(),
+				),
+				output,
+			)
 		}

-		if resp.StatusCode() != http.StatusOK {
-			return apiError(resp.StatusCode(), resp.ApplicationproblemJSONDefault)
-		}
-
-		return printOutput(cmd, resp.JSON200.User, "User renamed")
-	}),
+		SuccessOutput(response.GetUser(), "User renamed", output)
+	},
 }
@@ -4,146 +4,50 @@ import (
 	"context"
 	"crypto/tls"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"net"
-	"net/http"
 	"os"
-	"slices"
-	"strings"
-	"time"

-	"github.com/cenkalti/backoff/v5"
-	clientv1 "github.com/juanfont/headscale/gen/client/v1"
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
 	"github.com/juanfont/headscale/hscontrol"
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
-	"github.com/juanfont/headscale/hscontrol/util/zlog/zf"
-	"github.com/prometheus/common/model"
-	"github.com/pterm/pterm"
 	"github.com/rs/zerolog/log"
-	"github.com/spf13/cobra"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
 	"gopkg.in/yaml.v3"
 )

 const (
 	HeadscaleDateTimeFormat = "2006-01-02 15:04:05"
 	SocketWritePermissions  = 0o666
-
-	outputFormatJSON     = "json"
-	outputFormatJSONLine = "json-line"
-	outputFormatYAML     = "yaml"
 )

-var (
-	errAPIKeyNotSet     = errors.New("HEADSCALE_CLI_API_KEY environment variable needs to be set")
-	errMissingParameter = errors.New("missing parameters")
-	errResponseStatus   = errors.New("unexpected response status")
-)
-
-// apiError turns a non-2xx response into an error, surfacing the server's
-// RFC7807 problem detail. detail holds the operation context and errors[] the
-// wrapped cause (e.g. "name is too long"); both are joined so the server's
-// message text is not lost.
-func apiError(statusCode int, problem *clientv1.ErrorModel) error {
-	if problem == nil {
-		return fmt.Errorf("%w: %d %s", errResponseStatus, statusCode, http.StatusText(statusCode))
-	}
-
-	parts := make([]string, 0, 2)
-
-	if problem.Detail != nil && *problem.Detail != "" {
-		parts = append(parts, *problem.Detail)
-	}
-
-	if problem.Errors != nil {
-		for _, e := range *problem.Errors {
-			if e.Message != nil && *e.Message != "" {
-				parts = append(parts, *e.Message)
-			}
-		}
-	}
-
-	if len(parts) == 0 && problem.Title != nil && *problem.Title != "" {
-		parts = append(parts, *problem.Title)
-	}
-
-	if len(parts) == 0 {
-		return fmt.Errorf("%w: %d %s", errResponseStatus, statusCode, http.StatusText(statusCode))
-	}
-
-	return fmt.Errorf("%w: %s", errResponseStatus, strings.Join(parts, ": "))
-}
-
-// mustMarkRequired marks the named flags as required, panicking on an unknown
-// flag. Only called from init(), where a failure is a programming error.
-func mustMarkRequired(cmd *cobra.Command, names ...string) {
-	for _, n := range names {
-		err := cmd.MarkFlagRequired(n)
-		if err != nil {
-			panic(fmt.Sprintf("marking flag %q required on %q: %v", n, cmd.Name(), err))
-		}
-	}
-}
-
 func newHeadscaleServerWithConfig() (*hscontrol.Headscale, error) {
 	cfg, err := types.LoadServerConfig()
 	if err != nil {
 		return nil, fmt.Errorf(
-			"loading configuration: %w",
+			"failed to load configuration while creating headscale instance: %w",
 			err,
 		)
 	}

 	app, err := hscontrol.NewHeadscale(cfg)
 	if err != nil {
-		return nil, fmt.Errorf("creating new headscale: %w", err)
+		return nil, err
 	}

 	return app, nil
 }

-// clientRunE wraps a [cobra.Command.RunE] func, injecting a ready API client
-// and a context whose timeout/cancel the wrapper owns.
-func clientRunE(
-	fn func(ctx context.Context, client *clientv1.ClientWithResponses, cmd *cobra.Command, args []string) error,
-) func(*cobra.Command, []string) error {
-	return func(cmd *cobra.Command, args []string) error {
-		ctx, client, cancel, err := newHeadscaleCLIWithConfig()
-		if err != nil {
-			return fmt.Errorf("connecting to headscale: %w", err)
-		}
-		defer cancel()
-
-		return fn(ctx, client, cmd, args)
-	}
-}
-
-// withClient runs fn with an API client. For commands that branch on a flag
-// before talking to the server, where clientRunE's whole-RunE wrapping does
-// not fit.
-func withClient(
-	fn func(ctx context.Context, client *clientv1.ClientWithResponses) error,
-) error {
-	ctx, client, cancel, err := newHeadscaleCLIWithConfig()
-	if err != nil {
-		return fmt.Errorf("connecting to headscale: %w", err)
-	}
-	defer cancel()
-
-	return fn(ctx, client)
-}
-
-// newHeadscaleCLIWithConfig builds an HTTP client for the Headscale v1 API.
-//
-// When cfg.CLI.Address is unset the CLI is assumed to run on the server host
-// and talks to the unix socket over HTTP without authentication (local trust).
-// Otherwise it talks to the remote TCP address over HTTPS and injects the
-// configured API key as a bearer token.
-func newHeadscaleCLIWithConfig() (context.Context, *clientv1.ClientWithResponses, context.CancelFunc, error) {
+func newHeadscaleCLIWithConfig() (context.Context, v1.HeadscaleServiceClient, *grpc.ClientConn, context.CancelFunc) {
 	cfg, err := types.LoadCLIConfig()
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("loading configuration: %w", err)
+		log.Fatal().
+			Err(err).
+			Caller().
+			Msgf("Failed to load configuration")
+		os.Exit(-1) // we get here if logging is suppressed (i.e., json output)
 	}

 	log.Debug().
@@ -152,249 +56,147 @@ func newHeadscaleCLIWithConfig() (context.Context, *clientv1.ClientWithResponses

 	ctx, cancel := context.WithTimeout(context.Background(), cfg.CLI.Timeout)

+	grpcOptions := []grpc.DialOption{
+		grpc.WithBlock(),
+	}
+
 	address := cfg.CLI.Address

-	// If the address is not set, we assume that we are on the server hosting [hscontrol].
+	// If the address is not set, we assume that we are on the server hosting hscontrol.
 	if address == "" {
 		log.Debug().
 			Str("socket", cfg.UnixSocket).
 			Msgf("HEADSCALE_CLI_ADDRESS environment is not set, connecting to unix socket.")

-		client, err := newSocketClient(cfg.UnixSocket)
+		address = cfg.UnixSocket
+
+		// Try to give the user better feedback if we cannot write to the headscale
+		// socket.
+		socket, err := os.OpenFile(cfg.UnixSocket, os.O_WRONLY, SocketWritePermissions) // nolint
 		if err != nil {
-			cancel()
-
-			return nil, nil, nil, err
+			if os.IsPermission(err) {
+				log.Fatal().
+					Err(err).
+					Str("socket", cfg.UnixSocket).
+					Msgf("Unable to read/write to headscale socket, do you have the correct permissions?")
+			}
 		}
+		socket.Close()

-		log.Trace().Caller().Str(zf.Address, cfg.UnixSocket).Msg("connecting via unix socket")
+		grpcOptions = append(
+			grpcOptions,
+			grpc.WithTransportCredentials(insecure.NewCredentials()),
+			grpc.WithContextDialer(util.GrpcSocketDialer),
+		)
+	} else {
+		// If we are not connecting to a local server, require an API key for authentication
+		apiKey := cfg.CLI.APIKey
+		if apiKey == "" {
+			log.Fatal().Caller().Msgf("HEADSCALE_CLI_API_KEY environment variable needs to be set.")
+		}
+		grpcOptions = append(grpcOptions,
+			grpc.WithPerRPCCredentials(tokenAuth{
+				token: apiKey,
+			}),
+		)

-		return ctx, client, cancel, nil
-	}
+		if cfg.CLI.Insecure {
+			tlsConfig := &tls.Config{
+				// turn of gosec as we are intentionally setting
+				// insecure.
+				//nolint:gosec
+				InsecureSkipVerify: true,
+			}

-	// Remote connections require an API key for authentication.
-	apiKey := cfg.CLI.APIKey
-	if apiKey == "" {
-		cancel()
-
-		return nil, nil, nil, errAPIKeyNotSet
-	}
-
-	client, err := newRemoteClient(address, apiKey, cfg.CLI.Insecure)
-	if err != nil {
-		cancel()
-
-		return nil, nil, nil, err
-	}
-
-	log.Trace().Caller().Str(zf.Address, address).Msg("connecting via HTTPS")
-
-	return ctx, client, cancel, nil
-}
-
-// newSocketClient builds an API client that dials the local unix socket. The
-// base-URL host is irrelevant; the custom dialer routes every request to the
-// socket.
-func newSocketClient(socketPath string) (*clientv1.ClientWithResponses, error) {
-	// Probe for a clearer permission error up front. [os.OpenFile] on a unix
-	// socket returns ENXIO on Linux (expected); only permission errors are
-	// actionable. The real connection goes through [net.Dial].
-	socket, err := os.OpenFile(socketPath, os.O_WRONLY, SocketWritePermissions) //nolint
-	if err != nil {
-		if os.IsPermission(err) {
-			return nil, fmt.Errorf(
-				"unable to read/write to headscale socket %q, do you have the correct permissions? %w",
-				socketPath,
-				err,
+			grpcOptions = append(grpcOptions,
+				grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
+			)
+		} else {
+			grpcOptions = append(grpcOptions,
+				grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
 			)
 		}
-	} else {
-		socket.Close()
 	}

-	httpClient := &http.Client{
-		Transport: &http.Transport{
-			DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
-				return dialHeadscaleSocket(ctx, socketPath)
-			},
-		},
+	log.Trace().Caller().Str("address", address).Msg("Connecting via gRPC")
+	conn, err := grpc.DialContext(ctx, address, grpcOptions...)
+	if err != nil {
+		log.Fatal().Caller().Err(err).Msgf("Could not connect: %v", err)
+		os.Exit(-1) // we get here if logging is suppressed (i.e., json output)
 	}

-	return clientv1.NewClientWithResponses(
-		"http://local",
-		clientv1.WithHTTPClient(httpClient),
-	)
+	client := v1.NewHeadscaleServiceClient(conn)
+
+	return ctx, client, conn, cancel
 }

-// dialHeadscaleSocket connects to the unix socket, retrying until it appears or
-// ctx (the CLI timeout) expires. The socket is created late in startup (after
-// noise key, database, migrations), so a command run right after the server
-// starts can race its creation; retrying preserves the old gRPC client's
-// blocking-dial tolerance rather than failing on a not-yet-present socket.
-func dialHeadscaleSocket(ctx context.Context, socketPath string) (net.Conn, error) {
-	b := backoff.NewExponentialBackOff()
-	b.InitialInterval = 50 * time.Millisecond
-	b.MaxInterval = 1 * time.Second
-
-	return backoff.Retry(ctx, func() (net.Conn, error) {
-		return util.SocketDialer(ctx, socketPath)
-	}, backoff.WithBackOff(b))
-}
-
-// clientBaseURL turns a configured CLI address into a client base URL. A bare
-// host[:port] (the historical form) defaults to https; an address that already
-// carries a scheme is used as-is, so an explicit http:// or https:// is honoured
-// rather than doubled into https://https://...
-func clientBaseURL(address string) string {
-	if strings.Contains(address, "://") {
-		return address
-	}
-
-	return "https://" + address
-}
-
-// newRemoteClient builds an API client for a remote Headscale over HTTPS,
-// honouring insecure (skip TLS verification) and injecting the API key as a
-// bearer token on every request.
-func newRemoteClient(address, apiKey string, insecure bool) (*clientv1.ClientWithResponses, error) {
-	transport := &http.Transport{}
-	if insecure {
-		transport.TLSClientConfig = &tls.Config{
-			// turn off gosec as we are intentionally setting insecure.
-			//nolint:gosec
-			InsecureSkipVerify: true,
-		}
-	}
-
-	httpClient := &http.Client{Transport: transport}
-
-	return clientv1.NewClientWithResponses(
-		clientBaseURL(address),
-		clientv1.WithHTTPClient(httpClient),
-		clientv1.WithRequestEditorFn(func(_ context.Context, req *http.Request) error {
-			req.Header.Set("Authorization", "Bearer "+apiKey)
-
-			return nil
-		}),
-	)
-}
-
-// formatOutput serialises result into the requested format. For the
-// default (empty) format the human-readable override string is returned.
-func formatOutput(result any, override string, outputFormat string) (string, error) {
+func output(result interface{}, override string, outputFormat string) string {
+	var jsonBytes []byte
+	var err error
 	switch outputFormat {
-	case outputFormatJSON:
-		b, err := json.MarshalIndent(result, "", "\t")
+	case "json":
+		jsonBytes, err = json.MarshalIndent(result, "", "\t")
 		if err != nil {
-			return "", fmt.Errorf("marshalling JSON output: %w", err)
+			log.Fatal().Err(err).Msg("failed to unmarshal output")
 		}
-
-		return string(b), nil
-	case outputFormatJSONLine:
-		b, err := json.Marshal(result)
+	case "json-line":
+		jsonBytes, err = json.Marshal(result)
 		if err != nil {
-			return "", fmt.Errorf("marshalling JSON-line output: %w", err)
+			log.Fatal().Err(err).Msg("failed to unmarshal output")
 		}
-
-		return string(b), nil
-	case outputFormatYAML:
-		b, err := yaml.Marshal(result)
+	case "yaml":
+		jsonBytes, err = yaml.Marshal(result)
 		if err != nil {
-			return "", fmt.Errorf("marshalling YAML output: %w", err)
+			log.Fatal().Err(err).Msg("failed to unmarshal output")
 		}
-
-		return string(b), nil
 	default:
-		return override, nil
-	}
-}
-
-// printOutput formats result and writes it to stdout. It reads the --output
-// flag from cmd to decide the serialisation format.
-func printOutput(cmd *cobra.Command, result any, override string) error {
-	format, _ := cmd.Flags().GetString("output")
-
-	out, err := formatOutput(result, override, format)
-	if err != nil {
-		return err
+		// nolint
+		return override
 	}

-	fmt.Println(out)
-
-	return nil
+	return string(jsonBytes)
 }

-// expirationFromFlag parses the --expiration flag as a Prometheus-style
-// duration (e.g. "90d", "1h") and returns an absolute time.
-func expirationFromFlag(cmd *cobra.Command) (time.Time, error) {
-	durationStr, _ := cmd.Flags().GetString("expiration")
-
-	duration, err := model.ParseDuration(durationStr)
-	if err != nil {
-		return time.Time{}, fmt.Errorf("parsing duration: %w", err)
-	}
-
-	return time.Now().UTC().Add(time.Duration(duration)), nil
+// SuccessOutput prints the result to stdout and exits with status code 0.
+func SuccessOutput(result interface{}, override string, outputFormat string) {
+	fmt.Println(output(result, override, outputFormat))
+	os.Exit(0)
 }

-// confirmAction returns true when the user confirms a prompt, or when
-// --force is set.  Callers decide what to do when it returns false.
-func confirmAction(cmd *cobra.Command, prompt string) bool {
-	force, _ := cmd.Flags().GetBool("force")
-	if force {
-		return true
-	}
-
-	return util.YesNo(prompt)
-}
-
-// renderTable prints a human-readable pterm table with the given header row
-// and data rows, using the shared header styling.
-func renderTable(header []string, rows [][]string) error {
-	tableData := make(pterm.TableData, 0, 1+len(rows))
-	tableData = append(tableData, header)
-	tableData = append(tableData, rows...)
-
-	return pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
-}
-
-// printListOutput checks the --output flag: when a machine-readable format is
-// requested it serialises data as JSON/YAML; otherwise it calls the render
-// callback to produce the human-readable pterm table.
-func printListOutput(
-	cmd *cobra.Command,
-	data any,
-	renderTable func() error,
-) error {
-	format, _ := cmd.Flags().GetString("output")
-	if format != "" {
-		return printOutput(cmd, data, "")
-	}
-
-	return renderTable()
-}
-
-// printError writes err to stderr, formatting it as JSON/YAML when the
-// --output flag requests machine-readable output.  Used exclusively by
-// [Execute] so that every error surfaces in the format the caller asked for.
-func printError(err error, outputFormat string) {
+// ErrorOutput prints an error message to stderr and exits with status code 1.
+func ErrorOutput(errResult error, override string, outputFormat string) {
 	type errOutput struct {
 		Error string `json:"error"`
 	}

-	if outputFormat == "" {
-		fmt.Fprintf(os.Stderr, "Error: %s\n", err)
+	fmt.Fprintf(os.Stderr, "%s\n", output(errOutput{errResult.Error()}, override, outputFormat))
+	os.Exit(1)
+}

-		return
+func HasMachineOutputFlag() bool {
+	for _, arg := range os.Args {
+		if arg == "json" || arg == "json-line" || arg == "yaml" {
+			return true
+		}
 	}

-	// formatOutput cannot fail here: errOutput is a single string field.
-	out, _ := formatOutput(errOutput{Error: err.Error()}, "", outputFormat)
-	fmt.Fprintf(os.Stderr, "%s\n", out)
+	return false
 }

-func hasMachineOutputFlag() bool {
-	return slices.ContainsFunc(os.Args, func(arg string) bool {
-		return arg == outputFormatJSON || arg == outputFormatJSONLine || arg == outputFormatYAML
-	})
+type tokenAuth struct {
+	token string
+}
+
+// Return value is mapped to request headers.
+func (t tokenAuth) GetRequestMetadata(
+	ctx context.Context,
+	in ...string,
+) (map[string]string, error) {
+	return map[string]string{
+		"authorization": "Bearer " + t.token,
+	}, nil
+}
+
+func (tokenAuth) RequireTransportSecurity() bool {
+	return true
 }
@@ -1,72 +0,0 @@
-package cli
-
-import (
-	"context"
-	"net"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// TestDialHeadscaleSocketRetriesUntilPresent proves the CLI socket dialer
-// tolerates a not-yet-created socket (the server-still-starting race) by
-// retrying until it appears, rather than failing immediately like a bare dial.
-func TestDialHeadscaleSocketRetriesUntilPresent(t *testing.T) {
-	sock := filepath.Join(t.TempDir(), "headscale.sock")
-
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-
-	type result struct {
-		conn net.Conn
-		err  error
-	}
-
-	done := make(chan result, 1)
-
-	go func() {
-		conn, err := dialHeadscaleSocket(ctx, sock)
-		done <- result{conn, err}
-	}()
-
-	// Listen only after the dialer has begun, so its backoff must retry the
-	// absent socket and connect once it exists.
-	var lc net.ListenConfig
-
-	ln, err := lc.Listen(ctx, "unix", sock)
-	require.NoError(t, err)
-
-	defer ln.Close()
-
-	go func() {
-		if conn, _ := ln.Accept(); conn != nil {
-			conn.Close()
-		}
-	}()
-
-	res := <-done
-	require.NoError(t, res.err)
-	require.NotNil(t, res.conn)
-
-	res.conn.Close()
-}
-
-// TestDialHeadscaleSocketRespectsDeadline proves the retry is bounded by the
-// context: when the socket never appears, the dialer returns an error around the
-// deadline instead of hanging.
-func TestDialHeadscaleSocketRespectsDeadline(t *testing.T) {
-	sock := filepath.Join(t.TempDir(), "absent.sock")
-
-	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
-	defer cancel()
-
-	start := time.Now()
-
-	conn, err := dialHeadscaleSocket(ctx, sock)
-	require.Error(t, err)
-	assert.Nil(t, conn)
-	assert.Less(t, time.Since(start), 5*time.Second, "should stop near the deadline, not hang")
-}
@@ -1,35 +0,0 @@
-package cli
-
-import "testing"
-
-func TestClientBaseURL(t *testing.T) {
-	tests := []struct {
-		name    string
-		address string
-		want    string
-	}{
-		{
-			name:    "bare host defaults to https",
-			address: "headscale.example.com:50443",
-			want:    "https://headscale.example.com:50443",
-		},
-		{
-			name:    "explicit https scheme is kept",
-			address: "https://headscale.example.com",
-			want:    "https://headscale.example.com",
-		},
-		{
-			name:    "explicit http scheme is kept",
-			address: "http://localhost:8080",
-			want:    "http://localhost:8080",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := clientBaseURL(tt.address); got != tt.want {
-				t.Errorf("clientBaseURL(%q) = %q, want %q", tt.address, got, tt.want)
-			}
-		})
-	}
-}
@@ -1,22 +1,21 @@
 package cli

 import (
-	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/spf13/cobra"
 )

+var Version = "dev"
+
 func init() {
 	rootCmd.AddCommand(versionCmd)
-	versionCmd.Flags().StringP("output", "o", "", "Output format. Empty for human-readable, 'json', 'json-line' or 'yaml'")
 }

 var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Print the version.",
 	Long:  "The version of headscale.",
-	RunE: func(cmd *cobra.Command, args []string) error {
-		info := types.GetVersionInfo()
-
-		return printOutput(cmd, info, info.String())
+	Run: func(cmd *cobra.Command, args []string) {
+		output, _ := cmd.Flags().GetString("output")
+		SuccessOutput(map[string]string{"version": Version}, Version, output)
 	},
 }
@@ -11,7 +11,20 @@ import (
 )

 func main() {
-	colors := termcolor.SupportLevel(os.Stderr) != termcolor.LevelNone
+	var colors bool
+	switch l := termcolor.SupportLevel(os.Stderr); l {
+	case termcolor.Level16M:
+		colors = true
+	case termcolor.Level256:
+		colors = true
+	case termcolor.LevelBasic:
+		colors = true
+	case termcolor.LevelNone:
+		colors = false
+	default:
+		// no color, return text as is.
+		colors = false
+	}

 	// Adhere to no-color.org manifesto of allowing users to
 	// turn off color in cli/services
@@ -9,15 +9,34 @@ import (
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"gopkg.in/check.v1"
 )

-func TestConfigFileLoading(t *testing.T) {
-	tmpDir := t.TempDir()
+func Test(t *testing.T) {
+	check.TestingT(t)
+}
+
+var _ = check.Suite(&Suite{})
+
+type Suite struct{}
+
+func (s *Suite) SetUpSuite(c *check.C) {
+}
+
+func (s *Suite) TearDownSuite(c *check.C) {
+}
+
+func (*Suite) TestConfigFileLoading(c *check.C) {
+	tmpDir, err := os.MkdirTemp("", "headscale")
+	if err != nil {
+		c.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)

 	path, err := os.Getwd()
-	require.NoError(t, err)
+	if err != nil {
+		c.Fatal(err)
+	}

 	cfgFile := filepath.Join(tmpDir, "config.yaml")

@@ -26,51 +45,70 @@ func TestConfigFileLoading(t *testing.T) {
 		filepath.Clean(path+"/../../config-example.yaml"),
 		cfgFile,
 	)
-	require.NoError(t, err)
+	if err != nil {
+		c.Fatal(err)
+	}

 	// Load example config, it should load without validation errors
 	err = types.LoadConfig(cfgFile, true)
-	require.NoError(t, err)
+	c.Assert(err, check.IsNil)

 	// Test that config file was interpreted correctly
-	assert.Equal(t, "http://127.0.0.1:8080", viper.GetString("server_url"))
-	assert.Equal(t, "127.0.0.1:8080", viper.GetString("listen_addr"))
-	assert.Equal(t, "127.0.0.1:9090", viper.GetString("metrics_listen_addr"))
-	assert.Equal(t, "sqlite", viper.GetString("database.type"))
-	assert.Equal(t, "/var/lib/headscale/db.sqlite", viper.GetString("database.sqlite.path"))
-	assert.Empty(t, viper.GetString("tls_letsencrypt_hostname"))
-	assert.Equal(t, ":http", viper.GetString("tls_letsencrypt_listen"))
-	assert.Equal(t, "HTTP-01", viper.GetString("tls_letsencrypt_challenge_type"))
-	assert.Equal(t, fs.FileMode(0o770), util.GetFileMode("unix_socket_permission"))
-	assert.False(t, viper.GetBool("logtail.enabled"))
+	c.Assert(viper.GetString("server_url"), check.Equals, "http://127.0.0.1:8080")
+	c.Assert(viper.GetString("listen_addr"), check.Equals, "127.0.0.1:8080")
+	c.Assert(viper.GetString("metrics_listen_addr"), check.Equals, "127.0.0.1:9090")
+	c.Assert(viper.GetString("database.type"), check.Equals, "sqlite")
+	c.Assert(viper.GetString("database.sqlite.path"), check.Equals, "/var/lib/headscale/db.sqlite")
+	c.Assert(viper.GetString("tls_letsencrypt_hostname"), check.Equals, "")
+	c.Assert(viper.GetString("tls_letsencrypt_listen"), check.Equals, ":http")
+	c.Assert(viper.GetString("tls_letsencrypt_challenge_type"), check.Equals, "HTTP-01")
+	c.Assert(
+		util.GetFileMode("unix_socket_permission"),
+		check.Equals,
+		fs.FileMode(0o770),
+	)
+	c.Assert(viper.GetBool("logtail.enabled"), check.Equals, false)
 }

-func TestConfigLoading(t *testing.T) {
-	tmpDir := t.TempDir()
+func (*Suite) TestConfigLoading(c *check.C) {
+	tmpDir, err := os.MkdirTemp("", "headscale")
+	if err != nil {
+		c.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)

 	path, err := os.Getwd()
-	require.NoError(t, err)
+	if err != nil {
+		c.Fatal(err)
+	}

 	// Symlink the example config file
 	err = os.Symlink(
 		filepath.Clean(path+"/../../config-example.yaml"),
 		filepath.Join(tmpDir, "config.yaml"),
 	)
-	require.NoError(t, err)
+	if err != nil {
+		c.Fatal(err)
+	}

 	// Load example config, it should load without validation errors
 	err = types.LoadConfig(tmpDir, false)
-	require.NoError(t, err)
+	c.Assert(err, check.IsNil)

 	// Test that config file was interpreted correctly
-	assert.Equal(t, "http://127.0.0.1:8080", viper.GetString("server_url"))
-	assert.Equal(t, "127.0.0.1:8080", viper.GetString("listen_addr"))
-	assert.Equal(t, "127.0.0.1:9090", viper.GetString("metrics_listen_addr"))
-	assert.Equal(t, "sqlite", viper.GetString("database.type"))
-	assert.Equal(t, "/var/lib/headscale/db.sqlite", viper.GetString("database.sqlite.path"))
-	assert.Empty(t, viper.GetString("tls_letsencrypt_hostname"))
-	assert.Equal(t, ":http", viper.GetString("tls_letsencrypt_listen"))
-	assert.Equal(t, "HTTP-01", viper.GetString("tls_letsencrypt_challenge_type"))
-	assert.Equal(t, fs.FileMode(0o770), util.GetFileMode("unix_socket_permission"))
-	assert.False(t, viper.GetBool("logtail.enabled"))
+	c.Assert(viper.GetString("server_url"), check.Equals, "http://127.0.0.1:8080")
+	c.Assert(viper.GetString("listen_addr"), check.Equals, "127.0.0.1:8080")
+	c.Assert(viper.GetString("metrics_listen_addr"), check.Equals, "127.0.0.1:9090")
+	c.Assert(viper.GetString("database.type"), check.Equals, "sqlite")
+	c.Assert(viper.GetString("database.sqlite.path"), check.Equals, "/var/lib/headscale/db.sqlite")
+	c.Assert(viper.GetString("tls_letsencrypt_hostname"), check.Equals, "")
+	c.Assert(viper.GetString("tls_letsencrypt_listen"), check.Equals, ":http")
+	c.Assert(viper.GetString("tls_letsencrypt_challenge_type"), check.Equals, "HTTP-01")
+	c.Assert(
+		util.GetFileMode("unix_socket_permission"),
+		check.Equals,
+		fs.FileMode(0o770),
+	)
+	c.Assert(viper.GetBool("logtail.enabled"), check.Equals, false)
+	c.Assert(viper.GetBool("randomize_client_port"), check.Equals, false)
 }
@@ -1,262 +0,0 @@
-# hi — Headscale Integration test runner
-
-`hi` wraps Docker container orchestration around the tests in
-[`../../integration`](../../integration) and extracts debugging artefacts
-(logs, database snapshots, MapResponse protocol captures) for post-mortem
-analysis.
-
-**Read this file in full before running any `hi` command.** The test
-runner has sharp edges — wrong flags produce stale containers, lost
-artefacts, or hung CI.
-
-For test-authoring patterns (scenario setup, `EventuallyWithT`,
-`IntegrationSkip`, helper variants), read
-[`../../integration/README.md`](../../integration/README.md).
-
-## Quick Start
-
-```bash
-# Verify system requirements (Docker, Go, disk space, images)
-go run ./cmd/hi doctor
-
-# Run a single test (the default flags are tuned for development)
-go run ./cmd/hi run "TestPingAllByIP"
-
-# Run a database-heavy test against PostgreSQL
-go run ./cmd/hi run "TestExpireNode" --postgres
-
-# Pattern matching
-go run ./cmd/hi run "TestSubnet*"
-```
-
-Run `doctor` before the first `run` in any new environment. Tests
-generate ~100 MB of logs per run in `control_logs/`; `doctor` verifies
-there is enough space and that the required Docker images are available.
-
-## Commands
-
-| Command            | Purpose                                              |
-| ------------------ | ---------------------------------------------------- |
-| `run [pattern]`    | Execute the test(s) matching `pattern`               |
-| `doctor`           | Verify system requirements                           |
-| `clean networks`   | Prune unused Docker networks                         |
-| `clean images`     | Clean old test images                                |
-| `clean containers` | Kill **all** test containers (dangerous — see below) |
-| `clean cache`      | Clean Go module cache volume                         |
-| `clean all`        | Run all cleanup operations                           |
-
-## Flags
-
-Defaults are tuned for single-test development runs. Review before
-changing.
-
-| Flag                | Default        | Purpose                                                                     |
-| ------------------- | -------------- | --------------------------------------------------------------------------- |
-| `--timeout`         | `120m`         | Total test timeout. Use the built-in flag — never wrap with bash `timeout`. |
-| `--postgres`        | `false`        | Use PostgreSQL instead of SQLite                                            |
-| `--failfast`        | `true`         | Stop on first test failure                                                  |
-| `--go-version`      | auto           | Detected from `go.mod` (currently 1.26.1)                                   |
-| `--clean-before`    | `true`         | Clean stale (stopped/exited) containers before starting                     |
-| `--clean-after`     | `true`         | Clean this run's containers after completion                                |
-| `--keep-on-failure` | `false`        | Preserve containers for manual inspection on failure                        |
-| `--logs-dir`        | `control_logs` | Where to save run artefacts                                                 |
-| `--verbose`         | `false`        | Verbose output                                                              |
-| `--stats`           | `false`        | Collect container resource-usage stats                                      |
-| `--hs-memory-limit` | `0`            | Fail if any headscale container exceeds N MB (0 = disabled)                 |
-| `--ts-memory-limit` | `0`            | Fail if any tailscale container exceeds N MB                                |
-
-### Timeout guidance
-
-The default `120m` is generous for a single test. If you must tune it,
-these are realistic floors by category:
-
-| Test type                 | Minimum     | Examples                              |
-| ------------------------- | ----------- | ------------------------------------- |
-| Basic functionality / CLI | 900s (15m)  | `TestPingAllByIP`, `TestCLI*`         |
-| Route / ACL               | 1200s (20m) | `TestSubnet*`, `TestACL*`             |
-| HA / failover             | 1800s (30m) | `TestHASubnetRouter*`                 |
-| Long-running              | 2100s (35m) | `TestNodeOnlineStatus` (~12 min body) |
-| Full suite                | 45m         | `go test ./integration -timeout 45m`  |
-
-**Never** use the shell `timeout` command around `hi`. It kills the
-process mid-cleanup and leaves stale containers:
-
-```bash
-timeout 300 go run ./cmd/hi run "TestName"   # WRONG — orphaned containers
-go run ./cmd/hi run "TestName" --timeout=900s  # correct
-```
-
-## Concurrent Execution
-
-Multiple `hi run` invocations can run simultaneously on the same Docker
-daemon. Each invocation gets a unique **Run ID** (format
-`YYYYMMDD-HHMMSS-6charhash`, e.g. `20260409-104215-mdjtzx`).
-
- **Container names** include the short run ID: `ts-mdjtzx-1-74-fgdyls`
- **Docker labels**: `hi.run-id={runID}` on every container
- **Port allocation**: dynamic — kernel assigns free ports, no conflicts
- **Cleanup isolation**: each run cleans only its own containers
- **Log directories**: `control_logs/{runID}/`
-
-```bash
-# Start three tests in parallel — each gets its own run ID
-go run ./cmd/hi run "TestPingAllByIP" &
-go run ./cmd/hi run "TestACLAllowUserDst" &
-go run ./cmd/hi run "TestOIDCAuthenticationPingAll" &
-```
-
-### Safety rules for concurrent runs
-
- ✅ Your run cleans only containers labelled with its own `hi.run-id`
- ✅ `--clean-before` removes only stopped/exited containers
- ❌ **Never** run `docker rm -f $(docker ps -q --filter name=hs-)` —
-  this destroys other agents' live test sessions
- ❌ **Never** run `docker system prune -f` while any tests are running
- ❌ **Never** run `hi clean containers` / `hi clean all` while other
-  tests are running — both kill all test containers on the daemon
-
-To identify your own containers:
-
-```bash
-docker ps --filter "label=hi.run-id=20260409-104215-mdjtzx"
-```
-
-The run ID appears at the top of the `hi run` output — copy it from
-there rather than trying to reconstruct it.
-
-## Artefacts
-
-Every run saves debugging artefacts under `control_logs/{runID}/`:
-
-```
-control_logs/20260409-104215-mdjtzx/
-├── hs-<test>-<hash>.stderr.log        # headscale server errors
-├── hs-<test>-<hash>.stdout.log        # headscale server output
-├── hs-<test>-<hash>.db                # database snapshot (SQLite)
-├── hs-<test>-<hash>_metrics.txt       # Prometheus metrics dump
-├── hs-<test>-<hash>-mapresponses/     # MapResponse protocol captures
-├── ts-<client>-<hash>.stderr.log      # tailscale client errors
-├── ts-<client>-<hash>.stdout.log      # tailscale client output
-└── ts-<client>-<hash>_status.json     # client network-status dump
-```
-
-Artefacts persist after cleanup. Old runs accumulate fast — delete
-unwanted directories to reclaim disk.
-
-## Debugging workflow
-
-When a test fails, read the artefacts **in this order**:
-
-1. **`hs-*.stderr.log`** — headscale server errors, panics, policy
-   evaluation failures. Most issues originate server-side.
-
-   ```bash
-   grep -E "ERROR|panic|FATAL" control_logs/*/hs-*.stderr.log
-   ```
-
-2. **`ts-*.stderr.log`** — authentication failures, connectivity issues,
-   DNS resolution problems on the client side.
-
-3. **MapResponse JSON** in `hs-*-mapresponses/` — protocol-level
-   debugging for network map generation, peer visibility, route
-   distribution, policy evaluation results.
-
-   ```bash
-   ls control_logs/*/hs-*-mapresponses/
-   jq '.Peers[] | {Name, Tags, PrimaryRoutes}' \
-       control_logs/*/hs-*-mapresponses/001.json
-   ```
-
-4. **`*_status.json`** — client peer-connectivity state.
-
-5. **`hs-*.db`** — SQLite snapshot for post-mortem consistency checks.
-
-   ```bash
-   sqlite3 control_logs/<runID>/hs-*.db
-   sqlite> .tables
-   sqlite> .schema nodes
-   sqlite> SELECT id, hostname, user_id, tags FROM nodes WHERE hostname LIKE '%problematic%';
-   ```
-
-6. **`*_metrics.txt`** — Prometheus dumps for latency, NodeStore
-   operation timing, database query performance, memory usage.
-
-## Heuristic: infrastructure vs code
-
-**Before blaming Docker, disk, or network: read `hs-*.stderr.log` in
-full.** In practice, well over 99% of failures are code bugs (policy
-evaluation, NodeStore sync, route approval) rather than infrastructure.
-
-Actual infrastructure failures have signature error messages:
-
-| Signature                                                       | Cause                     | Fix                                                           |
-| --------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------- |
-| `failed to resolve "hs-...": no DNS fallback candidates remain` | Docker DNS                | Reset Docker networking                                       |
-| `container creation timeout`, no progress >2 min                | Resource exhaustion       | `docker system prune -f` (when no other tests running), retry |
-| OOM kills, slow Docker daemon                                   | Too many concurrent tests | Reduce concurrency, wait for completion                       |
-| `no space left on device`                                       | Disk full                 | Delete old `control_logs/`                                    |
-
-If you don't see a signature error, **assume it's a code regression** —
-do not retry hoping the flake goes away.
-
-## Common failure patterns (code bugs)
-
-### Route advertisement timing
-
-Test asserts route state before the client has finished propagating its
-Hostinfo update. Symptom: `nodes[0].GetAvailableRoutes()` empty when
-the test expects a route.
-
- **Wrong fix**: `time.Sleep(5 * time.Second)` — fragile and slow.
- **Right fix**: wrap the assertion in `EventuallyWithT`. See
-  [`../../integration/README.md`](../../integration/README.md).
-
-### NodeStore sync issues
-
-Route changes not reflected in the NodeStore snapshot. Symptom: route
-advertisements in logs but no tracking updates in subsequent reads.
-
-The sync point is `State.UpdateNodeFromMapRequest()` in
-`hscontrol/state/state.go`. If you added a new kind of client state
-update, make sure it lands here.
-
-### HA failover: routes disappearing on disconnect
-
-`TestHASubnetRouterFailover` fails because approved routes vanish when
-a subnet router goes offline. **This is a bug, not expected behaviour.**
-Route approval must not be coupled to client connectivity — routes
-stay approved; only the primary-route selection is affected by
-connectivity.
-
-### Policy evaluation race
-
-Symptom: tests that change policy and immediately assert peer visibility
-fail intermittently. Policy changes trigger async recomputation.
-
- See recent fixes in `git log -- hscontrol/state/` for examples (e.g.
-  the `PolicyChange` trigger on every Connect/Disconnect).
-
-### SQLite vs PostgreSQL timing differences
-
-Some race conditions only surface on one backend. If a test is flaky,
-try the other backend with `--postgres`:
-
-```bash
-go run ./cmd/hi run "TestName" --postgres --verbose
-```
-
-PostgreSQL generally has more consistent timing; SQLite can expose
-races during rapid writes.
-
-## Keeping containers for inspection
-
-If you need to inspect a failed test's state manually:
-
-```bash
-go run ./cmd/hi run "TestName" --keep-on-failure
-# containers survive — inspect them
-docker exec -it ts-<runID>-<...> /bin/sh
-docker logs hs-<runID>-<...>
-# clean up manually when done
-go run ./cmd/hi clean all   # only when no other tests are running
-```
@@ -1,435 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/cenkalti/backoff/v5"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/client"
-	"github.com/docker/docker/errdefs"
-)
-
-// cleanupBeforeTest performs cleanup operations before running tests.
-// Only removes stale (stopped/exited) test containers to avoid interfering with concurrent test runs.
-func cleanupBeforeTest(ctx context.Context) error {
-	err := cleanupStaleTestContainers(ctx)
-	if err != nil {
-		return fmt.Errorf("cleaning stale test containers: %w", err)
-	}
-
-	if err := pruneDockerNetworks(ctx); err != nil { //nolint:noinlineerr
-		return fmt.Errorf("pruning networks: %w", err)
-	}
-
-	return nil
-}
-
-// cleanupAfterTest removes the test container and all associated integration test containers for the run.
-func cleanupAfterTest(ctx context.Context, cli *client.Client, containerID, runID string) error {
-	// Remove the main test container
-	err := cli.ContainerRemove(ctx, containerID, container.RemoveOptions{
-		Force: true,
-	})
-	if err != nil {
-		return fmt.Errorf("removing test container: %w", err)
-	}
-
-	// Clean up integration test containers for this run only
-	if runID != "" {
-		err := killTestContainersByRunID(ctx, runID)
-		if err != nil {
-			return fmt.Errorf("cleaning up containers for run %s: %w", runID, err)
-		}
-	}
-
-	return nil
-}
-
-// killTestContainers terminates and removes all test containers.
-func killTestContainers(ctx context.Context) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	containers, err := cli.ContainerList(ctx, container.ListOptions{
-		All: true,
-	})
-	if err != nil {
-		return fmt.Errorf("listing containers: %w", err)
-	}
-
-	removed := 0
-
-	for _, cont := range containers {
-		if isTestContainerName(cont.Names) {
-			if killAndRemove(ctx, cli, cont) {
-				removed++
-			}
-		}
-	}
-
-	if removed > 0 {
-		fmt.Printf("Removed %d test containers\n", removed)
-	} else {
-		fmt.Println("No test containers found to remove")
-	}
-
-	return nil
-}
-
-// killTestContainersByRunID terminates and removes all test containers for a specific run ID.
-// This function filters containers by the hi.run-id label to only affect containers
-// belonging to the specified test run, leaving other concurrent test runs untouched.
-func killTestContainersByRunID(ctx context.Context, runID string) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	// Filter containers by hi.run-id label
-	containers, err := cli.ContainerList(ctx, container.ListOptions{
-		All: true,
-		Filters: filters.NewArgs(
-			filters.Arg("label", "hi.run-id="+runID),
-		),
-	})
-	if err != nil {
-		return fmt.Errorf("listing containers for run %s: %w", runID, err)
-	}
-
-	removed := 0
-
-	for _, cont := range containers {
-		if killAndRemove(ctx, cli, cont) {
-			removed++
-		}
-	}
-
-	if removed > 0 {
-		fmt.Printf("Removed %d containers for run ID %s\n", removed, runID)
-	}
-
-	return nil
-}
-
-// cleanupStaleTestContainers removes stopped/exited test containers without affecting running tests.
-// This is useful for cleaning up leftover containers from previous crashed or interrupted test runs
-// without interfering with currently running concurrent tests.
-func cleanupStaleTestContainers(ctx context.Context) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	// Only get stopped/exited containers
-	containers, err := cli.ContainerList(ctx, container.ListOptions{
-		All: true,
-		Filters: filters.NewArgs(
-			filters.Arg("status", "exited"),
-			filters.Arg("status", "dead"),
-		),
-	})
-	if err != nil {
-		return fmt.Errorf("listing stopped containers: %w", err)
-	}
-
-	removed := 0
-
-	for _, cont := range containers {
-		// Only remove containers that look like test containers
-		if isTestContainerName(cont.Names) {
-			if killAndRemove(ctx, cli, cont) {
-				removed++
-			}
-		}
-	}
-
-	if removed > 0 {
-		fmt.Printf("Removed %d stale test containers\n", removed)
-	}
-
-	return nil
-}
-
-const (
-	containerRemoveInitialInterval = 100 * time.Millisecond
-	containerRemoveMaxElapsedTime  = 2 * time.Second
-)
-
-// removeContainerWithRetry attempts to remove a container with exponential backoff retry logic.
-func removeContainerWithRetry(ctx context.Context, cli *client.Client, containerID string) bool {
-	expBackoff := backoff.NewExponentialBackOff()
-	expBackoff.InitialInterval = containerRemoveInitialInterval
-
-	_, err := backoff.Retry(ctx, func() (struct{}, error) {
-		err := cli.ContainerRemove(ctx, containerID, container.RemoveOptions{
-			Force: true,
-		})
-		if err != nil {
-			return struct{}{}, err
-		}
-
-		return struct{}{}, nil
-	}, backoff.WithBackOff(expBackoff), backoff.WithMaxElapsedTime(containerRemoveMaxElapsedTime))
-
-	return err == nil
-}
-
-// testContainerNamePrefixes are the name prefixes used by containers that the
-// integration test harness creates (headscale, tailscale, DERP, and k3s).
-var testContainerNamePrefixes = []string{"hs-", "ts-", "derp-", "k3s-"}
-
-// matchesTestContainerPrefix reports whether name belongs to an integration
-// test container, ignoring any leading "/" that Docker prefixes names with.
-func matchesTestContainerPrefix(name string) bool {
-	name = strings.TrimPrefix(name, "/")
-	for _, prefix := range testContainerNamePrefixes {
-		if strings.HasPrefix(name, prefix) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// isTestContainerName reports whether any of the container names belong to an
-// integration test container.
-func isTestContainerName(names []string) bool {
-	for _, name := range names {
-		if strings.Contains(name, "headscale-test-suite") ||
-			matchesTestContainerPrefix(name) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// killAndRemove kills a running container then removes it with retry logic,
-// reporting whether the removal succeeded.
-func killAndRemove(ctx context.Context, cli *client.Client, cont container.Summary) bool {
-	if cont.State == "running" {
-		_ = cli.ContainerKill(ctx, cont.ID, "KILL")
-	}
-
-	return removeContainerWithRetry(ctx, cli, cont.ID)
-}
-
-// pruneDockerNetworks removes unused Docker networks.
-func pruneDockerNetworks(ctx context.Context) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	report, err := cli.NetworksPrune(ctx, filters.Args{})
-	if err != nil {
-		return fmt.Errorf("pruning networks: %w", err)
-	}
-
-	if len(report.NetworksDeleted) > 0 {
-		fmt.Printf("Removed %d unused networks\n", len(report.NetworksDeleted))
-	} else {
-		fmt.Println("No unused networks found to remove")
-	}
-
-	return nil
-}
-
-// cleanOldImages removes test-related and old dangling Docker images.
-func cleanOldImages(ctx context.Context) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	images, err := cli.ImageList(ctx, image.ListOptions{
-		All: true,
-	})
-	if err != nil {
-		return fmt.Errorf("listing images: %w", err)
-	}
-
-	removed := 0
-
-	for _, img := range images {
-		shouldRemove := false
-
-		for _, tag := range img.RepoTags {
-			if strings.Contains(tag, "hs-") ||
-				strings.Contains(tag, "headscale-integration") ||
-				strings.Contains(tag, "tailscale") {
-				shouldRemove = true
-				break
-			}
-		}
-
-		if len(img.RepoTags) == 0 && time.Unix(img.Created, 0).Before(time.Now().Add(-7*24*time.Hour)) {
-			shouldRemove = true
-		}
-
-		if shouldRemove {
-			_, err := cli.ImageRemove(ctx, img.ID, image.RemoveOptions{
-				Force: true,
-			})
-			if err == nil {
-				removed++
-			}
-		}
-	}
-
-	if removed > 0 {
-		fmt.Printf("Removed %d test images\n", removed)
-	} else {
-		fmt.Println("No test images found to remove")
-	}
-
-	return nil
-}
-
-// cleanCacheVolume removes the Docker volume used for Go module cache.
-func cleanCacheVolume(ctx context.Context) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	volumeName := "hs-integration-go-cache"
-
-	err = cli.VolumeRemove(ctx, volumeName, true)
-	if err != nil {
-		if errdefs.IsNotFound(err) { //nolint:staticcheck // SA1019: deprecated but functional
-			fmt.Printf("Go module cache volume not found: %s\n", volumeName)
-		} else if errdefs.IsConflict(err) { //nolint:staticcheck // SA1019: deprecated but functional
-			fmt.Printf("Go module cache volume is in use and cannot be removed: %s\n", volumeName)
-		} else {
-			fmt.Printf("Failed to remove Go module cache volume %s: %v\n", volumeName, err)
-		}
-	} else {
-		fmt.Printf("Removed Go module cache volume: %s\n", volumeName)
-	}
-
-	return nil
-}
-
-// cleanupSuccessfulTestArtifacts removes artifacts from successful test runs to save disk space.
-// This function removes large artifacts that are mainly useful for debugging failures:
-// - Database dumps (.db files)
-// - Profile data (pprof directories)
-// - MapResponse data (mapresponses directories)
-// - Prometheus metrics files
-//
-// It preserves:
-// - Log files (.log) which are small and useful for verification.
-func cleanupSuccessfulTestArtifacts(logsDir string, verbose bool) error {
-	entries, err := os.ReadDir(logsDir)
-	if err != nil {
-		return fmt.Errorf("reading logs directory: %w", err)
-	}
-
-	var (
-		removedFiles, removedDirs int
-		totalSize                 int64
-	)
-
-	for _, entry := range entries {
-		name := entry.Name()
-		fullPath := filepath.Join(logsDir, name)
-
-		if entry.IsDir() {
-			// Remove pprof and mapresponses directories (typically large)
-			// These directories contain artifacts from all containers in the test run
-			if name == "pprof" || name == "mapresponses" {
-				size, sizeErr := getDirSize(fullPath)
-				if sizeErr == nil {
-					totalSize += size
-				}
-
-				err := os.RemoveAll(fullPath)
-				if err != nil {
-					if verbose {
-						log.Printf("Warning: failed to remove directory %s: %v", name, err)
-					}
-				} else {
-					removedDirs++
-
-					if verbose {
-						log.Printf("Removed directory: %s/", name)
-					}
-				}
-			}
-		} else {
-			// Only process test-related files (headscale and tailscale)
-			if !strings.HasPrefix(name, "hs-") && !strings.HasPrefix(name, "ts-") {
-				continue
-			}
-
-			// Remove database, metrics, and status files, but keep logs
-			shouldRemove := strings.HasSuffix(name, ".db") ||
-				strings.HasSuffix(name, "_metrics.txt") ||
-				strings.HasSuffix(name, "_status.json")
-
-			if shouldRemove {
-				info, infoErr := entry.Info()
-				if infoErr == nil {
-					totalSize += info.Size()
-				}
-
-				err := os.Remove(fullPath)
-				if err != nil {
-					if verbose {
-						log.Printf("Warning: failed to remove file %s: %v", name, err)
-					}
-				} else {
-					removedFiles++
-
-					if verbose {
-						log.Printf("Removed file: %s", name)
-					}
-				}
-			}
-		}
-	}
-
-	if removedFiles > 0 || removedDirs > 0 {
-		const bytesPerMB = 1024 * 1024
-		log.Printf("Cleaned up %d files and %d directories (freed ~%.2f MB)",
-			removedFiles, removedDirs, float64(totalSize)/bytesPerMB)
-	}
-
-	return nil
-}
-
-// getDirSize calculates the total size of a directory.
-func getDirSize(path string) (int64, error) {
-	var size int64
-
-	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		if !info.IsDir() {
-			size += info.Size()
-		}
-
-		return nil
-	})
-
-	return size, err
-}
@@ -1,818 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/cenkalti/backoff/v5"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/client"
-	"github.com/docker/docker/pkg/stdcopy"
-	"github.com/juanfont/headscale/integration/dockertestutil"
-)
-
-const defaultDirPerm = 0o755
-
-var (
-	ErrTestFailed              = errors.New("test failed")
-	ErrUnexpectedContainerWait = errors.New("unexpected end of container wait")
-	ErrNoDockerContext         = errors.New("no docker context found")
-	ErrMemoryLimitViolations   = errors.New("container(s) exceeded memory limits")
-)
-
-// runTestContainer executes integration tests in a Docker container.
-//
-//nolint:gocyclo // complex test orchestration function
-func runTestContainer(ctx context.Context, config *RunConfig) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	runID := dockertestutil.GenerateRunID()
-	containerName := "headscale-test-suite-" + runID
-	logsDir := filepath.Join(config.LogsDir, runID)
-
-	if config.Verbose {
-		log.Printf("Run ID: %s", runID)
-		log.Printf("Container name: %s", containerName)
-		log.Printf("Logs directory: %s", logsDir)
-	}
-
-	absLogsDir, err := filepath.Abs(logsDir)
-	if err != nil {
-		return fmt.Errorf("getting absolute path for logs directory: %w", err)
-	}
-
-	const dirPerm = 0o755
-	if err := os.MkdirAll(absLogsDir, dirPerm); err != nil { //nolint:noinlineerr
-		return fmt.Errorf("creating logs directory: %w", err)
-	}
-
-	if config.CleanBefore {
-		if config.Verbose {
-			log.Printf("Running pre-test cleanup...")
-		}
-
-		err := cleanupBeforeTest(ctx)
-		if err != nil && config.Verbose {
-			log.Printf("Warning: pre-test cleanup failed: %v", err)
-		}
-	}
-
-	goTestCmd := buildGoTestCommand(config)
-	if config.Verbose {
-		log.Printf("Command: %s", strings.Join(goTestCmd, " "))
-	}
-
-	imageName := "golang:" + config.GoVersion
-	if err := ensureImageAvailable(ctx, cli, imageName, config.Verbose); err != nil { //nolint:noinlineerr
-		return fmt.Errorf("ensuring image availability: %w", err)
-	}
-
-	resp, err := createGoTestContainer(ctx, cli, config, containerName, absLogsDir, goTestCmd)
-	if err != nil {
-		return fmt.Errorf("creating container: %w", err)
-	}
-
-	if config.Verbose {
-		log.Printf("Created container: %s", resp.ID)
-	}
-
-	if err := cli.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil { //nolint:noinlineerr
-		return fmt.Errorf("starting container: %w", err)
-	}
-
-	log.Printf("Starting test: %s", config.TestPattern)
-	log.Printf("Run ID: %s", runID)
-	log.Printf("Monitor with: docker logs -f %s", containerName)
-	log.Printf("Logs directory: %s", logsDir)
-
-	// Start stats collection for container resource monitoring (if enabled)
-	var statsCollector *StatsCollector
-
-	if config.Stats {
-		var err error
-
-		statsCollector, err = NewStatsCollector(ctx)
-		if err != nil {
-			if config.Verbose {
-				log.Printf("Warning: failed to create stats collector: %v", err)
-			}
-
-			statsCollector = nil
-		}
-
-		if statsCollector != nil {
-			defer statsCollector.Close()
-
-			// Start stats collection immediately - no need for complex retry logic
-			// The new implementation monitors Docker events and will catch containers as they start
-			err := statsCollector.StartCollection(ctx, runID, config.Verbose)
-			if err != nil {
-				if config.Verbose {
-					log.Printf("Warning: failed to start stats collection: %v", err)
-				}
-			}
-			defer statsCollector.StopCollection()
-		}
-	}
-
-	exitCode, err := streamAndWait(ctx, cli, resp.ID)
-
-	// Ensure all containers have finished and logs are flushed before extracting artifacts
-	waitErr := waitForContainerFinalization(ctx, cli, resp.ID, config.Verbose)
-	if waitErr != nil && config.Verbose {
-		log.Printf("Warning: failed to wait for container finalization: %v", waitErr)
-	}
-
-	// Extract artifacts from test containers before cleanup
-	if err := extractArtifactsFromContainers(ctx, resp.ID, logsDir, config.Verbose); err != nil && config.Verbose { //nolint:noinlineerr
-		log.Printf("Warning: failed to extract artifacts from containers: %v", err)
-	}
-
-	// Always list control files regardless of test outcome
-	listControlFiles(logsDir)
-
-	// Print stats summary and check memory limits if enabled
-	if config.Stats && statsCollector != nil {
-		violations := statsCollector.PrintSummaryAndCheckLimits(config.HSMemoryLimit, config.TSMemoryLimit)
-		if len(violations) > 0 {
-			log.Printf("MEMORY LIMIT VIOLATIONS DETECTED:")
-			log.Printf("=================================")
-
-			for _, violation := range violations {
-				log.Printf("Container %s exceeded memory limit: %.1f MB > %.1f MB",
-					violation.ContainerName, violation.MaxMemoryMB, violation.LimitMB)
-			}
-
-			return fmt.Errorf("test failed: %d %w", len(violations), ErrMemoryLimitViolations)
-		}
-	}
-
-	shouldCleanup := config.CleanAfter && (!config.KeepOnFailure || exitCode == 0)
-	if shouldCleanup {
-		if config.Verbose {
-			log.Printf("Running post-test cleanup for run %s...", runID)
-		}
-
-		cleanErr := cleanupAfterTest(ctx, cli, resp.ID, runID)
-
-		if cleanErr != nil && config.Verbose {
-			log.Printf("Warning: post-test cleanup failed: %v", cleanErr)
-		}
-
-		// Clean up artifacts from successful tests to save disk space in CI
-		if exitCode == 0 {
-			if config.Verbose {
-				log.Printf("Test succeeded, cleaning up artifacts to save disk space...")
-			}
-
-			cleanErr := cleanupSuccessfulTestArtifacts(logsDir, config.Verbose)
-
-			if cleanErr != nil && config.Verbose {
-				log.Printf("Warning: artifact cleanup failed: %v", cleanErr)
-			}
-		}
-	}
-
-	if err != nil {
-		return fmt.Errorf("executing test: %w", err)
-	}
-
-	if exitCode != 0 {
-		return fmt.Errorf("%w: exit code %d", ErrTestFailed, exitCode)
-	}
-
-	log.Printf("Test completed successfully!")
-
-	return nil
-}
-
-// buildGoTestCommand constructs the go test command arguments.
-func buildGoTestCommand(config *RunConfig) []string {
-	cmd := []string{"go", "test", "./..."}
-
-	if config.TestPattern != "" {
-		cmd = append(cmd, "-run", config.TestPattern)
-	}
-
-	if config.FailFast {
-		cmd = append(cmd, "-failfast")
-	}
-
-	cmd = append(cmd, "-timeout", config.Timeout.String())
-	cmd = append(cmd, "-v")
-
-	return cmd
-}
-
-// createGoTestContainer creates a Docker container configured for running integration tests.
-func createGoTestContainer(ctx context.Context, cli *client.Client, config *RunConfig, containerName, logsDir string, goTestCmd []string) (container.CreateResponse, error) {
-	pwd, err := os.Getwd()
-	if err != nil {
-		return container.CreateResponse{}, fmt.Errorf("getting working directory: %w", err)
-	}
-
-	projectRoot := findProjectRoot(pwd)
-
-	runID := dockertestutil.ExtractRunIDFromContainerName(containerName)
-
-	env := []string{
-		fmt.Sprintf("HEADSCALE_INTEGRATION_POSTGRES=%d", boolToInt(config.UsePostgres)),
-		"HEADSCALE_INTEGRATION_RUN_ID=" + runID,
-	}
-
-	// Pass through CI environment variable for CI detection
-	if ci := os.Getenv("CI"); ci != "" {
-		env = append(env, "CI="+ci)
-	}
-
-	// Pass through all HEADSCALE_INTEGRATION_* environment variables
-	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "HEADSCALE_INTEGRATION_") {
-			// Skip the ones we already set explicitly
-			if strings.HasPrefix(e, "HEADSCALE_INTEGRATION_POSTGRES=") ||
-				strings.HasPrefix(e, "HEADSCALE_INTEGRATION_RUN_ID=") {
-				continue
-			}
-
-			env = append(env, e)
-		}
-	}
-
-	// Set GOCACHE to a known location (used by both bind mount and volume cases)
-	env = append(env, "GOCACHE=/cache/go-build")
-
-	containerConfig := &container.Config{
-		Image:      "golang:" + config.GoVersion,
-		Cmd:        goTestCmd,
-		Env:        env,
-		WorkingDir: projectRoot + "/integration",
-		Tty:        true,
-		Labels: map[string]string{
-			"hi.run-id":    runID,
-			"hi.test-type": "test-runner",
-		},
-	}
-
-	// Get the correct Docker socket path from the current context
-	dockerSocketPath := getDockerSocketPath()
-
-	if config.Verbose {
-		log.Printf("Using Docker socket: %s", dockerSocketPath)
-	}
-
-	binds := []string{
-		fmt.Sprintf("%s:%s", projectRoot, projectRoot),
-		dockerSocketPath + ":/var/run/docker.sock",
-		logsDir + ":/tmp/control",
-	}
-
-	// Use bind mounts for Go cache if provided via environment variables,
-	// otherwise fall back to Docker volumes for local development
-	var mounts []mount.Mount
-
-	goCache := os.Getenv("HEADSCALE_INTEGRATION_GO_CACHE")
-	goBuildCache := os.Getenv("HEADSCALE_INTEGRATION_GO_BUILD_CACHE")
-
-	if goCache != "" {
-		binds = append(binds, goCache+":/go")
-	} else {
-		mounts = append(mounts, mount.Mount{
-			Type:   mount.TypeVolume,
-			Source: "hs-integration-go-cache",
-			Target: "/go",
-		})
-	}
-
-	if goBuildCache != "" {
-		binds = append(binds, goBuildCache+":/cache/go-build")
-	} else {
-		mounts = append(mounts, mount.Mount{
-			Type:   mount.TypeVolume,
-			Source: "hs-integration-go-build-cache",
-			Target: "/cache/go-build",
-		})
-	}
-
-	hostConfig := &container.HostConfig{
-		AutoRemove: false, // We'll remove manually for better control
-		Binds:      binds,
-		Mounts:     mounts,
-	}
-
-	return cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, nil, containerName)
-}
-
-// streamAndWait streams container output and waits for completion.
-func streamAndWait(ctx context.Context, cli *client.Client, containerID string) (int, error) {
-	out, err := cli.ContainerLogs(ctx, containerID, container.LogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Follow:     true,
-	})
-	if err != nil {
-		return -1, fmt.Errorf("getting container logs: %w", err)
-	}
-	defer out.Close()
-
-	go func() {
-		_, _ = io.Copy(os.Stdout, out)
-	}()
-
-	statusCh, errCh := cli.ContainerWait(ctx, containerID, container.WaitConditionNotRunning)
-	select {
-	case err := <-errCh:
-		if err != nil {
-			return -1, fmt.Errorf("waiting for container: %w", err)
-		}
-	case status := <-statusCh:
-		return int(status.StatusCode), nil
-	}
-
-	return -1, ErrUnexpectedContainerWait
-}
-
-// waitForContainerFinalization ensures all test containers have properly finished and flushed their output.
-func waitForContainerFinalization(ctx context.Context, cli *client.Client, testContainerID string, verbose bool) error {
-	// First, get all related test containers
-	containers, err := cli.ContainerList(ctx, container.ListOptions{All: true})
-	if err != nil {
-		return fmt.Errorf("listing containers: %w", err)
-	}
-
-	testContainers := getCurrentTestContainers(containers, testContainerID, verbose)
-
-	// Wait for all test containers to reach a final state
-	maxWaitTime := 10 * time.Second
-	checkInterval := 500 * time.Millisecond
-	timeout := time.After(maxWaitTime)
-
-	ticker := time.NewTicker(checkInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-timeout:
-			if verbose {
-				log.Printf("Timeout waiting for container finalization, proceeding with artifact extraction")
-			}
-
-			return nil
-		case <-ticker.C:
-			allFinalized := true
-
-			for _, testCont := range testContainers {
-				inspect, err := cli.ContainerInspect(ctx, testCont.ID)
-				if err != nil {
-					if verbose {
-						log.Printf("Warning: failed to inspect container %s: %v", testCont.name, err)
-					}
-
-					continue
-				}
-
-				// Check if container is in a final state
-				if !isContainerFinalized(inspect.State) {
-					allFinalized = false
-
-					if verbose {
-						log.Printf("Container %s still finalizing (state: %s)", testCont.name, inspect.State.Status)
-					}
-
-					break
-				}
-			}
-
-			if allFinalized {
-				if verbose {
-					log.Printf("All test containers finalized, ready for artifact extraction")
-				}
-
-				return nil
-			}
-		}
-	}
-}
-
-// isContainerFinalized checks if a container has reached a final state where logs are flushed.
-func isContainerFinalized(state *container.State) bool {
-	// Container is finalized if it's not running and has a finish time
-	return !state.Running && state.FinishedAt != ""
-}
-
-// findProjectRoot locates the project root by finding the directory containing go.mod.
-func findProjectRoot(startPath string) string {
-	current := startPath
-	for {
-		if _, err := os.Stat(filepath.Join(current, "go.mod")); err == nil { //nolint:noinlineerr
-			return current
-		}
-
-		parent := filepath.Dir(current)
-		if parent == current {
-			return startPath
-		}
-
-		current = parent
-	}
-}
-
-// boolToInt converts a boolean to an integer for environment variables.
-func boolToInt(b bool) int {
-	if b {
-		return 1
-	}
-
-	return 0
-}
-
-// DockerContext represents Docker context information.
-type DockerContext struct {
-	Name      string         `json:"Name"`
-	Metadata  map[string]any `json:"Metadata"`
-	Endpoints map[string]any `json:"Endpoints"`
-	Current   bool           `json:"Current"`
-}
-
-// createDockerClient creates a Docker client with context detection.
-func createDockerClient(ctx context.Context) (*client.Client, error) {
-	contextInfo, err := getCurrentDockerContext(ctx)
-	if err != nil {
-		return client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-	}
-
-	var clientOpts []client.Opt
-
-	clientOpts = append(clientOpts, client.WithAPIVersionNegotiation())
-
-	if contextInfo != nil {
-		if endpoints, ok := contextInfo.Endpoints["docker"]; ok {
-			if endpointMap, ok := endpoints.(map[string]any); ok {
-				if host, ok := endpointMap["Host"].(string); ok {
-					if runConfig.Verbose {
-						log.Printf("Using Docker host from context '%s': %s", contextInfo.Name, host)
-					}
-
-					clientOpts = append(clientOpts, client.WithHost(host))
-				}
-			}
-		}
-	}
-
-	if len(clientOpts) == 1 {
-		clientOpts = append(clientOpts, client.FromEnv)
-	}
-
-	return client.NewClientWithOpts(clientOpts...)
-}
-
-// getCurrentDockerContext retrieves the current Docker context information.
-func getCurrentDockerContext(ctx context.Context) (*DockerContext, error) {
-	cmd := exec.CommandContext(ctx, "docker", "context", "inspect")
-
-	output, err := cmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("getting docker context: %w", err)
-	}
-
-	var contexts []DockerContext
-	if err := json.Unmarshal(output, &contexts); err != nil { //nolint:noinlineerr
-		return nil, fmt.Errorf("parsing docker context: %w", err)
-	}
-
-	if len(contexts) > 0 {
-		return &contexts[0], nil
-	}
-
-	return nil, ErrNoDockerContext
-}
-
-// getDockerSocketPath returns the correct Docker socket path for the current context.
-func getDockerSocketPath() string {
-	// Always use the default socket path for mounting since Docker handles
-	// the translation to the actual socket (e.g., colima socket) internally
-	return "/var/run/docker.sock"
-}
-
-// checkImageAvailableLocally checks if the specified Docker image is available locally.
-func checkImageAvailableLocally(ctx context.Context, cli *client.Client, imageName string) (bool, error) {
-	_, _, err := cli.ImageInspectWithRaw(ctx, imageName) //nolint:staticcheck // SA1019: deprecated but functional
-	if err != nil {
-		if client.IsErrNotFound(err) { //nolint:staticcheck // SA1019: deprecated but functional
-			return false, nil
-		}
-
-		return false, fmt.Errorf("inspecting image %s: %w", imageName, err)
-	}
-
-	return true, nil
-}
-
-// ensureImageAvailable pulls imageName if missing, using Docker Hub
-// credentials and retrying transient errors.
-func ensureImageAvailable(ctx context.Context, cli *client.Client, imageName string, verbose bool) error {
-	available, err := checkImageAvailableLocally(ctx, cli, imageName)
-	if err != nil {
-		return fmt.Errorf("checking local image availability: %w", err)
-	}
-
-	if available {
-		if verbose {
-			log.Printf("Image %s is available locally", imageName)
-		}
-
-		return nil
-	}
-
-	if verbose {
-		log.Printf("Image %s not found locally, pulling...", imageName)
-	}
-
-	registryAuth, err := dockertestutil.RegistryAuth()
-	if err != nil {
-		return fmt.Errorf("resolving registry auth: %w", err)
-	}
-
-	_, err = backoff.Retry(
-		ctx,
-		func() (struct{}, error) {
-			reader, pullErr := cli.ImagePull(ctx, imageName, image.PullOptions{RegistryAuth: registryAuth})
-			if pullErr != nil {
-				if isPermanentDockerPullError(pullErr) {
-					return struct{}{}, backoff.Permanent(pullErr)
-				}
-
-				return struct{}{}, fmt.Errorf("pulling image %s: %w", imageName, pullErr)
-			}
-			defer reader.Close()
-
-			sink := io.Discard
-			if verbose {
-				sink = os.Stdout
-			}
-
-			_, copyErr := io.Copy(sink, reader)
-			if copyErr != nil {
-				return struct{}{}, fmt.Errorf("reading pull output: %w", copyErr)
-			}
-
-			return struct{}{}, nil
-		},
-		backoff.WithBackOff(backoff.NewExponentialBackOff()),
-		backoff.WithMaxElapsedTime(60*time.Second),
-	)
-	if err != nil {
-		return err
-	}
-
-	if !verbose {
-		log.Printf("Image %s pulled successfully", imageName)
-	}
-
-	return nil
-}
-
-func isPermanentDockerPullError(err error) bool {
-	msg := strings.ToLower(err.Error())
-
-	return strings.Contains(msg, "manifest unknown") ||
-		strings.Contains(msg, "manifest not found") ||
-		strings.Contains(msg, "repository does not exist") ||
-		strings.Contains(msg, "name unknown") ||
-		strings.Contains(msg, "no such image")
-}
-
-// listControlFiles displays the headscale test artifacts created in the control logs directory.
-func listControlFiles(logsDir string) {
-	entries, err := os.ReadDir(logsDir)
-	if err != nil {
-		log.Printf("Logs directory: %s", logsDir)
-		return
-	}
-
-	var (
-		logFiles  []string
-		dataFiles []string
-		dataDirs  []string
-	)
-
-	for _, entry := range entries {
-		name := entry.Name()
-		// Only show headscale (hs-*) files and directories
-		if !strings.HasPrefix(name, "hs-") {
-			continue
-		}
-
-		if entry.IsDir() {
-			// Include directories (pprof, mapresponses)
-			if strings.Contains(name, "-pprof") || strings.Contains(name, "-mapresponses") {
-				dataDirs = append(dataDirs, name)
-			}
-		} else {
-			// Include files
-			switch {
-			case strings.HasSuffix(name, ".stderr.log") || strings.HasSuffix(name, ".stdout.log"):
-				logFiles = append(logFiles, name)
-			case strings.HasSuffix(name, ".db"):
-				dataFiles = append(dataFiles, name)
-			}
-		}
-	}
-
-	log.Printf("Test artifacts saved to: %s", logsDir)
-
-	if len(logFiles) > 0 {
-		log.Printf("Headscale logs:")
-
-		for _, file := range logFiles {
-			log.Printf("  %s", file)
-		}
-	}
-
-	if len(dataFiles) > 0 || len(dataDirs) > 0 {
-		log.Printf("Headscale data:")
-
-		for _, file := range dataFiles {
-			log.Printf("  %s", file)
-		}
-
-		for _, dir := range dataDirs {
-			log.Printf("  %s/", dir)
-		}
-	}
-}
-
-// extractArtifactsFromContainers collects container logs and files from the specific test run.
-func extractArtifactsFromContainers(ctx context.Context, testContainerID, logsDir string, verbose bool) error {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fmt.Errorf("creating Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	// List all containers
-	containers, err := cli.ContainerList(ctx, container.ListOptions{All: true})
-	if err != nil {
-		return fmt.Errorf("listing containers: %w", err)
-	}
-
-	// Get containers from the specific test run
-	currentTestContainers := getCurrentTestContainers(containers, testContainerID, verbose)
-
-	extractedCount := 0
-
-	for _, cont := range currentTestContainers {
-		// Extract container logs and tar files
-		err := extractContainerArtifacts(ctx, cli, cont.ID, cont.name, logsDir, verbose)
-		if err != nil {
-			if verbose {
-				log.Printf("Warning: failed to extract artifacts from container %s (%s): %v", cont.name, cont.ID[:12], err)
-			}
-		} else {
-			if verbose {
-				log.Printf("Extracted artifacts from container %s (%s)", cont.name, cont.ID[:12])
-			}
-
-			extractedCount++
-		}
-	}
-
-	if verbose && extractedCount > 0 {
-		log.Printf("Extracted artifacts from %d containers", extractedCount)
-	}
-
-	return nil
-}
-
-// testContainer represents a container from the current test run.
-type testContainer struct {
-	ID   string
-	name string
-}
-
-// getCurrentTestContainers filters containers to only include those from the current test run.
-func getCurrentTestContainers(containers []container.Summary, testContainerID string, verbose bool) []testContainer {
-	var testRunContainers []testContainer
-
-	// Find the test container to get its run ID label
-	var runID string
-
-	for _, cont := range containers {
-		if cont.ID == testContainerID {
-			if cont.Labels != nil {
-				runID = cont.Labels["hi.run-id"]
-			}
-
-			break
-		}
-	}
-
-	if runID == "" {
-		log.Printf("Error: test container %s missing required hi.run-id label", testContainerID[:12])
-		return testRunContainers
-	}
-
-	if verbose {
-		log.Printf("Looking for containers with run ID: %s", runID)
-	}
-
-	// Find all containers with the same run ID
-	for _, cont := range containers {
-		for _, name := range cont.Names {
-			containerName := strings.TrimPrefix(name, "/")
-			if matchesTestContainerPrefix(containerName) {
-				// Check if container has matching run ID label
-				if cont.Labels != nil && cont.Labels["hi.run-id"] == runID {
-					testRunContainers = append(testRunContainers, testContainer{
-						ID:   cont.ID,
-						name: containerName,
-					})
-					if verbose {
-						log.Printf("Including container %s (run ID: %s)", containerName, runID)
-					}
-				}
-
-				break
-			}
-		}
-	}
-
-	return testRunContainers
-}
-
-// extractContainerArtifacts saves logs and tar files from a container.
-func extractContainerArtifacts(ctx context.Context, cli *client.Client, containerID, containerName, logsDir string, verbose bool) error {
-	// Ensure the logs directory exists
-	err := os.MkdirAll(logsDir, defaultDirPerm)
-	if err != nil {
-		return fmt.Errorf("creating logs directory: %w", err)
-	}
-
-	// Extract container logs
-	err = extractContainerLogs(ctx, cli, containerID, containerName, logsDir, verbose)
-	if err != nil {
-		return fmt.Errorf("extracting logs: %w", err)
-	}
-
-	return nil
-}
-
-// extractContainerLogs saves the stdout and stderr logs from a container to files.
-func extractContainerLogs(ctx context.Context, cli *client.Client, containerID, containerName, logsDir string, verbose bool) error {
-	// Get container logs
-	logReader, err := cli.ContainerLogs(ctx, containerID, container.LogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Timestamps: false,
-		Follow:     false,
-		Tail:       "all",
-	})
-	if err != nil {
-		return fmt.Errorf("getting container logs: %w", err)
-	}
-	defer logReader.Close()
-
-	// Create log files following the headscale naming convention
-	stdoutPath := filepath.Join(logsDir, containerName+".stdout.log")
-	stderrPath := filepath.Join(logsDir, containerName+".stderr.log")
-
-	// Create buffers to capture stdout and stderr separately
-	var stdoutBuf, stderrBuf bytes.Buffer
-
-	// Demultiplex the Docker logs stream to separate stdout and stderr
-	_, err = stdcopy.StdCopy(&stdoutBuf, &stderrBuf, logReader)
-	if err != nil {
-		return fmt.Errorf("demultiplexing container logs: %w", err)
-	}
-
-	// Write stdout logs
-	if err := os.WriteFile(stdoutPath, stdoutBuf.Bytes(), 0o644); err != nil { //nolint:gosec,noinlineerr // log files should be readable
-		return fmt.Errorf("writing stdout log: %w", err)
-	}
-
-	// Write stderr logs
-	if err := os.WriteFile(stderrPath, stderrBuf.Bytes(), 0o644); err != nil { //nolint:gosec,noinlineerr // log files should be readable
-		return fmt.Errorf("writing stderr log: %w", err)
-	}
-
-	if verbose {
-		log.Printf("Saved logs for %s: %s, %s", containerName, stdoutPath, stderrPath)
-	}
-
-	return nil
-}
@@ -1,386 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/juanfont/headscale/integration/dockertestutil"
-	"github.com/juanfont/headscale/integration/k3sic"
-)
-
-const (
-	statusPass = "PASS"
-	statusFail = "FAIL"
-	statusWarn = "WARN"
-
-	nameDockerDaemon  = "Docker Daemon"
-	nameDockerContext = "Docker Context"
-	nameDockerSocket  = "Docker Socket"
-	nameGolangImage   = "Golang Image"
-	nameK3sImage      = "K3s Image"
-	nameGoInstall     = "Go Installation"
-)
-
-var ErrSystemChecksFailed = errors.New("system checks failed")
-
-// DoctorResult represents the result of a single health check.
-type DoctorResult struct {
-	Name        string
-	Status      string // "PASS", "FAIL", "WARN"
-	Message     string
-	Suggestions []string
-}
-
-// pass builds a passing DoctorResult.
-func pass(name, message string) DoctorResult {
-	return DoctorResult{Name: name, Status: statusPass, Message: message}
-}
-
-// warn builds a warning DoctorResult with optional suggestions.
-func warn(name, message string, suggestions ...string) DoctorResult {
-	return DoctorResult{Name: name, Status: statusWarn, Message: message, Suggestions: suggestions}
-}
-
-// fail builds a failing DoctorResult with optional suggestions.
-func fail(name, message string, suggestions ...string) DoctorResult {
-	return DoctorResult{Name: name, Status: statusFail, Message: message, Suggestions: suggestions}
-}
-
-// runDoctorCheck performs comprehensive pre-flight checks for integration testing.
-func runDoctorCheck(ctx context.Context) error {
-	results := []DoctorResult{}
-
-	// Check 1: Docker binary availability
-	results = append(results, checkDockerBinary())
-
-	// Check 2: Docker daemon connectivity
-	dockerResult := checkDockerDaemon(ctx)
-	results = append(results, dockerResult)
-
-	// If Docker is available, run additional checks
-	if dockerResult.Status == statusPass {
-		results = append(results, checkDockerContext(ctx))
-		results = append(results, checkDockerSocket(ctx))
-		results = append(results, checkDockerHubCredentials())
-		results = append(results, checkGolangImage(ctx))
-		results = append(results, checkK3sImage(ctx))
-	}
-
-	// Check 3: Go installation
-	results = append(results, checkGoInstallation(ctx))
-
-	// Check 4: Git repository
-	results = append(results, checkGitRepository(ctx))
-
-	// Check 5: Required files
-	results = append(results, checkRequiredFiles(ctx))
-
-	// Display results
-	displayDoctorResults(results)
-
-	// Return error if any critical checks failed
-	for _, result := range results {
-		if result.Status == statusFail {
-			return fmt.Errorf("%w - see details above", ErrSystemChecksFailed)
-		}
-	}
-
-	log.Printf("✅ All system checks passed - ready to run integration tests!")
-
-	return nil
-}
-
-// checkDockerBinary verifies Docker binary is available.
-func checkDockerBinary() DoctorResult {
-	_, err := exec.LookPath("docker")
-	if err != nil {
-		return fail(
-			"Docker Binary",
-			"Docker binary not found in PATH",
-			"Install Docker: https://docs.docker.com/get-docker/",
-			"For macOS: consider using colima or Docker Desktop",
-			"Ensure docker is in your PATH",
-		)
-	}
-
-	return pass("Docker Binary", "Docker binary found")
-}
-
-// checkDockerDaemon verifies Docker daemon is running and accessible.
-func checkDockerDaemon(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fail(
-			nameDockerDaemon,
-			fmt.Sprintf("Cannot create Docker client: %v", err),
-			"Start Docker daemon/service",
-			"Check Docker Desktop is running (if using Docker Desktop)",
-			"For colima: run 'colima start'",
-			"Verify DOCKER_HOST environment variable if set",
-		)
-	}
-	defer cli.Close()
-
-	_, err = cli.Ping(ctx)
-	if err != nil {
-		return fail(
-			nameDockerDaemon,
-			fmt.Sprintf("Cannot ping Docker daemon: %v", err),
-			"Ensure Docker daemon is running",
-			"Check Docker socket permissions",
-			"Try: docker info",
-		)
-	}
-
-	return pass(nameDockerDaemon, "Docker daemon is running and accessible")
-}
-
-// checkDockerContext verifies Docker context configuration.
-func checkDockerContext(ctx context.Context) DoctorResult {
-	contextInfo, err := getCurrentDockerContext(ctx)
-	if err != nil {
-		return warn(
-			nameDockerContext,
-			"Could not detect Docker context, using default settings",
-			"Check: docker context ls",
-			"Consider setting up a specific context if needed",
-		)
-	}
-
-	if contextInfo == nil {
-		return pass(nameDockerContext, "Using default Docker context")
-	}
-
-	return pass(nameDockerContext, "Using Docker context: "+contextInfo.Name)
-}
-
-// checkDockerSocket verifies Docker socket accessibility.
-func checkDockerSocket(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fail(
-			nameDockerSocket,
-			fmt.Sprintf("Cannot access Docker socket: %v", err),
-			"Check Docker socket permissions",
-			"Add user to docker group: sudo usermod -aG docker $USER",
-			"For colima: ensure socket is accessible",
-		)
-	}
-	defer cli.Close()
-
-	info, err := cli.Info(ctx)
-	if err != nil {
-		return fail(
-			nameDockerSocket,
-			fmt.Sprintf("Cannot get Docker info: %v", err),
-			"Check Docker daemon status",
-			"Verify socket permissions",
-		)
-	}
-
-	return pass(nameDockerSocket, fmt.Sprintf("Docker socket accessible (Server: %s)", info.ServerVersion))
-}
-
-// checkDockerHubCredentials warns when pulls would be anonymous and
-// therefore rate-limited.
-func checkDockerHubCredentials() DoctorResult {
-	_, _, source := dockertestutil.Credentials()
-	if source == dockertestutil.CredentialSourceAnonymous {
-		return warn(
-			"Docker Hub Credentials",
-			"No Docker Hub credentials found — pulls will be rate-limited (100/6h per IP)",
-			"Run: docker login",
-			"Or export DOCKERHUB_USERNAME and DOCKERHUB_TOKEN",
-			"In CI: ensure the docker/login-action step is configured with secrets",
-		)
-	}
-
-	return pass("Docker Hub Credentials", fmt.Sprintf("Credentials available (source: %s)", source))
-}
-
-// checkGolangImage verifies the golang Docker image is available locally or can be pulled.
-func checkGolangImage(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fail(nameGolangImage, "Cannot create Docker client for image check")
-	}
-	defer cli.Close()
-
-	goVersion := detectGoVersion()
-	imageName := "golang:" + goVersion
-
-	// First check if image is available locally
-	available, err := checkImageAvailableLocally(ctx, cli, imageName)
-	if err != nil {
-		return fail(
-			nameGolangImage,
-			fmt.Sprintf("Cannot check golang image %s: %v", imageName, err),
-			"Check Docker daemon status",
-			"Try: docker images | grep golang",
-		)
-	}
-
-	if available {
-		return pass(nameGolangImage, fmt.Sprintf("Golang image %s is available locally", imageName))
-	}
-
-	// Image not available locally, try to pull it
-	err = ensureImageAvailable(ctx, cli, imageName, false)
-	if err != nil {
-		return fail(
-			nameGolangImage,
-			fmt.Sprintf("Golang image %s not available locally and cannot pull: %v", imageName, err),
-			"Check internet connectivity",
-			"Verify Docker Hub access",
-			"Try: docker pull "+imageName,
-			"Or run tests offline if image was pulled previously",
-		)
-	}
-
-	return pass(nameGolangImage, fmt.Sprintf("Golang image %s is now available", imageName))
-}
-
-// checkK3sImage verifies the ghcr k3s image used by TestK8sOperator is available
-// locally or can be pulled. The image is pinned (see [k3sic.K3sImage]).
-func checkK3sImage(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return fail(nameK3sImage, "Cannot create Docker client for image check")
-	}
-	defer cli.Close()
-
-	imageName := k3sic.K3sImage
-
-	available, err := checkImageAvailableLocally(ctx, cli, imageName)
-	if err != nil {
-		return fail(
-			nameK3sImage,
-			fmt.Sprintf("Cannot check k3s image %s: %v", imageName, err),
-			"Check Docker daemon status",
-			"Try: docker images | grep k3s",
-		)
-	}
-
-	if available {
-		return pass(nameK3sImage, fmt.Sprintf("K3s image %s is available locally", imageName))
-	}
-
-	err = ensureImageAvailable(ctx, cli, imageName, false)
-	if err != nil {
-		return warn(
-			nameK3sImage,
-			fmt.Sprintf("K3s image %s not available locally and could not pull: %v", imageName, err),
-			"Only TestK8sOperator needs this image; other tests are unaffected",
-			"Try: docker pull "+imageName,
-		)
-	}
-
-	return pass(nameK3sImage, fmt.Sprintf("K3s image %s is now available", imageName))
-}
-
-// checkGoInstallation verifies Go is installed and working.
-func checkGoInstallation(ctx context.Context) DoctorResult {
-	_, err := exec.LookPath("go")
-	if err != nil {
-		return fail(
-			nameGoInstall,
-			"Go binary not found in PATH",
-			"Install Go: https://golang.org/dl/",
-			"Ensure go is in your PATH",
-		)
-	}
-
-	cmd := exec.CommandContext(ctx, "go", "version")
-
-	output, err := cmd.Output()
-	if err != nil {
-		return fail(nameGoInstall, fmt.Sprintf("Cannot get Go version: %v", err))
-	}
-
-	version := strings.TrimSpace(string(output))
-
-	return pass(nameGoInstall, version)
-}
-
-// checkGitRepository verifies we're in a git repository.
-func checkGitRepository(ctx context.Context) DoctorResult {
-	cmd := exec.CommandContext(ctx, "git", "rev-parse", "--git-dir")
-
-	err := cmd.Run()
-	if err != nil {
-		return fail(
-			"Git Repository",
-			"Not in a Git repository",
-			"Run from within the headscale git repository",
-			"Clone the repository: git clone https://github.com/juanfont/headscale.git",
-		)
-	}
-
-	return pass("Git Repository", "Running in Git repository")
-}
-
-// checkRequiredFiles verifies required files exist.
-func checkRequiredFiles(_ context.Context) DoctorResult {
-	requiredFiles := []string{
-		"go.mod",
-		"integration/",
-		"cmd/hi/",
-	}
-
-	var missingFiles []string
-
-	for _, file := range requiredFiles {
-		_, err := os.Stat(file)
-		if err != nil {
-			missingFiles = append(missingFiles, file)
-		}
-	}
-
-	if len(missingFiles) > 0 {
-		return fail(
-			"Required Files",
-			"Missing required files: "+strings.Join(missingFiles, ", "),
-			"Ensure you're in the headscale project root directory",
-			"Check that integration/ directory exists",
-			"Verify this is a complete headscale repository",
-		)
-	}
-
-	return pass("Required Files", "All required files found")
-}
-
-// displayDoctorResults shows the results in a formatted way.
-func displayDoctorResults(results []DoctorResult) {
-	log.Printf("🔍 System Health Check Results")
-	log.Printf("================================")
-
-	for _, result := range results {
-		var icon string
-
-		switch result.Status {
-		case statusPass:
-			icon = "✅"
-		case statusWarn:
-			icon = "⚠️"
-		case statusFail:
-			icon = "❌"
-		default:
-			icon = "❓"
-		}
-
-		log.Printf("%s %s: %s", icon, result.Name, result.Message)
-
-		if len(result.Suggestions) > 0 {
-			for _, suggestion := range result.Suggestions {
-				log.Printf("   💡 %s", suggestion)
-			}
-		}
-	}
-
-	log.Printf("================================")
-}
@@ -1,89 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/creachadair/command"
-	"github.com/juanfont/headscale/hscontrol/capver"
-)
-
-var (
-	errUnknownSet    = errors.New("unknown --set value (want must|all)")
-	errUnknownFormat = errors.New("unknown --format value (want space|newline|json)")
-)
-
-// ListVersionsConfig holds flags for the list-versions subcommand.
-type ListVersionsConfig struct {
-	Set     string `flag:"set,default=must,Version set: must|all"`
-	Exclude string `flag:"exclude,Comma-separated versions to exclude (e.g. head,unstable)"`
-	Format  string `flag:"format,default=space,Output format: space|newline|json"`
-}
-
-var listVersionsConfig ListVersionsConfig
-
-// listVersions prints the Tailscale versions used by integration tests
-// in a format CI can shell out to. Mirrors integration/scenario.go
-// AllVersions and MustTestVersions: "head" and "unstable" are bare
-// tags, releases get a "v" prefix so each entry can be appended to
-// "ghcr.io/tailscale/tailscale:" directly.
-func listVersions(env *command.Env) error {
-	release := capver.TailscaleLatestMajorMinor(capver.SupportedMajorMinorVersions, true)
-	all := append([]string{"head", "unstable"}, release...)
-	must := append(append([]string{}, all[0:4]...), all[len(all)-2:]...)
-
-	var versions []string
-
-	switch listVersionsConfig.Set {
-	case "must":
-		versions = must
-	case "all":
-		versions = all
-	default:
-		return fmt.Errorf("%w: %q", errUnknownSet, listVersionsConfig.Set)
-	}
-
-	excluded := make(map[string]bool)
-
-	if listVersionsConfig.Exclude != "" {
-		for v := range strings.SplitSeq(listVersionsConfig.Exclude, ",") {
-			excluded[strings.TrimSpace(v)] = true
-		}
-	}
-
-	out := make([]string, 0, len(versions))
-
-	for _, v := range versions {
-		if excluded[v] {
-			continue
-		}
-
-		if v != "head" && v != "unstable" {
-			v = "v" + v
-		}
-
-		out = append(out, v)
-	}
-
-	switch listVersionsConfig.Format {
-	case "space":
-		fmt.Println(strings.Join(out, " "))
-	case "newline":
-		for _, v := range out {
-			fmt.Println(v)
-		}
-	case "json":
-		b, err := json.Marshal(out)
-		if err != nil {
-			return err
-		}
-
-		fmt.Println(string(b))
-	default:
-		return fmt.Errorf("%w: %q", errUnknownFormat, listVersionsConfig.Format)
-	}
-
-	return nil
-}
@@ -1,102 +0,0 @@
-package main
-
-import (
-	"context"
-	"os"
-
-	"github.com/creachadair/command"
-	"github.com/creachadair/flax"
-)
-
-var runConfig RunConfig
-
-func main() {
-	root := command.C{
-		Name: "hi",
-		Help: "Headscale Integration test runner",
-		Commands: []*command.C{
-			{
-				Name:     "run",
-				Help:     "Run integration tests",
-				Usage:    "run [test-pattern] [flags]",
-				SetFlags: command.Flags(flax.MustBind, &runConfig),
-				Run:      runIntegrationTest,
-			},
-			{
-				Name: "doctor",
-				Help: "Check system requirements for running integration tests",
-				Run: func(env *command.Env) error {
-					return runDoctorCheck(env.Context())
-				},
-			},
-			{
-				Name:     "list-versions",
-				Help:     "Print Tailscale versions used by integration tests",
-				Usage:    "list-versions [flags]",
-				SetFlags: command.Flags(flax.MustBind, &listVersionsConfig),
-				Run:      listVersions,
-			},
-			{
-				Name: "clean",
-				Help: "Clean Docker resources",
-				Commands: []*command.C{
-					{
-						Name: "networks",
-						Help: "Prune unused Docker networks",
-						Run: func(env *command.Env) error {
-							return pruneDockerNetworks(env.Context())
-						},
-					},
-					{
-						Name: "images",
-						Help: "Clean old test images",
-						Run: func(env *command.Env) error {
-							return cleanOldImages(env.Context())
-						},
-					},
-					{
-						Name: "containers",
-						Help: "Kill all test containers",
-						Run: func(env *command.Env) error {
-							return killTestContainers(env.Context())
-						},
-					},
-					{
-						Name: "cache",
-						Help: "Clean Go module cache volume",
-						Run: func(env *command.Env) error {
-							return cleanCacheVolume(env.Context())
-						},
-					},
-					{
-						Name: "all",
-						Help: "Run all cleanup operations",
-						Run: func(env *command.Env) error {
-							return cleanAll(env.Context())
-						},
-					},
-				},
-			},
-			command.HelpCommand(nil),
-		},
-	}
-
-	env := root.NewEnv(nil).MergeFlags(true)
-	command.RunOrFail(env, os.Args[1:])
-}
-
-func cleanAll(ctx context.Context) error {
-	for _, step := range []func(context.Context) error{
-		killTestContainers,
-		pruneDockerNetworks,
-		cleanOldImages,
-		cleanCacheVolume,
-	} {
-		err := step(ctx)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
@@ -1,87 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/creachadair/command"
-)
-
-var ErrTestPatternRequired = errors.New("test pattern is required as first argument or use --test flag")
-
-type RunConfig struct {
-	TestPattern   string        `flag:"test,Test pattern to run"`
-	Timeout       time.Duration `flag:"timeout,default=120m,Test timeout"`
-	FailFast      bool          `flag:"failfast,default=true,Stop on first test failure"`
-	UsePostgres   bool          `flag:"postgres,default=false,Use PostgreSQL instead of SQLite"`
-	GoVersion     string        `flag:"go-version,Go version to use (auto-detected from go.mod)"`
-	CleanBefore   bool          `flag:"clean-before,default=true,Clean stale resources before test"`
-	CleanAfter    bool          `flag:"clean-after,default=true,Clean resources after test"`
-	KeepOnFailure bool          `flag:"keep-on-failure,default=false,Keep containers on test failure"`
-	LogsDir       string        `flag:"logs-dir,default=control_logs,Control logs directory"`
-	Verbose       bool          `flag:"verbose,default=false,Verbose output"`
-	Stats         bool          `flag:"stats,default=false,Collect and display container resource usage statistics"`
-	HSMemoryLimit float64       `flag:"hs-memory-limit,default=0,Fail test if any Headscale container exceeds this memory limit in MB (0 = disabled)"`
-	TSMemoryLimit float64       `flag:"ts-memory-limit,default=0,Fail test if any Tailscale container exceeds this memory limit in MB (0 = disabled)"`
-}
-
-// runIntegrationTest executes the integration test workflow.
-func runIntegrationTest(env *command.Env) error {
-	args := env.Args
-	if len(args) > 0 && runConfig.TestPattern == "" {
-		runConfig.TestPattern = args[0]
-	}
-
-	if runConfig.TestPattern == "" {
-		return ErrTestPatternRequired
-	}
-
-	if runConfig.GoVersion == "" {
-		runConfig.GoVersion = detectGoVersion()
-	}
-
-	// Run pre-flight checks
-	if runConfig.Verbose {
-		log.Printf("Running pre-flight system checks...")
-	}
-
-	err := runDoctorCheck(env.Context())
-	if err != nil {
-		return fmt.Errorf("pre-flight checks failed: %w", err)
-	}
-
-	if runConfig.Verbose {
-		log.Printf("Running test: %s", runConfig.TestPattern)
-		log.Printf("Go version: %s", runConfig.GoVersion)
-		log.Printf("Timeout: %s", runConfig.Timeout)
-		log.Printf("Use PostgreSQL: %t", runConfig.UsePostgres)
-	}
-
-	return runTestContainer(env.Context(), &runConfig)
-}
-
-// detectGoVersion reads the Go version from go.mod file.
-func detectGoVersion() string {
-	content, err := os.ReadFile("go.mod")
-	if err != nil {
-		content, err = os.ReadFile(filepath.Join("..", "..", "go.mod"))
-		if err != nil {
-			return "1.26.1"
-		}
-	}
-
-	for line := range strings.Lines(string(content)) {
-		if rest, ok := strings.CutPrefix(line, "go "); ok {
-			if f := strings.Fields(rest); len(f) > 0 {
-				return f[0]
-			}
-		}
-	}
-
-	return "1.26.1"
-}
@@ -1,488 +0,0 @@
-package main
-
-import (
-	"cmp"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
-	"slices"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/events"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/client"
-)
-
-// ErrStatsCollectionAlreadyStarted is returned when trying to start stats collection that is already running.
-var ErrStatsCollectionAlreadyStarted = errors.New("stats collection already started")
-
-// ContainerStats represents statistics for a single container.
-type ContainerStats struct {
-	ContainerID   string
-	ContainerName string
-	Stats         []StatsSample
-	mutex         sync.RWMutex
-}
-
-// StatsSample represents a single stats measurement.
-type StatsSample struct {
-	Timestamp time.Time
-	CPUUsage  float64 // CPU usage percentage
-	MemoryMB  float64 // Memory usage in MB
-}
-
-// StatsCollector manages collection of container statistics.
-type StatsCollector struct {
-	client            *client.Client
-	containers        map[string]*ContainerStats
-	stopChan          chan struct{}
-	wg                sync.WaitGroup
-	mutex             sync.RWMutex
-	collectionStarted bool
-}
-
-// NewStatsCollector creates a new stats collector instance.
-func NewStatsCollector(ctx context.Context) (*StatsCollector, error) {
-	cli, err := createDockerClient(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("creating Docker client: %w", err)
-	}
-
-	return &StatsCollector{
-		client:     cli,
-		containers: make(map[string]*ContainerStats),
-		stopChan:   make(chan struct{}),
-	}, nil
-}
-
-// StartCollection begins monitoring all containers and collecting stats for hs- and ts- containers with matching run ID.
-func (sc *StatsCollector) StartCollection(ctx context.Context, runID string, verbose bool) error {
-	sc.mutex.Lock()
-	defer sc.mutex.Unlock()
-
-	if sc.collectionStarted {
-		return ErrStatsCollectionAlreadyStarted
-	}
-
-	sc.collectionStarted = true
-
-	// Start monitoring existing containers
-	sc.wg.Add(1)
-
-	go sc.monitorExistingContainers(ctx, runID, verbose)
-
-	// Start Docker events monitoring for new containers
-	sc.wg.Add(1)
-
-	go sc.monitorDockerEvents(ctx, runID, verbose)
-
-	if verbose {
-		log.Printf("Started container monitoring for run ID %s", runID)
-	}
-
-	return nil
-}
-
-// StopCollection stops all stats collection.
-func (sc *StatsCollector) StopCollection() {
-	// Check if already stopped without holding lock
-	sc.mutex.RLock()
-
-	if !sc.collectionStarted {
-		sc.mutex.RUnlock()
-		return
-	}
-
-	sc.mutex.RUnlock()
-
-	// Signal stop to all goroutines
-	close(sc.stopChan)
-
-	// Wait for all goroutines to finish
-	sc.wg.Wait()
-
-	// Mark as stopped
-	sc.mutex.Lock()
-	sc.collectionStarted = false
-	sc.mutex.Unlock()
-}
-
-// monitorExistingContainers checks for existing containers that match our criteria.
-func (sc *StatsCollector) monitorExistingContainers(ctx context.Context, runID string, verbose bool) {
-	defer sc.wg.Done()
-
-	containers, err := sc.client.ContainerList(ctx, container.ListOptions{})
-	if err != nil {
-		if verbose {
-			log.Printf("Failed to list existing containers: %v", err)
-		}
-
-		return
-	}
-
-	for _, cont := range containers {
-		if sc.shouldMonitorContainer(cont, runID) {
-			sc.startStatsForContainer(ctx, cont.ID, cont.Names[0], verbose)
-		}
-	}
-}
-
-// monitorDockerEvents listens for container start events and begins monitoring relevant containers.
-func (sc *StatsCollector) monitorDockerEvents(ctx context.Context, runID string, verbose bool) {
-	defer sc.wg.Done()
-
-	filter := filters.NewArgs()
-	filter.Add("type", "container")
-	filter.Add("event", "start")
-
-	eventOptions := events.ListOptions{
-		Filters: filter,
-	}
-
-	events, errs := sc.client.Events(ctx, eventOptions)
-
-	for {
-		select {
-		case <-sc.stopChan:
-			return
-		case <-ctx.Done():
-			return
-		case event := <-events:
-			if event.Type == "container" && event.Action == "start" {
-				// Get container details
-				containerInfo, err := sc.client.ContainerInspect(ctx, event.ID) //nolint:staticcheck // SA1019: use Actor.ID
-				if err != nil {
-					continue
-				}
-
-				// Convert to [types.Container] format for consistency
-				cont := types.Container{ //nolint:staticcheck // SA1019: use container.Summary
-					ID:     containerInfo.ID,
-					Names:  []string{containerInfo.Name},
-					Labels: containerInfo.Config.Labels,
-				}
-
-				if sc.shouldMonitorContainer(cont, runID) {
-					sc.startStatsForContainer(ctx, cont.ID, cont.Names[0], verbose)
-				}
-			}
-		case err := <-errs:
-			if verbose {
-				log.Printf("Error in Docker events stream: %v", err)
-			}
-
-			return
-		}
-	}
-}
-
-// shouldMonitorContainer determines if a container should be monitored.
-func (sc *StatsCollector) shouldMonitorContainer(cont types.Container, runID string) bool { //nolint:staticcheck // SA1019: use container.Summary
-	// Check if it has the correct run ID label
-	if cont.Labels == nil || cont.Labels["hi.run-id"] != runID {
-		return false
-	}
-
-	// Check if it's an hs- or ts- container
-	for _, name := range cont.Names {
-		containerName := strings.TrimPrefix(name, "/")
-		if strings.HasPrefix(containerName, "hs-") || strings.HasPrefix(containerName, "ts-") {
-			return true
-		}
-	}
-
-	return false
-}
-
-// startStatsForContainer begins stats collection for a specific container.
-func (sc *StatsCollector) startStatsForContainer(ctx context.Context, containerID, containerName string, verbose bool) {
-	containerName = strings.TrimPrefix(containerName, "/")
-
-	sc.mutex.Lock()
-	// Check if we're already monitoring this container
-	if _, exists := sc.containers[containerID]; exists {
-		sc.mutex.Unlock()
-		return
-	}
-
-	sc.containers[containerID] = &ContainerStats{
-		ContainerID:   containerID,
-		ContainerName: containerName,
-		Stats:         make([]StatsSample, 0),
-	}
-	sc.mutex.Unlock()
-
-	if verbose {
-		log.Printf("Starting stats collection for container %s (%s)", containerName, containerID[:12])
-	}
-
-	sc.wg.Add(1)
-
-	go sc.collectStatsForContainer(ctx, containerID, verbose)
-}
-
-// collectStatsForContainer collects stats for a specific container using Docker API streaming.
-func (sc *StatsCollector) collectStatsForContainer(ctx context.Context, containerID string, verbose bool) {
-	defer sc.wg.Done()
-
-	// Use Docker API streaming stats - much more efficient than CLI
-	statsResponse, err := sc.client.ContainerStats(ctx, containerID, true)
-	if err != nil {
-		if verbose {
-			log.Printf("Failed to get stats stream for container %s: %v", containerID[:12], err)
-		}
-
-		return
-	}
-	defer statsResponse.Body.Close()
-
-	decoder := json.NewDecoder(statsResponse.Body)
-
-	var prevStats *container.Stats //nolint:staticcheck // SA1019: use StatsResponse
-
-	for {
-		select {
-		case <-sc.stopChan:
-			return
-		case <-ctx.Done():
-			return
-		default:
-			var stats container.Stats //nolint:staticcheck // SA1019: use StatsResponse
-
-			err := decoder.Decode(&stats)
-			if err != nil {
-				// [io.EOF] is expected when container stops or stream ends
-				if err.Error() != "EOF" && verbose {
-					log.Printf("Failed to decode stats for container %s: %v", containerID[:12], err)
-				}
-
-				return
-			}
-
-			// Calculate CPU percentage (only if we have previous stats)
-			var cpuPercent float64
-			if prevStats != nil {
-				cpuPercent = calculateCPUPercent(prevStats, &stats)
-			}
-
-			// Calculate memory usage in MB
-			memoryMB := float64(stats.MemoryStats.Usage) / (1024 * 1024)
-
-			// Store the sample (skip first sample since CPU calculation needs previous stats)
-			if prevStats != nil {
-				// Get container stats reference without holding the main mutex
-				var (
-					containerStats *ContainerStats
-					exists         bool
-				)
-
-				sc.mutex.RLock()
-				containerStats, exists = sc.containers[containerID]
-				sc.mutex.RUnlock()
-
-				if exists && containerStats != nil {
-					containerStats.mutex.Lock()
-					containerStats.Stats = append(containerStats.Stats, StatsSample{
-						Timestamp: time.Now(),
-						CPUUsage:  cpuPercent,
-						MemoryMB:  memoryMB,
-					})
-					containerStats.mutex.Unlock()
-				}
-			}
-
-			// Save current stats for next iteration
-			prevStats = &stats
-		}
-	}
-}
-
-// calculateCPUPercent calculates CPU usage percentage from Docker stats.
-func calculateCPUPercent(prevStats, stats *container.Stats) float64 { //nolint:staticcheck // SA1019: use StatsResponse
-	// CPU calculation based on Docker's implementation
-	cpuDelta := float64(stats.CPUStats.CPUUsage.TotalUsage) - float64(prevStats.CPUStats.CPUUsage.TotalUsage)
-	systemDelta := float64(stats.CPUStats.SystemUsage) - float64(prevStats.CPUStats.SystemUsage)
-
-	if systemDelta > 0 && cpuDelta >= 0 {
-		// Calculate CPU percentage: (container CPU delta / system CPU delta) * number of CPUs * 100
-		numCPUs := float64(len(stats.CPUStats.CPUUsage.PercpuUsage))
-		if numCPUs == 0 {
-			// Fallback: if [PercpuUsage] is not available, assume 1 CPU
-			numCPUs = 1.0
-		}
-
-		return (cpuDelta / systemDelta) * numCPUs * 100.0
-	}
-
-	return 0.0
-}
-
-// ContainerStatsSummary represents summary statistics for a container.
-type ContainerStatsSummary struct {
-	ContainerName string
-	SampleCount   int
-	CPU           StatsSummary
-	Memory        StatsSummary
-}
-
-// MemoryViolation represents a container that exceeded the memory limit.
-type MemoryViolation struct {
-	ContainerName string
-	MaxMemoryMB   float64
-	LimitMB       float64
-}
-
-// StatsSummary represents min, max, and average for a metric.
-type StatsSummary struct {
-	Min     float64
-	Max     float64
-	Average float64
-}
-
-// GetSummary returns a summary of collected statistics.
-func (sc *StatsCollector) GetSummary() []ContainerStatsSummary {
-	// Take snapshot of container references without holding main lock long
-	sc.mutex.RLock()
-
-	containerRefs := make([]*ContainerStats, 0, len(sc.containers))
-	for _, containerStats := range sc.containers {
-		containerRefs = append(containerRefs, containerStats)
-	}
-
-	sc.mutex.RUnlock()
-
-	summaries := make([]ContainerStatsSummary, 0, len(containerRefs))
-
-	for _, containerStats := range containerRefs {
-		containerStats.mutex.RLock()
-		stats := make([]StatsSample, len(containerStats.Stats))
-		copy(stats, containerStats.Stats)
-		containerName := containerStats.ContainerName
-		containerStats.mutex.RUnlock()
-
-		if len(stats) == 0 {
-			continue
-		}
-
-		summary := ContainerStatsSummary{
-			ContainerName: containerName,
-			SampleCount:   len(stats),
-		}
-
-		extract := func(get func(StatsSample) float64) []float64 {
-			values := make([]float64, len(stats))
-			for i, sample := range stats {
-				values[i] = get(sample)
-			}
-
-			return values
-		}
-
-		summary.CPU = calculateStatsSummary(extract(func(s StatsSample) float64 { return s.CPUUsage }))
-		summary.Memory = calculateStatsSummary(extract(func(s StatsSample) float64 { return s.MemoryMB }))
-
-		summaries = append(summaries, summary)
-	}
-
-	// Sort by container name for consistent output
-	slices.SortFunc(summaries, func(a, b ContainerStatsSummary) int {
-		return cmp.Compare(a.ContainerName, b.ContainerName)
-	})
-
-	return summaries
-}
-
-// calculateStatsSummary calculates min, max, and average for a slice of values.
-func calculateStatsSummary(values []float64) StatsSummary {
-	if len(values) == 0 {
-		return StatsSummary{}
-	}
-
-	minVal := values[0]
-	maxVal := values[0]
-	sum := 0.0
-
-	for _, value := range values {
-		minVal = min(minVal, value)
-		maxVal = max(maxVal, value)
-		sum += value
-	}
-
-	return StatsSummary{
-		Min:     minVal,
-		Max:     maxVal,
-		Average: sum / float64(len(values)),
-	}
-}
-
-// PrintSummary prints the statistics summary to the console.
-func (sc *StatsCollector) PrintSummary() {
-	summaries := sc.GetSummary()
-
-	if len(summaries) == 0 {
-		log.Printf("No container statistics collected")
-		return
-	}
-
-	log.Printf("Container Resource Usage Summary:")
-	log.Printf("================================")
-
-	for _, summary := range summaries {
-		log.Printf("Container: %s (%d samples)", summary.ContainerName, summary.SampleCount)
-		log.Printf("  CPU Usage:    Min: %6.2f%%  Max: %6.2f%%  Avg: %6.2f%%",
-			summary.CPU.Min, summary.CPU.Max, summary.CPU.Average)
-		log.Printf("  Memory Usage: Min: %6.1f MB Max: %6.1f MB Avg: %6.1f MB",
-			summary.Memory.Min, summary.Memory.Max, summary.Memory.Average)
-		log.Printf("")
-	}
-}
-
-// CheckMemoryLimits checks if any containers exceeded their memory limits.
-func (sc *StatsCollector) CheckMemoryLimits(hsLimitMB, tsLimitMB float64) []MemoryViolation {
-	if hsLimitMB <= 0 && tsLimitMB <= 0 {
-		return nil
-	}
-
-	summaries := sc.GetSummary()
-
-	var violations []MemoryViolation
-
-	for _, summary := range summaries {
-		var limitMB float64
-		if strings.HasPrefix(summary.ContainerName, "hs-") {
-			limitMB = hsLimitMB
-		} else if strings.HasPrefix(summary.ContainerName, "ts-") {
-			limitMB = tsLimitMB
-		} else {
-			continue // Skip containers that don't match our patterns
-		}
-
-		if limitMB > 0 && summary.Memory.Max > limitMB {
-			violations = append(violations, MemoryViolation{
-				ContainerName: summary.ContainerName,
-				MaxMemoryMB:   summary.Memory.Max,
-				LimitMB:       limitMB,
-			})
-		}
-	}
-
-	return violations
-}
-
-// PrintSummaryAndCheckLimits prints the statistics summary and returns memory violations if any.
-func (sc *StatsCollector) PrintSummaryAndCheckLimits(hsLimitMB, tsLimitMB float64) []MemoryViolation {
-	sc.PrintSummary()
-	return sc.CheckMemoryLimits(hsLimitMB, tsLimitMB)
-}
-
-// Close closes the stats collector and cleans up resources.
-func (sc *StatsCollector) Close() error {
-	sc.StopCollection()
-	return sc.client.Close()
-}
@@ -1,66 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-
-	"github.com/creachadair/command"
-	"github.com/creachadair/flax"
-	"github.com/juanfont/headscale/hscontrol/mapper"
-	"github.com/juanfont/headscale/integration/integrationutil"
-)
-
-type MapConfig struct {
-	Directory string `flag:"directory,Directory to read map responses from"`
-}
-
-var (
-	mapConfig            MapConfig
-	errDirectoryRequired = errors.New("directory is required")
-)
-
-func main() {
-	root := command.C{
-		Name: "mapresponses",
-		Help: "MapResponses is a tool to map and compare map responses from a directory",
-		Commands: []*command.C{
-			{
-				Name:     "online",
-				Help:     "",
-				Usage:    "run [test-pattern] [flags]",
-				SetFlags: command.Flags(flax.MustBind, &mapConfig),
-				Run:      runOnline,
-			},
-			command.HelpCommand(nil),
-		},
-	}
-
-	env := root.NewEnv(nil).MergeFlags(true)
-	command.RunOrFail(env, os.Args[1:])
-}
-
-// runIntegrationTest executes the integration test workflow.
-func runOnline(env *command.Env) error {
-	if mapConfig.Directory == "" {
-		return errDirectoryRequired
-	}
-
-	resps, err := mapper.ReadMapResponsesFromDirectory(mapConfig.Directory)
-	if err != nil {
-		return fmt.Errorf("reading map responses from directory: %w", err)
-	}
-
-	expected := integrationutil.BuildExpectedOnlineMap(resps)
-
-	out, err := json.MarshalIndent(expected, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshaling expected online map: %w", err)
-	}
-
-	os.Stderr.Write(out)
-	os.Stderr.Write([]byte("\n"))
-
-	return nil
-}
@@ -1,221 +0,0 @@
-// vendorhash maintains the Nix SRI hash for the Go module vendor tree
-// and stores it in flakehashes.json alongside a content fingerprint of
-// go.mod and go.sum.
-//
-// Each block records its input fingerprint (goModSum) so that re-runs
-// with no input change are essentially free: the fast path is just a
-// sha256 over two small files. The vendor tree is only re-walked when
-// the fingerprint actually drifts.
-//
-// Subcommands:
-//
-//	vendorhash check   exit non-zero if flakehashes.json is stale
-//	vendorhash update  recompute and rewrite flakehashes.json
-//
-// The JSON schema and [goModFingerprint] algorithm mirror upstream
-// tailscale's tool/updateflakes so a future shared library extraction
-// is straightforward.
-package main
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-
-	"tailscale.com/cmd/nardump/nardump"
-)
-
-const (
-	hashesFile = "flakehashes.json"
-	goModFile  = "go.mod"
-	goSumFile  = "go.sum"
-)
-
-type FlakeHashes struct {
-	Vendor VendorBlock `json:"vendor"`
-}
-
-type VendorBlock struct {
-	GoModSum string `json:"goModSum"`
-	SRI      string `json:"sri"`
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		usage()
-		os.Exit(2)
-	}
-
-	ctx := context.Background()
-
-	var err error
-
-	switch os.Args[1] {
-	case "check":
-		err = cmdCheck(ctx)
-	case "update":
-		err = cmdUpdate(ctx)
-	case "-h", "--help", "help":
-		usage()
-		return
-	default:
-		usage()
-		os.Exit(2)
-	}
-
-	if err != nil {
-		if errors.Is(err, errStale) {
-			os.Exit(1)
-		}
-
-		fmt.Fprintln(os.Stderr, "vendorhash:", err)
-		os.Exit(1)
-	}
-}
-
-func usage() {
-	fmt.Fprintln(os.Stderr, "usage: vendorhash <check|update>")
-}
-
-// errStale signals to [main] that the check found a mismatch; it has
-// already printed a remediation message, so [main] should exit 1
-// silently.
-var errStale = errors.New("vendor hash stale")
-
-// cmdCheck verifies that flakehashes.json matches the current
-// go.mod/go.sum. The fast path (fingerprint unchanged) costs only
-// a sha256 over the two files. On mismatch, it computes the actual
-// SRI so the failure message gives the developer the value to paste
-// (or to run `vendorhash update`).
-func cmdCheck(ctx context.Context) error {
-	hashes, err := loadHashes()
-	if err != nil {
-		return err
-	}
-
-	curFP, err := goModFingerprint()
-	if err != nil {
-		return err
-	}
-
-	if curFP == hashes.Vendor.GoModSum {
-		return nil
-	}
-
-	curSRI, err := hashVendor(ctx)
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintln(os.Stderr, "vendor hash is stale.")
-	fmt.Fprintf(os.Stderr, "  expected goModSum: %s\n", hashes.Vendor.GoModSum)
-	fmt.Fprintf(os.Stderr, "    actual goModSum: %s\n", curFP)
-	fmt.Fprintf(os.Stderr, "       expected sri: %s\n", hashes.Vendor.SRI)
-	fmt.Fprintf(os.Stderr, "         actual sri: %s\n", curSRI)
-	fmt.Fprintln(os.Stderr, "run: go run ./cmd/vendorhash update")
-	// Also emit machine-parseable lines so CI can pick them up.
-	fmt.Printf("expected_sri=%s\n", hashes.Vendor.SRI)
-	fmt.Printf("actual_sri=%s\n", curSRI)
-
-	return errStale
-}
-
-func cmdUpdate(ctx context.Context) error {
-	fp, err := goModFingerprint()
-	if err != nil {
-		return err
-	}
-
-	sri, err := hashVendor(ctx)
-	if err != nil {
-		return err
-	}
-
-	return writeHashes(FlakeHashes{
-		Vendor: VendorBlock{
-			GoModSum: fp,
-			SRI:      sri,
-		},
-	})
-}
-
-// goModFingerprint returns a content fingerprint of go.mod and go.sum
-// that changes whenever either file changes. The byte layout matches
-// upstream tailscale's tool/updateflakes.
-func goModFingerprint() (string, error) {
-	h := sha256.New()
-
-	for _, f := range []string{goModFile, goSumFile} {
-		b, err := os.ReadFile(f)
-		if err != nil {
-			return "", err
-		}
-
-		fmt.Fprintf(h, "%s %d\n", f, len(b))
-		h.Write(b)
-	}
-
-	return "sha256-" + base64.StdEncoding.EncodeToString(h.Sum(nil)), nil
-}
-
-// hashVendor runs `go mod vendor` into a temporary directory and
-// returns the Nix SRI hash of the resulting tree.
-func hashVendor(ctx context.Context) (string, error) {
-	out, err := os.MkdirTemp("", "nar-vendor-")
-	if err != nil {
-		return "", err
-	}
-	// `go mod vendor -o` requires the destination to not already exist.
-	err = os.Remove(out)
-	if err != nil {
-		return "", err
-	}
-
-	defer os.RemoveAll(out)
-
-	cmd := exec.CommandContext(ctx, "go", "mod", "vendor", "-o", out)
-
-	cmd.Env = append(os.Environ(), "GOWORK=off")
-	cmd.Stderr = os.Stderr
-
-	err = cmd.Run()
-	if err != nil {
-		return "", fmt.Errorf("go mod vendor: %w", err)
-	}
-
-	return nardump.SRI(os.DirFS(out))
-}
-
-func loadHashes() (FlakeHashes, error) {
-	var h FlakeHashes
-
-	b, err := os.ReadFile(hashesFile)
-	if err != nil {
-		return h, err
-	}
-
-	err = json.Unmarshal(b, &h)
-	if err != nil {
-		return h, fmt.Errorf("%s: %w", hashesFile, err)
-	}
-
-	return h, nil
-}
-
-func writeHashes(h FlakeHashes) error {
-	b, err := json.MarshalIndent(h, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	b = append(b, '\n')
-
-	// flakehashes.json is committed source read by Nix during evaluation;
-	// world-readable matches every other tracked file in the repo.
-	return os.WriteFile(hashesFile, b, 0o644) //nolint:gosec
-}
@@ -18,52 +18,51 @@ server_url: http://127.0.0.1:8080
 # listen_addr: 0.0.0.0:8080
 listen_addr: 127.0.0.1:8080

-# Address to listen to /metrics and /debug, you may want
-# to keep this endpoint private to your internal network
-# Use an empty value to disable the metrics listener.
+# Address to listen to /metrics, you may want
+# to keep this endpoint private to your internal
+# network
+#
 metrics_listen_addr: 127.0.0.1:9090

-# CIDR(s) of reverse proxies (e.g. 127.0.0.1/32) whose
-# True-Client-IP, X-Real-IP and X-Forwarded-For headers should
-# be honoured. Empty (default) ignores those headers; setting
-# this without a proxy in front lets clients spoof their logged
-# source IP.
-trusted_proxies: []
+# Address to listen for gRPC.
+# gRPC is used for controlling a headscale server
+# remotely with the CLI
+# Note: Remote access _only_ works if you have
+# valid certificates.
+#
+# For production:
+# grpc_listen_addr: 0.0.0.0:50443
+grpc_listen_addr: 127.0.0.1:50443
+
+# Allow the gRPC admin interface to run in INSECURE
+# mode. This is not recommended as the traffic will
+# be unencrypted. Only enable if you know what you
+# are doing.
+grpc_allow_insecure: false

 # The Noise section includes specific configuration for the
 # TS2021 Noise protocol
 noise:
-  # The Noise private key is used to encrypt the traffic between headscale and
-  # Tailscale clients when using the new Noise-based protocol. A missing key
-  # will be automatically generated.
+  # The Noise private key is used to encrypt the
+  # traffic between headscale and Tailscale clients when
+  # using the new Noise-based protocol.
  private_key_path: /var/lib/headscale/noise_private.key

 # List of IP prefixes to allocate tailaddresses from.
 # Each prefix consists of either an IPv4 or IPv6 address,
 # and the associated prefix length, delimited by a slash.
-#
-# WARNING: These prefixes MUST be subsets of the standard Tailscale ranges:
-#   - IPv4: 100.64.0.0/10 (CGNAT range)
-#   - IPv6: fd7a:115c:a1e0::/48 (Tailscale ULA range)
-#
-# Using a SUBSET of these ranges is supported and useful if you want to
-# limit IP allocation to a smaller block (e.g., 100.64.0.0/24).
-#
-# Using ranges OUTSIDE of CGNAT/ULA is NOT supported and will cause
-# undefined behaviour. The Tailscale client has hard-coded assumptions
-# about these ranges and will break in subtle, hard-to-debug ways.
-#
-# See:
-# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33
+# It must be within IP ranges supported by the Tailscale
+# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48.
+# See below:
 # IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71
+# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33
+# Any other range is NOT supported, and it will cause unexpected issues.
 prefixes:
  v4: 100.64.0.0/10
  v6: fd7a:115c:a1e0::/48

  # Strategy used for allocation of IPs to nodes, available options:
-  # - sequential (default): assigns the next free IP from the previous given
-  #   IP. A best-effort approach is used and Headscale might leave holes in the
-  #   IP range or fill up existing holes in the IP range.
+  # - sequential (default): assigns the next free IP from the previous given IP.
  # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand).
  allocation: sequential

@@ -71,7 +70,8 @@ prefixes:
 # connection cannot be established.
 # https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp
 #
-# Headscale needs a list of DERP servers that can be presented to the clients.
+# headscale needs a list of DERP servers that can be presented
+# to the clients.
 derp:
  server:
    # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config
@@ -87,17 +87,16 @@ derp:
    region_code: "headscale"
    region_name: "Headscale Embedded DERP"

-    # Only allow clients associated with this server access
-    verify_clients: true
-
    # Listens over UDP at the configured address for STUN connections - to help with NAT traversal.
    # When the embedded DERP server is enabled stun_listen_addr MUST be defined.
    #
    # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/
    stun_listen_addr: "0.0.0.0:3478"

-    # Private key used to encrypt the traffic between headscale DERP and
-    # Tailscale clients. A missing key will be automatically generated.
+    # Private key used to encrypt the traffic between headscale DERP
+    # and Tailscale clients.
+    # The private key file will be autogenerated if it's missing.
+    #
    private_key_path: /var/lib/headscale/derp_server_private.key

    # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically,
@@ -107,7 +106,7 @@ derp:

    # For better connection stability (especially when using an Exit-Node and DNS is not working),
    # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using:
-    ipv4: 198.51.100.1
+    ipv4: 1.2.3.4
    ipv6: 2001:db8::1

  # List of externally available DERP maps encoded in JSON
@@ -116,9 +115,9 @@ derp:

  # Locally available DERP map files encoded in YAML
  #
-  # This option is mostly interesting for people hosting their own DERP servers:
-  # https://tailscale.com/docs/reference/derp-servers/custom-derp-servers
-  # https://headscale.net/stable/ref/derp/
+  # This option is mostly interesting for people hosting
+  # their own DERP servers:
+  # https://tailscale.com/kb/1118/custom-derp-servers/
  #
  # paths:
  #   - /etc/headscale/derp-example.yaml
@@ -130,50 +129,13 @@ derp:
  auto_update_enabled: true

  # How often should we check for DERP updates?
-  update_frequency: 3h
+  update_frequency: 24h

 # Disables the automatic check for headscale updates on startup
 disable_check_updates: false

-# Node lifecycle configuration.
-node:
-  # Default key expiry for non-tagged nodes, regardless of registration method
-  # (auth key, CLI, web auth). Tagged nodes are exempt and never expire.
-  #
-  # This is the base default. OIDC can override this via oidc.expiry.
-  # If a client explicitly requests a specific expiry, the client value is used.
-  #
-  # Setting the value to "0" means no default expiry (nodes never expire unless
-  # explicitly expired via `headscale nodes expire`).
-  #
-  # Tailscale SaaS uses 180d; set to a positive duration to match that behaviour.
-  #
-  # Default: 0 (no default expiry)
-  expiry: 0
-
-  ephemeral:
-    # Time before an inactive ephemeral node is deleted.
-    inactivity_timeout: 30m
-
-  # HA subnet router health probing.
-  #
-  # When HA routes exist (2+ nodes advertising the same prefix), headscale
-  # pings each HA node every probe_interval via the Noise channel. If a node
-  # fails to respond within probe_timeout it is marked unhealthy and the
-  # primary role moves to the next healthy node. A node that later responds
-  # is marked healthy again but does NOT reclaim primary (avoids flapping).
-  #
-  # Worst-case detection time is probe_interval + probe_timeout (15s default).
-  # No-op when no HA routes exist. Set probe_interval to 0 to disable.
-  routes:
-    ha:
-      # How often to ping HA subnet routers. Set to 0 to disable probing.
-      # Must be >= 2s when enabled.
-      probe_interval: 10s
-
-      # How long to wait for a ping response before marking a node unhealthy.
-      # Must be >= 1s and less than probe_interval.
-      probe_timeout: 5s
+# Time before an inactive ephemeral node is deleted?
+ephemeral_node_inactivity_timeout: 30m

 database:
  # Database type. Available options: sqlite, postgres
@@ -230,12 +192,12 @@ database:
  #   ssl: false

 ### TLS configuration
-# See: https://headscale.net/stable/ref/tls/
-
-## Let's Encrypt / ACME
-# Headscale supports automatically requesting and setting up
+#
+## Let's encrypt / ACME
+#
+# headscale supports automatically requesting and setting up
 # TLS for a domain with Let's Encrypt.
-
+#
 # URL to ACME directory
 acme_url: https://acme-v02.api.letsencrypt.org/directory

@@ -245,13 +207,15 @@ acme_email: ""
 # Domain name to request a TLS certificate for:
 tls_letsencrypt_hostname: ""

-# Path to store certificates and metadata needed by letsencrypt
+# Path to store certificates and metadata needed by
+# letsencrypt
+# For production:
 tls_letsencrypt_cache_dir: /var/lib/headscale/cache

 # Type of ACME challenge to use, currently supported types:
 # HTTP-01 or TLS-ALPN-01
+# See: docs/ref/tls.md for more information
 tls_letsencrypt_challenge_type: HTTP-01
-
 # When HTTP-01 challenge is chosen, letsencrypt must set up a
 # verification endpoint, and it will be listening on:
 # :http = port 80
@@ -262,32 +226,30 @@ tls_cert_path: ""
 tls_key_path: ""

 log:
-  # Valid log levels: panic, fatal, error, warn, info, debug, trace
-  level: info
-
  # Output formatting for logs: text or json
  format: text
+  level: info

 ## Policy
-# Headscale supports a wide range of Tailscale policy features such as ACLs and
-# Grants. Please have a look at their docs to better understand the concepts:
-# ACLs: https://tailscale.com/docs/features/access-control/acls
-# Grants: https://tailscale.com/docs/features/access-control/grants
+# headscale supports Tailscale's ACL policies.
+# Please have a look to their KB to better
+# understand the concepts: https://tailscale.com/kb/1018/acls/
 policy:
  # The mode can be "file" or "database" that defines
-  # where the policies are stored and read from.
+  # where the ACL policies are stored and read from.
  mode: file
-
-  # If the mode is set to "file", the path to a HuJSON file containing policies.
+  # If the mode is set to "file", the path to a
+  # HuJSON file containing ACL policies.
  path: ""

 ## DNS
 #
 # headscale supports Tailscale's DNS configuration and MagicDNS.
-# Please have a look to their docs to better understand the concepts:
+# Please have a look to their KB to better understand the concepts:
 #
-# - https://tailscale.com/docs/features/magicdns
-# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns
+# - https://tailscale.com/kb/1054/dns/
+# - https://tailscale.com/kb/1081/magicdns/
+# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/
 #
 # Please note that for the DNS configuration to have any effect,
 # clients must have the `--accept-dns=true` option enabled. This is the
@@ -297,12 +259,12 @@ policy:
 # Setting _any_ of the configuration and `--accept-dns=true` on the
 # clients will integrate with the DNS manager on the client or
 # overwrite /etc/resolv.conf.
-# https://tailscale.com/docs/reference/faq/dns-resolv-conf
+# https://tailscale.com/kb/1235/resolv-conf
 #
 # If you want stop Headscale from managing the DNS configuration
 # all the fields under `dns` should be set to empty values.
 dns:
-  # Whether to use MagicDNS
+  # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/).
  magic_dns: true

  # Defines the base domain to create the hostnames for MagicDNS.
@@ -312,10 +274,6 @@ dns:
  # `hostname.base_domain` (e.g., _myhost.example.com_).
  base_domain: example.com

-  # Whether to use the local DNS settings of a node or override the local DNS
-  # settings (default) and force the use of Headscale's DNS configuration.
-  override_local_dns: true
-
  # List of DNS servers to expose to clients.
  nameservers:
    global:
@@ -324,13 +282,14 @@ dns:
      - 2606:4700:4700::1111
      - 2606:4700:4700::1001

-      # NextDNS (see https://tailscale.com/docs/integrations/nextdns).
+      # NextDNS (see https://tailscale.com/kb/1218/nextdns/).
      # "abc123" is example NextDNS ID, replace with yours.
      # - https://dns.nextdns.io/abc123

-    # Split DNS (see https://tailscale.com/docs/reference/dns-in-tailscale#restricted-nameservers),
+    # Split DNS (see https://tailscale.com/kb/1054/dns/),
    # a map of domains and which DNS server to use for each.
-    split: {}
+    split:
+      {}
      # foo.bar.com:
      #   - 1.1.1.1
      # darp.headscale.net:
@@ -343,7 +302,7 @@ dns:

  # Extra DNS records
  # so far only A and AAAA records are supported (on the tailscale side)
-  # See: https://headscale.net/stable/ref/dns/
+  # See: docs/ref/dns.md
  extra_records: []
  #   - name: "grafana.myvpn.example.com"
  #     type: "A"
@@ -360,62 +319,50 @@ dns:
 # Note: for production you will want to set this to something like:
 unix_socket: /var/run/headscale/headscale.sock
 unix_socket_permission: "0770"
-
+#
+# headscale supports experimental OpenID connect support,
+# it is still being tested and might have some bugs, please
+# help us test it.
 # OpenID Connect
-# https://headscale.net/stable/ref/oidc/
 # oidc:
-#   # Block startup until the identity provider is available and healthy.
 #   only_start_if_oidc_is_available: true
-#
-#   # OpenID Connect Issuer URL from the identity provider
 #   issuer: "https://your-oidc.issuer.com/path"
-#
-#   # Client ID from the identity provider
 #   client_id: "your-oidc-client-id"
-#
-#   # Client secret generated by the identity provider
-#   # Note: client_secret and client_secret_path are mutually exclusive.
 #   client_secret: "your-oidc-client-secret"
 #   # Alternatively, set `client_secret_path` to read the secret from the file.
 #   # It resolves environment variables, making integration to systemd's
 #   # `LoadCredential` straightforward:
 #   client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret"
+#   # client_secret and client_secret_path are mutually exclusive.
+#
+#   # The amount of time from a node is authenticated with OpenID until it
+#   # expires and needs to reauthenticate.
+#   # Setting the value to "0" will mean no expiry.
+#   expiry: 180d
 #
 #   # Use the expiry from the token received from OpenID when the user logged
-#   # in. This will typically lead to frequent need to reauthenticate and should
-#   # only be enabled if you know what you are doing.
-#   # Note: enabling this will cause `node.expiry` to be ignored for
-#   # OIDC-authenticated nodes.
+#   # in, this will typically lead to frequent need to reauthenticate and should
+#   # only been enabled if you know what you are doing.
+#   # Note: enabling this will cause `oidc.expiry` to be ignored.
 #   use_expiry_from_token: false
 #
-#   # The OIDC scopes to use, defaults to "openid", "profile" and "email".
-#   # Custom scopes can be configured as needed, be sure to always include the
-#   # required "openid" scope.
-#   scope: ["openid", "profile", "email"]
+#   # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query
+#   # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email".
 #
-#   # Only verified email addresses are synchronized to the user profile by
-#   # default. Unverified emails may be allowed in case an identity provider
-#   # does not send the "email_verified: true" claim or email verification is
-#   # not required.
-#   email_verified_required: true
-#
-#   # Provide custom key/value pairs which get sent to the identity provider's
-#   # authorization endpoint.
+#   scope: ["openid", "profile", "email", "custom"]
 #   extra_params:
 #     domain_hint: example.com
 #
-#   # Only accept users whose email domain is part of the allowed_domains list.
+#   # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the
+#   # authentication request will be rejected.
+#
 #   allowed_domains:
 #     - example.com
-#
-#   # Only accept users whose email address is part of the allowed_users list.
-#   allowed_users:
-#     - alice@example.com
-#
-#   # Only accept users which are members of at least one group in the
-#   # allowed_groups list.
+#   # Note: Groups from keycloak have a leading '/'
 #   allowed_groups:
 #     - /headscale
+#   allowed_users:
+#     - alice@example.com
 #
 #   # Optional: PKCE (Proof Key for Code Exchange) configuration
 #   # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow
@@ -424,55 +371,34 @@ unix_socket_permission: "0770"
 #   pkce:
 #     # Enable or disable PKCE support (default: false)
 #     enabled: false
-#
 #     # PKCE method to use:
 #     # - plain: Use plain code verifier
 #     # - S256: Use SHA256 hashed code verifier (default, recommended)
 #     method: S256
+#
+#   # Map legacy users from pre-0.24.0 versions of headscale to the new OIDC users
+#   # by taking the username from the legacy user and matching it with the username
+#   # provided by the OIDC. This is useful when migrating from legacy users to OIDC
+#   # to force them using the unique identifier from the OIDC and to give them a
+#   # proper display name and picture if available.
+#   # Note that this will only work if the username from the legacy user is the same
+#   # and there is a possibility for account takeover should a username have changed
+#   # with the provider.
+#   # Disabling this feature will cause all new logins to be created as new users.
+#   # Note this option will be removed in the future and should be set to false
+#   # on all new installations, or when all users have logged in with OIDC once.
+#   map_legacy_users: true

 # Logtail configuration
-# Logtail is Tailscales logging and auditing infrastructure, it allows the
-# control panel to instruct tailscale nodes to log their activity to a remote
-# server. To disable logging on the client side, please refer to:
-# https://tailscale.com/docs/features/logging#opt-out-of-client-logging
+# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel
+# to instruct tailscale nodes to log their activity to a remote server.
 logtail:
-  # Enable logtail for tailscale nodes of this Headscale instance.
-  # As there is currently no support for overriding the log server in Headscale, this is
+  # Enable logtail for this headscales clients.
+  # As there is currently no support for overriding the log server in headscale, this is
  # disabled by default. Enabling this will make your clients send logs to Tailscale Inc.
  enabled: false

-# Taildrop configuration
-# Taildrop is the file sharing feature of Tailscale, allowing nodes to
-# send files to each other.
-# https://tailscale.com/docs/features/taildrop
-taildrop:
-  # Enable or disable Taildrop tailnet-wide. When disabled, headscale
-  # withholds `https://tailscale.com/cap/file-sharing` from every
-  # node's CapMap.
-  enabled: true
-
-# Default node auto-update behaviour. When enabled, every node's
-# CapMap carries `default-auto-update: [true]` so clients that have
-# not made a local opt-in / opt-out choice run auto-updates by
-# default. Setting it back to false flips the default for future
-# clients; clients that already stored the value locally keep their
-# choice.
-auto_update:
-  enabled: false
-
-# Advanced performance tuning parameters.
-# The defaults are carefully chosen and should rarely need adjustment.
-# Only modify these if you have identified a specific performance issue.
-#
-# tuning:
-#   # Maximum number of pending registration entries in the auth cache.
-#   # Oldest entries are evicted when the cap is reached.
-#   #
-#   # register_cache_max_entries: 1024
-#
-#   # NodeStore write batching configuration.
-#   # The NodeStore batches write operations before rebuilding peer relationships,
-#   # which is computationally expensive. Batching reduces rebuild frequency.
-#   #
-#   # node_store_batch_size: 100
-#   # node_store_batch_timeout: 500ms
+# Enabling this option makes devices prefer a random port for WireGuard traffic over the
+# default static port 41641. This option is intended as a workaround for some buggy
+# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information.
+randomize_client_port: false
@@ -1,7 +1,5 @@
-# If you plan to somehow use headscale, please deploy your own DERP infra.
-# See: https://tailscale.com/docs/reference/derp-servers/custom-derp-servers
+# If you plan to somehow use headscale, please deploy your own DERP infra: https://tailscale.com/kb/1118/custom-derp-servers/
 regions:
-  1: null # Disable DERP region with ID 1
  900:
    regionid: 900
    regioncode: custom
@@ -9,9 +7,9 @@ regions:
    nodes:
      - name: 900a
        regionid: 900
-        hostname: myderp.example.com
-        ipv4: 198.51.100.1
-        ipv6: 2001:db8::1
+        hostname: myderp.mydomain.no
+        ipv4: 123.123.123.123
+        ipv6: "2604:a880:400:d1::828:b001"
        stunport: 0
        stunonly: false
        derpport: 0
@@ -10,7 +10,7 @@ headscale.
 | OpenBSD | Yes                                                                                                   |
 | FreeBSD | Yes                                                                                                   |
 | Windows | Yes (see [docs](../usage/connect/windows.md) and `/windows` on your headscale for more information)   |
-| Android | Yes (see [docs](../usage/connect/android.md) for more information)                                    |
+| Android | Yes (see [docs](../usage/connect/android.md))                                                         |
 | macOS   | Yes (see [docs](../usage/connect/apple.md#macos) and `/apple` on your headscale for more information) |
 | iOS     | Yes (see [docs](../usage/connect/apple.md#ios) and `/apple` on your headscale for more information)   |
 | tvOS    | Yes (see [docs](../usage/connect/apple.md#tvos) and `/apple` on your headscale for more information)  |
@@ -1,3 +1,3 @@
 {%
-include-markdown "../../CONTRIBUTING.md"
+    include-markdown "../../CONTRIBUTING.md"
 %}
@@ -2,12 +2,12 @@

 ## What is the design goal of headscale?

-Headscale aims to implement a self-hosted, open source alternative to the
-[Tailscale](https://tailscale.com/) control server. Headscale's goal is to
-provide self-hosters and hobbyists with an open-source server they can use for
-their projects and labs. It implements a narrow scope, a _single_ Tailscale
-network (tailnet), suitable for a personal use, or a small open-source
-organisation.
+Headscale aims to implement a self-hosted, open source alternative to the [Tailscale](https://tailscale.com/)
+control server.
+Headscale's goal is to provide self-hosters and hobbyists with an open-source
+server they can use for their projects and labs.
+It implements a narrow scope, a _single_ Tailnet, suitable for a personal use, or a small
+open-source organisation.

 ## How can I contribute?

@@ -24,12 +24,9 @@ We are more than happy to exchange emails, or to have dedicated calls before a P

 ## When/Why is Feature X going to be implemented?

-We use [GitHub Milestones to plan for upcoming Headscale releases](https://github.com/juanfont/headscale/milestones).
-Have a look at [our current plan](https://github.com/juanfont/headscale/milestones) to get an idea when a specific
-feature is about to be implemented. The release plan is subject to change at any time.
+We don't know. We might be working on it. If you're interested in contributing, please post a feature request about it.

-If you're interested in contributing, please post a feature request about it. Please be aware that there are a number of
-reasons why we might not accept specific contributions:
+Please be aware that there are a number of reasons why we might not accept specific contributions:

 - It is not possible to implement the feature in a way that makes sense in a self-hosted environment.
 - Given that we are reverse-engineering Tailscale to satisfy our own curiosity, we might be interested in implementing the feature ourselves.
@@ -43,86 +40,22 @@ official releases](../setup/install/official.md) for more information.
 In addition to that, you may use packages provided by the community or from distributions. Learn more in the
 [installation guide using community packages](../setup/install/community.md).

-For convenience, we also [build container images with headscale](../setup/install/container.md). But **please be aware that
+For convenience, we also [build Docker images with headscale](../setup/install/container.md). But **please be aware that
 we don't officially support deploying headscale using Docker**. On our [Discord server](https://discord.gg/c84AZQhmpx)
 we have a "docker-issues" channel where you can ask for Docker-specific help to the community.

-## What is the recommended update path? Can I skip multiple versions while updating?
-
-Please follow the steps outlined in the [upgrade guide](../setup/upgrade.md) to update your existing Headscale
-installation. Its required to update from one stable version to the next (e.g. 0.26.0 → 0.27.1 → 0.28.0) without
-skipping minor versions in between. You should always pick the latest available patch release.
-
-Be sure to check the [changelog](https://github.com/juanfont/headscale/blob/main/CHANGELOG.md) for version specific
-upgrade instructions and breaking changes.
-
-## Scaling / How many clients does Headscale support?
-
-It depends. As often stated, Headscale is not enterprise software and our focus
-is homelabbers and self-hosters. Of course, we do not prevent people from using
-it in a commercial/professional setting and often get questions about scaling.
-
-Please note that when Headscale is developed, performance is not part of the
-consideration as the main audience is considered to be users with a modest
-amount of devices. We focus on correctness and feature parity with Tailscale
-SaaS over time.
-
-To understand if you might be able to use Headscale for your use case, I will
-describe two scenarios in an effort to explain what is the central bottleneck
-of Headscale:
-
-1. An environment with 1000 servers
-
-    - they rarely "move" (change their endpoints)
-    - new nodes are added rarely
-
-1. An environment with 80 laptops/phones (end user devices)
-
-    - nodes move often, e.g. switching from home to office
-
-Headscale calculates a map of all nodes that need to talk to each other,
-creating this "world map" requires a lot of CPU time. When an event that
-requires changes to this map happens, the whole "world" is recalculated, and a
-new "world map" is created for every node in the network.
-
-This means that under certain conditions, Headscale can likely handle 100s
-of devices (maybe more), if there is _little to no change_ happening in the
-network. For example, in Scenario 1, the process of computing the world map is
-extremely demanding due to the size of the network, but when the map has been
-created and the nodes are not changing, the Headscale instance will likely
-return to a very low resource usage until the next time there is an event
-requiring the new map.
-
-In the case of Scenario 2, the process of computing the world map is less
-demanding due to the smaller size of the network, however, the type of nodes
-will likely change frequently, which would lead to a constant resource usage.
-
-Headscale will start to struggle when the two scenarios overlap, e.g. many nodes
-with frequent changes will cause the resource usage to remain constantly high.
-In the worst case scenario, the queue of nodes waiting for their map will grow
-to a point where Headscale never will be able to catch up, and nodes will never
-learn about the current state of the world.
-
-We expect that the performance will improve over time as we improve the code
-base, but it is not a focus. In general, we will never make the tradeoff to make
-things faster on the cost of less maintainable or readable code. We are a small
-team and have to optimise for maintainability.
-
 ## Which database should I use?

 We recommend the use of SQLite as database for headscale:

 - SQLite is simple to setup and easy to use
- It scales well for all of headscale's use cases
+- It scales well for all of headscale's usecases
 - Development and testing happens primarily on SQLite
 - PostgreSQL is still supported, but is considered to be in "maintenance mode"

 The headscale project itself does not provide a tool to migrate from PostgreSQL to SQLite. Please have a look at [the
 related tools documentation](../ref/integration/tools.md) for migration tooling provided by the community.

-The choice of database has little to no impact on the performance of the server,
-see [Scaling / How many clients does Headscale support?](#scaling-how-many-clients-does-headscale-support) for understanding how Headscale spends its resources.
-
 ## Why is my reverse proxy not working with headscale?

 We don't know. We don't use reverse proxies with headscale ourselves, so we don't have any experience with them. We have
@@ -133,81 +66,3 @@ help to the community.
 ## Can I use headscale and tailscale on the same machine?

 Running headscale on a machine that is also in the tailnet can cause problems with subnet routers, traffic relay nodes, and MagicDNS. It might work, but it is not supported.
-
-## Why do two nodes see each other in their status, even if a policy rule allows traffic only in one direction?
-
-A frequent use case is to allow traffic only from one node to another, but not the other way around. For example, the
-workstation of an administrator should be able to connect to all nodes but the nodes themselves shouldn't be able to
-connect back to the administrator's node. Why do all nodes see the administrator's workstation in the output of
-`tailscale status`?
-
-This is essentially how Tailscale works. If traffic is allowed to flow in one direction, then both nodes see each other
-in their output of `tailscale status`. Traffic is still filtered according to the policy, with the exception of
-`tailscale ping` which is always allowed in either direction.
-
-See also <https://tailscale.com/docs/concepts/device-visibility>.
-
-## My policy is stored in the database and Headscale refuses to start due to an invalid policy. How can I recover?
-
-Headscale checks if the policy is valid during startup and refuses to start if it detects an error. The error message
-indicates which part of the policy is invalid. Follow these steps to fix your policy:
-
- Dump the policy to a file: `headscale policy get --bypass-server-and-access-database-directly > policy.json`
- Edit and fixup `policy.json`. Use the command `headscale policy check --file policy.json` to validate the policy.
- Load the modified policy: `headscale policy set --bypass-server-and-access-database-directly --file policy.json`
- Start Headscale as usual.
-
-!!! warning "Full server configuration required"
-
-    The above commands to get/set the policy require a complete server configuration file including database settings. A
-    minimal config to [control Headscale via remote CLI](../ref/api.md#remote-control) is not sufficient. You may use
-    `headscale -c /path/to/config.yaml` to specify the path to an alternative configuration file.
-
-## How can I migrate back to the recommended IP prefixes?
-
-Tailscale only supports the IP prefixes `100.64.0.0/10` and `fd7a:115c:a1e0::/48` or smaller subnets thereof. The
-following steps can be used to migrate from unsupported IP prefixes back to the supported and recommended ones.
-
-!!! warning "Backup and test in a demo environment required"
-
-    The commands below update the IP addresses of all nodes in your tailnet and this might have a severe impact in your
-    specific environment. At a minimum:
-
-    - [Create a backup of your database](../setup/upgrade.md#backup)
-    - Test the commands below in a representive demo environment. This allows to catch subsequent connectivity errors
-      early and see how the tailnet behaves in your specific environment.
-
- Stop Headscale
- Restore the default prefixes in the [configuration file](../ref/configuration.md):
-    ```yaml
-    prefixes:
-      v4: 100.64.0.0/10
-      v6: fd7a:115c:a1e0::/48
-    ```
- Update the `nodes.ipv4` and `nodes.ipv6` columns in the database and assign each node a unique IPv4 and IPv6 address.
-  The following SQL statement assigns IP addresses based on the node ID:
-    ```sql
-    UPDATE nodes
-    SET ipv4=concat('100.64.', id/256, '.', id%256),
-        ipv6=concat('fd7a:115c:a1e0::', format('%x', id));
-    ```
- Update the [policy](../ref/policy.md) to reflect the IP address changes (if any)
- Start Headscale
-
-Nodes should reconnect within a few seconds and pickup their newly assigned IP addresses.
-
-## How can I avoid to send logs to Tailscale Inc?
-
-A Tailscale client [collects logs about its operation and connection attempts with other
-clients](https://tailscale.com/docs/features/logging#client-logs) and sends them to a central log service operated by
-Tailscale Inc.
-
-Headscale, by default, instructs clients to disable log submission to the central log service. This configuration is
-applied by a client once it successfully connected with Headscale. See the configuration option `logtail.enabled` in the
-[configuration file](../ref/configuration.md) for details.
-
-Alternatively, logging can also be disabled on the client side. This is independent of Headscale and opting out of
-client logging disables log submission early during client startup. The configuration is operating system specific and
-is usually achieved by setting the environment variable `TS_NO_LOGS_NO_SUPPORT=true` or by passing the flag
-`--no-logs-no-support` to `tailscaled`. See <https://tailscale.com/docs/features/logging#opt-out-of-client-logging> for
-details.
@@ -2,44 +2,31 @@

 Headscale aims to implement a self-hosted, open source alternative to the Tailscale control server. Headscale's goal is
 to provide self-hosters and hobbyists with an open-source server they can use for their projects and labs. This page
-provides on overview of Headscale's feature and compatibility with the Tailscale control server:
+provides on overview of headscale's feature and compatibility with the Tailscale control server:

 - [x] Full "base" support of Tailscale's features
- [x] [Node registration](../ref/registration.md)
-    - [x] [Web authentication](../ref/registration.md#web-authentication)
-    - [x] [Pre authenticated key](../ref/registration.md#pre-authenticated-key)
- [x] [DNS](../ref/dns.md)
-    - [x] [MagicDNS](https://tailscale.com/docs/features/magicdns)
-    - [x] [Global and restricted nameservers (split DNS)](https://tailscale.com/docs/reference/dns-in-tailscale#nameservers)
-    - [x] [search domains](https://tailscale.com/docs/reference/dns-in-tailscale#search-domains)
-    - [x] [Extra DNS records (Headscale only)](../ref/dns.md#setting-extra-dns-records)
- [x] File sharing
-    - [x] [Taildrive](https://tailscale.com/docs/features/taildrive)
-    - [x] [Taildrop](https://tailscale.com/docs/features/taildrop)
- [x] [Tags](../ref/tags.md)
- [x] [Routes](../ref/routes.md)
-    - [x] [Subnet routers](../ref/routes.md#subnet-router)
-    - [x] [Exit nodes](../ref/routes.md#exit-node)
-    - [x] [Route filtering with Via](https://tailscale.com/docs/features/access-control/grants/grants-via)
+- [x] Node registration
+    - [x] Interactive
+    - [x] Pre authenticated key
+- [x] [DNS](https://tailscale.com/kb/1054/dns)
+    - [x] [MagicDNS](https://tailscale.com/kb/1081/magicdns)
+    - [x] [Global and restricted nameservers (split DNS)](https://tailscale.com/kb/1054/dns#nameservers)
+    - [x] [search domains](https://tailscale.com/kb/1054/dns#search-domains)
+    - [x] [Extra DNS records (headscale only)](../ref/dns.md#setting-extra-dns-records)
+- [x] [Taildrop (File Sharing)](https://tailscale.com/kb/1106/taildrop)
+- [x] Routing advertising (including exit nodes)
 - [x] Dual stack (IPv4 and IPv6)
 - [x] Ephemeral nodes
- [x] Embedded [DERP server](../ref/derp.md)
- [x] [Peer relays](https://tailscale.com/docs/features/peer-relay)
- [x] [Policy](../ref/policy.md) ([GitHub label "policy"](https://github.com/juanfont/headscale/labels/policy%20%F0%9F%93%9D))
-    - [x] ACLs
-    - [x] Grants
-    - [x] Some [Autogroups](../ref/policy.md#autogroups)
-    - [x] [Auto approvers](https://tailscale.com/docs/reference/syntax/policy-file#auto-approvers) for [subnet
-      routers](../ref/routes.md#automatically-approve-routes-of-a-subnet-router) and [exit
-      nodes](../ref/routes.md#automatically-approve-an-exit-node-with-auto-approvers)
-    - [x] [Tailscale SSH](https://tailscale.com/docs/features/tailscale-ssh)
-    - [x] [Node attributes](../ref/policy.md#node-attributes)
-    - [x] [Tests](https://tailscale.com/docs/reference/syntax/policy-file#tests) and
-      [sshTests](https://tailscale.com/docs/reference/syntax/policy-file#ssh-tests)
- [x] [Node registration using Single-Sign-On (OpenID Connect)](../ref/oidc.md) ([GitHub label "OIDC"](https://github.com/juanfont/headscale/labels/OIDC))
+- [x] Embedded [DERP server](https://tailscale.com/kb/1232/derp-servers)
+- [x] Access control lists ([GitHub label "policy"](https://github.com/juanfont/headscale/labels/policy%20%F0%9F%93%9D))
+    - [x] ACL management via API
+    - [x] `autogroup:internet`
+    - [ ] `autogroup:self`
+    - [ ] `autogroup:member`
+* [ ] Node registration using Single-Sign-On (OpenID Connect) ([GitHub label "OIDC"](https://github.com/juanfont/headscale/labels/OIDC))
    - [x] Basic registration
-    - [x] Update user profile from identity provider
+    - [ ] Update user profile from identity provider
+    - [ ] Dynamic ACL support
    - [ ] OIDC groups cannot be used in ACLs
- [ ] [Funnel](https://tailscale.com/docs/features/tailscale-funnel) ([#1040](https://github.com/juanfont/headscale/issues/1040))
- [ ] [Serve](https://tailscale.com/docs/features/tailscale-serve) ([#1234](https://github.com/juanfont/headscale/issues/1921))
- [ ] [Network flow logs](https://tailscale.com/docs/features/logging/network-flow-logs) ([#1687](https://github.com/juanfont/headscale/issues/1687))
+- [ ] [Funnel](https://tailscale.com/kb/1223/funnel) ([#1040](https://github.com/juanfont/headscale/issues/1040))
+- [ ] [Serve](https://tailscale.com/kb/1312/serve) ([#1234](https://github.com/juanfont/headscale/issues/1921))
@@ -2,8 +2,7 @@

 All headscale releases are available on the [GitHub release page](https://github.com/juanfont/headscale/releases). Those
 releases are available as binaries for various platforms and architectures, packages for Debian based systems and source
-code archives. Container images are available on [Docker Hub](https://hub.docker.com/r/headscale/headscale) and
-[GitHub Container Registry](https://github.com/juanfont/headscale/pkgs/container/headscale).
+code archives. Container images are available on [Docker Hub](https://hub.docker.com/r/headscale/headscale).

 An Atom/RSS feed of headscale releases is available [here](https://github.com/juanfont/headscale/releases.atom).

@@ -8,18 +8,18 @@ hide:

 Headscale is an open source, self-hosted implementation of the Tailscale control server.

-This page contains the documentation for the latest version of headscale. Please also check our [FAQ](about/faq.md).
+This page contains the documentation for the latest version of headscale. Please also check our [FAQ](./about/faq.md).

 Join our [Discord server](https://discord.gg/c84AZQhmpx) for a chat and community support.

 ## Design goal

-Headscale aims to implement a self-hosted, open source alternative to the
-[Tailscale](https://tailscale.com/) control server. Headscale's goal is to
-provide self-hosters and hobbyists with an open-source server they can use for
-their projects and labs. It implements a narrow scope, a _single_ Tailscale
-network (tailnet), suitable for a personal use, or a small open-source
-organisation.
+Headscale aims to implement a self-hosted, open source alternative to the Tailscale
+control server.
+Headscale's goal is to provide self-hosters and hobbyists with an open-source
+server they can use for their projects and labs.
+It implements a narrower scope, a single Tailnet, suitable for a personal use, or a small
+open-source organisation.

 ## Supporting headscale

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2" viewBox="0 0 1280 640"><circle cx="141.023" cy="338.36" r="117.472" style="fill:#f8b5cb" transform="matrix(.997276 0 0 1.00556 10.0024 -14.823)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 -3.15847 0)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 -3.15847 115.914)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 148.43 115.914)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 148.851 0)"/><circle cx="805.557" cy="336.915" r="118.199" style="fill:#8d8d8d" transform="matrix(.99196 0 0 1 3.36978 -10.2458)"/><circle cx="805.557" cy="336.915" r="118.199" style="fill:#8d8d8d" transform="matrix(.99196 0 0 1 255.633 -10.2458)"/><path d="M680.282 124.808h-68.093v390.325h68.081v-28.23H640V153.228h40.282v-28.42Z" style="fill:#303030"/><path d="M680.282 124.808h-68.093v390.325h68.081v-28.23H640V153.228h40.282v-28.42Z" style="fill:#303030" transform="matrix(-1 0 0 1 1857.19 0)"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2" viewBox="0 0 1280 640"><circle cx="141.023" cy="338.36" r="117.472" style="fill:#f8b5cb" transform="matrix(.997276 0 0 1.00556 10.0024 -14.823)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 -3.15847 0)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 -3.15847 115.914)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 148.43 115.914)"/><circle cx="352.014" cy="268.302" r="33.095" style="fill:#a2a2a2" transform="matrix(1.01749 0 0 1 148.851 0)"/><circle cx="805.557" cy="336.915" r="118.199" style="fill:#8d8d8d" transform="matrix(.99196 0 0 1 3.36978 -10.2458)"/><circle cx="805.557" cy="336.915" r="118.199" style="fill:#8d8d8d" transform="matrix(.99196 0 0 1 255.633 -10.2458)"/><path d="M680.282 124.808h-68.093v390.325h68.081v-28.23H640V153.228h40.282v-28.42Z" style="fill:#303030"/><path d="M680.282 124.808h-68.093v390.325h68.081v-28.23H640V153.228h40.282v-28.42Z" style="fill:#303030" transform="matrix(-1 0 0 1 1857.19 0)"/></svg>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Florian Preinstorfer	bb34b4ebb8	Set doc version to 0.24.3	2025-03-21 06:49:15 +01:00
Florian Preinstorfer	f0c17ceeb6	Set doc version to 0.24.2	2025-02-02 16:54:17 +01:00
Florian Preinstorfer	8cfc804e07	Set doc version to 0.24.1	2025-02-02 16:51:42 +01:00
Florian Preinstorfer	453b000711	Set doc version to 0.24.0	2025-01-17 17:31:29 +01:00