Fix /machine/map endpoint vulnerability (#2642)

* Improve map auth logic

* Bugfix

* Add comment, improve error message

* noise: make func, get by node

this commit splits the additional validation into a
separate function so it can be reused if we add more
endpoints in the future.

It swaps the check, so we still look up by NodeKey, but before
accepting the connection, we validate the known machinekey from
the db against the noise connection.

The reason for this is that when a node logs in or out, the node key
is replaced and it will no longer be possible to look it up, breaking
reauthentication.

Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com>
Co-authored-by: Kristoffer Dalby <kristoffer@tailscale.com>

.dockerignore

@@ -17,8 +17,3 @@ LICENSE
 .vscode
 
 *.sock
-
-node_modules/
-package-lock.json
-package.json
-

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -6,18 +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

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -16,15 +16,13 @@ body:
   - type: textarea
     attributes:
       label: Description
-      description:
-        A clear and precise description of what new or changed feature you want.
+      description: A clear and precise description of what new or changed feature you want.
     validations:
       required: true
   - type: checkboxes
     attributes:
       label: Contribution
-      description:
-        Are you willing to contribute to the implementation of this feature?
+      description: Are you willing to contribute to the implementation of this feature?
       options:
         - label: I can write the design doc for this feature
           required: false
@@ -33,7 +31,6 @@ body:
   - type: textarea
     attributes:
       label: How can it be implemented?
-      description:
-        Free text for your ideas on how this feature could be implemented.
+      description: Free text for your ideas on how this feature could be implemented.
     validations:
       required: false

.github/workflows/build.yml

@@ -17,12 +17,12 @@ jobs:
     runs-on: ubuntu-latest
     permissions: write-all
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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:
@@ -31,15 +31,10 @@ jobs:
               - '**/*.go'
               - 'integration_test/'
               - 'config-example.yaml'
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
+      - uses: DeterminateSystems/nix-installer-action@main
         if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
+      - uses: DeterminateSystems/magic-nix-cache-action@main
         if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
 
       - name: Run nix build
         id: build
@@ -57,7 +52,7 @@ jobs:
           exit $BUILD_STATUS
 
       - name: Nix gosum diverging
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        uses: actions/github-script@v6
         if: failure() && steps.build.outcome == 'failure'
         with:
           github-token: ${{secrets.GITHUB_TOKEN}}
@@ -69,7 +64,7 @@ jobs:
               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 }}'
             })
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@v4
         if: steps.changed-files.outputs.files == 'true'
         with:
           name: headscale-linux
@@ -88,20 +83,13 @@ jobs:
           - "GOARCH=arm64 GOOS=darwin"
           - "GOARCH=amd64 GOOS=darwin"
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
+      - uses: actions/checkout@v4
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
 
       - name: Run go cross compile
-        run:
-          env ${{ matrix.env }} nix develop --command -- go build -o "headscale"
-          ./cmd/headscale
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        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"

.github/workflows/check-tests.yaml

@@ -10,12 +10,12 @@ jobs:
   check-tests:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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:
@@ -24,15 +24,10 @@ jobs:
               - '**/*.go'
               - 'integration_test/'
               - 'config-example.yaml'
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
+      - uses: DeterminateSystems/nix-installer-action@main
         if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
+      - uses: DeterminateSystems/magic-nix-cache-action@main
         if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
 
       - name: Generate and check integration tests
         if: steps.changed-files.outputs.files == 'true'

.github/workflows/docs-deploy.yml

@@ -21,15 +21,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install python
-        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        uses: actions/setup-python@v5
         with:
           python-version: 3.x
       - name: Setup cache
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+        uses: actions/cache@v4
         with:
           key: ${{ github.ref }}
           path: .cache

.github/workflows/docs-test.yml

@@ -11,13 +11,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@v4
       - name: Install python
-        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        uses: actions/setup-python@v5
         with:
           python-version: 3.x
       - name: Setup cache
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+        uses: actions/cache@v4
         with:
           key: ${{ github.ref }}
           path: .cache

.github/workflows/gh-action-integration-generator.go

@@ -38,12 +38,11 @@ func findTests() []string {
 	return tests
 }
 
-func updateYAML(tests []string, jobName string, testPath string) {
+func updateYAML(tests []string, testPath string) {
 	testsForYq := fmt.Sprintf("[%s]", strings.Join(tests, ", "))
 
 	yqCommand := fmt.Sprintf(
-		"yq eval '.jobs.%s.strategy.matrix.test = %s' %s -i",
-		jobName,
+		"yq eval '.jobs.integration-test.strategy.matrix.test = %s' %s -i",
 		testsForYq,
 		testPath,
 	)
@@ -60,7 +59,7 @@ func updateYAML(tests []string, jobName string, testPath string) {
 		log.Fatalf("failed to run yq command: %s", err)
 	}
 
-	fmt.Printf("YAML file (%s) job %s updated successfully\n", testPath, jobName)
+	fmt.Printf("YAML file (%s) updated successfully\n", testPath)
 }
 
 func main() {
@@ -71,21 +70,5 @@ func main() {
 		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")
+	updateYAML(quotedTests, "./test-integration.yaml")
 }

.github/workflows/gh-actions-updater.yaml

@@ -11,13 +11,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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@64be81ba69383f81f2be476703ea6570c4c8686e # v0.8.1
+        uses: saadmk11/github-actions-version-updater@v0.8.1
         with:
           # [Required] Access token with `workflow` scope.
           token: ${{ secrets.WORKFLOW_SECRET }}

.github/workflows/integration-test-template.yml

@@ -1,95 +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-latest
-    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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        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_test/'
-              - 'config-example.yaml'
-      - name: Tailscale
-        if: ${{ env.HAS_TAILSCALE_SECRET }}
-        uses: tailscale/github-action@6986d2c82a91fbac2949fe01f5bab95cf21b5102 # v3.2.2
-        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: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
-        if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
-        if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
-      - name: Run Integration Test
-        uses: Wandalen/wretry.action@e68c23e6309f2871ca8ae4763e7629b9c258e1ea # v3.8.0
-        if: steps.changed-files.outputs.files == 'true'
-        with:
-          # Our integration tests are started like a thundering herd, often
-          # hitting limits of the various external repositories we depend on
-          # like docker hub. This will retry jobs every 5 min, 10 times,
-          # hopefully letting us avoid manual intervention and restarting jobs.
-          # One could of course argue that we should invest in trying to avoid
-          # this, but currently it seems like a larger investment to be cleverer
-          # about this.
-          # Some of the jobs might still require manual restart as they are really
-          # slow and this will cause them to eventually be killed by Github actions.
-          attempt_delay: 300000 # 5 min
-          attempt_limit: 2
-          command: |
-            nix develop --command -- hi run "^${{ inputs.test }}$" \
-              --timeout=120m \
-              ${{ inputs.postgres_flag }}
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: always() && steps.changed-files.outputs.files == 'true'
-        with:
-          name: ${{ inputs.database_name }}-${{ inputs.test }}-logs
-          path: "control_logs/*/*.log"
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: always() && steps.changed-files.outputs.files == 'true'
-        with:
-          name: ${{ inputs.database_name }}-${{ inputs.test }}-archives
-          path: "control_logs/*/*.tar"
-      - name: Setup a blocking tmux session
-        if: ${{ env.HAS_TAILSCALE_SECRET }}
-        uses: alexellis/block-with-tmux-action@master

.github/workflows/lint.yml

@@ -10,12 +10,12 @@ jobs:
   golangci-lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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:
@@ -24,31 +24,24 @@ jobs:
               - '**/*.go'
               - 'integration_test/'
               - 'config-example.yaml'
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
+      - uses: DeterminateSystems/nix-installer-action@main
         if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
+      - uses: DeterminateSystems/magic-nix-cache-action@main
         if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
 
       - 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}}
-          --format=colored-line-number
+        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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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:
@@ -62,32 +55,21 @@ jobs:
               - '**/*.css'
               - '**/*.scss'
               - '**/*.html'
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
+      - uses: DeterminateSystems/nix-installer-action@main
         if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
+      - uses: DeterminateSystems/magic-nix-cache-action@main
         if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
 
       - 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}
+        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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
+      - 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

.github/workflows/release.yml

@@ -13,30 +13,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Login to DockerHub
-        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GHCR
-        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
 
       - name: Run goreleaser
         run: nix develop --command -- goreleaser release --clean

.github/workflows/stale.yml

@@ -12,17 +12,13 @@ jobs:
       issues: write
       pull-requests: write
     steps:
-      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
+      - 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"

.github/workflows/test-integration.yaml

@@ -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.
@@ -7,7 +7,8 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 jobs:
-  sqlite:
+  integration-test:
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
@@ -21,8 +22,6 @@ jobs:
           - TestACLNamedHostsCanReach
           - TestACLDevice1CanAccessDevice2
           - TestPolicyUpdateWhileRunningWithCLIInDatabase
-          - TestACLAutogroupMember
-          - TestACLAutogroupTagged
           - TestAuthKeyLogoutAndReloginSameUser
           - TestAuthKeyLogoutAndReloginNewUser
           - TestAuthKeyLogoutAndReloginSameUserExpiredKey
@@ -79,23 +78,91 @@ jobs:
           - TestSSHNoSSHConfigured
           - TestSSHIsBlockedInACL
           - TestSSHUserOnlyIsolation
-    uses: ./.github/workflows/integration-test-template.yml
-    with:
-      test: ${{ matrix.test }}
-      postgres_flag: "--postgres=0"
-      database_name: "sqlite"
-  postgres:
-    strategy:
-      fail-fast: false
-      matrix:
-        test:
-          - TestACLAllowUserDst
-          - TestPingAllByIP
-          - TestEphemeral2006DeletedTooQuickly
-          - TestPingAllByIPManyUpDown
-          - TestSubnetRouterMultiNetwork
-    uses: ./.github/workflows/integration-test-template.yml
-    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:
+          # Our integration tests are started like a thundering herd, often
+          # hitting limits of the various external repositories we depend on
+          # like docker hub. This will retry jobs every 5 min, 10 times,
+          # hopefully letting us avoid manual intervention and restarting jobs.
+          # One could of course argue that we should invest in trying to avoid
+          # this, but currently it seems like a larger investment to be cleverer
+          # about this.
+          # Some of the jobs might still require manual restart as they are really
+          # slow and this will cause them to eventually be killed by Github actions.
+          attempt_delay: 300000 # 5 min
+          attempt_limit: 10
+          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

.github/workflows/test.yml

@@ -11,13 +11,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - 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:
@@ -27,15 +27,10 @@ jobs:
               - 'integration_test/'
               - 'config-example.yaml'
 
-      - uses: nixbuild/nix-quick-install-action@889f3180bb5f064ee9e3201428d04ae9e41d54ad # v31
+      - uses: DeterminateSystems/nix-installer-action@main
         if: steps.changed-files.outputs.files == 'true'
-      - uses: nix-community/cache-nix-action@135667ec418502fa5a3598af6fb9eb733888ce6a # v6.1.3
+      - uses: DeterminateSystems/magic-nix-cache-action@main
         if: steps.changed-files.outputs.files == 'true'
-        with:
-          primary-key:
-            nix-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('**/*.nix',
-            '**/flake.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-${{ runner.arch }}
 
       - name: Run tests
         if: steps.changed-files.outputs.files == 'true'

.github/workflows/update-flake.yml

@@ -10,10 +10,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@v4
       - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@21a544727d0c62386e78b4befe52d19ad12692e3 # v17
+        uses: DeterminateSystems/nix-installer-action@main
       - name: Update flake.lock
-        uses: DeterminateSystems/update-flake-lock@428c2b58a4b7414dabd372acb6a03dba1084d3ab # v25
+        uses: DeterminateSystems/update-flake-lock@main
         with:
           pr-title: "Update flake.lock"

.gitignore

@@ -20,9 +20,9 @@ vendor/
 
 dist/
 /headscale
+config.json
 config.yaml
 config*.yaml
-!config-example.yaml
 derp.yaml
 *.hujson
 *.key
@@ -46,9 +46,3 @@ integration_test/etc/config.dump.yaml
 /site
 
 __debug_bin
-
-
-node_modules/
-package-lock.json
-package.json
-

.golangci.yaml

@@ -24,7 +24,6 @@ linters:
     - revive
     - tagliatelle
     - testpackage
-    - varnamelen
     - wrapcheck
     - wsl
   settings:

.goreleaser.yml

@@ -7,7 +7,6 @@ before:
 
 release:
   prerelease: auto
-  draft: true
 
 builds:
   - id: headscale
@@ -64,15 +63,8 @@ nfpms:
     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:
@@ -81,21 +73,15 @@ 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: 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

.prettierignore

@@ -1,5 +1,4 @@
 .github/workflows/test-integration-v2*
 docs/about/features.md
 docs/ref/configuration.md
-docs/ref/oidc.md
 docs/ref/remote-cli.md

CHANGELOG.md

@@ -1,115 +1,11 @@
 # CHANGELOG
 
-## Next
-
-### Database integrity improvements
-
-This release includes a significant database migration that addresses longstanding
-issues with the database schema and data integrity that has accumulated over the
-years. The migration introduces a `schema.sql` file as the source of truth for
-the expected database schema to ensure new migrations that will cause divergence
-does not occur again.
-
-These issues arose from a combination of factors discovered over time: SQLite
-foreign keys not being enforced for many early versions, all migrations being
-run in one large function until version 0.23.0, and inconsistent use of GORM's
-AutoMigrate feature. Moving forward, all new migrations will be explicit SQL
-operations rather than relying on GORM AutoMigrate, and foreign keys will be
-enforced throughout the migration process.
-
-We are only improving SQLite databases with this change - PostgreSQL databases
-are not affected.
-
-Please read the [PR description](https://github.com/juanfont/headscale/pull/2617)
-for more technical details about the issues and solutions.
-
-**SQLite Database Backup Example:**
-```bash
-# Stop headscale
-systemctl stop headscale
-
-# Backup sqlite database
-cp /var/lib/headscale/db.sqlite /var/lib/headscale/db.sqlite.backup
-
-# Backup sqlite WAL/SHM files (if they exist)
-cp /var/lib/headscale/db.sqlite-wal /var/lib/headscale/db.sqlite-wal.backup
-cp /var/lib/headscale/db.sqlite-shm /var/lib/headscale/db.sqlite-shm.backup
-
-# Start headscale (migration will run automatically)
-systemctl start headscale
-```
-
-### BREAKING
-
-- **CLI: Remove deprecated flags**
-  - `--identifier` flag removed - use `--node` or `--user` instead
-  - `--namespace` flag removed - use `--user` instead
-  
-  **Command changes:**
-  ```bash
-  # Before
-  headscale nodes expire --identifier 123
-  headscale nodes rename --identifier 123 new-name
-  headscale nodes delete --identifier 123
-  headscale nodes move --identifier 123 --user 456
-  headscale nodes list-routes --identifier 123
-  
-  # After
-  headscale nodes expire --node 123
-  headscale nodes rename --node 123 new-name
-  headscale nodes delete --node 123
-  headscale nodes move --node 123 --user 456
-  headscale nodes list-routes --node 123
-  
-  # Before
-  headscale users destroy --identifier 123
-  headscale users rename --identifier 123 --new-name john
-  headscale users list --identifier 123
-  
-  # After
-  headscale users destroy --user 123
-  headscale users rename --user 123 --new-name john
-  headscale users list --user 123
-  
-  # Before
-  headscale nodes register --namespace myuser nodekey
-  headscale nodes list --namespace myuser
-  headscale preauthkeys create --namespace myuser
-  
-  # After
-  headscale nodes register --user myuser nodekey
-  headscale nodes list --user myuser
-  headscale preauthkeys create --user myuser
-  ```
-
-- Policy: Zero or empty destination port is no longer allowed
-  [#2606](https://github.com/juanfont/headscale/pull/2606)
-
-### Changes
-
-- **Database schema migration improvements for SQLite**
-  [#2617](https://github.com/juanfont/headscale/pull/2617)
-  - **IMPORTANT: Backup your SQLite database before upgrading**
-  - Introduces safer table renaming migration strategy
-  - Addresses longstanding database integrity issues
-
-- Remove policy v1 code [#2600](https://github.com/juanfont/headscale/pull/2600)
-- Refactor Debian/Ubuntu packaging and drop support for Ubuntu 20.04.
-  [#2614](https://github.com/juanfont/headscale/pull/2614)
-- Support client verify for DERP
-  [#2046](https://github.com/juanfont/headscale/pull/2046)
-- Remove redundant check regarding `noise` config
-  [#2658](https://github.com/juanfont/headscale/pull/2658)
-- Refactor OpenID Connect documentation
-  [#2625](https://github.com/juanfont/headscale/pull/2625)
-- Don't crash if config file is missing
-  [#2656](https://github.com/juanfont/headscale/pull/2656)
-
 ## 0.26.1 (2025-06-06)
 
 ### Changes
 
-- Ensure nodes are matching both node key and machine key when connecting.
+- Ensure nodes are matching both node key and machine key
+  when connecting.
   [#2642](https://github.com/juanfont/headscale/pull/2642)
 
 ## 0.26.0 (2025-05-14)
@@ -227,11 +123,6 @@ working in v1 and not tested might be broken in v2 (and vice versa).
   [#2542](https://github.com/juanfont/headscale/pull/2542)
 - Pre auth key API/CLI now uses ID over username
   [#2542](https://github.com/juanfont/headscale/pull/2542)
-- A non-empty list of global nameservers needs to be specified via
-  `dns.nameservers.global` if the configuration option `dns.override_local_dns`
-  is enabled or is not specified in the configuration file. This aligns with
-  behaviour of tailscale.com.
-  [#2438](https://github.com/juanfont/headscale/pull/2438)
 
 ### Changes
 
@@ -260,8 +151,6 @@ working in v1 and not tested might be broken in v2 (and vice versa).
   [#2438](https://github.com/juanfont/headscale/pull/2438)
 - Add documentation for routes
   [#2496](https://github.com/juanfont/headscale/pull/2496)
-- Add support for `autogroup:member`, `autogroup:tagged`
-  [#2572](https://github.com/juanfont/headscale/pull/2572)
 
 ## 0.25.1 (2025-02-25)
 

CLAUDE.md

@@ -1,395 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Overview
-
-Headscale is an open-source implementation of the Tailscale control server written in Go. It provides self-hosted coordination for Tailscale networks (tailnets), managing node registration, IP allocation, policy enforcement, and DERP routing.
-
-## Development Commands
-
-### Quick Setup
-```bash
-# Recommended: Use Nix for dependency management
-nix develop
-
-# Full development workflow
-make dev  # runs fmt + lint + test + build
-```
-
-### Essential Commands
-```bash
-# Build headscale binary
-make build
-
-# Run tests
-make test
-go test ./...                    # All unit tests
-go test -race ./...              # With race detection
-
-# Run specific integration test
-go run ./cmd/hi run "TestName" --postgres
-
-# Code formatting and linting
-make fmt         # Format all code (Go, docs, proto)
-make lint        # Lint all code (Go, proto)
-make fmt-go      # Format Go code only
-make lint-go     # Lint Go code only
-
-# Protocol buffer generation (after modifying proto/)
-make generate
-
-# Clean build artifacts  
-make clean
-```
-
-### Integration Testing
-```bash
-# Use the hi (Headscale Integration) test runner
-go run ./cmd/hi doctor                    # Check system requirements
-go run ./cmd/hi run "TestPattern"         # Run specific test
-go run ./cmd/hi run "TestPattern" --postgres  # With PostgreSQL backend
-
-# Test artifacts are saved to control_logs/ with logs and debug data
-```
-
-## Project Structure & Architecture
-
-### Top-Level Organization
-
-```
-headscale/
-├── cmd/                    # Command-line applications
-│   ├── headscale/         # Main headscale server binary
-│   └── hi/               # Headscale Integration test runner
-├── hscontrol/            # Core control plane logic
-├── integration/          # End-to-end Docker-based tests
-├── proto/               # Protocol buffer definitions
-├── gen/                 # Generated code (protobuf)
-├── docs/                # Documentation
-└── packaging/           # Distribution packaging
-```
-
-### Core Packages (`hscontrol/`)
-
-**Main Server (`hscontrol/`)**
-- `app.go`: Application setup, dependency injection, server lifecycle
-- `handlers.go`: HTTP/gRPC API endpoints for management operations
-- `grpcv1.go`: gRPC service implementation for headscale API
-- `poll.go`: **Critical** - Handles Tailscale MapRequest/MapResponse protocol
-- `noise.go`: Noise protocol implementation for secure client communication
-- `auth.go`: Authentication flows (web, OIDC, command-line)
-- `oidc.go`: OpenID Connect integration for user authentication
-
-**State Management (`hscontrol/state/`)**
-- `state.go`: Central coordinator for all subsystems (database, policy, IP allocation, DERP)
-- `node_store.go`: **Performance-critical** - In-memory cache with copy-on-write semantics
-- Thread-safe operations with deadlock detection
-- Coordinates between database persistence and real-time operations
-
-**Database Layer (`hscontrol/db/`)**
-- `db.go`: Database abstraction, GORM setup, migration management
-- `node.go`: Node lifecycle, registration, expiration, IP assignment
-- `users.go`: User management, namespace isolation
-- `api_key.go`: API authentication tokens
-- `preauth_keys.go`: Pre-authentication keys for automated node registration
-- `ip.go`: IP address allocation and management
-- `policy.go`: Policy storage and retrieval
-- Schema migrations in `schema.sql` with extensive test data coverage
-
-**Policy Engine (`hscontrol/policy/`)**
-- `policy.go`: Core ACL evaluation logic, HuJSON parsing
-- `v2/`: Next-generation policy system with improved filtering
-- `matcher/`: ACL rule matching and evaluation engine
-- Determines peer visibility, route approval, and network access rules
-- Supports both file-based and database-stored policies
-
-**Network Management (`hscontrol/`)**
-- `derp/`: DERP (Designated Encrypted Relay for Packets) server implementation
-  - NAT traversal when direct connections fail
-  - Fallback relay for firewall-restricted environments
-- `mapper/`: Converts internal Headscale state to Tailscale's wire protocol format
-  - `tail.go`: Tailscale-specific data structure generation
-- `routes/`: Subnet route management and primary route selection
-- `dns/`: DNS record management and MagicDNS implementation
-
-**Utilities & Support (`hscontrol/`)**
-- `types/`: Core data structures, configuration, validation
-- `util/`: Helper functions for networking, DNS, key management
-- `templates/`: Client configuration templates (Apple, Windows, etc.)
-- `notifier/`: Event notification system for real-time updates
-- `metrics.go`: Prometheus metrics collection
-- `capver/`: Tailscale capability version management
-
-### Key Subsystem Interactions
-
-**Node Registration Flow**
-1. **Client Connection**: `noise.go` handles secure protocol handshake
-2. **Authentication**: `auth.go` validates credentials (web/OIDC/preauth)
-3. **State Creation**: `state.go` coordinates IP allocation via `db/ip.go`
-4. **Storage**: `db/node.go` persists node, `NodeStore` caches in memory
-5. **Network Setup**: `mapper/` generates initial Tailscale network map
-
-**Ongoing Operations**
-1. **Poll Requests**: `poll.go` receives periodic client updates
-2. **State Updates**: `NodeStore` maintains real-time node information
-3. **Policy Application**: `policy/` evaluates ACL rules for peer relationships
-4. **Map Distribution**: `mapper/` sends network topology to all affected clients
-
-**Route Management**
-1. **Advertisement**: Clients announce routes via `poll.go` Hostinfo updates
-2. **Storage**: `db/` persists routes, `NodeStore` caches for performance
-3. **Approval**: `policy/` auto-approves routes based on ACL rules
-4. **Distribution**: `routes/` selects primary routes, `mapper/` distributes to peers
-
-### Command-Line Tools (`cmd/`)
-
-**Main Server (`cmd/headscale/`)**
-- `headscale.go`: CLI parsing, configuration loading, server startup
-- Supports daemon mode, CLI operations (user/node management), database operations
-
-**Integration Test Runner (`cmd/hi/`)**
-- `main.go`: Test execution framework with Docker orchestration
-- `run.go`: Individual test execution with artifact collection
-- `doctor.go`: System requirements validation
-- `docker.go`: Container lifecycle management
-- Essential for validating changes against real Tailscale clients
-
-### Generated & External Code
-
-**Protocol Buffers (`proto/` → `gen/`)**
-- Defines gRPC API for headscale management operations
-- Client libraries can generate from these definitions
-- Run `make generate` after modifying `.proto` files
-
-**Integration Testing (`integration/`)**
-- `scenario.go`: Docker test environment setup
-- `tailscale.go`: Tailscale client container management
-- Individual test files for specific functionality areas
-- Real end-to-end validation with network isolation
-
-### Critical Performance Paths
-
-**High-Frequency Operations**
-1. **MapRequest Processing** (`poll.go`): Every 15-60 seconds per client
-2. **NodeStore Reads** (`node_store.go`): Every operation requiring node data
-3. **Policy Evaluation** (`policy/`): On every peer relationship calculation
-4. **Route Lookups** (`routes/`): During network map generation
-
-**Database Write Patterns**
-- **Frequent**: Node heartbeats, endpoint updates, route changes
-- **Moderate**: User operations, policy updates, API key management
-- **Rare**: Schema migrations, bulk operations
-
-### Configuration & Deployment
-
-**Configuration** (`hscontrol/types/config.go`)**
-- Database connection settings (SQLite/PostgreSQL)
-- Network configuration (IP ranges, DNS settings)
-- Policy mode (file vs database)
-- DERP relay configuration
-- OIDC provider settings
-
-**Key Dependencies**
-- **GORM**: Database ORM with migration support
-- **Tailscale Libraries**: Core networking and protocol code
-- **Zerolog**: Structured logging throughout the application
-- **Buf**: Protocol buffer toolchain for code generation
-
-### Development Workflow Integration
-
-The architecture supports incremental development:
-- **Unit Tests**: Focus on individual packages (`*_test.go` files)
-- **Integration Tests**: Validate cross-component interactions
-- **Database Tests**: Extensive migration and data integrity validation
-- **Policy Tests**: ACL rule evaluation and edge cases
-- **Performance Tests**: NodeStore and high-frequency operation validation
-
-## Integration Test System
-
-### Overview
-Integration tests use Docker containers running real Tailscale clients against a Headscale server. Tests validate end-to-end functionality including routing, ACLs, node lifecycle, and network coordination.
-
-### Running Integration Tests
-
-**System Requirements**
-```bash
-# Check if your system is ready
-go run ./cmd/hi doctor
-```
-This verifies Docker, Go, required images, and disk space.
-
-**Test Execution Patterns**
-```bash
-# Run a single test (recommended for development)
-go run ./cmd/hi run "TestSubnetRouterMultiNetwork"
-
-# Run with PostgreSQL backend (for database-heavy tests)
-go run ./cmd/hi run "TestExpireNode" --postgres
-
-# Run multiple tests with pattern matching
-go run ./cmd/hi run "TestSubnet*"
-
-# Run all integration tests (CI/full validation)
-go test ./integration -timeout 30m
-```
-
-**Test Categories & Timing**
-- **Fast tests** (< 2 min): Basic functionality, CLI operations
-- **Medium tests** (2-5 min): Route management, ACL validation  
-- **Slow tests** (5+ min): Node expiration, HA failover
-- **Long-running tests** (10+ min): `TestNodeOnlineStatus` (12 min duration)
-
-### Test Infrastructure
-
-**Docker Setup**
-- Headscale server container with configurable database backend
-- Multiple Tailscale client containers with different versions
-- Isolated networks per test scenario
-- Automatic cleanup after test completion
-
-**Test Artifacts**
-All test runs save artifacts to `control_logs/TIMESTAMP-ID/`:
-```
-control_logs/20250713-213106-iajsux/
-├── hs-testname-abc123.stderr.log     # Headscale server logs
-├── hs-testname-abc123.stdout.log
-├── hs-testname-abc123.db             # Database snapshot
-├── hs-testname-abc123_metrics.txt    # Prometheus metrics
-├── hs-testname-abc123-mapresponses/  # Protocol debug data
-├── ts-client-xyz789.stderr.log       # Tailscale client logs
-├── ts-client-xyz789.stdout.log
-└── ts-client-xyz789_status.json      # Client status dump
-```
-
-### Test Development Guidelines
-
-**Timing Considerations**
-Integration tests involve real network operations and Docker container lifecycle:
-
-```go
-// ❌ Wrong: Immediate assertions after async operations
-client.Execute([]string{"tailscale", "set", "--advertise-routes=10.0.0.0/24"})
-nodes, _ := headscale.ListNodes()
-require.Len(t, nodes[0].GetAvailableRoutes(), 1) // May fail due to timing
-
-// ✅ Correct: Wait for async operations to complete
-client.Execute([]string{"tailscale", "set", "--advertise-routes=10.0.0.0/24"})
-require.EventuallyWithT(t, func(c *assert.CollectT) {
-    nodes, err := headscale.ListNodes()
-    assert.NoError(c, err)
-    assert.Len(c, nodes[0].GetAvailableRoutes(), 1)
-}, 10*time.Second, 100*time.Millisecond, "route should be advertised")
-```
-
-**Common Test Patterns**
-- **Route Advertisement**: Use `EventuallyWithT` for route propagation
-- **Node State Changes**: Wait for NodeStore synchronization  
-- **ACL Policy Changes**: Allow time for policy recalculation
-- **Network Connectivity**: Use ping tests with retries
-
-**Test Data Management**
-```go
-// Node identification: Don't assume array ordering
-expectedRoutes := map[string]string{"1": "10.33.0.0/16"}
-for _, node := range nodes {
-    nodeIDStr := fmt.Sprintf("%d", node.GetId())
-    if route, shouldHaveRoute := expectedRoutes[nodeIDStr]; shouldHaveRoute {
-        // Test the node that should have the route
-    }
-}
-```
-
-### Troubleshooting Integration Tests
-
-**Common Failure Patterns**
-1. **Timing Issues**: Test assertions run before async operations complete
-   - **Solution**: Use `EventuallyWithT` with appropriate timeouts
-   - **Timeout Guidelines**: 3-5s for route operations, 10s for complex scenarios
-
-2. **Infrastructure Problems**: Disk space, Docker issues, network conflicts
-   - **Check**: `go run ./cmd/hi doctor` for system health
-   - **Clean**: Remove old test containers and networks
-
-3. **NodeStore Synchronization**: Tests expecting immediate data availability
-   - **Key Points**: Route advertisements must propagate through poll requests
-   - **Fix**: Wait for NodeStore updates after Hostinfo changes
-
-4. **Database Backend Differences**: SQLite vs PostgreSQL behavior differences
-   - **Use**: `--postgres` flag for database-intensive tests
-   - **Note**: Some timing characteristics differ between backends
-
-**Debugging Failed Tests**
-1. **Check test artifacts** in `control_logs/` for detailed logs
-2. **Examine MapResponse JSON** files for protocol-level debugging
-3. **Review Headscale stderr logs** for server-side error messages
-4. **Check Tailscale client status** for network-level issues
-
-**Resource Management**
-- Tests require significant disk space (each run ~100MB of logs)
-- Docker containers are cleaned up automatically on success
-- Failed tests may leave containers running - clean manually if needed
-- Use `docker system prune` periodically to reclaim space
-
-### Best Practices for Test Modifications
-
-1. **Always test locally** before committing integration test changes
-2. **Use appropriate timeouts** - too short causes flaky tests, too long slows CI
-3. **Clean up properly** - ensure tests don't leave persistent state
-4. **Handle both success and failure paths** in test scenarios
-5. **Document timing requirements** for complex test scenarios
-
-## NodeStore Implementation Details
-
-**Key Insight from Recent Work**: The NodeStore is a critical performance optimization that caches node data in memory while ensuring consistency with the database. When working with route advertisements or node state changes:
-
-1. **Timing Considerations**: Route advertisements need time to propagate from clients to server. Use `require.EventuallyWithT()` patterns in tests instead of immediate assertions.
-
-2. **Synchronization Points**: NodeStore updates happen at specific points like `poll.go:420` after Hostinfo changes. Ensure these are maintained when modifying the polling logic.
-
-3. **Peer Visibility**: The NodeStore's `peersFunc` determines which nodes are visible to each other. Policy-based filtering is separate from monitoring visibility - expired nodes should remain visible for debugging but marked as expired.
-
-## Testing Guidelines
-
-### Integration Test Patterns
-```go
-// Use EventuallyWithT for async operations
-require.EventuallyWithT(t, func(c *assert.CollectT) {
-    nodes, err := headscale.ListNodes()
-    assert.NoError(c, err)
-    // Check expected state
-}, 10*time.Second, 100*time.Millisecond, "description")
-
-// Node route checking by actual node properties, not array position
-var routeNode *v1.Node
-for _, node := range nodes {
-    if nodeIDStr := fmt.Sprintf("%d", node.GetId()); expectedRoutes[nodeIDStr] != "" {
-        routeNode = node
-        break
-    }
-}
-```
-
-### Running Problematic Tests
-- Some tests require significant time (e.g., `TestNodeOnlineStatus` runs for 12 minutes)
-- Infrastructure issues like disk space can cause test failures unrelated to code changes  
-- Use `--postgres` flag when testing database-heavy scenarios
-
-## Important Notes
-
-- **Dependencies**: Use `nix develop` for consistent toolchain (Go, buf, protobuf tools, linting)
-- **Protocol Buffers**: Changes to `proto/` require `make generate` and should be committed separately
-- **Code Style**: Enforced via golangci-lint with golines (width 88) and gofumpt formatting
-- **Database**: Supports both SQLite (development) and PostgreSQL (production/testing)
-- **Integration Tests**: Require Docker and can consume significant disk space
-- **Performance**: NodeStore optimizations are critical for scale - be careful with changes to state management
-
-## Debugging Integration Tests
-
-Test artifacts are preserved in `control_logs/TIMESTAMP-ID/` including:
-- Headscale server logs (stderr/stdout)
-- Tailscale client logs and status
-- Database dumps and network captures
-- MapResponse JSON files for protocol debugging
-
-When tests fail, check these artifacts first before assuming code issues.

CLI_STANDARDIZATION_SUMMARY.md

@@ -1,201 +0,0 @@
-# CLI Standardization Summary
-
-## Changes Made
-
-### 1. Command Naming Standardization
-- **Fixed**: `backfillips` → `backfill-ips` (with backward compat alias)
-- **Fixed**: `dumpConfig` → `dump-config` (with backward compat alias) 
-- **Result**: All commands now use kebab-case consistently
-
-### 2. Flag Standardization
-
-#### Node Commands
-- **Added**: `--node` flag as primary way to specify nodes
-- **Deprecated**: `--identifier` flag (hidden, marked deprecated)
-- **Backward Compatible**: Both flags work, `--identifier` shows deprecation warning
-- **Smart Lookup Ready**: `--node` accepts strings for future name/hostname/IP lookup
-
-#### User Commands  
-- **Updated**: User identification flow prepared for `--user` flag
-- **Maintained**: Existing `--name` and `--identifier` flags for backward compatibility
-
-### 3. Description Consistency
-- **Fixed**: "Api" → "API" throughout
-- **Fixed**: Capitalization consistency in short descriptions
-- **Fixed**: Removed unnecessary periods from short descriptions
-- **Standardized**: "Handle/Manage the X of Headscale" pattern
-
-### 4. Type Consistency
-- **Standardized**: Node IDs use `uint64` consistently
-- **Maintained**: Backward compatibility with existing flag types
-
-## Current Status
-
-### ✅ Completed
-- Command naming (kebab-case)
-- Flag deprecation and aliasing
-- Description standardization  
-- Backward compatibility preservation
-- Helper functions for flag processing
-- **SMART LOOKUP IMPLEMENTATION**:
-  - Enhanced `ListNodesRequest` proto with ID, name, hostname, IP filters
-  - Implemented smart filtering in `ListNodes` gRPC method
-  - Added CLI smart lookup functions for nodes and users
-  - Single match validation with helpful error messages
-  - Automatic detection: ID (numeric) vs IP vs name/hostname/email
-
-### ✅ Smart Lookup Features
-- **Node Lookup**: By ID, hostname, or IP address
-- **User Lookup**: By ID, username, or email address  
-- **Single Match Enforcement**: Errors if 0 or >1 matches found
-- **Helpful Error Messages**: Shows all matches when ambiguous
-- **Full Backward Compatibility**: All existing flags still work
-- **Enhanced List Commands**: Both `nodes list` and `users list` support all filter types
-
-## Breaking Changes
-
-**None.** All changes maintain full backward compatibility through flag aliases and deprecation warnings.
-
-## Implementation Details
-
-### Smart Lookup Algorithm
-
-1. **Input Detection**:
-   ```go
-   if numeric && > 0 -> treat as ID
-   else if contains "@" -> treat as email (users only)  
-   else if valid IP address -> treat as IP (nodes only)
-   else -> treat as name/hostname
-   ```
-
-2. **gRPC Filtering**:
-   - Uses enhanced `ListNodes`/`ListUsers` with specific filters
-   - Server-side filtering for optimal performance
-   - Single transaction per lookup
-
-3. **Match Validation**:
-   - Exactly 1 match: Return ID
-   - 0 matches: Error with "not found" message
-   - >1 matches: Error listing all matches for disambiguation
-
-### Enhanced Proto Definitions
-
-```protobuf
-message ListNodesRequest { 
-  string user = 1;           // existing
-  uint64 id = 2;            // new: filter by ID
-  string name = 3;          // new: filter by hostname  
-  string hostname = 4;      // new: alias for name
-  repeated string ip_addresses = 5; // new: filter by IPs
-}
-```
-
-### Future Enhancements
-
-- **Fuzzy Matching**: Partial name matching with confirmation
-- **Recently Used**: Cache recently accessed nodes/users
-- **Tab Completion**: Shell completion for names/hostnames
-- **Bulk Operations**: Multi-select with pattern matching
-
-## Migration Path for Users
-
-### Now Available (Current Release)
-```bash
-# Old way (still works, shows deprecation warning)
-headscale nodes expire --identifier 123
-
-# New way with smart lookup:
-headscale nodes expire --node 123                    # by ID
-headscale nodes expire --node "my-laptop"           # by hostname  
-headscale nodes expire --node "100.64.0.1"          # by Tailscale IP
-headscale nodes expire --node "192.168.1.100"       # by real IP
-
-# User operations:
-headscale users destroy --user 123                   # by ID
-headscale users destroy --user "alice"               # by username
-headscale users destroy --user "alice@company.com"   # by email
-
-# Enhanced list commands with filtering:
-headscale nodes list --node "laptop"                 # filter nodes by name
-headscale nodes list --ip "100.64.0.1"              # filter nodes by IP
-headscale nodes list --user "alice"                  # filter nodes by user
-headscale users list --user "alice"                  # smart lookup user
-headscale users list --email "@company.com"          # filter by email domain
-headscale users list --name "alice"                  # filter by exact name
-
-# Error handling examples:
-headscale nodes expire --node "laptop"
-# Error: multiple nodes found matching 'laptop': ID=1 name=laptop-alice, ID=2 name=laptop-bob
-
-headscale nodes expire --node "nonexistent" 
-# Error: no node found matching 'nonexistent'
-```
-
-## Command Structure Overview
-
-```
-headscale [global-flags] <command> [command-flags] <subcommand> [subcommand-flags] [args]
-
-Global Flags:
-  --config, -c     config file path
-  --output, -o     output format (json, yaml, json-line)  
-  --force          disable prompts
-
-Commands:
-├── serve
-├── version  
-├── config-test
-├── dump-config (alias: dumpConfig)
-├── mockoidc
-├── generate/
-│   └── private-key
-├── nodes/
-│   ├── list (--user, --tags, --columns)
-│   ├── register (--user, --key) 
-│   ├── list-routes (--node)
-│   ├── expire (--node)
-│   ├── rename (--node) <new-name>
-│   ├── delete (--node)
-│   ├── move (--node, --user)
-│   ├── tag (--node, --tags)
-│   ├── approve-routes (--node, --routes)
-│   └── backfill-ips (alias: backfillips)
-├── users/
-│   ├── create <name> (--display-name, --email, --picture-url)
-│   ├── list (--user, --name, --email, --columns)
-│   ├── destroy (--user|--name|--identifier)
-│   └── rename (--user|--name|--identifier, --new-name)
-├── apikeys/
-│   ├── list
-│   ├── create (--expiration)
-│   ├── expire (--prefix)
-│   └── delete (--prefix)
-├── preauthkeys/
-│   ├── list (--user)
-│   ├── create (--user, --reusable, --ephemeral, --expiration, --tags)
-│   └── expire (--user) <key>
-├── policy/
-│   ├── get
-│   ├── set (--file)
-│   └── check (--file)
-└── debug/
-    └── create-node (--name, --user, --key, --route)
-```
-
-## Deprecated Flags
-
-All deprecated flags continue to work but show warnings:
-
-- `--identifier` → use `--node` (for node commands) or `--user` (for user commands)
-- `--namespace` → use `--user` (already implemented)
-- `dumpConfig` → use `dump-config`
-- `backfillips` → use `backfill-ips`
-
-## Error Handling
-
-Improved error messages provide clear guidance:
-```
-Error: node specifier must be a numeric ID (smart lookup by name/hostname/IP not yet implemented)
-Error: --node flag is required  
-Error: --user flag is required
-```

Makefile

@@ -1,130 +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/*')
-PROTO_SOURCES := $(shell find . -name '*.proto' -not -path './gen/*' -not -path './vendor/*')
-DOC_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,prettier)
-	$(call check_tool,clang-format)
-	$(call check_tool,buf)
-
-# 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
+build:
+	nix build
+
+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
 
-.PHONY: fmt-go
-fmt-go: check-deps $(GO_SOURCES)
-	@echo "Formatting Go code..."
+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-prettier
-fmt-prettier: check-deps $(DOC_SOURCES)
-	@echo "Formatting documentation and config files..."
-	prettier --write '**/*.{ts,js,md,yaml,yml,sass,css,scss,html}'
-	prettier --write --print-width 80 --prose-wrap always CHANGELOG.md
-
-.PHONY: fmt-proto
-fmt-proto: check-deps $(PROTO_SOURCES)
-	@echo "Formatting Protocol Buffer files..."
+fmt-proto:
 	clang-format -i $(PROTO_SOURCES)
 
-# Linting targets
-.PHONY: lint
-lint: lint-go lint-proto
+proto-lint:
+	cd proto/ && go run github.com/bufbuild/buf/cmd/buf lint
 
-.PHONY: lint-go
-lint-go: check-deps $(GO_SOURCES) go.mod go.sum
-	@echo "Linting Go code..."
-	golangci-lint run --timeout 10m
+compress: build
+	upx --brute headscale
 
-.PHONY: lint-proto
-lint-proto: check-deps $(PROTO_SOURCES)
-	@echo "Linting Protocol Buffer files..."
-	cd proto/ && buf lint
-
-# Code generation
-.PHONY: generate
-generate: check-deps $(PROTO_SOURCES)
-	@echo "Generating code from Protocol Buffers..."
+generate:
 	rm -rf gen
 	buf generate proto
-
-# Clean targets
-.PHONY: clean
-clean:
-	rm -rf headscale gen
-
-# Development workflow
-.PHONY: dev
-dev: fmt lint test build
-
-# 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, proto)"
-	@echo "  lint         - Lint all code (Go, proto)"
-	@echo "  generate     - Generate code from Protocol Buffers"
-	@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-prettier - Format documentation only" 
-	@echo "  fmt-proto    - Format Protocol Buffer files only"
-	@echo "  lint-go      - Lint Go code only"
-	@echo "  lint-proto   - Lint Protocol Buffer files 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"

README.md

@@ -11,8 +11,8 @@ 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/)
+* [Documentation for the stable version](https://headscale.net/stable/)
+* [Documentation for the development version](https://headscale.net/development/)
 
 ## What is Tailscale
 
@@ -139,28 +139,15 @@ make test
 To build the program:
 
 ```shell
-make build
+nix build
 ```
 
-### Development workflow
+or
 
-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):**
 ```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">

cmd/headscale/cli/api_key.go

@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"time"
@@ -15,6 +14,11 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
+const (
+	// 90 days.
+	DefaultAPIKeyExpiry = "90d"
+)
+
 func init() {
 	rootCmd.AddCommand(apiKeysCmd)
 	apiKeysCmd.AddCommand(listAPIKeys)
@@ -39,80 +43,75 @@ func init() {
 
 var apiKeysCmd = &cobra.Command{
 	Use:     "apikeys",
-	Short:   "Handle the API keys in Headscale",
+	Short:   "Handle the Api keys in Headscale",
 	Aliases: []string{"apikey", "api"},
 }
 
 var listAPIKeys = &cobra.Command{
 	Use:     "list",
-	Short:   "List the API keys for Headscale",
+	Short:   "List the Api keys for headscale",
 	Aliases: []string{"ls", "show"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.ListApiKeysRequest{}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			response, err := client.ListApiKeys(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Error getting the list of keys: %s", err),
-					output,
-				)
-				return err
-			}
+		request := &v1.ListApiKeysRequest{}
 
-			if output != "" {
-				SuccessOutput(response.GetApiKeys(), "", output)
-				return nil
-			}
-
-			tableData := pterm.TableData{
-				{"ID", "Prefix", "Expiration", "Created"},
-			}
-			for _, key := range response.GetApiKeys() {
-				expiration := "-"
-
-				if key.GetExpiration() != nil {
-					expiration = ColourTime(key.GetExpiration().AsTime())
-				}
-
-				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,
-				)
-				return err
-			}
-			return nil
-		})
+		response, err := client.ListApiKeys(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting the list of keys: %s", err),
+				output,
+			)
+		}
+
+		if output != "" {
+			SuccessOutput(response.GetApiKeys(), "", output)
+		}
+
+		tableData := pterm.TableData{
+			{"ID", "Prefix", "Expiration", "Created"},
+		}
+		for _, key := range response.GetApiKeys() {
+			expiration := "-"
+
+			if key.GetExpiration() != nil {
+				expiration = ColourTime(key.GetExpiration().AsTime())
+			}
+
+			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{
 	Use:   "create",
-	Short: "Create a new API key",
+	Short: "Creates a new Api key",
 	Long: `
 Creates a new Api key, the Api key is only visible on creation
 and cannot be retrieved again.
 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 := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
 		request := &v1.CreateApiKeyRequest{}
 
@@ -125,101 +124,99 @@ If you loose a key, create a new one and revoke (expire) the old one.`,
 				fmt.Sprintf("Could not parse duration: %s\n", err),
 				output,
 			)
-			return
 		}
 
 		expiration := time.Now().UTC().Add(time.Duration(duration))
 
 		request.Expiration = timestamppb.New(expiration)
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			response, err := client.CreateApiKey(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Cannot create Api Key: %s\n", err),
-					output,
-				)
-				return err
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			SuccessOutput(response.GetApiKey(), response.GetApiKey(), output)
-			return nil
-		})
+		response, err := client.CreateApiKey(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create Api Key: %s\n", err),
+				output,
+			)
 		}
+
+		SuccessOutput(response.GetApiKey(), response.GetApiKey(), output)
 	},
 }
 
 var expireAPIKeyCmd = &cobra.Command{
 	Use:     "expire",
-	Short:   "Expire an API key",
+	Short:   "Expire an ApiKey",
 	Aliases: []string{"revoke", "exp", "e"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
+
 		prefix, err := cmd.Flags().GetString("prefix")
 		if err != nil {
-			ErrorOutput(err, fmt.Sprintf("Error getting prefix from CLI flag: %s", err), output)
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting prefix from CLI flag: %s", err),
+				output,
+			)
 		}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.ExpireApiKeyRequest{
-				Prefix: prefix,
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			response, err := client.ExpireApiKey(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Cannot expire Api Key: %s\n", err),
-					output,
-				)
-				return err
-			}
+		request := &v1.ExpireApiKeyRequest{
+			Prefix: prefix,
+		}
 
-			SuccessOutput(response, "Key expired", output)
-			return nil
-		})
+		response, err := client.ExpireApiKey(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot expire Api Key: %s\n", err),
+				output,
+			)
 		}
+
+		SuccessOutput(response, "Key expired", output)
 	},
 }
 
 var deleteAPIKeyCmd = &cobra.Command{
 	Use:     "delete",
-	Short:   "Delete an API key",
+	Short:   "Delete an ApiKey",
 	Aliases: []string{"remove", "del"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
+
 		prefix, err := cmd.Flags().GetString("prefix")
 		if err != nil {
-			ErrorOutput(err, fmt.Sprintf("Error getting prefix from CLI flag: %s", err), output)
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting prefix from CLI flag: %s", err),
+				output,
+			)
 		}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.DeleteApiKeyRequest{
-				Prefix: prefix,
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			response, err := client.DeleteApiKey(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Cannot delete Api Key: %s\n", err),
-					output,
-				)
-				return err
-			}
+		request := &v1.DeleteApiKeyRequest{
+			Prefix: prefix,
+		}
 
-			SuccessOutput(response, "Key deleted", output)
-			return nil
-		})
+		response, err := client.DeleteApiKey(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot delete Api Key: %s\n", err),
+				output,
+			)
 		}
+
+		SuccessOutput(response, "Key deleted", output)
 	},
 }

cmd/headscale/cli/client.go

@@ -1,16 +0,0 @@
-package cli
-
-import (
-	"context"
-
-	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
-)
-
-// WithClient handles gRPC client setup and cleanup, calls fn with client and context
-func WithClient(fn func(context.Context, v1.HeadscaleServiceClient) error) error {
-	ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
-	defer cancel()
-	defer conn.Close()
-
-	return fn(ctx, client)
-}

cmd/headscale/cli/configtest.go

@@ -11,8 +11,8 @@ func init() {
 
 var configTestCmd = &cobra.Command{
 	Use:   "configtest",
-	Short: "Test the configuration",
-	Long:  "Run a test of the configuration and exit",
+	Short: "Test the configuration.",
+	Long:  "Run a test of the configuration and exit.",
 	Run: func(cmd *cobra.Command, args []string) {
 		_, err := newHeadscaleServerWithConfig()
 		if err != nil {

cmd/headscale/cli/configtest_test.go

@@ -1,46 +0,0 @@
-package cli
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestConfigTestCommand(t *testing.T) {
-	// Test that the configtest command exists and is properly configured
-	assert.NotNil(t, configTestCmd)
-	assert.Equal(t, "configtest", configTestCmd.Use)
-	assert.Equal(t, "Test the configuration.", configTestCmd.Short)
-	assert.Equal(t, "Run a test of the configuration and exit.", configTestCmd.Long)
-	assert.NotNil(t, configTestCmd.Run)
-}
-
-func TestConfigTestCommandInRootCommand(t *testing.T) {
-	// Test that configtest is available as a subcommand of root
-	cmd, _, err := rootCmd.Find([]string{"configtest"})
-	require.NoError(t, err)
-	assert.Equal(t, "configtest", cmd.Name())
-	assert.Equal(t, configTestCmd, cmd)
-}
-
-func TestConfigTestCommandHelp(t *testing.T) {
-	// Test that the command has proper help text
-	assert.NotEmpty(t, configTestCmd.Short)
-	assert.NotEmpty(t, configTestCmd.Long)
-	assert.Contains(t, configTestCmd.Short, "configuration")
-	assert.Contains(t, configTestCmd.Long, "test")
-	assert.Contains(t, configTestCmd.Long, "configuration")
-}
-
-// Note: We can't easily test the actual execution of configtest because:
-// 1. It depends on configuration files being present
-// 2. It calls log.Fatal() which would exit the test process
-// 3. It tries to initialize a full Headscale server
-//
-// In a real refactor, we would:
-// 1. Extract the configuration validation logic to a testable function
-// 2. Return errors instead of calling log.Fatal()
-// 3. Accept configuration as a parameter instead of loading from global state
-//
-// For now, we test the command structure and that it's properly wired up.

cmd/headscale/cli/debug.go

@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 
 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
@@ -15,6 +14,11 @@ 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)
 
@@ -25,6 +29,11 @@ func init() {
 	}
 	createNodeCmd.Flags().StringP("user", "u", "", "User")
 
+	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("")
@@ -50,14 +59,17 @@ var createNodeCmd = &cobra.Command{
 	Use:   "create-node",
 	Short: "Create a node that can be registered with `nodes register <>` command",
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
 		user, err := cmd.Flags().GetString("user")
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
-			return
 		}
 
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
 		name, err := cmd.Flags().GetString("name")
 		if err != nil {
 			ErrorOutput(
@@ -65,7 +77,6 @@ var createNodeCmd = &cobra.Command{
 				fmt.Sprintf("Error getting node from flag: %s", err),
 				output,
 			)
-			return
 		}
 
 		registrationID, err := cmd.Flags().GetString("key")
@@ -75,7 +86,6 @@ var createNodeCmd = &cobra.Command{
 				fmt.Sprintf("Error getting key from flag: %s", err),
 				output,
 			)
-			return
 		}
 
 		_, err = types.RegistrationIDFromString(registrationID)
@@ -85,7 +95,6 @@ var createNodeCmd = &cobra.Command{
 				fmt.Sprintf("Failed to parse machine key from flag: %s", err),
 				output,
 			)
-			return
 		}
 
 		routes, err := cmd.Flags().GetStringSlice("route")
@@ -95,32 +104,24 @@ var createNodeCmd = &cobra.Command{
 				fmt.Sprintf("Error getting routes from flag: %s", err),
 				output,
 			)
-			return
 		}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.DebugCreateNodeRequest{
-				Key:    registrationID,
-				Name:   name,
-				User:   user,
-				Routes: routes,
-			}
+		request := &v1.DebugCreateNodeRequest{
+			Key:    registrationID,
+			Name:   name,
+			User:   user,
+			Routes: routes,
+		}
 
-			response, err := client.DebugCreateNode(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Cannot create node: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			SuccessOutput(response.GetNode(), "Node created", output)
-			return nil
-		})
+		response, err := client.DebugCreateNode(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create node: %s", status.Convert(err).Message()),
+				output,
+			)
 		}
+
+		SuccessOutput(response.GetNode(), "Node created", output)
 	},
 }

cmd/headscale/cli/debug_test.go

@@ -1,144 +0,0 @@
-package cli
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestDebugCommand(t *testing.T) {
-	// Test that the debug command exists and is properly configured
-	assert.NotNil(t, debugCmd)
-	assert.Equal(t, "debug", debugCmd.Use)
-	assert.Equal(t, "debug and testing commands", debugCmd.Short)
-	assert.Equal(t, "debug contains extra commands used for debugging and testing headscale", debugCmd.Long)
-}
-
-func TestDebugCommandInRootCommand(t *testing.T) {
-	// Test that debug is available as a subcommand of root
-	cmd, _, err := rootCmd.Find([]string{"debug"})
-	require.NoError(t, err)
-	assert.Equal(t, "debug", cmd.Name())
-	assert.Equal(t, debugCmd, cmd)
-}
-
-func TestCreateNodeCommand(t *testing.T) {
-	// Test that the create-node command exists and is properly configured
-	assert.NotNil(t, createNodeCmd)
-	assert.Equal(t, "create-node", createNodeCmd.Use)
-	assert.Equal(t, "Create a node that can be registered with `nodes register <>` command", createNodeCmd.Short)
-	assert.NotNil(t, createNodeCmd.Run)
-}
-
-func TestCreateNodeCommandInDebugCommand(t *testing.T) {
-	// Test that create-node is available as a subcommand of debug
-	cmd, _, err := rootCmd.Find([]string{"debug", "create-node"})
-	require.NoError(t, err)
-	assert.Equal(t, "create-node", cmd.Name())
-	assert.Equal(t, createNodeCmd, cmd)
-}
-
-func TestCreateNodeCommandFlags(t *testing.T) {
-	// Test that create-node has the required flags
-
-	// Test name flag
-	nameFlag := createNodeCmd.Flags().Lookup("name")
-	assert.NotNil(t, nameFlag)
-	assert.Equal(t, "", nameFlag.Shorthand) // No shorthand for name
-	assert.Equal(t, "", nameFlag.DefValue)
-
-	// Test user flag
-	userFlag := createNodeCmd.Flags().Lookup("user")
-	assert.NotNil(t, userFlag)
-	assert.Equal(t, "u", userFlag.Shorthand)
-
-	// Test key flag
-	keyFlag := createNodeCmd.Flags().Lookup("key")
-	assert.NotNil(t, keyFlag)
-	assert.Equal(t, "k", keyFlag.Shorthand)
-
-	// Test route flag
-	routeFlag := createNodeCmd.Flags().Lookup("route")
-	assert.NotNil(t, routeFlag)
-	assert.Equal(t, "r", routeFlag.Shorthand)
-
-}
-
-func TestCreateNodeCommandRequiredFlags(t *testing.T) {
-	// Test that required flags are marked as required
-	// We can't easily test the actual requirement enforcement without executing the command
-	// But we can test that the flags exist and have the expected properties
-
-	// These flags should be required based on the init() function
-	requiredFlags := []string{"name", "user", "key"}
-
-	for _, flagName := range requiredFlags {
-		flag := createNodeCmd.Flags().Lookup(flagName)
-		assert.NotNil(t, flag, "Required flag %s should exist", flagName)
-	}
-}
-
-func TestErrorType(t *testing.T) {
-	// Test the Error type implementation
-	err := errPreAuthKeyMalformed
-	assert.Equal(t, "key is malformed. expected 64 hex characters with `nodekey` prefix", err.Error())
-	assert.Equal(t, "key is malformed. expected 64 hex characters with `nodekey` prefix", string(err))
-
-	// Test that it implements the error interface
-	var genericErr error = err
-	assert.Equal(t, "key is malformed. expected 64 hex characters with `nodekey` prefix", genericErr.Error())
-}
-
-func TestErrorConstants(t *testing.T) {
-	// Test that error constants are defined properly
-	assert.Equal(t, Error("key is malformed. expected 64 hex characters with `nodekey` prefix"), errPreAuthKeyMalformed)
-}
-
-func TestDebugCommandStructure(t *testing.T) {
-	// Test that debug has create-node as a subcommand
-	found := false
-	for _, subcmd := range debugCmd.Commands() {
-		if subcmd.Name() == "create-node" {
-			found = true
-			break
-		}
-	}
-	assert.True(t, found, "create-node should be a subcommand of debug")
-}
-
-func TestCreateNodeCommandHelp(t *testing.T) {
-	// Test that the command has proper help text
-	assert.NotEmpty(t, createNodeCmd.Short)
-	assert.Contains(t, createNodeCmd.Short, "Create a node")
-	assert.Contains(t, createNodeCmd.Short, "nodes register")
-}
-
-func TestCreateNodeCommandFlagDescriptions(t *testing.T) {
-	// Test that flags have appropriate usage descriptions
-	nameFlag := createNodeCmd.Flags().Lookup("name")
-	assert.Equal(t, "Name", nameFlag.Usage)
-
-	userFlag := createNodeCmd.Flags().Lookup("user")
-	assert.Equal(t, "User", userFlag.Usage)
-
-	keyFlag := createNodeCmd.Flags().Lookup("key")
-	assert.Equal(t, "Key", keyFlag.Usage)
-
-	routeFlag := createNodeCmd.Flags().Lookup("route")
-	assert.Contains(t, routeFlag.Usage, "routes to advertise")
-
-}
-
-// Note: We can't easily test the actual execution of create-node because:
-// 1. It depends on gRPC client configuration
-// 2. It calls SuccessOutput/ErrorOutput which exit the process
-// 3. It requires valid registration keys and user setup
-//
-// In a real refactor, we would:
-// 1. Extract the business logic to testable functions
-// 2. Use dependency injection for the gRPC client
-// 3. Return errors instead of calling ErrorOutput/SuccessOutput
-// 4. Add validation functions that can be tested independently
-//
-// For now, we test the command structure and flag configuration.

cmd/headscale/cli/dump_config.go

@@ -12,10 +12,9 @@ func init() {
 }
 
 var dumpConfigCmd = &cobra.Command{
-	Use:     "dump-config",
-	Short:   "Dump current config to /etc/headscale/config.dump.yaml, integration test only",
-	Aliases: []string{"dumpConfig"},
-	Hidden:  true,
+	Use:    "dumpConfig",
+	Short:  "dump current config to /etc/headscale/config.dump.yaml, integration test only",
+	Hidden: true,
 	Args: func(cmd *cobra.Command, args []string) error {
 		return nil
 	},

cmd/headscale/cli/generate.go

@@ -22,7 +22,7 @@ var generatePrivateKeyCmd = &cobra.Command{
 	Use:   "private-key",
 	Short: "Generate a private key for the headscale server",
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 		machineKey := key.NewMachine()
 
 		machineKeyStr, err := machineKey.MarshalText()

cmd/headscale/cli/generate_test.go

@@ -1,230 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
-)
-
-func TestGenerateCommand(t *testing.T) {
-	// Test that the generate command exists and shows help
-	cmd := &cobra.Command{
-		Use:   "headscale",
-		Short: "headscale - a Tailscale control server",
-	}
-
-	cmd.AddCommand(generateCmd)
-
-	out := new(bytes.Buffer)
-	cmd.SetOut(out)
-	cmd.SetErr(out)
-	cmd.SetArgs([]string{"generate", "--help"})
-
-	err := cmd.Execute()
-	require.NoError(t, err)
-
-	outStr := out.String()
-	assert.Contains(t, outStr, "Generate commands")
-	assert.Contains(t, outStr, "private-key")
-	assert.Contains(t, outStr, "Aliases:")
-	assert.Contains(t, outStr, "gen")
-}
-
-func TestGenerateCommandAlias(t *testing.T) {
-	// Test that the "gen" alias works
-	cmd := &cobra.Command{
-		Use:   "headscale",
-		Short: "headscale - a Tailscale control server",
-	}
-
-	cmd.AddCommand(generateCmd)
-
-	out := new(bytes.Buffer)
-	cmd.SetOut(out)
-	cmd.SetErr(out)
-	cmd.SetArgs([]string{"gen", "--help"})
-
-	err := cmd.Execute()
-	require.NoError(t, err)
-
-	outStr := out.String()
-	assert.Contains(t, outStr, "Generate commands")
-}
-
-func TestGeneratePrivateKeyCommand(t *testing.T) {
-	tests := []struct {
-		name       string
-		args       []string
-		expectJSON bool
-		expectYAML bool
-	}{
-		{
-			name:       "default output",
-			args:       []string{"generate", "private-key"},
-			expectJSON: false,
-			expectYAML: false,
-		},
-		{
-			name:       "json output",
-			args:       []string{"generate", "private-key", "--output", "json"},
-			expectJSON: true,
-			expectYAML: false,
-		},
-		{
-			name:       "yaml output",
-			args:       []string{"generate", "private-key", "--output", "yaml"},
-			expectJSON: false,
-			expectYAML: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Note: This command calls SuccessOutput which exits the process
-			// We can't test the actual execution easily without mocking
-			// Instead, we test the command structure and that it exists
-
-			cmd := &cobra.Command{
-				Use:   "headscale",
-				Short: "headscale - a Tailscale control server",
-			}
-
-			cmd.AddCommand(generateCmd)
-			cmd.PersistentFlags().StringP("output", "o", "", "Output format")
-
-			// Test that the command exists and can be found
-			privateKeyCmd, _, err := cmd.Find([]string{"generate", "private-key"})
-			require.NoError(t, err)
-			assert.Equal(t, "private-key", privateKeyCmd.Name())
-			assert.Equal(t, "Generate a private key for the headscale server", privateKeyCmd.Short)
-		})
-	}
-}
-
-func TestGeneratePrivateKeyHelp(t *testing.T) {
-	cmd := &cobra.Command{
-		Use:   "headscale",
-		Short: "headscale - a Tailscale control server",
-	}
-
-	cmd.AddCommand(generateCmd)
-
-	out := new(bytes.Buffer)
-	cmd.SetOut(out)
-	cmd.SetErr(out)
-	cmd.SetArgs([]string{"generate", "private-key", "--help"})
-
-	err := cmd.Execute()
-	require.NoError(t, err)
-
-	outStr := out.String()
-	assert.Contains(t, outStr, "Generate a private key for the headscale server")
-	assert.Contains(t, outStr, "Usage:")
-}
-
-// Test the key generation logic in isolation (without SuccessOutput/ErrorOutput)
-func TestPrivateKeyGeneration(t *testing.T) {
-	// We can't easily test the full command because it calls SuccessOutput which exits
-	// But we can test that the key generation produces valid output format
-
-	// This is testing the core logic that would be in the command
-	// In a real refactor, we'd extract this to a testable function
-
-	// For now, we can test that the command structure is correct
-	assert.NotNil(t, generatePrivateKeyCmd)
-	assert.Equal(t, "private-key", generatePrivateKeyCmd.Use)
-	assert.Equal(t, "Generate a private key for the headscale server", generatePrivateKeyCmd.Short)
-	assert.NotNil(t, generatePrivateKeyCmd.Run)
-}
-
-func TestGenerateCommandStructure(t *testing.T) {
-	// Test the command hierarchy
-	assert.Equal(t, "generate", generateCmd.Use)
-	assert.Equal(t, "Generate commands", generateCmd.Short)
-	assert.Contains(t, generateCmd.Aliases, "gen")
-
-	// Test that private-key is a subcommand
-	found := false
-	for _, subcmd := range generateCmd.Commands() {
-		if subcmd.Name() == "private-key" {
-			found = true
-			break
-		}
-	}
-	assert.True(t, found, "private-key should be a subcommand of generate")
-}
-
-// Helper function to test output formats (would be used if we refactored the command)
-func validatePrivateKeyOutput(t *testing.T, output string, format string) {
-	switch format {
-	case "json":
-		var result map[string]interface{}
-		err := json.Unmarshal([]byte(output), &result)
-		require.NoError(t, err, "Output should be valid JSON")
-
-		privateKey, exists := result["private_key"]
-		require.True(t, exists, "JSON should contain private_key field")
-
-		keyStr, ok := privateKey.(string)
-		require.True(t, ok, "private_key should be a string")
-		require.NotEmpty(t, keyStr, "private_key should not be empty")
-
-		// Basic validation that it looks like a machine key
-		assert.True(t, strings.HasPrefix(keyStr, "mkey:"), "Machine key should start with mkey:")
-
-	case "yaml":
-		var result map[string]interface{}
-		err := yaml.Unmarshal([]byte(output), &result)
-		require.NoError(t, err, "Output should be valid YAML")
-
-		privateKey, exists := result["private_key"]
-		require.True(t, exists, "YAML should contain private_key field")
-
-		keyStr, ok := privateKey.(string)
-		require.True(t, ok, "private_key should be a string")
-		require.NotEmpty(t, keyStr, "private_key should not be empty")
-
-		assert.True(t, strings.HasPrefix(keyStr, "mkey:"), "Machine key should start with mkey:")
-
-	default:
-		// Default format should just be the key itself
-		assert.True(t, strings.HasPrefix(output, "mkey:"), "Default output should be the machine key")
-		assert.NotContains(t, output, "{", "Default output should not contain JSON")
-		assert.NotContains(t, output, "private_key:", "Default output should not contain YAML structure")
-	}
-}
-
-func TestPrivateKeyOutputFormats(t *testing.T) {
-	// Test cases for different output formats
-	// These test the validation logic we would use after refactoring
-
-	tests := []struct {
-		format string
-		sample string
-	}{
-		{
-			format: "json",
-			sample: `{"private_key": "mkey:abcd1234567890abcd1234567890abcd1234567890abcd1234567890abcd1234"}`,
-		},
-		{
-			format: "yaml",
-			sample: "private_key: mkey:abcd1234567890abcd1234567890abcd1234567890abcd1234567890abcd1234\n",
-		},
-		{
-			format: "",
-			sample: "mkey:abcd1234567890abcd1234567890abcd1234567890abcd1234567890abcd1234",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run("format_"+tt.format, func(t *testing.T) {
-			validatePrivateKeyOutput(t, tt.sample, tt.format)
-		})
-	}
-}

cmd/headscale/cli/mockoidc.go

@@ -2,7 +2,6 @@ package cli
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -15,11 +14,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// 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) }
-
 const (
 	errMockOidcClientIDNotDefined     = Error("MOCKOIDC_CLIENT_ID not defined")
 	errMockOidcClientSecretNotDefined = Error("MOCKOIDC_CLIENT_SECRET not defined")
@@ -74,7 +68,7 @@ func mockOIDC() error {
 
 	userStr := os.Getenv("MOCKOIDC_USERS")
 	if userStr == "" {
-		return errors.New("MOCKOIDC_USERS not defined")
+		return fmt.Errorf("MOCKOIDC_USERS not defined")
 	}
 
 	var users []mockoidc.MockUser

cmd/headscale/cli/policy.go

@@ -1,17 +1,14 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"os"
 
 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
 	"github.com/juanfont/headscale/hscontrol/policy"
-	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-	"tailscale.com/types/views"
 )
 
 func init() {
@@ -41,26 +38,22 @@ var getPolicy = &cobra.Command{
 	Short:   "Print the current ACL Policy",
 	Aliases: []string{"show", "view", "fetch"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.GetPolicyRequest{}
+		request := &v1.GetPolicyRequest{}
 
-			response, err := client.GetPolicy(ctx, request)
-			if err != nil {
-				ErrorOutput(err, fmt.Sprintf("Failed loading ACL Policy: %s", err), output)
-				return err
-			}
-
-			// 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(), "")
-			return nil
-		})
+		response, err := client.GetPolicy(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(err, fmt.Sprintf("Failed loading ACL Policy: %s", err), output)
 		}
+
+		// 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(), "")
 	},
 }
 
@@ -72,36 +65,31 @@ var setPolicy = &cobra.Command{
 	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"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 		policyPath, _ := cmd.Flags().GetString("file")
 
 		f, err := os.Open(policyPath)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error opening the policy file: %s", err), output)
-			return
 		}
 		defer f.Close()
 
 		policyBytes, err := io.ReadAll(f)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error reading the policy file: %s", err), output)
-			return
 		}
 
 		request := &v1.SetPolicyRequest{Policy: string(policyBytes)}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			if _, err := client.SetPolicy(ctx, request); err != nil {
-				ErrorOutput(err, fmt.Sprintf("Failed to set ACL Policy: %s", err), output)
-				return err
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			SuccessOutput(nil, "Policy updated.", "")
-			return nil
-		})
-		if err != nil {
-			return
+		if _, err := client.SetPolicy(ctx, request); err != nil {
+			ErrorOutput(err, fmt.Sprintf("Failed to set ACL Policy: %s", err), output)
 		}
+
+		SuccessOutput(nil, "Policy updated.", "")
 	},
 }
 
@@ -109,26 +97,23 @@ var checkPolicy = &cobra.Command{
 	Use:   "check",
 	Short: "Check the Policy file for errors",
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 		policyPath, _ := cmd.Flags().GetString("file")
 
 		f, err := os.Open(policyPath)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error opening the policy file: %s", err), output)
-			return
 		}
 		defer f.Close()
 
 		policyBytes, err := io.ReadAll(f)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error reading the policy file: %s", err), output)
-			return
 		}
 
-		_, err = policy.NewPolicyManager(policyBytes, nil, views.Slice[types.NodeView]{})
+		_, err = policy.NewPolicyManager(policyBytes, nil, nil)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error parsing the policy file: %s", err), output)
-			return
 		}
 
 		SuccessOutput(nil, "Policy is valid", "")

cmd/headscale/cli/preauthkeys.go

@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -15,10 +14,19 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
+const (
+	DefaultPreAuthKeyExpiry = "1h"
+)
+
 func init() {
 	rootCmd.AddCommand(preauthkeysCmd)
 	preauthkeysCmd.PersistentFlags().Uint64P("user", "u", 0, "User identifier (ID)")
 
+	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("")
@@ -47,85 +55,81 @@ var listPreAuthKeys = &cobra.Command{
 	Short:   "List the preauthkeys for this user",
 	Aliases: []string{"ls", "show"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
 		user, err := cmd.Flags().GetUint64("user")
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
+		}
+
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		request := &v1.ListPreAuthKeysRequest{
+			User: user,
+		}
+
+		response, err := client.ListPreAuthKeys(ctx, request)
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Error getting the list of keys: %s", err),
+				output,
+			)
+
 			return
 		}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.ListPreAuthKeysRequest{
-				User: user,
+		if output != "" {
+			SuccessOutput(response.GetPreAuthKeys(), "", output)
+		}
+
+		tableData := pterm.TableData{
+			{
+				"ID",
+				"Key",
+				"Reusable",
+				"Ephemeral",
+				"Used",
+				"Expiration",
+				"Created",
+				"Tags",
+			},
+		}
+		for _, key := range response.GetPreAuthKeys() {
+			expiration := "-"
+			if key.GetExpiration() != nil {
+				expiration = ColourTime(key.GetExpiration().AsTime())
 			}
 
-			response, err := client.ListPreAuthKeys(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Error getting the list of keys: %s", err),
-					output,
-				)
-				return err
+			aclTags := ""
+
+			for _, tag := range key.GetAclTags() {
+				aclTags += "," + tag
 			}
 
-			if output != "" {
-				SuccessOutput(response.GetPreAuthKeys(), "", output)
-				return nil
-			}
+			aclTags = strings.TrimLeft(aclTags, ",")
 
-			tableData := pterm.TableData{
-				{
-					"ID",
-					"Key",
-					"Reusable",
-					"Ephemeral",
-					"Used",
-					"Expiration",
-					"Created",
-					"Tags",
-				},
-			}
-			for _, key := range response.GetPreAuthKeys() {
-				expiration := "-"
-				if key.GetExpiration() != nil {
-					expiration = ColourTime(key.GetExpiration().AsTime())
-				}
+			tableData = append(tableData, []string{
+				strconv.FormatUint(key.GetId(), 10),
+				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,
+			})
 
-				aclTags := ""
-
-				for _, tag := range key.GetAclTags() {
-					aclTags += "," + tag
-				}
-
-				aclTags = strings.TrimLeft(aclTags, ",")
-
-				tableData = append(tableData, []string{
-					strconv.FormatUint(key.GetId(), 10),
-					key.GetKey(),
-					strconv.FormatBool(key.GetReusable()),
-					strconv.FormatBool(key.GetEphemeral()),
-					strconv.FormatBool(key.GetUsed()),
-					expiration,
-					key.GetCreatedAt().AsTime().Format(HeadscaleDateTimeFormat),
-					aclTags,
-				})
-
-			}
-			err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Failed to render pterm table: %s", err),
-					output,
-				)
-				return err
-			}
-			return nil
-		})
+		}
+		err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Failed to render pterm table: %s", err),
+				output,
+			)
 		}
 	},
 }
@@ -135,12 +139,11 @@ var createPreAuthKeyCmd = &cobra.Command{
 	Short:   "Creates a new preauthkey in the specified user",
 	Aliases: []string{"c", "new"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
 		user, err := cmd.Flags().GetUint64("user")
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
-			return
 		}
 
 		reusable, _ := cmd.Flags().GetBool("reusable")
@@ -163,7 +166,6 @@ var createPreAuthKeyCmd = &cobra.Command{
 				fmt.Sprintf("Could not parse duration: %s\n", err),
 				output,
 			)
-			return
 		}
 
 		expiration := time.Now().UTC().Add(time.Duration(duration))
@@ -174,23 +176,20 @@ var createPreAuthKeyCmd = &cobra.Command{
 
 		request.Expiration = timestamppb.New(expiration)
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			response, err := client.CreatePreAuthKey(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Cannot create Pre Auth Key: %s\n", err),
-					output,
-				)
-				return err
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			SuccessOutput(response.GetPreAuthKey(), response.GetPreAuthKey().GetKey(), output)
-			return nil
-		})
+		response, err := client.CreatePreAuthKey(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot create Pre Auth Key: %s\n", err),
+				output,
+			)
 		}
+
+		SuccessOutput(response.GetPreAuthKey(), response.GetPreAuthKey().GetKey(), output)
 	},
 }
 
@@ -206,34 +205,30 @@ var expirePreAuthKeyCmd = &cobra.Command{
 		return nil
 	},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 		user, err := cmd.Flags().GetUint64("user")
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error getting user: %s", err), output)
-			return
 		}
 
-		err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.ExpirePreAuthKeyRequest{
-				User: user,
-				Key:  args[0],
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			response, err := client.ExpirePreAuthKey(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Cannot expire Pre Auth Key: %s\n", err),
-					output,
-				)
-				return err
-			}
+		request := &v1.ExpirePreAuthKeyRequest{
+			User: user,
+			Key:  args[0],
+		}
 
-			SuccessOutput(response, "Key expired", output)
-			return nil
-		})
+		response, err := client.ExpirePreAuthKey(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot expire Pre Auth Key: %s\n", err),
+				output,
+			)
 		}
+
+		SuccessOutput(response, "Key expired", output)
 	},
 }

cmd/headscale/cli/pterm_style.go

@@ -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)

cmd/headscale/cli/root.go

@@ -14,6 +14,10 @@ import (
 	"github.com/tcnksm/go-latest"
 )
 
+const (
+	deprecateNamespaceMessage = "use --user"
+)
+
 var cfgFile string = ""
 
 func init() {

cmd/headscale/cli/serve.go

@@ -2,12 +2,10 @@ package cli
 
 import (
 	"errors"
-	"fmt"
 	"net/http"
 
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-	"github.com/tailscale/squibble"
 )
 
 func init() {
@@ -23,12 +21,6 @@ var serveCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		app, err := newHeadscaleServerWithConfig()
 		if err != nil {
-			var squibbleErr squibble.ValidationError
-			if errors.As(err, &squibbleErr) {
-				fmt.Printf("SQLite schema failed to validate:\n")
-				fmt.Println(squibbleErr.Diff)
-			}
-
 			log.Fatal().Caller().Err(err).Msg("Error initializing")
 		}
 

cmd/headscale/cli/serve_test.go

@@ -1,70 +0,0 @@
-package cli
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestServeCommand(t *testing.T) {
-	// Test that the serve command exists and is properly configured
-	assert.NotNil(t, serveCmd)
-	assert.Equal(t, "serve", serveCmd.Use)
-	assert.Equal(t, "Launches the headscale server", serveCmd.Short)
-	assert.NotNil(t, serveCmd.Run)
-	assert.NotNil(t, serveCmd.Args)
-}
-
-func TestServeCommandInRootCommand(t *testing.T) {
-	// Test that serve is available as a subcommand of root
-	cmd, _, err := rootCmd.Find([]string{"serve"})
-	require.NoError(t, err)
-	assert.Equal(t, "serve", cmd.Name())
-	assert.Equal(t, serveCmd, cmd)
-}
-
-func TestServeCommandArgs(t *testing.T) {
-	// Test that the Args function is defined and accepts any arguments
-	// The current implementation always returns nil (accepts any args)
-	assert.NotNil(t, serveCmd.Args)
-
-	// Test the args function directly
-	err := serveCmd.Args(serveCmd, []string{})
-	assert.NoError(t, err, "Args function should accept empty arguments")
-
-	err = serveCmd.Args(serveCmd, []string{"extra", "args"})
-	assert.NoError(t, err, "Args function should accept extra arguments")
-}
-
-func TestServeCommandHelp(t *testing.T) {
-	// Test that the command has proper help text
-	assert.NotEmpty(t, serveCmd.Short)
-	assert.Contains(t, serveCmd.Short, "server")
-	assert.Contains(t, serveCmd.Short, "headscale")
-}
-
-func TestServeCommandStructure(t *testing.T) {
-	// Test basic command structure
-	assert.Equal(t, "serve", serveCmd.Name())
-	assert.Equal(t, "Launches the headscale server", serveCmd.Short)
-
-	// Test that it has no subcommands (it's a leaf command)
-	subcommands := serveCmd.Commands()
-	assert.Empty(t, subcommands, "Serve command should not have subcommands")
-}
-
-// Note: We can't easily test the actual execution of serve because:
-// 1. It depends on configuration files being present and valid
-// 2. It calls log.Fatal() which would exit the test process
-// 3. It tries to start an actual HTTP server which would block forever
-// 4. It requires database connections and other infrastructure
-//
-// In a real refactor, we would:
-// 1. Extract server initialization logic to a testable function
-// 2. Use dependency injection for configuration and dependencies
-// 3. Return errors instead of calling log.Fatal()
-// 4. Add graceful shutdown capabilities for testing
-// 5. Allow server startup to be cancelled via context
-//
-// For now, we test the command structure and basic properties.

cmd/headscale/cli/table_filter.go

@@ -1,55 +0,0 @@
-package cli
-
-import (
-	"strings"
-
-	"github.com/pterm/pterm"
-	"github.com/spf13/cobra"
-)
-
-const (
-	HeadscaleDateTimeFormat = "2006-01-02 15:04:05"
-	DefaultAPIKeyExpiry     = "90d"
-	DefaultPreAuthKeyExpiry = "1h"
-)
-
-// FilterTableColumns filters table columns based on --columns flag
-func FilterTableColumns(cmd *cobra.Command, tableData pterm.TableData) pterm.TableData {
-	columns, _ := cmd.Flags().GetString("columns")
-	if columns == "" || len(tableData) == 0 {
-		return tableData
-	}
-
-	headers := tableData[0]
-	wantedColumns := strings.Split(columns, ",")
-
-	// Find column indices
-	var indices []int
-	for _, wanted := range wantedColumns {
-		wanted = strings.TrimSpace(wanted)
-		for i, header := range headers {
-			if strings.EqualFold(header, wanted) {
-				indices = append(indices, i)
-				break
-			}
-		}
-	}
-
-	if len(indices) == 0 {
-		return tableData
-	}
-
-	// Filter all rows
-	filtered := make(pterm.TableData, len(tableData))
-	for i, row := range tableData {
-		newRow := make([]string, len(indices))
-		for j, idx := range indices {
-			if idx < len(row) {
-				newRow[j] = row[idx]
-			}
-		}
-		filtered[i] = newRow
-	}
-
-	return filtered
-}

cmd/headscale/cli/users.go

@@ -1,12 +1,9 @@
 package cli
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"net/url"
-	"strconv"
-	"strings"
 
 	survey "github.com/AlecAivazis/survey/v2"
 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
@@ -17,23 +14,28 @@ import (
 )
 
 func usernameAndIDFlag(cmd *cobra.Command) {
-	cmd.Flags().StringP("user", "u", "", "User identifier (ID, name, or email)")
+	cmd.Flags().Int64P("identifier", "i", -1, "User identifier (ID)")
 	cmd.Flags().StringP("name", "n", "", "Username")
 }
 
-// userIDFromFlag returns the user ID using smart lookup.
-// If no user is specified, it will exit the program with an error.
-func userIDFromFlag(cmd *cobra.Command) uint64 {
-	userID, err := GetUserIdentifier(cmd)
-	if err != nil {
+// usernameAndIDFromFlag returns the username and ID from the flags of the command.
+// 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 {
+		err := errors.New("--name or --identifier flag is required")
 		ErrorOutput(
 			err,
-			"Cannot identify user: "+err.Error(),
-			GetOutputFlag(cmd),
+			fmt.Sprintf(
+				"Cannot rename user: %s",
+				status.Convert(err).Message(),
+			),
+			"",
 		)
 	}
 
-	return userID
+	return uint64(identifier), username
 }
 
 func init() {
@@ -43,18 +45,14 @@ func init() {
 	createUserCmd.Flags().StringP("email", "e", "", "Email")
 	createUserCmd.Flags().StringP("picture-url", "p", "", "Profile picture URL")
 	userCmd.AddCommand(listUsersCmd)
-	// Smart lookup filters - can be used individually or combined
-	listUsersCmd.Flags().StringP("user", "u", "", "Filter by user (ID, name, or email)")
-	listUsersCmd.Flags().Uint64P("id", "", 0, "Filter by user ID")
-	listUsersCmd.Flags().StringP("name", "n", "", "Filter by username")
-	listUsersCmd.Flags().StringP("email", "e", "", "Filter by email address")
-	listUsersCmd.Flags().String("columns", "", "Comma-separated list of columns to display (ID,Name,Username,Email,Created)")
+	usernameAndIDFlag(listUsersCmd)
+	listUsersCmd.Flags().StringP("email", "e", "", "Email")
 	userCmd.AddCommand(destroyUserCmd)
 	usernameAndIDFlag(destroyUserCmd)
 	userCmd.AddCommand(renameUserCmd)
 	usernameAndIDFlag(renameUserCmd)
 	renameUserCmd.Flags().StringP("new-name", "r", "", "New username")
-	renameUserCmd.MarkFlagRequired("new-name")
+	renameNodeCmd.MarkFlagRequired("new-name")
 }
 
 var errMissingParameter = errors.New("missing parameters")
@@ -77,9 +75,16 @@ var createUserCmd = &cobra.Command{
 		return nil
 	},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
+
 		userName := args[0]
 
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
+
+		log.Trace().Interface("client", client).Msg("Obtained gRPC client")
+
 		request := &v1.CreateUserRequest{Name: userName}
 
 		if displayName, _ := cmd.Flags().GetString("display-name"); displayName != "" {
@@ -100,75 +105,64 @@ var createUserCmd = &cobra.Command{
 					),
 					output,
 				)
-				return
 			}
 			request.PictureUrl = pictureURL
 		}
 
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			log.Trace().Interface("client", client).Msg("Obtained gRPC client")
-			log.Trace().Interface("request", request).Msg("Sending CreateUser request")
-
-			response, err := client.CreateUser(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Cannot create user: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			SuccessOutput(response.GetUser(), "User created", output)
-			return nil
-		})
+		log.Trace().Interface("request", request).Msg("Sending CreateUser request")
+		response, err := client.CreateUser(ctx, request)
 		if err != nil {
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf(
+					"Cannot create user: %s",
+					status.Convert(err).Message(),
+				),
+				output,
+			)
 		}
+
+		SuccessOutput(response.GetUser(), "User created", output)
 	},
 }
 
 var destroyUserCmd = &cobra.Command{
-	Use:     "destroy --user USER",
+	Use:     "destroy --identifier ID or --name NAME",
 	Short:   "Destroys a user",
 	Aliases: []string{"delete"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
-		id := userIDFromFlag(cmd)
+		id, username := usernameAndIDFromFlag(cmd)
 		request := &v1.ListUsersRequest{
-			Id: id,
+			Name: username,
+			Id:   id,
 		}
 
-		var user *v1.User
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			users, err := client.ListUsers(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Error: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			if len(users.GetUsers()) != 1 {
-				err := errors.New("Unable to determine user to delete, query returned multiple users, use ID")
-				ErrorOutput(
-					err,
-					"Error: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			user = users.GetUsers()[0]
-			return nil
-		})
+		users, err := client.ListUsers(ctx, request)
 		if err != nil {
-			return
+			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,
+			)
+		}
+
+		user := users.GetUsers()[0]
+
 		confirm := false
 		force, _ := cmd.Flags().GetBool("force")
 		if !force {
@@ -185,24 +179,20 @@ var destroyUserCmd = &cobra.Command{
 		}
 
 		if confirm || force {
-			err = WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-				request := &v1.DeleteUserRequest{Id: user.GetId()}
+			request := &v1.DeleteUserRequest{Id: user.GetId()}
 
-				response, err := client.DeleteUser(ctx, request)
-				if err != nil {
-					ErrorOutput(
-						err,
-						"Cannot destroy user: "+status.Convert(err).Message(),
-						output,
-					)
-					return err
-				}
-				SuccessOutput(response, "User destroyed", output)
-				return nil
-			})
+			response, err := client.DeleteUser(ctx, request)
 			if err != nil {
-				return
+				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)
 		}
@@ -214,76 +204,64 @@ var listUsersCmd = &cobra.Command{
 	Short:   "List all the users",
 	Aliases: []string{"ls", "show"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			request := &v1.ListUsersRequest{}
+		ctx, client, conn, cancel := newHeadscaleCLIWithConfig()
+		defer cancel()
+		defer conn.Close()
 
-			// Check for smart lookup flag first
-			userFlag, _ := cmd.Flags().GetString("user")
-			if userFlag != "" {
-				// Use smart lookup to determine filter type
-				if id, err := strconv.ParseUint(userFlag, 10, 64); err == nil && id > 0 {
-					request.Id = id
-				} else if strings.Contains(userFlag, "@") {
-					request.Email = userFlag
-				} else {
-					request.Name = userFlag
-				}
-			} else {
-				// Check specific filter flags
-				if id, _ := cmd.Flags().GetUint64("id"); id > 0 {
-					request.Id = id
-				} else if name, _ := cmd.Flags().GetString("name"); name != "" {
-					request.Name = name
-				} else if email, _ := cmd.Flags().GetString("email"); email != "" {
-					request.Email = email
-				}
-			}
+		request := &v1.ListUsersRequest{}
 
-			response, err := client.ListUsers(ctx, request)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Cannot get users: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
+		id, _ := cmd.Flags().GetInt64("identifier")
+		username, _ := cmd.Flags().GetString("name")
+		email, _ := cmd.Flags().GetString("email")
 
-			if output != "" {
-				SuccessOutput(response.GetUsers(), "", output)
-				return nil
-			}
+		// filter by one param at most
+		switch {
+		case id > 0:
+			request.Id = uint64(id)
+			break
+		case username != "":
+			request.Name = username
+			break
+		case email != "":
+			request.Email = email
+			break
+		}
 
-			tableData := pterm.TableData{{"ID", "Name", "Username", "Email", "Created"}}
-			for _, user := range response.GetUsers() {
-				tableData = append(
-					tableData,
-					[]string{
-						strconv.FormatUint(user.GetId(), 10),
-						user.GetDisplayName(),
-						user.GetName(),
-						user.GetEmail(),
-						user.GetCreatedAt().AsTime().Format(HeadscaleDateTimeFormat),
-					},
-				)
-			}
-			tableData = FilterTableColumns(cmd, tableData)
-			err = pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
-			if err != nil {
-				ErrorOutput(
-					err,
-					fmt.Sprintf("Failed to render pterm table: %s", err),
-					output,
-				)
-				return err
-			}
-			return nil
-		})
+		response, err := client.ListUsers(ctx, request)
 		if err != nil {
-			// Error already handled in closure
-			return
+			ErrorOutput(
+				err,
+				fmt.Sprintf("Cannot get users: %s", status.Convert(err).Message()),
+				output,
+			)
+		}
+
+		if output != "" {
+			SuccessOutput(response.GetUsers(), "", output)
+		}
+
+		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,
+			)
 		}
 	},
 }
@@ -293,56 +271,55 @@ var renameUserCmd = &cobra.Command{
 	Short:   "Renames a user",
 	Aliases: []string{"mv"},
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		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 {
+			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,
+			)
+		}
 
-		id := userIDFromFlag(cmd)
 		newName, _ := cmd.Flags().GetString("new-name")
 
-		err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-			listReq := &v1.ListUsersRequest{
-				Id: id,
-			}
-
-			users, err := client.ListUsers(ctx, listReq)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Error: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			if len(users.GetUsers()) != 1 {
-				err := errors.New("Unable to determine user to delete, query returned multiple users, use ID")
-				ErrorOutput(
-					err,
-					"Error: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			renameReq := &v1.RenameUserRequest{
-				OldId:   id,
-				NewName: newName,
-			}
-
-			response, err := client.RenameUser(ctx, renameReq)
-			if err != nil {
-				ErrorOutput(
-					err,
-					"Cannot rename user: "+status.Convert(err).Message(),
-					output,
-				)
-				return err
-			}
-
-			SuccessOutput(response.GetUser(), "User renamed", output)
-			return nil
-		})
-		if err != nil {
-			return
+		renameReq := &v1.RenameUserRequest{
+			OldId:   id,
+			NewName: newName,
 		}
+
+		response, err := client.RenameUser(ctx, renameReq)
+		if err != nil {
+			ErrorOutput(
+				err,
+				fmt.Sprintf(
+					"Cannot rename user: %s",
+					status.Convert(err).Message(),
+				),
+				output,
+			)
+		}
+
+		SuccessOutput(response.GetUser(), "User renamed", output)
 	},
 }

cmd/headscale/cli/utils.go

@@ -5,23 +5,24 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"net"
 	"os"
-	"strconv"
-	"strings"
 
 	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/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
+)
+
 func newHeadscaleServerWithConfig() (*hscontrol.Headscale, error) {
 	cfg, err := types.LoadServerConfig()
 	if err != nil {
@@ -71,7 +72,7 @@ func newHeadscaleCLIWithConfig() (context.Context, v1.HeadscaleServiceClient, *g
 
 		// Try to give the user better feedback if we cannot write to the headscale
 		// socket.
-		socket, err := os.OpenFile(cfg.UnixSocket, os.O_WRONLY, 0o666) // nolint
+		socket, err := os.OpenFile(cfg.UnixSocket, os.O_WRONLY, SocketWritePermissions) // nolint
 		if err != nil {
 			if os.IsPermission(err) {
 				log.Fatal().
@@ -199,152 +200,3 @@ func (t tokenAuth) GetRequestMetadata(
 func (tokenAuth) RequireTransportSecurity() bool {
 	return true
 }
-
-// GetOutputFlag returns the output flag value (never fails)
-func GetOutputFlag(cmd *cobra.Command) string {
-	output, _ := cmd.Flags().GetString("output")
-	return output
-}
-
-
-// GetNodeIdentifier returns the node ID using smart lookup via gRPC ListNodes call
-func GetNodeIdentifier(cmd *cobra.Command) (uint64, error) {
-	nodeFlag, _ := cmd.Flags().GetString("node")
-
-	// Use --node flag
-	if nodeFlag == "" {
-		return 0, fmt.Errorf("--node flag is required")
-	}
-
-	// Use smart lookup via gRPC
-	return lookupNodeBySpecifier(nodeFlag)
-}
-
-// lookupNodeBySpecifier performs smart lookup of a node by ID, name, hostname, or IP
-func lookupNodeBySpecifier(specifier string) (uint64, error) {
-	var nodeID uint64
-
-	err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-		request := &v1.ListNodesRequest{}
-
-		// Detect what type of specifier this is and set appropriate filter
-		if id, err := strconv.ParseUint(specifier, 10, 64); err == nil && id > 0 {
-			// Looks like a numeric ID
-			request.Id = id
-		} else if isIPAddress(specifier) {
-			// Looks like an IP address
-			request.IpAddresses = []string{specifier}
-		} else {
-			// Treat as hostname/name
-			request.Name = specifier
-		}
-
-		response, err := client.ListNodes(ctx, request)
-		if err != nil {
-			return fmt.Errorf("failed to lookup node: %w", err)
-		}
-
-		nodes := response.GetNodes()
-		if len(nodes) == 0 {
-			return fmt.Errorf("node not found")
-		}
-
-		if len(nodes) > 1 {
-			var nodeInfo []string
-			for _, node := range nodes {
-				nodeInfo = append(nodeInfo, fmt.Sprintf("ID=%d name=%s", node.GetId(), node.GetName()))
-			}
-			return fmt.Errorf("multiple nodes found matching '%s': %s", specifier, strings.Join(nodeInfo, ", "))
-		}
-
-		// Exactly one match - this is what we want
-		nodeID = nodes[0].GetId()
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-
-	return nodeID, nil
-}
-
-// isIPAddress checks if a string looks like an IP address
-func isIPAddress(s string) bool {
-	// Try parsing as IP address (both IPv4 and IPv6)
-	if net.ParseIP(s) != nil {
-		return true
-	}
-	// Try parsing as CIDR
-	if _, _, err := net.ParseCIDR(s); err == nil {
-		return true
-	}
-	return false
-}
-
-// GetUserIdentifier returns the user ID using smart lookup via gRPC ListUsers call
-func GetUserIdentifier(cmd *cobra.Command) (uint64, error) {
-	userFlag, _ := cmd.Flags().GetString("user")
-	nameFlag, _ := cmd.Flags().GetString("name")
-
-	var specifier string
-
-	// Determine which flag was used (prefer --user, fall back to legacy flags)
-	if userFlag != "" {
-		specifier = userFlag
-	} else if nameFlag != "" {
-		specifier = nameFlag
-	} else {
-		return 0, fmt.Errorf("--user flag is required")
-	}
-
-	// Use smart lookup via gRPC
-	return lookupUserBySpecifier(specifier)
-}
-
-// lookupUserBySpecifier performs smart lookup of a user by ID, name, or email
-func lookupUserBySpecifier(specifier string) (uint64, error) {
-	var userID uint64
-
-	err := WithClient(func(ctx context.Context, client v1.HeadscaleServiceClient) error {
-		request := &v1.ListUsersRequest{}
-
-		// Detect what type of specifier this is and set appropriate filter
-		if id, err := strconv.ParseUint(specifier, 10, 64); err == nil && id > 0 {
-			// Looks like a numeric ID
-			request.Id = id
-		} else if strings.Contains(specifier, "@") {
-			// Looks like an email address
-			request.Email = specifier
-		} else {
-			// Treat as username
-			request.Name = specifier
-		}
-
-		response, err := client.ListUsers(ctx, request)
-		if err != nil {
-			return fmt.Errorf("failed to lookup user: %w", err)
-		}
-
-		users := response.GetUsers()
-		if len(users) == 0 {
-			return fmt.Errorf("user not found")
-		}
-
-		if len(users) > 1 {
-			var userInfo []string
-			for _, user := range users {
-				userInfo = append(userInfo, fmt.Sprintf("ID=%d name=%s email=%s", user.GetId(), user.GetName(), user.GetEmail()))
-			}
-			return fmt.Errorf("multiple users found matching '%s': %s", specifier, strings.Join(userInfo, ", "))
-		}
-
-		// Exactly one match - this is what we want
-		userID = users[0].GetId()
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-
-	return userID, nil
-}

cmd/headscale/cli/utils_test.go

@@ -1,175 +0,0 @@
-package cli
-
-import (
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestHasMachineOutputFlag(t *testing.T) {
-	tests := []struct {
-		name     string
-		args     []string
-		expected bool
-	}{
-		{
-			name:     "no machine output flags",
-			args:     []string{"headscale", "users", "list"},
-			expected: false,
-		},
-		{
-			name:     "json flag present",
-			args:     []string{"headscale", "users", "list", "json"},
-			expected: true,
-		},
-		{
-			name:     "json-line flag present",
-			args:     []string{"headscale", "nodes", "list", "json-line"},
-			expected: true,
-		},
-		{
-			name:     "yaml flag present",
-			args:     []string{"headscale", "apikeys", "list", "yaml"},
-			expected: true,
-		},
-		{
-			name:     "mixed flags with json",
-			args:     []string{"headscale", "--config", "/tmp/config.yaml", "users", "list", "json"},
-			expected: true,
-		},
-		{
-			name:     "flag as part of longer argument",
-			args:     []string{"headscale", "users", "create", "json-user@example.com"},
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Save original os.Args
-			originalArgs := os.Args
-			defer func() { os.Args = originalArgs }()
-
-			// Set os.Args to test case
-			os.Args = tt.args
-
-			result := HasMachineOutputFlag()
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestOutput(t *testing.T) {
-	tests := []struct {
-		name         string
-		result       interface{}
-		override     string
-		outputFormat string
-		expected     string
-	}{
-		{
-			name:         "default format returns override",
-			result:       map[string]string{"test": "value"},
-			override:     "Human readable output",
-			outputFormat: "",
-			expected:     "Human readable output",
-		},
-		{
-			name:         "default format with empty override",
-			result:       map[string]string{"test": "value"},
-			override:     "",
-			outputFormat: "",
-			expected:     "",
-		},
-		{
-			name:         "json format",
-			result:       map[string]string{"name": "test", "id": "123"},
-			override:     "Human readable",
-			outputFormat: "json",
-			expected:     "{\n\t\"id\": \"123\",\n\t\"name\": \"test\"\n}",
-		},
-		{
-			name:         "json-line format",
-			result:       map[string]string{"name": "test", "id": "123"},
-			override:     "Human readable",
-			outputFormat: "json-line",
-			expected:     "{\"id\":\"123\",\"name\":\"test\"}",
-		},
-		{
-			name:         "yaml format",
-			result:       map[string]string{"name": "test", "id": "123"},
-			override:     "Human readable",
-			outputFormat: "yaml",
-			expected:     "id: \"123\"\nname: test\n",
-		},
-		{
-			name:         "invalid format returns override",
-			result:       map[string]string{"test": "value"},
-			override:     "Human readable output",
-			outputFormat: "invalid",
-			expected:     "Human readable output",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := output(tt.result, tt.override, tt.outputFormat)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestOutputWithComplexData(t *testing.T) {
-	// Test with more complex data structures
-	complexData := struct {
-		Users []struct {
-			Name string `json:"name" yaml:"name"`
-			ID   int    `json:"id" yaml:"id"`
-		} `json:"users" yaml:"users"`
-	}{
-		Users: []struct {
-			Name string `json:"name" yaml:"name"`
-			ID   int    `json:"id" yaml:"id"`
-		}{
-			{Name: "user1", ID: 1},
-			{Name: "user2", ID: 2},
-		},
-	}
-
-	// Test JSON output
-	jsonResult := output(complexData, "override", "json")
-	assert.Contains(t, jsonResult, "\"users\":")
-	assert.Contains(t, jsonResult, "\"name\": \"user1\"")
-	assert.Contains(t, jsonResult, "\"id\": 1")
-
-	// Test YAML output
-	yamlResult := output(complexData, "override", "yaml")
-	assert.Contains(t, yamlResult, "users:")
-	assert.Contains(t, yamlResult, "name: user1")
-	assert.Contains(t, yamlResult, "id: 1")
-}
-
-func TestOutputWithNilData(t *testing.T) {
-	// Test with nil data
-	result := output(nil, "fallback", "json")
-	assert.Equal(t, "null", result)
-
-	result = output(nil, "fallback", "yaml")
-	assert.Equal(t, "null\n", result)
-
-	result = output(nil, "fallback", "")
-	assert.Equal(t, "fallback", result)
-}
-
-func TestOutputWithEmptyData(t *testing.T) {
-	// Test with empty slice
-	emptySlice := []string{}
-	result := output(emptySlice, "fallback", "json")
-	assert.Equal(t, "[]", result)
-
-	// Test with empty map
-	emptyMap := map[string]string{}
-	result = output(emptyMap, "fallback", "json")
-	assert.Equal(t, "{}", result)
-}

cmd/headscale/cli/version.go

@@ -11,10 +11,10 @@ func init() {
 
 var versionCmd = &cobra.Command{
 	Use:   "version",
-	Short: "Print the version",
-	Long:  "The version of headscale",
+	Short: "Print the version.",
+	Long:  "The version of headscale.",
 	Run: func(cmd *cobra.Command, args []string) {
-		output := GetOutputFlag(cmd)
+		output, _ := cmd.Flags().GetString("output")
 		SuccessOutput(map[string]string{
 			"version": types.Version,
 			"commit":  types.GitCommitHash,

cmd/headscale/cli/version_test.go

@@ -1,45 +0,0 @@
-package cli
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestVersionCommand(t *testing.T) {
-	// Test that version command exists
-	assert.NotNil(t, versionCmd)
-	assert.Equal(t, "version", versionCmd.Use)
-	assert.Equal(t, "Print the version.", versionCmd.Short)
-	assert.Equal(t, "The version of headscale.", versionCmd.Long)
-}
-
-func TestVersionCommandStructure(t *testing.T) {
-	// Test command is properly added to root
-	found := false
-	for _, cmd := range rootCmd.Commands() {
-		if cmd.Use == "version" {
-			found = true
-			break
-		}
-	}
-	assert.True(t, found, "version command should be added to root command")
-}
-
-func TestVersionCommandFlags(t *testing.T) {
-	// Version command should inherit output flag from root as persistent flag
-	outputFlag := versionCmd.Flag("output")
-	if outputFlag == nil {
-		// Try persistent flags from root
-		outputFlag = rootCmd.PersistentFlags().Lookup("output")
-	}
-	assert.NotNil(t, outputFlag, "version command should have access to output flag")
-}
-
-func TestVersionCommandRun(t *testing.T) {
-	// Test that Run function is set
-	assert.NotNil(t, versionCmd.Run)
-
-	// We can't easily test the actual execution without mocking SuccessOutput
-	// but we can verify the function exists and has the right signature
-}

cmd/hi/cleanup.go

@@ -1,207 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"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.
-func cleanupBeforeTest(ctx context.Context) error {
-	if err := killTestContainers(ctx); err != nil {
-		return fmt.Errorf("failed to kill test containers: %w", err)
-	}
-
-	if err := pruneDockerNetworks(ctx); err != nil {
-		return fmt.Errorf("failed to prune networks: %w", err)
-	}
-
-	return nil
-}
-
-// cleanupAfterTest removes the test container after completion.
-func cleanupAfterTest(ctx context.Context, cli *client.Client, containerID string) error {
-	return cli.ContainerRemove(ctx, containerID, container.RemoveOptions{
-		Force: true,
-	})
-}
-
-// killTestContainers terminates and removes all test containers.
-func killTestContainers(ctx context.Context) error {
-	cli, err := createDockerClient()
-	if err != nil {
-		return fmt.Errorf("failed to create Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	containers, err := cli.ContainerList(ctx, container.ListOptions{
-		All: true,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to list containers: %w", err)
-	}
-
-	removed := 0
-	for _, cont := range containers {
-		shouldRemove := false
-		for _, name := range cont.Names {
-			if strings.Contains(name, "headscale-test-suite") ||
-				strings.Contains(name, "hs-") ||
-				strings.Contains(name, "ts-") ||
-				strings.Contains(name, "derp-") {
-				shouldRemove = true
-				break
-			}
-		}
-
-		if shouldRemove {
-			// First kill the container if it's running
-			if cont.State == "running" {
-				_ = cli.ContainerKill(ctx, cont.ID, "KILL")
-			}
-
-			// Then remove the container with retry logic
-			if removeContainerWithRetry(ctx, cli, cont.ID) {
-				removed++
-			}
-		}
-	}
-
-	if removed > 0 {
-		fmt.Printf("Removed %d test containers\n", removed)
-	} else {
-		fmt.Println("No test containers found to remove")
-	}
-
-	return nil
-}
-
-// removeContainerWithRetry attempts to remove a container with exponential backoff retry logic.
-func removeContainerWithRetry(ctx context.Context, cli *client.Client, containerID string) bool {
-	maxRetries := 3
-	baseDelay := 100 * time.Millisecond
-
-	for attempt := range maxRetries {
-		err := cli.ContainerRemove(ctx, containerID, container.RemoveOptions{
-			Force: true,
-		})
-		if err == nil {
-			return true
-		}
-
-		// If this is the last attempt, don't wait
-		if attempt == maxRetries-1 {
-			break
-		}
-
-		// Wait with exponential backoff
-		delay := baseDelay * time.Duration(1<<attempt)
-		time.Sleep(delay)
-	}
-
-	return false
-}
-
-// pruneDockerNetworks removes unused Docker networks.
-func pruneDockerNetworks(ctx context.Context) error {
-	cli, err := createDockerClient()
-	if err != nil {
-		return fmt.Errorf("failed to create Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	report, err := cli.NetworksPrune(ctx, filters.Args{})
-	if err != nil {
-		return fmt.Errorf("failed to prune 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()
-	if err != nil {
-		return fmt.Errorf("failed to create Docker client: %w", err)
-	}
-	defer cli.Close()
-
-	images, err := cli.ImageList(ctx, image.ListOptions{
-		All: true,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to list 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()
-	if err != nil {
-		return fmt.Errorf("failed to create 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) {
-			fmt.Printf("Go module cache volume not found: %s\n", volumeName)
-		} else if errdefs.IsConflict(err) {
-			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
-}

cmd/hi/docker.go

@@ -1,695 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"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"
-)
-
-var (
-	ErrTestFailed              = errors.New("test failed")
-	ErrUnexpectedContainerWait = errors.New("unexpected end of container wait")
-	ErrNoDockerContext         = errors.New("no docker context found")
-)
-
-// runTestContainer executes integration tests in a Docker container.
-func runTestContainer(ctx context.Context, config *RunConfig) error {
-	cli, err := createDockerClient()
-	if err != nil {
-		return fmt.Errorf("failed to create 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("failed to get absolute path for logs directory: %w", err)
-	}
-
-	const dirPerm = 0o755
-	if err := os.MkdirAll(absLogsDir, dirPerm); err != nil {
-		return fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	if config.CleanBefore {
-		if config.Verbose {
-			log.Printf("Running pre-test cleanup...")
-		}
-		if err := cleanupBeforeTest(ctx); 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 {
-		return fmt.Errorf("failed to ensure image availability: %w", err)
-	}
-
-	resp, err := createGoTestContainer(ctx, cli, config, containerName, absLogsDir, goTestCmd)
-	if err != nil {
-		return fmt.Errorf("failed to create container: %w", err)
-	}
-
-	if config.Verbose {
-		log.Printf("Created container: %s", resp.ID)
-	}
-
-	if err := cli.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
-		return fmt.Errorf("failed to start container: %w", err)
-	}
-
-	log.Printf("Starting test: %s", config.TestPattern)
-
-	exitCode, err := streamAndWait(ctx, cli, resp.ID)
-
-	// Ensure all containers have finished and logs are flushed before extracting artifacts
-	if waitErr := waitForContainerFinalization(ctx, cli, resp.ID, config.Verbose); 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 {
-		log.Printf("Warning: failed to extract artifacts from containers: %v", err)
-	}
-
-	// Always list control files regardless of test outcome
-	listControlFiles(logsDir)
-
-	shouldCleanup := config.CleanAfter && (!config.KeepOnFailure || exitCode == 0)
-	if shouldCleanup {
-		if config.Verbose {
-			log.Printf("Running post-test cleanup...")
-		}
-		if cleanErr := cleanupAfterTest(ctx, cli, resp.ID); cleanErr != nil && config.Verbose {
-			log.Printf("Warning: post-test cleanup failed: %v", cleanErr)
-		}
-	}
-
-	if err != nil {
-		return fmt.Errorf("test execution failed: %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("failed to get 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,
-	}
-	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)
-	}
-
-	hostConfig := &container.HostConfig{
-		AutoRemove: false, // We'll remove manually for better control
-		Binds: []string{
-			fmt.Sprintf("%s:%s", projectRoot, projectRoot),
-			dockerSocketPath + ":/var/run/docker.sock",
-			logsDir + ":/tmp/control",
-		},
-		Mounts: []mount.Mount{
-			{
-				Type:   mount.TypeVolume,
-				Source: "hs-integration-go-cache",
-				Target: "/go",
-			},
-		},
-	}
-
-	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("failed to get 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("error 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("failed to list 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 {
-			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]interface{} `json:"Metadata"`
-	Endpoints map[string]interface{} `json:"Endpoints"`
-	Current   bool                   `json:"Current"`
-}
-
-// createDockerClient creates a Docker client with context detection.
-func createDockerClient() (*client.Client, error) {
-	contextInfo, err := getCurrentDockerContext()
-	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]interface{}); 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() (*DockerContext, error) {
-	cmd := exec.Command("docker", "context", "inspect")
-	output, err := cmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get docker context: %w", err)
-	}
-
-	var contexts []DockerContext
-	if err := json.Unmarshal(output, &contexts); err != nil {
-		return nil, fmt.Errorf("failed to parse 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"
-}
-
-// ensureImageAvailable pulls the specified Docker image to ensure it's available.
-func ensureImageAvailable(ctx context.Context, cli *client.Client, imageName string, verbose bool) error {
-	if verbose {
-		log.Printf("Pulling image %s...", imageName)
-	}
-
-	reader, err := cli.ImagePull(ctx, imageName, image.PullOptions{})
-	if err != nil {
-		return fmt.Errorf("failed to pull image %s: %w", imageName, err)
-	}
-	defer reader.Close()
-
-	if verbose {
-		_, err = io.Copy(os.Stdout, reader)
-		if err != nil {
-			return fmt.Errorf("failed to read pull output: %w", err)
-		}
-	} else {
-		_, err = io.Copy(io.Discard, reader)
-		if err != nil {
-			return fmt.Errorf("failed to read pull output: %w", err)
-		}
-		log.Printf("Image %s pulled successfully", imageName)
-	}
-
-	return nil
-}
-
-// 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
-	var dataFiles []string
-	var 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()
-	if err != nil {
-		return fmt.Errorf("failed to create 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("failed to list 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
-		if err := extractContainerArtifacts(ctx, cli, cont.ID, cont.name, logsDir, verbose); 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 strings.HasPrefix(containerName, "hs-") || strings.HasPrefix(containerName, "ts-") {
-				// 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
-	if err := os.MkdirAll(logsDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	// Extract container logs
-	if err := extractContainerLogs(ctx, cli, containerID, containerName, logsDir, verbose); err != nil {
-		return fmt.Errorf("failed to extract logs: %w", err)
-	}
-
-	// Extract tar files for headscale containers only
-	if strings.HasPrefix(containerName, "hs-") {
-		if err := extractContainerFiles(ctx, cli, containerID, containerName, logsDir, verbose); err != nil {
-			if verbose {
-				log.Printf("Warning: failed to extract files from %s: %v", containerName, err)
-			}
-			// Don't fail the whole extraction if files are missing
-		}
-	}
-
-	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("failed to get 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("failed to demultiplex container logs: %w", err)
-	}
-
-	// Write stdout logs
-	if err := os.WriteFile(stdoutPath, stdoutBuf.Bytes(), 0o644); err != nil {
-		return fmt.Errorf("failed to write stdout log: %w", err)
-	}
-
-	// Write stderr logs
-	if err := os.WriteFile(stderrPath, stderrBuf.Bytes(), 0o644); err != nil {
-		return fmt.Errorf("failed to write stderr log: %w", err)
-	}
-
-	if verbose {
-		log.Printf("Saved logs for %s: %s, %s", containerName, stdoutPath, stderrPath)
-	}
-
-	return nil
-}
-
-// extractContainerFiles extracts database file and directories from headscale containers.
-// Note: The actual file extraction is now handled by the integration tests themselves
-// via SaveProfile, SaveMapResponses, and SaveDatabase functions in hsic.go.
-func extractContainerFiles(ctx context.Context, cli *client.Client, containerID, containerName, logsDir string, verbose bool) error {
-	// Files are now extracted directly by the integration tests
-	// This function is kept for potential future use or other file types
-	return nil
-}
-
-// logExtractionError logs extraction errors with appropriate level based on error type.
-func logExtractionError(artifactType, containerName string, err error, verbose bool) {
-	if errors.Is(err, ErrFileNotFoundInTar) {
-		// File not found is expected and only logged in verbose mode
-		if verbose {
-			log.Printf("No %s found in container %s", artifactType, containerName)
-		}
-	} else {
-		// Other errors are actual failures and should be logged as warnings
-		log.Printf("Warning: failed to extract %s from %s: %v", artifactType, containerName, err)
-	}
-}
-
-// extractSingleFile copies a single file from a container.
-func extractSingleFile(ctx context.Context, cli *client.Client, containerID, sourcePath, fileName, logsDir string, verbose bool) error {
-	tarReader, _, err := cli.CopyFromContainer(ctx, containerID, sourcePath)
-	if err != nil {
-		return fmt.Errorf("failed to copy %s from container: %w", sourcePath, err)
-	}
-	defer tarReader.Close()
-
-	// Extract the single file from the tar
-	filePath := filepath.Join(logsDir, fileName)
-	if err := extractFileFromTar(tarReader, filepath.Base(sourcePath), filePath); err != nil {
-		return fmt.Errorf("failed to extract file from tar: %w", err)
-	}
-
-	if verbose {
-		log.Printf("Extracted %s from %s", fileName, containerID[:12])
-	}
-
-	return nil
-}
-
-// extractDirectory copies a directory from a container and extracts its contents.
-func extractDirectory(ctx context.Context, cli *client.Client, containerID, sourcePath, dirName, logsDir string, verbose bool) error {
-	tarReader, _, err := cli.CopyFromContainer(ctx, containerID, sourcePath)
-	if err != nil {
-		return fmt.Errorf("failed to copy %s from container: %w", sourcePath, err)
-	}
-	defer tarReader.Close()
-
-	// Create target directory
-	targetDir := filepath.Join(logsDir, dirName)
-	if err := os.MkdirAll(targetDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create directory %s: %w", targetDir, err)
-	}
-
-	// Extract the directory from the tar
-	if err := extractDirectoryFromTar(tarReader, targetDir); err != nil {
-		return fmt.Errorf("failed to extract directory from tar: %w", err)
-	}
-
-	if verbose {
-		log.Printf("Extracted %s/ from %s", dirName, containerID[:12])
-	}
-
-	return nil
-}

cmd/hi/doctor.go

@@ -1,351 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"os/exec"
-	"strings"
-)
-
-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
-}
-
-// 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 == "PASS" {
-		results = append(results, checkDockerContext(ctx))
-		results = append(results, checkDockerSocket(ctx))
-		results = append(results, checkGolangImage(ctx))
-	}
-
-	// Check 3: Go installation
-	results = append(results, checkGoInstallation())
-
-	// Check 4: Git repository
-	results = append(results, checkGitRepository())
-
-	// Check 5: Required files
-	results = append(results, checkRequiredFiles())
-
-	// Display results
-	displayDoctorResults(results)
-
-	// Return error if any critical checks failed
-	for _, result := range results {
-		if result.Status == "FAIL" {
-			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 DoctorResult{
-			Name:    "Docker Binary",
-			Status:  "FAIL",
-			Message: "Docker binary not found in PATH",
-			Suggestions: []string{
-				"Install Docker: https://docs.docker.com/get-docker/",
-				"For macOS: consider using colima or Docker Desktop",
-				"Ensure docker is in your PATH",
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Docker Binary",
-		Status:  "PASS",
-		Message: "Docker binary found",
-	}
-}
-
-// checkDockerDaemon verifies Docker daemon is running and accessible.
-func checkDockerDaemon(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Docker Daemon",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot create Docker client: %v", err),
-			Suggestions: []string{
-				"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 DoctorResult{
-			Name:    "Docker Daemon",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot ping Docker daemon: %v", err),
-			Suggestions: []string{
-				"Ensure Docker daemon is running",
-				"Check Docker socket permissions",
-				"Try: docker info",
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Docker Daemon",
-		Status:  "PASS",
-		Message: "Docker daemon is running and accessible",
-	}
-}
-
-// checkDockerContext verifies Docker context configuration.
-func checkDockerContext(_ context.Context) DoctorResult {
-	contextInfo, err := getCurrentDockerContext()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Docker Context",
-			Status:  "WARN",
-			Message: "Could not detect Docker context, using default settings",
-			Suggestions: []string{
-				"Check: docker context ls",
-				"Consider setting up a specific context if needed",
-			},
-		}
-	}
-
-	if contextInfo == nil {
-		return DoctorResult{
-			Name:    "Docker Context",
-			Status:  "PASS",
-			Message: "Using default Docker context",
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Docker Context",
-		Status:  "PASS",
-		Message: "Using Docker context: " + contextInfo.Name,
-	}
-}
-
-// checkDockerSocket verifies Docker socket accessibility.
-func checkDockerSocket(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Docker Socket",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot access Docker socket: %v", err),
-			Suggestions: []string{
-				"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 DoctorResult{
-			Name:    "Docker Socket",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot get Docker info: %v", err),
-			Suggestions: []string{
-				"Check Docker daemon status",
-				"Verify socket permissions",
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Docker Socket",
-		Status:  "PASS",
-		Message: fmt.Sprintf("Docker socket accessible (Server: %s)", info.ServerVersion),
-	}
-}
-
-// checkGolangImage verifies we can access the golang Docker image.
-func checkGolangImage(ctx context.Context) DoctorResult {
-	cli, err := createDockerClient()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Golang Image",
-			Status:  "FAIL",
-			Message: "Cannot create Docker client for image check",
-		}
-	}
-	defer cli.Close()
-
-	goVersion := detectGoVersion()
-	imageName := "golang:" + goVersion
-
-	// Check if we can pull the image
-	err = ensureImageAvailable(ctx, cli, imageName, false)
-	if err != nil {
-		return DoctorResult{
-			Name:    "Golang Image",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot pull golang image %s: %v", imageName, err),
-			Suggestions: []string{
-				"Check internet connectivity",
-				"Verify Docker Hub access",
-				"Try: docker pull " + imageName,
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Golang Image",
-		Status:  "PASS",
-		Message: fmt.Sprintf("Golang image %s is available", imageName),
-	}
-}
-
-// checkGoInstallation verifies Go is installed and working.
-func checkGoInstallation() DoctorResult {
-	_, err := exec.LookPath("go")
-	if err != nil {
-		return DoctorResult{
-			Name:    "Go Installation",
-			Status:  "FAIL",
-			Message: "Go binary not found in PATH",
-			Suggestions: []string{
-				"Install Go: https://golang.org/dl/",
-				"Ensure go is in your PATH",
-			},
-		}
-	}
-
-	cmd := exec.Command("go", "version")
-	output, err := cmd.Output()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Go Installation",
-			Status:  "FAIL",
-			Message: fmt.Sprintf("Cannot get Go version: %v", err),
-		}
-	}
-
-	version := strings.TrimSpace(string(output))
-
-	return DoctorResult{
-		Name:    "Go Installation",
-		Status:  "PASS",
-		Message: version,
-	}
-}
-
-// checkGitRepository verifies we're in a git repository.
-func checkGitRepository() DoctorResult {
-	cmd := exec.Command("git", "rev-parse", "--git-dir")
-	err := cmd.Run()
-	if err != nil {
-		return DoctorResult{
-			Name:    "Git Repository",
-			Status:  "FAIL",
-			Message: "Not in a Git repository",
-			Suggestions: []string{
-				"Run from within the headscale git repository",
-				"Clone the repository: git clone https://github.com/juanfont/headscale.git",
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Git Repository",
-		Status:  "PASS",
-		Message: "Running in Git repository",
-	}
-}
-
-// checkRequiredFiles verifies required files exist.
-func checkRequiredFiles() DoctorResult {
-	requiredFiles := []string{
-		"go.mod",
-		"integration/",
-		"cmd/hi/",
-	}
-
-	var missingFiles []string
-	for _, file := range requiredFiles {
-		cmd := exec.Command("test", "-e", file)
-		if err := cmd.Run(); err != nil {
-			missingFiles = append(missingFiles, file)
-		}
-	}
-
-	if len(missingFiles) > 0 {
-		return DoctorResult{
-			Name:    "Required Files",
-			Status:  "FAIL",
-			Message: "Missing required files: " + strings.Join(missingFiles, ", "),
-			Suggestions: []string{
-				"Ensure you're in the headscale project root directory",
-				"Check that integration/ directory exists",
-				"Verify this is a complete headscale repository",
-			},
-		}
-	}
-
-	return DoctorResult{
-		Name:    "Required Files",
-		Status:  "PASS",
-		Message: "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 "PASS":
-			icon = "✅"
-		case "WARN":
-			icon = "⚠️"
-		case "FAIL":
-			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("================================")
-}

cmd/hi/main.go

@@ -1,93 +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: "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 {
-	if err := killTestContainers(ctx); err != nil {
-		return err
-	}
-	if err := pruneDockerNetworks(ctx); err != nil {
-		return err
-	}
-	if err := cleanOldImages(ctx); err != nil {
-		return err
-	}
-
-	return cleanCacheVolume(ctx)
-}

cmd/hi/run.go

@@ -1,122 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"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 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"`
-}
-
-// 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...")
-	}
-	if err := runDoctorCheck(env.Context()); 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 {
-	goModPath := filepath.Join("..", "..", "go.mod")
-
-	if _, err := os.Stat("go.mod"); err == nil {
-		goModPath = "go.mod"
-	} else if _, err := os.Stat("../../go.mod"); err == nil {
-		goModPath = "../../go.mod"
-	}
-
-	content, err := os.ReadFile(goModPath)
-	if err != nil {
-		return "1.24"
-	}
-
-	lines := splitLines(string(content))
-	for _, line := range lines {
-		if len(line) > 3 && line[:3] == "go " {
-			version := line[3:]
-			if idx := indexOf(version, " "); idx != -1 {
-				version = version[:idx]
-			}
-
-			return version
-		}
-	}
-
-	return "1.24"
-}
-
-// splitLines splits a string into lines without using strings.Split.
-func splitLines(s string) []string {
-	var lines []string
-	var current string
-
-	for _, char := range s {
-		if char == '\n' {
-			lines = append(lines, current)
-			current = ""
-		} else {
-			current += string(char)
-		}
-	}
-
-	if current != "" {
-		lines = append(lines, current)
-	}
-
-	return lines
-}
-
-// indexOf finds the first occurrence of substr in s.
-func indexOf(s, substr string) int {
-	for i := 0; i <= len(s)-len(substr); i++ {
-		if s[i:i+len(substr)] == substr {
-			return i
-		}
-	}
-
-	return -1
-}

cmd/hi/tar_utils.go

@@ -1,100 +0,0 @@
-package main
-
-import (
-	"archive/tar"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// ErrFileNotFoundInTar indicates a file was not found in the tar archive.
-var ErrFileNotFoundInTar = errors.New("file not found in tar")
-
-// extractFileFromTar extracts a single file from a tar reader.
-func extractFileFromTar(tarReader io.Reader, fileName, outputPath string) error {
-	tr := tar.NewReader(tarReader)
-
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("failed to read tar header: %w", err)
-		}
-
-		// Check if this is the file we're looking for
-		if filepath.Base(header.Name) == fileName {
-			if header.Typeflag == tar.TypeReg {
-				// Create the output file
-				outFile, err := os.Create(outputPath)
-				if err != nil {
-					return fmt.Errorf("failed to create output file: %w", err)
-				}
-				defer outFile.Close()
-
-				// Copy file contents
-				if _, err := io.Copy(outFile, tr); err != nil {
-					return fmt.Errorf("failed to copy file contents: %w", err)
-				}
-
-				return nil
-			}
-		}
-	}
-
-	return fmt.Errorf("%w: %s", ErrFileNotFoundInTar, fileName)
-}
-
-// extractDirectoryFromTar extracts all files from a tar reader to a target directory.
-func extractDirectoryFromTar(tarReader io.Reader, targetDir string) error {
-	tr := tar.NewReader(tarReader)
-
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("failed to read tar header: %w", err)
-		}
-
-		// Clean the path to prevent directory traversal
-		cleanName := filepath.Clean(header.Name)
-		if strings.Contains(cleanName, "..") {
-			continue // Skip potentially dangerous paths
-		}
-
-		targetPath := filepath.Join(targetDir, filepath.Base(cleanName))
-
-		switch header.Typeflag {
-		case tar.TypeDir:
-			// Create directory
-			if err := os.MkdirAll(targetPath, os.FileMode(header.Mode)); err != nil {
-				return fmt.Errorf("failed to create directory %s: %w", targetPath, err)
-			}
-		case tar.TypeReg:
-			// Create file
-			outFile, err := os.Create(targetPath)
-			if err != nil {
-				return fmt.Errorf("failed to create file %s: %w", targetPath, err)
-			}
-
-			if _, err := io.Copy(outFile, tr); err != nil {
-				outFile.Close()
-				return fmt.Errorf("failed to copy file contents: %w", err)
-			}
-			outFile.Close()
-
-			// Set file permissions
-			if err := os.Chmod(targetPath, os.FileMode(header.Mode)); err != nil {
-				return fmt.Errorf("failed to set file permissions: %w", err)
-			}
-		}
-	}
-
-	return nil
-}

config-example.yaml

@@ -85,9 +85,6 @@ 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.
     #
@@ -322,59 +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
 # 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 a node is authenticated with OpenID until it expires
-#   # and needs to reauthenticate.
+#   # 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.
+#   # 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".
 #
-#   # 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
@@ -383,7 +371,6 @@ 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)

docs/about/faq.md

@@ -61,12 +61,12 @@ of Headscale:
 
 1. An environment with 1000 servers
 
-   - they rarely "move" (change their endpoints)
-   - new nodes are added rarely
+    - they rarely  "move" (change their endpoints)
+    - new nodes are added rarely
 
 2. An environment with 80 laptops/phones (end user devices)
 
-   - nodes move often, e.g. switching from home to office
+    - 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
@@ -122,6 +122,7 @@ help to the community.
 
 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 an ACL 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

docs/about/features.md

@@ -23,14 +23,15 @@ provides on overview of Headscale's feature and compatibility with the Tailscale
 - [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] Some [Autogroups](https://tailscale.com/kb/1396/targets#autogroups), currently: `autogroup:internet`,
-      `autogroup:nonroot`, `autogroup:member`, `autogroup:tagged`
+      `autogroup:nonroot`
     - [x] [Auto approvers](https://tailscale.com/kb/1337/acl-syntax#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/kb/1193/tailscale-ssh)
-* [x] [Node registration using Single-Sign-On (OpenID Connect)](../ref/oidc.md) ([GitHub label "OIDC"](https://github.com/juanfont/headscale/labels/OIDC))
+* [ ] 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
+    - [ ] Dynamic ACL support
     - [ ] OIDC groups cannot be used in ACLs
 - [ ] [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))

docs/packaging/README.md

@@ -0,0 +1,5 @@
+# Packaging
+
+We use [nFPM](https://nfpm.goreleaser.com/) for making `.deb`, `.rpm` and `.apk`.
+
+This folder contains files we need to package with these releases.

docs/packaging/headscale.systemd.service

@@ -1,4 +1,5 @@
 [Unit]
+After=syslog.target
 After=network.target
 Description=headscale coordination server for Tailscale
 X-Restart-Triggers=/etc/headscale/config.yaml
@@ -13,7 +14,7 @@ Restart=always
 RestartSec=5
 
 WorkingDirectory=/var/lib/headscale
-ReadWritePaths=/var/lib/headscale
+ReadWritePaths=/var/lib/headscale /var/run
 
 AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_CHOWN
 CapabilityBoundingSet=CAP_NET_BIND_SERVICE CAP_CHOWN

docs/packaging/postinstall.sh

@@ -0,0 +1,88 @@
+#!/bin/sh
+# Determine OS platform
+# shellcheck source=/dev/null
+. /etc/os-release
+
+HEADSCALE_EXE="/usr/bin/headscale"
+BSD_HIER=""
+HEADSCALE_RUN_DIR="/var/run/headscale"
+HEADSCALE_HOME_DIR="/var/lib/headscale"
+HEADSCALE_USER="headscale"
+HEADSCALE_GROUP="headscale"
+HEADSCALE_SHELL="/usr/sbin/nologin"
+
+ensure_sudo() {
+	if [ "$(id -u)" = "0" ]; then
+		echo "Sudo permissions detected"
+	else
+		echo "No sudo permission detected, please run as sudo"
+		exit 1
+	fi
+}
+
+ensure_headscale_path() {
+	if [ ! -f "$HEADSCALE_EXE" ]; then
+		echo "headscale not in default path, exiting..."
+		exit 1
+	fi
+
+	printf "Found headscale %s\n" "$HEADSCALE_EXE"
+}
+
+create_headscale_user() {
+	printf "PostInstall: Adding headscale user %s\n" "$HEADSCALE_USER"
+	useradd -r -s "$HEADSCALE_SHELL" -d "$HEADSCALE_HOME_DIR" -c "headscale default user" "$HEADSCALE_USER"
+}
+
+create_headscale_group() {
+	if command -V systemctl >/dev/null 2>&1; then
+		printf "PostInstall: Adding headscale group %s\n" "$HEADSCALE_GROUP"
+		groupadd -r "$HEADSCALE_GROUP"
+
+		printf "PostInstall: Adding headscale user %s to group %s\n" "$HEADSCALE_USER" "$HEADSCALE_GROUP"
+		usermod -a -G "$HEADSCALE_GROUP" "$HEADSCALE_USER"
+	fi
+
+	if [ "$ID" = "alpine" ]; then
+		printf "PostInstall: Adding headscale group %s\n" "$HEADSCALE_GROUP"
+		addgroup -S "$HEADSCALE_GROUP"
+
+		printf "PostInstall: Adding headscale user %s to group %s\n" "$HEADSCALE_USER" "$HEADSCALE_GROUP"
+		addgroup "$HEADSCALE_USER" "$HEADSCALE_GROUP"
+	fi
+}
+
+create_run_dir() {
+	printf "PostInstall: Creating headscale run directory \n"
+	mkdir -p "$HEADSCALE_RUN_DIR"
+
+	printf "PostInstall: Modifying group ownership of headscale run directory \n"
+	chown "$HEADSCALE_USER":"$HEADSCALE_GROUP" "$HEADSCALE_RUN_DIR"
+}
+
+summary() {
+	echo "----------------------------------------------------------------------"
+	echo " headscale package has been successfully installed."
+	echo ""
+	echo " Please follow the next steps to start the software:"
+	echo ""
+	echo "    sudo systemctl enable headscale"
+	echo "    sudo systemctl start headscale"
+	echo ""
+	echo " Configuration settings can be adjusted here:"
+	echo "    ${BSD_HIER}/etc/headscale/config.yaml"
+	echo ""
+	echo "----------------------------------------------------------------------"
+}
+
+#
+# Main body of the script
+#
+{
+	ensure_sudo
+	ensure_headscale_path
+	create_headscale_user
+	create_headscale_group
+	create_run_dir
+	summary
+}

docs/packaging/postremove.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+# Determine OS platform
+# shellcheck source=/dev/null
+. /etc/os-release
+
+if command -V systemctl >/dev/null 2>&1; then
+	echo "Stop and disable headscale service"
+	systemctl stop headscale >/dev/null 2>&1 || true
+	systemctl disable headscale >/dev/null 2>&1 || true
+	echo "Running daemon-reload"
+	systemctl daemon-reload || true
+fi
+
+echo "Removing run directory"
+rm -rf "/var/run/headscale.sock"

docs/ref/configuration.md

@@ -5,9 +5,7 @@
     - `/etc/headscale`
     - `$HOME/.headscale`
     - the current working directory
-- To load the configuration from a different path, use:
-    - the command line flag `-c`, `--config`
-    - the environment variable `HEADSCALE_CONFIG`
+- Use the command line flag `-c`, `--config` to load the configuration from a different path
 - Validate the configuration file with: `headscale configtest`
 
 !!! example "Get the [example configuration from the GitHub repository](https://github.com/juanfont/headscale/blob/main/config-example.yaml)"

docs/ref/dns.md

@@ -9,10 +9,10 @@ Headscale allows to set extra DNS records which are made available via
 [MagicDNS](https://tailscale.com/kb/1081/magicdns). Extra DNS records can be configured either via static entries in the
 [configuration file](./configuration.md) or from a JSON file that Headscale continuously watches for changes:
 
-- Use the `dns.extra_records` option in the [configuration file](./configuration.md) for entries that are static and
+* Use the `dns.extra_records` option in the [configuration file](./configuration.md) for entries that are static and
   don't change while Headscale is running. Those entries are processed when Headscale is starting up and changes to the
   configuration require a restart of Headscale.
-- For dynamic DNS records that may be added, updated or removed while Headscale is running or DNS records that are
+* For dynamic DNS records that may be added, updated or removed while Headscale is running or DNS records that are
   generated by scripts the option `dns.extra_records_path` in the [configuration file](./configuration.md) is useful.
   Set it to the absolute path of the JSON file containing DNS records and Headscale processes this file as it detects
   changes.
@@ -25,6 +25,7 @@ hostname and port combination "http://hostname-in-magic-dns.myvpn.example.com:30
 
     Currently, [only A and AAAA records are processed by Tailscale](https://github.com/tailscale/tailscale/blob/v1.78.3/ipn/ipnlocal/local.go#L4461-L4479).
 
+
 1.  Configure extra DNS records using one of the available configuration options:
 
     === "Static entries, via `dns.extra_records`"

docs/ref/integration/tools.md

@@ -5,11 +5,10 @@
     This page contains community contributions. The projects listed here are not
     maintained by the headscale authors and are written by community members.
 
-This page collects third-party tools, client libraries, and scripts related to headscale.
+This page collects third-party tools and scripts related to headscale.
 
 | Name                  | Repository Link                                                 | Description                                                          |
 | --------------------- | --------------------------------------------------------------- | -------------------------------------------------------------------- |
 | tailscale-manager     | [Github](https://github.com/singlestore-labs/tailscale-manager) | Dynamically manage Tailscale route advertisements                    |
 | headscalebacktosqlite | [Github](https://github.com/bigbozza/headscalebacktosqlite)     | Migrate headscale from PostgreSQL back to SQLite                     |
 | headscale-pf          | [Github](https://github.com/YouSysAdmin/headscale-pf)           | Populates user groups based on user groups in Jumpcloud or Authentik |
-| headscale-client-go   | [Github](https://github.com/hibare/headscale-client-go)         | A Go client implementation for the Headscale HTTP API.               |

docs/ref/integration/web-ui.md

@@ -7,14 +7,13 @@
 
 Headscale doesn't provide a built-in web interface but users may pick one from the available options.
 
-| Name                   | Repository Link                                             | Description                                                                                  |
-| ---------------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| headscale-ui           | [Github](https://github.com/gurucomputing/headscale-ui)     | A web frontend for the headscale Tailscale-compatible coordination server                    |
-| HeadscaleUi            | [GitHub](https://github.com/simcu/headscale-ui)             | A static headscale admin ui, no backend environment required                                 |
-| Headplane              | [GitHub](https://github.com/tale/headplane)                 | An advanced Tailscale inspired frontend for headscale                                        |
-| headscale-admin        | [Github](https://github.com/GoodiesHQ/headscale-admin)      | Headscale-Admin is meant to be a simple, modern web interface for headscale                  |
-| ouroboros              | [Github](https://github.com/yellowsink/ouroboros)           | Ouroboros is designed for users to manage their own devices, rather than for admins          |
-| unraid-headscale-admin | [Github](https://github.com/ich777/unraid-headscale-admin)  | A simple headscale admin UI for Unraid, it offers Local (`docker exec`) and API Mode         |
-| headscale-console      | [Github](https://github.com/rickli-cloud/headscale-console) | WebAssembly-based client supporting SSH, VNC and RDP with optional self-service capabilities |
+| Name                   | Repository Link                                            | Description                                                                          |
+| ---------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------ |
+| headscale-ui           | [Github](https://github.com/gurucomputing/headscale-ui)    | A web frontend for the headscale Tailscale-compatible coordination server            |
+| HeadscaleUi            | [GitHub](https://github.com/simcu/headscale-ui)            | A static headscale admin ui, no backend environment required                         |
+| Headplane              | [GitHub](https://github.com/tale/headplane)                | An advanced Tailscale inspired frontend for headscale                                |
+| headscale-admin        | [Github](https://github.com/GoodiesHQ/headscale-admin)     | Headscale-Admin is meant to be a simple, modern web interface for headscale          |
+| ouroboros              | [Github](https://github.com/yellowsink/ouroboros)          | Ouroboros is designed for users to manage their own devices, rather than for admins  |
+| unraid-headscale-admin | [Github](https://github.com/ich777/unraid-headscale-admin) | A simple headscale admin UI for Unraid, it offers Local (`docker exec`) and API Mode |
 
 You can ask for support on our [Discord server](https://discord.gg/c84AZQhmpx) in the "web-interfaces" channel.

docs/ref/oidc.md

@@ -1,272 +1,162 @@
-# OpenID Connect
-
-Headscale supports authentication via external identity providers using OpenID Connect (OIDC). It features:
-
-- Autoconfiguration via OpenID Connect Discovery Protocol
-- [Proof Key for Code Exchange (PKCE) code verification](#enable-pkce-recommended)
-- [Authorization based on a user's domain, email address or group membership](#authorize-users-with-filters)
-- Synchronization of [standard OIDC claims](#supported-oidc-claims)
-
-Please see [limitations](#limitations) for known issues and limitations.
-
-## Configuration
-
-OpenID requires configuration in Headscale and your identity provider:
-
-- Headscale: The `oidc` section of the Headscale [configuration](configuration.md) contains all available configuration
-  options along with a description and their default values.
-- Identity provider: Please refer to the official documentation of your identity provider for specific instructions.
-  Additionally, there might be some useful hints in the [Identity provider specific
-  configuration](#identity-provider-specific-configuration) section below.
-
-### Basic configuration
-
-A basic configuration connects Headscale to an identity provider and typically requires:
-
-- OpenID Connect Issuer URL from the identity provider. Headscale uses the OpenID Connect Discovery Protocol 1.0 to
-  automatically obtain OpenID configuration parameters (example: `https://sso.example.com`).
-- Client ID from the identity provider (example: `headscale`).
-- Client secret generated by the identity provider (example: `generated-secret`).
-- Redirect URI for your identity provider (example: `https://headscale.example.com/oidc/callback`).
-
-=== "Headscale"
-
-    ```yaml
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-    ```
-
-=== "Identity provider"
-
-    * Create a new confidential client (`Client ID`, `Client secret`)
-    * Add Headscale's OIDC callback URL as valid redirect URL: `https://headscale.example.com/oidc/callback`
-    * Configure additional parameters to improve user experience such as: name, description, logo, …
-
-### Enable PKCE (recommended)
-
-Proof Key for Code Exchange (PKCE) adds an additional layer of security to the OAuth 2.0 authorization code flow by
-preventing authorization code interception attacks, see: <https://datatracker.ietf.org/doc/html/rfc7636>. PKCE is
-recommended and needs to be configured for Headscale and the identity provider alike:
-
-=== "Headscale"
-
-    ```yaml hl_lines="5-6"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      pkce:
-        enabled: true
-    ```
-
-=== "Identity provider"
-
-    * Enable PKCE for the headscale client
-    * Set the PKCE challenge method to "S256"
-
-### Authorize users with filters
-
-Headscale allows to filter for allowed users based on their domain, email address or group membership. These filters can
-be helpful to apply additional restrictions and control which users are allowed to join. Filters are disabled by
-default, users are allowed to join once the authentication with the identity provider succeeds. In case multiple filters
-are configured, a user needs to pass all of them.
-
-=== "Allowed domains"
-
-    * Check the email domain of each authenticating user against the list of allowed domains and only authorize users
-      whose email domain matches `example.com`.
-    * Access allowed: `alice@example.com`
-    * Access denied: `bob@example.net`
-
-    ```yaml hl_lines="5-6"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      allowed_domains:
-        - "example.com"
-    ```
-
-=== "Allowed users/emails"
-
-    * Check the email address of each authenticating user against the list of allowed email addresses and only authorize
-      users whose email is part of the `allowed_users` list.
-    * Access allowed: `alice@example.com`, `bob@example.net`
-    * Access denied: `mallory@example.net`
-
-    ```yaml hl_lines="5-7"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      allowed_users:
-        - "alice@example.com"
-        - "bob@example.net"
-    ```
-
-=== "Allowed groups"
-
-    * Use the OIDC `groups` claim of each authenticating user to get their group membership and only authorize users
-      which are members in at least one of the referenced groups.
-    * Access allowed: users in the `headscale_users` group
-    * Access denied: users without groups, users with other groups
-
-    ```yaml hl_lines="5-7"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      scope: ["openid", "profile", "email", "groups"]
-      allowed_groups:
-        - "headscale_users"
-    ```
-
-### Customize node expiration
-
-The node expiration is the amount of time a node is authenticated with OpenID Connect until it expires and needs to
-reauthenticate. The default node expiration is 180 days. This can either be customized or set to the expiration from the
-Access Token.
-
-=== "Customize node expiration"
-
-    ```yaml hl_lines="5"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      expiry: 30d   # Use 0 to disable node expiration
-    ```
-
-=== "Use expiration from Access Token"
-
-    Please keep in mind that the Access Token is typically a short-lived token that expires within a few minutes. You
-    will have to configure token expiration in your identity provider to avoid frequent reauthentication.
-
-
-    ```yaml hl_lines="5"
-    oidc:
-      issuer: "https://sso.example.com"
-      client_id: "headscale"
-      client_secret: "generated-secret"
-      use_expiry_from_token: true
-    ```
-
-!!! tip "Expire a node and force re-authentication"
-
-    A node can be expired immediately via:
-    ```console
-    headscale node expire -i <NODE_ID>
-    ```
-
-### Reference a user in the policy
-
-You may refer to users in the Headscale policy via:
-
-- Email address
-- Username
-- Provider identifier (only available in the database or from your identity provider)
-
-!!! note "A user identifier in the policy must contain a single `@`"
-
-    The Headscale policy requires a single `@` to reference a user. If the username or provider identifier doesn't
-    already contain a single `@`, it needs to be appended at the end. For example: the username `ssmith` has to be
-    written as `ssmith@` to be correctly identified as user within the policy.
-
-!!! warning "Email address or username might be updated by users"
-
-    Many identity providers allow users to update their own profile. Depending on the identity provider and its
-    configuration, the values for username or email address might change over time. This might have unexpected
-    consequences for Headscale where a policy might no longer work or a user might obtain more access by hijacking an
-    existing username or email address.
-
-## Supported OIDC claims
-
-Headscale uses [the standard OIDC claims](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) to
-populate and update its local user profile on each login. OIDC claims are read from the ID Token or from the UserInfo
-endpoint.
-
-| Headscale profile   | OIDC claim           | Notes / examples                                                                                  |
-| ------------------- | -------------------- | ------------------------------------------------------------------------------------------------- |
-| email address       | `email`              | Only used when `email_verified: true`                                                             |
-| display name        | `name`               | eg: `Sam Smith`                                                                                   |
-| username            | `preferred_username` | Depends on identity provider, eg: `ssmith`, `ssmith@idp.example.com`, `\\example.com\ssmith`      |
-| profile picture     | `picture`            | URL to a profile picture or avatar                                                                |
-| provider identifier | `iss`, `sub`         | A stable and unique identifier for a user, typically a combination of `iss` and `sub` OIDC claims |
-|                     | `groups`             | [Only used to filter for allowed groups](#authorize-users-with-filters)                           |
-
-## Limitations
-
-- Support for OpenID Connect aims to be generic and vendor independent. It offers only limited support for quirks of
-  specific identity providers.
-- OIDC groups cannot be used in ACLs.
-- The username provided by the identity provider needs to adhere to this pattern:
-    - The username must be at least two characters long.
-    - It must only contain letters, digits, hyphens, dots, underscores, and up to a single `@`.
-    - The username must start with a letter.
-- A user's email address is only synchronized to the local user profile when the identity provider marks the email
-  address as verified (`email_verified: true`).
-
-Please see the [GitHub label "OIDC"](https://github.com/juanfont/headscale/labels/OIDC) for OIDC related issues.
-
-## Identity provider specific configuration
-
-!!! warning "Third-party software and services"
-
-    This section of the documentation is specific for third-party software and services. We recommend users read the
-    third-party documentation on how to configure and integrate an OIDC client. Please see the [Configuration
-    section](#configuration) for a description of Headscale's OIDC related configuration settings.
-
-Any identity provider with OpenID Connect support should "just work" with Headscale. The following identity providers
-are known to work:
-
-- [Authelia](#authelia)
-- [Authentik](#authentik)
-- [Kanidm](#kanidm)
-- [Keycloak](#keycloak)
-
-### Authelia
-
-Authelia is fully supported by Headscale.
-
-#### Additional configuration to authorize users based on filters
-
-Authelia (4.39.0 or newer) no longer provides standard OIDC claims such as `email` or `groups` via the ID Token. The
-OIDC `email` and `groups` claims are used to [authorize users with filters](#authorize-users-with-filters). This extra
-configuration step is **only** needed if you need to authorize access based on one of the following user properties:
-
-- domain
-- email address
-- group membership
-
-Please follow the instructions from Authelia's documentation on how to [Restore Functionality Prior to Claims
-Parameter](https://www.authelia.com/integration/openid-connect/openid-connect-1.0-claims/#restore-functionality-prior-to-claims-parameter).
-
-### Authentik
-
-- Authentik is fully supported by Headscale.
-- [Headscale does not JSON Web Encryption](https://github.com/juanfont/headscale/issues/2446). Leave the field
-  `Encryption Key` in the providers section unset.
-
-### Google OAuth
-
-!!! warning "No username due to missing preferred_username"
-
-    Google OAuth does not send the `preferred_username` claim when the scope `profile` is requested. The username in
-    Headscale will be blank/not set.
-
-In order to integrate Headscale with Google, you'll need to have a [Google Cloud
-Console](https://console.cloud.google.com) account.
-
-Google OAuth has a [verification process](https://support.google.com/cloud/answer/9110914?hl=en) if you need to have
-users authenticate who are outside of your domain. If you only need to authenticate users from your domain name (ie
-`@example.com`), you don't need to go through the verification process.
-
-However if you don't have a domain, or need to add users outside of your domain, you can manually add emails via Google
-Console.
-
-#### Steps
+# Configuring headscale to use OIDC authentication
+
+In order to authenticate users through a centralized solution one must enable the OIDC integration.
+
+Known limitations:
+
+- No dynamic ACL support
+- OIDC groups cannot be used in ACLs
+
+## Basic configuration
+
+In your `config.yaml`, customize this to your liking:
+
+```yaml title="config.yaml"
+oidc:
+  # Block further startup until the OIDC provider is healthy and available
+  only_start_if_oidc_is_available: true
+  # Specified by your OIDC provider
+  issuer: "https://your-oidc.issuer.com/path"
+  # Specified/generated by your OIDC provider
+  client_id: "your-oidc-client-id"
+  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"
+  # as third option, it's also possible to load the oidc secret from environment variables
+  # set HEADSCALE_OIDC_CLIENT_SECRET to the required value
+
+  # 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".
+  scope: ["openid", "profile", "email", "custom"]
+  # Optional: Passed on to the browser login request – used to tweak behaviour for the OIDC provider
+  extra_params:
+    domain_hint: example.com
+
+  # Optional: 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
+  # Optional. Note that groups from Keycloak have a leading '/'.
+  allowed_groups:
+    - /headscale
+  # Optional.
+  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
+  # by preventing authorization code interception attacks
+  # See https://datatracker.ietf.org/doc/html/rfc7636
+  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
+```
+
+## Azure AD example
+
+In order to integrate headscale with Azure Active Directory, we'll need to provision an App Registration with the correct scopes and redirect URI. Here with Terraform:
+
+```hcl title="terraform.hcl"
+resource "azuread_application" "headscale" {
+  display_name = "Headscale"
+
+  sign_in_audience = "AzureADMyOrg"
+  fallback_public_client_enabled = false
+
+  required_resource_access {
+    // Microsoft Graph
+    resource_app_id = "00000003-0000-0000-c000-000000000000"
+
+    resource_access {
+      // scope: profile
+      id   = "14dad69e-099b-42c9-810b-d002981feec1"
+      type = "Scope"
+    }
+    resource_access {
+      // scope: openid
+      id   = "37f7f235-527c-4136-accd-4a02d197296e"
+      type = "Scope"
+    }
+    resource_access {
+      // scope: email
+      id   = "64a6cdd6-aab1-4aaf-94b8-3cc8405e90d0"
+      type = "Scope"
+    }
+  }
+  web {
+    # Points at your running headscale instance
+    redirect_uris = ["https://headscale.example.com/oidc/callback"]
+
+    implicit_grant {
+      access_token_issuance_enabled = false
+      id_token_issuance_enabled = true
+    }
+  }
+
+  group_membership_claims = ["SecurityGroup"]
+  optional_claims {
+    # Expose group memberships
+    id_token {
+      name = "groups"
+    }
+  }
+}
+
+resource "azuread_application_password" "headscale-application-secret" {
+  display_name          = "Headscale Server"
+  application_object_id = azuread_application.headscale.object_id
+}
+
+resource "azuread_service_principal" "headscale" {
+  application_id = azuread_application.headscale.application_id
+}
+
+resource "azuread_service_principal_password" "headscale" {
+  service_principal_id = azuread_service_principal.headscale.id
+  end_date_relative    = "44640h"
+}
+
+output "headscale_client_id" {
+  value = azuread_application.headscale.application_id
+}
+
+output "headscale_client_secret" {
+  value = azuread_application_password.headscale-application-secret.value
+}
+```
+
+And in your headscale `config.yaml`:
+
+```yaml title="config.yaml"
+oidc:
+  issuer: "https://login.microsoftonline.com/<tenant-UUID>/v2.0"
+  client_id: "<client-id-from-terraform>"
+  client_secret: "<client-secret-from-terraform>"
+
+  # Optional: add "groups"
+  scope: ["openid", "profile", "email"]
+  extra_params:
+    # Use your own domain, associated with Azure AD
+    domain_hint: example.com
+    # Optional: Force the Azure AD account picker
+    prompt: select_account
+```
+
+## Google OAuth Example
+
+In order to integrate headscale with Google, you'll need to have a [Google Cloud Console](https://console.cloud.google.com) account.
+
+Google OAuth has a [verification process](https://support.google.com/cloud/answer/9110914?hl=en) if you need to have users authenticate who are outside of your domain. If you only need to authenticate users from your domain name (ie `@example.com`), you don't need to go through the verification process.
+
+However if you don't have a domain, or need to add users outside of your domain, you can manually add emails via Google Console.
+
+### Steps
 
 1. Go to [Google Console](https://console.cloud.google.com) and login or create an account if you don't have one.
 2. Create a project (if you don't already have one).
@@ -274,44 +164,50 @@ Console.
 4. Click `Create Credentials` -> `OAuth client ID`
 5. Under `Application Type`, choose `Web Application`
 6. For `Name`, enter whatever you like
-7. Under `Authorised redirect URIs`, add Headscale's OIDC callback URL: `https://headscale.example.com/oidc/callback`
+7. Under `Authorised redirect URIs`, use `https://example.com/oidc/callback`, replacing example.com with your headscale URL.
 8. Click `Save` at the bottom of the form
 9. Take note of the `Client ID` and `Client secret`, you can also download it for reference if you need it.
-10. [Configure Headscale following the "Basic configuration" steps](#basic-configuration). The issuer URL for Google
-    OAuth is: `https://accounts.google.com`.
+10. Edit your headscale config, under `oidc`, filling in your `client_id` and `client_secret`:
+    ```yaml title="config.yaml"
+    oidc:
+      issuer: "https://accounts.google.com"
+      client_id: ""
+      client_secret: ""
+      scope: ["openid", "profile", "email"]
+    ```
 
-### Kanidm
+You can also use `allowed_domains` and `allowed_users` to restrict the users who can authenticate.
 
-- Kanidm is fully supported by Headscale.
-- Groups for the [allowed groups filter](#authorize-users-with-filters) need to be specified with their full SPN, for
-  example: `headscale_users@sso.example.com`.
+## Authelia
+Authelia since v4.39.0, has removed most claims from the `ID Token`, they are still available when application queries [UserInfo Endpoint](https://openid.net/specs/openid-connect-core-1_0.html#UserInfo). 
 
-### Keycloak
+Following config restores sending 'default' claims in the `ID Token`
 
-Keycloak is fully supported by Headscale.
+For more information please read: [Authelia restore functionality prior to claims parameter](https://www.authelia.com/integration/openid-connect/openid-connect-1.0-claims/#restore-functionality-prior-to-claims-parameter)
 
-#### Additional configuration to use the allowed groups filter
 
-Keycloak has no built-in client scope for the OIDC `groups` claim. This extra configuration step is **only** needed if
-you need to [authorize access based on group membership](#authorize-users-with-filters).
-
-- Create a new client scope `groups` for OpenID Connect:
-    - Configure a `Group Membership` mapper with name `groups` and the token claim name `groups`.
-    - Enable the mapper for the ID Token, Access Token and UserInfo endpoint.
-- Configure the new client scope for your Headscale client:
-    - Edit the Headscale client.
-    - Search for the client scope `group`.
-    - Add it with assigned type `Default`.
-- [Configure the allowed groups in Headscale](#authorize-users-with-filters). Keep in mind that groups in Keycloak start
-  with a leading `/`.
-
-### Microsoft Entra ID
-
-In order to integrate Headscale with Microsoft Entra ID, you'll need to provision an App Registration with the correct
-scopes and redirect URI.
-
-[Configure Headscale following the "Basic configuration" steps](#basic-configuration). The issuer URL for Microsoft
-Entra ID is: `https://login.microsoftonline.com/<tenant-UUID>/v2.0`. The following `extra_params` might be useful:
-
-- `domain_hint: example.com` to use your own domain
-- `prompt: select_account` to force an account picker during login
+```yaml
+identity_providers:
+  oidc:
+    claims_policies:
+      default:
+        id_token: ['groups', 'email', 'email_verified', 'alt_emails', 'preferred_username', 'name']
+    clients:
+      - client_id: 'headscale'
+        client_name: 'headscale'
+        client_secret: ''
+        public: false
+        claims_policy: 'default'
+        authorization_policy: 'two_factor'
+        require_pkce: true
+        pkce_challenge_method: 'S256'
+        redirect_uris:
+          - 'https://headscale.example.com/oidc/callback'
+        scopes:
+          - 'openid'
+          - 'profile'
+          - 'groups'
+          - 'email'
+        userinfo_signed_response_alg: 'none'
+        token_endpoint_auth_method: 'client_secret_basic'
+```

docs/ref/routes.md

@@ -1,5 +1,4 @@
 # Routes
-
 Headscale supports route advertising and can be used to manage [subnet routers](https://tailscale.com/kb/1019/subnets)
 and [exit nodes](https://tailscale.com/kb/1103/exit-nodes) for a tailnet.
 
@@ -11,13 +10,11 @@ and [exit nodes](https://tailscale.com/kb/1103/exit-nodes) for a tailnet.
   from a specific IP address.
 
 ## Subnet router
-
 The setup of a subnet router requires double opt-in, once from a subnet router and once on the control server to allow
 its use within the tailnet. Optionally, use [`autoApprovers` to automatically approve routes from a subnet
 router](#automatically-approve-routes-of-a-subnet-router).
 
 ### Setup a subnet router
-
 #### Configure a node as subnet router
 
 Register a node and advertise the routes it should handle as comma separated list:
@@ -34,6 +31,7 @@ $ sudo tailscale set --advertise-routes=10.0.0.0/8,192.168.0.0/24
 
 Finally, [enable IP forwarding](#enable-ip-forwarding) to route traffic.
 
+
 #### Enable the subnet router on the control server
 
 The routes of a tailnet can be displayed with the `headscale nodes list-routes` command. A subnet router with the
@@ -49,7 +47,7 @@ ID | Hostname | Approved | Available                  | Serving (Primary)
 Approve all desired routes of a subnet router by specifying them as comma separated list:
 
 ```console
-$ headscale nodes approve-routes --node 1 --routes 10.0.0.0/8,192.168.0.0/24
+$ headscale nodes approve-routes --identifier 1 --routes 10.0.0.0/8,192.168.0.0/24
 Node updated
 ```
 
@@ -74,7 +72,6 @@ documentation](https://tailscale.com/kb/1019/subnets#use-your-subnet-routes-from
 router on different operating systems.
 
 ### Restrict the use of a subnet router with ACL
-
 The routes announced by subnet routers are available to the nodes in a tailnet. By default, without an ACL enabled, all
 nodes can accept and use such routes. Configure an ACL to explicitly manage who can use routes.
 
@@ -94,15 +91,18 @@ denied.
   "acls": [
     {
       "action": "accept",
-      "src": ["node"],
-      "dst": ["service.example.net:80,443"]
+      "src": [
+        "node"
+      ],
+      "dst": [
+        "service.example.net:80,443"
+      ]
     }
   ]
 }
 ```
 
 ### Automatically approve routes of a subnet router
-
 The initial setup of a subnet router usually requires manual approval of their announced routes on the control server
 before they can be used by a node in a tailnet. Headscale supports the `autoApprovers` section of an ACL to automate the
 approval of routes served with a subnet router.
@@ -114,11 +114,15 @@ owned by the user `alice` and that also advertises the tag `tag:router`.
 ```json title="Subnet routers owned by alice and tagged with tag:router are automatically approved"
 {
   "tagOwners": {
-    "tag:router": ["alice@"]
+    "tag:router": [
+      "alice@"
+    ]
   },
   "autoApprovers": {
     "routes": {
-      "192.168.0.0/24": ["tag:router"]
+      "192.168.0.0/24": [
+        "tag:router"
+      ]
     }
   },
   "acls": [
@@ -137,13 +141,11 @@ Please see the [official Tailscale documentation](https://tailscale.com/kb/1337/
 information on auto approvers.
 
 ## Exit node
-
 The setup of an exit node requires double opt-in, once from an exit node and once on the control server to allow its use
 within the tailnet. Optionally, use [`autoApprovers` to automatically approve an exit
 node](#automatically-approve-an-exit-node-with-auto-approvers).
 
 ### Setup an exit node
-
 #### Configure a node as exit node
 
 Register a node and make it advertise itself as an exit node:
@@ -160,6 +162,7 @@ $ sudo tailscale set --advertise-exit-node
 
 Finally, [enable IP forwarding](#enable-ip-forwarding) to route traffic.
 
+
 #### Enable the exit node on the control server
 
 The routes of a tailnet can be displayed with the `headscale nodes list-routes` command. An exit node can be recognized
@@ -175,7 +178,7 @@ ID | Hostname | Approved | Available       | Serving (Primary)
 For exit nodes, it is sufficient to approve either the IPv4 or IPv6 route. The other will be approved automatically.
 
 ```console
-$ headscale nodes approve-routes --node 1 --routes 0.0.0.0/0
+$ headscale nodes approve-routes --identifier 1 --routes 0.0.0.0/0
 Node updated
 ```
 
@@ -199,9 +202,8 @@ Please refer to the official [Tailscale documentation](https://tailscale.com/kb/
 how to use an exit node on different operating systems.
 
 ### Restrict the use of an exit node with ACL
-
 An exit node is offered to all nodes in a tailnet. By default, without an ACL enabled, all nodes in a tailnet can select
-and use an exit node. Configure `autogroup:internet` in an ACL rule to restrict who can use _any_ of the available exit
+and use an exit node. Configure `autogroup:internet` in an ACL rule to restrict who can use *any* of the available exit
 nodes.
 
 ```json title="Example use of autogroup:internet"
@@ -209,15 +211,18 @@ nodes.
   "acls": [
     {
       "action": "accept",
-      "src": ["..."],
-      "dst": ["autogroup:internet:*"]
+      "src": [
+        "..."
+      ],
+      "dst": [
+        "autogroup:internet:*"
+      ]
     }
   ]
 }
 ```
 
 ### Automatically approve an exit node with auto approvers
-
 The initial setup of an exit node usually requires manual approval on the control server before it can be used by a node
 in a tailnet. Headscale supports the `autoApprovers` section of an ACL to automate the approval of a new exit node as
 soon as it joins the tailnet.
@@ -229,10 +234,14 @@ is automatically approved:
 ```json title="Exit nodes owned by alice and tagged with tag:exit are automatically approved"
 {
   "tagOwners": {
-    "tag:exit": ["alice@"]
+    "tag:exit": [
+      "alice@"
+    ]
   },
   "autoApprovers": {
-    "exitNode": ["tag:exit"]
+    "exitNode": [
+      "tag:exit"
+    ]
   },
   "acls": [
     // more rules
@@ -263,7 +272,6 @@ availability](https://tailscale.com/kb/1115/high-availability#subnet-router-high
     interruptions for clients. See [issue 2129](https://github.com/juanfont/headscale/issues/2129) for more information.
 
 ## Troubleshooting
-
 ### Enable IP forwarding
 
 A subnet router or exit node is routing traffic on behalf of other nodes and thus requires IP forwarding. Check the

docs/ref/tls.md

@@ -2,7 +2,7 @@
 
 ## Bring your own certificate
 
-Headscale can be configured to expose its web service via TLS. To configure the certificate and key file manually, set the `tls_cert_path` and `tls_key_path` configuration parameters. If the path is relative, it will be interpreted as relative to the directory the configuration file was read from.
+Headscale can be configured to expose its web service via TLS. To configure the certificate and key file manually, set the `tls_cert_path` and `tls_cert_path` configuration parameters. If the path is relative, it will be interpreted as relative to the directory the configuration file was read from.
 
 ```yaml title="config.yaml"
 tls_cert_path: ""

docs/setup/install/official.md

@@ -7,7 +7,7 @@ Both are available on the [GitHub releases page](https://github.com/juanfont/hea
 
 It is recommended to use our DEB packages to install headscale on a Debian based system as those packages configure a
 local user to run headscale, provide a default configuration and ship with a systemd service file. Supported
-distributions are Ubuntu 22.04 or newer, Debian 11 or newer.
+distributions are Ubuntu 20.04 or newer, Debian 11 or newer.
 
 1.  Download the [latest headscale package](https://github.com/juanfont/headscale/releases/latest) for your platform (`.deb` for Ubuntu and Debian).
 
@@ -87,8 +87,8 @@ managed by systemd.
     sudo nano /etc/headscale/config.yaml
     ```
 
-1.  Copy [headscale's systemd service file](https://github.com/juanfont/headscale/blob/main/packaging/systemd/headscale.service)
-    to `/etc/systemd/system/headscale.service` and adjust it to suit your local setup. The following parameters likely need
+1.  Copy [headscale's systemd service file](../../packaging/headscale.systemd.service) to
+    `/etc/systemd/system/headscale.service` and adjust it to suit your local setup. The following parameters likely need
     to be modified: `ExecStart`, `WorkingDirectory`, `ReadWritePaths`.
 
 1.  In `/etc/headscale/config.yaml`, override the default `headscale` unix socket with a path that is writable by the

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1752012998,
-        "narHash": "sha256-Q82Ms+FQmgOBkdoSVm+FBpuFoeUAffNerR5yVV7SgT8=",
+        "lastModified": 1746300365,
+        "narHash": "sha256-thYTdWqCRipwPRxWiTiH1vusLuAy0okjOyzRx4hLWh4=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "2a2130494ad647f953593c4e84ea4df839fbd68c",
+        "rev": "f21e4546e3ede7ae34d12a84602a22246b31f7e0",
         "type": "github"
       },
       "original": {

flake.nix

@@ -19,7 +19,6 @@
       overlay = _: prev: let
         pkgs = nixpkgs.legacyPackages.${prev.system};
         buildGo = pkgs.buildGo124Module;
-        vendorHash = "sha256-S2GnCg2dyfjIyi5gXhVEuRs5Bop2JAhZcnhg1fu4/Gg=";
       in {
         headscale = buildGo {
           pname = "headscale";
@@ -31,7 +30,7 @@
 
           # When updating go.mod or go.sum, a new sha will need to be calculated,
           # update this if you have a mismatch after doing a change to those files.
-          inherit vendorHash;
+          vendorHash = "sha256-dR8xmUIDMIy08lhm7r95GNNMAbXv4qSH3v9HR40HlNk=";
 
           subPackages = ["cmd/headscale"];
 
@@ -43,17 +42,6 @@
           ];
         };
 
-        hi = buildGo {
-          pname = "hi";
-          version = headscaleVersion;
-          src = pkgs.lib.cleanSource self;
-
-          checkFlags = ["-short"];
-          inherit vendorHash;
-
-          subPackages = ["cmd/hi"];
-        };
-
         protoc-gen-grpc-gateway = buildGo rec {
           pname = "grpc-gateway";
           version = "2.24.0";
@@ -113,9 +101,9 @@
           buildGoModule = buildGo;
         };
 
-        # gopls = prev.gopls.override {
-        #   buildGoModule = buildGo;
-        # };
+        gopls = prev.gopls.override {
+          buildGoModule = buildGo;
+        };
       };
     }
     // flake-utils.lib.eachDefaultSystem
@@ -156,11 +144,7 @@
           buf
           clang-tools # clang-format
           protobuf-language-server
-
-          # Add hi to make it even easier to use ci runner.
-          hi
-        ]
-        ++ lib.optional pkgs.stdenv.isLinux [traceroute];
+        ];
 
       # Add entry to build a docker image with headscale
       # caveat: only works on Linux

gen/go/headscale/v1/node.pb.go

@@ -913,10 +913,6 @@ func (x *RenameNodeResponse) GetNode() *Node {
 type ListNodesRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	User          string                 `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
-	Id            uint64                 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
-	Name          string                 `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
-	Hostname      string                 `protobuf:"bytes,4,opt,name=hostname,proto3" json:"hostname,omitempty"`
-	IpAddresses   []string               `protobuf:"bytes,5,rep,name=ip_addresses,json=ipAddresses,proto3" json:"ip_addresses,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -958,34 +954,6 @@ func (x *ListNodesRequest) GetUser() string {
 	return ""
 }
 
-func (x *ListNodesRequest) GetId() uint64 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *ListNodesRequest) GetName() string {
-	if x != nil {
-		return x.Name
-	}
-	return ""
-}
-
-func (x *ListNodesRequest) GetHostname() string {
-	if x != nil {
-		return x.Hostname
-	}
-	return ""
-}
-
-func (x *ListNodesRequest) GetIpAddresses() []string {
-	if x != nil {
-		return x.IpAddresses
-	}
-	return nil
-}
-
 type ListNodesResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Nodes         []*Node                `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
@@ -1390,13 +1358,9 @@ const file_headscale_v1_node_proto_rawDesc = "" +
 	"\anode_id\x18\x01 \x01(\x04R\x06nodeId\x12\x19\n" +
 	"\bnew_name\x18\x02 \x01(\tR\anewName\"<\n" +
 	"\x12RenameNodeResponse\x12&\n" +
-	"\x04node\x18\x01 \x01(\v2\x12.headscale.v1.NodeR\x04node\"\x89\x01\n" +
+	"\x04node\x18\x01 \x01(\v2\x12.headscale.v1.NodeR\x04node\"&\n" +
 	"\x10ListNodesRequest\x12\x12\n" +
-	"\x04user\x18\x01 \x01(\tR\x04user\x12\x0e\n" +
-	"\x02id\x18\x02 \x01(\x04R\x02id\x12\x12\n" +
-	"\x04name\x18\x03 \x01(\tR\x04name\x12\x1a\n" +
-	"\bhostname\x18\x04 \x01(\tR\bhostname\x12!\n" +
-	"\fip_addresses\x18\x05 \x03(\tR\vipAddresses\"=\n" +
+	"\x04user\x18\x01 \x01(\tR\x04user\"=\n" +
 	"\x11ListNodesResponse\x12(\n" +
 	"\x05nodes\x18\x01 \x03(\v2\x12.headscale.v1.NodeR\x05nodes\">\n" +
 	"\x0fMoveNodeRequest\x12\x17\n" +

gen/openapiv2/headscale/v1/headscale.swagger.json

@@ -187,35 +187,6 @@
             "in": "query",
             "required": false,
             "type": "string"
-          },
-          {
-            "name": "id",
-            "in": "query",
-            "required": false,
-            "type": "string",
-            "format": "uint64"
-          },
-          {
-            "name": "name",
-            "in": "query",
-            "required": false,
-            "type": "string"
-          },
-          {
-            "name": "hostname",
-            "in": "query",
-            "required": false,
-            "type": "string"
-          },
-          {
-            "name": "ipAddresses",
-            "in": "query",
-            "required": false,
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "collectionFormat": "multi"
           }
         ],
         "tags": [

go.mod

@@ -7,21 +7,19 @@ toolchain go1.24.2
 require (
 	github.com/AlecAivazis/survey/v2 v2.3.7
 	github.com/arl/statsviz v0.6.0
-	github.com/cenkalti/backoff/v5 v5.0.2
+	github.com/cenkalti/backoff/v4 v4.3.0
 	github.com/chasefleming/elem-go v0.30.0
 	github.com/coder/websocket v1.8.13
 	github.com/coreos/go-oidc/v3 v3.14.1
-	github.com/creachadair/command v0.1.22
-	github.com/creachadair/flax v0.0.5
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
-	github.com/docker/docker v28.2.2+incompatible
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/glebarez/sqlite v1.11.0
 	github.com/go-gormigrate/gormigrate/v2 v2.1.4
 	github.com/gofrs/uuid/v5 v5.3.2
 	github.com/google/go-cmp v0.7.0
 	github.com/gorilla/mux v1.8.1
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.0
+	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3
 	github.com/jagottsicher/termcolor v1.0.2
 	github.com/klauspost/compress v1.18.0
 	github.com/oauth2-proxy/mockoidc v0.0.0-20240214162133-caebfff84d25
@@ -29,34 +27,33 @@ require (
 	github.com/philip-bui/grpc-zerolog v1.0.1
 	github.com/pkg/profile v1.7.0
 	github.com/prometheus/client_golang v1.22.0
-	github.com/prometheus/common v0.65.0
-	github.com/pterm/pterm v0.12.81
-	github.com/puzpuzpuz/xsync/v4 v4.1.0
+	github.com/prometheus/common v0.63.0
+	github.com/pterm/pterm v0.12.80
+	github.com/puzpuzpuz/xsync/v3 v3.5.1
 	github.com/rs/zerolog v1.34.0
-	github.com/samber/lo v1.51.0
+	github.com/samber/lo v1.50.0
 	github.com/sasha-s/go-deadlock v0.3.5
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/viper v1.20.1
 	github.com/stretchr/testify v1.10.0
 	github.com/tailscale/hujson v0.0.0-20250226034555-ec1d1c113d33
-	github.com/tailscale/squibble v0.0.0-20250108170732-a4ca58afa694
 	github.com/tailscale/tailsql v0.0.0-20250421235516-02f85f087b97
 	github.com/tcnksm/go-latest v0.0.0-20170313132115-e3007ae9052e
 	go4.org/netipx v0.0.0-20231129151722-fdeea329fbba
-	golang.org/x/crypto v0.39.0
+	golang.org/x/crypto v0.37.0
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0
-	golang.org/x/net v0.41.0
-	golang.org/x/oauth2 v0.30.0
-	golang.org/x/sync v0.15.0
-	google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822
-	google.golang.org/grpc v1.73.0
+	golang.org/x/net v0.39.0
+	golang.org/x/oauth2 v0.29.0
+	golang.org/x/sync v0.13.0
+	google.golang.org/genproto/googleapis/api v0.0.0-20250428153025-10db94c68c34
+	google.golang.org/grpc v1.72.0
 	google.golang.org/protobuf v1.36.6
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c
 	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/driver/postgres v1.6.0
-	gorm.io/gorm v1.30.0
-	tailscale.com v1.84.2
-	zgo.at/zcache/v2 v2.2.0
+	gorm.io/driver/postgres v1.5.11
+	gorm.io/gorm v1.25.12
+	tailscale.com v1.83.0-pre.0.20250331211809-96fe8a6db6c9
+	zgo.at/zcache/v2 v2.1.0
 	zombiezen.com/go/postgrestest v1.0.1
 )
 
@@ -81,7 +78,7 @@ require (
 	modernc.org/libc v1.62.1 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.10.0 // indirect
-	modernc.org/sqlite v1.37.0
+	modernc.org/sqlite v1.37.0 // indirect
 )
 
 require (
@@ -110,31 +107,25 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/sts v1.33.13 // indirect
 	github.com/aws/smithy-go v1.22.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/containerd/console v1.0.5 // indirect
+	github.com/containerd/console v1.0.4 // indirect
 	github.com/containerd/continuity v0.4.5 // indirect
-	github.com/containerd/errdefs v0.3.0 // indirect
-	github.com/containerd/errdefs/pkg v0.3.0 // indirect
 	github.com/coreos/go-iptables v0.7.1-0.20240112124308-65c67c9f46e6 // indirect
-	github.com/creachadair/mds v0.24.3 // indirect
+	github.com/creachadair/mds v0.24.1 // indirect
 	github.com/dblohm7/wingoes v0.0.0-20240123200102-b75a8a7d7eb0 // indirect
 	github.com/digitalocean/go-smbios v0.0.0-20180907143718-390a4f403a8e // indirect
-	github.com/distribution/reference v0.6.0 // indirect
 	github.com/docker/cli v28.1.1+incompatible // indirect
+	github.com/docker/docker v28.1.1+incompatible // indirect
 	github.com/docker/go-connections v0.5.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/felixge/fgprof v0.9.5 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
 	github.com/gaissmai/bart v0.18.0 // indirect
 	github.com/glebarez/go-sqlite v1.22.0 // indirect
 	github.com/go-jose/go-jose/v3 v3.0.4 // indirect
 	github.com/go-jose/go-jose/v4 v4.1.0 // indirect
 	github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
 	github.com/godbus/dbus/v5 v5.1.1-0.20230522191255-76236955d466 // indirect
@@ -157,6 +148,7 @@ require (
 	github.com/hdevalence/ed25519consensus v0.2.0 // indirect
 	github.com/illarion/gonotify/v3 v3.0.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/insomniacslk/dhcp v0.0.0-20240129002554-15c9b8791914 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/pgx/v5 v5.7.4 // indirect
@@ -166,6 +158,7 @@ require (
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/jsimonetti/rtnetlink v1.4.1 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/kortschak/wol v0.0.0-20200729010619-da482cc4850a // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/lib/pq v1.10.9 // indirect
@@ -181,10 +174,8 @@ require (
 	github.com/miekg/dns v1.1.58 // indirect
 	github.com/mitchellh/go-ps v1.0.0 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/moby/sys/atomicwriter v0.1.0 // indirect
 	github.com/moby/sys/user v0.4.0 // indirect
 	github.com/moby/term v0.5.2 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
@@ -192,10 +183,11 @@ require (
 	github.com/opencontainers/runc v1.3.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/petermattis/goid v0.0.0-20250319124200-ccd6737f222a // indirect
+	github.com/pierrec/lz4/v4 v4.1.21 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus-community/pro-bing v0.4.0 // indirect
-	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
@@ -214,31 +206,26 @@ require (
 	github.com/tailscale/netlink v1.1.1-0.20240822203006-4d49adab4de7 // indirect
 	github.com/tailscale/peercred v0.0.0-20250107143737-35a0c7bd7edc // indirect
 	github.com/tailscale/setec v0.0.0-20250305161714-445cadbbca3d // indirect
+	github.com/tailscale/squibble v0.0.0-20250108170732-a4ca58afa694 // indirect
 	github.com/tailscale/web-client-prebuilt v0.0.0-20250124233751-d4cd19a26976 // indirect
-	github.com/tailscale/wireguard-go v0.0.0-20250304000100-91a0587fb251 // indirect
+	github.com/tailscale/wireguard-go v0.0.0-20250107165329-0b8b35511f19 // indirect
+	github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 // indirect
 	github.com/vishvananda/netns v0.0.4 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 // indirect
-	go.opentelemetry.io/otel v1.36.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0 // indirect
-	go.opentelemetry.io/otel/metric v1.36.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.36.0 // indirect
-	go.opentelemetry.io/otel/trace v1.36.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go4.org/mem v0.0.0-20240501181205-ae6ca9944745 // indirect
-	golang.org/x/mod v0.25.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/term v0.32.0 // indirect
-	golang.org/x/text v0.26.0 // indirect
+	golang.org/x/mod v0.24.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/term v0.31.0 // indirect
+	golang.org/x/text v0.24.0 // indirect
 	golang.org/x/time v0.10.0 // indirect
-	golang.org/x/tools v0.33.0 // indirect
+	golang.org/x/tools v0.32.0 // indirect
 	golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect
 	golang.zx2c4.com/wireguard/windows v0.5.3 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34 // indirect
 	gvisor.dev/gvisor v0.0.0-20250205023644-9414b50a5633 // indirect
 )

go.sum

@@ -1,5 +1,3 @@
-9fans.net/go v0.0.8-0.20250307142834-96bdba94b63f h1:1C7nZuxUMNz7eiQALRfiqNOm04+m3edWlRff/BYHf0Q=
-9fans.net/go v0.0.8-0.20250307142834-96bdba94b63f/go.mod h1:hHyrZRryGqVdqrknjq5OWDLGCTJ2NeEvtrpR96mjraM=
 atomicgo.dev/assert v0.0.2 h1:FiKeMiZSgRrZsPo9qn/7vmr7mCsh5SZyXY4YGYiYwrg=
 atomicgo.dev/assert v0.0.2/go.mod h1:ut4NcI3QDdJtlmAxQULOmA13Gz6e2DWbSAS8RUOmNYQ=
 atomicgo.dev/cursor v0.2.0 h1:H6XN5alUJ52FZZUkI7AlJbUc1aW38GWZalpYRPpoPOw=
@@ -8,6 +6,7 @@ atomicgo.dev/keyboard v0.2.9 h1:tOsIid3nlPLZ3lwgG8KZMp/SFmr7P0ssEN5JUsm78K8=
 atomicgo.dev/keyboard v0.2.9/go.mod h1:BC4w9g00XkxH/f1HXhW2sXmJFOCWbKn9xrOunSFtExQ=
 atomicgo.dev/schedule v0.1.0 h1:nTthAbhZS5YZmgYbb2+DH8uQIZcTlIrd4eYr3UQxEjs=
 atomicgo.dev/schedule v0.1.0/go.mod h1:xeUa3oAkiuHYh8bKiQBRojqAMq3PXXbJujjb0hw8pEU=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
 dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
@@ -18,6 +17,7 @@ github.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkk
 github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs=
 github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/MarvinJWendt/testza v0.1.0/go.mod h1:7AxNvlfeHP7Z/hDQ5JtE3OKYT3XFUeLCDE2DQninSqs=
@@ -82,12 +82,12 @@ github.com/aws/aws-sdk-go-v2/service/sts v1.33.13 h1:3LXNnmtH3TURctC23hnC0p/39Q5
 github.com/aws/aws-sdk-go-v2/service/sts v1.33.13/go.mod h1:7Yn+p66q/jt38qMoVfNvjbm3D89mGBnkwDcijgtih8w=
 github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
 github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/cenkalti/backoff/v5 v5.0.2 h1:rIfFVxEf1QsI7E1ZHfp/B4DF/6QBAUhmgkxc0H7Zss8=
-github.com/cenkalti/backoff/v5 v5.0.2/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chasefleming/elem-go v0.30.0 h1:BlhV1ekv1RbFiM8XZUQeln1Ikb4D+bu2eDO4agREvok=
@@ -103,33 +103,23 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn
 github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
 github.com/cilium/ebpf v0.17.3 h1:FnP4r16PWYSE4ux6zN+//jMcW4nMVRvuTLVTvCjyyjg=
 github.com/cilium/ebpf v0.17.3/go.mod h1:G5EDHij8yiLzaqn0WjyfJHvRa+3aDlReIaLVRMvOyJk=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/coder/websocket v1.8.13 h1:f3QZdXy7uGVz+4uCJy2nTZyM0yTBj8yANEHhqlXZ9FE=
 github.com/coder/websocket v1.8.13/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
 github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U=
-github.com/containerd/console v1.0.5 h1:R0ymNeydRqH2DmakFNdmjR2k0t7UPuiOV/N/27/qqsc=
-github.com/containerd/console v1.0.5/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
+github.com/containerd/console v1.0.4 h1:F2g4+oChYvBTsASRTz8NP6iIAi97J3TtSAsLbIFn4ro=
+github.com/containerd/console v1.0.4/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
 github.com/containerd/continuity v0.4.5 h1:ZRoN1sXq9u7V6QoHMcVWGhOwDFqZ4B9i5H6un1Wh0x4=
 github.com/containerd/continuity v0.4.5/go.mod h1:/lNJvtJKUQStBzpVQ1+rasXO1LAWtUQssk28EZvJ3nE=
-github.com/containerd/errdefs v0.3.0 h1:FSZgGOeK4yuT/+DnF07/Olde/q4KBoMsaamhXxIMDp4=
-github.com/containerd/errdefs v0.3.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
-github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
-github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
-github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
-github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
 github.com/coreos/go-iptables v0.7.1-0.20240112124308-65c67c9f46e6 h1:8h5+bWd7R6AYUslN6c6iuZWTKsKxUFDlpnmilO6R2n0=
 github.com/coreos/go-iptables v0.7.1-0.20240112124308-65c67c9f46e6/go.mod h1:Qe8Bv2Xik5FyTXwgIbLAnv2sWSBmvWdFETJConOQ//Q=
 github.com/coreos/go-oidc/v3 v3.14.1 h1:9ePWwfdwC4QKRlCXsJGou56adA/owXczOzwKdOumLqk=
 github.com/coreos/go-oidc/v3 v3.14.1/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmrfah6hnSYEU=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
-github.com/creachadair/command v0.1.22 h1:WmdrURwZdmPD1jm13SjKooaMoqo7mW1qI2BPCShs154=
-github.com/creachadair/command v0.1.22/go.mod h1:YFc+OMGucqTpxwQg/iJnNg8BMNmRPDK60rYy8ckgKwE=
-github.com/creachadair/flax v0.0.5 h1:zt+CRuXQASxwQ68e9GHAOnEgAU29nF0zYMHOCrL5wzE=
-github.com/creachadair/flax v0.0.5/go.mod h1:F1PML0JZLXSNDMNiRGK2yjm5f+L9QCHchyHBldFymj8=
-github.com/creachadair/mds v0.24.3 h1:X7cM2ymZSyl4IVWnfyXLxRXMJ6awhbcWvtLPhfnTaqI=
-github.com/creachadair/mds v0.24.3/go.mod h1:0oeHt9QWu8VfnmskOL4zi2CumjEvB29ScmtOmdrhFeU=
-github.com/creachadair/taskgroup v0.13.2 h1:3KyqakBuFsm3KkXi/9XIb0QcA8tEzLHLgaoidf0MdVc=
-github.com/creachadair/taskgroup v0.13.2/go.mod h1:i3V1Zx7H8RjwljUEeUWYT30Lmb9poewSb2XI1yTwD0g=
+github.com/creachadair/mds v0.24.1 h1:bzL4ItCtAUxxO9KkotP0PVzlw4tnJicAcjPu82v2mGs=
+github.com/creachadair/mds v0.24.1/go.mod h1:ArfS0vPHoLV/SzuIzoqTEZfoYmac7n9Cj8XPANHocvw=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 github.com/creack/pty v1.1.23 h1:4M6+isWdcStXEf15G/RbrMPOQj1dZ7HPZCGwE4kOeP0=
@@ -142,14 +132,12 @@ github.com/dblohm7/wingoes v0.0.0-20240123200102-b75a8a7d7eb0 h1:vrC07UZcgPzu/Oj
 github.com/dblohm7/wingoes v0.0.0-20240123200102-b75a8a7d7eb0/go.mod h1:Nx87SkVqTKd8UtT+xu7sM/l+LgXs6c0aHrlKusR+2EQ=
 github.com/digitalocean/go-smbios v0.0.0-20180907143718-390a4f403a8e h1:vUmf0yezR0y7jJ5pceLHthLaYf4bA5T14B6q39S4q2Q=
 github.com/digitalocean/go-smbios v0.0.0-20180907143718-390a4f403a8e/go.mod h1:YTIHhz/QFSYnu/EhlF2SpU2Uk+32abacUYA5ZPljz1A=
-github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
-github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/djherbis/times v1.6.0 h1:w2ctJ92J8fBvWPxugmXIv7Nz7Q3iDMKNx9v5ocVH20c=
 github.com/djherbis/times v1.6.0/go.mod h1:gOHeRAz2h+VJNZ5Gmc/o7iD9k4wW7NMVqieYCY99oc0=
 github.com/docker/cli v28.1.1+incompatible h1:eyUemzeI45DY7eDPuwUcmDyDj1pM98oD5MdSpiItp8k=
 github.com/docker/cli v28.1.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/docker v28.2.2+incompatible h1:CjwRSksz8Yo4+RmQ339Dp/D2tGO5JxwYeqtMOEe0LDw=
-github.com/docker/docker v28.2.2+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v28.1.1+incompatible h1:49M11BFLsVO1gxY9UX9p/zwkE/rswggs8AdFmXQw51I=
+github.com/docker/docker v28.1.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
 github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
@@ -158,11 +146,13 @@ github.com/dsnet/try v0.0.3 h1:ptR59SsrcFUYbT/FhAbKTV6iLkeD6O18qfIWRml2fqI=
 github.com/dsnet/try v0.0.3/go.mod h1:WBM8tRpUmnXXhY1U6/S8dt6UWdHTQ7y8A5YSkRCkq40=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/felixge/fgprof v0.9.3/go.mod h1:RdbpDgzqYVh/T9fPELJyV7EYJuHB55UTEULNun8eiPw=
 github.com/felixge/fgprof v0.9.5 h1:8+vR6yu2vvSKn08urWyEuxx75NWPEvybbkBirEpsbVY=
 github.com/felixge/fgprof v0.9.5/go.mod h1:yKl+ERSa++RYOs32d8K6WEXCB4uXdLls4ZaZPpayhMM=
-github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
-github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -185,7 +175,8 @@ github.com/go-jose/go-jose/v4 v4.1.0 h1:cYSYxd3pw5zd2FSXk2vGdn9igQU2PS8MuxrCOCl0
 github.com/go-jose/go-jose/v4 v4.1.0/go.mod h1:GG/vqmYm3Von2nYiB2vGTXzdoNKE5tix5tuc6iAd+sw=
 github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874 h1:F8d1AJ6M9UQCavhwmO6ZsrYLfG8zVFWfEfMS2MXPkSY=
 github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M=
-github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
@@ -194,10 +185,9 @@ github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
 github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
 github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
-github.com/go4org/plan9netshell v0.0.0-20250324183649-788daa080737 h1:cf60tHxREO3g1nroKr2osU3JWZsJzkfi7rEg+oAB0Lo=
-github.com/go4org/plan9netshell v0.0.0-20250324183649-788daa080737/go.mod h1:MIS0jDzbU/vuM9MC4YnBITCv+RYuTRq8dJzmCrFsK9g=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.2.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
@@ -210,12 +200,18 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
 github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU=
 github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
@@ -224,8 +220,6 @@ github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4r
 github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
-github.com/google/go-tpm v0.9.4 h1:awZRf9FwOeTunQmHoDYSHJps3ie6f1UlhS1fOdPEt1I=
-github.com/google/go-tpm v0.9.4/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
 github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/nftables v0.2.1-0.20240414091927-5e242ec57806 h1:wG8RYIyctLhdFk6Vl1yPGtSRtwGpVkWyZww1OCil2MI=
@@ -250,8 +244,10 @@ github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kX
 github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.0 h1:+epNPbD5EqgpEMm5wrl4Hqts3jZt8+kYaqUisuuIGTk=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.0/go.mod h1:Zanoh4+gvIgluNqcfMVTJueD4wSS5hT7zTt4Mrutd90=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI=
 github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
 github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hdevalence/ed25519consensus v0.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU=
@@ -300,6 +296,7 @@ github.com/klauspost/cpuid/v2 v2.0.10/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuOb
 github.com/klauspost/cpuid/v2 v2.0.12/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
 github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
 github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kortschak/wol v0.0.0-20200729010619-da482cc4850a h1:+RR6SqnTkDLWyICxS1xpjCi/3dhyV+TgZwA6Ww3KncQ=
 github.com/kortschak/wol v0.0.0-20200729010619-da482cc4850a/go.mod h1:YTtCCM3ryyfiu4F7t8HQ1mxvp1UBdWM2r6Xa+nGWvDk=
 github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8=
@@ -350,16 +347,10 @@ github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc
 github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
-github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw=
-github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs=
-github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU=
-github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko=
 github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs=
 github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs=
 github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=
 github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=
-github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
-github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
@@ -374,6 +365,7 @@ github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJw
 github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M=
 github.com/opencontainers/runc v1.3.0 h1:cvP7xbEvD0QQAs0nZKLzkVog2OPZhI/V2w3WmTmUSXI=
 github.com/opencontainers/runc v1.3.0/go.mod h1:9wbWt42gV+KRxKRVVugNP6D5+PQciRbenB4fLVsqGPs=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
 github.com/ory/dockertest/v3 v3.12.0 h1:3oV9d0sDzlSQfHtIaB5k6ghUCVMVLpAY8hwrqoCyRCw=
 github.com/ory/dockertest/v3 v3.12.0/go.mod h1:aKNDTva3cp8dwOWwb9cWuX84aH5akkxXRvO7KCwWVjE=
@@ -387,6 +379,7 @@ github.com/philip-bui/grpc-zerolog v1.0.1/go.mod h1:qXbiq/2X4ZUMMshsqlWyTHOcw7ns
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA=
@@ -400,10 +393,11 @@ github.com/prometheus-community/pro-bing v0.4.0 h1:YMbv+i08gQz97OZZBwLyvmmQEEzyf
 github.com/prometheus-community/pro-bing v0.4.0/go.mod h1:b7wRYZtCcPmt4Sz319BykUU241rWLe1VFXyiyWK/dH4=
 github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
 github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
-github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
-github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
-github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k=
+github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18=
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/pterm/pterm v0.12.27/go.mod h1:PhQ89w4i95rhgE+xedAoqous6K9X+r6aSOI2eFF7DZI=
@@ -413,10 +407,10 @@ github.com/pterm/pterm v0.12.31/go.mod h1:32ZAWZVXD7ZfG0s8qqHXePte42kdz8ECtRyEej
 github.com/pterm/pterm v0.12.33/go.mod h1:x+h2uL+n7CP/rel9+bImHD5lF3nM9vJj80k9ybiiTTE=
 github.com/pterm/pterm v0.12.36/go.mod h1:NjiL09hFhT/vWjQHSj1athJpx6H8cjpHXNAK5bUw8T8=
 github.com/pterm/pterm v0.12.40/go.mod h1:ffwPLwlbXxP+rxT0GsgDTzS3y3rmpAO1NMjUkGTYf8s=
-github.com/pterm/pterm v0.12.81 h1:ju+j5I2++FO1jBKMmscgh5h5DPFDFMB7epEjSoKehKA=
-github.com/pterm/pterm v0.12.81/go.mod h1:TyuyrPjnxfwP+ccJdBTeWHtd/e0ybQHkOS/TakajZCw=
-github.com/puzpuzpuz/xsync/v4 v4.1.0 h1:x9eHRl4QhZFIPJ17yl4KKW9xLyVWbb3/Yq4SXpjF71U=
-github.com/puzpuzpuz/xsync/v4 v4.1.0/go.mod h1:VJDmTCJMBt8igNxnkQd86r+8KUeN1quSfNKu5bLYFQo=
+github.com/pterm/pterm v0.12.80 h1:mM55B+GnKUnLMUSqhdINe4s6tOuVQIetQ3my8JGyAIg=
+github.com/pterm/pterm v0.12.80/go.mod h1:c6DeF9bSnOSeFPZlfs4ZRAFcf5SCoTwvwQ5xaKGQlHo=
+github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg=
+github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
@@ -433,13 +427,14 @@ github.com/safchain/ethtool v0.3.0 h1:gimQJpsI6sc1yIqP/y8GYgiXn/NjgvpM0RNoWLVVmP
 github.com/safchain/ethtool v0.3.0/go.mod h1:SA9BwrgyAqNo7M+uaL6IYbxpm5wk3L7Mm6ocLW+CJUs=
 github.com/sagikazarmark/locafero v0.9.0 h1:GbgQGNtTrEmddYDSAH9QLRyfAHY12md+8YFTqyMTC9k=
 github.com/sagikazarmark/locafero v0.9.0/go.mod h1:UBUyz37V+EdMS3hDF3QWIiVr/2dPrx49OMO0Bn0hJqk=
-github.com/samber/lo v1.51.0 h1:kysRYLbHy/MB7kQZf5DSN50JHmMsNEdeY24VzJFu7wI=
-github.com/samber/lo v1.51.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
+github.com/samber/lo v1.50.0 h1:XrG0xOeHs+4FQ8gJR97zDz5uOFMW7OwFWiFVzqopKgY=
+github.com/samber/lo v1.50.0/go.mod h1:RjZyNk6WSnUFRKK6EyOhsRJMqft3G+pg7dCWHQCWvsc=
 github.com/sasha-s/go-deadlock v0.3.5 h1:tNCOEEDG6tBqrNDOX35j/7hL5FcFViG6awUGROb2NsU=
 github.com/sasha-s/go-deadlock v0.3.5/go.mod h1:bugP6EGbdGYObIlx7pUZtWqlvo8k9H6vCBBsiChJQ5U=
 github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
@@ -455,9 +450,11 @@ github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4=
 github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -472,8 +469,8 @@ github.com/tailscale/certstore v0.1.1-0.20231202035212-d3fa0460f47e h1:PtWT87weP
 github.com/tailscale/certstore v0.1.1-0.20231202035212-d3fa0460f47e/go.mod h1:XrBNfAFN+pwoWuksbFS9Ccxnopa15zJGgXRFN90l3K4=
 github.com/tailscale/go-winio v0.0.0-20231025203758-c4f33415bf55 h1:Gzfnfk2TWrk8Jj4P4c1a3CtQyMaTVCznlkLZI++hok4=
 github.com/tailscale/go-winio v0.0.0-20231025203758-c4f33415bf55/go.mod h1:4k4QO+dQ3R5FofL+SanAUZe+/QfeK0+OIuwDIRu2vSg=
-github.com/tailscale/golang-x-crypto v0.0.0-20250404221719-a5573b049869 h1:SRL6irQkKGQKKLzvQP/ke/2ZuB7Py5+XuqtOgSj+iMM=
-github.com/tailscale/golang-x-crypto v0.0.0-20250404221719-a5573b049869/go.mod h1:ikbF+YT089eInTp9f2vmvy4+ZVnW5hzX1q2WknxSprQ=
+github.com/tailscale/golang-x-crypto v0.0.0-20250218230618-9a281fd8faca h1:ecjHwH73Yvqf/oIdQ2vxAX+zc6caQsYdPzsxNW1J3G8=
+github.com/tailscale/golang-x-crypto v0.0.0-20250218230618-9a281fd8faca/go.mod h1:ikbF+YT089eInTp9f2vmvy4+ZVnW5hzX1q2WknxSprQ=
 github.com/tailscale/goupnp v1.0.1-0.20210804011211-c64d0f06ea05 h1:4chzWmimtJPxRs2O36yuGRW3f9SYV+bMTTvMBI0EKio=
 github.com/tailscale/goupnp v1.0.1-0.20210804011211-c64d0f06ea05/go.mod h1:PdCqy9JzfWMJf1H5UJW2ip33/d4YkoKN0r67yKH1mG8=
 github.com/tailscale/hujson v0.0.0-20250226034555-ec1d1c113d33 h1:idh63uw+gsG05HwjZsAENCG4KZfyvjK03bpjxa5qRRk=
@@ -492,8 +489,8 @@ github.com/tailscale/web-client-prebuilt v0.0.0-20250124233751-d4cd19a26976 h1:U
 github.com/tailscale/web-client-prebuilt v0.0.0-20250124233751-d4cd19a26976/go.mod h1:agQPE6y6ldqCOui2gkIh7ZMztTkIQKH049tv8siLuNQ=
 github.com/tailscale/wf v0.0.0-20240214030419-6fbb0a674ee6 h1:l10Gi6w9jxvinoiq15g8OToDdASBni4CyJOdHY1Hr8M=
 github.com/tailscale/wf v0.0.0-20240214030419-6fbb0a674ee6/go.mod h1:ZXRML051h7o4OcI0d3AaILDIad/Xw0IkXaHM17dic1Y=
-github.com/tailscale/wireguard-go v0.0.0-20250304000100-91a0587fb251 h1:h/41LFTrwMxB9Xvvug0kRdQCU5TlV1+pAMQw0ZtDE3U=
-github.com/tailscale/wireguard-go v0.0.0-20250304000100-91a0587fb251/go.mod h1:BOm5fXUBFM+m9woLNBoxI9TaBXXhGNP50LX/TGIvGb4=
+github.com/tailscale/wireguard-go v0.0.0-20250107165329-0b8b35511f19 h1:BcEJP2ewTIK2ZCsqgl6YGpuO6+oKqqag5HHb7ehljKw=
+github.com/tailscale/wireguard-go v0.0.0-20250107165329-0b8b35511f19/go.mod h1:BOm5fXUBFM+m9woLNBoxI9TaBXXhGNP50LX/TGIvGb4=
 github.com/tailscale/xnet v0.0.0-20240729143630-8497ac4dab2e h1:zOGKqN5D5hHhiYUp091JqK7DPCqSARyUfduhGUY8Bek=
 github.com/tailscale/xnet v0.0.0-20240729143630-8497ac4dab2e/go.mod h1:orPd6JZXXRyuDusYilywte7k094d7dycXXU5YnWsrwg=
 github.com/tc-hib/winres v0.2.1 h1:YDE0FiP0VmtRaDn7+aaChp1KiF4owBiJa5l964l5ujA=
@@ -502,8 +499,8 @@ github.com/tcnksm/go-latest v0.0.0-20170313132115-e3007ae9052e h1:IWllFTiDjjLIf2
 github.com/tcnksm/go-latest v0.0.0-20170313132115-e3007ae9052e/go.mod h1:d7u6HkTYKSv5m6MCKkOQlHwaShTMl3HjqSGW3XtVhXM=
 github.com/tink-crypto/tink-go/v2 v2.1.0 h1:QXFBguwMwTIaU17EgZpEJWsUSc60b1BAGTzBIoMdmok=
 github.com/tink-crypto/tink-go/v2 v2.1.0/go.mod h1:y1TnYFt1i2eZVfx4OGc+C+EMp4CoKWAw2VSEuoicHHI=
-github.com/u-root/u-root v0.14.0 h1:Ka4T10EEML7dQ5XDvO9c3MBN8z4nuSnGjcd1jmU2ivg=
-github.com/u-root/u-root v0.14.0/go.mod h1:hAyZorapJe4qzbLWlAkmSVCJGbfoU9Pu4jpJ1WMluqE=
+github.com/u-root/u-root v0.12.0 h1:K0AuBFriwr0w/PGS3HawiAw89e3+MU7ks80GpghAsNs=
+github.com/u-root/u-root v0.12.0/go.mod h1:FYjTOh4IkIZHhjsd17lb8nYW6udgXdJhG1c0r6u0arI=
 github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 h1:pyC9PaHYZFgEKFdlp3G8RaCKgVpHZnecvArXvPXcFkM=
 github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701/go.mod h1:P3a5rG4X7tI17Nn3aOIAYr5HbIMukwXG0urG0WuL8OA=
 github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
@@ -526,26 +523,22 @@ github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9dec
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 h1:yd02MEjBdJkG3uabWP9apV+OuWRIXGDuJEUJbOHmCFU=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0/go.mod h1:umTcuxiv1n/s/S6/c2AT/g2CQ7u5C59sHDNmfSwgz7Q=
-go.opentelemetry.io/otel v1.36.0 h1:UumtzIklRBY6cI/lllNZlALOF5nNIzJVb16APdvgTXg=
-go.opentelemetry.io/otel v1.36.0/go.mod h1:/TcFMXYjyRNh8khOAO9ybYkqaDBb/70aVwkNML4pP8E=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0 h1:dNzwXjZKpMpE2JhmO+9HsPl42NIXFIFSUSSs0fiqra0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0/go.mod h1:90PoxvaEB5n6AOdZvi+yWJQoE95U8Dhhw2bSyRqnTD0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0 h1:nRVXXvf78e00EwY6Wp0YII8ww2JVWshZ20HfTlE11AM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0/go.mod h1:r49hO7CgrxY9Voaj3Xe8pANWtr0Oq916d0XAmOoCZAQ=
-go.opentelemetry.io/otel/metric v1.36.0 h1:MoWPKVhQvJ+eeXWHFBOPoBOi20jh6Iq2CcCREuTYufE=
-go.opentelemetry.io/otel/metric v1.36.0/go.mod h1:zC7Ks+yeyJt4xig9DEw9kuUFe5C3zLbVjV2PzT6qzbs=
-go.opentelemetry.io/otel/sdk v1.36.0 h1:b6SYIuLRs88ztox4EyrvRti80uXIFy+Sqzoh9kFULbs=
-go.opentelemetry.io/otel/sdk v1.36.0/go.mod h1:+lC+mTgD+MUWfjJubi2vvXWcVxyr9rmlshZni72pXeY=
-go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o=
-go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w=
-go.opentelemetry.io/otel/trace v1.36.0 h1:ahxWNuqZjpdiFAyrIoQ4GIiAIhxAunQR6MUoKrsNd4w=
-go.opentelemetry.io/otel/trace v1.36.0/go.mod h1:gQ+OnDZzrybY4k4seLzPAWNwVBBVlF2szhehOBB/tGA=
-go.opentelemetry.io/proto/otlp v1.6.0 h1:jQjP+AQyTf+Fe7OKj/MfkDrmK4MNVtw2NpXsf9fefDI=
-go.opentelemetry.io/proto/otlp v1.6.0/go.mod h1:cicgGehlFuNdgZkcALOCh3VE6K/u2tAjzlRhDwmVpZc=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
+go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
+go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
+go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk=
+go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
 go4.org/mem v0.0.0-20240501181205-ae6ca9944745 h1:Tl++JLUCe4sxGu8cTpDzRLd3tN7US4hOxG5YpKCzkek=
 go4.org/mem v0.0.0-20240501181205-ae6ca9944745/go.mod h1:reUoABIJ9ikfM5sgtSF3Wushcza7+WeD01VB9Lirh3g=
 go4.org/netipx v0.0.0-20231129151722-fdeea329fbba h1:0b9z3AuHCjxk0x/opv64kcgZLBseWJUpBw5I82+2U4M=
@@ -555,20 +548,29 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
+golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
 golang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f h1:phY1HzDcf18Aq9A8KkmRtY9WvOFIxN8wgfvy6Zm1DV8=
 golang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
 golang.org/x/image v0.24.0 h1:AN7zRgVsbvmTfNyqIbbOraYL8mSwcKncEj8ofjgzcMQ=
 golang.org/x/image v0.24.0/go.mod h1:4b/ITuLfqYq1hqZcjofwctIhi7sZh2WaCjvsBNjjya8=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
-golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -577,21 +579,26 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.29.0 h1:WdYw2tdTK1S8olAzWHdgeqfy+Mtm9XNhv/xJsY65d98=
+golang.org/x/oauth2 v0.29.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
+golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -602,6 +609,7 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211013075003-97ac67df715c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -615,8 +623,8 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -624,8 +632,8 @@ golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuX
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
+golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
@@ -633,18 +641,23 @@ golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
 golang.org/x/time v0.10.0 h1:3usCWA8tQn0L8+hFJQNgzpWbd89begxN66o1Ojdn5L4=
 golang.org/x/time v0.10.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+golang.org/x/tools v0.32.0 h1:Q7N1vhpkQv7ybVzLFtTjvQya2ewbwNDZzUgfXGqtMWU=
+golang.org/x/tools v0.32.0/go.mod h1:ZxrU41P/wAbZD8EDa6dDCa6XfpkhJ7HFMjHJXfBDu8s=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -653,15 +666,26 @@ golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 h1:B82qJJgjvYKsXS9jeu
 golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2/go.mod h1:deeaetjYA+DHMHg+sMSMI58GrEteJUUzzw7en6TJQcI=
 golang.zx2c4.com/wireguard/windows v0.5.3 h1:On6j2Rpn3OEMXqBq00QEDC7bWSZrPIHKIus8eIuExIE=
 golang.zx2c4.com/wireguard/windows v0.5.3/go.mod h1:9TEe8TJmtwyQebdFwAkEWOPr3prrtqm+REGFifP60hI=
-google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822 h1:oWVWY3NzT7KJppx2UKhKmzPq4SRe0LdCijVRwvGeikY=
-google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822/go.mod h1:h3c4v36UTKzUiuaOKQ6gr3S+0hovBtUrXzTG/i3+XEc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 h1:fc6jSaCT0vBduLYZHYrBBNY4dsWuvgyff9noRNDdBeE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
-google.golang.org/grpc v1.73.0 h1:VIWSmpI2MegBtTuFt5/JWy2oXxtjJ/e89Z70ImfD2ok=
-google.golang.org/grpc v1.73.0/go.mod h1:50sbHOUqWoCQGI8V2HQLJM0B+LMlIUjNSZmow7EVBQc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto/googleapis/api v0.0.0-20250428153025-10db94c68c34 h1:0PeQib/pH3nB/5pEmFeVQJotzGohV0dq4Vcp09H5yhE=
+google.golang.org/genproto/googleapis/api v0.0.0-20250428153025-10db94c68c34/go.mod h1:0awUlEkap+Pb1UMeJwJQQAdJQrt3moU7J2moTy69irI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34 h1:h6p3mQqrmT1XkHVTfzLdNz1u7IhINeZkz67/xTbOuWs=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM=
+google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
 google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -674,28 +698,36 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/driver/postgres v1.6.0 h1:2dxzU8xJ+ivvqTRph34QX+WrRaJlmfyPqXmoGVjMBa4=
-gorm.io/driver/postgres v1.6.0/go.mod h1:vUw0mrGgrTK+uPHEhAdV4sfFELrByKVGnaVRkXDhtWo=
-gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
-gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
+gorm.io/driver/postgres v1.5.11 h1:ubBVAfbKEUld/twyKZ0IYn9rSQh448EdelLYk9Mv314=
+gorm.io/driver/postgres v1.5.11/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI=
+gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
+gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+gorm.io/gorm v1.26.0 h1:9lqQVPG5aNNS6AyHdRiwScAVnXHg/L/Srzx55G5fOgs=
+gorm.io/gorm v1.26.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
 gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
 gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
 gvisor.dev/gvisor v0.0.0-20250205023644-9414b50a5633 h1:2gap+Kh/3F47cO6hAu3idFvsJ0ue6TRcEi2IUkv/F8k=
 gvisor.dev/gvisor v0.0.0-20250205023644-9414b50a5633/go.mod h1:5DMfjtclAbTIjbXqO1qCe2K5GKKxWz2JHvCChuTcJEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.6.1 h1:R094WgE8K4JirYjBaOpz/AvTyUu/3wbmAoskKN/pxTI=
 honnef.co/go/tools v0.6.1/go.mod h1:3puzxxljPCe8RGJX7BIy1plGbxEOZni5mR2aXe3/uk4=
 howett.net/plist v1.0.0 h1:7CrbWYbPPO/PyNy38b2EB/+gYbjCe2DXBxgtOOZbSQM=
 howett.net/plist v1.0.0/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
 modernc.org/cc/v4 v4.25.2 h1:T2oH7sZdGvTaie0BRNFbIYsabzCxUQg8nLqCdQ2i0ic=
-modernc.org/cc/v4 v4.25.2/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/cc/v4 v4.26.0 h1:QMYvbVduUGH0rrO+5mqF/PSPPRZNpRtg2CLELy7vUpA=
+modernc.org/cc/v4 v4.26.0/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/ccgo/v4 v4.25.1 h1:TFSzPrAGmDsdnhT9X2UrcPMI3N/mJ9/X9ykKXwLhDsU=
-modernc.org/ccgo/v4 v4.25.1/go.mod h1:njjuAYiPflywOOrm3B7kCB444ONP5pAVr8PIEoE0uDw=
-modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE=
-modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ=
+modernc.org/ccgo/v4 v4.26.0 h1:gVzXaDzGeBYJ2uXTOpR8FR7OlksDOe9jxnjhIKCsiTc=
+modernc.org/ccgo/v4 v4.26.0/go.mod h1:Sem8f7TFUtVXkG2fiaChQtyyfkqhJBg/zjEJBkmuAVY=
+modernc.org/fileutil v1.3.1 h1:8vq5fe7jdtEvoCf3Zf9Nm0Q05sH6kGx0Op2CPx1wTC8=
+modernc.org/fileutil v1.3.1/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
 modernc.org/libc v1.62.1 h1:s0+fv5E3FymN8eJVmnk0llBe6rOxCu/DEU+XygRbS8s=
 modernc.org/libc v1.62.1/go.mod h1:iXhATfJQLjG3NWy56a6WVU73lWOcdYVxsvwCgoPljuo=
+modernc.org/libc v1.65.0 h1:e183gLDnAp9VJh6gWKdTy0CThL9Pt7MfcR/0bgb7Y1Y=
+modernc.org/libc v1.65.0/go.mod h1:7m9VzGq7APssBTydds2zBcxGREwvIGpuUBaKTXdm2Qs=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.10.0 h1:fzumd51yQ1DxcOxSO+S6X7+QTuVU+n8/Aj7swYjFfC4=
@@ -712,9 +744,9 @@ modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
 modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
 software.sslmate.com/src/go-pkcs12 v0.4.0 h1:H2g08FrTvSFKUj+D309j1DPfk5APnIdAQAB8aEykJ5k=
 software.sslmate.com/src/go-pkcs12 v0.4.0/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI=
-tailscale.com v1.84.2 h1:v6aM4RWUgYiV52LRAx6ET+dlGnvO/5lnqPXb7/pMnR0=
-tailscale.com v1.84.2/go.mod h1:6/S63NMAhmncYT/1zIPDJkvCuZwMw+JnUuOfSPNazpo=
-zgo.at/zcache/v2 v2.2.0 h1:K29/IPjMniZfveYE+IRXfrl11tMzHkIPuyGrfVZ2fGo=
-zgo.at/zcache/v2 v2.2.0/go.mod h1:gyCeoLVo01QjDZynjime8xUGHHMbsLiPyUTBpDGd4Gk=
+tailscale.com v1.83.0-pre.0.20250331211809-96fe8a6db6c9 h1:mPTb8dGYSqzJhrrYNrLVP717Nh8DME85DWnhBATB/94=
+tailscale.com v1.83.0-pre.0.20250331211809-96fe8a6db6c9/go.mod h1:iU6kohVzG+bP0/5XjqBAnW8/6nSG/Du++bO+x7VJZD0=
+zgo.at/zcache/v2 v2.1.0 h1:USo+ubK+R4vtjw4viGzTe/zjXyPw6R7SK/RL3epBBxs=
+zgo.at/zcache/v2 v2.1.0/go.mod h1:gyCeoLVo01QjDZynjime8xUGHHMbsLiPyUTBpDGd4Gk=
 zombiezen.com/go/postgrestest v1.0.1 h1:aXoADQAJmZDU3+xilYVut0pHhgc0sF8ZspPW9gFNwP4=
 zombiezen.com/go/postgrestest v1.0.1/go.mod h1:marlZezr+k2oSJrvXHnZUs1olHqpE9czlz8ZYkVxliQ=

hscontrol/app.go

@@ -5,6 +5,7 @@ import (
 	"crypto/tls"
 	"errors"
 	"fmt"
+	"io"
 	"net"
 	"net/http"
 	_ "net/http/pprof" // nolint
@@ -19,6 +20,7 @@ import (
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/gorilla/mux"
+	grpcMiddleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpcRuntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/juanfont/headscale"
 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
@@ -29,7 +31,8 @@ import (
 	"github.com/juanfont/headscale/hscontrol/dns"
 	"github.com/juanfont/headscale/hscontrol/mapper"
 	"github.com/juanfont/headscale/hscontrol/notifier"
-	"github.com/juanfont/headscale/hscontrol/state"
+	"github.com/juanfont/headscale/hscontrol/policy"
+	"github.com/juanfont/headscale/hscontrol/routes"
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	zerolog "github.com/philip-bui/grpc-zerolog"
@@ -47,11 +50,13 @@ import (
 	"google.golang.org/grpc/peer"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/grpc/status"
+	"gorm.io/gorm"
 	"tailscale.com/envknob"
 	"tailscale.com/tailcfg"
 	"tailscale.com/types/dnstype"
 	"tailscale.com/types/key"
 	"tailscale.com/util/dnsname"
+	zcache "zgo.at/zcache/v2"
 )
 
 var (
@@ -69,22 +74,33 @@ const (
 	updateInterval     = 5 * time.Second
 	privateKeyFileMode = 0o600
 	headscaleDirPerm   = 0o700
+
+	registerCacheExpiration = time.Minute * 15
+	registerCacheCleanup    = time.Minute * 20
 )
 
 // Headscale represents the base app of the service.
 type Headscale struct {
 	cfg             *types.Config
-	state           *state.State
+	db              *db.HSDatabase
+	ipAlloc         *db.IPAllocator
 	noisePrivateKey *key.MachinePrivate
 	ephemeralGC     *db.EphemeralGarbageCollector
 
+	DERPMap    *tailcfg.DERPMap
 	DERPServer *derpServer.DERPServer
 
-	// Things that generate changes
+	polManOnce     sync.Once
+	polMan         policy.PolicyManager
 	extraRecordMan *dns.ExtraRecordsMan
-	mapper         *mapper.Mapper
-	nodeNotifier   *notifier.Notifier
-	authProvider   AuthProvider
+	primaryRoutes  *routes.PrimaryRoutes
+
+	mapper       *mapper.Mapper
+	nodeNotifier *notifier.Notifier
+
+	registrationCache *zcache.Cache[types.RegistrationID, types.RegisterNode]
+
+	authProvider AuthProvider
 
 	pollNetMapStreamWG sync.WaitGroup
 }
@@ -109,42 +125,43 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
 		return nil, fmt.Errorf("failed to read or create Noise protocol private key: %w", err)
 	}
 
-	s, err := state.NewState(cfg)
-	if err != nil {
-		return nil, fmt.Errorf("init state: %w", err)
-	}
+	registrationCache := zcache.New[types.RegistrationID, types.RegisterNode](
+		registerCacheExpiration,
+		registerCacheCleanup,
+	)
 
 	app := Headscale{
 		cfg:                cfg,
 		noisePrivateKey:    noisePrivateKey,
+		registrationCache:  registrationCache,
 		pollNetMapStreamWG: sync.WaitGroup{},
 		nodeNotifier:       notifier.NewNotifier(cfg),
-		state:              s,
+		primaryRoutes:      routes.New(),
 	}
 
-	// Initialize ephemeral garbage collector
-	ephemeralGC := db.NewEphemeralGarbageCollector(func(ni types.NodeID) {
-		node, err := app.state.GetNodeByID(ni)
-		if err != nil {
-			log.Err(err).Uint64("node.id", ni.Uint64()).Msgf("failed to get ephemeral node for deletion")
-			return
-		}
+	app.db, err = db.NewHeadscaleDatabase(
+		cfg.Database,
+		cfg.BaseDomain,
+		registrationCache,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("new database: %w", err)
+	}
 
-		policyChanged, err := app.state.DeleteNode(node)
-		if err != nil {
+	app.ipAlloc, err = db.NewIPAllocator(app.db, cfg.PrefixV4, cfg.PrefixV6, cfg.IPAllocation)
+	if err != nil {
+		return nil, err
+	}
+
+	app.ephemeralGC = db.NewEphemeralGarbageCollector(func(ni types.NodeID) {
+		if err := app.db.DeleteEphemeralNode(ni); err != nil {
 			log.Err(err).Uint64("node.id", ni.Uint64()).Msgf("failed to delete ephemeral node")
-			return
 		}
-
-		// Send policy update notifications if needed
-		if policyChanged {
-			ctx := types.NotifyCtx(context.Background(), "ephemeral-gc-policy", node.Hostname)
-			app.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
-		}
-
-		log.Debug().Uint64("node.id", ni.Uint64()).Msgf("deleted ephemeral node")
 	})
-	app.ephemeralGC = ephemeralGC
+
+	if err = app.loadPolicyManager(); err != nil {
+		return nil, fmt.Errorf("loading ACL policy: %w", err)
+	}
 
 	var authProvider AuthProvider
 	authProvider = NewAuthProviderWeb(cfg.ServerURL)
@@ -155,8 +172,10 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
 			ctx,
 			cfg.ServerURL,
 			&cfg.OIDC,
-			app.state,
+			app.db,
 			app.nodeNotifier,
+			app.ipAlloc,
+			app.polMan,
 		)
 		if err != nil {
 			if cfg.OIDC.OnlyStartIfOIDCIsAvailable {
@@ -207,14 +226,6 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) {
 			)
 		}
 
-		if cfg.DERP.ServerVerifyClients {
-			t := http.DefaultTransport.(*http.Transport) //nolint:forcetypeassert
-			t.RegisterProtocol(
-				derpServer.DerpVerifyScheme,
-				derpServer.NewDERPVerifyTransport(app.handleVerifyRequest),
-			)
-		}
-
 		embeddedDERPServer, err := derpServer.NewDERPServer(
 			cfg.ServerURL,
 			key.NodePrivate(*derpServerKey),
@@ -265,7 +276,14 @@ func (h *Headscale) scheduledTasks(ctx context.Context) {
 			var update types.StateUpdate
 			var changed bool
 
-			lastExpiryCheck, update, changed = h.state.ExpireExpiredNodes(lastExpiryCheck)
+			if err := h.db.Write(func(tx *gorm.DB) error {
+				lastExpiryCheck, update, changed = db.ExpireExpiredNodes(tx, lastExpiryCheck)
+
+				return nil
+			}); err != nil {
+				log.Error().Err(err).Msg("database error while expiring nodes")
+				continue
+			}
 
 			if changed {
 				log.Trace().Interface("nodes", update.ChangePatches).Msgf("expiring nodes")
@@ -276,16 +294,16 @@ func (h *Headscale) scheduledTasks(ctx context.Context) {
 
 		case <-derpTickerChan:
 			log.Info().Msg("Fetching DERPMap updates")
-			derpMap := derp.GetDERPMap(h.cfg.DERP)
+			h.DERPMap = derp.GetDERPMap(h.cfg.DERP)
 			if h.cfg.DERP.ServerEnabled && h.cfg.DERP.AutomaticallyAddEmbeddedDerpRegion {
 				region, _ := h.DERPServer.GenerateRegion()
-				derpMap.Regions[region.RegionID] = &region
+				h.DERPMap.Regions[region.RegionID] = &region
 			}
 
 			ctx := types.NotifyCtx(context.Background(), "derpmap-update", "na")
 			h.nodeNotifier.NotifyAll(ctx, types.StateUpdate{
 				Type:    types.StateDERPUpdated,
-				DERPMap: derpMap,
+				DERPMap: h.DERPMap,
 			})
 
 		case records, ok := <-extraRecordsUpdate:
@@ -344,7 +362,7 @@ func (h *Headscale) grpcAuthenticationInterceptor(ctx context.Context,
 		)
 	}
 
-	valid, err := h.state.ValidateAPIKey(strings.TrimPrefix(token, AuthPrefix))
+	valid, err := h.db.ValidateAPIKey(strings.TrimPrefix(token, AuthPrefix))
 	if err != nil {
 		return ctx, status.Error(codes.Internal, "failed to validate token")
 	}
@@ -389,7 +407,7 @@ func (h *Headscale) httpAuthenticationMiddleware(next http.Handler) http.Handler
 			return
 		}
 
-		valid, err := h.state.ValidateAPIKey(strings.TrimPrefix(authHeader, AuthPrefix))
+		valid, err := h.db.ValidateAPIKey(strings.TrimPrefix(authHeader, AuthPrefix))
 		if err != nil {
 			log.Error().
 				Caller().
@@ -472,7 +490,7 @@ func (h *Headscale) createRouter(grpcMux *grpcRuntime.ServeMux) *mux.Router {
 		router.HandleFunc("/derp", h.DERPServer.DERPHandler)
 		router.HandleFunc("/derp/probe", derpServer.DERPProbeHandler)
 		router.HandleFunc("/derp/latency-check", derpServer.DERPProbeHandler)
-		router.HandleFunc("/bootstrap-dns", derpServer.DERPBootstrapDNSHandler(h.state.DERPMap()))
+		router.HandleFunc("/bootstrap-dns", derpServer.DERPBootstrapDNSHandler(h.DERPMap))
 	}
 
 	apiRouter := router.PathPrefix("/api").Subrouter()
@@ -484,57 +502,57 @@ func (h *Headscale) createRouter(grpcMux *grpcRuntime.ServeMux) *mux.Router {
 	return router
 }
 
-// // TODO(kradalby): Do a variant of this, and polman which only updates the node that has changed.
-// // Maybe we should attempt a new in memory state and not go via the DB?
-// // Maybe this should be implemented as an event bus?
-// // A bool is returned indicating if a full update was sent to all nodes
-// func usersChangedHook(db *db.HSDatabase, polMan policy.PolicyManager, notif *notifier.Notifier) error {
-// 	users, err := db.ListUsers()
-// 	if err != nil {
-// 		return err
-// 	}
+// TODO(kradalby): Do a variant of this, and polman which only updates the node that has changed.
+// Maybe we should attempt a new in memory state and not go via the DB?
+// Maybe this should be implemented as an event bus?
+// A bool is returned indicating if a full update was sent to all nodes
+func usersChangedHook(db *db.HSDatabase, polMan policy.PolicyManager, notif *notifier.Notifier) error {
+	users, err := db.ListUsers()
+	if err != nil {
+		return err
+	}
 
-// 	changed, err := polMan.SetUsers(users)
-// 	if err != nil {
-// 		return err
-// 	}
+	changed, err := polMan.SetUsers(users)
+	if err != nil {
+		return err
+	}
 
-// 	if changed {
-// 		ctx := types.NotifyCtx(context.Background(), "acl-users-change", "all")
-// 		notif.NotifyAll(ctx, types.UpdateFull())
-// 	}
+	if changed {
+		ctx := types.NotifyCtx(context.Background(), "acl-users-change", "all")
+		notif.NotifyAll(ctx, types.UpdateFull())
+	}
 
-// 	return nil
-// }
+	return nil
+}
 
-// // TODO(kradalby): Do a variant of this, and polman which only updates the node that has changed.
-// // Maybe we should attempt a new in memory state and not go via the DB?
-// // Maybe this should be implemented as an event bus?
-// // A bool is returned indicating if a full update was sent to all nodes
-// func nodesChangedHook(
-// 	db *db.HSDatabase,
-// 	polMan policy.PolicyManager,
-// 	notif *notifier.Notifier,
-// ) (bool, error) {
-// 	nodes, err := db.ListNodes()
-// 	if err != nil {
-// 		return false, err
-// 	}
+// TODO(kradalby): Do a variant of this, and polman which only updates the node that has changed.
+// Maybe we should attempt a new in memory state and not go via the DB?
+// Maybe this should be implemented as an event bus?
+// A bool is returned indicating if a full update was sent to all nodes
+func nodesChangedHook(
+	db *db.HSDatabase,
+	polMan policy.PolicyManager,
+	notif *notifier.Notifier,
+) (bool, error) {
+	nodes, err := db.ListNodes()
+	if err != nil {
+		return false, err
+	}
 
-// 	filterChanged, err := polMan.SetNodes(nodes)
-// 	if err != nil {
-// 		return false, err
-// 	}
+	filterChanged, err := polMan.SetNodes(nodes)
+	if err != nil {
+		return false, err
+	}
 
-// 	if filterChanged {
-// 		ctx := types.NotifyCtx(context.Background(), "acl-nodes-change", "all")
-// 		notif.NotifyAll(ctx, types.UpdateFull())
+	if filterChanged {
+		ctx := types.NotifyCtx(context.Background(), "acl-nodes-change", "all")
+		notif.NotifyAll(ctx, types.UpdateFull())
 
-// 		return true, nil
-// 	}
+		return true, nil
+	}
 
-// 	return false, nil
-// }
+	return false, nil
+}
 
 // Serve launches the HTTP and gRPC server service Headscale and the API.
 func (h *Headscale) Serve() error {
@@ -563,9 +581,9 @@ func (h *Headscale) Serve() error {
 		Msg("Clients with a lower minimum version will be rejected")
 
 	// Fetch an initial DERP Map before we start serving
-	h.mapper = mapper.NewMapper(h.state, h.cfg, h.nodeNotifier)
+	h.DERPMap = derp.GetDERPMap(h.cfg.DERP)
+	h.mapper = mapper.NewMapper(h.db, h.cfg, h.DERPMap, h.nodeNotifier, h.polMan, h.primaryRoutes)
 
-	// TODO(kradalby): fix state part.
 	if h.cfg.DERP.ServerEnabled {
 		// When embedded DERP is enabled we always need a STUN server
 		if h.cfg.DERP.STUNAddr == "" {
@@ -578,13 +596,13 @@ func (h *Headscale) Serve() error {
 		}
 
 		if h.cfg.DERP.AutomaticallyAddEmbeddedDerpRegion {
-			h.state.DERPMap().Regions[region.RegionID] = &region
+			h.DERPMap.Regions[region.RegionID] = &region
 		}
 
 		go h.DERPServer.ServeSTUN()
 	}
 
-	if len(h.state.DERPMap().Regions) == 0 {
+	if len(h.DERPMap.Regions) == 0 {
 		return errEmptyInitialDERPMap
 	}
 
@@ -593,7 +611,7 @@ func (h *Headscale) Serve() error {
 	// around between restarts, they will reconnect and the GC will
 	// be cancelled.
 	go h.ephemeralGC.Start()
-	ephmNodes, err := h.state.ListEphemeralNodes()
+	ephmNodes, err := h.db.ListEphemeralNodes()
 	if err != nil {
 		return fmt.Errorf("failed to list ephemeral nodes: %w", err)
 	}
@@ -716,10 +734,12 @@ func (h *Headscale) Serve() error {
 		log.Info().Msgf("Enabling remote gRPC at %s", h.cfg.GRPCAddr)
 
 		grpcOptions := []grpc.ServerOption{
-			grpc.ChainUnaryInterceptor(
-				h.grpcAuthenticationInterceptor,
-				// Uncomment to debug grpc communication.
-				// zerolog.NewUnaryServerInterceptor(),
+			grpc.UnaryInterceptor(
+				grpcMiddleware.ChainUnaryServer(
+					h.grpcAuthenticationInterceptor,
+					// Uncomment to debug grpc communication.
+					// zerolog.NewUnaryServerInterceptor(),
+				),
 			),
 		}
 
@@ -822,22 +842,35 @@ func (h *Headscale) Serve() error {
 			case syscall.SIGHUP:
 				log.Info().
 					Str("signal", sig.String()).
-					Msg("Received SIGHUP, reloading ACL policy")
+					Msg("Received SIGHUP, reloading ACL and Config")
 
 				if h.cfg.Policy.IsEmpty() {
 					continue
 				}
 
-				changed, err := h.state.ReloadPolicy()
+				if err := h.loadPolicyManager(); err != nil {
+					log.Error().Err(err).Msg("failed to reload Policy")
+				}
+
+				pol, err := h.policyBytes()
 				if err != nil {
-					log.Error().Err(err).Msgf("reloading policy")
-					continue
+					log.Error().Err(err).Msg("failed to get policy blob")
+				}
+
+				changed, err := h.polMan.SetPolicy(pol)
+				if err != nil {
+					log.Error().Err(err).Msg("failed to set new policy")
 				}
 
 				if changed {
 					log.Info().
 						Msg("ACL policy successfully reloaded, notifying nodes of change")
 
+					err = h.autoApproveNodes()
+					if err != nil {
+						log.Error().Err(err).Msg("failed to approve routes after new policy")
+					}
+
 					ctx := types.NotifyCtx(context.Background(), "acl-sighup", "na")
 					h.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
 				}
@@ -896,7 +929,7 @@ func (h *Headscale) Serve() error {
 
 				// Close db connections
 				info("closing database connection")
-				err = h.state.Close()
+				err = h.db.Close()
 				if err != nil {
 					log.Error().Err(err).Msg("failed to close db")
 				}
@@ -1047,3 +1080,124 @@ func readOrCreatePrivateKey(path string) (*key.MachinePrivate, error) {
 
 	return &machineKey, nil
 }
+
+// policyBytes returns the appropriate policy for the
+// current configuration as a []byte array.
+func (h *Headscale) policyBytes() ([]byte, error) {
+	switch h.cfg.Policy.Mode {
+	case types.PolicyModeFile:
+		path := h.cfg.Policy.Path
+
+		// It is fine to start headscale without a policy file.
+		if len(path) == 0 {
+			return nil, nil
+		}
+
+		absPath := util.AbsolutePathFromConfigPath(path)
+		policyFile, err := os.Open(absPath)
+		if err != nil {
+			return nil, err
+		}
+		defer policyFile.Close()
+
+		return io.ReadAll(policyFile)
+
+	case types.PolicyModeDB:
+		p, err := h.db.GetPolicy()
+		if err != nil {
+			if errors.Is(err, types.ErrPolicyNotFound) {
+				return nil, nil
+			}
+
+			return nil, err
+		}
+
+		if p.Data == "" {
+			return nil, nil
+		}
+
+		return []byte(p.Data), err
+	}
+
+	return nil, fmt.Errorf("unsupported policy mode: %s", h.cfg.Policy.Mode)
+}
+
+func (h *Headscale) loadPolicyManager() error {
+	var errOut error
+	h.polManOnce.Do(func() {
+		// Validate and reject configuration that would error when applied
+		// when creating a map response. This requires nodes, so there is still
+		// a scenario where they might be allowed if the server has no nodes
+		// yet, but it should help for the general case and for hot reloading
+		// configurations.
+		// Note that this check is only done for file-based policies in this function
+		// as the database-based policies are checked in the gRPC API where it is not
+		// allowed to be written to the database.
+		nodes, err := h.db.ListNodes()
+		if err != nil {
+			errOut = fmt.Errorf("loading nodes from database to validate policy: %w", err)
+			return
+		}
+		users, err := h.db.ListUsers()
+		if err != nil {
+			errOut = fmt.Errorf("loading users from database to validate policy: %w", err)
+			return
+		}
+
+		pol, err := h.policyBytes()
+		if err != nil {
+			errOut = fmt.Errorf("loading policy bytes: %w", err)
+			return
+		}
+
+		h.polMan, err = policy.NewPolicyManager(pol, users, nodes)
+		if err != nil {
+			errOut = fmt.Errorf("creating policy manager: %w", err)
+			return
+		}
+		log.Info().Msgf("Using policy manager version: %d", h.polMan.Version())
+
+		if len(nodes) > 0 {
+			_, err = h.polMan.SSHPolicy(nodes[0])
+			if err != nil {
+				errOut = fmt.Errorf("verifying SSH rules: %w", err)
+				return
+			}
+		}
+	})
+
+	return errOut
+}
+
+// autoApproveNodes mass approves routes on all nodes. It is _only_ intended for
+// use when the policy is replaced. It is not sending or reporting any changes
+// or updates as we send full updates after replacing the policy.
+// TODO(kradalby): This is kind of messy, maybe this is another +1
+// for an event bus. See example comments here.
+func (h *Headscale) autoApproveNodes() error {
+	err := h.db.Write(func(tx *gorm.DB) error {
+		nodes, err := db.ListNodes(tx)
+		if err != nil {
+			return err
+		}
+
+		for _, node := range nodes {
+			changed := policy.AutoApproveRoutes(h.polMan, node)
+			if changed {
+				err = tx.Save(node).Error
+				if err != nil {
+					return err
+				}
+
+				h.primaryRoutes.SetRoutes(node.ID, node.SubnetRoutes()...)
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("auto approving routes for nodes: %w", err)
+	}
+
+	return nil
+}

hscontrol/auth.go

@@ -9,7 +9,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/juanfont/headscale/hscontrol/db"
+	"github.com/juanfont/headscale/hscontrol/policy"
 	"github.com/juanfont/headscale/hscontrol/types"
+	"github.com/juanfont/headscale/hscontrol/util"
 	"gorm.io/gorm"
 	"tailscale.com/tailcfg"
 	"tailscale.com/types/key"
@@ -26,7 +29,7 @@ func (h *Headscale) handleRegister(
 	regReq tailcfg.RegisterRequest,
 	machineKey key.MachinePublic,
 ) (*tailcfg.RegisterResponse, error) {
-	node, err := h.state.GetNodeByNodeKey(regReq.NodeKey)
+	node, err := h.db.GetNodeByNodeKey(regReq.NodeKey)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, fmt.Errorf("looking up node in database: %w", err)
 	}
@@ -82,39 +85,25 @@ func (h *Headscale) handleExistingNode(
 		// If the request expiry is in the past, we consider it a logout.
 		if requestExpiry.Before(time.Now()) {
 			if node.IsEphemeral() {
-				policyChanged, err := h.state.DeleteNode(node)
+				err := h.db.DeleteNode(node)
 				if err != nil {
 					return nil, fmt.Errorf("deleting ephemeral node: %w", err)
 				}
 
-				// Send policy update notifications if needed
-				if policyChanged {
-					ctx := types.NotifyCtx(context.Background(), "auth-logout-ephemeral-policy", "na")
-					h.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
-				} else {
-					ctx := types.NotifyCtx(context.Background(), "logout-ephemeral", "na")
-					h.nodeNotifier.NotifyAll(ctx, types.UpdatePeerRemoved(node.ID))
-				}
-
-				return nil, nil
+				ctx := types.NotifyCtx(context.Background(), "logout-ephemeral", "na")
+				h.nodeNotifier.NotifyAll(ctx, types.UpdatePeerRemoved(node.ID))
 			}
+
+			expired = true
 		}
 
-		n, policyChanged, err := h.state.SetNodeExpiry(node.ID, requestExpiry)
+		err := h.db.NodeSetExpiry(node.ID, requestExpiry)
 		if err != nil {
 			return nil, fmt.Errorf("setting node expiry: %w", err)
 		}
 
-		// Send policy update notifications if needed
-		if policyChanged {
-			ctx := types.NotifyCtx(context.Background(), "auth-expiry-policy", "na")
-			h.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
-		} else {
-			ctx := types.NotifyCtx(context.Background(), "logout-expiry", "na")
-			h.nodeNotifier.NotifyWithIgnore(ctx, types.UpdateExpire(node.ID, requestExpiry), node.ID)
-		}
-
-		return nodeToRegisterResponse(n), nil
+		ctx := types.NotifyCtx(context.Background(), "logout-expiry", "na")
+		h.nodeNotifier.NotifyWithIgnore(ctx, types.UpdateExpire(node.ID, requestExpiry), node.ID)
 	}
 
 	return nodeToRegisterResponse(node), nil
@@ -149,7 +138,7 @@ func (h *Headscale) waitForFollowup(
 		return nil, NewHTTPError(http.StatusUnauthorized, "invalid registration ID", err)
 	}
 
-	if reg, ok := h.state.GetRegistrationCacheEntry(followupReg); ok {
+	if reg, ok := h.registrationCache.Get(followupReg); ok {
 		select {
 		case <-ctx.Done():
 			return nil, NewHTTPError(http.StatusUnauthorized, "registration timed out", err)
@@ -164,26 +153,98 @@ func (h *Headscale) waitForFollowup(
 	return nil, NewHTTPError(http.StatusNotFound, "followup registration not found", nil)
 }
 
+// canUsePreAuthKey checks if a pre auth key can be used.
+func canUsePreAuthKey(pak *types.PreAuthKey) error {
+	if pak == nil {
+		return NewHTTPError(http.StatusUnauthorized, "invalid authkey", nil)
+	}
+	if pak.Expiration != nil && pak.Expiration.Before(time.Now()) {
+		return NewHTTPError(http.StatusUnauthorized, "authkey expired", nil)
+	}
+
+	// we don't need to check if has been used before
+	if pak.Reusable {
+		return nil
+	}
+
+	if pak.Used {
+		return NewHTTPError(http.StatusUnauthorized, "authkey already used", nil)
+	}
+
+	return nil
+}
+
 func (h *Headscale) handleRegisterWithAuthKey(
 	regReq tailcfg.RegisterRequest,
 	machineKey key.MachinePublic,
 ) (*tailcfg.RegisterResponse, error) {
-	node, changed, err := h.state.HandleNodeFromPreAuthKey(
-		regReq,
-		machineKey,
-	)
+	pak, err := h.db.GetPreAuthKey(regReq.Auth.AuthKey)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, NewHTTPError(http.StatusUnauthorized, "invalid pre auth key", nil)
 		}
-		var perr types.PAKError
-		if errors.As(err, &perr) {
-			return nil, NewHTTPError(http.StatusUnauthorized, perr.Error(), nil)
+		return nil, err
+	}
+
+	err = canUsePreAuthKey(pak)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeToRegister := types.Node{
+		Hostname:       regReq.Hostinfo.Hostname,
+		UserID:         pak.User.ID,
+		User:           pak.User,
+		MachineKey:     machineKey,
+		NodeKey:        regReq.NodeKey,
+		Hostinfo:       regReq.Hostinfo,
+		LastSeen:       ptr.To(time.Now()),
+		RegisterMethod: util.RegisterMethodAuthKey,
+
+		// TODO(kradalby): This should not be set on the node,
+		// they should be looked up through the key, which is
+		// attached to the node.
+		ForcedTags: pak.Proto().GetAclTags(),
+		AuthKey:    pak,
+		AuthKeyID:  &pak.ID,
+	}
+
+	if !regReq.Expiry.IsZero() {
+		nodeToRegister.Expiry = &regReq.Expiry
+	}
+
+	ipv4, ipv6, err := h.ipAlloc.Next()
+	if err != nil {
+		return nil, fmt.Errorf("allocating IPs: %w", err)
+	}
+
+	node, err := db.Write(h.db.DB, func(tx *gorm.DB) (*types.Node, error) {
+		node, err := db.RegisterNode(tx,
+			nodeToRegister,
+			ipv4, ipv6,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("registering node: %w", err)
 		}
 
+		if !pak.Reusable {
+			err = db.UsePreAuthKey(tx, pak)
+			if err != nil {
+				return nil, fmt.Errorf("using pre auth key: %w", err)
+			}
+		}
+
+		return node, nil
+	})
+	if err != nil {
 		return nil, err
 	}
 
+	updateSent, err := nodesChangedHook(h.db, h.polMan, h.nodeNotifier)
+	if err != nil {
+		return nil, fmt.Errorf("nodes changed hook: %w", err)
+	}
+
 	// This is a bit of a back and forth, but we have a bit of a chicken and egg
 	// dependency here.
 	// Because the way the policy manager works, we need to have the node
@@ -195,30 +256,21 @@ func (h *Headscale) handleRegisterWithAuthKey(
 	// ensure we send an update.
 	// This works, but might be another good candidate for doing some sort of
 	// eventbus.
-	routesChanged := h.state.AutoApproveRoutes(node)
-	if _, _, err := h.state.SaveNode(node); err != nil {
+	routesChanged := policy.AutoApproveRoutes(h.polMan, node)
+	if err := h.db.DB.Save(node).Error; err != nil {
 		return nil, fmt.Errorf("saving auto approved routes to node: %w", err)
 	}
 
-	if routesChanged {
+	if !updateSent || routesChanged {
 		ctx := types.NotifyCtx(context.Background(), "node updated", node.Hostname)
 		h.nodeNotifier.NotifyAll(ctx, types.UpdatePeerChanged(node.ID))
-	} else if changed {
-		ctx := types.NotifyCtx(context.Background(), "node created", node.Hostname)
-		h.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
-	} else {
-		// Existing node re-registering without route changes
-		// Still need to notify peers about the node being active again
-		// Use UpdateFull to ensure all peers get complete peer maps
-		ctx := types.NotifyCtx(context.Background(), "node re-registered", node.Hostname)
-		h.nodeNotifier.NotifyAll(ctx, types.UpdateFull())
 	}
 
 	return &tailcfg.RegisterResponse{
 		MachineAuthorized: true,
 		NodeKeyExpired:    node.IsExpired(),
-		User:              *node.User.TailscaleUser(),
-		Login:             *node.User.TailscaleLogin(),
+		User:              *pak.User.TailscaleUser(),
+		Login:             *pak.User.TailscaleLogin(),
 	}, nil
 }
 
@@ -246,7 +298,7 @@ func (h *Headscale) handleRegisterInteractive(
 		nodeToRegister.Node.Expiry = &regReq.Expiry
 	}
 
-	h.state.SetRegistrationCacheEntry(
+	h.registrationCache.Set(
 		registrationId,
 		nodeToRegister,
 	)

hscontrol/auth_test.go

@@ -1,11 +1,12 @@
-package types
+package hscontrol
 
 import (
-	"errors"
+	"net/http"
 	"testing"
 	"time"
 
 	"github.com/google/go-cmp/cmp"
+	"github.com/juanfont/headscale/hscontrol/types"
 )
 
 func TestCanUsePreAuthKey(t *testing.T) {
@@ -15,13 +16,13 @@ func TestCanUsePreAuthKey(t *testing.T) {
 
 	tests := []struct {
 		name    string
-		pak     *PreAuthKey
+		pak     *types.PreAuthKey
 		wantErr bool
-		err     PAKError
+		err     HTTPError
 	}{
 		{
 			name: "valid reusable key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   true,
 				Used:       false,
 				Expiration: &future,
@@ -30,7 +31,7 @@ func TestCanUsePreAuthKey(t *testing.T) {
 		},
 		{
 			name: "valid non-reusable key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       false,
 				Expiration: &future,
@@ -39,27 +40,27 @@ func TestCanUsePreAuthKey(t *testing.T) {
 		},
 		{
 			name: "expired key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       false,
 				Expiration: &past,
 			},
 			wantErr: true,
-			err:     PAKError("authkey expired"),
+			err:     NewHTTPError(http.StatusUnauthorized, "authkey expired", nil),
 		},
 		{
 			name: "used non-reusable key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       true,
 				Expiration: &future,
 			},
 			wantErr: true,
-			err:     PAKError("authkey already used"),
+			err:     NewHTTPError(http.StatusUnauthorized, "authkey already used", nil),
 		},
 		{
 			name: "used reusable key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   true,
 				Used:       true,
 				Expiration: &future,
@@ -68,7 +69,7 @@ func TestCanUsePreAuthKey(t *testing.T) {
 		},
 		{
 			name: "no expiration date",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       false,
 				Expiration: nil,
@@ -79,39 +80,38 @@ func TestCanUsePreAuthKey(t *testing.T) {
 			name:    "nil preauth key",
 			pak:     nil,
 			wantErr: true,
-			err:     PAKError("invalid authkey"),
+			err:     NewHTTPError(http.StatusUnauthorized, "invalid authkey", nil),
 		},
 		{
 			name: "expired and used key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       true,
 				Expiration: &past,
 			},
 			wantErr: true,
-			err:     PAKError("authkey expired"),
+			err:     NewHTTPError(http.StatusUnauthorized, "authkey expired", nil),
 		},
 		{
 			name: "no expiration and used key",
-			pak: &PreAuthKey{
+			pak: &types.PreAuthKey{
 				Reusable:   false,
 				Used:       true,
 				Expiration: nil,
 			},
 			wantErr: true,
-			err:     PAKError("authkey already used"),
+			err:     NewHTTPError(http.StatusUnauthorized, "authkey already used", nil),
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := tt.pak.Validate()
+			err := canUsePreAuthKey(tt.pak)
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("expected error but got none")
 				} else {
-					var httpErr PAKError
-					ok := errors.As(err, &httpErr)
+					httpErr, ok := err.(HTTPError)
 					if !ok {
 						t.Errorf("expected HTTPError but got %T", err)
 					} else {

hscontrol/capver/capver.go

@@ -1,10 +1,11 @@
 package capver
 
 import (
-	"slices"
 	"sort"
 	"strings"
 
+	"slices"
+
 	xmaps "golang.org/x/exp/maps"
 	"tailscale.com/tailcfg"
 	"tailscale.com/util/set"

hscontrol/capver/capver_generated.go

@@ -1,6 +1,6 @@
 package capver
 
-// Generated DO NOT EDIT
+//Generated DO NOT EDIT
 
 import "tailscale.com/tailcfg"
 
@@ -38,16 +38,17 @@ var tailscaleToCapVer = map[string]tailcfg.CapabilityVersion{
 	"v1.82.5": 115,
 }
 
+
 var capVerToTailscaleVer = map[tailcfg.CapabilityVersion]string{
-	87:  "v1.60.0",
-	88:  "v1.62.0",
-	90:  "v1.64.0",
-	95:  "v1.66.0",
-	97:  "v1.68.0",
-	102: "v1.70.0",
-	104: "v1.72.0",
-	106: "v1.74.0",
-	109: "v1.78.0",
-	113: "v1.80.0",
-	115: "v1.82.0",
+	87:		"v1.60.0",
+	88:		"v1.62.0",
+	90:		"v1.64.0",
+	95:		"v1.66.0",
+	97:		"v1.68.0",
+	102:		"v1.70.0",
+	104:		"v1.72.0",
+	106:		"v1.74.0",
+	109:		"v1.78.0",
+	113:		"v1.80.0",
+	115:		"v1.82.0",
 }

hscontrol/db/db.go

@@ -3,7 +3,6 @@ package db
 import (
 	"context"
 	"database/sql"
-	_ "embed"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -16,11 +15,9 @@ import (
 
 	"github.com/glebarez/sqlite"
 	"github.com/go-gormigrate/gormigrate/v2"
-	"github.com/juanfont/headscale/hscontrol/db/sqliteconfig"
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/rs/zerolog/log"
-	"github.com/tailscale/squibble"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
@@ -30,23 +27,12 @@ import (
 	"zgo.at/zcache/v2"
 )
 
-//go:embed schema.sql
-var dbSchema string
-
 func init() {
 	schema.RegisterSerializer("text", TextSerialiser{})
 }
 
 var errDatabaseNotSupported = errors.New("database type not supported")
 
-var errForeignKeyConstraintsViolated = errors.New("foreign key constraints violated")
-
-const (
-	maxIdleConns       = 100
-	maxOpenConns       = 100
-	contextTimeoutSecs = 10
-)
-
 // KV is a key-value store in a psql table. For future use...
 // TODO(kradalby): Is this used for anything?
 type KV struct {
@@ -485,7 +471,6 @@ func NewHeadscaleDatabase(
 
 					// Drop the old table.
 					_ = tx.Migrator().DropTable(&preAuthKeyACLTag{})
-
 					return nil
 				},
 				Rollback: func(db *gorm.DB) error { return nil },
@@ -617,7 +602,7 @@ COMMIT;
 				},
 				Rollback: func(db *gorm.DB) error { return nil },
 			},
-			// Ensure there are no nodes referring to a deleted preauthkey.
+			// Ensure there are no nodes refering to a deleted preauthkey.
 			{
 				ID: "202502070949",
 				Migrate: func(tx *gorm.DB) error {
@@ -733,209 +718,6 @@ AND auth_key_id NOT IN (
 				},
 				Rollback: func(db *gorm.DB) error { return nil },
 			},
-			// Schema migration to ensure all tables match the expected schema.
-			// This migration recreates all tables to match the exact structure in schema.sql,
-			// preserving all data during the process.
-			// Only SQLite will be migrated for consistency.
-			{
-				ID: "202507021200",
-				Migrate: func(tx *gorm.DB) error {
-					// Only run on SQLite
-					if cfg.Type != types.DatabaseSqlite {
-						log.Info().Msg("Skipping schema migration on non-SQLite database")
-						return nil
-					}
-
-					log.Info().Msg("Starting schema recreation with table renaming")
-
-					// Rename existing tables to _old versions
-					tablesToRename := []string{"users", "pre_auth_keys", "api_keys", "nodes", "policies"}
-
-					// Check if routes table exists and drop it (should have been migrated already)
-					var routesExists bool
-					err := tx.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='routes'").Row().Scan(&routesExists)
-					if err == nil && routesExists {
-						log.Info().Msg("Dropping leftover routes table")
-						if err := tx.Exec("DROP TABLE routes").Error; err != nil {
-							return fmt.Errorf("dropping routes table: %w", err)
-						}
-					}
-
-					// Drop all indexes first to avoid conflicts
-					indexesToDrop := []string{
-						"idx_users_deleted_at",
-						"idx_provider_identifier",
-						"idx_name_provider_identifier",
-						"idx_name_no_provider_identifier",
-						"idx_api_keys_prefix",
-						"idx_policies_deleted_at",
-					}
-
-					for _, index := range indexesToDrop {
-						_ = tx.Exec("DROP INDEX IF EXISTS " + index).Error
-					}
-
-					for _, table := range tablesToRename {
-						// Check if table exists before renaming
-						var exists bool
-						err := tx.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?", table).Row().Scan(&exists)
-						if err != nil {
-							return fmt.Errorf("checking if table %s exists: %w", table, err)
-						}
-
-						if exists {
-							// Drop old table if it exists from previous failed migration
-							_ = tx.Exec("DROP TABLE IF EXISTS " + table + "_old").Error
-
-							// Rename current table to _old
-							if err := tx.Exec("ALTER TABLE " + table + " RENAME TO " + table + "_old").Error; err != nil {
-								return fmt.Errorf("renaming table %s to %s_old: %w", table, table, err)
-							}
-						}
-					}
-
-					// Create new tables with correct schema
-					tableCreationSQL := []string{
-						`CREATE TABLE users(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  name text,
-  display_name text,
-  email text,
-  provider_identifier text,
-  provider text,
-  profile_pic_url text,
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime
-)`,
-						`CREATE TABLE pre_auth_keys(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  key text,
-  user_id integer,
-  reusable numeric,
-  ephemeral numeric DEFAULT false,
-  used numeric DEFAULT false,
-  tags text,
-  expiration datetime,
-  created_at datetime,
-  CONSTRAINT fk_pre_auth_keys_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE SET NULL
-)`,
-						`CREATE TABLE api_keys(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  prefix text,
-  hash blob,
-  expiration datetime,
-  last_seen datetime,
-  created_at datetime
-)`,
-						`CREATE TABLE nodes(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  machine_key text,
-  node_key text,
-  disco_key text,
-  endpoints text,
-  host_info text,
-  ipv4 text,
-  ipv6 text,
-  hostname text,
-  given_name varchar(63),
-  user_id integer,
-  register_method text,
-  forced_tags text,
-  auth_key_id integer,
-  last_seen datetime,
-  expiry datetime,
-  approved_routes text,
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime,
-  CONSTRAINT fk_nodes_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
-  CONSTRAINT fk_nodes_auth_key FOREIGN KEY(auth_key_id) REFERENCES pre_auth_keys(id)
-)`,
-						`CREATE TABLE policies(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  data text,
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime
-)`,
-					}
-
-					for _, createSQL := range tableCreationSQL {
-						if err := tx.Exec(createSQL).Error; err != nil {
-							return fmt.Errorf("creating new table: %w", err)
-						}
-					}
-
-					// Copy data directly using SQL
-					dataCopySQL := []string{
-						`INSERT INTO users (id, name, display_name, email, provider_identifier, provider, profile_pic_url, created_at, updated_at, deleted_at)
-             SELECT id, name, display_name, email, provider_identifier, provider, profile_pic_url, created_at, updated_at, deleted_at 
-             FROM users_old`,
-
-						`INSERT INTO pre_auth_keys (id, key, user_id, reusable, ephemeral, used, tags, expiration, created_at)
-             SELECT id, key, user_id, reusable, ephemeral, used, tags, expiration, created_at 
-             FROM pre_auth_keys_old`,
-
-						`INSERT INTO api_keys (id, prefix, hash, expiration, last_seen, created_at)
-             SELECT id, prefix, hash, expiration, last_seen, created_at 
-             FROM api_keys_old`,
-
-						`INSERT INTO nodes (id, machine_key, node_key, disco_key, endpoints, host_info, ipv4, ipv6, hostname, given_name, user_id, register_method, forced_tags, auth_key_id, last_seen, expiry, approved_routes, created_at, updated_at, deleted_at)
-             SELECT id, machine_key, node_key, disco_key, endpoints, host_info, ipv4, ipv6, hostname, given_name, user_id, register_method, forced_tags, auth_key_id, last_seen, expiry, approved_routes, created_at, updated_at, deleted_at 
-             FROM nodes_old`,
-
-						`INSERT INTO policies (id, data, created_at, updated_at, deleted_at)
-             SELECT id, data, created_at, updated_at, deleted_at 
-             FROM policies_old`,
-					}
-
-					for _, copySQL := range dataCopySQL {
-						if err := tx.Exec(copySQL).Error; err != nil {
-							return fmt.Errorf("copying data: %w", err)
-						}
-					}
-
-					// Create indexes
-					indexes := []string{
-						"CREATE INDEX idx_users_deleted_at ON users(deleted_at)",
-						`CREATE UNIQUE INDEX idx_provider_identifier ON users(
-  provider_identifier
-) WHERE provider_identifier IS NOT NULL`,
-						`CREATE UNIQUE INDEX idx_name_provider_identifier ON users(
-  name,
-  provider_identifier
-)`,
-						`CREATE UNIQUE INDEX idx_name_no_provider_identifier ON users(
-  name
-) WHERE provider_identifier IS NULL`,
-						"CREATE UNIQUE INDEX idx_api_keys_prefix ON api_keys(prefix)",
-						"CREATE INDEX idx_policies_deleted_at ON policies(deleted_at)",
-					}
-
-					for _, indexSQL := range indexes {
-						if err := tx.Exec(indexSQL).Error; err != nil {
-							return fmt.Errorf("creating index: %w", err)
-						}
-					}
-
-					// Drop old tables only after everything succeeds
-					for _, table := range tablesToRename {
-						if err := tx.Exec("DROP TABLE IF EXISTS " + table + "_old").Error; err != nil {
-							log.Warn().Str("table", table+"_old").Err(err).Msg("Failed to drop old table, but migration succeeded")
-						}
-					}
-
-					log.Info().Msg("Schema recreation completed successfully")
-
-					return nil
-				},
-				Rollback: func(db *gorm.DB) error { return nil },
-			},
-			// From this point, the following rules must be followed:
-			// - NEVER use gorm.AutoMigrate, write the exact migration steps needed
-			// - AutoMigrate depends on the struct staying exactly the same, which it wont over time.
-			// - Never write migrations that requires foreign keys to be disabled.
 		},
 	)
 
@@ -943,30 +725,6 @@ AND auth_key_id NOT IN (
 		log.Fatal().Err(err).Msgf("Migration failed: %v", err)
 	}
 
-	// Validate that the schema ends up in the expected state.
-	// This is currently only done on sqlite as squibble does not
-	// support Postgres and we use our sqlite schema as our source of
-	// truth.
-	if cfg.Type == types.DatabaseSqlite {
-		sqlConn, err := dbConn.DB()
-		if err != nil {
-			return nil, fmt.Errorf("getting DB from gorm: %w", err)
-		}
-
-		// or else it blocks...
-		sqlConn.SetMaxIdleConns(maxIdleConns)
-		sqlConn.SetMaxOpenConns(maxOpenConns)
-		defer sqlConn.SetMaxIdleConns(1)
-		defer sqlConn.SetMaxOpenConns(1)
-
-		ctx, cancel := context.WithTimeout(context.Background(), contextTimeoutSecs*time.Second)
-		defer cancel()
-
-		if err := squibble.Validate(ctx, sqlConn, dbSchema); err != nil {
-			return nil, fmt.Errorf("validating schema: %w", err)
-		}
-	}
-
 	db := HSDatabase{
 		DB:       dbConn,
 		cfg:      &cfg,
@@ -1000,26 +758,32 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
 			Str("path", cfg.Sqlite.Path).
 			Msg("Opening database")
 
-		// Build SQLite configuration with pragmas set at connection time
-		sqliteConfig := sqliteconfig.Default(cfg.Sqlite.Path)
-		if cfg.Sqlite.WriteAheadLog {
-			sqliteConfig.JournalMode = sqliteconfig.JournalModeWAL
-			sqliteConfig.WALAutocheckpoint = cfg.Sqlite.WALAutoCheckPoint
-		}
-
-		connectionURL, err := sqliteConfig.ToURL()
-		if err != nil {
-			return nil, fmt.Errorf("building sqlite connection URL: %w", err)
-		}
-
 		db, err := gorm.Open(
-			sqlite.Open(connectionURL),
+			sqlite.Open(cfg.Sqlite.Path),
 			&gorm.Config{
 				PrepareStmt: cfg.Gorm.PrepareStmt,
 				Logger:      dbLogger,
 			},
 		)
 
+		if err := db.Exec(`
+			PRAGMA foreign_keys=ON;
+			PRAGMA busy_timeout=10000;
+			PRAGMA auto_vacuum=INCREMENTAL;
+			PRAGMA synchronous=NORMAL;
+			`).Error; err != nil {
+			return nil, fmt.Errorf("enabling foreign keys: %w", err)
+		}
+
+		if cfg.Sqlite.WriteAheadLog {
+			if err := db.Exec(fmt.Sprintf(`
+				PRAGMA journal_mode=WAL;
+				PRAGMA wal_autocheckpoint=%d;
+				`, cfg.Sqlite.WALAutoCheckPoint)).Error; err != nil {
+				return nil, fmt.Errorf("setting WAL mode: %w", err)
+			}
+		}
+
 		// The pure Go SQLite library does not handle locking in
 		// the same way as the C based one and we can't use the gorm
 		// connection pool as of 2022/02/23.
@@ -1048,7 +812,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
 				dbString += " sslmode=disable"
 			}
 		} else {
-			dbString += " sslmode=" + cfg.Postgres.Ssl
+			dbString += fmt.Sprintf(" sslmode=%s", cfg.Postgres.Ssl)
 		}
 
 		if cfg.Postgres.Port != 0 {
@@ -1056,7 +820,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
 		}
 
 		if cfg.Postgres.Pass != "" {
-			dbString += " password=" + cfg.Postgres.Pass
+			dbString += fmt.Sprintf(" password=%s", cfg.Postgres.Pass)
 		}
 
 		db, err := gorm.Open(postgres.Open(dbString), &gorm.Config{
@@ -1084,84 +848,29 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
 }
 
 func runMigrations(cfg types.DatabaseConfig, dbConn *gorm.DB, migrations *gormigrate.Gormigrate) error {
+	// Turn off foreign keys for the duration of the migration if using sqlite to
+	// prevent data loss due to the way the GORM migrator handles certain schema
+	// changes.
 	if cfg.Type == types.DatabaseSqlite {
-		// SQLite: Run migrations step-by-step, only disabling foreign keys when necessary
-
-		// List of migration IDs that require foreign keys to be disabled
-		// These are migrations that perform complex schema changes that GORM cannot handle safely with FK enabled
-		// NO NEW MIGRATIONS SHOULD BE ADDED HERE. ALL NEW MIGRATIONS MUST RUN WITH FOREIGN KEYS ENABLED.
-		migrationsRequiringFKDisabled := map[string]bool{
-			"202312101416":  true, // Initial migration with complex table/column renames
-			"202402151347":  true, // Migration that removes last_successful_update column
-			"2024041121742": true, // Migration that changes IP address storage format
-			"202407191627":  true, // User table automigration with FK constraint issues
-			"202408181235":  true, // User table automigration with FK constraint issues
-			"202501221827":  true, // Route table automigration with FK constraint issues
-			"202501311657":  true, // PreAuthKey table automigration with FK constraint issues
-			// Add other migration IDs here as they are identified to need FK disabled
-		}
-
-		// Get the current foreign key status
-		var fkOriginallyEnabled int
-		if err := dbConn.Raw("PRAGMA foreign_keys").Scan(&fkOriginallyEnabled).Error; err != nil {
+		var fkEnabled int
+		if err := dbConn.Raw("PRAGMA foreign_keys").Scan(&fkEnabled).Error; err != nil {
 			return fmt.Errorf("checking foreign key status: %w", err)
 		}
-
-		// Get all migration IDs in order from the actual migration definitions
-		// Only IDs that are in the migrationsRequiringFKDisabled map will be processed with FK disabled
-		// any other new migrations are ran after.
-		migrationIDs := []string{
-			"202312101416",
-			"202312101430",
-			"202402151347",
-			"2024041121742",
-			"202406021630",
-			"202407191627",
-			"202408181235",
-			"202409271400",
-			"202501221827",
-			"202501311657",
-			"202502070949",
-			"202502131714",
-			"202502171819",
-			"202505091439",
-			"202505141324",
-			// As of 2025-07-02, no new IDs should be added here.
-			// They will be ran by the migrations.Migrate() call below.
-		}
-
-		for _, migrationID := range migrationIDs {
-			log.Trace().Str("migration_id", migrationID).Msg("Running migration")
-			needsFKDisabled := migrationsRequiringFKDisabled[migrationID]
-
-			if needsFKDisabled {
-				// Disable foreign keys for this migration
-				if err := dbConn.Exec("PRAGMA foreign_keys = OFF").Error; err != nil {
-					return fmt.Errorf("disabling foreign keys for migration %s: %w", migrationID, err)
-				}
-			} else {
-				// Ensure foreign keys are enabled for this migration
-				if err := dbConn.Exec("PRAGMA foreign_keys = ON").Error; err != nil {
-					return fmt.Errorf("enabling foreign keys for migration %s: %w", migrationID, err)
-				}
-			}
-
-			// Run up to this specific migration (will only run the next pending migration)
-			if err := migrations.MigrateTo(migrationID); err != nil {
-				return fmt.Errorf("running migration %s: %w", migrationID, err)
+		if fkEnabled == 1 {
+			if err := dbConn.Exec("PRAGMA foreign_keys = OFF").Error; err != nil {
+				return fmt.Errorf("disabling foreign keys: %w", err)
 			}
+			defer dbConn.Exec("PRAGMA foreign_keys = ON")
 		}
+	}
 
-		if err := dbConn.Exec("PRAGMA foreign_keys = ON").Error; err != nil {
-			return fmt.Errorf("restoring foreign keys: %w", err)
-		}
+	if err := migrations.Migrate(); err != nil {
+		return err
+	}
 
-		// Run the rest of the migrations
-		if err := migrations.Migrate(); err != nil {
-			return err
-		}
-
-		// Check for constraint violations at the end
+	// Since we disabled foreign keys for the migration, we need to check for
+	// constraint violations manually at the end of the migration.
+	if cfg.Type == types.DatabaseSqlite {
 		type constraintViolation struct {
 			Table           string
 			RowID           int
@@ -1195,12 +904,7 @@ func runMigrations(cfg types.DatabaseConfig, dbConn *gorm.DB, migrations *gormig
 					Msg("Foreign key constraint violated")
 			}
 
-			return errForeignKeyConstraintsViolated
-		}
-	} else {
-		// PostgreSQL can run all migrations in one block - no foreign key issues
-		if err := migrations.Migrate(); err != nil {
-			return err
+			return fmt.Errorf("foreign key constraints violated")
 		}
 	}
 
@@ -1245,7 +949,6 @@ func Read[T any](db *gorm.DB, fn func(rx *gorm.DB) (T, error)) (T, error) {
 		var no T
 		return no, err
 	}
-
 	return ret, nil
 }
 
@@ -1267,6 +970,5 @@ func Write[T any](db *gorm.DB, fn func(tx *gorm.DB) (T, error)) (T, error) {
 		var no T
 		return no, err
 	}
-
 	return ret, tx.Commit().Error
 }

hscontrol/db/db_test.go

@@ -2,6 +2,8 @@ package db
 
 import (
 	"database/sql"
+	"fmt"
+	"io"
 	"net/netip"
 	"os"
 	"os/exec"
@@ -22,10 +24,10 @@ import (
 	"zgo.at/zcache/v2"
 )
 
-// TestSQLiteMigrationAndDataValidation tests specific SQLite migration scenarios
-// and validates data integrity after migration. All migrations that require data validation
-// should be added here.
-func TestSQLiteMigrationAndDataValidation(t *testing.T) {
+// TestMigrationsSQLite is the main function for testing migrations,
+// we focus on SQLite correctness as it is the main database used in headscale.
+// All migrations that are worth testing should be added here.
+func TestMigrationsSQLite(t *testing.T) {
 	ipp := func(p string) netip.Prefix {
 		return netip.MustParsePrefix(p)
 	}
@@ -41,39 +43,12 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 	tests := []struct {
 		dbPath   string
 		wantFunc func(*testing.T, *HSDatabase)
+		wantErr  string
 	}{
 		{
-			dbPath: "testdata/sqlite/0-22-3-to-0-23-0-routes-are-dropped-2063_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Comprehensive data preservation validation for 0.22.3->0.23.0 migration
-				// Expected data from dump: 4 users, 17 pre_auth_keys, 14 machines/nodes, 12 routes
-
-				// Verify users data preservation - should have 4 users
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 4, "should preserve all 4 users from original schema")
-
-				// Verify pre_auth_keys data preservation - should have 17 keys
-				preAuthKeys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					var keys []types.PreAuthKey
-					err := rx.Find(&keys).Error
-					return keys, err
-				})
-				require.NoError(t, err)
-				assert.Len(t, preAuthKeys, 17, "should preserve all 17 pre_auth_keys from original schema")
-
-				// Verify all nodes data preservation - should have 14 nodes
-				allNodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
-					return ListNodes(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, allNodes, 14, "should preserve all 14 machines/nodes from original schema")
-
-				// Verify specific nodes and their route migration with detailed validation
-				nodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
+			dbPath: "testdata/0-22-3-to-0-23-0-routes-are-dropped-2063.sqlite",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				nodes, err := Read(h.DB, func(rx *gorm.DB) (types.Nodes, error) {
 					n1, err := GetNodeByID(rx, 1)
 					n26, err := GetNodeByID(rx, 26)
 					n31, err := GetNodeByID(rx, 31)
@@ -85,66 +60,24 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 					return types.Nodes{n1, n26, n31, n32}, nil
 				})
 				require.NoError(t, err)
-				assert.Len(t, nodes, 4, "should have retrieved 4 specific nodes")
 
-				// Validate specific node data from dump file
-				nodesByID := make(map[uint64]*types.Node)
-				for i := range nodes {
-					nodesByID[nodes[i].ID.Uint64()] = nodes[i]
-				}
-
-				node1 := nodesByID[1]
-				node26 := nodesByID[26]
-				node31 := nodesByID[31]
-				node32 := nodesByID[32]
-
-				require.NotNil(t, node1, "node 1 should exist")
-				require.NotNil(t, node26, "node 26 should exist")
-				require.NotNil(t, node31, "node 31 should exist")
-				require.NotNil(t, node32, "node 32 should exist")
-
-				// Validate node data using cmp.Diff
-				expectedNodes := map[uint64]struct {
-					Hostname  string
-					GivenName string
-					IPv4      string
-				}{
-					1:  {Hostname: "test_hostname", GivenName: "test_given_name", IPv4: "100.64.0.1"},
-					26: {Hostname: "test_hostname", GivenName: "test_given_name", IPv4: "100.64.0.19"},
-					31: {Hostname: "test_hostname", GivenName: "test_given_name", IPv4: "100.64.0.7"},
-					32: {Hostname: "test_hostname", GivenName: "test_given_name", IPv4: "100.64.0.11"},
-				}
-
-				for nodeID, expected := range expectedNodes {
-					node := nodesByID[nodeID]
-					require.NotNil(t, node, "node %d should exist", nodeID)
-
-					actual := struct {
-						Hostname  string
-						GivenName string
-						IPv4      string
-					}{
-						Hostname:  node.Hostname,
-						GivenName: node.GivenName,
-						IPv4:      node.IPv4.String(),
-					}
-
-					if diff := cmp.Diff(expected, actual); diff != "" {
-						t.Errorf("TestSQLiteMigrationAndDataValidation() node %d mismatch (-want +got):\n%s", nodeID, diff)
-					}
-				}
-
-				// Validate that routes were properly migrated from routes table to approved_routes
-				// Based on the dump file routes data:
-				// Node 1 (machine_id 1): routes 1,2,3 (0.0.0.0/0 enabled, ::/0 enabled, 10.9.110.0/24 enabled+primary)
-				// Node 26 (machine_id 26): route 6 (172.100.100.0/24 enabled+primary), route 7 (172.100.100.0/24 disabled)
-				// Node 31 (machine_id 31): routes 8,10 (0.0.0.0/0 enabled, ::/0 enabled), routes 9,11 (duplicates disabled)
-				// Node 32 (machine_id 32): route 12 (192.168.0.24/32 enabled+primary)
+				// want := types.Routes{
+				// 	r(1, "0.0.0.0/0", true, false),
+				// 	r(1, "::/0", true, false),
+				// 	r(1, "10.9.110.0/24", true, true),
+				// 	r(26, "172.100.100.0/24", true, true),
+				// 	r(26, "172.100.100.0/24", true, false, false),
+				// 	r(31, "0.0.0.0/0", true, false),
+				// 	r(31, "0.0.0.0/0", true, false, false),
+				// 	r(31, "::/0", true, false),
+				// 	r(31, "::/0", true, false, false),
+				// 	r(32, "192.168.0.24/32", true, true),
+				// }
 				want := [][]netip.Prefix{
-					{ipp("0.0.0.0/0"), ipp("10.9.110.0/24"), ipp("::/0")}, // node 1: 3 enabled routes
-					{ipp("172.100.100.0/24")},                             // node 26: 1 enabled route
-					{ipp("0.0.0.0/0"), ipp("::/0")},                       // node 31: 2 enabled routes
-					{ipp("192.168.0.24/32")},                              // node 32: 1 enabled route
+					{ipp("0.0.0.0/0"), ipp("10.9.110.0/24"), ipp("::/0")},
+					{ipp("172.100.100.0/24")},
+					{ipp("0.0.0.0/0"), ipp("::/0")},
+					{ipp("192.168.0.24/32")},
 				}
 				var got [][]netip.Prefix
 				for _, node := range nodes {
@@ -152,48 +85,14 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 				}
 
 				if diff := cmp.Diff(want, got, util.PrefixComparer); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() route migration mismatch (-want +got):\n%s", diff)
+					t.Errorf("TestMigrations() mismatch (-want +got):\n%s", diff)
 				}
-
-				// Verify routes table was dropped after migration
-				var routesTableExists bool
-				err = hsdb.DB.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='routes'").Row().Scan(&routesTableExists)
-				require.NoError(t, err)
-				assert.False(t, routesTableExists, "routes table should have been dropped after migration")
 			},
 		},
 		{
-			dbPath: "testdata/sqlite/0-22-3-to-0-23-0-routes-fail-foreign-key-2076_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Comprehensive data preservation validation for foreign key constraint issue case
-				// Expected data from dump: 4 users, 2 pre_auth_keys, 8 nodes
-
-				// Verify users data preservation
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 4, "should preserve all 4 users from original schema")
-
-				// Verify pre_auth_keys data preservation
-				preAuthKeys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					var keys []types.PreAuthKey
-					err := rx.Find(&keys).Error
-					return keys, err
-				})
-				require.NoError(t, err)
-				assert.Len(t, preAuthKeys, 2, "should preserve all 2 pre_auth_keys from original schema")
-
-				// Verify all nodes data preservation
-				allNodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
-					return ListNodes(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, allNodes, 8, "should preserve all 8 nodes from original schema")
-
-				// Verify specific node route migration
-				node, err := Read(hsdb.DB, func(rx *gorm.DB) (*types.Node, error) {
+			dbPath: "testdata/0-22-3-to-0-23-0-routes-fail-foreign-key-2076.sqlite",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				node, err := Read(h.DB, func(rx *gorm.DB) (*types.Node, error) {
 					return GetNodeByID(rx, 13)
 				})
 				require.NoError(t, err)
@@ -202,26 +101,26 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 				_ = types.Routes{
 					// These routes exists, but have no nodes associated with them
 					// when the migration starts.
-					// r(1, "0.0.0.0/0", true, false),
-					// r(1, "::/0", true, false),
-					// r(3, "0.0.0.0/0", true, false),
-					// r(3, "::/0", true, false),
-					// r(5, "0.0.0.0/0", true, false),
-					// r(5, "::/0", true, false),
-					// r(6, "0.0.0.0/0", true, false),
-					// r(6, "::/0", true, false),
+					// r(1, "0.0.0.0/0", true, true, false),
+					// r(1, "::/0", true, true, false),
+					// r(3, "0.0.0.0/0", true, true, false),
+					// r(3, "::/0", true, true, false),
+					// r(5, "0.0.0.0/0", true, true, false),
+					// r(5, "::/0", true, true, false),
+					// r(6, "0.0.0.0/0", true, true, false),
+					// r(6, "::/0", true, true, false),
 					// r(6, "10.0.0.0/8", true, false, false),
-					// r(7, "0.0.0.0/0", true, false),
-					// r(7, "::/0", true, false),
+					// r(7, "0.0.0.0/0", true, true, false),
+					// r(7, "::/0", true, true, false),
 					// r(7, "10.0.0.0/8", true, false, false),
-					// r(9, "0.0.0.0/0", true, false),
-					// r(9, "::/0", true, false),
-					// r(9, "10.0.0.0/8", true, false),
-					// r(11, "0.0.0.0/0", true, false),
-					// r(11, "::/0", true, false),
-					// r(11, "10.0.0.0/8", true, true),
-					// r(12, "0.0.0.0/0", true, false),
-					// r(12, "::/0", true, false),
+					// r(9, "0.0.0.0/0", true, true, false),
+					// r(9, "::/0", true, true, false),
+					// r(9, "10.0.0.0/8", true, true, false),
+					// r(11, "0.0.0.0/0", true, true, false),
+					// r(11, "::/0", true, true, false),
+					// r(11, "10.0.0.0/8", true, true, true),
+					// r(12, "0.0.0.0/0", true, true, false),
+					// r(12, "::/0", true, true, false),
 					// r(12, "10.0.0.0/8", true, false, false),
 					//
 					// These nodes exists, so routes should be kept.
@@ -232,14 +131,8 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 				}
 				want := []netip.Prefix{ipp("0.0.0.0/0"), ipp("10.18.80.2/32"), ipp("::/0")}
 				if diff := cmp.Diff(want, node.ApprovedRoutes, util.PrefixComparer); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() route migration mismatch (-want +got):\n%s", diff)
+					t.Errorf("TestMigrations() mismatch (-want +got):\n%s", diff)
 				}
-
-				// Verify routes table was dropped after migration
-				var routesTableExists bool
-				err = hsdb.DB.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='routes'").Row().Scan(&routesTableExists)
-				require.NoError(t, err)
-				assert.False(t, routesTableExists, "routes table should have been dropped after migration")
 			},
 		},
 		// at 14:15:06 ❯ go run ./cmd/headscale preauthkeys list
@@ -250,49 +143,9 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 		// 4  | f20155.. | false    | false     | false | 2024-09-27 | 2024-09-27 | tag:test
 		// 5  | b212b9.. | false    | false     | false | 2024-09-27 | 2024-09-27 | tag:test,tag:woop,tag:dedu
 		{
-			dbPath: "testdata/sqlite/0-23-0-to-0-24-0-preauthkey-tags-table_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Comprehensive data preservation validation for pre-auth key tags migration
-				// Expected data from dump: 2 users (kratest, testkra), 5 pre_auth_keys with specific tags
-
-				// Verify users data preservation with specific user data
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 2, "should preserve all 2 users from original schema")
-
-				// Validate specific user data from dump file using cmp.Diff
-				expectedUsers := []types.User{
-					{Model: gorm.Model{ID: 1}, Name: "kratest"},
-					{Model: gorm.Model{ID: 2}, Name: "testkra"},
-				}
-
-				if diff := cmp.Diff(expectedUsers, users,
-					cmpopts.IgnoreFields(types.User{}, "CreatedAt", "UpdatedAt", "DeletedAt", "DisplayName", "Email", "ProviderIdentifier", "Provider", "ProfilePicURL")); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() users mismatch (-want +got):\n%s", diff)
-				}
-
-				// Create maps for easier access in later validations
-				usersByName := make(map[string]*types.User)
-				for i := range users {
-					usersByName[users[i].Name] = &users[i]
-				}
-				kratest := usersByName["kratest"]
-				testkra := usersByName["testkra"]
-
-				// Verify all pre_auth_keys data preservation
-				allKeys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					var keys []types.PreAuthKey
-					err := rx.Find(&keys).Error
-					return keys, err
-				})
-				require.NoError(t, err)
-				assert.Len(t, allKeys, 5, "should preserve all 5 pre_auth_keys from original schema")
-
-				// Verify specific pre-auth keys and their tag migration with exact data validation
-				keys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
+			dbPath: "testdata/0-23-0-to-0-24-0-preauthkey-tags-table.sqlite",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				keys, err := Read(h.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
 					kratest, err := ListPreAuthKeysByUser(rx, 1) // kratest
 					if err != nil {
 						return nil, err
@@ -306,104 +159,51 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 					return append(kratest, testkra...), nil
 				})
 				require.NoError(t, err)
+
 				assert.Len(t, keys, 5)
-
-				// Create map for easier validation by ID
-				keysByID := make(map[uint64]*types.PreAuthKey)
-				for i := range keys {
-					keysByID[keys[i].ID] = &keys[i]
-				}
-
-				// Validate specific pre-auth key data and tag migration from pre_auth_key_acl_tags table
-				key1 := keysByID[1]
-				key2 := keysByID[2]
-				key3 := keysByID[3]
-				key4 := keysByID[4]
-				key5 := keysByID[5]
-
-				require.NotNil(t, key1, "pre_auth_key 1 should exist")
-				require.NotNil(t, key2, "pre_auth_key 2 should exist")
-				require.NotNil(t, key3, "pre_auth_key 3 should exist")
-				require.NotNil(t, key4, "pre_auth_key 4 should exist")
-				require.NotNil(t, key5, "pre_auth_key 5 should exist")
-
-				// Validate specific pre-auth key data and tag migration using cmp.Diff
-				expectedKeys := []types.PreAuthKey{
+				want := []types.PreAuthKey{
 					{
-						ID:     1,
-						Key:    "09b28f8c3351984874d46dace0a70177a8721933a950b663",
-						UserID: kratest.ID,
-						Tags:   []string{"tag:derp"},
+						ID:   1,
+						Tags: []string{"tag:derp"},
 					},
 					{
-						ID:     2,
-						Key:    "3112b953cb344191b2d5aec1b891250125bf7b437eac5d26",
-						UserID: kratest.ID,
-						Tags:   []string{"tag:derp"},
+						ID:   2,
+						Tags: []string{"tag:derp"},
 					},
 					{
-						ID:     3,
-						Key:    "7c23b9f215961e7609527aef78bf82fb19064b002d78c36f",
-						UserID: kratest.ID,
-						Tags:   []string{"tag:derp", "tag:merp"},
+						ID:   3,
+						Tags: []string{"tag:derp", "tag:merp"},
 					},
 					{
-						ID:     4,
-						Key:    "f2015583852b725220cc4b107fb288a4cf7ac259bd458a32",
-						UserID: testkra.ID,
-						Tags:   []string{"tag:test"},
+						ID:   4,
+						Tags: []string{"tag:test"},
 					},
 					{
-						ID:     5,
-						Key:    "b212b990165e897944dd3772786544402729fb349da50f57",
-						UserID: testkra.ID,
-						Tags:   []string{"tag:test", "tag:woop", "tag:dedu"},
+						ID:   5,
+						Tags: []string{"tag:test", "tag:woop", "tag:dedu"},
 					},
 				}
 
-				if diff := cmp.Diff(expectedKeys, keys, cmp.Comparer(func(a, b []string) bool {
+				if diff := cmp.Diff(want, keys, cmp.Comparer(func(a, b []string) bool {
 					sort.Sort(sort.StringSlice(a))
 					sort.Sort(sort.StringSlice(b))
 					return slices.Equal(a, b)
-				}), cmpopts.IgnoreFields(types.PreAuthKey{}, "User", "CreatedAt", "Reusable", "Ephemeral", "Used", "Expiration")); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() pre-auth key tags migration mismatch (-want +got):\n%s", diff)
+				}), cmpopts.IgnoreFields(types.PreAuthKey{}, "Key", "UserID", "User", "CreatedAt", "Expiration")); diff != "" {
+					t.Errorf("TestMigrations() mismatch (-want +got):\n%s", diff)
 				}
 
-				// Verify pre_auth_key_acl_tags table was dropped after migration
-				if hsdb.DB.Migrator().HasTable("pre_auth_key_acl_tags") {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() table pre_auth_key_acl_tags should not exist after migration")
+				if h.DB.Migrator().HasTable("pre_auth_key_acl_tags") {
+					t.Errorf("TestMigrations() table pre_auth_key_acl_tags should not exist")
 				}
 			},
 		},
 		{
-			dbPath: "testdata/sqlite/0-23-0-to-0-24-0-no-more-special-types_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Comprehensive data preservation validation for special types removal migration
-				// Expected data from dump: 2 users, 2 pre_auth_keys, 12 nodes
-
-				// Verify users data preservation
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 2, "should preserve all 2 users from original schema")
-
-				// Verify pre_auth_keys data preservation
-				preAuthKeys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					var keys []types.PreAuthKey
-					err := rx.Find(&keys).Error
-					return keys, err
-				})
-				require.NoError(t, err)
-				assert.Len(t, preAuthKeys, 2, "should preserve all 2 pre_auth_keys from original schema")
-
-				// Verify nodes data preservation and field validation
-				nodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
+			dbPath: "testdata/0-23-0-to-0-24-0-no-more-special-types.sqlite",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				nodes, err := Read(h.DB, func(rx *gorm.DB) (types.Nodes, error) {
 					return ListNodes(rx)
 				})
 				require.NoError(t, err)
-				assert.Len(t, nodes, 12, "should preserve all 12 nodes from original schema")
 
 				for _, node := range nodes {
 					assert.Falsef(t, node.MachineKey.IsZero(), "expected non zero machinekey")
@@ -413,7 +213,7 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 					assert.Falsef(t, node.DiscoKey.IsZero(), "expected non zero discokey")
 					assert.Contains(t, node.DiscoKey.String(), "discokey:")
 					assert.NotNil(t, node.IPv4)
-					assert.NotNil(t, node.IPv6)
+					assert.NotNil(t, node.IPv4)
 					assert.Len(t, node.Endpoints, 1)
 					assert.NotNil(t, node.Hostinfo)
 					assert.NotNil(t, node.MachineKey)
@@ -421,31 +221,12 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 			},
 		},
 		{
-			dbPath: "testdata/sqlite/failing-node-preauth-constraint_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Comprehensive data preservation validation for node-preauth constraint issue
-				// Expected data from dump: 1 user, 2 api_keys, 6 nodes
-
-				// Verify users data preservation
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 1, "should preserve all 1 user from original schema")
-
-				// Verify api_keys data preservation
-				var apiKeyCount int
-				err = hsdb.DB.Raw("SELECT COUNT(*) FROM api_keys").Scan(&apiKeyCount).Error
-				require.NoError(t, err)
-				assert.Equal(t, 2, apiKeyCount, "should preserve all 2 api_keys from original schema")
-
-				// Verify nodes data preservation and field validation
-				nodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
+			dbPath: "testdata/failing-node-preauth-constraint.sqlite",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				nodes, err := Read(h.DB, func(rx *gorm.DB) (types.Nodes, error) {
 					return ListNodes(rx)
 				})
 				require.NoError(t, err)
-				assert.Len(t, nodes, 6, "should preserve all 6 nodes from original schema")
 
 				for _, node := range nodes {
 					assert.Falsef(t, node.MachineKey.IsZero(), "expected non zero machinekey")
@@ -459,262 +240,25 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 				}
 			},
 		},
-		{
-			dbPath: "testdata/sqlite/wrongly-migrated-schema-0.25.1_dump.sql",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				// Test migration of a database that was wrongly migrated in 0.25.1
-				// This database has several issues:
-				// 1. Missing proper user unique constraints (idx_provider_identifier, idx_name_provider_identifier, idx_name_no_provider_identifier)
-				// 2. Still has routes table that should have been migrated to node.approved_routes
-				// 3. Wrong FOREIGN KEY constraint on pre_auth_keys (CASCADE instead of SET NULL)
-				// 4. Missing some required indexes
-
-				// Verify users table data is preserved with specific user data
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-					return ListUsers(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, users, 2, "should preserve existing users")
-
-				// Validate specific user data from dump file using cmp.Diff
-				expectedUsers := []types.User{
-					{Model: gorm.Model{ID: 1}, Name: "user2"},
-					{Model: gorm.Model{ID: 2}, Name: "user1"},
-				}
-
-				if diff := cmp.Diff(expectedUsers, users,
-					cmpopts.IgnoreFields(types.User{}, "CreatedAt", "UpdatedAt", "DeletedAt", "DisplayName", "Email", "ProviderIdentifier", "Provider", "ProfilePicURL")); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() users mismatch (-want +got):\n%s", diff)
-				}
-
-				// Create maps for easier access in later validations
-				usersByName := make(map[string]*types.User)
-				for i := range users {
-					usersByName[users[i].Name] = &users[i]
-				}
-				user1 := usersByName["user1"]
-				user2 := usersByName["user2"]
-
-				// Verify nodes table data is preserved and routes migrated to approved_routes
-				nodes, err := Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
-					return ListNodes(rx)
-				})
-				require.NoError(t, err)
-				assert.Len(t, nodes, 3, "should preserve existing nodes")
-
-				// Validate specific node data from dump file
-				nodesByID := make(map[uint64]*types.Node)
-				for i := range nodes {
-					nodesByID[nodes[i].ID.Uint64()] = nodes[i]
-				}
-
-				node1 := nodesByID[1]
-				node2 := nodesByID[2]
-				node3 := nodesByID[3]
-				require.NotNil(t, node1, "node 1 should exist")
-				require.NotNil(t, node2, "node 2 should exist")
-				require.NotNil(t, node3, "node 3 should exist")
-
-				// Validate specific node field data using cmp.Diff
-				expectedNodes := map[uint64]struct {
-					Hostname  string
-					GivenName string
-					IPv4      string
-					IPv6      string
-					UserID    uint
-				}{
-					1: {Hostname: "node1", GivenName: "node1", IPv4: "100.64.0.1", IPv6: "fd7a:115c:a1e0::1", UserID: user2.ID},
-					2: {Hostname: "node2", GivenName: "node2", IPv4: "100.64.0.2", IPv6: "fd7a:115c:a1e0::2", UserID: user2.ID},
-					3: {Hostname: "node3", GivenName: "node3", IPv4: "100.64.0.3", IPv6: "fd7a:115c:a1e0::3", UserID: user1.ID},
-				}
-
-				for nodeID, expected := range expectedNodes {
-					node := nodesByID[nodeID]
-					require.NotNil(t, node, "node %d should exist", nodeID)
-
-					actual := struct {
-						Hostname  string
-						GivenName string
-						IPv4      string
-						IPv6      string
-						UserID    uint
-					}{
-						Hostname:  node.Hostname,
-						GivenName: node.GivenName,
-						IPv4:      node.IPv4.String(),
-						IPv6: func() string {
-							if node.IPv6 != nil {
-								return node.IPv6.String()
-							} else {
-								return ""
-							}
-						}(),
-						UserID: node.UserID,
-					}
-
-					if diff := cmp.Diff(expected, actual); diff != "" {
-						t.Errorf("TestSQLiteMigrationAndDataValidation() node %d basic fields mismatch (-want +got):\n%s", nodeID, diff)
-					}
-
-					// Special validation for MachineKey content for node 1 only
-					if nodeID == 1 {
-						assert.Contains(t, node.MachineKey.String(), "mkey:1efe4388236c1c83fe0a19d3ce7c321ab81e138a4da57917c231ce4c01944409")
-					}
-				}
-
-				// Check that routes were migrated from routes table to node.approved_routes using cmp.Diff
-				// Original routes table had 4 routes for nodes 1, 2, 3:
-				// Node 1: 0.0.0.0/0 (enabled), ::/0 (enabled) -> should have 2 approved routes
-				// Node 2: 192.168.100.0/24 (enabled) -> should have 1 approved route
-				// Node 3: 10.0.0.0/8 (disabled) -> should have 0 approved routes
-				expectedRoutes := map[uint64][]netip.Prefix{
-					1: {netip.MustParsePrefix("0.0.0.0/0"), netip.MustParsePrefix("::/0")},
-					2: {netip.MustParsePrefix("192.168.100.0/24")},
-					3: nil,
-				}
-
-				actualRoutes := map[uint64][]netip.Prefix{
-					1: node1.ApprovedRoutes,
-					2: node2.ApprovedRoutes,
-					3: node3.ApprovedRoutes,
-				}
-
-				if diff := cmp.Diff(expectedRoutes, actualRoutes, util.PrefixComparer); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() routes migration mismatch (-want +got):\n%s", diff)
-				}
-
-				// Verify pre_auth_keys data is preserved with specific key data
-				preAuthKeys, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					var keys []types.PreAuthKey
-					err := rx.Find(&keys).Error
-					return keys, err
-				})
-				require.NoError(t, err)
-				assert.Len(t, preAuthKeys, 2, "should preserve existing pre_auth_keys")
-
-				// Validate specific pre_auth_key data from dump file using cmp.Diff
-				expectedKeys := []types.PreAuthKey{
-					{
-						ID:       1,
-						Key:      "3d133ec953e31fd41edbd935371234f762b4bae300cea618",
-						UserID:   user2.ID,
-						Reusable: true,
-						Used:     true,
-					},
-					{
-						ID:       2,
-						Key:      "9813cc1df1832259fb6322dad788bb9bec89d8a01eef683a",
-						UserID:   user1.ID,
-						Reusable: true,
-						Used:     true,
-					},
-				}
-
-				if diff := cmp.Diff(expectedKeys, preAuthKeys,
-					cmpopts.IgnoreFields(types.PreAuthKey{}, "User", "CreatedAt", "Expiration", "Ephemeral", "Tags")); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() pre_auth_keys mismatch (-want +got):\n%s", diff)
-				}
-
-				// Verify api_keys data is preserved with specific key data
-				var apiKeys []struct {
-					ID         uint64
-					Prefix     string
-					Hash       []byte
-					CreatedAt  string
-					Expiration string
-					LastSeen   string
-				}
-				err = hsdb.DB.Raw("SELECT id, prefix, hash, created_at, expiration, last_seen FROM api_keys").Scan(&apiKeys).Error
-				require.NoError(t, err)
-				assert.Len(t, apiKeys, 1, "should preserve existing api_keys")
-
-				// Validate specific api_key data from dump file using cmp.Diff
-				expectedAPIKey := struct {
-					ID     uint64
-					Prefix string
-					Hash   []byte
-				}{
-					ID:     1,
-					Prefix: "ak_test",
-					Hash:   []byte{0xde, 0xad, 0xbe, 0xef},
-				}
-
-				actualAPIKey := struct {
-					ID     uint64
-					Prefix string
-					Hash   []byte
-				}{
-					ID:     apiKeys[0].ID,
-					Prefix: apiKeys[0].Prefix,
-					Hash:   apiKeys[0].Hash,
-				}
-
-				if diff := cmp.Diff(expectedAPIKey, actualAPIKey); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() api_key mismatch (-want +got):\n%s", diff)
-				}
-
-				// Validate date fields separately since they need Contains check
-				assert.Contains(t, apiKeys[0].CreatedAt, "2025-12-31", "created_at should be preserved")
-				assert.Contains(t, apiKeys[0].Expiration, "2025-06-18", "expiration should be preserved")
-
-				// Verify that routes table no longer exists (should have been dropped)
-				var routesTableExists bool
-				err = hsdb.DB.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='routes'").Row().Scan(&routesTableExists)
-				require.NoError(t, err)
-				assert.False(t, routesTableExists, "routes table should have been dropped")
-
-				// Verify all required indexes exist with correct structure using cmp.Diff
-				expectedIndexes := []string{
-					"idx_users_deleted_at",
-					"idx_provider_identifier",
-					"idx_name_provider_identifier",
-					"idx_name_no_provider_identifier",
-					"idx_api_keys_prefix",
-					"idx_policies_deleted_at",
-				}
-
-				expectedIndexMap := make(map[string]bool)
-				for _, index := range expectedIndexes {
-					expectedIndexMap[index] = true
-				}
-
-				actualIndexMap := make(map[string]bool)
-				for _, indexName := range expectedIndexes {
-					var indexExists bool
-					err = hsdb.DB.Raw("SELECT COUNT(*) FROM sqlite_master WHERE type='index' AND name=?", indexName).Row().Scan(&indexExists)
-					require.NoError(t, err)
-					actualIndexMap[indexName] = indexExists
-				}
-
-				if diff := cmp.Diff(expectedIndexMap, actualIndexMap); diff != "" {
-					t.Errorf("TestSQLiteMigrationAndDataValidation() indexes existence mismatch (-want +got):\n%s", diff)
-				}
-
-				// Verify proper foreign key constraints are set
-				// Check that pre_auth_keys has correct FK constraint (SET NULL, not CASCADE)
-				var preAuthKeyConstraint string
-				err = hsdb.DB.Raw("SELECT sql FROM sqlite_master WHERE type='table' AND name='pre_auth_keys'").Row().Scan(&preAuthKeyConstraint)
-				require.NoError(t, err)
-				assert.Contains(t, preAuthKeyConstraint, "ON DELETE SET NULL", "pre_auth_keys should have SET NULL constraint")
-				assert.NotContains(t, preAuthKeyConstraint, "ON DELETE CASCADE", "pre_auth_keys should not have CASCADE constraint")
-
-				// Verify that user unique constraints work properly
-				// Try to create duplicate local user (should fail)
-				err = hsdb.DB.Create(&types.User{Name: users[0].Name}).Error
-				require.Error(t, err, "should not allow duplicate local usernames")
-				assert.Contains(t, err.Error(), "UNIQUE constraint", "should fail with unique constraint error")
-			},
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.dbPath, func(t *testing.T) {
-			if !strings.HasSuffix(tt.dbPath, ".sql") {
-				t.Fatalf("TestSQLiteMigrationAndDataValidation only supports .sql files, got: %s", tt.dbPath)
+			dbPath, err := testCopyOfDatabase(t, tt.dbPath)
+			if err != nil {
+				t.Fatalf("copying db for test: %s", err)
+			}
+
+			hsdb, err := NewHeadscaleDatabase(types.DatabaseConfig{
+				Type: "sqlite3",
+				Sqlite: types.SqliteConfig{
+					Path: dbPath,
+				},
+			}, "", emptyCache())
+			if err != nil && tt.wantErr != err.Error() {
+				t.Errorf("TestMigrations() unexpected error = %v, wantErr %v", err, tt.wantErr)
 			}
 
-			hsdb := dbForTestWithPath(t, tt.dbPath)
 			if tt.wantFunc != nil {
 				tt.wantFunc(t, hsdb)
 			}
@@ -722,25 +266,37 @@ func TestSQLiteMigrationAndDataValidation(t *testing.T) {
 	}
 }
 
-func emptyCache() *zcache.Cache[types.RegistrationID, types.RegisterNode] {
-	return zcache.New[types.RegistrationID, types.RegisterNode](time.Minute, time.Hour)
+func testCopyOfDatabase(t *testing.T, src string) (string, error) {
+	sourceFileStat, err := os.Stat(src)
+	if err != nil {
+		return "", err
+	}
+
+	if !sourceFileStat.Mode().IsRegular() {
+		return "", fmt.Errorf("%s is not a regular file", src)
+	}
+
+	source, err := os.Open(src)
+	if err != nil {
+		return "", err
+	}
+	defer source.Close()
+
+	tmpDir := t.TempDir()
+	fn := filepath.Base(src)
+	dst := filepath.Join(tmpDir, fn)
+
+	destination, err := os.Create(dst)
+	if err != nil {
+		return "", err
+	}
+	defer destination.Close()
+	_, err = io.Copy(destination, source)
+	return dst, err
 }
 
-func createSQLiteFromSQLFile(sqlFilePath, dbPath string) error {
-	db, err := sql.Open("sqlite", dbPath)
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	schemaContent, err := os.ReadFile(sqlFilePath)
-	if err != nil {
-		return err
-	}
-
-	_, err = db.Exec(string(schemaContent))
-
-	return err
+func emptyCache() *zcache.Cache[types.RegistrationID, types.RegisterNode] {
+	return zcache.New[types.RegistrationID, types.RegisterNode](time.Minute, time.Hour)
 }
 
 // requireConstraintFailed checks if the error is a constraint failure with
@@ -859,13 +415,7 @@ func TestConstraints(t *testing.T) {
 	}
 }
 
-// TestPostgresMigrationAndDataValidation tests specific PostgreSQL migration scenarios
-// and validates data integrity after migration. All migrations that require data validation
-// should be added here.
-//
-// TODO(kradalby): Convert to use plain text SQL dumps instead of binary .pssql dumps for consistency
-// with SQLite tests and easier version control.
-func TestPostgresMigrationAndDataValidation(t *testing.T) {
+func TestMigrationsPostgres(t *testing.T) {
 	tests := []struct {
 		name     string
 		dbPath   string
@@ -873,10 +423,9 @@ func TestPostgresMigrationAndDataValidation(t *testing.T) {
 	}{
 		{
 			name:   "user-idx-breaking",
-			dbPath: "testdata/postgres/pre-24-postgresdb.pssql.dump",
-			wantFunc: func(t *testing.T, hsdb *HSDatabase) {
-				t.Helper()
-				users, err := Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
+			dbPath: "testdata/pre-24-postgresdb.pssql.dump",
+			wantFunc: func(t *testing.T, h *HSDatabase) {
+				users, err := Read(h.DB, func(rx *gorm.DB) ([]types.User, error) {
 					return ListUsers(rx)
 				})
 				require.NoError(t, err)
@@ -923,27 +472,9 @@ func TestPostgresMigrationAndDataValidation(t *testing.T) {
 
 func dbForTest(t *testing.T) *HSDatabase {
 	t.Helper()
-	return dbForTestWithPath(t, "")
-}
-
-func dbForTestWithPath(t *testing.T, sqlFilePath string) *HSDatabase {
-	t.Helper()
 
 	dbPath := t.TempDir() + "/headscale_test.db"
 
-	// If SQL file path provided, validate and create database from it
-	if sqlFilePath != "" {
-		// Validate that the file is a SQL text file
-		if !strings.HasSuffix(sqlFilePath, ".sql") {
-			t.Fatalf("dbForTestWithPath only accepts .sql files, got: %s", sqlFilePath)
-		}
-
-		err := createSQLiteFromSQLFile(sqlFilePath, dbPath)
-		if err != nil {
-			t.Fatalf("setting up database from SQL file %s: %s", sqlFilePath, err)
-		}
-	}
-
 	db, err := NewHeadscaleDatabase(
 		types.DatabaseConfig{
 			Type: "sqlite3",
@@ -958,59 +489,7 @@ func dbForTestWithPath(t *testing.T, sqlFilePath string) *HSDatabase {
 		t.Fatalf("setting up database: %s", err)
 	}
 
-	if sqlFilePath != "" {
-		t.Logf("database set up from %s at: %s", sqlFilePath, dbPath)
-	} else {
-		t.Logf("database set up at: %s", dbPath)
-	}
+	t.Logf("database set up at: %s", dbPath)
 
 	return db
 }
-
-// TestSQLiteAllTestdataMigrations tests migration compatibility across all SQLite schemas
-// in the testdata directory. It verifies they can be successfully migrated to the current
-// schema version. This test only validates migration success, not data integrity.
-//
-// A lot of the schemas have been automatically generated with old Headscale binaries on empty databases
-// (no user/node data):
-// - `headscale_<VERSION>_schema.sql` (created with `sqlite3 headscale.db .schema`)
-// - `headscale_<VERSION>_dump.sql` (created with `sqlite3 headscale.db .dump`)
-// where `_dump.sql` contains the migration steps that have been applied to the database.
-func TestSQLiteAllTestdataMigrations(t *testing.T) {
-	t.Parallel()
-	schemas, err := os.ReadDir("testdata/sqlite")
-	require.NoError(t, err)
-
-	t.Logf("loaded %d schemas", len(schemas))
-
-	for _, schema := range schemas {
-		if schema.IsDir() {
-			continue
-		}
-
-		t.Logf("validating: %s", schema.Name())
-
-		t.Run(schema.Name(), func(t *testing.T) {
-			t.Parallel()
-
-			dbPath := t.TempDir() + "/headscale_test.db"
-
-			// Setup a database with the old schema
-			schemaPath := filepath.Join("testdata/sqlite", schema.Name())
-			err := createSQLiteFromSQLFile(schemaPath, dbPath)
-			require.NoError(t, err)
-
-			_, err = NewHeadscaleDatabase(
-				types.DatabaseConfig{
-					Type: "sqlite3",
-					Sqlite: types.SqliteConfig{
-						Path: dbPath,
-					},
-				},
-				"",
-				emptyCache(),
-			)
-			require.NoError(t, err)
-		})
-	}
-}

hscontrol/db/ephemeral_garbage_collector_test.go

@@ -11,11 +11,9 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-const (
-	fiveHundred = 500 * time.Millisecond
-	oneHundred  = 100 * time.Millisecond
-	fifty       = 50 * time.Millisecond
-)
+const fiveHundredMillis = 500 * time.Millisecond
+const oneHundredMillis = 100 * time.Millisecond
+const fiftyMillis = 50 * time.Millisecond
 
 // TestEphemeralGarbageCollectorGoRoutineLeak is a test for a goroutine leak in EphemeralGarbageCollector().
 // It creates a new EphemeralGarbageCollector, schedules several nodes for deletion with a short expiry,
@@ -43,7 +41,7 @@ func TestEphemeralGarbageCollectorGoRoutineLeak(t *testing.T) {
 	go gc.Start()
 
 	// Schedule several nodes for deletion with short expiry
-	const expiry = fifty
+	const expiry = fiftyMillis
 	const numNodes = 100
 
 	// Set up wait group for expected deletions
@@ -58,7 +56,7 @@ func TestEphemeralGarbageCollectorGoRoutineLeak(t *testing.T) {
 
 	// Check nodes are deleted
 	deleteMutex.Lock()
-	assert.Len(t, deletedIDs, numNodes, "Not all nodes were deleted")
+	assert.Equal(t, numNodes, len(deletedIDs), "Not all nodes were deleted")
 	deleteMutex.Unlock()
 
 	// Schedule and immediately cancel to test that part of the code
@@ -78,7 +76,7 @@ func TestEphemeralGarbageCollectorGoRoutineLeak(t *testing.T) {
 
 		// Give any potential leaked goroutines a chance to exit
 		// Still need a small sleep here as we're checking for absence of goroutines
-		time.Sleep(oneHundred)
+		time.Sleep(oneHundredMillis)
 
 		// Check for leaked goroutines
 		finalGoroutines := runtime.NumGoroutine()
@@ -114,7 +112,7 @@ func TestEphemeralGarbageCollectorReschedule(t *testing.T) {
 	go gc.Start()
 	defer gc.Close()
 
-	const shortExpiry = fifty
+	const shortExpiry = fiftyMillis
 	const longExpiry = 1 * time.Hour
 
 	nodeID := types.NodeID(1)
@@ -130,7 +128,7 @@ func TestEphemeralGarbageCollectorReschedule(t *testing.T) {
 
 	// Verify that the node was deleted once
 	deleteMutex.Lock()
-	assert.Len(t, deletedIDs, 1, "Node should be deleted exactly once")
+	assert.Equal(t, 1, len(deletedIDs), "Node should be deleted exactly once")
 	assert.Equal(t, nodeID, deletedIDs[0], "The correct node should be deleted")
 	deleteMutex.Unlock()
 }
@@ -157,7 +155,7 @@ func TestEphemeralGarbageCollectorCancelAndReschedule(t *testing.T) {
 	defer gc.Close()
 
 	nodeID := types.NodeID(1)
-	const expiry = fifty
+	const expiry = fiftyMillis
 
 	// Schedule node for deletion
 	gc.Schedule(nodeID, expiry)
@@ -174,7 +172,7 @@ func TestEphemeralGarbageCollectorCancelAndReschedule(t *testing.T) {
 	}
 
 	deleteMutex.Lock()
-	assert.Empty(t, deletedIDs, "Node should not be deleted after cancellation")
+	assert.Equal(t, 0, len(deletedIDs), "Node should not be deleted after cancellation")
 	deleteMutex.Unlock()
 
 	// Reschedule the node
@@ -191,7 +189,7 @@ func TestEphemeralGarbageCollectorCancelAndReschedule(t *testing.T) {
 
 	// Verify final state
 	deleteMutex.Lock()
-	assert.Len(t, deletedIDs, 1, "Node should be deleted after rescheduling")
+	assert.Equal(t, 1, len(deletedIDs), "Node should be deleted after rescheduling")
 	assert.Equal(t, nodeID, deletedIDs[0], "The correct node should be deleted")
 	deleteMutex.Unlock()
 }
@@ -214,7 +212,7 @@ func TestEphemeralGarbageCollectorCloseBeforeTimerFires(t *testing.T) {
 	go gc.Start()
 
 	const longExpiry = 1 * time.Hour
-	const shortExpiry = fifty
+	const shortExpiry = fiftyMillis
 
 	// Schedule node deletion with a long expiry
 	gc.Schedule(types.NodeID(1), longExpiry)
@@ -227,7 +225,7 @@ func TestEphemeralGarbageCollectorCloseBeforeTimerFires(t *testing.T) {
 
 	// Verify that no deletion occurred
 	deleteMutex.Lock()
-	assert.Empty(t, deletedIDs, "No node should be deleted when GC is closed before timer fires")
+	assert.Equal(t, 0, len(deletedIDs), "No node should be deleted when GC is closed before timer fires")
 	deleteMutex.Unlock()
 }
 
@@ -271,7 +269,7 @@ func TestEphemeralGarbageCollectorScheduleAfterClose(t *testing.T) {
 		// Give the GC time to fully close and clean up resources
 		// This is still time-based but only affects when we check the goroutine count,
 		// not the actual test logic
-		time.Sleep(oneHundred)
+		time.Sleep(oneHundredMillis)
 		close(gcClosedCheck)
 	}()
 
@@ -281,7 +279,7 @@ func TestEphemeralGarbageCollectorScheduleAfterClose(t *testing.T) {
 	gc.Schedule(nodeID, 1*time.Millisecond)
 
 	// Set up a timeout channel for our test
-	timeout := time.After(fiveHundred)
+	timeout := time.After(fiveHundredMillis)
 
 	// Check if any node was deleted (which shouldn't happen)
 	select {
@@ -331,7 +329,7 @@ func TestEphemeralGarbageCollectorConcurrentScheduleAndClose(t *testing.T) {
 	// Number of concurrent scheduling goroutines
 	const numSchedulers = 10
 	const nodesPerScheduler = 50
-	const schedulingDuration = fiveHundred
+	const schedulingDuration = fiveHundredMillis
 
 	// Use WaitGroup to wait for all scheduling goroutines to finish
 	var wg sync.WaitGroup
@@ -341,14 +339,14 @@ func TestEphemeralGarbageCollectorConcurrentScheduleAndClose(t *testing.T) {
 	stopScheduling := make(chan struct{})
 
 	// Launch goroutines that continuously schedule nodes
-	for schedulerIndex := range numSchedulers {
+	for i := 0; i < numSchedulers; i++ {
 		go func(schedulerID int) {
 			defer wg.Done()
 
 			baseNodeID := schedulerID * nodesPerScheduler
 
 			// Keep scheduling nodes until signaled to stop
-			for j := range nodesPerScheduler {
+			for j := 0; j < nodesPerScheduler; j++ {
 				select {
 				case <-stopScheduling:
 					return
@@ -360,7 +358,7 @@ func TestEphemeralGarbageCollectorConcurrentScheduleAndClose(t *testing.T) {
 					time.Sleep(time.Duration(rand.Intn(5)) * time.Millisecond)
 				}
 			}
-		}(schedulerIndex)
+		}(i)
 	}
 
 	// After a short delay, close the garbage collector while schedulers are still running
@@ -379,7 +377,7 @@ func TestEphemeralGarbageCollectorConcurrentScheduleAndClose(t *testing.T) {
 	wg.Wait()
 
 	// Wait a bit longer to allow any leaked goroutines to do their work
-	time.Sleep(oneHundred)
+	time.Sleep(oneHundredMillis)
 
 	// Check for leaks
 	finalGoroutines := runtime.NumGoroutine()

hscontrol/db/ip.go

@@ -17,8 +17,6 @@ import (
 	"tailscale.com/net/tsaddr"
 )
 
-var errGeneratedIPBytesInvalid = errors.New("generated ip bytes are invalid ip")
-
 // IPAllocator is a singleton responsible for allocating
 // IP addresses for nodes and making sure the same
 // address is not handed out twice. There can only be one
@@ -238,7 +236,7 @@ func randomNext(pfx netip.Prefix) (netip.Addr, error) {
 
 	ip, ok := netip.AddrFromSlice(valInRange.Bytes())
 	if !ok {
-		return netip.Addr{}, errGeneratedIPBytesInvalid
+		return netip.Addr{}, fmt.Errorf("generated ip bytes are invalid ip")
 	}
 
 	if !pfx.Contains(ip) {

hscontrol/db/node.go

@@ -64,7 +64,7 @@ func ListPeers(tx *gorm.DB, nodeID types.NodeID, peerIDs ...types.NodeID) (types
 }
 
 // ListNodes queries the database for either all nodes if no parameters are given
-// or for the given nodes if at least one node ID is given as parameter.
+// or for the given nodes if at least one node ID is given as parameter
 func (hsdb *HSDatabase) ListNodes(nodeIDs ...types.NodeID) (types.Nodes, error) {
 	return Read(hsdb.DB, func(rx *gorm.DB) (types.Nodes, error) {
 		return ListNodes(rx, nodeIDs...)
@@ -72,7 +72,7 @@ func (hsdb *HSDatabase) ListNodes(nodeIDs ...types.NodeID) (types.Nodes, error)
 }
 
 // ListNodes queries the database for either all nodes if no parameters are given
-// or for the given nodes if at least one node ID is given as parameter.
+// or for the given nodes if at least one node ID is given as parameter
 func ListNodes(tx *gorm.DB, nodeIDs ...types.NodeID) (types.Nodes, error) {
 	nodes := types.Nodes{}
 	if err := tx.
@@ -406,7 +406,6 @@ func (hsdb *HSDatabase) HandleNodeFromAuthPath(
 				close(reg.Registered)
 
 				newNode = true
-
 				return node, err
 			} else {
 				// If the node is already registered, this is a refresh.
@@ -414,7 +413,6 @@ func (hsdb *HSDatabase) HandleNodeFromAuthPath(
 				if err != nil {
 					return nil, err
 				}
-
 				return node, nil
 			}
 		}
@@ -589,9 +587,6 @@ func ensureUniqueGivenName(
 	return givenName, nil
 }
 
-// ExpireExpiredNodes checks for nodes that have expired since the last check
-// and returns a time to be used for the next check, a StateUpdate
-// containing the expired nodes, and a boolean indicating if any nodes were found.
 func ExpireExpiredNodes(tx *gorm.DB,
 	lastCheck time.Time,
 ) (time.Time, types.StateUpdate, bool) {

hscontrol/db/node_test.go

@@ -118,7 +118,7 @@ func (s *Suite) TestListPeers(c *check.C) {
 	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
-	for index := range 11 {
+	for index := 0; index <= 10; index++ {
 		nodeKey := key.NewNode()
 		machineKey := key.NewMachine()
 
@@ -435,7 +435,8 @@ func TestAutoApproveRoutes(t *testing.T) {
 	for _, tt := range tests {
 		pmfs := policy.PolicyManagerFuncsForTest([]byte(tt.acl))
 		for i, pmf := range pmfs {
-			t.Run(fmt.Sprintf("%s-policy-index%d", tt.name, i), func(t *testing.T) {
+			version := i + 1
+			t.Run(fmt.Sprintf("%s-policyv%d", tt.name, version), func(t *testing.T) {
 				adb, err := newSQLiteTestDB()
 				require.NoError(t, err)
 
@@ -485,7 +486,7 @@ func TestAutoApproveRoutes(t *testing.T) {
 				nodes, err := adb.ListNodes()
 				assert.NoError(t, err)
 
-				pm, err := pmf(users, nodes.ViewSlice())
+				pm, err := pmf(users, nodes)
 				require.NoError(t, err)
 				require.NotNil(t, pm)
 
@@ -589,7 +590,6 @@ func generateRandomNumber(t *testing.T, max int64) int64 {
 	if err != nil {
 		t.Fatalf("getting random number: %s", err)
 	}
-
 	return n.Int64() + 1
 }
 
@@ -693,7 +693,6 @@ func TestRenameNode(t *testing.T) {
 			return err
 		}
 		_, err = RegisterNode(tx, node2, nil, nil)
-
 		return err
 	})
 	require.NoError(t, err)
@@ -794,7 +793,6 @@ func TestListPeers(t *testing.T) {
 			return err
 		}
 		_, err = RegisterNode(tx, node2, nil, nil)
-
 		return err
 	})
 	require.NoError(t, err)
@@ -807,30 +805,30 @@ func TestListPeers(t *testing.T) {
 	// No parameter means no filter, should return all peers
 	nodes, err = db.ListPeers(1)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 1)
+	assert.Equal(t, len(nodes), 1)
 	assert.Equal(t, "test2", nodes[0].Hostname)
 
 	// Empty node list should return all peers
 	nodes, err = db.ListPeers(1, types.NodeIDs{}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 1)
+	assert.Equal(t, len(nodes), 1)
 	assert.Equal(t, "test2", nodes[0].Hostname)
 
 	// No match in IDs should return empty list and no error
 	nodes, err = db.ListPeers(1, types.NodeIDs{3, 4, 5}...)
 	require.NoError(t, err)
-	assert.Empty(t, nodes)
+	assert.Equal(t, len(nodes), 0)
 
 	// Partial match in IDs
 	nodes, err = db.ListPeers(1, types.NodeIDs{2, 3}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 1)
+	assert.Equal(t, len(nodes), 1)
 	assert.Equal(t, "test2", nodes[0].Hostname)
 
 	// Several matched IDs, but node ID is still filtered out
 	nodes, err = db.ListPeers(1, types.NodeIDs{1, 2, 3}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 1)
+	assert.Equal(t, len(nodes), 1)
 	assert.Equal(t, "test2", nodes[0].Hostname)
 }
 
@@ -879,7 +877,6 @@ func TestListNodes(t *testing.T) {
 			return err
 		}
 		_, err = RegisterNode(tx, node2, nil, nil)
-
 		return err
 	})
 	require.NoError(t, err)
@@ -892,32 +889,32 @@ func TestListNodes(t *testing.T) {
 	// No parameter means no filter, should return all nodes
 	nodes, err = db.ListNodes()
 	require.NoError(t, err)
-	assert.Len(t, nodes, 2)
+	assert.Equal(t, len(nodes), 2)
 	assert.Equal(t, "test1", nodes[0].Hostname)
 	assert.Equal(t, "test2", nodes[1].Hostname)
 
 	// Empty node list should return all nodes
 	nodes, err = db.ListNodes(types.NodeIDs{}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 2)
+	assert.Equal(t, len(nodes), 2)
 	assert.Equal(t, "test1", nodes[0].Hostname)
 	assert.Equal(t, "test2", nodes[1].Hostname)
 
 	// No match in IDs should return empty list and no error
 	nodes, err = db.ListNodes(types.NodeIDs{3, 4, 5}...)
 	require.NoError(t, err)
-	assert.Empty(t, nodes)
+	assert.Equal(t, len(nodes), 0)
 
 	// Partial match in IDs
 	nodes, err = db.ListNodes(types.NodeIDs{2, 3}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 1)
+	assert.Equal(t, len(nodes), 1)
 	assert.Equal(t, "test2", nodes[0].Hostname)
 
 	// Several matched IDs
 	nodes, err = db.ListNodes(types.NodeIDs{1, 2, 3}...)
 	require.NoError(t, err)
-	assert.Len(t, nodes, 2)
+	assert.Equal(t, len(nodes), 2)
 	assert.Equal(t, "test1", nodes[0].Hostname)
 	assert.Equal(t, "test2", nodes[1].Hostname)
 }

hscontrol/db/preauth_keys_test.go

@@ -8,8 +8,9 @@ import (
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gopkg.in/check.v1"
 	"tailscale.com/types/ptr"
+
+	"gopkg.in/check.v1"
 )
 
 func (*Suite) TestCreatePreAuthKey(c *check.C) {

hscontrol/db/schema.sql

@@ -1,110 +0,0 @@
--- This file is the representation of the SQLite schema of Headscale.
--- It is the "source of truth" and is used to validate any migrations
--- that are run against the database to ensure it ends in the expected state.
-
-CREATE TABLE migrations(id text,PRIMARY KEY(id));
-
-CREATE TABLE users(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  name text,
-  display_name text,
-  email text,
-  provider_identifier text,
-  provider text,
-  profile_pic_url text,
-
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime
-);
-CREATE INDEX idx_users_deleted_at ON users(deleted_at);
-
-
--- The following three UNIQUE indexes work together to enforce the user identity model:
---
--- 1. Users can be either local (provider_identifier is NULL) or from external providers (provider_identifier set)
--- 2. Each external provider identifier must be unique across the system
--- 3. Local usernames must be unique among local users
--- 4. The same username can exist across different providers with different identifiers
---
--- Examples:
--- - Can create local user "alice" (provider_identifier=NULL)
--- - Can create external user "alice" with GitHub (name="alice", provider_identifier="alice_github")
--- - Can create external user "alice" with Google (name="alice", provider_identifier="alice_google")
--- - Cannot create another local user "alice" (blocked by idx_name_no_provider_identifier)
--- - Cannot create another user with provider_identifier="alice_github" (blocked by idx_provider_identifier)
--- - Cannot create user "bob" with provider_identifier="alice_github" (blocked by idx_name_provider_identifier)
-CREATE UNIQUE INDEX idx_provider_identifier ON users(
-  provider_identifier
-) WHERE provider_identifier IS NOT NULL;
-CREATE UNIQUE INDEX idx_name_provider_identifier ON users(
-  name,
-  provider_identifier
-);
-CREATE UNIQUE INDEX idx_name_no_provider_identifier ON users(
-  name
-) WHERE provider_identifier IS NULL;
-
-CREATE TABLE pre_auth_keys(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  key text,
-  user_id integer,
-  reusable numeric,
-  ephemeral numeric DEFAULT false,
-  used numeric DEFAULT false,
-  tags text,
-  expiration datetime,
-
-  created_at datetime,
-
-  CONSTRAINT fk_pre_auth_keys_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE SET NULL
-);
-
-CREATE TABLE api_keys(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  prefix text,
-  hash blob,
-  expiration datetime,
-  last_seen datetime,
-
-  created_at datetime
-);
-CREATE UNIQUE INDEX idx_api_keys_prefix ON api_keys(prefix);
-
-CREATE TABLE nodes(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  machine_key text,
-  node_key text,
-  disco_key text,
-
-  endpoints text,
-  host_info text,
-  ipv4 text,
-  ipv6 text,
-  hostname text,
-  given_name varchar(63),
-  user_id integer,
-  register_method text,
-  forced_tags text,
-  auth_key_id integer,
-  last_seen datetime,
-  expiry datetime,
-  approved_routes text,
-
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime,
-
-  CONSTRAINT fk_nodes_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
-  CONSTRAINT fk_nodes_auth_key FOREIGN KEY(auth_key_id) REFERENCES pre_auth_keys(id)
-);
-
-CREATE TABLE policies(
-  id integer PRIMARY KEY AUTOINCREMENT,
-  data text,
-
-  created_at datetime,
-  updated_at datetime,
-  deleted_at datetime
-);
-CREATE INDEX idx_policies_deleted_at ON policies(deleted_at);

hscontrol/db/sqliteconfig/config.go

@@ -1,345 +0,0 @@
-// Package sqliteconfig provides type-safe configuration for SQLite databases
-// with proper enum validation and URL generation for modernc.org/sqlite driver.
-package sqliteconfig
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-)
-
-// Errors returned by config validation.
-var (
-	ErrPathEmpty           = errors.New("path cannot be empty")
-	ErrBusyTimeoutNegative = errors.New("busy_timeout must be >= 0")
-	ErrInvalidJournalMode  = errors.New("invalid journal_mode")
-	ErrInvalidAutoVacuum   = errors.New("invalid auto_vacuum")
-	ErrWALAutocheckpoint   = errors.New("wal_autocheckpoint must be >= -1")
-	ErrInvalidSynchronous  = errors.New("invalid synchronous")
-)
-
-const (
-	// DefaultBusyTimeout is the default busy timeout in milliseconds.
-	DefaultBusyTimeout = 10000
-)
-
-// JournalMode represents SQLite journal_mode pragma values.
-// Journal modes control how SQLite handles write transactions and crash recovery.
-//
-// Performance vs Durability Tradeoffs:
-//
-// WAL (Write-Ahead Logging) - Recommended for production:
-//   - Best performance for concurrent reads/writes
-//   - Readers don't block writers, writers don't block readers
-//   - Excellent crash recovery with minimal data loss risk
-//   - Uses additional .wal and .shm files
-//   - Default choice for Headscale production deployments
-//
-// DELETE - Traditional rollback journal:
-//   - Good performance for single-threaded access
-//   - Readers block writers and vice versa
-//   - Reliable crash recovery but with exclusive locking
-//   - Creates temporary journal files during transactions
-//   - Suitable for low-concurrency scenarios
-//
-// TRUNCATE - Similar to DELETE but faster cleanup:
-//   - Slightly better performance than DELETE
-//   - Same concurrency limitations as DELETE
-//   - Faster transaction commit by truncating instead of deleting journal
-//
-// PERSIST - Journal file remains between transactions:
-//   - Avoids file creation/deletion overhead
-//   - Same concurrency limitations as DELETE
-//   - Good for frequent small transactions
-//
-// MEMORY - Journal kept in memory:
-//   - Fastest performance but NO crash recovery
-//   - Data loss risk on power failure or crash
-//   - Only suitable for temporary or non-critical data
-//
-// OFF - No journaling:
-//   - Maximum performance but NO transaction safety
-//   - High risk of database corruption on crash
-//   - Should only be used for read-only or disposable databases
-type JournalMode string
-
-const (
-	// JournalModeWAL enables Write-Ahead Logging (RECOMMENDED for production).
-	// Best concurrent performance + crash recovery. Uses additional .wal/.shm files.
-	JournalModeWAL JournalMode = "WAL"
-
-	// JournalModeDelete uses traditional rollback journaling.
-	// Good single-threaded performance, readers block writers. Creates temp journal files.
-	JournalModeDelete JournalMode = "DELETE"
-
-	// JournalModeTruncate is like DELETE but with faster cleanup.
-	// Slightly better performance than DELETE, same safety with exclusive locking.
-	JournalModeTruncate JournalMode = "TRUNCATE"
-
-	// JournalModePersist keeps journal file between transactions.
-	// Good for frequent transactions, avoids file creation/deletion overhead.
-	JournalModePersist JournalMode = "PERSIST"
-
-	// JournalModeMemory keeps journal in memory (DANGEROUS).
-	// Fastest performance but NO crash recovery - data loss on power failure.
-	JournalModeMemory JournalMode = "MEMORY"
-
-	// JournalModeOff disables journaling entirely (EXTREMELY DANGEROUS).
-	// Maximum performance but high corruption risk. Only for disposable databases.
-	JournalModeOff JournalMode = "OFF"
-)
-
-// IsValid returns true if the JournalMode is valid.
-func (j JournalMode) IsValid() bool {
-	switch j {
-	case JournalModeWAL, JournalModeDelete, JournalModeTruncate,
-		JournalModePersist, JournalModeMemory, JournalModeOff:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns the string representation.
-func (j JournalMode) String() string {
-	return string(j)
-}
-
-// AutoVacuum represents SQLite auto_vacuum pragma values.
-// Auto-vacuum controls how SQLite reclaims space from deleted data.
-//
-// Performance vs Storage Tradeoffs:
-//
-// INCREMENTAL - Recommended for production:
-//   - Reclaims space gradually during normal operations
-//   - Minimal performance impact on writes
-//   - Database size shrinks automatically over time
-//   - Can manually trigger with PRAGMA incremental_vacuum
-//   - Good balance of space efficiency and performance
-//
-// FULL - Automatic space reclamation:
-//   - Immediately reclaims space on every DELETE/DROP
-//   - Higher write overhead due to page reorganization
-//   - Keeps database file size minimal
-//   - Can cause significant slowdowns on large deletions
-//   - Best for applications with frequent deletes and limited storage
-//
-// NONE - No automatic space reclamation:
-//   - Fastest write performance (no vacuum overhead)
-//   - Database file only grows, never shrinks
-//   - Deleted space is reused but file size remains large
-//   - Requires manual VACUUM to reclaim space
-//   - Best for write-heavy workloads where storage isn't constrained
-type AutoVacuum string
-
-const (
-	// AutoVacuumNone disables automatic space reclamation.
-	// Fastest writes, file only grows. Requires manual VACUUM to reclaim space.
-	AutoVacuumNone AutoVacuum = "NONE"
-
-	// AutoVacuumFull immediately reclaims space on every DELETE/DROP.
-	// Minimal file size but slower writes. Can impact performance on large deletions.
-	AutoVacuumFull AutoVacuum = "FULL"
-
-	// AutoVacuumIncremental reclaims space gradually (RECOMMENDED for production).
-	// Good balance: minimal write impact, automatic space management over time.
-	AutoVacuumIncremental AutoVacuum = "INCREMENTAL"
-)
-
-// IsValid returns true if the AutoVacuum is valid.
-func (a AutoVacuum) IsValid() bool {
-	switch a {
-	case AutoVacuumNone, AutoVacuumFull, AutoVacuumIncremental:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns the string representation.
-func (a AutoVacuum) String() string {
-	return string(a)
-}
-
-// Synchronous represents SQLite synchronous pragma values.
-// Synchronous mode controls how aggressively SQLite flushes data to disk.
-//
-// Performance vs Durability Tradeoffs:
-//
-// NORMAL - Recommended for production:
-//   - Good balance of performance and safety
-//   - Syncs at critical moments (transaction commits in WAL mode)
-//   - Very low risk of corruption, minimal performance impact
-//   - Safe with WAL mode even with power loss
-//   - Default choice for most production applications
-//
-// FULL - Maximum durability:
-//   - Syncs to disk after every write operation
-//   - Highest data safety, virtually no corruption risk
-//   - Significant performance penalty (up to 50% slower)
-//   - Recommended for critical data where corruption is unacceptable
-//
-// EXTRA - Paranoid mode:
-//   - Even more aggressive syncing than FULL
-//   - Maximum possible data safety
-//   - Severe performance impact
-//   - Only for extremely critical scenarios
-//
-// OFF - Maximum performance, minimum safety:
-//   - No syncing, relies on OS to flush data
-//   - Fastest possible performance
-//   - High risk of corruption on power failure or crash
-//   - Only suitable for non-critical or easily recreatable data
-type Synchronous string
-
-const (
-	// SynchronousOff disables syncing (DANGEROUS).
-	// Fastest performance but high corruption risk on power failure. Avoid in production.
-	SynchronousOff Synchronous = "OFF"
-
-	// SynchronousNormal provides balanced performance and safety (RECOMMENDED).
-	// Good performance with low corruption risk. Safe with WAL mode on power loss.
-	SynchronousNormal Synchronous = "NORMAL"
-
-	// SynchronousFull provides maximum durability with performance cost.
-	// Syncs after every write. Up to 50% slower but virtually no corruption risk.
-	SynchronousFull Synchronous = "FULL"
-
-	// SynchronousExtra provides paranoid-level data safety (EXTREME).
-	// Maximum safety with severe performance impact. Rarely needed in practice.
-	SynchronousExtra Synchronous = "EXTRA"
-)
-
-// IsValid returns true if the Synchronous is valid.
-func (s Synchronous) IsValid() bool {
-	switch s {
-	case SynchronousOff, SynchronousNormal, SynchronousFull, SynchronousExtra:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns the string representation.
-func (s Synchronous) String() string {
-	return string(s)
-}
-
-// Config holds SQLite database configuration with type-safe enums.
-// This configuration balances performance, durability, and operational requirements
-// for Headscale's SQLite database usage patterns.
-type Config struct {
-	Path              string      // file path or ":memory:"
-	BusyTimeout       int         // milliseconds (0 = default/disabled)
-	JournalMode       JournalMode // journal mode (affects concurrency and crash recovery)
-	AutoVacuum        AutoVacuum  // auto vacuum mode (affects storage efficiency)
-	WALAutocheckpoint int         // pages (-1 = default/not set, 0 = disabled, >0 = enabled)
-	Synchronous       Synchronous // synchronous mode (affects durability vs performance)
-	ForeignKeys       bool        // enable foreign key constraints (data integrity)
-}
-
-// Default returns the production configuration optimized for Headscale's usage patterns.
-// This configuration prioritizes:
-//   - Concurrent access (WAL mode for multiple readers/writers)
-//   - Data durability with good performance (NORMAL synchronous)
-//   - Automatic space management (INCREMENTAL auto-vacuum)
-//   - Data integrity (foreign key constraints enabled)
-//   - Reasonable timeout for busy database scenarios (10s)
-func Default(path string) *Config {
-	return &Config{
-		Path:              path,
-		BusyTimeout:       DefaultBusyTimeout,
-		JournalMode:       JournalModeWAL,
-		AutoVacuum:        AutoVacuumIncremental,
-		WALAutocheckpoint: 1000,
-		Synchronous:       SynchronousNormal,
-		ForeignKeys:       true,
-	}
-}
-
-// Memory returns a configuration for in-memory databases.
-func Memory() *Config {
-	return &Config{
-		Path:              ":memory:",
-		WALAutocheckpoint: -1, // not set, use driver default
-		ForeignKeys:       true,
-	}
-}
-
-// Validate checks if all configuration values are valid.
-func (c *Config) Validate() error {
-	if c.Path == "" {
-		return ErrPathEmpty
-	}
-
-	if c.BusyTimeout < 0 {
-		return fmt.Errorf("%w, got %d", ErrBusyTimeoutNegative, c.BusyTimeout)
-	}
-
-	if c.JournalMode != "" && !c.JournalMode.IsValid() {
-		return fmt.Errorf("%w: %s", ErrInvalidJournalMode, c.JournalMode)
-	}
-
-	if c.AutoVacuum != "" && !c.AutoVacuum.IsValid() {
-		return fmt.Errorf("%w: %s", ErrInvalidAutoVacuum, c.AutoVacuum)
-	}
-
-	if c.WALAutocheckpoint < -1 {
-		return fmt.Errorf("%w, got %d", ErrWALAutocheckpoint, c.WALAutocheckpoint)
-	}
-
-	if c.Synchronous != "" && !c.Synchronous.IsValid() {
-		return fmt.Errorf("%w: %s", ErrInvalidSynchronous, c.Synchronous)
-	}
-
-	return nil
-}
-
-// ToURL builds a properly encoded SQLite connection string using _pragma parameters
-// compatible with modernc.org/sqlite driver.
-func (c *Config) ToURL() (string, error) {
-	if err := c.Validate(); err != nil {
-		return "", fmt.Errorf("invalid config: %w", err)
-	}
-
-	var pragmas []string
-
-	// Add pragma parameters only if they're set (non-zero/non-empty)
-	if c.BusyTimeout > 0 {
-		pragmas = append(pragmas, fmt.Sprintf("busy_timeout=%d", c.BusyTimeout))
-	}
-	if c.JournalMode != "" {
-		pragmas = append(pragmas, fmt.Sprintf("journal_mode=%s", c.JournalMode))
-	}
-	if c.AutoVacuum != "" {
-		pragmas = append(pragmas, fmt.Sprintf("auto_vacuum=%s", c.AutoVacuum))
-	}
-	if c.WALAutocheckpoint >= 0 {
-		pragmas = append(pragmas, fmt.Sprintf("wal_autocheckpoint=%d", c.WALAutocheckpoint))
-	}
-	if c.Synchronous != "" {
-		pragmas = append(pragmas, fmt.Sprintf("synchronous=%s", c.Synchronous))
-	}
-	if c.ForeignKeys {
-		pragmas = append(pragmas, "foreign_keys=ON")
-	}
-
-	// Handle different database types
-	var baseURL string
-	if c.Path == ":memory:" {
-		baseURL = ":memory:"
-	} else {
-		baseURL = "file:" + c.Path
-	}
-
-	// Add parameters without encoding = signs
-	if len(pragmas) > 0 {
-		var queryParts []string
-		for _, pragma := range pragmas {
-			queryParts = append(queryParts, "_pragma="+pragma)
-		}
-		baseURL += "?" + strings.Join(queryParts, "&")
-	}
-
-	return baseURL, nil
-}

hscontrol/db/sqliteconfig/config_test.go

@@ -1,211 +0,0 @@
-package sqliteconfig
-
-import (
-	"testing"
-)
-
-func TestJournalMode(t *testing.T) {
-	tests := []struct {
-		mode  JournalMode
-		valid bool
-	}{
-		{JournalModeWAL, true},
-		{JournalModeDelete, true},
-		{JournalModeTruncate, true},
-		{JournalModePersist, true},
-		{JournalModeMemory, true},
-		{JournalModeOff, true},
-		{JournalMode("INVALID"), false},
-		{JournalMode(""), false},
-	}
-
-	for _, tt := range tests {
-		t.Run(string(tt.mode), func(t *testing.T) {
-			if got := tt.mode.IsValid(); got != tt.valid {
-				t.Errorf("JournalMode(%q).IsValid() = %v, want %v", tt.mode, got, tt.valid)
-			}
-		})
-	}
-}
-
-func TestAutoVacuum(t *testing.T) {
-	tests := []struct {
-		mode  AutoVacuum
-		valid bool
-	}{
-		{AutoVacuumNone, true},
-		{AutoVacuumFull, true},
-		{AutoVacuumIncremental, true},
-		{AutoVacuum("INVALID"), false},
-		{AutoVacuum(""), false},
-	}
-
-	for _, tt := range tests {
-		t.Run(string(tt.mode), func(t *testing.T) {
-			if got := tt.mode.IsValid(); got != tt.valid {
-				t.Errorf("AutoVacuum(%q).IsValid() = %v, want %v", tt.mode, got, tt.valid)
-			}
-		})
-	}
-}
-
-func TestSynchronous(t *testing.T) {
-	tests := []struct {
-		mode  Synchronous
-		valid bool
-	}{
-		{SynchronousOff, true},
-		{SynchronousNormal, true},
-		{SynchronousFull, true},
-		{SynchronousExtra, true},
-		{Synchronous("INVALID"), false},
-		{Synchronous(""), false},
-	}
-
-	for _, tt := range tests {
-		t.Run(string(tt.mode), func(t *testing.T) {
-			if got := tt.mode.IsValid(); got != tt.valid {
-				t.Errorf("Synchronous(%q).IsValid() = %v, want %v", tt.mode, got, tt.valid)
-			}
-		})
-	}
-}
-
-func TestConfigValidate(t *testing.T) {
-	tests := []struct {
-		name    string
-		config  *Config
-		wantErr bool
-	}{
-		{
-			name:   "valid default config",
-			config: Default("/path/to/db.sqlite"),
-		},
-		{
-			name: "empty path",
-			config: &Config{
-				Path: "",
-			},
-			wantErr: true,
-		},
-		{
-			name: "negative busy timeout",
-			config: &Config{
-				Path:        "/path/to/db.sqlite",
-				BusyTimeout: -1,
-			},
-			wantErr: true,
-		},
-		{
-			name: "invalid journal mode",
-			config: &Config{
-				Path:        "/path/to/db.sqlite",
-				JournalMode: JournalMode("INVALID"),
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := tt.config.Validate()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Config.Validate() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestConfigToURL(t *testing.T) {
-	tests := []struct {
-		name   string
-		config *Config
-		want   string
-	}{
-		{
-			name:   "default config",
-			config: Default("/path/to/db.sqlite"),
-			want:   "file:/path/to/db.sqlite?_pragma=busy_timeout=10000&_pragma=journal_mode=WAL&_pragma=auto_vacuum=INCREMENTAL&_pragma=wal_autocheckpoint=1000&_pragma=synchronous=NORMAL&_pragma=foreign_keys=ON",
-		},
-		{
-			name:   "memory config",
-			config: Memory(),
-			want:   ":memory:?_pragma=foreign_keys=ON",
-		},
-		{
-			name: "minimal config",
-			config: &Config{
-				Path:              "/simple/db.sqlite",
-				WALAutocheckpoint: -1, // not set
-			},
-			want: "file:/simple/db.sqlite",
-		},
-		{
-			name: "custom config",
-			config: &Config{
-				Path:              "/custom/db.sqlite",
-				BusyTimeout:       5000,
-				JournalMode:       JournalModeDelete,
-				WALAutocheckpoint: -1, // not set
-				Synchronous:       SynchronousFull,
-				ForeignKeys:       true,
-			},
-			want: "file:/custom/db.sqlite?_pragma=busy_timeout=5000&_pragma=journal_mode=DELETE&_pragma=synchronous=FULL&_pragma=foreign_keys=ON",
-		},
-		{
-			name: "memory with custom timeout",
-			config: &Config{
-				Path:              ":memory:",
-				BusyTimeout:       2000,
-				WALAutocheckpoint: -1, // not set
-				ForeignKeys:       true,
-			},
-			want: ":memory:?_pragma=busy_timeout=2000&_pragma=foreign_keys=ON",
-		},
-		{
-			name: "wal autocheckpoint zero",
-			config: &Config{
-				Path:              "/test.db",
-				WALAutocheckpoint: 0,
-			},
-			want: "file:/test.db?_pragma=wal_autocheckpoint=0",
-		},
-		{
-			name: "all options",
-			config: &Config{
-				Path:              "/full.db",
-				BusyTimeout:       15000,
-				JournalMode:       JournalModeWAL,
-				AutoVacuum:        AutoVacuumFull,
-				WALAutocheckpoint: 1000,
-				Synchronous:       SynchronousExtra,
-				ForeignKeys:       true,
-			},
-			want: "file:/full.db?_pragma=busy_timeout=15000&_pragma=journal_mode=WAL&_pragma=auto_vacuum=FULL&_pragma=wal_autocheckpoint=1000&_pragma=synchronous=EXTRA&_pragma=foreign_keys=ON",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.config.ToURL()
-			if err != nil {
-				t.Errorf("Config.ToURL() error = %v", err)
-				return
-			}
-			if got != tt.want {
-				t.Errorf("Config.ToURL() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestConfigToURLInvalid(t *testing.T) {
-	config := &Config{
-		Path:        "",
-		BusyTimeout: -1,
-	}
-	_, err := config.ToURL()
-	if err == nil {
-		t.Error("Config.ToURL() with invalid config should return error")
-	}
-}

hscontrol/db/sqliteconfig/integration_test.go

@@ -1,269 +0,0 @@
-package sqliteconfig
-
-import (
-	"database/sql"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	_ "modernc.org/sqlite"
-)
-
-const memoryDBPath = ":memory:"
-
-// TestSQLiteDriverPragmaIntegration verifies that the modernc.org/sqlite driver
-// correctly applies all pragma settings from URL parameters, ensuring they work
-// the same as the old SQL PRAGMA statements approach.
-func TestSQLiteDriverPragmaIntegration(t *testing.T) {
-	tests := []struct {
-		name     string
-		config   *Config
-		expected map[string]any
-	}{
-		{
-			name:   "default configuration",
-			config: Default("/tmp/test.db"),
-			expected: map[string]any{
-				"busy_timeout":       10000,
-				"journal_mode":       "wal",
-				"auto_vacuum":        2, // INCREMENTAL = 2
-				"wal_autocheckpoint": 1000,
-				"synchronous":        1, // NORMAL = 1
-				"foreign_keys":       1, // ON = 1
-			},
-		},
-		{
-			name:   "memory database with foreign keys",
-			config: Memory(),
-			expected: map[string]any{
-				"foreign_keys": 1, // ON = 1
-			},
-		},
-		{
-			name: "custom configuration",
-			config: &Config{
-				Path:              "/tmp/custom.db",
-				BusyTimeout:       5000,
-				JournalMode:       JournalModeDelete,
-				AutoVacuum:        AutoVacuumFull,
-				WALAutocheckpoint: 1000,
-				Synchronous:       SynchronousFull,
-				ForeignKeys:       true,
-			},
-			expected: map[string]any{
-				"busy_timeout":       5000,
-				"journal_mode":       "delete",
-				"auto_vacuum":        1, // FULL = 1
-				"wal_autocheckpoint": 1000,
-				"synchronous":        2, // FULL = 2
-				"foreign_keys":       1, // ON = 1
-			},
-		},
-		{
-			name: "foreign keys disabled",
-			config: &Config{
-				Path:        "/tmp/no_fk.db",
-				ForeignKeys: false,
-			},
-			expected: map[string]any{
-				// foreign_keys should not be set (defaults to 0/OFF)
-				"foreign_keys": 0,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create temporary database file if not memory
-			if tt.config.Path == memoryDBPath {
-				// For memory databases, no changes needed
-			} else {
-				tempDir := t.TempDir()
-				dbPath := filepath.Join(tempDir, "test.db")
-				// Update config with actual temp path
-				configCopy := *tt.config
-				configCopy.Path = dbPath
-				tt.config = &configCopy
-			}
-
-			// Generate URL and open database
-			url, err := tt.config.ToURL()
-			if err != nil {
-				t.Fatalf("Failed to generate URL: %v", err)
-			}
-
-			t.Logf("Opening database with URL: %s", url)
-
-			db, err := sql.Open("sqlite", url)
-			if err != nil {
-				t.Fatalf("Failed to open database: %v", err)
-			}
-			defer db.Close()
-
-			// Test connection
-			if err := db.Ping(); err != nil {
-				t.Fatalf("Failed to ping database: %v", err)
-			}
-
-			// Verify each expected pragma setting
-			for pragma, expectedValue := range tt.expected {
-				t.Run("pragma_"+pragma, func(t *testing.T) {
-					var actualValue any
-					query := "PRAGMA " + pragma
-					err := db.QueryRow(query).Scan(&actualValue)
-					if err != nil {
-						t.Fatalf("Failed to query %s: %v", query, err)
-					}
-
-					t.Logf("%s: expected=%v, actual=%v", pragma, expectedValue, actualValue)
-
-					// Handle type conversion for comparison
-					switch expected := expectedValue.(type) {
-					case int:
-						if actual, ok := actualValue.(int64); ok {
-							if int64(expected) != actual {
-								t.Errorf("%s: expected %d, got %d", pragma, expected, actual)
-							}
-						} else {
-							t.Errorf("%s: expected int %d, got %T %v", pragma, expected, actualValue, actualValue)
-						}
-					case string:
-						if actual, ok := actualValue.(string); ok {
-							if expected != actual {
-								t.Errorf("%s: expected %q, got %q", pragma, expected, actual)
-							}
-						} else {
-							t.Errorf("%s: expected string %q, got %T %v", pragma, expected, actualValue, actualValue)
-						}
-					default:
-						t.Errorf("Unsupported expected type for %s: %T", pragma, expectedValue)
-					}
-				})
-			}
-		})
-	}
-}
-
-// TestForeignKeyConstraintEnforcement verifies that foreign key constraints
-// are actually enforced when enabled via URL parameters.
-func TestForeignKeyConstraintEnforcement(t *testing.T) {
-	tempDir := t.TempDir()
-
-	dbPath := filepath.Join(tempDir, "fk_test.db")
-	config := Default(dbPath)
-
-	url, err := config.ToURL()
-	if err != nil {
-		t.Fatalf("Failed to generate URL: %v", err)
-	}
-
-	db, err := sql.Open("sqlite", url)
-	if err != nil {
-		t.Fatalf("Failed to open database: %v", err)
-	}
-	defer db.Close()
-
-	// Create test tables with foreign key relationship
-	schema := `
-		CREATE TABLE parent (
-			id INTEGER PRIMARY KEY,
-			name TEXT NOT NULL
-		);
-
-		CREATE TABLE child (
-			id INTEGER PRIMARY KEY,
-			parent_id INTEGER NOT NULL,
-			name TEXT NOT NULL,
-			FOREIGN KEY (parent_id) REFERENCES parent(id)
-		);
-	`
-
-	if _, err := db.Exec(schema); err != nil {
-		t.Fatalf("Failed to create schema: %v", err)
-	}
-
-	// Insert parent record
-	if _, err := db.Exec("INSERT INTO parent (id, name) VALUES (1, 'Parent 1')"); err != nil {
-		t.Fatalf("Failed to insert parent: %v", err)
-	}
-
-	// Test 1: Valid foreign key should work
-	_, err = db.Exec("INSERT INTO child (id, parent_id, name) VALUES (1, 1, 'Child 1')")
-	if err != nil {
-		t.Fatalf("Valid foreign key insert failed: %v", err)
-	}
-
-	// Test 2: Invalid foreign key should fail
-	_, err = db.Exec("INSERT INTO child (id, parent_id, name) VALUES (2, 999, 'Child 2')")
-	if err == nil {
-		t.Error("Expected foreign key constraint violation, but insert succeeded")
-	} else if !contains(err.Error(), "FOREIGN KEY constraint failed") {
-		t.Errorf("Expected foreign key constraint error, got: %v", err)
-	} else {
-		t.Logf("✓ Foreign key constraint correctly enforced: %v", err)
-	}
-
-	// Test 3: Deleting referenced parent should fail
-	_, err = db.Exec("DELETE FROM parent WHERE id = 1")
-	if err == nil {
-		t.Error("Expected foreign key constraint violation when deleting referenced parent")
-	} else if !contains(err.Error(), "FOREIGN KEY constraint failed") {
-		t.Errorf("Expected foreign key constraint error on delete, got: %v", err)
-	} else {
-		t.Logf("✓ Foreign key constraint correctly prevented parent deletion: %v", err)
-	}
-}
-
-// TestJournalModeValidation verifies that the journal_mode setting is applied correctly.
-func TestJournalModeValidation(t *testing.T) {
-	modes := []struct {
-		mode     JournalMode
-		expected string
-	}{
-		{JournalModeWAL, "wal"},
-		{JournalModeDelete, "delete"},
-		{JournalModeTruncate, "truncate"},
-		{JournalModeMemory, "memory"},
-	}
-
-	for _, tt := range modes {
-		t.Run(string(tt.mode), func(t *testing.T) {
-			tempDir := t.TempDir()
-
-			dbPath := filepath.Join(tempDir, "journal_test.db")
-			config := &Config{
-				Path:        dbPath,
-				JournalMode: tt.mode,
-				ForeignKeys: true,
-			}
-
-			url, err := config.ToURL()
-			if err != nil {
-				t.Fatalf("Failed to generate URL: %v", err)
-			}
-
-			db, err := sql.Open("sqlite", url)
-			if err != nil {
-				t.Fatalf("Failed to open database: %v", err)
-			}
-			defer db.Close()
-
-			var actualMode string
-			err = db.QueryRow("PRAGMA journal_mode").Scan(&actualMode)
-			if err != nil {
-				t.Fatalf("Failed to query journal_mode: %v", err)
-			}
-
-			if actualMode != tt.expected {
-				t.Errorf("journal_mode: expected %q, got %q", tt.expected, actualMode)
-			} else {
-				t.Logf("✓ journal_mode correctly set to: %s", actualMode)
-			}
-		})
-	}
-}
-
-// contains checks if a string contains a substring (helper function).
-func contains(str, substr string) bool {
-	return strings.Contains(str, substr)
-}

hscontrol/db/suite_test.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"log"
 	"net/url"
 	"os"
@@ -83,7 +84,7 @@ func newPostgresTestDB(t *testing.T) *HSDatabase {
 func newPostgresDBForTest(t *testing.T) *url.URL {
 	t.Helper()
 
-	ctx := t.Context()
+	ctx := context.Background()
 	srv, err := postgrestest.Start(ctx)
 	if err != nil {
 		t.Fatal(err)

hscontrol/db/testdata/sqlite/0-22-3-to-0-23-0-routes-are-dropped-2063_dump.sql

@@ -1,59 +0,0 @@
-PRAGMA foreign_keys=OFF;
-BEGIN TRANSACTION;
-CREATE TABLE IF NOT EXISTS "users" (`id` integer,`created_at` datetime,`updated_at` datetime,`deleted_at` datetime,`name` text UNIQUE,PRIMARY KEY (`id`));
-INSERT INTO users VALUES(1,'2023-01-20 15:24:32.036023546+00:00','2023-01-20 15:24:32.036023546+00:00',NULL,'test_username');
-INSERT INTO users VALUES(2,'2023-01-20 15:24:37.819763186+00:00','2023-01-20 15:24:37.819763186+00:00',NULL,'test_username2');
-INSERT INTO users VALUES(3,'2023-03-14 18:44:35.748065603+00:00','2023-03-14 18:44:35.748065603+00:00',NULL,'test_username3');
-INSERT INTO users VALUES(4,'2023-10-28 10:11:58.184072133+00:00','2023-10-28 10:11:58.184072133+00:00',NULL,'test_username4');
-CREATE TABLE `pre_auth_keys` (`id` integer,`key` text,"user_id" integer,`reusable` numeric,`ephemeral` numeric DEFAULT false,`used` numeric DEFAULT false,`created_at` datetime,`expiration` datetime,PRIMARY KEY (`id`));
-INSERT INTO pre_auth_keys VALUES(1,'abc',3,0,0,1,'2023-03-14 18:48:00.276961537+00:00','2023-03-14 19:47:00+00:00');
-INSERT INTO pre_auth_keys VALUES(2,'abc',3,0,0,1,'2023-03-19 02:03:37.127380891+00:00','2023-03-19 03:03:00+00:00');
-INSERT INTO pre_auth_keys VALUES(3,'abc',3,0,0,1,'2023-07-12 16:29:17.255869839+00:00','2023-07-12 17:29:17.253994971+00:00');
-INSERT INTO pre_auth_keys VALUES(4,'abc',4,0,0,0,'2023-10-28 10:12:25.105521216+00:00','2023-10-28 11:12:25.103560646+00:00');
-INSERT INTO pre_auth_keys VALUES(5,'abc',4,0,0,1,'2023-10-28 11:19:38.120019211+00:00','2023-10-28 12:19:38.118375437+00:00');
-INSERT INTO pre_auth_keys VALUES(6,'abc',4,0,0,1,'2023-10-28 11:47:58.0406679+00:00','2023-10-28 12:47:58.036681164+00:00');
-INSERT INTO pre_auth_keys VALUES(7,'abc',4,0,0,1,'2023-10-30 15:14:21.038723484+00:00','2023-10-30 16:14:21.03662712+00:00');
-INSERT INTO pre_auth_keys VALUES(8,'abc',4,0,0,1,'2023-10-30 16:18:12.358594006+00:00','2023-10-30 17:18:12.357173229+00:00');
-INSERT INTO pre_auth_keys VALUES(9,'abc',4,0,0,1,'2023-10-31 16:00:05.806877017+00:00','2023-10-31 17:00:05.801991493+00:00');
-INSERT INTO pre_auth_keys VALUES(10,'abc',1,0,0,1,'2023-10-31 16:17:04.813054795+00:00','2023-10-31 17:17:04.809264757+00:00');
-INSERT INTO pre_auth_keys VALUES(11,'abc',1,0,0,1,'2023-11-20 21:03:07.524801178+00:00','2023-11-20 22:03:07.521904023+00:00');
-INSERT INTO pre_auth_keys VALUES(12,'abc',1,0,0,1,'2024-01-09 16:53:26.73433598+00:00','2024-01-09 17:53:26.730815243+00:00');
-INSERT INTO pre_auth_keys VALUES(13,'abc',1,0,0,0,'2024-01-15 10:57:54.79892743+00:00','2024-01-15 11:57:54.797213855+00:00');
-INSERT INTO pre_auth_keys VALUES(14,'abc',3,0,0,1,'2024-02-09 11:11:44.760824633+00:00','2024-02-09 12:11:44.757791384+00:00');
-INSERT INTO pre_auth_keys VALUES(15,'abc',1,0,0,1,'2024-02-09 15:58:39.383257853+00:00','2024-02-09 16:58:39.381325589+00:00');
-INSERT INTO pre_auth_keys VALUES(16,'abc',3,0,0,1,'2024-02-15 14:28:52.808875211+00:00','2024-02-15 15:28:52.806886242+00:00');
-INSERT INTO pre_auth_keys VALUES(17,'abc',3,0,0,1,'2024-03-22 09:14:48.915733965+00:00','2024-03-22 10:14:48.913376104+00:00');
-CREATE TABLE `machines` (`id` integer,`machine_key` varchar(64),`node_key` text,`disco_key` text,`ip_addresses` text,`hostname` text,`given_name` varchar(63),"user_id" integer,`register_method` text,`forced_tags` text,`auth_key_id` integer,`last_seen` datetime,`last_successful_update` datetime,`expiry` datetime,`host_info` text,`endpoints` text,`created_at` datetime,`updated_at` datetime,`deleted_at` datetime,PRIMARY KEY (`id`));
-INSERT INTO machines VALUES(1,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.1','test_hostname','test_given_name',2,'cli','null',0,'2024-08-21 08:40:52.222825283+00:00','2024-08-21 08:18:52.242124403+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-01-20 15:25:20.356129891+00:00','2024-08-21 08:40:52.222881482+00:00',NULL);
-INSERT INTO machines VALUES(3,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.3','test_hostname','test_given_name',1,'cli','null',0,'2024-08-21 08:40:56.62914289+00:00','2024-08-21 08:18:46.63998217+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-01-20 15:35:03.370060441+00:00','2024-08-21 08:40:56.629253788+00:00',NULL);
-INSERT INTO machines VALUES(6,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.6','test_hostname','test_given_name',3,'authkey','[]',2,'2023-03-20 19:41:31.098518915+00:00','2023-03-20 19:40:35.242992108+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-03-19 02:04:05.008046059+00:00','2023-03-20 19:41:31.098577514+00:00',NULL);
-INSERT INTO machines VALUES(9,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.9','test_hostname','test_given_name',1,'cli','null',0,'2024-07-29 13:49:30.299050593+00:00','2024-07-29 13:48:10.308424118+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-07-27 08:56:16.70263804+00:00','2024-07-29 13:49:30.299142293+00:00',NULL);
-INSERT INTO machines VALUES(14,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.2','test_hostname','test_given_name',1,'cli','null',0,'2024-08-21 08:40:55.887260826+00:00','2024-08-21 08:18:45.907361083+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-10-10 18:41:13.821106556+00:00','2024-08-21 08:40:55.887344424+00:00',NULL);
-INSERT INTO machines VALUES(24,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.16','test_hostname','test_given_name',1,'cli','null',0,'2024-08-21 08:40:53.141335445+00:00','2024-08-21 08:18:43.153446351+00:00','0001-01-01 00:00:00+00:00','{}','[]','2023-12-05 10:35:59.888379379+00:00','2024-08-21 08:40:53.141393344+00:00',NULL);
-INSERT INTO machines VALUES(26,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.19','test_hostname','test_given_name',1,'authkey','[]',12,'2024-08-21 08:40:53.117322135+00:00','2024-08-21 08:18:43.129839273+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-01-09 16:54:15.190375117+00:00','2024-08-21 08:40:53.117392533+00:00',NULL);
-INSERT INTO machines VALUES(27,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.10','test_hostname','test_given_name',3,'authkey','[]',14,'2024-08-21 08:40:17.737469943+00:00','2024-08-21 08:18:47.747596039+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-02-09 11:12:06.970690104+00:00','2024-08-21 08:40:17.737524142+00:00',NULL);
-INSERT INTO machines VALUES(28,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.5','test_hostname','test_given_name',1,'cli','null',0,'2024-08-16 16:10:15.388306191+00:00','2024-08-16 15:42:50.445601237+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-02-09 12:05:40.426476827+00:00','2024-08-16 16:10:15.38838619+00:00',NULL);
-INSERT INTO machines VALUES(30,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.4','test_hostname','test_given_name',1,'authkey','[]',15,'2024-08-21 08:40:58.279528619+00:00','2024-08-21 08:18:48.290788011+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-02-09 15:58:53.072455801+00:00','2024-08-21 08:40:58.279725115+00:00',NULL);
-INSERT INTO machines VALUES(31,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.7','test_hostname','test_given_name',3,'authkey','[]',16,'2024-08-21 08:40:59.118548501+00:00','2024-08-21 08:18:49.131796048+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-02-15 14:29:11.751167192+00:00','2024-08-21 08:40:59.118634099+00:00',NULL);
-INSERT INTO machines VALUES(32,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.11','test_hostname','test_given_name',1,'cli','null',0,'2024-08-21 08:40:11.534414289+00:00','2024-08-21 08:18:51.548310242+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-03-05 21:21:27.482961607+00:00','2024-08-21 08:40:11.534488588+00:00',NULL);
-INSERT INTO machines VALUES(33,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.12','test_hostname','test_given_name',3,'authkey','[]',17,'2024-07-24 14:02:32.230464112+00:00','2024-07-24 13:58:06.34346502+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-03-22 09:15:06.999732064+00:00','2024-07-24 14:02:32.230542511+00:00',NULL);
-INSERT INTO machines VALUES(34,'f3c6d0e51ae64e6020827a70fb345e8ca1225acfe2e5064b6d3611ed2ffc0a7b','c2ef0d2e0ec342d836e45690c7f6e4b986553b78997e08c55fbe28238283e30f','7808fad26f34fb919895224f80e01979074d8b8af4b81d2fa465134c20795e11','100.64.0.8','test_hostname','test_given_name',1,'cli','null',0,'2024-08-20 18:55:03.645637741+00:00','2024-08-20 18:53:33.573112275+00:00','0001-01-01 00:00:00+00:00','{}','[]','2024-05-12 18:10:18.529512769+00:00','2024-08-20 18:55:03.64569204+00:00',NULL);
-CREATE TABLE `routes` (`id` integer,`created_at` datetime,`updated_at` datetime,`deleted_at` datetime,`machine_id` integer,`prefix` text,`advertised` numeric,`enabled` numeric,`is_primary` numeric,PRIMARY KEY (`id`));
-INSERT INTO routes VALUES(1,'2023-06-07 19:33:30.351228569+00:00','2024-02-09 12:12:46.846169943+00:00',NULL,1,'0.0.0.0/0',1,1,0);
-INSERT INTO routes VALUES(2,'2023-06-07 19:33:30.374825485+00:00','2024-02-09 12:12:46.85904672+00:00',NULL,1,'::/0',1,1,0);
-INSERT INTO routes VALUES(3,'2023-06-07 19:40:59.371440019+00:00','2024-02-09 12:12:50.579469958+00:00',NULL,1,'10.9.110.0/24',1,1,1);
-INSERT INTO routes VALUES(6,'2024-01-09 16:54:15.230556693+00:00','2024-01-09 16:56:18.454994668+00:00',NULL,26,'172.100.100.0/24',1,1,1);
-INSERT INTO routes VALUES(7,'2024-01-09 16:54:15.244301546+00:00','2024-01-09 16:54:15.244301546+00:00',NULL,26,'172.100.100.0/24',1,0,0);
-INSERT INTO routes VALUES(8,'2024-02-15 14:29:11.80450206+00:00','2024-02-15 14:31:33.693110756+00:00',NULL,31,'0.0.0.0/0',1,1,0);
-INSERT INTO routes VALUES(9,'2024-02-15 14:29:11.819498226+00:00','2024-02-15 14:29:11.819498226+00:00',NULL,31,'0.0.0.0/0',1,0,0);
-INSERT INTO routes VALUES(10,'2024-02-15 14:29:11.83141704+00:00','2024-02-15 14:31:33.710242987+00:00',NULL,31,'::/0',1,1,0);
-INSERT INTO routes VALUES(11,'2024-02-15 14:29:11.843494351+00:00','2024-02-15 14:29:11.843494351+00:00',NULL,31,'::/0',1,0,0);
-INSERT INTO routes VALUES(12,'2024-08-16 14:58:46.162834956+00:00','2024-08-16 14:59:46.380224608+00:00',NULL,32,'192.168.0.24/32',1,1,1);
-CREATE TABLE `kvs` (`key` text,`value` text);
-CREATE TABLE `pre_auth_key_acl_tags` (`id` integer,`pre_auth_key_id` integer,`tag` text,PRIMARY KEY (`id`));
-CREATE TABLE IF NOT EXISTS "api_keys" (`id` integer,`prefix` text UNIQUE,`hash` blob,`created_at` datetime,`expiration` datetime,`last_seen` datetime,PRIMARY KEY (`id`));
-CREATE INDEX `idx_namespaces_deleted_at` ON "users"(`deleted_at`);
-CREATE INDEX `idx_routes_deleted_at` ON `routes`(`deleted_at`);
-CREATE INDEX `idx_users_deleted_at` ON `users`(`deleted_at`);
-CREATE UNIQUE INDEX `idx_api_keys_prefix` ON `api_keys`(`prefix`);
-COMMIT;