Release 2024.8.0

2026-08-07 15:24:46 +00:00 · 2024-08-01 11:31:27 +01:00
2305 changed files with 205973 additions and 250569 deletions
@@ -1,122 +0,0 @@
-.register_inputs: &register_inputs
-  stage: release-internal
-  runOnBranches: "^master$"
-  COMPONENT: "common"
-
-.register_inputs_stable_trixie: &register_inputs_stable_trixie
-  <<: *register_inputs
-  runOnChangesTo: ['RELEASE_NOTES']
-  FLAVOR: "trixie"
-  SERIES: "stable"
-
-.register_inputs_next_trixie: &register_inputs_next_trixie
-  <<: *register_inputs
-  FLAVOR: "trixie"
-  SERIES: next
-
-################################################
-### Generate Debian Package for Internal APT ###
-################################################
-.cloudflared-apt-build: &cloudflared_apt_build
-  stage: package
-  needs:
-    - ci-image-get-image-ref
-    - linux-packaging # For consistency, we only run this job after we knew we could build the packages for external delivery
-  image: $BUILD_IMAGE
-  cache: {}
-  script:
-    - make cloudflared-deb
-  artifacts:
-    paths:
-      - cloudflared*.deb
-
-##############
-### Stable ###
-##############
-cloudflared-amd64-stable:
-  <<: *cloudflared_apt_build
-  rules:
-    - !reference [.default-rules, run-on-release]
-  variables: &amd64-stable-vars
-    GOOS: linux
-    GOARCH: amd64
-    FIPS: true
-    ORIGINAL_NAME: true
-    CGO_ENABLED: 1
-
-cloudflared-arm64-stable:
-  <<: *cloudflared_apt_build
-  rules:
-    - !reference [.default-rules, run-on-release]
-  variables: &arm64-stable-vars
-    GOOS: linux
-    GOARCH: arm64
-    FIPS: false # TUN-7595
-    ORIGINAL_NAME: true
-    CGO_ENABLED: 1
-
-# Jobs names
-.amd64-stable: &amd64-stable ["cloudflared-amd64-stable"]
-.arm64-stable: &arm64-stable ["cloudflared-arm64-stable"]
-
-############
-### Next ###
-############
-cloudflared-amd64-next:
-  <<: *cloudflared_apt_build
-  rules:
-    - !reference [.default-rules, run-on-master]
-  variables:
-    <<: *amd64-stable-vars
-    NIGHTLY: true
-
-cloudflared-arm64-next:
-  <<: *cloudflared_apt_build
-  rules:
-    - !reference [.default-rules, run-on-master]
-  variables:
-    <<: *arm64-stable-vars
-    NIGHTLY: true
-
-# Jobs names
-.amd64-next: &amd64-next ["cloudflared-amd64-next"]
-.arm64-next: &arm64-next ["cloudflared-arm64-next"]
-
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-  ##########################################
-  ### Publish Packages to Internal Repos ###
-  ##########################################
-
-  # Trixie AMD64
-  - component: $CI_SERVER_FQDN/cloudflare/ci/apt-register/register@~latest
-    inputs:
-      <<: *register_inputs_stable_trixie
-      jobPrefix: cloudflared-trixie-amd64
-      needs: *amd64-stable
-
-  # Trixie ARM64
-  - component: $CI_SERVER_FQDN/cloudflare/ci/apt-register/register@~latest
-    inputs:
-      <<: *register_inputs_stable_trixie
-      jobPrefix: cloudflared-trixie-arm64
-      needs: *arm64-stable
-
-  ##################################################
-  ### Publish Nightly Packages to Internal Repos ###
-  ##################################################
-
-  # Trixie AMD64
-  - component: $CI_SERVER_FQDN/cloudflare/ci/apt-register/register@~latest
-    inputs:
-      <<: *register_inputs_next_trixie
-      jobPrefix: cloudflared-nightly-trixie-amd64
-      needs: *amd64-next
-
-  # Trixie ARM64
-  - component: $CI_SERVER_FQDN/cloudflare/ci/apt-register/register@~latest
-    inputs:
-      <<: *register_inputs_next_trixie
-      jobPrefix: cloudflared-nightly-trixie-arm64
-      needs: *arm64-next
@@ -1,31 +0,0 @@
-# Builds a custom CI Image when necessary
-
-include:
-  #####################################################
-  ############## Build and Push CI Image ##############
-  #####################################################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/docker-image/build-push-image@~latest
-    inputs:
-      stage: pre-build
-      jobPrefix: ci-image
-      runOnChangesTo: [".ci/image/**"]
-      runOnMR: true
-      runOnBranches: '^master$'
-      commentImageRefs: false
-      runner: vm-linux-x86-4cpu-8gb
-      EXTRA_DIB_ARGS: "--manifest=.ci/image/.docker-images"
-
-  #####################################################
-  ## Resolve the image reference for downstream jobs ##
-  #####################################################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/docker-image/get-image-ref@~latest
-    inputs:
-      stage: pre-build
-      jobPrefix: ci-image
-      runOnMR: true
-      runOnBranches: '^master$'
-      IMAGE_PATH: "$REGISTRY_HOST/stash/tun/cloudflared/ci-image/master"
-      VARIABLE_NAME: BUILD_IMAGE
-      needs:
-        - job: ci-image-build-push-image
-          optional: true
@@ -1,45 +0,0 @@
-## A set of predefined rules to use on the different jobs
-.default-rules:
-  # Rules to run the job only on the master branch
-  run-on-master:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      when: on_success
-    - when: never
-  # Rules to run the job only on merge requests
-  run-on-mr:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-      when: on_success
-    - when: never
-  # Rules to run the job on merge_requests and master branch
-  run-always:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-    - if: $CI_COMMIT_BRANCH != null && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      when: on_success
-    - when: never
-  # Rules to run the job only when a release happens
-  run-on-release:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      changes:
-          - 'RELEASE_NOTES'
-      when: on_success
-    - when: never
-
-.component-tests:
-  image: $BUILD_IMAGE
-  rules:
-    - !reference [.default-rules, run-always]
-  variables:
-    COMPONENT_TESTS_CONFIG: component-test-config.yaml
-    COMPONENT_TESTS_CONFIG_CONTENT: Y2xvdWRmbGFyZWRfYmluYXJ5OiBjbG91ZGZsYXJlZC5leGUKY3JlZGVudGlhbHNfZmlsZTogY3JlZC5qc29uCm9yaWdpbmNlcnQ6IGNlcnQucGVtCnpvbmVfZG9tYWluOiBhcmdvdHVubmVsdGVzdC5jb20Kem9uZV90YWc6IDQ4Nzk2ZjFlNzBiYjc2NjljMjliYjUxYmEyODJiZjY1
-  secrets:
-    DNS_API_TOKEN:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/_terraform_atlantis/component_tests_token/data@kv
-      file: false
-    COMPONENT_TESTS_ORIGINCERT:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/component_tests_cert_pem/data@kv
-      file: false
-  cache: {}
@@ -1,17 +0,0 @@
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-######################################
-### Sync master branch with Github ###
-######################################
-push-github:
-  stage: sync
-  rules:
-    - !reference [.default-rules, run-on-master]
-  script:
-    - ./.ci/scripts/github-push.sh
-  secrets:
-    CLOUDFLARED_DEPLOY_SSH_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cloudflared_github_ssh/data@kv
-      file: false
-  cache: {}
@@ -1,2 +0,0 @@
-images:
-  - name: ci-image
@@ -1,39 +0,0 @@
-ARG CLOUDFLARE_DOCKER_REGISTRY_HOST
-
-FROM ${CLOUDFLARE_DOCKER_REGISTRY_HOST:-registry.cfdata.org}/stash/cf/debian-images/trixie/main:2026.1.0@sha256:e32092fd01520f5ae7de1fa6bb5a721720900ebeaa48e98f36f6f86168833cd7
-RUN apt-get update && \
-  apt-get upgrade -y && \
-  apt-get install --no-install-recommends --allow-downgrades -y \
-  build-essential \
-  git \
-  go-boring=1.26.4-1 \
-  libffi-dev \
-  procps \
-  python3-dev \
-  python3-pip \
-  python3-setuptools \
-  python3-venv \
-  # tool to create msi packages
-  wixl \
-  # install ruby and rpm which are required to install fpm package builder
-  rpm \
-  ruby \
-  ruby-dev \
-  rubygems \
-  # create deb and rpm repository files
-  reprepro \
-  createrepo-c \
-  # gcc for cross architecture compilation in arm
-  gcc-aarch64-linux-gnu \
-  libc6-dev-arm64-cross && \
-  rm -rf /var/lib/apt/lists/* && \
-  # Install fpm gem
-  gem install fpm --no-document && \
-  # Initialize rpm repository, SQL Lite DB
-  mkdir -p /var/lib/rpm && \
-  rpm --initdb && \
-  chmod -R 777 /var/lib/rpm && \
-  # Create work directory
-  mkdir -p opt
-
-WORKDIR /opt
@@ -1,34 +0,0 @@
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-  ###########################################################################
-  ### Build and Push Internal Image (commit SHA on master, version on tag) ###
-  ###########################################################################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/docker-image/build-push-image@~latest
-    inputs:
-      stage: release-internal
-      jobPrefix: internal-image
-      runOnMR: false
-      runOnBranches: '^master$'
-      needs:
-        - generate-internal-image-version
-      commentImageRefs: false
-      runner: vm-linux-x86-4cpu-8gb
-      EXTRA_DIB_ARGS: "--manifest=.docker-images-internal"
-
-###############################################################################
-### Generate Internal Image Version File                                     ###
-### Uses `git describe`: version tag on tagged commits, SHA-based on master  ###
-###############################################################################
-generate-internal-image-version:
-  stage: release-internal
-  image: $BUILD_IMAGE
-  rules:
-    - !reference [.default-rules, run-on-master]
-  needs:
-    - ci-image-get-image-ref
-  script:
-    - make generate-internal-image-version
-  artifacts:
-    paths:
-      - versions-internal
@@ -1,122 +0,0 @@
-.golang-inputs: &golang_inputs
-  runOnMR: true
-  runOnBranches: "^master$"
-  outputDir: artifacts
-  runner: linux-x86-8cpu-16gb
-  stage: build
-  golangVersion: "boring-1.26"
-  imageVersion: "3625-1801d52@sha256:9261597bc2d229c997522848260de758567643d58ae1097196ae368db89a1d0f"
-  CGO_ENABLED: 1
-
-.default-packaging-job: &packaging-job-defaults
-  stage: package
-  needs:
-    - ci-image-get-image-ref
-  rules:
-    - !reference [.default-rules, run-on-master]
-  image: $BUILD_IMAGE
-  cache: {}
-  artifacts:
-    paths:
-      - artifacts/*
-
-include:
-  ###################
-  ### Linux Build ###
-  ###################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/golang/boring-make@~latest
-    inputs:
-      <<: *golang_inputs
-      jobPrefix: linux-build
-      GOLANG_MAKE_TARGET: ci-build
-
-  ########################
-  ### Linux FIPS Build ###
-  ########################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/golang/boring-make@~latest
-    inputs:
-      <<: *golang_inputs
-      jobPrefix: linux-fips-build
-      GOLANG_MAKE_TARGET: ci-fips-build
-
-  #################
-  ### Unit Tests ##
-  #################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/golang/boring-make@~latest
-    inputs:
-      <<: *golang_inputs
-      stage: test
-      jobPrefix: test
-      GOLANG_MAKE_TARGET: ci-test
-
-  ######################
-  ### Unit Tests FIPS ##
-  ######################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/golang/boring-make@~latest
-    inputs:
-      <<: *golang_inputs
-      stage: test
-      jobPrefix: test-fips
-      GOLANG_MAKE_TARGET: ci-fips-test
-
-  #################
-  ### Vuln Check ##
-  #################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/golang/boring-make@~latest
-    inputs:
-      <<: *golang_inputs
-      runOnBranches: "^$"
-      stage: validate
-      jobPrefix: vulncheck
-      GOLANG_MAKE_TARGET: vulncheck
-
-#################################
-### Run Linux Component Tests ###
-#################################
-linux-component-tests: &linux-component-tests
-  stage: test
-  extends: .component-tests
-  needs:
-    - ci-image-get-image-ref
-    - linux-build-boring-make
-  script:
-    - ./.ci/scripts/component-tests.sh
-  variables: &component-tests-variables
-    CI: 1
-    COMPONENT_TESTS_CONFIG_CONTENT: Y2xvdWRmbGFyZWRfYmluYXJ5OiAuL2Nsb3VkZmxhcmVkCmNyZWRlbnRpYWxzX2ZpbGU6IGNyZWQuanNvbgpvcmlnaW5jZXJ0OiBjZXJ0LnBlbQp6b25lX2RvbWFpbjogYXJnb3R1bm5lbHRlc3QuY29tCnpvbmVfdGFnOiA0ODc5NmYxZTcwYmI3NjY5YzI5YmI1MWJhMjgyYmY2NQ==
-  tags:
-    - linux-x86-8cpu-16gb
-  artifacts:
-    reports:
-      junit: report.xml
-
-######################################
-### Run Linux FIPS Component Tests ###
-######################################
-linux-component-tests-fips:
-  <<: *linux-component-tests
-  needs:
-    - ci-image-get-image-ref
-    - linux-fips-build-boring-make
-  variables:
-    <<: *component-tests-variables
-    COMPONENT_TESTS_FIPS: 1
-
-################################
-####### Linux Packaging ########
-################################
-linux-packaging:
-  <<: *packaging-job-defaults
-  parallel:
-    matrix:
-      - ARCH: ["386", "amd64", "arm", "armhf", "arm64"]
-  script:
-    - ./.ci/scripts/linux/build-packages.sh ${ARCH}
-
-################################
-##### Linux FIPS Packaging #####
-################################
-linux-packaging-fips:
-  <<: *packaging-job-defaults
-  script:
-    - ./.ci/scripts/linux/build-packages-fips.sh
@@ -1,66 +0,0 @@
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-###############################
-### Defaults for Mac Builds ###
-###############################
-.mac-build-defaults: &mac-build-defaults
-  rules:
-    - !reference [.default-rules, run-on-mr]
-  tags:
-    - "macstadium-${RUNNER_ARCH}"
-  parallel:
-    matrix:
-      - RUNNER_ARCH: [arm, intel]
-  cache: {}
-
-######################################
-### Build Cloudflared Mac Binaries ###
-######################################
-macos-build-cloudflared: &mac-build
-  <<: *mac-build-defaults
-  stage: build
-  artifacts:
-    paths:
-      - artifacts/*
-  script:
-    - '[ "${RUNNER_ARCH}" = "arm" ] && export TARGET_ARCH=arm64'
-    - '[ "${RUNNER_ARCH}" = "intel" ] && export TARGET_ARCH=amd64'
-    - ARCH=$(uname -m)
-    - echo ARCH=$ARCH - TARGET_ARCH=$TARGET_ARCH
-    - ./.ci/scripts/mac/install-go.sh "$MAC_GO_VERSION"
-    - BUILD_SCRIPT=.ci/scripts/mac/build.sh
-    - if [[ ! -x ${BUILD_SCRIPT} ]] ; then exit ; fi
-    - set -euo pipefail
-    - echo "Executing ${BUILD_SCRIPT}"
-    - exec ${BUILD_SCRIPT}
-
-###############################################
-### Build and Sign Cloudflared Mac Binaries ###
-###############################################
-macos-build-and-sign-cloudflared:
-  <<: *mac-build
-  rules:
-    - !reference [.default-rules, run-on-master]
-  secrets:
-    APPLE_DEV_CA_CERT:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/apple_dev_ca_cert_v2/data@kv
-      file: false
-    CFD_CODE_SIGN_CERT:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_code_sign_cert_v2/data@kv
-      file: false
-    CFD_CODE_SIGN_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_code_sign_key_v2/data@kv
-      file: false
-    CFD_CODE_SIGN_PASS:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_code_sign_pass_v2/data@kv
-      file: false
-    CFD_INSTALLER_CERT:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_installer_cert_v2/data@kv
-      file: false
-    CFD_INSTALLER_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_installer_key_v2/data@kv
-      file: false
-    CFD_INSTALLER_PASS:
-      vault: gitlab/cloudflare/tun/cloudflared/_branch/master/cfd_installer_pass_v2/data@kv
-      file: false
@@ -1,133 +0,0 @@
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-  ######################################
-  ### Build and Push DockerHub Image ###
-  ######################################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/docker-image/build-push-image@~latest
-    inputs:
-      stage: release
-      jobPrefix: docker-hub
-      runOnMR: false
-      runOnBranches: '^master$'
-      runOnChangesTo: ['RELEASE_NOTES']
-      needs:
-        - generate-version-file
-        - release-cloudflared-to-r2
-      commentImageRefs: false
-      runner: vm-linux-x86-4cpu-8gb
-      # Based on if the CI reference is protected or not the CI component will
-      # either use _BRANCH or _PROD, therefore, to prevent the pipelines from failing
-      # we simply set both to the same value.
-      DOCKER_USER_BRANCH: &docker-hub-user svcgithubdockerhubcloudflar045
-      DOCKER_PASSWORD_BRANCH: &docker-hub-password gitlab/cloudflare/tun/cloudflared/_dev/dockerhub/svc_password/data
-      DOCKER_USER_PROD: *docker-hub-user
-      DOCKER_PASSWORD_PROD: *docker-hub-password
-      EXTRA_DIB_ARGS: --overwrite
-
-.default-release-job: &release-job-defaults
-  stage: release
-  image: $BUILD_IMAGE
-  cache:
-    paths:
-      - .cache/pip
-  variables: &release-job-variables
-    PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
-    # KV Vars
-    KV_NAMESPACE: 380e19aa04314648949b6ad841417ebe
-    KV_ACCOUNT: &cf-account 5ab4e9dfbd435d24068829fda0077963
-    # R2 Vars
-    R2_BUCKET: cloudflared-pkgs
-    R2_ACCOUNT_ID: *cf-account
-    # APT and RPM Repository Vars
-    GPG_PUBLIC_KEY_URL: "https://pkg.cloudflare.com/cloudflare-ascii-pubkey.gpg"
-    PKG_URL: "https://pkg.cloudflare.com/cloudflared"
-    BINARY_NAME: cloudflared
-  secrets:
-    KV_API_TOKEN:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/cfd_kv_api_token/data@kv
-      file: false
-    API_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/cfd_github_api_key/data@kv
-      file: false
-    R2_CLIENT_ID:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/_terraform_atlantis/r2_api_token/client_id@kv
-      file: false
-    R2_CLIENT_SECRET:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/_terraform_atlantis/r2_api_token/client_secret@kv
-      file: false
-    LINUX_SIGNING_PUBLIC_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/gpg_v1/public_key@kv
-      file: false
-    LINUX_SIGNING_PRIVATE_KEY:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/gpg_v1/private_key@kv
-      file: false
-    LINUX_SIGNING_PUBLIC_KEY_2:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/gpg_v2/public_key@kv
-      file: false
-    LINUX_SIGNING_PRIVATE_KEY_2:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/gpg_v2/private_key@kv
-      file: false
-
-###########################################
-### Push Cloudflared Binaries to Github ###
-###########################################
-release-cloudflared-to-github:
-  <<: *release-job-defaults
-  rules:
-    - !reference [.default-rules, run-on-release]
-  needs:
-    - ci-image-get-image-ref
-    - linux-packaging
-    - linux-packaging-fips
-    - macos-build-and-sign-cloudflared
-    - windows-package-sign
-  script:
-    - ./.ci/scripts/release-target.sh github-release
-
-#########################################
-### Upload Cloudflared Binaries to R2 ###
-#########################################
-release-cloudflared-to-r2:
-  <<: *release-job-defaults
-  rules:
-    - !reference [.default-rules, run-on-release]
-  needs:
-    - ci-image-get-image-ref
-    - linux-packaging # We only release non-FIPS binaries to R2
-    - release-cloudflared-to-github
-  script:
-    - ./.ci/scripts/release-target.sh r2-linux-release
-
-#################################################
-### Upload Cloudflared Nightly Binaries to R2 ###
-#################################################
-release-cloudflared-nightly-to-r2:
-  <<: *release-job-defaults
-  rules:
-    - !reference [.default-rules, run-on-master]
-  variables:
-    <<: *release-job-variables
-    R2_BUCKET: cloudflared-pkgs-next
-    GPG_PUBLIC_KEY_URL: "https://next.pkg.cloudflare.com/cloudflare-ascii-pubkey.gpg"
-    PKG_URL: "https://next.pkg.cloudflare.com/cloudflared"
-  needs:
-    - ci-image-get-image-ref
-    - linux-packaging # We only release non-FIPS binaries to R2
-  script:
-    - ./.ci/scripts/release-target.sh r2-linux-release
-
-#############################
-### Generate Version File ###
-#############################
-generate-version-file:
-  <<: *release-job-defaults
-  rules:
-    - !reference [.default-rules, run-on-release]
-  needs:
-    - ci-image-get-image-ref
-  script:
-    - make generate-docker-version
-  artifacts:
-    paths:
-      - versions
@@ -1,25 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-# Fetch cloudflared from the artifacts folder
-mv ./artifacts/cloudflared ./cloudflared
-
-python3 -m venv env
-. env/bin/activate
-
-pip install --upgrade -r component-tests/requirements.txt
-
-# Creates and routes a Named Tunnel for this build. Also constructs
-# config file from env vars.
-python3 component-tests/setup.py --type create
-
-# Define the cleanup function
-cleanup() {
-    # The Named Tunnel is deleted and its route unprovisioned here.
-    python3 component-tests/setup.py --type cleanup
-}
-
-# The trap will call the cleanup function on script exit
-trap cleanup EXIT
-
-pytest component-tests -o log_cli=true --log-cli-level=INFO --junit-xml=report.xml
@@ -1,13 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-OUTPUT=$(go run -mod=readonly golang.org/x/tools/cmd/goimports@v0.30.0 -l -d -local github.com/cloudflare/cloudflared $(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc))
-
-if [ -n "$OUTPUT" ] ; then
-  PAGER=$(which colordiff || echo cat)
-  echo
-  echo "Code formatting issues found, use 'make fmt' to correct them"
-  echo
-  echo "$OUTPUT" | $PAGER
-  exit 1
-fi
@@ -1,31 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-BRANCH="master"
-TMP_PATH="$PWD/tmp"
-PRIVATE_KEY_PATH="$TMP_PATH/github-deploy-key"
-PUBLIC_KEY_GITHUB_PATH="$TMP_PATH/github.pub"
-
-mkdir -p $TMP_PATH
-
-# Setup Private Key
-echo "$CLOUDFLARED_DEPLOY_SSH_KEY" > $PRIVATE_KEY_PATH
-chmod 400 $PRIVATE_KEY_PATH
-
-# Download GitHub Public Key for KnownHostsFile
-ssh-keyscan -t ed25519 github.com > $PUBLIC_KEY_GITHUB_PATH
-
-# Setup git ssh command with the right configurations
-export GIT_SSH_COMMAND="ssh -o UserKnownHostsFile=$PUBLIC_KEY_GITHUB_PATH -o IdentitiesOnly=yes -i $PRIVATE_KEY_PATH"
-
-# Add GitHub as a new remote
-git remote add github git@github.com:cloudflare/cloudflared.git || true
-
-# GitLab doesn't pull branch references, instead it creates a new one on each pipeline.
-# Therefore, we need to manually fetch the reference to then push it to GitHub.
-git fetch origin $BRANCH:$BRANCH
-git push -u github $BRANCH
-
-if TAG="$(git describe --tags --exact-match 2>/dev/null)"; then
-  git push -u github "$TAG"
-fi
@@ -1,60 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-# Check if architecture argument is provided
-if [ $# -eq 0 ]; then
-    echo "Error: Architecture argument is required"
-    echo "Usage: $0 <architecture>"
-    exit 1
-fi
-
-# Parameters
-arch=$1
-
-# Get Version
-VERSION=$(git describe --tags --always --match "[0-9][0-9][0-9][0-9].*.*")
-echo $VERSION
-
-# Disable FIPS module in go-boring
-export GOEXPERIMENT=noboringcrypto
-export CGO_ENABLED=0
-
-# This controls the directory the built artifacts go into
-export ARTIFACT_DIR=artifacts/
-mkdir -p $ARTIFACT_DIR
-
-export TARGET_OS=linux
-
-unset TARGET_ARM
-export TARGET_ARCH=$arch
-
-## Support for arm platforms without hardware FPU enabled
-if [[ $arch == arm ]] ; then
-    export TARGET_ARCH=arm
-    export TARGET_ARM=5
-fi
-
-## Support for armhf builds
-if [[ $arch == armhf ]] ; then
-    export TARGET_ARCH=arm
-    export TARGET_ARM=7
-fi
-
-make cloudflared-deb
-mv cloudflared\_$VERSION\_$arch.deb $ARTIFACT_DIR/cloudflared-linux-$arch.deb
-
-# rpm packages invert the - and _ and use x86_64 instead of amd64.
-RPMVERSION=$(echo $VERSION|sed -r 's/-/_/g')
-RPMARCH=$arch
-if [ $arch == "amd64" ];then
-    RPMARCH="x86_64"
-fi
-if [ $arch == "arm64" ]; then
-    RPMARCH="aarch64"
-fi
-make cloudflared-rpm
-mv cloudflared-$RPMVERSION-1.$RPMARCH.rpm $ARTIFACT_DIR/cloudflared-linux-$RPMARCH.rpm
-
-# finally move the linux binary as well.
-mv ./cloudflared $ARTIFACT_DIR/cloudflared-linux-$arch
-
@@ -1,228 +0,0 @@
-#!/bin/bash
-
-set -exo pipefail
-
-if [[ "$(uname)" != "Darwin" ]] ; then
-    echo "This should be run on macOS"
-    exit 1
-fi
-
-if [[ "amd64" != "${TARGET_ARCH}" && "arm64" != "${TARGET_ARCH}" ]]
-then
-  echo "TARGET_ARCH must be amd64 or arm64"
-  exit 1
-fi
-
-go version
-export GO111MODULE=on
-
-# build 'cloudflared-darwin-amd64.tgz'
-mkdir -p artifacts
-TARGET_DIRECTORY=".build"
-BINARY_NAME="cloudflared"
-VERSION=$(git describe --tags --always --dirty="-dev")
-PRODUCT="cloudflared"
-APPLE_CA_CERT="apple_dev_ca.cert"
-CODE_SIGN_PRIV="code_sign.p12"
-CODE_SIGN_CERT="code_sign.cer"
-INSTALLER_PRIV="installer.p12"
-INSTALLER_CERT="installer.cer"
-BUNDLE_ID="com.cloudflare.cloudflared"
-SEC_DUP_MSG="security: SecKeychainItemImport: The specified item already exists in the keychain."
-export PATH="$PATH:/usr/local/bin"
-FILENAME="$(pwd)/artifacts/cloudflared-darwin-$TARGET_ARCH.tgz"
-PKGNAME="$(pwd)/artifacts/cloudflared-$TARGET_ARCH.pkg"
-mkdir -p ../src/github.com/cloudflare/    
-cp -r . ../src/github.com/cloudflare/cloudflared
-cd ../src/github.com/cloudflare/cloudflared 
-
-# Imports certificates to the Apple KeyChain
-import_certificate() {
-    local CERTIFICATE_NAME=$1
-    local CERTIFICATE_ENV_VAR=$2
-    local CERTIFICATE_FILE_NAME=$3
-
-    echo "Importing $CERTIFICATE_NAME"
-
-    if [[ ! -z "$CERTIFICATE_ENV_VAR" ]]; then
-      # write certificate to disk and then import it keychain
-      echo -n -e ${CERTIFICATE_ENV_VAR} | base64 -D > ${CERTIFICATE_FILE_NAME}
-      # we set || true  here and for every `security import invoke` because the  "duplicate SecKeychainItemImport" error
-      # will cause set -e to exit 1. It is okay we do this because we deliberately handle this error in the lines below.
-      local out=$(security import ${CERTIFICATE_FILE_NAME} -T /usr/bin/pkgbuild -A 2>&1) || true
-      local exitcode=$?
-      # delete the certificate from disk
-      rm -rf ${CERTIFICATE_FILE_NAME}
-      if [ -n "$out" ]; then
-        if [ $exitcode -eq 0 ]; then
-            echo "$out"
-        else
-            if [ "$out" != "${SEC_DUP_MSG}" ]; then
-                echo "$out" >&2
-                exit $exitcode
-            else
-                echo "already imported code signing certificate"
-            fi
-        fi
-      fi
-    fi
-}
-
-create_cloudflared_build_keychain() {
-  # Reusing the private key password as the keychain key
-  local PRIVATE_KEY_PASS=$1
-
-  # Create keychain only if it doesn't already exist
-  if [ ! -f "$HOME/Library/Keychains/cloudflared_build_keychain.keychain-db" ]; then
-    security create-keychain -p "$PRIVATE_KEY_PASS" cloudflared_build_keychain
-  else
-    echo "Keychain already exists: cloudflared_build_keychain"
-  fi
-
-  # Append temp keychain to the user domain
-  security list-keychains -d user -s cloudflared_build_keychain $(security list-keychains -d user | sed s/\"//g)
-
-  # Remove relock timeout
-  security set-keychain-settings cloudflared_build_keychain
-
-  # Unlock keychain so it doesn't require password
-  security unlock-keychain -p "$PRIVATE_KEY_PASS" cloudflared_build_keychain
-
-}
-
-# Imports private keys to the Apple KeyChain
-import_private_keys() {
-    local PRIVATE_KEY_NAME=$1
-    local PRIVATE_KEY_ENV_VAR=$2
-    local PRIVATE_KEY_FILE_NAME=$3
-    local PRIVATE_KEY_PASS=$4
-
-    echo "Importing $PRIVATE_KEY_NAME"
-
-    if [[ ! -z "$PRIVATE_KEY_ENV_VAR" ]]; then
-      if [[ ! -z "$PRIVATE_KEY_PASS" ]]; then
-        # write private key to disk and then import it keychain
-        echo -n -e ${PRIVATE_KEY_ENV_VAR} | base64 -D > ${PRIVATE_KEY_FILE_NAME}
-        # we set || true  here and for every `security import invoke` because the  "duplicate SecKeychainItemImport" error
-        # will cause set -e to exit 1. It is okay we do this because we deliberately handle this error in the lines below.
-        local out=$(security import ${PRIVATE_KEY_FILE_NAME} -k cloudflared_build_keychain -P "$PRIVATE_KEY_PASS" -T /usr/bin/pkgbuild -A -P "${PRIVATE_KEY_PASS}" 2>&1) || true
-        local exitcode=$?
-        rm -rf ${PRIVATE_KEY_FILE_NAME}
-        if [ -n "$out" ]; then
-          if [ $exitcode -eq 0 ]; then
-              echo "$out"
-          else
-              if [ "$out" != "${SEC_DUP_MSG}" ]; then
-                  echo "$out" >&2
-                  exit $exitcode
-              fi
-          fi
-        fi
-      fi
-    fi
-}
-
-# Create temp keychain only for this build
-create_cloudflared_build_keychain "${CFD_CODE_SIGN_PASS}"
-
-# Add Apple Root Developer certificate to the key chain
-import_certificate "Apple Developer CA" "${APPLE_DEV_CA_CERT}" "${APPLE_CA_CERT}"
-
-# Add code signing private key to the key chain
-import_private_keys "Developer ID Application" "${CFD_CODE_SIGN_KEY}" "${CODE_SIGN_PRIV}" "${CFD_CODE_SIGN_PASS}"
-
-# Add code signing certificate to the key chain
-import_certificate "Developer ID Application" "${CFD_CODE_SIGN_CERT}" "${CODE_SIGN_CERT}"
-
-# Add package signing private key to the key chain
-import_private_keys "Developer ID Installer" "${CFD_INSTALLER_KEY}" "${INSTALLER_PRIV}" "${CFD_INSTALLER_PASS}"
-
-# Add package signing certificate to the key chain
-import_certificate "Developer ID Installer" "${CFD_INSTALLER_CERT}" "${INSTALLER_CERT}"
-
-# get the code signing certificate name
-if [[ ! -z "$CFD_CODE_SIGN_NAME" ]]; then
-  CODE_SIGN_NAME="${CFD_CODE_SIGN_NAME}"
-else
-  if [[ -n "$(security find-certificate -c "Developer ID Application" cloudflared_build_keychain | cut -d'"' -f 4 -s | grep "Developer ID Application:" | head -1)" ]]; then
-    CODE_SIGN_NAME=$(security find-certificate -c "Developer ID Application" cloudflared_build_keychain | cut -d'"' -f 4 -s | grep "Developer ID Application:" | head -1)
-  else
-    CODE_SIGN_NAME=""
-  fi
-fi
-
-# get the package signing certificate name
-if [[ ! -z "$CFD_INSTALLER_NAME" ]]; then
-  PKG_SIGN_NAME="${CFD_INSTALLER_NAME}"
-else
-  if [[ -n "$(security find-certificate -c "Developer ID Installer" cloudflared_build_keychain | cut -d'"' -f 4 -s | grep "Developer ID Installer:" | head -1)" ]]; then
-    PKG_SIGN_NAME=$(security find-certificate -c "Developer ID Installer" cloudflared_build_keychain | cut -d'"' -f 4 -s | grep "Developer ID Installer:" | head -1)
-  else
-    PKG_SIGN_NAME=""
-  fi
-fi
-
-# cleanup the build directory because the previous execution might have failed without cleaning up.
-rm -rf "${TARGET_DIRECTORY}"
-export TARGET_OS="darwin"
-GOCACHE="$PWD/../../../../" GOPATH="$PWD/../../../../" CGO_ENABLED=1 make cloudflared
-
-
-# This allows apple tools to use the certificates in the keychain without requiring password input.
-# This command always needs to run after the certificates have been loaded into the keychain
-if [[ ! -z "$CFD_CODE_SIGN_PASS" ]]; then
-  security set-key-partition-list -S apple-tool:,apple: -s -k "${CFD_CODE_SIGN_PASS}" cloudflared_build_keychain
-fi
-
-# sign the cloudflared binary
-if [[ ! -z "$CODE_SIGN_NAME" ]]; then
-  codesign --keychain $HOME/Library/Keychains/cloudflared_build_keychain.keychain-db -s "${CODE_SIGN_NAME}" -fv --options runtime --timestamp ${BINARY_NAME}
-
- # notarize the binary
- # TODO: TUN-5789
-fi
-
-ARCH_TARGET_DIRECTORY="${TARGET_DIRECTORY}/${TARGET_ARCH}-build"
-# creating build directory
-rm -rf $ARCH_TARGET_DIRECTORY
-mkdir -p "${ARCH_TARGET_DIRECTORY}"
-mkdir -p "${ARCH_TARGET_DIRECTORY}/contents"
-cp -r ".mac_resources/scripts" "${ARCH_TARGET_DIRECTORY}/scripts"
-
-# copy cloudflared into the build directory
-cp ${BINARY_NAME} "${ARCH_TARGET_DIRECTORY}/contents/${PRODUCT}"
-
-# compress cloudflared into a tar and gzipped file
-tar czf "$FILENAME" "${BINARY_NAME}"
-
-# build the installer package
-if [[ ! -z "$PKG_SIGN_NAME" ]]; then
-
-  pkgbuild --identifier com.cloudflare.${PRODUCT} \
-      --version ${VERSION} \
-      --scripts ${ARCH_TARGET_DIRECTORY}/scripts \
-      --root ${ARCH_TARGET_DIRECTORY}/contents \
-      --install-location /usr/local/bin \
-      --keychain cloudflared_build_keychain \
-      --sign "${PKG_SIGN_NAME}" \
-      ${PKGNAME}
-
-      # notarize the package
-      # TODO: TUN-5789
-else
-    pkgbuild --identifier com.cloudflare.${PRODUCT} \
-      --version ${VERSION} \
-      --scripts ${ARCH_TARGET_DIRECTORY}/scripts \
-      --root ${ARCH_TARGET_DIRECTORY}/contents \
-      --install-location /usr/local/bin \
-      ${PKGNAME}
-fi
-
-# cleanup build directory because this script is not ran within containers,
-# which might lead to future issues in subsequent runs.
-rm -rf "${TARGET_DIRECTORY}"
-
-# cleanup the keychain
-security default-keychain -d user -s login.keychain-db
-security list-keychains -d user -s login.keychain-db
-security delete-keychain cloudflared_build_keychain
@@ -1,14 +0,0 @@
-rm -rf /tmp/go
-export GOCACHE=/tmp/gocache
-rm -rf $GOCACHE
-
-if [ -z "$1" ]
-  then
-    echo "No go version supplied"
-fi
-
-brew install "$1"
-
-go version
-which go
-go env
@@ -1,25 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-python3 -m venv env
-. env/bin/activate
-pip install pynacl==1.4.0 pygithub==1.55
-
-VERSION=$(git describe --tags --always --match "[0-9][0-9][0-9][0-9].*.*")
-echo $VERSION
-
-export TARGET_OS=windows
-# This controls the directory the built artifacts go into
-export BUILT_ARTIFACT_DIR=artifacts/
-export FINAL_ARTIFACT_DIR=artifacts/
-mkdir -p $BUILT_ARTIFACT_DIR
-mkdir -p $FINAL_ARTIFACT_DIR
-windowsArchs=("amd64" "386")
-for arch in ${windowsArchs[@]}; do
-    export TARGET_ARCH=$arch
-    # Copy .exe from artifacts directory
-    cp $BUILT_ARTIFACT_DIR/cloudflared-windows-$arch.exe ./cloudflared.exe
-    make cloudflared-msi
-    # Copy msi into final directory
-    mv cloudflared-$VERSION-$arch.msi $FINAL_ARTIFACT_DIR/cloudflared-windows-$arch.msi
-done
@@ -1,18 +0,0 @@
-#!/bin/bash
-set -e -u -o pipefail
-
-# Check if a make target is provided as an argument
-if [ $# -eq 0 ]; then
-    echo "Error: Make target argument is required"
-    echo "Usage: $0 <make-target>"
-    exit 1
-fi
-
-MAKE_TARGET=$1
-
-python3 -m venv venv
-source venv/bin/activate
-
-# Our release scripts are written in python, so we should install their dependecies here.
-pip install pynacl==1.4.0 pygithub==1.55 boto3==1.42.30 python-gnupg==0.4.9
-make $MAKE_TARGET
@@ -1,53 +0,0 @@
-#!/bin/bash
-set -e -u
-
-# Define the file to store the list of vulnerabilities to ignore.
-IGNORE_FILE=".vulnignore"
-
-go version
-# Check if the ignored vulnerabilities file exists. If not, create an empty one.
-if [ ! -f "$IGNORE_FILE" ]; then
-  touch "$IGNORE_FILE"
-  echo "Created an empty file to store ignored vulnerabilities: $IGNORE_FILE"
-  echo "# Add vulnerability IDs (e.g., GO-2022-0450) to ignore, one per line." >>"$IGNORE_FILE"
-  echo "# You can also add comments on the same line after the ID." >>"$IGNORE_FILE"
-  echo "" >>"$IGNORE_FILE"
-fi
-
-# Run govulncheck and capture its output.
-VULN_OUTPUT=$(go run -mod=readonly golang.org/x/vuln/cmd/govulncheck@latest ./... || true)
-
-# Print the govuln output
-echo "====================================="
-echo "Full Output of govulncheck:"
-echo "====================================="
-echo "$VULN_OUTPUT"
-echo "====================================="
-echo "End of govulncheck Output"
-echo "====================================="
-
-# Process the ignore file to remove comments and empty lines.
-# The 'cut' command gets the vulnerability ID and removes anything after the '#'.
-# The 'grep' command filters out empty lines and lines starting with '#'.
-CLEAN_IGNORES=$(grep -v '^\s*#' "$IGNORE_FILE" | cut -d'#' -f1 | sed 's/ //g' | sort -u || true)
-
-# Filter out the ignored vulnerabilities.
-UNIGNORED_VULNS=$(echo "$VULN_OUTPUT" | grep 'Vulnerability' || true)
-
-# If the list of ignored vulnerabilities is not empty, filter them out.
-if [ -n "$CLEAN_IGNORES" ]; then
-  UNIGNORED_VULNS=$(echo "$UNIGNORED_VULNS" | grep -vFf <(echo "$CLEAN_IGNORES") || true)
-fi
-
-# If there are any vulnerabilities that were not in our ignore list, print them and exit with an error.
-if [ -n "$UNIGNORED_VULNS" ]; then
-  echo "🚨 Found new, unignored vulnerabilities:"
-  echo "-------------------------------------"
-  echo "$UNIGNORED_VULNS"
-  echo "-------------------------------------"
-  echo "Exiting with an error. ❌"
-  exit 1
-else
-  echo "🎉 No new vulnerabilities found. All clear! ✨"
-  exit 0
-fi
@@ -1,29 +0,0 @@
-Set-StrictMode -Version Latest
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-
-$env:TARGET_OS = "windows"
-$env:LOCAL_OS = "windows"
-$TIMESTAMP_RFC3161 = "http://timestamp.digicert.com"
-
-New-Item -Path ".\artifacts" -ItemType Directory
-
-Write-Output "Building for amd64"
-$env:TARGET_ARCH = "amd64"
-$env:LOCAL_ARCH = "amd64"
-$env:CGO_ENABLED = 1
-& make cloudflared
-if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared for amd64" }
-# Sign build
-azuresigntool.exe sign -kvu $env:KEY_VAULT_URL -kvi "$env:KEY_VAULT_CLIENT_ID" -kvs "$env:KEY_VAULT_SECRET" -kvc "$env:KEY_VAULT_CERTIFICATE" -kvt "$env:KEY_VAULT_TENANT_ID" -tr "$TIMESTAMP_RFC3161" -d "Cloudflare Tunnel Daemon" .\cloudflared.exe
-copy .\cloudflared.exe .\artifacts\cloudflared-windows-amd64.exe
-
-Write-Output "Building for 386"
-$env:TARGET_ARCH = "386"
-$env:LOCAL_ARCH = "386"
-$env:CGO_ENABLED = 0
-& make cloudflared
-if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared for 386" }
-## Sign build
-azuresigntool.exe sign -kvu $env:KEY_VAULT_URL -kvi "$env:KEY_VAULT_CLIENT_ID" -kvs "$env:KEY_VAULT_SECRET" -kvc "$env:KEY_VAULT_CERTIFICATE" -kvt "$env:KEY_VAULT_TENANT_ID" -tr "$TIMESTAMP_RFC3161" -d "Cloudflare Tunnel Daemon" .\cloudflared.exe
-copy .\cloudflared.exe .\artifacts\cloudflared-windows-386.exe
@@ -1,40 +0,0 @@
-Set-StrictMode -Version Latest
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-
-$env:TARGET_OS = "windows"
-$env:LOCAL_OS = "windows"
-$env:TARGET_ARCH = "amd64"
-$env:LOCAL_ARCH = "amd64"
-$env:CGO_ENABLED = 1
-
-python --version
-python -m pip --version
-
-
-Write-Host "Building cloudflared"
-& make cloudflared
-if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared" }
-
-
-Write-Host "Running unit tests"
-# Not testing with race detector because of https://github.com/golang/go/issues/61058
-# We already test it on other platforms
-go test -failfast -v -mod=vendor ./...
-if ($LASTEXITCODE -ne 0) { throw "Failed unit tests" }
-
-
-# On Gitlab runners we need to add all of this addresses to the NO_PROXY list in order for the tests to run.
-$env:NO_PROXY = "pypi.org,files.pythonhosted.org,api.cloudflare.com,argotunneltest.com,argotunnel.com,trycloudflare.com,${env:NO_PROXY}"
-Write-Host "No Proxy: ${env:NO_PROXY}"
-Write-Host "Running component tests"
-try {
-    python -m pip --disable-pip-version-check install --upgrade -r component-tests/requirements.txt --use-pep517
-    python component-tests/setup.py --type create
-    python -m pytest component-tests -o log_cli=true --log-cli-level=INFO --junit-xml=report.xml
-    if ($LASTEXITCODE -ne 0) {
-        throw "Failed component tests"
-    }
-} finally {
-    python component-tests/setup.py --type cleanup
-}
@@ -1,69 +0,0 @@
-Param(
-    [string]$GoVersion,
-    [string]$ScriptToExecute
-)
-
-# The script is a wrapper that downloads a specific version
-# of go, adds it to the PATH and executes a script with that go
-# version in the path.
-
-Set-StrictMode -Version Latest
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-
-# Get the path to the system's temporary directory.
-$tempPath = [System.IO.Path]::GetTempPath()
-
-# Create a unique name for the new temporary folder.
-$folderName = "go_" + (Get-Random)
-
-# Join the temp path and the new folder name to create the full path.
-$fullPath = Join-Path -Path $tempPath -ChildPath $folderName
-
-# Store the current value of PATH environment variable.
-$oldPath = $env:Path
-
-# Use a try...finally block to ensure the temporrary folder and PATH are cleaned up.
-try {
-    # Create the temporary folder.
-    Write-Host "Creating temporary folder at: $fullPath"
-    $newTempFolder = New-Item -ItemType Directory -Path $fullPath -Force
-
-    # Download go
-    $url = "https://go.dev/dl/$GoVersion.windows-amd64.zip"
-    $destinationFile = Join-Path -Path $newTempFolder.FullName -ChildPath "go$GoVersion.windows-amd64.zip"
-    Write-Host "Downloading go from: $url"
-    Invoke-WebRequest -Uri $url -OutFile $destinationFile
-    Write-Host "File downloaded to: $destinationFile"
-
-    # Unzip the downloaded file.
-    Write-Host "Unzipping the file..."
-    Expand-Archive -Path $destinationFile -DestinationPath $newTempFolder.FullName -Force
-    Write-Host "File unzipped successfully."
-
-    # Define the go/bin path wich is inside the temporary folder
-    $goBinPath = Join-Path -Path $fullPath -ChildPath "go\bin"
-
-    # Add the go/bin path to the PATH environment variable.
-    $env:Path = "$goBinPath;$($env:Path)"
-    Write-Host "Added $goBinPath to the environment PATH."
-
-    go env
-    go version
-
-    & $ScriptToExecute
-} finally {
-    # Cleanup: Remove the path from the environment variable and then the temporary folder.
-    Write-Host "Starting cleanup..."
-
-    $env:Path = $oldPath
-    Write-Host "Reverted changes in the environment PATH."
-
-    # Remove the temporary folder and its contents.
-    if (Test-Path -Path $fullPath) {
-        Remove-Item -Path $fullPath -Recurse -Force
-        Write-Host "Temporary folder and its contents have been removed."
-    } else {
-        Write-Host "Temporary folder does not exist, no cleanup needed."
-    }
-}
@@ -1,26 +0,0 @@
-# Sign Windows artifacts using azuretool
-# This script processes MSI files from the artifacts directory
-
-$ErrorActionPreference = "Stop"
-
-# Define paths
-$ARTIFACT_DIR = "artifacts"
-$TIMESTAMP_RFC3161 = "http://timestamp.digicert.com"
-
-Write-Host "Looking for Windows artifacts to sign in $ARTIFACT_DIR..."
-
-# Find all Windows MSI files
-$msiFiles = Get-ChildItem -Path $ARTIFACT_DIR -Filter "cloudflared-windows-*.msi" -ErrorAction SilentlyContinue
-
-if ($msiFiles.Count -eq 0) {
-    Write-Host "No Windows MSI files found in $ARTIFACT_DIR"
-    exit 1
-}
-
-Write-Host "Found $($msiFiles.Count) file(s) to sign:"
-foreach ($file in $msiFiles) {
-    Write-Host "Running azuretool sign for $($file.Name)"
-    azuresigntool.exe sign -kvu $env:KEY_VAULT_URL -kvi "$env:KEY_VAULT_CLIENT_ID" -kvs "$env:KEY_VAULT_SECRET" -kvc "$env:KEY_VAULT_CERTIFICATE" -kvt "$env:KEY_VAULT_TENANT_ID" -tr "$TIMESTAMP_RFC3161" -d "Cloudflare Tunnel Daemon" .\\$ARTIFACT_DIR\\$($file.Name)
-}
-
-Write-Host "Signing process completed"
@@ -1,114 +0,0 @@
-include:
-  - local: .ci/commons.gitlab-ci.yml
-
-###################################
-### Defaults for Windows Builds ###
-###################################
-.windows-build-defaults: &windows-build-defaults
-  rules:
-    - !reference [.default-rules, run-always]
-  tags:
-    - canary-windows-x86
-  cache: {}
-
-##########################################
-### Build Cloudflared Windows Binaries ###
-##########################################
-windows-build-cloudflared:
-  <<: *windows-build-defaults
-  stage: build
-  script:
-    - powershell -ExecutionPolicy Bypass -File ".\.ci\scripts\windows\go-wrapper.ps1" "${WIN_GO_VERSION}" ".\.ci\scripts\windows\builds.ps1"
-  artifacts:
-    paths:
-      - artifacts/*
-
-######################################################
-### Load Environment Variables for Component Tests ###
-######################################################
-windows-load-env-variables:
-  stage: pre-build
-  extends: .component-tests
-  script:
-    - echo "COMPONENT_TESTS_CONFIG=$COMPONENT_TESTS_CONFIG" >> windows.env
-    - echo "COMPONENT_TESTS_CONFIG_CONTENT=$COMPONENT_TESTS_CONFIG_CONTENT" >> windows.env
-    - echo "DNS_API_TOKEN=$DNS_API_TOKEN" >> windows.env
-    # We have to encode the `COMPONENT_TESTS_ORIGINCERT` secret, because it content is a file, otherwise we can't export it using gitlab
-    - echo "COMPONENT_TESTS_ORIGINCERT=$(echo "$COMPONENT_TESTS_ORIGINCERT" | base64 -w0)" >> windows.env
-    - echo "KEY_VAULT_URL=$KEY_VAULT_URL" >> windows.env
-    - echo "KEY_VAULT_CLIENT_ID=$KEY_VAULT_CLIENT_ID" >> windows.env
-    - echo "KEY_VAULT_TENANT_ID=$KEY_VAULT_TENANT_ID" >> windows.env
-    - echo "KEY_VAULT_SECRET=$KEY_VAULT_SECRET" >> windows.env
-    - echo "KEY_VAULT_CERTIFICATE=$KEY_VAULT_CERTIFICATE" >> windows.env
-  variables:
-    COMPONENT_TESTS_CONFIG_CONTENT: Y2xvdWRmbGFyZWRfYmluYXJ5OiAuL2Nsb3VkZmxhcmVkLmV4ZQpjcmVkZW50aWFsc19maWxlOiBjcmVkLmpzb24Kb3JpZ2luY2VydDogY2VydC5wZW0Kem9uZV9kb21haW46IGFyZ290dW5uZWx0ZXN0LmNvbQp6b25lX3RhZzogNDg3OTZmMWU3MGJiNzY2OWMyOWJiNTFiYTI4MmJmNjU=
-  secrets:
-    KEY_VAULT_URL:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/azure_vault/app_info/key_vault_url@kv
-      file: false
-    KEY_VAULT_CLIENT_ID:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/azure_vault/app_info/key_vault_client_id@kv
-      file: false
-    KEY_VAULT_TENANT_ID:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/azure_vault/app_info/key_vault_tenant_id@kv
-      file: false
-    KEY_VAULT_SECRET:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/azure_vault/secret/key_vault_secret@kv
-      file: false
-    KEY_VAULT_CERTIFICATE:
-      vault: gitlab/cloudflare/tun/cloudflared/_dev/azure_vault/certificate/key_vault_certificate@kv
-      file: false
-  artifacts:
-    access: 'none'
-    reports:
-      dotenv: windows.env
-
-###################################
-### Run Windows Component Tests ###
-###################################
-windows-component-tests-cloudflared:
-  <<: *windows-build-defaults
-  stage: test
-  needs: ["windows-load-env-variables"]
-  script:
-    # We have to decode the secret we encoded on the `windows-load-env-variables` job
-    - $env:COMPONENT_TESTS_ORIGINCERT = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($env:COMPONENT_TESTS_ORIGINCERT))
-    - powershell -ExecutionPolicy Bypass -File ".\.ci\scripts\windows\go-wrapper.ps1" "${WIN_GO_VERSION}" ".\.ci\scripts\windows\component-test.ps1"
-  artifacts:
-    reports:
-      junit: report.xml
-
-################################
-### Package Windows Binaries ###
-################################
-windows-package:
-  rules:
-    - !reference [.default-rules, run-on-master]
-  stage: package
-  needs:
-    - ci-image-get-image-ref
-    - windows-build-cloudflared
-  image: $BUILD_IMAGE
-  script:
-    - .ci/scripts/package-windows.sh
-  cache: {}
-  artifacts:
-    paths:
-      - artifacts/*
-
-#############################
-### Sign Windows Binaries ###
-#############################
-windows-package-sign:
-  <<: *windows-build-defaults
-  rules:
-    - !reference [.default-rules, run-on-master]
-  stage: package
-  needs:
-    - windows-package
-    - windows-load-env-variables
-  script:
-    - powershell -ExecutionPolicy Bypass -File ".\.ci\scripts\windows\sign-msi.ps1"
-  artifacts:
-    paths:
-      - artifacts/*
@@ -1,8 +0,0 @@
-images:
-  - name: cloudflared
-    dockerfile: Dockerfile.$ARCH
-    context: .
-    version_file: versions-internal
-    architectures:
-    - amd64
-    - arm64
@@ -1,29 +0,0 @@
-#!/bin/sh
-# Pre-push hook for cloudflared
-# Runs linting and tests before allowing pushes
-
-set -e
-
-echo "========================================"
-echo "Running pre-push checks..."
-echo "========================================"
-
-# Run formatting check
-echo ""
-echo "==> Checking formatting..."
-make fmt-check
-
-# Run linter
-echo ""
-echo "==> Running linter..."
-make lint
-
-# Run tests
-echo ""
-echo "==> Running tests..."
-make test
-
-echo ""
-echo "========================================"
-echo "All pre-push checks passed!"
-echo "========================================"
@@ -1,30 +0,0 @@
-name: Semgrep OSS scan
-on:
-  pull_request: {}
-  push:
-    branches: [main, master]
-  workflow_dispatch: {}
-  schedule:
-    - cron: '0 0 25 * *'
-concurrency:
-  group: semgrep-${{ github.event_name }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-permissions:
-  contents: read
-jobs:
-  semgrep:
-    name: semgrep-oss
-    runs-on: ubuntu-slim
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 1
-      - id: cache-semgrep
-        uses: actions/cache@v5
-        with:
-          path: ~/.local
-          key: semgrep-1.160.0-${{ runner.os }}
-      - if: steps.cache-semgrep.outputs.cache-hit != 'true'
-        run: pip install --user semgrep==1.160.0
-      - run: echo "$HOME/.local/bin" >> "$GITHUB_PATH"
-      - run: semgrep scan --config=auto
@@ -17,5 +17,3 @@ cscope.*
 ssh_server_tests/.env
 /.cover
 built_artifacts/
-component-tests/.venv
-/artifacts
@@ -1,74 +0,0 @@
-variables:
-  GO_VERSION: "1.26.4"
-  MAC_GO_VERSION: "go@$GO_VERSION"
-  WIN_GO_VERSION: "go$GO_VERSION"
-  GIT_DEPTH: "0"
-
-default:
-  id_tokens:
-    VAULT_ID_TOKEN:
-      aud: https://vault.cfdata.org
-
-stages:
-  [
-    sync,
-    pre-build,
-    build,
-    validate,
-    test,
-    package,
-    release,
-    release-internal,
-    review,
-  ]
-
-include:
-  #####################################################
-  ########## Import Commons Configurations ############
-  #####################################################
-  - local: .ci/commons.gitlab-ci.yml
-
-  #####################################################
-  ########### Sync Repository with Github #############
-  #####################################################
-  - local: .ci/github.gitlab-ci.yml
-
-  #####################################################
-  ############# Build or Fetch CI Image ###############
-  #####################################################
-  - local: .ci/ci-image.gitlab-ci.yml
-
-  #####################################################
-  ################## Linux Builds ###################
-  #####################################################
-  - local: .ci/linux.gitlab-ci.yml
-
-  #####################################################
-  ################## Windows Builds ###################
-  #####################################################
-  - local: .ci/windows.gitlab-ci.yml
-
-  #####################################################
-  ################### macOS Builds ####################
-  #####################################################
-  - local: .ci/mac.gitlab-ci.yml
-
-  #####################################################
-  ################# Release Packages ##################
-  #####################################################
-  - local: .ci/release.gitlab-ci.yml
-
-  #####################################################
-  ########## Release Packages Internally ##############
-  #####################################################
-  - local: .ci/apt-internal.gitlab-ci.yml
-
-  #####################################################
-  ########## Release Internal Docker Image ############
-  #####################################################
-  - local: .ci/internal-image.gitlab-ci.yml
-
-  #####################################################
-  ############## Manual Claude Review #################
-  #####################################################
-  - component: $CI_SERVER_FQDN/cloudflare/ci/ai/review@~latest
@@ -1,95 +0,0 @@
-version: "2"
-
-linters:
-  enable:
-    # Some of the linters below are commented out. We should uncomment and start running them, but they return
-    # too many problems to fix in one commit. Something for later.
-    - asasalint        # Check for pass []any as any in variadic func(...any).
-    - asciicheck       # Checks that all code identifiers does not have non-ASCII symbols in the name.
-    - bidichk          # Checks for dangerous unicode character sequences.
-    - bodyclose        # Checks whether HTTP response body is closed successfully.
-    - decorder         # Check declaration order and count of types, constants, variables and functions.
-    - dogsled          # Checks assignments with too many blank identifiers (e.g. x, , , _, := f()).
-    - dupl             # Tool for code clone detection.
-    - dupword          # Checks for duplicate words in the source code.
-    - durationcheck    # Check for two durations multiplied together.
-    - errcheck         # Errcheck is a program for checking for unchecked errors in Go code. These unchecked errors can be critical bugs in some cases.
-    - errname          # Checks that sentinel errors are prefixed with the Err and error types are suffixed with the Error.
-    - exhaustive       # Check exhaustiveness of enum switch statements.
-    - gosec            # Inspects source code for security problems.
-    - govet            # Vet examines Go source code and reports suspicious constructs. It is roughly the same as 'go vet' and uses its passes.
-    - ineffassign      # Detects when assignments to existing variables are not used.
-    - importas         # Enforces consistent import aliases.
-    - misspell         # Finds commonly misspelled English words.
-    - prealloc         # Finds slice declarations that could potentially be pre-allocated.
-    - promlinter       # Check Prometheus metrics naming via promlint.
-    - sloglint         # Ensure consistent code style when using log/slog.
-    - sqlclosecheck    # Checks that sql.Rows, sql.Stmt, sqlx.NamedStmt, pgx.Query are closed.
-    - staticcheck      # It's a set of rules from staticcheck. It's not the same thing as the staticcheck binary.
-    - usetesting       # Reports uses of functions with replacement inside the testing package.
-    - testableexamples # Linter checks if examples are testable (have an expected output).
-    - testifylint      # Checks usage of github.com/stretchr/testify.
-    - tparallel        # Tparallel detects inappropriate usage of t.Parallel() method in your Go test codes.
-    - unconvert        # Remove unnecessary type conversions.
-    - unused           # Checks Go code for unused constants, variables, functions and types.
-    - wastedassign     # Finds wasted assignment statements.
-    - whitespace       # Whitespace is a linter that checks for unnecessary newlines at the start and end of functions, if, for, etc.
-    - zerologlint      # Detects the wrong usage of zerolog that a user forgets to dispatch with Send or Msg.
-    # Other linters are disabled, list of all is here: https://golangci-lint.run/usage/linters/
-
-formatters:
-  enable:
-    - gofmt      # Formats code according to Go standard formatting
-    - goimports  # Formats imports and groups them properly
-
-run:
-  timeout: 5m
-  modules-download-mode: vendor
-
-# output configuration options
-output:
-  formats:
-    text:
-      colors: true
-      print-linter-name: true
-      print-issued-lines: true
-
-issues:
-  # Maximum issues count per one linter.
-  # Set to 0 to disable.
-  # Default: 50
-  max-issues-per-linter: 50
-  # Maximum count of issues with the same text.
-  # Set to 0 to disable.
-  # Default: 3
-  max-same-issues: 15
-  # Show only new issues: if there are unstaged changes or untracked files,
-  # only those changes are analyzed, else only changes in HEAD~ are analyzed.
-  # It's a super-useful option for integration of golangci-lint into existing large codebase.
-  # It's not practical to fix all existing issues at the moment of integration:
-  # much better don't allow issues in new code.
-  #
-  # Default: false
-  new: true
-  # Show only new issues created after git revision `REV`.
-  # Default: ""
-  new-from-rev: d2a87e9b93456ad7f82417400f4209d513668487
-  # Show issues in any part of update files (requires new-from-rev or new-from-patch).
-  # Default: false
-  whole-files: true
-  # Which dirs to exclude: issues from them won't be reported.
-  # Can use regexp here: `generated.*`, regexp is applied on full path,
-  # including the path prefix if one is set.
-  # Default dirs are skipped independently of this option's value (see exclude-dirs-use-default).
-  # "/" will be replaced by current OS file path separator to properly work on Windows.
-  # Default: []
-  exclude-dirs:
-    - vendor
-
-linters-settings:
-  # Check exhaustiveness of enum switch statements.
-  exhaustive:
-    # Presence of "default" case in switch statements satisfies exhaustiveness,
-    # even if all enum members are not listed.
-    # Default: false
-    default-signifies-exhaustive: true
@@ -0,0 +1,8 @@
+# !/usr/bin/env bash
+
+cd /tmp
+git clone -q https://github.com/cloudflare/go
+cd go/src
+# https://github.com/cloudflare/go/tree/ec0a014545f180b0c74dfd687698657a9e86e310 is version go1.22.2-devel-cf
+git checkout -q ec0a014545f180b0c74dfd687698657a9e86e310
+./make.bash
@@ -0,0 +1,195 @@
+#!/bin/bash
+
+set -exo pipefail
+
+if [[ "$(uname)" != "Darwin" ]] ; then
+    echo "This should be run on macOS"
+    exit 1
+fi
+
+if [[ "amd64" != "${TARGET_ARCH}" && "arm64" != "${TARGET_ARCH}" ]]
+then
+  echo "TARGET_ARCH must be amd64 or arm64"
+  exit 1
+fi
+
+go version
+export GO111MODULE=on
+
+# build 'cloudflared-darwin-amd64.tgz'
+mkdir -p artifacts
+TARGET_DIRECTORY=".build"
+BINARY_NAME="cloudflared"
+VERSION=$(git describe --tags --always --dirty="-dev")
+PRODUCT="cloudflared"
+CODE_SIGN_PRIV="code_sign.p12"
+CODE_SIGN_CERT="code_sign.cer"
+INSTALLER_PRIV="installer.p12"
+INSTALLER_CERT="installer.cer"
+BUNDLE_ID="com.cloudflare.cloudflared"
+SEC_DUP_MSG="security: SecKeychainItemImport: The specified item already exists in the keychain."
+export PATH="$PATH:/usr/local/bin"
+FILENAME="$(pwd)/artifacts/cloudflared-darwin-$TARGET_ARCH.tgz"
+PKGNAME="$(pwd)/artifacts/cloudflared-$TARGET_ARCH.pkg"
+mkdir -p ../src/github.com/cloudflare/    
+cp -r . ../src/github.com/cloudflare/cloudflared
+cd ../src/github.com/cloudflare/cloudflared 
+
+# Add code signing private key to the key chain
+if [[ ! -z "$CFD_CODE_SIGN_KEY" ]]; then
+  if [[ ! -z "$CFD_CODE_SIGN_PASS" ]]; then
+    # write private key to disk and then import it keychain
+    echo -n -e ${CFD_CODE_SIGN_KEY} | base64 -D > ${CODE_SIGN_PRIV}
+    # we set || true  here and for every `security import invoke` because the  "duplicate SecKeychainItemImport" error 
+    # will cause set -e to exit 1. It is okay we do this because we deliberately handle this error in the lines below.
+    out=$(security import ${CODE_SIGN_PRIV} -A -P "${CFD_CODE_SIGN_PASS}" 2>&1) || true 
+    exitcode=$?
+    if [ -n "$out" ]; then
+      if [ $exitcode -eq 0 ]; then
+          echo "$out"
+      else
+          if [ "$out" != "${SEC_DUP_MSG}" ]; then
+              echo "$out" >&2
+              exit $exitcode
+          fi
+      fi
+    fi
+    rm ${CODE_SIGN_PRIV}
+  fi
+fi
+
+# Add code signing certificate to the key chain
+if [[ ! -z "$CFD_CODE_SIGN_CERT" ]]; then
+  # write certificate to disk and then import it keychain
+  echo -n -e ${CFD_CODE_SIGN_CERT} | base64 -D > ${CODE_SIGN_CERT}
+  out1=$(security import ${CODE_SIGN_CERT} -A 2>&1) || true
+  exitcode1=$?
+  if [ -n "$out1" ]; then
+    if [ $exitcode1 -eq 0 ]; then
+        echo "$out1"
+    else
+        if [ "$out1" != "${SEC_DUP_MSG}" ]; then
+            echo "$out1" >&2
+            exit $exitcode1
+        else 
+            echo "already imported code signing certificate"
+        fi
+    fi
+  fi
+  rm ${CODE_SIGN_CERT}
+fi
+
+# Add package signing private key to the key chain
+if [[ ! -z "$CFD_INSTALLER_KEY" ]]; then
+  if [[ ! -z "$CFD_INSTALLER_PASS" ]]; then
+    # write private key to disk and then import it into the keychain
+    echo -n -e ${CFD_INSTALLER_KEY} | base64 -D > ${INSTALLER_PRIV}
+    out2=$(security import ${INSTALLER_PRIV} -A -P "${CFD_INSTALLER_PASS}" 2>&1) || true
+    exitcode2=$?
+    if [ -n "$out2" ]; then
+      if [ $exitcode2 -eq 0 ]; then
+          echo "$out2"
+      else
+          if [ "$out2" != "${SEC_DUP_MSG}" ]; then
+              echo "$out2" >&2
+              exit $exitcode2
+          fi
+      fi
+    fi
+    rm ${INSTALLER_PRIV}
+  fi
+fi
+
+# Add package signing certificate to the key chain
+if [[ ! -z "$CFD_INSTALLER_CERT" ]]; then
+  # write certificate to disk and then import it keychain
+  echo -n -e ${CFD_INSTALLER_CERT} | base64 -D > ${INSTALLER_CERT}
+  out3=$(security import ${INSTALLER_CERT} -A 2>&1) || true
+  exitcode3=$?
+  if [ -n "$out3" ]; then
+    if [ $exitcode3 -eq 0 ]; then
+        echo "$out3"
+    else
+        if [ "$out3" != "${SEC_DUP_MSG}" ]; then
+            echo "$out3" >&2
+            exit $exitcode3
+        else 
+            echo "already imported installer certificate"
+        fi
+    fi
+  fi
+  rm ${INSTALLER_CERT}
+fi
+
+# get the code signing certificate name
+if [[ ! -z "$CFD_CODE_SIGN_NAME" ]]; then
+  CODE_SIGN_NAME="${CFD_CODE_SIGN_NAME}"
+else
+  if [[ -n "$(security find-certificate -c "Developer ID Application" | cut -d'"' -f 4 -s | grep "Developer ID Application:" | head -1)" ]]; then
+    CODE_SIGN_NAME=$(security find-certificate -c "Developer ID Application" | cut -d'"' -f 4 -s | grep "Developer ID Application:" | head -1)
+  else
+    CODE_SIGN_NAME=""
+  fi
+fi
+
+# get the package signing certificate name
+if [[ ! -z "$CFD_INSTALLER_NAME" ]]; then
+  PKG_SIGN_NAME="${CFD_INSTALLER_NAME}"
+else
+  if [[ -n "$(security find-certificate -c "Developer ID Installer" | cut -d'"' -f 4 -s | grep "Developer ID Installer:" | head -1)" ]]; then
+    PKG_SIGN_NAME=$(security find-certificate -c "Developer ID Installer" | cut -d'"' -f 4 -s | grep "Developer ID Installer:" | head -1)
+  else
+    PKG_SIGN_NAME=""
+  fi
+fi
+
+# cleanup the build directory because the previous execution might have failed without cleaning up.
+rm -rf "${TARGET_DIRECTORY}"
+export TARGET_OS="darwin"
+GOCACHE="$PWD/../../../../" GOPATH="$PWD/../../../../" CGO_ENABLED=1 make cloudflared
+
+# sign the cloudflared binary
+if [[ ! -z "$CODE_SIGN_NAME" ]]; then
+  codesign -s "${CODE_SIGN_NAME}" -f -v --timestamp --options runtime ${BINARY_NAME}
+
+ # notarize the binary
+ # TODO: TUN-5789
+fi
+
+ARCH_TARGET_DIRECTORY="${TARGET_DIRECTORY}/${TARGET_ARCH}-build"
+# creating build directory
+rm -rf $ARCH_TARGET_DIRECTORY
+mkdir -p "${ARCH_TARGET_DIRECTORY}"
+mkdir -p "${ARCH_TARGET_DIRECTORY}/contents"
+cp -r ".mac_resources/scripts" "${ARCH_TARGET_DIRECTORY}/scripts"
+
+# copy cloudflared into the build directory
+cp ${BINARY_NAME} "${ARCH_TARGET_DIRECTORY}/contents/${PRODUCT}"
+
+# compress cloudflared into a tar and gzipped file
+tar czf "$FILENAME" "${BINARY_NAME}"
+
+# build the installer package
+if [[ ! -z "$PKG_SIGN_NAME" ]]; then
+  pkgbuild --identifier com.cloudflare.${PRODUCT} \
+      --version ${VERSION} \
+      --scripts ${ARCH_TARGET_DIRECTORY}/scripts \
+      --root ${ARCH_TARGET_DIRECTORY}/contents \
+      --install-location /usr/local/bin \
+      --sign "${PKG_SIGN_NAME}" \
+      ${PKGNAME}
+
+      # notarize the package
+      # TODO: TUN-5789
+else
+    pkgbuild --identifier com.cloudflare.${PRODUCT} \
+      --version ${VERSION} \
+      --scripts ${ARCH_TARGET_DIRECTORY}/scripts \
+      --root ${ARCH_TARGET_DIRECTORY}/contents \
+      --install-location /usr/local/bin \
+      ${PKGNAME}
+fi
+
+# cleanup build directory because this script is not ran within containers,
+# which might lead to future issues in subsequent runs.
+rm -rf "${TARGET_DIRECTORY}"
@@ -0,0 +1,10 @@
+rm -rf /tmp/go
+export GOCACHE=/tmp/gocache
+rm -rf $GOCACHE
+
+./.teamcity/install-cloudflare-go.sh
+
+export PATH="/tmp/go/bin:$PATH"
+go version
+which go
+go env
@@ -0,0 +1,16 @@
+VERSION=$(git describe --tags --always --match "[0-9][0-9][0-9][0-9].*.*")
+echo $VERSION
+
+export TARGET_OS=windows
+# This controls the directory the built artifacts go into
+export ARTIFACT_DIR=built_artifacts/
+mkdir -p $ARTIFACT_DIR
+windowsArchs=("amd64" "386")
+for arch in ${windowsArchs[@]}; do
+    export TARGET_ARCH=$arch
+    # Copy exe into final directory
+    cp $ARTIFACT_DIR/cloudflared-windows-$arch.exe ./cloudflared.exe
+    make cloudflared-msi
+    # Copy msi into final directory
+    mv cloudflared-$VERSION-$arch.msi $ARTIFACT_DIR/cloudflared-windows-$arch.msi
+done
@@ -0,0 +1,28 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+# Relative path to working directory
+$CloudflaredDirectory = "go\src\github.com\cloudflare\cloudflared"
+
+cd $CloudflaredDirectory
+
+Write-Output "Building for amd64"
+$env:TARGET_OS = "windows"
+$env:CGO_ENABLED = 1
+$env:TARGET_ARCH = "amd64"
+$env:Path = "$Env:Temp\go\bin;$($env:Path)"
+
+go env
+go version
+
+& make cloudflared
+if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared for amd64" }
+copy .\cloudflared.exe .\cloudflared-windows-amd64.exe
+
+Write-Output "Building for 386"
+$env:CGO_ENABLED = 0
+$env:TARGET_ARCH = "386"
+make cloudflared
+if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared for 386" }
+copy .\cloudflared.exe .\cloudflared-windows-386.exe
@@ -0,0 +1,47 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+$WorkingDirectory = Get-Location
+$CloudflaredDirectory = "$WorkingDirectory\go\src\github.com\cloudflare\cloudflared"
+
+go env
+go version
+
+$env:TARGET_OS = "windows"
+$env:CGO_ENABLED = 1
+$env:TARGET_ARCH = "amd64"
+$env:Path = "$Env:Temp\go\bin;$($env:Path)"
+
+python --version
+python -m pip --version
+
+cd $CloudflaredDirectory
+
+go env
+go version
+
+Write-Output "Building cloudflared"
+
+& make cloudflared
+if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared" }
+
+echo $LASTEXITCODE
+
+Write-Output "Running unit tests"
+
+# Not testing with race detector because of https://github.com/golang/go/issues/61058
+# We already test it on other platforms
+& go test -failfast -mod=vendor ./...
+if ($LASTEXITCODE -ne 0) { throw "Failed unit tests" }
+
+Write-Output "Running component tests"
+
+python -m pip --disable-pip-version-check install --upgrade -r component-tests/requirements.txt
+python component-tests/setup.py --type create
+python -m pytest component-tests -o log_cli=true --log-cli-level=INFO
+if ($LASTEXITCODE -ne 0) {
+    python component-tests/setup.py --type cleanup
+    throw "Failed component tests"
+}
+python component-tests/setup.py --type cleanup
@@ -0,0 +1,16 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+Write-Output "Downloading cloudflare go..."
+
+Set-Location "$Env:Temp"
+
+git clone -q https://github.com/cloudflare/go
+Write-Output "Building go..."
+cd go/src
+# https://github.com/cloudflare/go/tree/ec0a014545f180b0c74dfd687698657a9e86e310 is version go1.22.2-devel-cf
+git checkout -q ec0a014545f180b0c74dfd687698657a9e86e310
+& ./make.bat
+
+Write-Output "Installed"
@@ -0,0 +1,20 @@
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+$GoMsiVersion = "go1.22.2.windows-amd64.msi"
+
+Write-Output "Downloading go installer..."
+
+Set-Location "$Env:Temp"
+
+(New-Object System.Net.WebClient).DownloadFile(
+    "https://go.dev/dl/$GoMsiVersion",
+    "$Env:Temp\$GoMsiVersion"
+)
+
+Write-Output "Installing go..."
+Install-Package "$Env:Temp\$GoMsiVersion" -Force
+
+# Go installer updates global $PATH
+go env
+
+Write-Output "Installed"
@@ -1,2 +0,0 @@
-# Add vulnerability IDs (e.g., GO-2022-0450) to ignore, one per line.
-# You can also add comments on the same line after the ID.
@@ -1,303 +0,0 @@
-# Cloudflared
-
-Cloudflare's command-line tool and networking daemon written in Go.
-Production-grade tunneling and network connectivity services used by millions of
-developers and organizations worldwide.
-
-## Essential Commands
-
-### Build & Test (Always run before commits)
-
-```bash
-# Full development check (run before any commit)
-make test lint
-
-# Build for current platform
-make cloudflared
-
-# Run all unit tests with coverage
-make test
-make cover
-
-# Run specific test
-go test -run TestFunctionName ./path/to/package
-
-# Run tests with race detection
-go test -race ./...
-```
-
-### Platform-Specific Builds
-
-```bash
-# Linux
-TARGET_OS=linux TARGET_ARCH=amd64 make cloudflared
-
-# Windows
-TARGET_OS=windows TARGET_ARCH=amd64 make cloudflared
-
-# macOS ARM64
-TARGET_OS=darwin TARGET_ARCH=arm64 make cloudflared
-
-# FIPS compliant build
-FIPS=true make cloudflared
-```
-
-### Code Quality & Formatting
-
-```bash
-# Run linter (38+ enabled linters)
-make lint
-
-# Auto-fix formatting
-make fmt
-gofmt -w .
-goimports -w .
-
-# Security scanning
-make vet
-
-# Component tests (Python integration tests)
-cd component-tests && python -m pytest test_file.py::test_function_name
-```
-
-Notes on linting:
-
- `.golangci.yaml` is configured with `new-from-rev` and `whole-files: true`.
-  Touching a file triggers linting of the ENTIRE file, not just the changed
-  hunks. Expect to fix pre-existing issues in files you modify, or add
-  targeted `// nolint: <linter>` comments with a short justification.
- Prefer `defer func() { _ = resource.Close() }()` over `defer resource.Close()`
-  for `io.Closer` values whose error truly does not matter — this satisfies
-  `errcheck` without hiding real failures elsewhere.
-
-## Project Knowledge
-
-### Package Structure
-
- Use meaningful package names that reflect functionality
- Package names should be lowercase, single words when possible
- Avoid generic names like `util`, `common`, `helper`
-
-#### Well-known shared packages
-
- `crypto/`: Single source of truth for TLS curve preferences and other
-  cryptographic primitives shared by every edge-facing transport. Import as
-  `cfdcrypto "github.com/cloudflare/cloudflared/crypto"` to avoid colliding
-  with the standard library's `crypto` package. Do NOT duplicate TLS curve
-  or cipher selection logic in other packages.
- `tlsconfig/`: Builds the base `*tls.Config` used for edge connections
-  (`CreateTunnelConfig`) and loads origin/CA pools. Curve selection is
-  intentionally NOT set here; it is applied per-connection from the
-  `crypto/` package so the same config can be cloned and reused across
-  protocols.
- `features/`: Runtime feature flags including `PostQuantumMode`
-  (`PostQuantumPrefer` = default, `PostQuantumStrict` = `--post-quantum`).
- `fips/`: Build-tag driven FIPS detection. Only `fips.IsFipsEnabled()` is
-  exposed; never branch on `fipsEnabled` inside a function if the two
-  branches return the same value.
-
-### Function and Method Guidelines
-
-```go
-// Good: Clear purpose, proper error handling
-func (c *Connection) HandleRequest(ctx context.Context, req *http.Request) error {
-    if req == nil {
-        return errors.New("request cannot be nil")
-    }
-    // Implementation...
-    return nil
-}
-```
-
-### Error Handling
-
- Always handle errors explicitly, never ignore them
- Use `fmt.Errorf` for error wrapping
- Create meaningful error messages with context
- Use error variables for common errors
-
-```go
-// Good error handling patterns
-if err != nil {
-    return fmt.Errorf("failed to process connection: %w", err)
-}
-```
-
-### Logging Standards
-
- Use `github.com/rs/zerolog` for structured logging
- Include relevant context fields
- Use appropriate log levels (Debug, Info, Warn, Error)
-
-```go
-logger.Info().
-    Str("tunnelID", tunnel.ID).
-    Int("connIndex", connIndex).
-    Msg("Connection established")
-```
-
-### Testing Patterns
-
- Use `github.com/stretchr/testify` for assertions
- Test files end with `_test.go`
- Use table-driven tests for multiple scenarios
- Always use `t.Parallel()` for parallel-safe tests
- Use meaningful test names that describe behavior
-
-```go
-func TestMetricsListenerCreation(t *testing.T) {
-    t.Parallel()
-    // Test implementation
-    assert.Equal(t, expected, actual)
-    require.NoError(t, err)
-}
-```
-
-### Constants and Variables
-
-```go
-const (
-    MaxGracePeriod       = time.Minute * 3
-    MaxConcurrentStreams = math.MaxUint32
-    LogFieldConnIndex    = "connIndex"
-)
-
-var (
-    // Group related variables
-    switchingProtocolText = fmt.Sprintf("%d %s", http.StatusSwitchingProtocols, http.StatusText(http.StatusSwitchingProtocols))
-    flushableContentTypes = []string{sseContentType, grpcContentType, sseJsonContentType}
-)
-```
-
-### Type Definitions
-
- Define interfaces close to their usage
- Keep interfaces small and focused
- Use descriptive names for complex types
-
-```go
-type TunnelConnection interface {
-    Serve(ctx context.Context) error
-}
-
-type TunnelProperties struct {
-    Credentials    Credentials
-    QuickTunnelUrl string
-}
-```
-
-## Key Architectural Patterns
-
-### Context Usage
-
- Always accept `context.Context` as first parameter for long-running operations
- Respect context cancellation in loops and blocking operations
- Pass context through call chains
-
-### Concurrency
-
- Use channels for goroutine communication
- Protect shared state with mutexes
- Prefer `sync.RWMutex` for read-heavy workloads
- `*tls.Config` values stored in shared maps (e.g.
-  `TunnelConfig.EdgeTLSConfigs`) must be `Clone()`d before mutating
-  per-connection fields like `CurvePreferences` or `NextProtos`. Writing
-  through the shared pointer races with concurrent connection attempts.
-
-### TLS & Post-Quantum key exchange
-
- Per-connection TLS configuration for edge connections is built via
-  `cfdcrypto.TLSConfigWithCurvePreferences(tlsConfig, pqMode)`. It clones
-  the provided `*tls.Config` and sets `CurvePreferences` based on `pqMode`,
-  so callers never need to clone or mutate `CurvePreferences` themselves.
-  Do NOT reach for the package-private `getCurvePreferences` helper; the
-  exported `TLSConfigWithCurvePreferences` is the only supported entry
-  point.
- Two PQ modes are supported and apply identically to QUIC and HTTP/2:
-  - `PostQuantumPrefer` (default): `[X25519MLKEM768, P256Kyber768Draft00, CurveP256]`
-  - `PostQuantumStrict` (`--post-quantum`): `[X25519MLKEM768, P256Kyber768Draft00]`
- FIPS and non-FIPS builds use the same curve list. Do NOT reintroduce a
-  `fipsEnabled` branch in curve-selection code; if the two modes ever
-  diverge, express the divergence inside `crypto/` so call sites remain
-  untouched.
- HTTP/2 supports post-quantum handshakes. Never re-add a
-  `PostQuantumStrict`-based rejection to H2 code paths, and never force
-  `--post-quantum` to select QUIC-only in protocol selection.
-
-### Configuration
-
- Use structured configuration with validation
- Support both file-based and CLI flag configuration
- Provide sensible defaults
-
-### Metrics and Observability
-
- Instrument code with Prometheus metrics
- Use OpenTelemetry for distributed tracing
- Include structured logging with relevant context
-
-## Boundaries
-
-### ✅ Always Do
-
- Run `make test lint` before any commit
- Handle all errors explicitly with proper context
- Use `github.com/rs/zerolog` for all logging
- Add `t.Parallel()` to all parallel-safe tests
- Follow the import grouping conventions
- Use meaningful variable and function names
- Include context.Context for long-running operations
- Close resources in defer statements
-
-### ⚠️ Ask First Before
-
- Adding new dependencies to go.mod
- Modifying CI/CD configuration files
- Changing build system or Makefile
- Modifying component test infrastructure
- Adding new linter rules or changing golangci-lint config
- Making breaking changes to public APIs
- Changing logging levels or structured logging fields
-
-### 🚫 Never Do
-
- Ignore errors without explicit handling (`_ = err`)
- Use generic package names (`util`, `helper`, `common`)
- Commit code that fails `make test lint`
- Use `fmt.Print*` instead of structured logging
- Modify vendor dependencies directly
- Commit secrets, credentials, or sensitive data
- Use deprecated or unsafe Go patterns
- Skip testing for new functionality
- Remove existing tests unless they're genuinely invalid
-
-## Dependencies Management
-
- Use Go modules (`go.mod`) exclusively
- Vendor dependencies for reproducible builds
- Keep dependencies up-to-date and secure
- Prefer standard library when possible
- Cloudflared uses a fork of quic-go always check release notes before bumping
-  this dependency.
-
-## Security Considerations
-
- FIPS compliance support available
- Vulnerability scanning integrated in CI
- Credential handling follows security best practices
- Network security with TLS/QUIC protocols
- Regular security audits and updates
- Post quantum encryption
-
-## Common Patterns to Follow
-
-1. **Graceful shutdown**: Always implement proper cleanup
-2. **Resource management**: Close resources in defer statements
-3. **Error propagation**: Wrap errors with meaningful context
-4. **Configuration validation**: Validate inputs early
-5. **Logging consistency**: Use structured logging throughout
-6. **Testing coverage**: Aim for comprehensive test coverage
-7. **Documentation**: Comment exported functions and types
-
-Remember: This is a mission-critical networking tool used in production by many
-organizations. Code quality, security, and reliability are paramount.
@@ -1,38 +1,3 @@
-## 2026.4.0
-### Breaking Change
- The default value of `--edge-ip-version` has changed from `4` to `auto`. This means cloudflared will now use whichever address family (IPv4 or IPv6) the system resolver returns first, instead of always preferring IPv4. Users who require IPv4-only connections should explicitly set `--edge-ip-version 4`.
-
-## 2026.2.0
-### Breaking Change
- Removes the `proxy-dns` feature from cloudflared. This feature allowed running a local DNS over HTTPS (DoH) proxy.
-  Users who relied on this functionality should migrate to alternative solutions.
-  
-  Removed commands and flags:
-  - `cloudflared proxy-dns`
-  - `cloudflared tunnel proxy-dns` 
-  - `--proxy-dns`, `--proxy-dns-port`, `--proxy-dns-address`, `--proxy-dns-upstream`, `--proxy-dns-max-upstream-conns`, `--proxy-dns-bootstrap`
-  - `resolver` section in configuration file
-
-## 2025.7.1
-### Notices
- `cloudflared` will no longer officially support Debian and Ubuntu distros that reached end-of-life: `buster`, `bullseye`, `impish`, `trusty`.
-
-## 2025.1.1
-### New Features
- This release introduces the use of new Post Quantum curves and the ability to use Post Quantum curves when running tunnels with the QUIC protocol this applies to non-FIPS and FIPS builds.
-
-## 2024.12.2
-### New Features
- This release introduces the ability to collect troubleshooting information from one instance of cloudflared running on the local machine. The command can be executed as `cloudflared tunnel diag`.
-
-## 2024.12.1
-### Notices
- The use of the `--metrics` is still honoured meaning that if this flag is set the metrics server will try to bind it, however, this version includes a change that makes the metrics server bind to a port with a semi-deterministic approach. If the metrics flag is not present the server will bind to the first available port of the range 20241 to 20245. In case of all ports being unavailable then the fallback is to bind to a random port.
-
-## 2024.10.0
-### Bug Fixes
- We fixed a bug related to `--grace-period`. Tunnels that use QUIC as transport weren't abiding by this waiting period before forcefully closing the connections to the edge. From now on, both QUIC and HTTP2 tunnels will wait for either the grace period to end (defaults to 30 seconds) or until the last in-flight request is handled. Users that wish to maintain the previous behavior should set `--grace-period` to 0 if `--protocol` is set to `quic`. This will force `cloudflared` to shutdown as soon as either SIGTERM or SIGINT is received.
-
 ## 2024.2.1
 ### Notices
 - Starting from this version, tunnel diagnostics will be enabled by default. This will allow the engineering team to remotely get diagnostics from cloudflared during debug activities. Users still have the capability to opt-out of this feature by defining `--management-diagnostics=false` (or env `TUNNEL_MANAGEMENT_DIAGNOSTICS`).
@@ -296,7 +261,7 @@ of uptime. Previous cloudflared versions will soon be unable to run legacy tempo
 ### Bug Fixes

 - Tunnel create and delete commands no longer use path to credentials from the configuration file.
-  If you need to place tunnel credentials file at a specific location, you must use `--credentials-file` flag.
+  If you need ot place tunnel credentials file at a specific location, you must use `--credentials-file` flag.
 - Access ssh-gen creates properly named keys for SSH short lived certs.


@@ -1,37 +1,32 @@
 # use a builder image for building cloudflare
 ARG TARGET_GOOS
 ARG TARGET_GOARCH
-FROM golang:1.26.4 AS builder
+FROM golang:1.22.2 as builder
 ENV GO111MODULE=on \
-  CGO_ENABLED=0 \
-  TARGET_GOOS=${TARGET_GOOS} \
-  TARGET_GOARCH=${TARGET_GOARCH} \
-  # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual
-  # which changes how cloudflared binds the metrics server
-  CONTAINER_BUILD=1
-
+    CGO_ENABLED=0 \
+    TARGET_GOOS=${TARGET_GOOS} \
+    TARGET_GOARCH=${TARGET_GOARCH}

 WORKDIR /go/src/github.com/cloudflare/cloudflared/

 # copy our sources into the builder image
 COPY . .

+RUN .teamcity/install-cloudflare-go.sh
+
 # compile cloudflared
-RUN make cloudflared
+RUN PATH="/tmp/go/bin:$PATH" make cloudflared

 # use a distroless base image with glibc
-FROM gcr.io/distroless/base-debian13:nonroot@sha256:b78832f41c8128046807c24840ebee4f1c18ba7870eed423d8750c272c15e147
+FROM gcr.io/distroless/base-debian11:nonroot

 LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared"

 # copy our compiled binary
 COPY --from=builder --chown=nonroot /go/src/github.com/cloudflare/cloudflared/cloudflared /usr/local/bin/

-# run as nonroot user
-# We need to use numeric user id's because Kubernetes doesn't support strings:
-# https://github.com/kubernetes/kubernetes/blob/v1.33.2/pkg/kubelet/kuberuntime/security_context_others.go#L49
-# The `nonroot` user maps to `65532`, from: https://github.com/GoogleContainerTools/distroless/blob/main/common/variables.bzl#L18
-USER 65532:65532
+# run as non-privileged user
+USER nonroot

 # command / entrypoint of container
 ENTRYPOINT ["cloudflared", "--no-autoupdate"]
@@ -1,32 +1,28 @@
 # use a builder image for building cloudflare
-FROM golang:1.26.4 AS builder
+FROM golang:1.22.2 as builder
 ENV GO111MODULE=on \
-  CGO_ENABLED=0 \
-  # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual
-  # which changes how cloudflared binds the metrics server
-  CONTAINER_BUILD=1 
+    CGO_ENABLED=0

 WORKDIR /go/src/github.com/cloudflare/cloudflared/

 # copy our sources into the builder image
 COPY . .

+RUN .teamcity/install-cloudflare-go.sh
+
 # compile cloudflared
-RUN GOOS=linux GOARCH=amd64 make cloudflared
+RUN GOOS=linux GOARCH=amd64 PATH="/tmp/go/bin:$PATH" make cloudflared

 # use a distroless base image with glibc
-FROM gcr.io/distroless/base-debian13:nonroot-amd64@sha256:ce2a20e0e277b7d913aa8bcfa098fc2a543dc08028f7393434963fa24b39ea81
+FROM gcr.io/distroless/base-debian11:nonroot

 LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared"

 # copy our compiled binary
 COPY --from=builder --chown=nonroot /go/src/github.com/cloudflare/cloudflared/cloudflared /usr/local/bin/

-# run as nonroot user
-# We need to use numeric user id's because Kubernetes doesn't support strings:
-# https://github.com/kubernetes/kubernetes/blob/v1.33.2/pkg/kubelet/kuberuntime/security_context_others.go#L49
-# The `nonroot` user maps to `65532`, from: https://github.com/GoogleContainerTools/distroless/blob/main/common/variables.bzl#L18
-USER 65532:65532
+# run as non-privileged user
+USER nonroot

 # command / entrypoint of container
 ENTRYPOINT ["cloudflared", "--no-autoupdate"]
@@ -1,32 +1,28 @@
 # use a builder image for building cloudflare
-FROM golang:1.26.4 AS builder
+FROM golang:1.22.2 as builder
 ENV GO111MODULE=on \
-  CGO_ENABLED=0 \
-  # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual
-  # which changes how cloudflared binds the metrics server
-  CONTAINER_BUILD=1
+    CGO_ENABLED=0

 WORKDIR /go/src/github.com/cloudflare/cloudflared/

 # copy our sources into the builder image
 COPY . .

+RUN .teamcity/install-cloudflare-go.sh
+
 # compile cloudflared
-RUN GOOS=linux GOARCH=arm64 make cloudflared
+RUN GOOS=linux GOARCH=arm64 PATH="/tmp/go/bin:$PATH" make cloudflared

 # use a distroless base image with glibc
-FROM gcr.io/distroless/base-debian13:nonroot-arm64@sha256:7a4876f88e7fe3190972c274b679b3473f61e8d990a4dce3627961b3e22a0eaf
+FROM gcr.io/distroless/base-debian11:nonroot-arm64

 LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared"

 # copy our compiled binary
 COPY --from=builder --chown=nonroot /go/src/github.com/cloudflare/cloudflared/cloudflared /usr/local/bin/

-# run as nonroot user
-# We need to use numeric user id's because Kubernetes doesn't support strings:
-# https://github.com/kubernetes/kubernetes/blob/v1.33.2/pkg/kubelet/kuberuntime/security_context_others.go#L49
-# The `nonroot` user maps to `65532`, from: https://github.com/GoogleContainerTools/distroless/blob/main/common/variables.bzl#L18
-USER 65532:65532
+# run as non-privileged user
+USER nonroot

 # command / entrypoint of container
 ENTRYPOINT ["cloudflared", "--no-autoupdate"]
@@ -24,22 +24,12 @@ else
 	DEB_PACKAGE_NAME := $(BINARY_NAME)
 endif

-# Use git in windows since we don't have access to the `date` tool
-ifeq ($(TARGET_OS), windows)
-	DATE := $(shell git log -1 --format="%ad" --date=format-local:'%Y-%m-%dT%H:%M UTC' -- RELEASE_NOTES)
-else
-	DATE := $(shell date -u -r RELEASE_NOTES '+%Y-%m-%d-%H:%M UTC')
-endif
-
+DATE          := $(shell date -u '+%Y-%m-%d-%H%M UTC')
 VERSION_FLAGS := -X "main.Version=$(VERSION)" -X "main.BuildTime=$(DATE)"
 ifdef PACKAGE_MANAGER
 	VERSION_FLAGS := $(VERSION_FLAGS) -X "github.com/cloudflare/cloudflared/cmd/cloudflared/updater.BuiltForPackageManager=$(PACKAGE_MANAGER)"
 endif

-ifdef CONTAINER_BUILD
-	VERSION_FLAGS := $(VERSION_FLAGS) -X "github.com/cloudflare/cloudflared/metrics.Runtime=virtual"
-endif
-
 LINK_FLAGS :=
 ifeq ($(FIPS), true)
 	LINK_FLAGS := -linkmode=external -extldflags=-static $(LINK_FLAGS)
@@ -62,6 +52,8 @@ PACKAGE_DIR    := $(CURDIR)/packaging
 PREFIX         := /usr
 INSTALL_BINDIR := $(PREFIX)/bin/
 INSTALL_MANDIR := $(PREFIX)/share/man/man1/
+CF_GO_PATH     := /tmp/go
+PATH           := $(CF_GO_PATH)/bin:$(PATH)

 LOCAL_ARCH ?= $(shell uname -m)
 ifneq ($(GOARCH),)
@@ -70,8 +62,6 @@ else ifeq ($(LOCAL_ARCH),x86_64)
    TARGET_ARCH ?= amd64
 else ifeq ($(LOCAL_ARCH),amd64)
    TARGET_ARCH ?= amd64
-else ifeq ($(LOCAL_ARCH),386)
-    TARGET_ARCH ?= 386
 else ifeq ($(LOCAL_ARCH),i686)
    TARGET_ARCH ?= amd64
 else ifeq ($(shell echo $(LOCAL_ARCH) | head -c 5),armv8)
@@ -119,7 +109,7 @@ ifneq ($(TARGET_ARM), )
 	ARM_COMMAND := GOARM=$(TARGET_ARM)
 endif

-ifeq ($(TARGET_ARM), 7)
+ifeq ($(TARGET_ARM), 7) 
 	PACKAGE_ARCH := armhf
 else
 	PACKAGE_ARCH := $(TARGET_ARCH)
@@ -128,8 +118,6 @@ endif
 #for FIPS compliance, FPM defaults to MD5.
 RPM_DIGEST := --rpm-digest sha256

-GO_TEST_LOG_OUTPUT = /tmp/gotest.log
-
 .PHONY: all
 all: cloudflared test

@@ -137,17 +125,15 @@ all: cloudflared test
 clean:
 	go clean

-.PHONY: vulncheck
-vulncheck:
-	@./.ci/scripts/vuln-check.sh
-
 .PHONY: cloudflared
 cloudflared:
 ifeq ($(FIPS), true)
 	$(info Building cloudflared with go-fips)
+	cp -f fips/fips.go.linux-amd64 cmd/cloudflared/fips.go
 endif
 	GOOS=$(TARGET_OS) GOARCH=$(TARGET_ARCH) $(ARM_COMMAND) go build -mod=vendor $(GO_BUILD_TAGS) $(LDFLAGS) $(IMPORT_PATH)/cmd/cloudflared
 ifeq ($(FIPS), true)
+	rm -f cmd/cloudflared/fips.go
 	./check-fips.sh cloudflared
 endif

@@ -159,16 +145,14 @@ container:
 generate-docker-version:
 	echo latest $(VERSION) > versions

-.PHONY: generate-internal-image-version
-generate-internal-image-version:
-	echo $(VERSION) > versions-internal
-

 .PHONY: test
 test: vet
-	$Q go test -json -v -mod=vendor -race $(LDFLAGS) ./... 2>&1 | tee $(GO_TEST_LOG_OUTPUT)
-ifneq ($(FIPS), true)
-	@go run -mod=readonly github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest -input $(GO_TEST_LOG_OUTPUT)
+ifndef CI
+	go test -v -mod=vendor -race $(LDFLAGS) ./...
+else
+	@mkdir -p .cover
+	go test -v -mod=vendor -race $(LDFLAGS) -coverprofile=".cover/c.out" ./...
 endif

 .PHONY: cover
@@ -181,22 +165,23 @@ cover:
 	# Generate the HTML report that can be viewed from the browser in CI.
 	$Q go tool cover -html ".cover/c.out" -o .cover/all.html

-.PHONY: fuzz
-fuzz:
-	@go test -fuzz=FuzzIPDecoder -fuzztime=600s ./packet
-	@go test -fuzz=FuzzICMPDecoder -fuzztime=600s ./packet
-	@go test -fuzz=FuzzSessionWrite -fuzztime=600s ./quic/v3
-	@go test -fuzz=FuzzSessionRead -fuzztime=600s ./quic/v3
-	@go test -fuzz=FuzzRegistrationDatagram -fuzztime=600s ./quic/v3
-	@go test -fuzz=FuzzPayloadDatagram -fuzztime=600s ./quic/v3
-	@go test -fuzz=FuzzRegistrationResponseDatagram -fuzztime=600s ./quic/v3
-	@go test -fuzz=FuzzNewIdentity -fuzztime=600s ./tracing
-	@go test -fuzz=FuzzNewAccessValidator -fuzztime=600s ./validation
+.PHONY: test-ssh-server
+test-ssh-server:
+	docker-compose -f ssh_server_tests/docker-compose.yml up
+
+.PHONY: install-go
+install-go:
+	rm -rf ${CF_GO_PATH}
+	./.teamcity/install-cloudflare-go.sh
+
+.PHONY: cleanup-go
+cleanup-go:
+	rm -rf ${CF_GO_PATH}

 cloudflared.1: cloudflared_man_template
 	sed -e 's/\$${VERSION}/$(VERSION)/; s/\$${DATE}/$(DATE)/' cloudflared_man_template > cloudflared.1

-install: cloudflared cloudflared.1
+install: install-go cloudflared cloudflared.1 cleanup-go
 	mkdir -p $(DESTDIR)$(INSTALL_BINDIR) $(DESTDIR)$(INSTALL_MANDIR)
 	install -m755 cloudflared $(DESTDIR)$(INSTALL_BINDIR)/cloudflared
 	install -m644 cloudflared.1 $(DESTDIR)$(INSTALL_MANDIR)/cloudflared.1
@@ -225,28 +210,23 @@ cloudflared-deb: cloudflared cloudflared.1
 cloudflared-rpm: cloudflared cloudflared.1
 	$(call build_package,rpm)

+.PHONY: cloudflared-pkg
+cloudflared-pkg: cloudflared cloudflared.1
+	$(call build_package,osxpkg)
+
 .PHONY: cloudflared-msi
 cloudflared-msi:
 	wixl --define Version=$(VERSION) --define Path=$(EXECUTABLE_PATH) --output cloudflared-$(VERSION)-$(TARGET_ARCH).msi cloudflared.wxs

-.PHONY: github-release-dryrun
-github-release-dryrun:
-	python3 github_release.py --path $(PWD)/built_artifacts --release-version $(VERSION) --dry-run
-
 .PHONY: github-release
 github-release:
-	python3 github_release.py --path $(PWD)/artifacts/ --release-version $(VERSION)
+	python3 github_release.py --path $(PWD)/built_artifacts --release-version $(VERSION)
 	python3 github_message.py --release-version $(VERSION)

 .PHONY: r2-linux-release
 r2-linux-release:
 	python3 ./release_pkgs.py

-.PHONY: r2-next-linux-release
-# Publishes to a separate R2 repository during GPG key rollover, using dual-key signing.
-r2-next-linux-release:
-	python3 ./release_pkgs.py --upload-repo-file
-
 .PHONY: capnp
 capnp:
 	which capnp  # https://capnproto.org/install.html
@@ -255,47 +235,8 @@ capnp:

 .PHONY: vet
 vet:
-	$Q go vet -mod=vendor github.com/cloudflare/cloudflared/...
+	go vet -mod=vendor github.com/cloudflare/cloudflared/...

 .PHONY: fmt
 fmt:
-	@goimports -l -w -local github.com/cloudflare/cloudflared $$(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto)
-	@go fmt $$(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto)
-
-.PHONY: fmt-check
-fmt-check:
-	@./.ci/scripts/fmt-check.sh
-
-.PHONY: lint
-lint:
-	@golangci-lint run
-
-.PHONY: mocks
-mocks:
-	go generate mocks/mockgen.go
-
-.PHONY: ci-build
-ci-build:
-	@GOOS=linux GOARCH=amd64 $(MAKE) cloudflared
-	@mkdir -p artifacts
-	@mv cloudflared artifacts/cloudflared
-
-.PHONY: ci-fips-build
-ci-fips-build:
-	@FIPS=true GOOS=linux GOARCH=amd64 $(MAKE) cloudflared
-	@mkdir -p artifacts
-	@mv cloudflared artifacts/cloudflared
-
-.PHONY: ci-test
-ci-test: fmt-check lint test
-	@go run -mod=readonly github.com/jstemmer/go-junit-report/v2@latest -in $(GO_TEST_LOG_OUTPUT) -parser gojson -out report.xml -set-exit-code
-
-.PHONY: ci-fips-test
-ci-fips-test:
-	@FIPS=true $(MAKE) ci-test
-
-.PHONY: install-hooks
-install-hooks:
-	git config core.hooksPath .githooks
-	@echo "Git hooks installed from .githooks/"
-	@echo "Pre-push hook will run: make fmt-check lint test"
+	goimports -l -w -local github.com/cloudflare/cloudflared $$(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto)
@@ -3,14 +3,14 @@
 Contains the command-line client for Cloudflare Tunnel, a tunneling daemon that proxies traffic from the Cloudflare network to your origins.
 This daemon sits between Cloudflare network and your origin (e.g. a webserver). Cloudflare attracts client requests and sends them to you
 via this daemon, without requiring you to poke holes on your firewall --- your origin can remain as closed as possible.
-Extensive documentation can be found in the [Cloudflare Tunnel section](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel) of the Cloudflare Docs.
+Extensive documentation can be found in the [Cloudflare Tunnel section](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps) of the Cloudflare Docs.
 All usages related with proxying to your origins are available under `cloudflared tunnel help`.

 You can also use `cloudflared` to access Tunnel origins (that are protected with `cloudflared tunnel`) for TCP traffic
 at Layer 4 (i.e., not HTTP/websocket), which is relevant for use cases such as SSH, RDP, etc.
 Such usages are available under `cloudflared access help`.

-You can instead use [WARP client](https://developers.cloudflare.com/warp-client/)
+You can instead use [WARP client](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/configuration/private-networks)
 to access private origins behind Tunnels for Layer 4 traffic without requiring `cloudflared access` commands on the client side.


@@ -19,71 +19,40 @@ to access private origins behind Tunnels for Layer 4 traffic without requiring `
 Before you use Cloudflare Tunnel, you'll need to complete a few steps in the Cloudflare dashboard: you need to add a
 website to your Cloudflare account. Note that today it is possible to use Tunnel without a website (e.g. for private
 routing), but for legacy reasons this requirement is still necessary:
-1. [Add a website to Cloudflare](https://developers.cloudflare.com/fundamentals/manage-domains/add-site/)
-2. [Change your domain nameservers to Cloudflare](https://developers.cloudflare.com/dns/zone-setups/full-setup/setup/)
+1. [Add a website to Cloudflare](https://support.cloudflare.com/hc/en-us/articles/201720164-Creating-a-Cloudflare-account-and-adding-a-website)
+2. [Change your domain nameservers to Cloudflare](https://support.cloudflare.com/hc/en-us/articles/205195708)


 ## Installing `cloudflared`

 Downloads are available as standalone binaries, a Docker image, and Debian, RPM, and Homebrew packages. You can also find releases [here](https://github.com/cloudflare/cloudflared/releases) on the `cloudflared` GitHub repository.

-* You can [install on macOS](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/#macos) via Homebrew or by downloading the [latest Darwin amd64 release](https://github.com/cloudflare/cloudflared/releases)
-* Binaries, Debian, and RPM packages for Linux [can be found here](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/#linux)
+* You can [install on macOS](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation#macos) via Homebrew or by downloading the [latest Darwin amd64 release](https://github.com/cloudflare/cloudflared/releases)
+* Binaries, Debian, and RPM packages for Linux [can be found here](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation#linux)
 * A Docker image of `cloudflared` is [available on DockerHub](https://hub.docker.com/r/cloudflare/cloudflared)
-* You can install on Windows machines with the [steps here](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/#windows)
-* To build from source, install the required version of go, mentioned in the [Development](#development) section below. Then you can run `make cloudflared`.
+* You can install on Windows machines with the [steps here](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation#windows)
+* To build from source, first you need to download the go toolchain by running `./.teamcity/install-cloudflare-go.sh` and follow the output. Then you can run `make cloudflared`

-User documentation for Cloudflare Tunnel can be found at https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/
+User documentation for Cloudflare Tunnel can be found at https://developers.cloudflare.com/cloudflare-one/connections/connect-apps


 ## Creating Tunnels and routing traffic

 Once installed, you can authenticate `cloudflared` into your Cloudflare account and begin creating Tunnels to serve traffic to your origins.

-* Create a Tunnel with [these instructions](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/get-started/create-remote-tunnel/)
+* Create a Tunnel with [these instructions](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/create-tunnel)
 * Route traffic to that Tunnel:
-  * Via public [DNS records in Cloudflare](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/routing-to-tunnel/dns/)
-  * Or via a public hostname guided by a [Cloudflare Load Balancer](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/routing-to-tunnel/public-load-balancers/)
-  * Or from [WARP client private traffic](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/private-net/)
+  * Via public [DNS records in Cloudflare](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/routing-to-tunnel/dns)
+  * Or via a public hostname guided by a [Cloudflare Load Balancer](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/routing-to-tunnel/lb)
+  * Or from [WARP client private traffic](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/private-net/)


 ## TryCloudflare

-Want to test Cloudflare Tunnel before adding a website to Cloudflare? You can do so with TryCloudflare using the documentation [available here](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/do-more-with-tunnels/trycloudflare/).
+Want to test Cloudflare Tunnel before adding a website to Cloudflare? You can do so with TryCloudflare using the documentation [available here](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/run-tunnel/trycloudflare).

 ## Deprecated versions

-Cloudflare currently supports versions of cloudflared that are **within one year** of the most recent release. Breaking changes unrelated to feature availability may be introduced that will impact versions released more than one year ago. You can read more about upgrading cloudflared in our [developer documentation](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/update-cloudflared/).
+Cloudflare currently supports versions of cloudflared that are **within one year** of the most recent release. Breaking changes unrelated to feature availability may be introduced that will impact versions released more than one year ago. You can read more about upgrading cloudflared in our [developer documentation](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/#updating-cloudflared).

 For example, as of January 2023 Cloudflare will support cloudflared version 2023.1.1 to cloudflared 2022.1.1.
-
-## Development
-
-### Requirements
- [GNU Make](https://www.gnu.org/software/make/)
- [capnp](https://capnproto.org/install.html)
- [go >= 1.26](https://go.dev/doc/install)
- Optional tools:
-  - [capnpc-go](https://pkg.go.dev/zombiezen.com/go/capnproto2/capnpc-go)
-  - [goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)
-  - [golangci-lint](https://github.com/golangci/golangci-lint)
-  - [gomocks](https://pkg.go.dev/go.uber.org/mock)
-
-### Build
-To build cloudflared locally run `make cloudflared`
-
-### Test
-To locally run the tests run `make test`
-
-### Linting
-To format the code and keep a good code quality use `make fmt` and `make lint`
-
-### Mocks
-After changes on interfaces you might need to regenerate the mocks, so run `make mocks`
-
-### Git Hooks
-To avoid CI errors, you can install pre-push hooks that run linting and tests before each push:
-```bash
-make install-hooks
-```
-This will configure git to use the hooks in `.githooks/` that run `make fmt-check lint test` before each push.
@@ -1,353 +1,5 @@
-2026.7.3
- 2026-07-22 VULN-143514: Windows svc: use --token-file instead of --token
- 2026-07-22 fix: Bump golang.org/x/text and its dependencies to fix CVE
- 2026-07-20 TUN-10701: Use curves for prechecks
-
-2026.7.2
- 2026-07-15 VULN-118896: MacOS service: use --token-file instead of --token
- 2026-07-14 Update gcr.io/distroless/base-debian13:nonroot Docker digest to b78832f
- 2026-07-14 chore: Change internal image name
- 2026-07-14 Update gcr.io/distroless/base-debian13:nonroot-arm Docker digest to 7a4876f88
- 2026-07-13 VULN-118896: Linux service: Use --token-file instead of --token
- 2026-07-13 chore: Remove bookworm internal register publish
- 2026-07-13 Update gcr.io/distroless/base-debian13:nonroot-amd64 Docker digest to ce2a20e
-
-2026.7.1
- 2026-07-09 Revert "TUN-10621: Propagate max wait timeout"
-
-2026.7.0
- 2026-07-08 chore: Bump go-chi to version 5.3.1
- 2026-07-08 Revert "TUN-10557: Bump quic-go v0.59.1"
- 2026-07-01 TUN-10621: Test websocket path
- 2026-06-30 ci: add Semgrep OSS scanning workflow
- 2026-06-29 TUN-10621: Propagate max wait timeout
- 2026-06-29 Migrate config renovate.json
- 2026-06-25 chore: Fix renovate
- 2026-06-25 Pin dependencies
- 2026-06-25 Consolidate init-system detection into shared inits package
- 2026-06-24 Fix lint issues
- 2026-06-22 Add OpenRC support
- 2026-06-22 Fix broken installed-service detection in systemd uninstall
- 2026-06-18 TUN-10557: Bump quic-go v0.59.1
-
-2026.6.1
- 2026-06-18 TUN-10630: Fix precheck protocol override
- 2026-06-18 Revert "TUN-10557: Bump quic-go v0.59.1"
- 2026-06-16 chore: Fix warnings
- 2026-06-15 TUN-10612: Add renovate to cloudflared to update distroless images explicitely
- 2026-06-11 TUN-9251: Publish internal image
- 2026-05-26 TUN-10557: Bump quic-go v0.59.1
-
-2026.6.0
- 2026-06-08 TUN-10558: Bump go to v1.24.4, x/crypto to v0.52.0 and google.golang.org/grpc to v1.81.1
- 2026-06-01 TUN-10563: introduce QUICConnection interface
-
-2026.5.2
- 2026-05-26 TUN-10391: Avoid using fmt.Println
-
-2026.5.1
- 2026-05-22 fix: Bump go to 1.26.3 and go.opentelemetry.io/otel and go-jose/v4 to fix CVE's
- 2026-05-22 TUN-10391: Avoid blocking cloudflared due to logging
- 2026-05-22 TUN-10391: Add precheck integration tests
- 2026-05-14 TUN-10511: Revise --edge support for pre-checks
- 2026-05-13 fix: Update golang.org/x/net to v0.54.0
- 2026-05-13 TUN-10525: Add prechecks kill switch
-
-2026.5.0
- 2026-05-08 Bump golang.org/x/net from v0.40.0 to v0.53.0
- 2026-05-07 TUN-10507: Bump go and go-boring to 1.26.2
- 2026-05-07 TUN-10511: Add Static DNS Resolvers
- 2026-05-07 TUN-10390: Call prechecks
- 2026-05-07 TUN-10513: Disable /debug/pprof/cmdline endpoint
- 2026-05-06 TUN-10390: Fix missing TLS settings
- 2026-05-05 chore: Fix warnings
- 2026-05-04 TUN-10389: Implement main run method
- 2026-04-30 TUN-10388: Adding probe check
- 2026-04-30 TUN-10388 Implement dialers for connectivity checks
- 2026-04-30 TUN-10389: Improve probe functions
- 2026-04-29 SECENG-13496 update pkg docs for gokeyless to support multiple builds
- 2026-04-29 chore: Add pre-push hooks
- 2026-04-29 TUN-10388: Use pointer for suggested protocol
- 2026-04-27 TUN-10387: Add no-prechecks flag
- 2026-04-23 TUN-10386: Add Table Renderer
- 2026-04-21 AUTH-4699, AUTH-8460, TUN-10179: Vendor gopsutil/v4 for cross-platform process identification
- 2026-04-21 AUTH-4699, AUTH-8460, TUN-10179: Fix .lock file deletion race condition
- 2026-04-20 TUN-10413: Centralize TLS curve configuration in crypto/ and adopt X25519MLKEM768 for QUIC/H2
- 2026-04-15 TUN-10385: Add connectivity checks foundation
- 2026-04-14 chore: Fix errors in cmd
- 2026-04-14 TUN-10384: Probe TLS Helper
- 2026-04-14 TUN-10383: Set edge-ip-version to auto
- 2026-04-10 SECENG-13056 update gokeyless install instructions on pkg.cloudflare.com/index.html
- 2026-04-02 TUN-9952: Bump go to 1.26
-
-2026.3.0
- 2026-03-05 TUN-10292: Add cloudflared management token command
- 2026-03-03 chore: Addressing small fixes and typos
- 2026-03-03 fix: Update go-sentry and go-oidc to address CVE's
- 2026-02-24 TUN-10258: add agents.md
- 2026-02-23 TUN-10267: Update mods to fix CVE GO-2026-4394
- 2026-02-20 TUN-10247: Update tail command to use /management/logs endpoint
- 2026-02-11 TUN-9858: Add more information to proxy-dns removal message
-
-2026.2.0
- 2026-02-06 TUN-10216: TUN fix cloudflare vulnerabilities GO-2026-4340 and GO-2026-4341
- 2026-02-02 TUN-9858: Remove proxy-dns feature from cloudflared
-
-2026.1.2
- 2026-01-23 Revert "TUN-9863: Update pipelines to use cloudflared EV Certificate"
- 2026-01-21 Revert "TUN-9886 notarize cloudflared"
- 2025-12-12 TUN-9886 notarize cloudflared
-
-2026.1.1
- 2026-01-19 fix: Update boto3 to run on trixie
- 2026-01-19 fix: Fix wixl bundling tool for windows msi packages
- 2026-01-19 fix: rpm bundling and rpm key import
-
-2026.1.0
- 2026-01-13 TUN-10162: Update go to 1.24.11 and Debian distroless to debian13
- 2025-11-21 Replace jira.cfops.it with jira.cfdata.org in connection/http2_test.go
- 2025-11-19 TUN-9863: Update pipelines to use cloudflared EV Certificate
- 2025-11-07 TUN-9800: Migrate apt internal builds to Gitlab
- 2025-11-04 TUN-9998: Don't need to read origin cert to determine if the endpoint is fedramp
- 2025-10-13 TUN-9910: Make the metadata key to carry HTTP status over QUIC transport a constant
-
-2025.11.1
- 2025-11-07 TUN-9800: Fix docker hub push step
-
-2025.11.0
- 2025-11-06 TUN-9863: Introduce Code Signing for Windows Builds
- 2025-11-06 TUN-9800: Prefix gitlab steps with operating system
- 2025-11-04 chore: Update cloudflared signing key name in index.html
- 2025-10-31 chore: add claude review
- 2025-10-31 Chore: Update documentation links in README
- 2025-10-31 TUN-9800: Add pipelines for linux packaging
-
-2025.10.1
- 2025-10-30 chore: Update ci image to use goboring 1.24.9
- 2025-10-28 TUN-9849: Add cf-proxy-* to control response headers
- 2025-10-24 TUN-9961: Add pkg.cloudflared.com index.html to git repo
- 2025-10-23 TUN-9954: Update from go1.24.6 to go1.24.9
- 2025-10-23 Fix systemd service installation hanging
- 2025-10-21 TUN-9941: Use new GPG key for RPM builds
- 2025-10-21 TUN-9941: Fix typo causing r2-release-next deployment to fail
- 2025-10-21 TUN-9941: Lookup correct key for RPM signature
- 2025-10-15 TUN-9919: Make RPM postinstall scriplet idempotent
- 2025-10-14 TUN-9916: Fix the cloudflared binary path used in the component test
-
-2025.10.0
- 2025-10-14 chore: Fix upload of RPM repo file during double signing
- 2025-10-13 TUN-9882: Bump datagram v3 write channel capacity
- 2025-10-10 chore: Fix import of GPG keys when two keys are provided
- 2025-10-10 chore: Fix parameter order when uploading RPM .repo file to R2
- 2025-10-10 TUN-9883: Add new datagram v3 feature flag
- 2025-10-09 chore: Force usage of go-boring 1.24
- 2025-10-08 TUN-9882: Improve metrics for datagram v3
- 2025-10-07 GRC-16749: Add fedramp tags to catalog
- 2025-10-07 TUN-9882: Add buffers for UDP and ICMP datagrams in datagram v3
- 2025-10-07 TUN-9882: Add write deadline for UDP origin writes
- 2025-09-29 TUN-9776: Support signing Debian packages with two keys for rollover
- 2025-09-22 TUN-9800: Add pipeline to sync between gitlab and github repos
-
-2025.9.1
- 2025-09-22 TUN-9855: Create script to ignore vulnerabilities from govuln check
- 2025-09-19 TUN-9852: Remove fmt.Println from cloudflared access command
-
-2025.9.0
- 2025-09-15 TUN-9820: Add support for FedRAMP in originRequest Access config
- 2025-09-11 TUN-9800: Migrate cloudflared-ci pipelines to Gitlab CI
- 2025-09-04 TUN-9803: Add windows builds to gitlab-ci
- 2025-08-27 TUN-9755: Set endpoint in tunnel credentials when generating locally managed tunnel with a Fed token
-
-2025.8.1
- 2025-08-19 AUTH-7480 update fed callback url for login helper
- 2025-08-19 CUSTESC-53681: Correct QUIC connection management for datagram handlers
- 2025-08-12 AUTH-7260: Add support for login interstitial auto closure
-
-2025.8.0
- 2025-08-07 vuln: Fix GO-2025-3770 vulnerability
- 2025-07-23 TUN-9583: set proper url and hostname for cloudflared tail command
- 2025-07-07 TUN-9542: Remove unsupported Debian-based releases
-
-2025.7.0
- 2025-07-03 TUN-9540: Use numeric user id for Dockerfiles
- 2025-07-01 TUN-9161: Remove P256Kyber768Draft00PQKex curve from nonFips curve preferences
- 2025-07-01 TUN-9531: Bump go-boring from 1.24.2 to 1.24.4
- 2025-07-01 TUN-9511: Add metrics for virtual DNS origin
- 2025-06-30 TUN-9470: Add OriginDialerService to include TCP
- 2025-06-30 TUN-9473: Add --dns-resolver-addrs flag
- 2025-06-27 TUN-9472: Add virtual DNS service
- 2025-06-23 TUN-9469: Centralize UDP origin proxy dialing as ingress service
-
-2025.6.1
- 2025-06-16 TUN-9467: add vulncheck to cloudflared
- 2025-06-16 TUN-9495: Remove references to cloudflare-go
- 2025-06-16 TUN-9371: Add logging format as JSON
- 2025-06-12 TUN-9467: bump coredns to solve CVE
-
-2025.6.0
- 2025-06-06 TUN-9016: update go to 1.24
- 2025-06-05 TUN-9171: Use `is_default_network` instead of `is_default` to create vnet's
-
-2025.5.0
- 2025-05-14 TUN-9319: Add dynamic loading of features to connections via ConnectionOptionsSnapshot
- 2025-05-13 TUN-9322: Add metric for unsupported RPC commands for datagram v3
- 2025-05-07 TUN-9291: Remove dynamic reloading of features for datagram v3
-
-2025.4.2
- 2025-04-30 chore: Do not use gitlab merge request pipelines
- 2025-04-30 DEVTOOLS-16383: Create GitlabCI pipeline to release Mac builds
- 2025-04-24 TUN-9255: Improve flush on write conditions in http2 tunnel type to match what is done on the edge
- 2025-04-10 SDLC-3727 - Adding FIPS status to backstage
-
-2025.4.0
- 2025-04-02 Fix broken links in `cmd/cloudflared/*.go` related to running tunnel as a service
- 2025-04-02 chore: remove repetitive words
- 2025-04-01 Fix messages to point to one.dash.cloudflare.com
- 2025-04-01 feat: emit explicit errors for the `service` command on unsupported OSes
- 2025-04-01 Use RELEASE_NOTES date instead of build date
- 2025-04-01 chore: Update tunnel configuration link in the readme
- 2025-04-01 fix: expand home directory for credentials file
- 2025-04-01 fix: Use path and filepath operation appropriately
- 2025-04-01 feat: Adds a new command line for tunnel run for token file
- 2025-04-01 chore: fix linter rules
- 2025-03-17 TUN-9101: Don't ignore errors on `cloudflared access ssh`
- 2025-03-06 TUN-9089: Pin go import to v0.30.0, v0.31.0 requires go 1.23
-
-2025.2.1
- 2025-02-26 TUN-9016: update base-debian to v12
- 2025-02-25 TUN-8960: Connect to FED API GW based on the OriginCert's endpoint
- 2025-02-25 TUN-9007: modify logic to resolve region when the tunnel token has an endpoint field
- 2025-02-13 SDLC-3762: Remove backstage.io/source-location from catalog-info.yaml
- 2025-02-06 TUN-8914: Create a flags module to group all cloudflared cli flags
-
-2025.2.0
- 2025-02-03 TUN-8914: Add a new configuration to locally override the max-active-flows
- 2025-02-03 Bump x/crypto to 0.31.0
-
-2025.1.1
- 2025-01-30 TUN-8858: update go to 1.22.10 and include quic-go FIPS changes
- 2025-01-30 TUN-8855: fix lint issues
- 2025-01-30 TUN-8855: Update PQ curve preferences
- 2025-01-30 TUN-8857: remove restriction for using FIPS and PQ
- 2025-01-30 TUN-8894: report FIPS+PQ error to Sentry when dialling to the edge
- 2025-01-22 TUN-8904: Rename Connect Response Flow Rate Limited metadata
- 2025-01-21 AUTH-6633 Fix cloudflared access login + warp as auth
- 2025-01-20 TUN-8861: Add session limiter to UDP session manager
- 2025-01-20 TUN-8861: Rename Session Limiter to Flow Limiter
- 2025-01-17 TUN-8900: Add import of Apple Developer Certificate Authority to macOS Pipeline
- 2025-01-17 TUN-8871: Accept login flag to authenticate with Fedramp environment
- 2025-01-16 TUN-8866: Add linter to cloudflared repository
- 2025-01-14 TUN-8861: Add session limiter to TCP session manager
- 2025-01-13 TUN-8861: Add configuration for active sessions limiter
- 2025-01-09 TUN-8848: Don't treat connection shutdown as an error condition when RPC server is done
-
-2025.1.0
- 2025-01-06 TUN-8842: Add Ubuntu Noble and 'any' debian distributions to release script
- 2025-01-06 TUN-8807: Add support_datagram_v3 to remote feature rollout
- 2024-12-20 TUN-8829: add CONTAINER_BUILD to dockerfiles
-
-2024.12.2
- 2024-12-19 TUN-8822: Prevent concurrent usage of ICMPDecoder
- 2024-12-18 TUN-8818: update changes document to reflect newly added diag subcommand
- 2024-12-17 TUN-8817: Increase close session channel by one since there are two writers
- 2024-12-13 TUN-8797: update CHANGES.md with note about semi-deterministic approach used to bind metrics server
- 2024-12-13 TUN-8724: Add CLI command for diagnostic procedure
- 2024-12-11 TUN-8786: calculate cli flags once for the diagnostic procedure
- 2024-12-11 TUN-8792: Make diag/system endpoint always return a JSON
- 2024-12-10 TUN-8783: fix log collectors for the diagnostic procedure
- 2024-12-10 TUN-8785: include the icmp sources in the diag's tunnel state
- 2024-12-10 TUN-8784: Set JSON encoder options to print formatted JSON when writing diag files
-
-2024.12.1
- 2024-12-10 TUN-8795: update createrepo to createrepo_c to fix the release_pkgs.py script
-
-2024.12.0
- 2024-12-09 TUN-8640: Add ICMP support for datagram V3
- 2024-12-09 TUN-8789: make python package installation consistent
- 2024-12-06 TUN-8781: Add Trixie, drop Buster. Default to Bookworm
- 2024-12-05 TUN-8775: Make sure the session Close can only be called once
- 2024-12-04 TUN-8725: implement diagnostic procedure
- 2024-12-04 TUN-8767: include raw output from network collector in diagnostic zipfile
- 2024-12-04 TUN-8770: add cli configuration and tunnel configuration to diagnostic zipfile
- 2024-12-04 TUN-8768: add job report to diagnostic zipfile
- 2024-12-03 TUN-8726: implement compression routine to be used in diagnostic procedure
- 2024-12-03 TUN-8732: implement port selection algorithm
- 2024-12-03 TUN-8762: fix argument order when invoking tracert and modify network info output parsing.
- 2024-12-03 TUN-8769: fix k8s log collector arguments
- 2024-12-03 TUN-8727: extend client to include function to get cli configuration and tunnel configuration
- 2024-11-29 TUN-8729: implement network collection for diagnostic procedure
- 2024-11-29 TUN-8727: implement metrics, runtime, system, and tunnelstate in diagnostic http client
- 2024-11-27 TUN-8733: add log collection for docker
- 2024-11-27 TUN-8734: add log collection for kubernetes
- 2024-11-27 TUN-8640: Refactor ICMPRouter to support new ICMPResponders
- 2024-11-26 TUN-8735: add managed/local log collection
- 2024-11-25 TUN-8728: implement diag/tunnel endpoint
- 2024-11-25 TUN-8730: implement diag/configuration
- 2024-11-22 TUN-8737: update metrics server port selection
- 2024-11-22 TUN-8731: Implement diag/system endpoint
- 2024-11-21 TUN-8748: Migrated datagram V3 flows to use migrated context
-
-2024.11.1
- 2024-11-18 Add cloudflared tunnel ready command
- 2024-11-14 Make metrics a requirement for tunnel ready command
- 2024-11-12 TUN-8701:  Simplify flow registration logs for datagram v3
- 2024-11-11 add: new go-fuzz targets
- 2024-11-07 TUN-8701: Add metrics and adjust logs for datagram v3
- 2024-11-06 TUN-8709: Add session migration for datagram v3
- 2024-11-04 Fixed 404 in README.md to TryCloudflare
- 2024-09-24 Update semgrep.yml
-
-2024.11.0
- 2024-11-05 VULN-66059: remove ssh server tests
- 2024-11-04 TUN-8700: Add datagram v3 muxer
- 2024-11-04 TUN-8646: Allow experimental feature support for datagram v3
- 2024-11-04 TUN-8641: Expose methods to simplify V3 Datagram parsing on the edge
- 2024-10-31 TUN-8708: Bump python min version to 3.10
- 2024-10-31 TUN-8667: Add datagram v3 session manager
- 2024-10-25 TUN-8692: remove dashes from session id
- 2024-10-24 TUN-8694: Rework release script
- 2024-10-24 TUN-8661: Refactor connection methods to support future different datagram muxing methods
- 2024-07-22 TUN-8553: Bump go to 1.22.5 and go-boring 1.22.5-1
-
-2024.10.1
- 2024-10-23 TUN-8694: Fix github release script
- 2024-10-21 Revert "TUN-8592: Use metadata from the edge to determine if request body is empty for QUIC transport"
- 2024-10-18 TUN-8688: Correct UDP bind for IPv6 edge connectivity on macOS
- 2024-10-17 TUN-8685: Bump coredns dependency
- 2024-10-16 TUN-8638: Add datagram v3 serializers and deserializers
- 2024-10-15 chore: Remove h2mux code
- 2024-10-11 TUN-8631: Abort release on version mismatch
-
-2024.10.0
- 2024-10-01 TUN-8646: Add datagram v3 support feature flag
- 2024-09-30 TUN-8621: Fix cloudflared version in change notes to account for release date
- 2024-09-19 Adding semgrep yaml file
- 2024-09-12 TUN-8632: Delay checking auto-update by the provided frequency
- 2024-09-11 TUN-8630: Check checksum of downloaded binary to compare to current for auto-updating
- 2024-09-09 TUN-8629: Cloudflared update on Windows requires running it twice to update
- 2024-09-06 PPIP-2310: Update quick tunnel disclaimer
- 2024-08-30 TUN-8621: Prevent QUIC connection from closing before grace period after unregistering
- 2024-08-09 TUN-8592: Use metadata from the edge to determine if request body is empty for QUIC transport
- 2024-06-26 TUN-8484: Print response when QuickTunnel can't be unmarshalled
-
-2024.9.1
- 2024-09-10 Revert Release 2024.9.0
-
-2024.9.0
- 2024-09-10 TUN-8621: Fix cloudflared version in change notes.
- 2024-09-06 PPIP-2310: Update quick tunnel disclaimer
- 2024-08-30 TUN-8621: Prevent QUIC connection from closing before grace period after unregistering
- 2024-08-09 TUN-8592: Use metadata from the edge to determine if request body is empty for QUIC transport
- 2024-06-26 TUN-8484: Print response when QuickTunnel can't be unmarshalled
-
-2024.8.3
- 2024-08-15 TUN-8591 login command without extra text
- 2024-03-25 remove code that will not be executed
- 2024-03-25 remove code that will not be executed
-
-2024.8.2
- 2024-08-05 TUN-8583: change final directory of artifacts
- 2024-08-05 TUN-8585: Avoid creating GH client when dry-run is true
+2024.8.0
+- 2024-08-01 TUN-8546: remove call to non existant make target

 2024.7.3
 - 2024-07-31 TUN-8546: Fix final artifacts paths
@@ -1,10 +1,9 @@
 #!/bin/bash
-set -e -u -o pipefail
 VERSION=$(git describe --tags --always --match "[0-9][0-9][0-9][0-9].*.*")
 echo $VERSION

 # This controls the directory the built artifacts go into
-export ARTIFACT_DIR=artifacts/
+export ARTIFACT_DIR=built_artifacts/
 mkdir -p $ARTIFACT_DIR

 arch=("amd64")
@@ -18,10 +17,10 @@ make cloudflared-deb
 mv cloudflared-fips\_$VERSION\_$arch.deb $ARTIFACT_DIR/cloudflared-fips-linux-$arch.deb

 # rpm packages invert the - and _ and use x86_64 instead of amd64.
-RPMVERSION=$(echo $VERSION | sed -r 's/-/_/g')
+RPMVERSION=$(echo $VERSION|sed -r 's/-/_/g')
 RPMARCH="x86_64"
 make cloudflared-rpm
 mv cloudflared-fips-$RPMVERSION-1.$RPMARCH.rpm $ARTIFACT_DIR/cloudflared-fips-linux-$RPMARCH.rpm

 # finally move the linux binary as well.
-mv ./cloudflared $ARTIFACT_DIR/cloudflared-fips-linux-$arch
+mv ./cloudflared $ARTIFACT_DIR/cloudflared-fips-linux-$arch
@@ -0,0 +1,48 @@
+#!/bin/bash
+VERSION=$(git describe --tags --always --match "[0-9][0-9][0-9][0-9].*.*")
+echo $VERSION
+
+# Disable FIPS module in go-boring
+export GOEXPERIMENT=noboringcrypto
+export CGO_ENABLED=0
+
+# This controls the directory the built artifacts go into
+export ARTIFACT_DIR=built_artifacts/
+mkdir -p $ARTIFACT_DIR
+
+linuxArchs=("386" "amd64" "arm" "armhf" "arm64")
+export TARGET_OS=linux
+for arch in ${linuxArchs[@]}; do
+    unset TARGET_ARM
+    export TARGET_ARCH=$arch
+
+    ## Support for arm platforms without hardware FPU enabled
+    if [[ $arch == arm ]] ; then
+        export TARGET_ARCH=arm
+        export TARGET_ARM=5
+    fi
+    
+    ## Support for armhf builds 
+    if [[ $arch == armhf ]] ; then
+        export TARGET_ARCH=arm
+        export TARGET_ARM=7 
+    fi
+    
+    make cloudflared-deb
+    mv cloudflared\_$VERSION\_$arch.deb $ARTIFACT_DIR/cloudflared-linux-$arch.deb
+
+    # rpm packages invert the - and _ and use x86_64 instead of amd64.
+    RPMVERSION=$(echo $VERSION|sed -r 's/-/_/g')
+    RPMARCH=$arch
+    if [ $arch == "amd64" ];then
+        RPMARCH="x86_64"
+    fi
+    if [ $arch == "arm64" ]; then
+        RPMARCH="aarch64"
+    fi
+    make cloudflared-rpm
+    mv cloudflared-$RPMVERSION-1.$RPMARCH.rpm $ARTIFACT_DIR/cloudflared-linux-$RPMARCH.rpm
+
+    # finally move the linux binary as well.
+    mv ./cloudflared $ARTIFACT_DIR/cloudflared-linux-$arch
+done
@@ -26,13 +26,11 @@ const (
 )

 type StartOptions struct {
-	AppInfo               *token.AppInfo
-	OriginURL             string
-	Headers               http.Header
-	Host                  string
-	TLSClientConfig       *tls.Config
-	AutoCloseInterstitial bool
-	IsFedramp             bool
+	AppInfo         *token.AppInfo
+	OriginURL       string
+	Headers         http.Header
+	Host            string
+	TLSClientConfig *tls.Config
 }

 // Connection wraps up all the needed functions to forward over the tunnel
@@ -48,6 +46,7 @@ type StdinoutStream struct{}
 // Read will read from Stdin
 func (c *StdinoutStream) Read(p []byte) (int, error) {
 	return os.Stdin.Read(p)
+
 }

 // Write will write to Stdout
@@ -140,7 +139,7 @@ func BuildAccessRequest(options *StartOptions, log *zerolog.Logger) (*http.Reque
 		return nil, err
 	}

-	token, err := token.FetchTokenWithRedirect(req.URL, options.AppInfo, options.AutoCloseInterstitial, options.IsFedramp, log)
+	token, err := token.FetchTokenWithRedirect(req.URL, options.AppInfo, log)
 	if err != nil {
 		return nil, err
 	}
@@ -17,7 +17,8 @@ import (
 // Websocket is used to carry data via WS binary frames over the tunnel from client to the origin
 // This implements the functions for glider proxy (sock5) and the carrier interface
 type Websocket struct {
-	log *zerolog.Logger
+	log     *zerolog.Logger
+	isSocks bool
 }

 // NewWSConnection returns a new connection object
@@ -35,7 +36,7 @@ func (ws *Websocket) ServeStream(options *StartOptions, conn io.ReadWriter) erro
 		ws.log.Err(err).Str(LogFieldOriginURL, options.OriginURL).Msg("failed to connect to origin")
 		return err
 	}
-	defer func() { _ = wsConn.Close() }()
+	defer wsConn.Close()

 	stream.Pipe(wsConn, conn, ws.log)
 	return nil
@@ -2,11 +2,10 @@ package carrier

 import (
 	"context"
-	crand "crypto/rand"
 	"crypto/tls"
 	"crypto/x509"
 	"fmt"
-	"math/big"
+	"math/rand"
 	"testing"
 	"time"

@@ -24,7 +23,7 @@ import (
 func websocketClientTLSConfig(t *testing.T) *tls.Config {
 	certPool := x509.NewCertPool()
 	helloCert, err := tlsconfig.GetHelloCertificateX509()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	certPool.AddCert(helloCert)
 	assert.NotNil(t, certPool)
 	return &tls.Config{RootCAs: certPool}
@@ -44,8 +43,8 @@ func TestServe(t *testing.T) {
 	shutdownC := make(chan struct{})
 	errC := make(chan error)
 	listener, err := hello.CreateTLSListener("localhost:1111")
-	require.NoError(t, err)
-	defer func() { _ = listener.Close() }()
+	assert.NoError(t, err)
+	defer listener.Close()

 	go func() {
 		errC <- hello.StartHelloWorldServer(&log, listener, shutdownC)
@@ -57,21 +56,19 @@ func TestServe(t *testing.T) {
 	assert.NotNil(t, tlsConfig)
 	d := gws.Dialer{TLSClientConfig: tlsConfig}
 	conn, resp, err := clientConnect(req, &d)
-	require.NoError(t, err)
-	defer func() { _ = resp.Body.Close() }()
+	assert.NoError(t, err)
 	assert.Equal(t, "websocket", resp.Header.Get("Upgrade"))

 	for i := 0; i < 1000; i++ {
-		messageSize, err := crand.Int(crand.Reader, big.NewInt(2048))
-		require.NoError(t, err)
-		clientMessage := make([]byte, int(messageSize.Int64())+1)
-		_, err = crand.Read(clientMessage)
-		require.NoError(t, err)
+		messageSize := rand.Int()%2048 + 1
+		clientMessage := make([]byte, messageSize)
+		// rand.Read always returns len(clientMessage) and a nil error
+		rand.Read(clientMessage)
 		err = conn.WriteMessage(websocket.BinaryFrame, clientMessage)
-		require.NoError(t, err)
+		assert.NoError(t, err)

 		messageType, message, err := conn.ReadMessage()
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, websocket.BinaryFrame, messageType)
 		assert.Equal(t, clientMessage, message)
 	}
@@ -100,30 +97,27 @@ func TestWebsocketWrapper(t *testing.T) {
 	req := testRequest(t, testAddr, nil)
 	conn, resp, err := clientConnect(req, &d)
 	require.NoError(t, err)
-	defer func() { _ = resp.Body.Close() }()
 	assert.Equal(t, "websocket", resp.Header.Get("Upgrade"))

 	// Websocket now connected to test server so lets check our wrapper
 	wrapper := cfwebsocket.GorillaConn{Conn: conn}
 	buf := make([]byte, 100)
-	_, err = wrapper.Write([]byte("abc"))
-	require.NoError(t, err)
+	wrapper.Write([]byte("abc"))
 	n, err := wrapper.Read(buf)
 	require.NoError(t, err)
-	require.Equal(t, 3, n)
+	require.Equal(t, n, 3)
 	require.Equal(t, "abc", string(buf[:n]))

 	// Test partial read, read 1 of 3 bytes in one read and the other 2 in another read
-	_, err = wrapper.Write([]byte("abc"))
-	require.NoError(t, err)
+	wrapper.Write([]byte("abc"))
 	buf = buf[:1]
 	n, err = wrapper.Read(buf)
 	require.NoError(t, err)
-	require.Equal(t, 1, n)
+	require.Equal(t, n, 1)
 	require.Equal(t, "a", string(buf[:n]))
 	buf = buf[:cap(buf)]
 	n, err = wrapper.Read(buf)
 	require.NoError(t, err)
-	require.Equal(t, 2, n)
+	require.Equal(t, n, 2)
 	require.Equal(t, "bc", string(buf[:n]))
 }
@@ -4,6 +4,7 @@ metadata:
  name: cloudflared
  description: Client for Cloudflare Tunnels
  annotations:
+    backstage.io/source-location: url:https://bitbucket.cfdata.org/projects/TUN/repos/cloudflared/browse
    cloudflare.com/software-excellence-opt-in: "true"
    cloudflare.com/jira-project-key: "TUN"
    cloudflare.com/jira-project-component: "Cloudflare Tunnel"
@@ -13,8 +14,3 @@ spec:
  type: "service"
  lifecycle: "Active"
  owner: "teams/tunnel-teams-routing"
-  cf:
-    compliance:
-      fedramp-high: "pending"
-      fedramp-moderate: "yes"
-    FIPS: "required"
@@ -45,7 +45,9 @@ type baseEndpoints struct {
 var _ Client = (*RESTClient)(nil)

 func NewRESTClient(baseURL, accountTag, zoneTag, authToken, userAgent string, log *zerolog.Logger) (*RESTClient, error) {
-	baseURL = strings.TrimSuffix(baseURL, "/")
+	if strings.HasSuffix(baseURL, "/") {
+		baseURL = baseURL[:len(baseURL)-1]
+	}
 	accountLevelEndpoint, err := url.Parse(fmt.Sprintf("%s/accounts/%s/cfd_tunnel", baseURL, accountTag))
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to create account level endpoint")
@@ -66,7 +68,7 @@ func NewRESTClient(baseURL, accountTag, zoneTag, authToken, userAgent string, lo
 		TLSHandshakeTimeout:   defaultTimeout,
 		ResponseHeaderTimeout: defaultTimeout,
 	}
-	_ = http2.ConfigureTransport(&httpTransport)
+	http2.ConfigureTransport(&httpTransport)
 	return &RESTClient{
 		baseEndpoints: &baseEndpoints{
 			accountLevel:  *accountLevelEndpoint,
@@ -159,6 +161,7 @@ func fetchExhaustively[T any](requestFn func(int) (*http.Response, error)) ([]*T
 		if envelope.Pagination.Count < envelope.Pagination.PerPage || len(fullResponse) >= envelope.Pagination.TotalCount {
 			break
 		}
+
 	}
 	return fullResponse, nil
 }
@@ -176,13 +179,14 @@ func fetchPage[T any](requestFn func(int) (*http.Response, error), page int) (*r
 		}
 		var parsedRspBody []*T
 		return envelope, parsedRspBody, parseResponseBody(envelope, &parsedRspBody)
+
 	}
 	return nil, nil, errors.New(fmt.Sprintf("Failed to fetch page. Server returned: %d", pageResp.StatusCode))
 }

 type response struct {
 	Success    bool            `json:"success,omitempty"`
-	Errors     []apiError      `json:"errors,omitempty"`
+	Errors     []apiErr        `json:"errors,omitempty"`
 	Messages   []string        `json:"messages,omitempty"`
 	Result     json.RawMessage `json:"result,omitempty"`
 	Pagination Pagination      `json:"result_info,omitempty"`
@@ -202,19 +206,19 @@ func (r *response) checkErrors() error {
 	if len(r.Errors) == 1 {
 		return r.Errors[0]
 	}
-	var messagesBuilder strings.Builder
+	var messages string
 	for _, e := range r.Errors {
-		messagesBuilder.WriteString(fmt.Sprintf("%s; ", e))
+		messages += fmt.Sprintf("%s; ", e)
 	}
-	return fmt.Errorf("API errors: %s", messagesBuilder.String())
+	return fmt.Errorf("API errors: %s", messages)
 }

-type apiError struct {
+type apiErr struct {
 	Code    json.Number `json:"code,omitempty"`
 	Message string      `json:"message,omitempty"`
 }

-func (e apiError) Error() string {
+func (e apiErr) Error() string {
 	return fmt.Sprintf("code: %v, reason: %s", e.Code, e.Message)
 }

@@ -8,7 +8,7 @@ type TunnelClient interface {
 	CreateTunnel(name string, tunnelSecret []byte) (*TunnelWithToken, error)
 	GetTunnel(tunnelID uuid.UUID) (*Tunnel, error)
 	GetTunnelToken(tunnelID uuid.UUID) (string, error)
-	GetManagementToken(tunnelID uuid.UUID, resource ManagementResource) (string, error)
+	GetManagementToken(tunnelID uuid.UUID) (string, error)
 	DeleteTunnel(tunnelID uuid.UUID, cascade bool) error
 	ListTunnels(filter *TunnelFilter) ([]*Tunnel, error)
 	ListActiveClients(tunnelID uuid.UUID) ([]*ActiveClient, error)
@@ -15,27 +15,6 @@ import (

 var ErrTunnelNameConflict = errors.New("tunnel with name already exists")

-type ManagementResource int
-
-const (
-	Logs ManagementResource = iota
-	Admin
-	HostDetails
-)
-
-func (r ManagementResource) String() string {
-	switch r {
-	case Logs:
-		return "logs"
-	case Admin:
-		return "admin"
-	case HostDetails:
-		return "host_details"
-	default:
-		return ""
-	}
-}
-
 type Tunnel struct {
 	ID          uuid.UUID    `json:"id"`
 	Name        string       `json:"name"`
@@ -71,6 +50,10 @@ type newTunnel struct {
 	TunnelSecret []byte `json:"tunnel_secret"`
 }

+type managementRequest struct {
+	Resources []string `json:"resources"`
+}
+
 type CleanupParams struct {
 	queryParams url.Values
 }
@@ -154,16 +137,15 @@ func (r *RESTClient) GetTunnelToken(tunnelID uuid.UUID) (token string, err error
 	return "", r.statusCodeToError("get tunnel token", resp)
 }

-// managementEndpointPath returns the path segment for a management resource endpoint
-func managementEndpointPath(tunnelID uuid.UUID, res ManagementResource) string {
-	return fmt.Sprintf("%v/management/%s", tunnelID, res.String())
-}
-
-func (r *RESTClient) GetManagementToken(tunnelID uuid.UUID, res ManagementResource) (token string, err error) {
+func (r *RESTClient) GetManagementToken(tunnelID uuid.UUID) (token string, err error) {
 	endpoint := r.baseEndpoints.accountLevel
-	endpoint.Path = path.Join(endpoint.Path, managementEndpointPath(tunnelID, res))
+	endpoint.Path = path.Join(endpoint.Path, fmt.Sprintf("%v/management", tunnelID))

-	resp, err := r.sendRequest("POST", endpoint, nil)
+	body := &managementRequest{
+		Resources: []string{"logs"},
+	}
+
+	resp, err := r.sendRequest("POST", endpoint, body)
 	if err != nil {
 		return "", errors.Wrap(err, "REST request failed")
 	}
@@ -2,6 +2,7 @@ package cfapi

 import (
 	"bytes"
+	"fmt"
 	"net"
 	"reflect"
 	"strings"
@@ -10,7 +11,6 @@ import (

 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )

 var loc, _ = time.LoadLocation("UTC")
@@ -52,6 +52,7 @@ func Test_unmarshalTunnel(t *testing.T) {
 }

 func TestUnmarshalTunnelOk(t *testing.T) {
+
 	jsonBody := `{"success": true, "result": {"id": "00000000-0000-0000-0000-000000000000","name":"test","created_at":"0001-01-01T00:00:00Z","connections":[]}}`
 	expected := Tunnel{
 		ID:          uuid.Nil,
@@ -60,11 +61,12 @@ func TestUnmarshalTunnelOk(t *testing.T) {
 		Connections: []Connection{},
 	}
 	actual, err := unmarshalTunnel(bytes.NewReader([]byte(jsonBody)))
-	require.NoError(t, err)
-	require.Equal(t, &expected, actual)
+	assert.NoError(t, err)
+	assert.Equal(t, &expected, actual)
 }

 func TestUnmarshalTunnelErr(t *testing.T) {
+
 	tests := []string{
 		`abc`,
 		`{"success": true, "result": abc}`,
@@ -74,73 +76,7 @@ func TestUnmarshalTunnelErr(t *testing.T) {

 	for i, test := range tests {
 		_, err := unmarshalTunnel(bytes.NewReader([]byte(test)))
-		assert.Error(t, err, "Test #%v failed", i)
-	}
-}
-
-func TestManagementResource_String(t *testing.T) {
-	tests := []struct {
-		name     string
-		resource ManagementResource
-		want     string
-	}{
-		{
-			name:     "Logs",
-			resource: Logs,
-			want:     "logs",
-		},
-		{
-			name:     "Admin",
-			resource: Admin,
-			want:     "admin",
-		},
-		{
-			name:     "HostDetails",
-			resource: HostDetails,
-			want:     "host_details",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, tt.resource.String())
-		})
-	}
-}
-
-func TestManagementResource_String_Unknown(t *testing.T) {
-	unknown := ManagementResource(999)
-	assert.Equal(t, "", unknown.String())
-}
-
-func TestManagementEndpointPath(t *testing.T) {
-	tunnelID := uuid.MustParse("b34cc7ce-925b-46ee-bc23-4cb5c18d8292")
-
-	tests := []struct {
-		name     string
-		resource ManagementResource
-		want     string
-	}{
-		{
-			name:     "Logs resource",
-			resource: Logs,
-			want:     "b34cc7ce-925b-46ee-bc23-4cb5c18d8292/management/logs",
-		},
-		{
-			name:     "Admin resource",
-			resource: Admin,
-			want:     "b34cc7ce-925b-46ee-bc23-4cb5c18d8292/management/admin",
-		},
-		{
-			name:     "HostDetails resource",
-			resource: HostDetails,
-			want:     "b34cc7ce-925b-46ee-bc23-4cb5c18d8292/management/host_details",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := managementEndpointPath(tunnelID, tt.resource)
-			assert.Equal(t, tt.want, got)
-		})
+		assert.Error(t, err, fmt.Sprintf("Test #%v failed", i))
 	}
 }

@@ -161,6 +97,6 @@ func TestUnmarshalConnections(t *testing.T) {
 		}},
 	}
 	actual, err := parseConnectionsDetails(bytes.NewReader([]byte(jsonBody)))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []*ActiveClient{&expected}, actual)
 }
@@ -16,7 +16,7 @@ import (
 type NewVirtualNetwork struct {
 	Name      string `json:"name"`
 	Comment   string `json:"comment"`
-	IsDefault bool   `json:"is_default_network"`
+	IsDefault bool   `json:"is_default"`
 }

 type VirtualNetwork struct {
@@ -1,2 +1,236 @@
-# A valid cfsetup.yaml is required but we dont have any real config to specify
-dummy_key: true
+pinned_go: &pinned_go go-boring=1.22.2-1
+
+build_dir: &build_dir /cfsetup_build
+default-flavor: bullseye
+buster: &buster
+  build-linux:
+    build_dir: *build_dir
+    builddeps: &build_deps
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+      - rpm
+      - libffi-dev
+    pre-cache: &build_pre_cache
+      - export GOCACHE=/cfsetup_build/.cache/go-build
+      - go install golang.org/x/tools/cmd/goimports@latest
+    post-cache:
+      # Build binary for component test
+      - GOOS=linux GOARCH=amd64 make cloudflared
+  build-linux-fips:
+    build_dir: *build_dir
+    builddeps: *build_deps
+    pre-cache: *build_pre_cache
+    post-cache:
+      - export FIPS=true
+      # Build binary for component test
+      - GOOS=linux GOARCH=amd64 make cloudflared
+  cover:
+    build_dir: *build_dir
+    builddeps: *build_deps
+    pre-cache: *build_pre_cache
+    post-cache:
+     - make cover
+  # except FIPS and macos 
+  build-linux-release:
+    build_dir: *build_dir
+    builddeps: &build_deps_release
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+      - rpm
+      - libffi-dev
+      - python3-dev
+      - python3-pip
+      - python3-setuptools
+      - wget
+    pre-cache: &build_release_pre_cache
+      - pip3 install pynacl==1.4.0
+      - pip3 install pygithub==1.55
+      - pip3 install boto3==1.22.9
+      - pip3 install python-gnupg==0.4.9
+    post-cache:
+      # build all packages (except macos and FIPS) and move them to /cfsetup/built_artifacts
+      - ./build-packages.sh
+  # handle FIPS separately so that we built with gofips compiler
+  build-linux-fips-release:
+    build_dir: *build_dir
+    builddeps: *build_deps_release
+    pre-cache: *build_release_pre_cache
+    post-cache:
+      # same logic as above, but for FIPS packages only
+      - ./build-packages-fips.sh
+  generate-versions-file:
+    build_dir: *build_dir
+    builddeps:
+      - *pinned_go
+      - build-essential
+    post-cache:
+      - make generate-docker-version
+  build-deb:
+    build_dir: *build_dir
+    builddeps: &build_deb_deps
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=amd64
+      - make cloudflared-deb
+  build-fips-internal-deb:
+    build_dir: *build_dir
+    builddeps: &build_fips_deb_deps
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=amd64
+      - export FIPS=true
+      - export ORIGINAL_NAME=true
+      - make cloudflared-deb
+  build-internal-deb-nightly-amd64:
+    build_dir: *build_dir
+    builddeps: *build_fips_deb_deps
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=amd64
+      - export NIGHTLY=true
+      - export FIPS=true
+      - export ORIGINAL_NAME=true
+      - make cloudflared-deb
+  build-internal-deb-nightly-arm64:
+    build_dir: *build_dir
+    builddeps: *build_fips_deb_deps
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=arm64
+      - export NIGHTLY=true
+      #- export FIPS=true # TUN-7595
+      - export ORIGINAL_NAME=true
+      - make cloudflared-deb
+  build-deb-arm64:
+    build_dir: *build_dir
+    builddeps: *build_deb_deps
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=arm64
+      - make cloudflared-deb
+  package-windows:
+    build_dir: *build_dir
+    builddeps:
+      - *pinned_go
+      - build-essential
+      - python3-dev
+      - libffi-dev
+      - python3-setuptools
+      - python3-pip
+      - wget
+      # libmsi and libgcab are libraries the wixl binary depends on.
+      - libmsi-dev
+      - libgcab-dev
+    pre-cache:
+      - wget https://github.com/sudarshan-reddy/msitools/releases/download/v0.101b/wixl -P /usr/local/bin
+      - chmod a+x /usr/local/bin/wixl
+      - pip3 install pynacl==1.4.0
+      - pip3 install pygithub==1.55
+    post-cache:
+      - .teamcity/package-windows.sh
+  test:
+    build_dir: *build_dir
+    builddeps: &build_deps_tests
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+      - rpm
+      - libffi-dev
+      - gotest-to-teamcity
+    pre-cache: *build_pre_cache
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=amd64
+      - export PATH="$HOME/go/bin:$PATH"
+      - ./fmt-check.sh
+      - make test | gotest-to-teamcity
+  test-fips:
+    build_dir: *build_dir
+    builddeps: *build_deps_tests
+    pre-cache: *build_pre_cache
+    post-cache:
+      - export GOOS=linux
+      - export GOARCH=amd64
+      - export FIPS=true
+      - export PATH="$HOME/go/bin:$PATH"
+      - ./fmt-check.sh
+      - make test | gotest-to-teamcity
+  component-test:
+    build_dir: *build_dir
+    builddeps: &build_deps_component_test
+      - *pinned_go
+      - python3.7
+      - python3-pip
+      - python3-setuptools
+      # procps installs the ps command which is needed in test_sysv_service because the init script
+      # uses ps pid to determine if the agent is running
+      - procps
+    pre-cache-copy-paths:
+      - component-tests/requirements.txt
+    pre-cache: &component_test_pre_cache
+      - sudo pip3 install --upgrade -r component-tests/requirements.txt
+    post-cache: &component_test_post_cache
+      # Creates and routes a Named Tunnel for this build. Also constructs config file from env vars.
+      - python3 component-tests/setup.py --type create
+      - pytest component-tests -o log_cli=true --log-cli-level=INFO
+      # The Named Tunnel is deleted and its route unprovisioned here.
+      - python3 component-tests/setup.py --type cleanup
+  component-test-fips:
+    build_dir: *build_dir
+    builddeps: *build_deps_component_test
+    pre-cache-copy-paths:
+      - component-tests/requirements.txt
+    pre-cache: *component_test_pre_cache
+    post-cache: *component_test_post_cache
+  github-release:
+    build_dir: *build_dir
+    builddeps: 
+      - *pinned_go
+      - build-essential
+      - python3-dev
+      - libffi-dev
+      - python3-setuptools
+      - python3-pip
+    pre-cache:
+      - pip3 install pynacl==1.4.0
+      - pip3 install pygithub==1.55
+    post-cache:
+      - make github-release
+  r2-linux-release:
+    build_dir: *build_dir
+    builddeps:
+      - *pinned_go
+      - build-essential
+      - fakeroot
+      - rubygem-fpm
+      - rpm
+      - wget
+      - python3-dev
+      - libffi-dev
+      - python3-setuptools
+      - python3-pip
+      - reprepro
+      - createrepo
+    pre-cache:
+      - pip3 install pynacl==1.4.0
+      - pip3 install pygithub==1.55
+      - pip3 install boto3==1.22.9
+      - pip3 install python-gnupg==0.4.9
+    post-cache:
+      - make r2-linux-release
+
+bullseye: *buster
+bookworm: *buster
@@ -1,78 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"net"
-
-	"github.com/google/uuid"
-	"github.com/rs/zerolog"
-
-	"github.com/cloudflare/cloudflared/features"
-	"github.com/cloudflare/cloudflared/tunnelrpc/pogs"
-)
-
-// Config captures the local client runtime configuration.
-type Config struct {
-	ConnectorID uuid.UUID
-	Version     string
-	Arch        string
-
-	featureSelector features.FeatureSelector
-}
-
-func NewConfig(version string, arch string, featureSelector features.FeatureSelector) (*Config, error) {
-	connectorID, err := uuid.NewRandom()
-	if err != nil {
-		return nil, fmt.Errorf("unable to generate a connector UUID: %w", err)
-	}
-	return &Config{
-		ConnectorID:     connectorID,
-		Version:         version,
-		Arch:            arch,
-		featureSelector: featureSelector,
-	}, nil
-}
-
-// ConnectionOptionsSnapshot is a snapshot of the current client information used to initialize a connection.
-//
-// The FeatureSnapshot is the features that are available for this connection. At the client level they may
-// change, but they will not change within the scope of this struct.
-type ConnectionOptionsSnapshot struct {
-	client              pogs.ClientInfo
-	originLocalIP       net.IP
-	numPreviousAttempts uint8
-	FeatureSnapshot     features.FeatureSnapshot
-}
-
-func (c *Config) ConnectionOptionsSnapshot(originIP net.IP, previousAttempts uint8) *ConnectionOptionsSnapshot {
-	snapshot := c.featureSelector.Snapshot()
-	return &ConnectionOptionsSnapshot{
-		client: pogs.ClientInfo{
-			ClientID: c.ConnectorID[:],
-			Version:  c.Version,
-			Arch:     c.Arch,
-			Features: snapshot.FeaturesList,
-		},
-		originLocalIP:       originIP,
-		numPreviousAttempts: previousAttempts,
-		FeatureSnapshot:     snapshot,
-	}
-}
-
-func (c ConnectionOptionsSnapshot) ConnectionOptions() *pogs.ConnectionOptions {
-	return &pogs.ConnectionOptions{
-		Client:              c.client,
-		OriginLocalIP:       c.originLocalIP,
-		ReplaceExisting:     false,
-		CompressionQuality:  0,
-		NumPreviousAttempts: c.numPreviousAttempts,
-	}
-}
-
-func (c ConnectionOptionsSnapshot) LogFields(event *zerolog.Event) *zerolog.Event {
-	return event.Strs("features", c.client.Features)
-}
-
-func (c *Config) ConnectionFeaturesSnapshot() features.FeatureSnapshot {
-	return c.featureSelector.Snapshot()
-}
@@ -1,50 +0,0 @@
-package client
-
-import (
-	"net"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/cloudflare/cloudflared/features"
-)
-
-func TestGenerateConnectionOptions(t *testing.T) {
-	version := "1234"
-	arch := "linux_amd64"
-	originIP := net.ParseIP("192.168.1.1")
-	var previousAttempts uint8 = 4
-
-	config, err := NewConfig(version, arch, &mockFeatureSelector{})
-	require.NoError(t, err)
-	require.Equal(t, version, config.Version)
-	require.Equal(t, arch, config.Arch)
-
-	// Validate ConnectionOptionsSnapshot fields
-	connOptions := config.ConnectionOptionsSnapshot(originIP, previousAttempts)
-	require.Equal(t, version, connOptions.client.Version)
-	require.Equal(t, arch, connOptions.client.Arch)
-	require.Equal(t, config.ConnectorID[:], connOptions.client.ClientID)
-
-	// Vaidate snapshot feature fields against the connOptions generated
-	snapshot := config.featureSelector.Snapshot()
-	require.Equal(t, features.DatagramV3, snapshot.DatagramVersion)
-	require.Equal(t, features.DatagramV3, connOptions.FeatureSnapshot.DatagramVersion)
-
-	pogsConnOptions := connOptions.ConnectionOptions()
-	require.Equal(t, connOptions.client, pogsConnOptions.Client)
-	require.Equal(t, originIP, pogsConnOptions.OriginLocalIP)
-	require.False(t, pogsConnOptions.ReplaceExisting)
-	require.Equal(t, uint8(0), pogsConnOptions.CompressionQuality)
-	require.Equal(t, previousAttempts, pogsConnOptions.NumPreviousAttempts)
-}
-
-type mockFeatureSelector struct{}
-
-func (m *mockFeatureSelector) Snapshot() features.FeatureSnapshot {
-	return features.FeatureSnapshot{
-		PostQuantum:     features.PostQuantumPrefer,
-		DatagramVersion: features.DatagramV3,
-		FeaturesList:    []string{features.FeaturePostQuantum, features.FeatureDatagramV3_2},
-	}
-}
@@ -47,7 +47,6 @@ func StartForwarder(forwarder config.Forwarder, shutdown <-chan struct{}, log *z
 	options := &carrier.StartOptions{
 		OriginURL: forwarder.URL,
 		Headers:   headers, //TODO: TUN-2688 support custom headers from config file
-		IsFedramp: forwarder.IsFedramp,
 	}

 	// we could add a cmd line variable for this bool if we want the SOCK5 server to be on the client side
@@ -93,7 +92,6 @@ func ssh(c *cli.Context) error {
 		OriginURL: url.String(),
 		Headers:   headers,
 		Host:      url.Host,
-		IsFedramp: c.Bool(fedrampFlag),
 	}

 	if connectTo := c.String(sshConnectTo); connectTo != "" {
@@ -106,7 +104,7 @@ func ssh(c *cli.Context) error {
 		case 3:
 			options.OriginURL = fmt.Sprintf("https://%s:%s", parts[2], parts[1])
 			options.TLSClientConfig = &tls.Config{
-				InsecureSkipVerify: true, // #nosec G402
+				InsecureSkipVerify: true,
 				ServerName:         parts[0],
 			}
 			log.Warn().Msgf("Using insecure SSL connection because SNI overridden to %s", parts[0])
@@ -143,5 +141,6 @@ func ssh(c *cli.Context) error {
 		logger := log.With().Str("host", url.Host).Logger()
 		s = stream.NewDebugStream(s, &logger, maxMessages)
 	}
-	return carrier.StartClient(wsConn, s, options)
+	carrier.StartClient(wsConn, s, options)
+	return nil
 }
@@ -19,7 +19,6 @@ import (

 	"github.com/cloudflare/cloudflared/carrier"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/sshgen"
 	"github.com/cloudflare/cloudflared/token"
@@ -27,7 +26,6 @@ import (
 )

 const (
-	appURLFlag         = "app"
 	loginQuietFlag     = "quiet"
 	sshHostnameFlag    = "hostname"
 	sshDestinationFlag = "destination"
@@ -51,7 +49,6 @@ Host {{.Hostname}}
  ProxyCommand {{.Cloudflared}} access ssh --hostname %h
 {{end}}
 `
-	fedrampFlag = "fedramp"
 )

 const sentryDSN = "https://56a9c9fa5c364ab28f34b14f35ea0f1b@sentry.io/189878"
@@ -80,20 +77,15 @@ func Commands() []*cli.Command {
 			Aliases:  []string{"forward"},
 			Category: "Access",
 			Usage:    "access <subcommand>",
-			Flags: []cli.Flag{&cli.BoolFlag{
-				Name:  fedrampFlag,
-				Usage: "use when performing operations in fedramp account",
-			}},
 			Description: `Cloudflare Access protects internal resources by securing, authenticating and monitoring access
 			per-user and by application. With Cloudflare Access, only authenticated users with the required permissions are
 			able to reach sensitive resources. The commands provided here allow you to interact with Access protected
 			applications from the command line.`,
 			Subcommands: []*cli.Command{
 				{
-					Name:      "login",
-					Action:    cliutil.Action(login),
-					Usage:     "login <url of access application>",
-					ArgsUsage: "url of Access application",
+					Name:   "login",
+					Action: cliutil.Action(login),
+					Usage:  "login <url of access application>",
 					Description: `The login subcommand initiates an authentication flow with your identity provider.
 					The subcommand will launch a browser. For headless systems, a url is provided.
 					Once authenticated with your identity provider, the login command will generate a JSON Web Token (JWT)
@@ -105,17 +97,6 @@ func Commands() []*cli.Command {
 							Aliases: []string{"q"},
 							Usage:   "do not print the jwt to the command line",
 						},
-						&cli.BoolFlag{
-							Name:  "no-verbose",
-							Usage: "print only the jwt to stdout",
-						},
-						&cli.BoolFlag{
-							Name:  "auto-close",
-							Usage: "automatically close the auth interstitial after action",
-						},
-						&cli.StringFlag{
-							Name: appURLFlag,
-						},
 					},
 				},
 				{
@@ -130,12 +111,12 @@ func Commands() []*cli.Command {
 				{
 					Name:        "token",
 					Action:      cliutil.Action(generateToken),
-					Usage:       "token <url of access application>",
+					Usage:       "token -app=<url of access application>",
 					ArgsUsage:   "url of Access application",
 					Description: `The token subcommand produces a JWT which can be used to authenticate requests.`,
 					Flags: []cli.Flag{
 						&cli.StringFlag{
-							Name: appURLFlag,
+							Name: "app",
 						},
 					},
 				},
@@ -182,15 +163,15 @@ func Commands() []*cli.Command {
 							EnvVars: []string{"TUNNEL_SERVICE_TOKEN_SECRET"},
 						},
 						&cli.StringFlag{
-							Name:  cfdflags.LogFile,
+							Name:  logger.LogFileFlag,
 							Usage: "Save application log to this file for reporting issues.",
 						},
 						&cli.StringFlag{
-							Name:  cfdflags.LogDirectory,
+							Name:  logger.LogSSHDirectoryFlag,
 							Usage: "Save application log to this directory for reporting issues.",
 						},
 						&cli.StringFlag{
-							Name:    cfdflags.LogLevelSSH,
+							Name:    logger.LogSSHLevelFlag,
 							Aliases: []string{"loglevel"}, //added to match the tunnel side
 							Usage:   "Application logging level {debug, info, warn, error, fatal}. ",
 						},
@@ -251,8 +232,9 @@ func login(c *cli.Context) error {

 	log := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)

-	appURL, err := getAppURLFromArgs(c)
-	if err != nil {
+	args := c.Args()
+	appURL, err := parseURL(args.First())
+	if args.Len() < 1 || err != nil {
 		log.Error().Msg("Please provide the url of the Access application")
 		return err
 	}
@@ -279,14 +261,7 @@ func login(c *cli.Context) error {
 	if c.Bool(loginQuietFlag) {
 		return nil
 	}
-
-	// Chatty by default for backward compat. The new --app flag
-	// is an implicit opt-out of the backwards-compatible chatty output.
-	if c.Bool("no-verbose") || c.IsSet(appURLFlag) {
-		fmt.Fprint(os.Stdout, cfdToken)
-	} else {
-		fmt.Fprintf(os.Stdout, "Successfully fetched your token:\n\n%s\n\n", cfdToken)
-	}
+	fmt.Fprintf(os.Stdout, "Successfully fetched your token:\n\n%s\n\n", cfdToken)

 	return nil
 }
@@ -331,7 +306,7 @@ func curl(c *cli.Context) error {
 			log.Info().Msg("You don't have an Access token set. Please run access token <access application> to fetch one.")
 			return run("curl", cmdArgs...)
 		}
-		tok, err = token.FetchToken(appURL, appInfo, c.Bool(cfdflags.AutoCloseInterstitial), c.Bool(fedrampFlag), log)
+		tok, err = token.FetchToken(appURL, appInfo, log)
 		if err != nil {
 			log.Err(err).Msg("Failed to refresh token")
 			return err
@@ -352,7 +327,7 @@ func run(cmd string, args ...string) error {
 		return err
 	}
 	go func() {
-		_, _ = io.Copy(os.Stderr, stderr)
+		io.Copy(os.Stderr, stderr)
 	}()

 	stdout, err := c.StdoutPipe()
@@ -360,22 +335,11 @@ func run(cmd string, args ...string) error {
 		return err
 	}
 	go func() {
-		_, _ = io.Copy(os.Stdout, stdout)
+		io.Copy(os.Stdout, stdout)
 	}()
 	return c.Run()
 }

-func getAppURLFromArgs(c *cli.Context) (*url.URL, error) {
-	var appURLStr string
-	args := c.Args()
-	if args.Len() < 1 {
-		appURLStr = c.String(appURLFlag)
-	} else {
-		appURLStr = args.First()
-	}
-	return parseURL(appURLStr)
-}
-
 // token dumps provided token to stdout
 func generateToken(c *cli.Context) error {
 	err := sentry.Init(sentry.ClientOptions{
@@ -385,8 +349,8 @@ func generateToken(c *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	appURL, err := getAppURLFromArgs(c)
-	if err != nil {
+	appURL, err := parseURL(c.String("app"))
+	if err != nil || c.NumFlags() < 1 {
 		fmt.Fprintln(os.Stderr, "Please provide a url.")
 		return err
 	}
@@ -451,7 +415,7 @@ func sshGen(c *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	cfdToken, err := token.FetchTokenWithRedirect(fetchTokenURL, appInfo, c.Bool(cfdflags.AutoCloseInterstitial), c.Bool(fedrampFlag), log)
+	cfdToken, err := token.FetchTokenWithRedirect(fetchTokenURL, appInfo, log)
 	if err != nil {
 		return err
 	}
@@ -541,7 +505,7 @@ func isFileThere(candidate string) bool {
 }

 // verifyTokenAtEdge checks for a token on disk, or generates a new one.
-// Then makes a request to the origin with the token to ensure it is valid.
+// Then makes a request to to the origin with the token to ensure it is valid.
 // Returns nil if token is valid.
 func verifyTokenAtEdge(appUrl *url.URL, appInfo *token.AppInfo, c *cli.Context, log *zerolog.Logger) error {
 	headers := parseRequestHeaders(c.StringSlice(sshHeaderFlag))
@@ -551,7 +515,7 @@ func verifyTokenAtEdge(appUrl *url.URL, appInfo *token.AppInfo, c *cli.Context,
 	if c.IsSet(sshTokenSecretFlag) {
 		headers.Add(cfAccessClientSecretHeader, c.String(sshTokenSecretFlag))
 	}
-	options := &carrier.StartOptions{AppInfo: appInfo, OriginURL: appUrl.String(), Headers: headers, AutoCloseInterstitial: c.Bool(cfdflags.AutoCloseInterstitial), IsFedramp: c.Bool(fedrampFlag)}
+	options := &carrier.StartOptions{AppInfo: appInfo, OriginURL: appUrl.String(), Headers: headers}

 	if valid, err := isTokenValid(options, log); err != nil {
 		return err
@@ -3,7 +3,6 @@ package access
 import (
 	"errors"
 	"fmt"
-	"net"
 	"net/http"
 	"net/url"
 	"strings"
@@ -24,24 +23,6 @@ func parseRequestHeaders(values []string) http.Header {
 	return headers
 }

-// bracketBareIPv6 wraps bare IPv6 addresses in a URL with square brackets.
-// Go 1.26 tightened net/url parsing to strictly require RFC 3986 bracket syntax
-// for IPv6 addresses in URLs. Before Go 1.26, bare forms like "http://::1" were
-// accepted; now they are rejected. This function detects bare IPv6 in the host
-// portion and brackets it so that url.ParseRequestURI can parse it correctly.
-func bracketBareIPv6(input string) string {
-	prefix := input[:strings.Index(input, "://")+3]
-	rest := input[len(prefix):]
-	host := rest
-	if i := strings.IndexAny(rest, "/?#"); i >= 0 {
-		host = rest[:i]
-	}
-	if net.ParseIP(host) != nil && strings.Contains(host, ":") {
-		return prefix + "[" + host + "]" + rest[len(host):]
-	}
-	return input
-}
-
 // parseHostname will attempt to convert a user provided URL string into a string with some light error checking on
 // certain expectations from the URL.
 // Will convert all HTTP URLs to HTTPS
@@ -52,7 +33,6 @@ func parseURL(input string) (*url.URL, error) {
 	if !strings.HasPrefix(input, "https://") && !strings.HasPrefix(input, "http://") {
 		input = fmt.Sprintf("https://%s", input)
 	}
-	input = bracketBareIPv6(input)
 	url, err := url.ParseRequestURI(input)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse as URL: %w", err)
@@ -5,7 +5,6 @@ import (
 	"testing"

 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )

 func TestParseRequestHeaders(t *testing.T) {
@@ -16,30 +15,6 @@ func TestParseRequestHeaders(t *testing.T) {
 	assert.Equal(t, "000:000:0:1:asd", values.Get("cf-trace-id"))
 }

-func TestBracketBareIPv6(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"https://::1", "https://[::1]"},
-		{"https://::1/path", "https://[::1]/path"},
-		{"https://::1:8080", "https://[::1:8080]"},
-		{"https://::1:8080/path", "https://[::1:8080]/path"},
-		{"https://::1?query=1", "https://[::1]?query=1"},         // query without path
-		{"https://::1#fragment", "https://[::1]#fragment"},       // fragment without path
-		{"https://[::1]", "https://[::1]"},                       // already bracketed
-		{"https://[::1]:8080", "https://[::1]:8080"},             // already bracketed with port
-		{"https://127.0.0.1", "https://127.0.0.1"},               // IPv4 unchanged
-		{"https://example.com", "https://example.com"},           // hostname unchanged
-		{"https://example.com:8080", "https://example.com:8080"}, // hostname:port unchanged
-	}
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			assert.Equal(t, tt.expected, bracketBareIPv6(tt.input))
-		})
-	}
-}
-
 func TestParseURL(t *testing.T) {
 	schemes := []string{
 		"http://",
@@ -53,8 +28,8 @@ func TestParseURL(t *testing.T) {
 		{"localhost", "localhost"},
 		{"127.0.0.1", "127.0.0.1"},
 		{"127.0.0.1:9090", "127.0.0.1:9090"},
-		{"::1", "[::1]"},
-		{"::1:8080", "[::1:8080]"},
+		{"::1", "::1"},
+		{"::1:8080", "::1:8080"},
 		{"[::1]", "[::1]"},
 		{"[::1]:8080", "[::1]:8080"},
 		{":8080", ":8080"},
@@ -74,7 +49,7 @@ func TestParseURL(t *testing.T) {
 					input := fmt.Sprintf("%s%s%s", scheme, host.input, path)
 					expected := fmt.Sprintf("%s%s%s", "https://", host.expected, path)
 					url, err := parseURL(input)
-					require.NoError(t, err, "input: %s\texpected: %s", input, expected)
+					assert.NoError(t, err, "input: %s\texpected: %s", input, expected)
 					assert.Equal(t, expected, url.String())
 					assert.Equal(t, host.expected, url.Host)
 					assert.Equal(t, "https", url.Scheme)
@@ -0,0 +1,87 @@
+package main
+
+import (
+	"github.com/rs/zerolog"
+
+	"github.com/cloudflare/cloudflared/config"
+	"github.com/cloudflare/cloudflared/tunneldns"
+)
+
+const (
+	// ResolverServiceType is used to identify what kind of overwatch service this is
+	ResolverServiceType = "resolver"
+
+	LogFieldResolverAddress          = "resolverAddress"
+	LogFieldResolverPort             = "resolverPort"
+	LogFieldResolverMaxUpstreamConns = "resolverMaxUpstreamConns"
+)
+
+// ResolverService is used to wrap the tunneldns package's DNS over HTTP
+// into a service model for the overwatch package.
+// it also holds a reference to the config object that represents its state
+type ResolverService struct {
+	resolver config.DNSResolver
+	shutdown chan struct{}
+	log      *zerolog.Logger
+}
+
+// NewResolverService creates a new resolver service
+func NewResolverService(r config.DNSResolver, log *zerolog.Logger) *ResolverService {
+	return &ResolverService{resolver: r,
+		shutdown: make(chan struct{}),
+		log:      log,
+	}
+}
+
+// Name is used to figure out this service is related to the others (normally the addr it binds to)
+// this is just "resolver" since there can only be one DNS resolver running
+func (s *ResolverService) Name() string {
+	return ResolverServiceType
+}
+
+// Type is used to identify what kind of overwatch service this is
+func (s *ResolverService) Type() string {
+	return ResolverServiceType
+}
+
+// Hash is used to figure out if this forwarder is the unchanged or not from the config file updates
+func (s *ResolverService) Hash() string {
+	return s.resolver.Hash()
+}
+
+// Shutdown stops the tunneldns listener
+func (s *ResolverService) Shutdown() {
+	s.shutdown <- struct{}{}
+}
+
+// Run is the run loop that is started by the overwatch service
+func (s *ResolverService) Run() error {
+	// create a listener
+	l, err := tunneldns.CreateListener(s.resolver.AddressOrDefault(), s.resolver.PortOrDefault(),
+		s.resolver.UpstreamsOrDefault(), s.resolver.BootstrapsOrDefault(), s.resolver.MaxUpstreamConnectionsOrDefault(), s.log)
+	if err != nil {
+		return err
+	}
+
+	// start the listener.
+	readySignal := make(chan struct{})
+	err = l.Start(readySignal)
+	if err != nil {
+		_ = l.Stop()
+		return err
+	}
+	<-readySignal
+
+	resolverLog := s.log.With().
+		Str(LogFieldResolverAddress, s.resolver.AddressOrDefault()).
+		Uint16(LogFieldResolverPort, s.resolver.PortOrDefault()).
+		Int(LogFieldResolverMaxUpstreamConns, s.resolver.MaxUpstreamConnectionsOrDefault()).
+		Logger()
+
+	resolverLog.Info().Msg("Starting resolver")
+
+	// wait for shutdown signal
+	<-s.shutdown
+	resolverLog.Info().Msg("Shutting down resolver")
+	return l.Stop()
+}
@@ -8,7 +8,7 @@ import (
 )

 // AppService is the main service that runs when no command lines flags are passed to cloudflared
-// it manages all the running services such as tunnels, forwarders, etc
+// it manages all the running services such as tunnels, forwarders, DNS resolver, etc
 type AppService struct {
 	configManager    config.Manager
 	serviceManager   overwatch.Manager
@@ -73,6 +73,14 @@ func (s *AppService) handleConfigUpdate(c config.Root) {
 		activeServices[service.Name()] = struct{}{}
 	}

+	// handle resolver changes
+	if c.Resolver.Enabled {
+		service := NewResolverService(c.Resolver, s.log)
+		s.serviceManager.Add(service)
+		activeServices[service.Name()] = struct{}{}
+
+	}
+
 	// TODO: TUN-1451 - tunnels

 	// remove any services that are no longer active
@@ -1,10 +1,7 @@
 package cliutil

 import (
-	"crypto/sha256"
 	"fmt"
-	"io"
-	"os"
 	"runtime"

 	"github.com/rs/zerolog"
@@ -16,7 +13,6 @@ type BuildInfo struct {
 	GoArch             string `json:"go_arch"`
 	BuildType          string `json:"build_type"`
 	CloudflaredVersion string `json:"cloudflared_version"`
-	Checksum           string `json:"checksum"`
 }

 func GetBuildInfo(buildType, version string) *BuildInfo {
@@ -26,12 +22,11 @@ func GetBuildInfo(buildType, version string) *BuildInfo {
 		GoArch:             runtime.GOARCH,
 		BuildType:          buildType,
 		CloudflaredVersion: version,
-		Checksum:           currentBinaryChecksum(),
 	}
 }

 func (bi *BuildInfo) Log(log *zerolog.Logger) {
-	log.Info().Msgf("Version %s (Checksum %s)", bi.CloudflaredVersion, bi.Checksum)
+	log.Info().Msgf("Version %s", bi.CloudflaredVersion)
 	if bi.BuildType != "" {
 		log.Info().Msgf("Built%s", bi.GetBuildTypeMsg())
 	}
@@ -56,28 +51,3 @@ func (bi *BuildInfo) GetBuildTypeMsg() string {
 func (bi *BuildInfo) UserAgent() string {
 	return fmt.Sprintf("cloudflared/%s", bi.CloudflaredVersion)
 }
-
-// FileChecksum opens a file and returns the SHA256 checksum.
-func FileChecksum(filePath string) (string, error) {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	h := sha256.New()
-	if _, err := io.Copy(h, f); err != nil {
-		return "", err
-	}
-
-	return fmt.Sprintf("%x", h.Sum(nil)), nil
-}
-
-func currentBinaryChecksum() string {
-	currentPath, err := os.Executable()
-	if err != nil {
-		return ""
-	}
-	sum, _ := FileChecksum(currentPath)
-	return sum
-}
@@ -1,38 +1,28 @@
 package cliutil

 import (
-	"strings"
-
-	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 	"github.com/urfave/cli/v2/altsrc"

-	"github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
+	"github.com/cloudflare/cloudflared/logger"
 )

 var (
 	debugLevelWarning = "At debug level cloudflared will log request URL, method, protocol, content length, as well as, all request and response headers. " +
 		"This can expose sensitive information in your logs."
-
-	FlagLogOutput = &cli.StringFlag{
-		Name:    flags.LogFormatOutput,
-		Usage:   "Output format for the logs (default, json)",
-		Value:   flags.LogFormatOutputValueDefault,
-		EnvVars: []string{"TUNNEL_MANAGEMENT_OUTPUT", "TUNNEL_LOG_OUTPUT"},
-	}
 )

 func ConfigureLoggingFlags(shouldHide bool) []cli.Flag {
 	return []cli.Flag{
 		altsrc.NewStringFlag(&cli.StringFlag{
-			Name:    flags.LogLevel,
+			Name:    logger.LogLevelFlag,
 			Value:   "info",
 			Usage:   "Application logging level {debug, info, warn, error, fatal}. " + debugLevelWarning,
 			EnvVars: []string{"TUNNEL_LOGLEVEL"},
 			Hidden:  shouldHide,
 		}),
 		altsrc.NewStringFlag(&cli.StringFlag{
-			Name:    flags.TransportLogLevel,
+			Name:    logger.LogTransportLevelFlag,
 			Aliases: []string{"proto-loglevel"}, // This flag used to be called proto-loglevel
 			Value:   "info",
 			Usage:   "Transport logging level(previously called protocol logging level) {debug, info, warn, error, fatal}",
@@ -40,77 +30,22 @@ func ConfigureLoggingFlags(shouldHide bool) []cli.Flag {
 			Hidden:  shouldHide,
 		}),
 		altsrc.NewStringFlag(&cli.StringFlag{
-			Name:    flags.LogFile,
+			Name:    logger.LogFileFlag,
 			Usage:   "Save application log to this file for reporting issues.",
 			EnvVars: []string{"TUNNEL_LOGFILE"},
 			Hidden:  shouldHide,
 		}),
 		altsrc.NewStringFlag(&cli.StringFlag{
-			Name:    flags.LogDirectory,
+			Name:    logger.LogDirectoryFlag,
 			Usage:   "Save application log to this directory for reporting issues.",
 			EnvVars: []string{"TUNNEL_LOGDIRECTORY"},
 			Hidden:  shouldHide,
 		}),
 		altsrc.NewStringFlag(&cli.StringFlag{
-			Name:    flags.TraceOutput,
+			Name:    "trace-output",
 			Usage:   "Name of trace output file, generated when cloudflared stops.",
 			EnvVars: []string{"TUNNEL_TRACE_OUTPUT"},
 			Hidden:  shouldHide,
 		}),
-		FlagLogOutput,
 	}
 }
-
-// LogTable renders lines inside an ASCII table and logs each rendered row.
-func LogTable(log *zerolog.Logger, lines []string, title ...string) {
-	tableTitle := ""
-	if len(title) > 0 {
-		tableTitle = title[0]
-	}
-	for _, line := range asciiBox(lines, tableTitle, 2) {
-		if line != "" {
-			log.Info().Msg(line)
-		}
-	}
-}
-
-// asciiBox wraps lines in a bordered ASCII box with an optional title row.
-func asciiBox(lines []string, title string, padding int) (box []string) {
-	maxLen := maxLen(lines, title)
-	spacer := strings.Repeat(" ", padding)
-	border := "+" + strings.Repeat("-", maxLen+(padding*2)) + "+"
-	box = append(box, border)
-	if title != "" {
-		box = append(box, renderBoxLine(centerLine(title, maxLen), maxLen, spacer))
-		box = append(box, border)
-	}
-	for _, line := range lines {
-		box = append(box, renderBoxLine(line, maxLen, spacer))
-	}
-	box = append(box, border)
-	return
-}
-
-// renderBoxLine pads a single line so it fills the box width.
-func renderBoxLine(line string, maxLen int, spacer string) string {
-	return "|" + spacer + line + strings.Repeat(" ", maxLen-len(line)) + spacer + "|"
-}
-
-// centerLine pads line evenly so it is centered within width.
-func centerLine(line string, width int) string {
-	padding := width - len(line)
-	leftPadding := padding / 2
-	rightPadding := padding - leftPadding
-	return strings.Repeat(" ", leftPadding) + line + strings.Repeat(" ", rightPadding)
-}
-
-// maxLen returns the longest visible line length including the title.
-func maxLen(lines []string, title string) int {
-	max := len(title)
-	for _, line := range lines {
-		if len(line) > max {
-			max = len(line)
-		}
-	}
-	return max
-}
@@ -1,60 +0,0 @@
-package cliutil
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/rs/zerolog"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestLogTableWithoutTitle(t *testing.T) {
-	t.Parallel()
-
-	lines := captureTableLogs(t, []string{"first", "second"})
-
-	assert.Equal(t, []string{
-		"+----------+",
-		"|  first   |",
-		"|  second  |",
-		"+----------+",
-	}, lines)
-}
-
-func TestLogTableWithTitle(t *testing.T) {
-	t.Parallel()
-
-	lines := captureTableLogs(t, []string{"first", "second"}, "TT")
-
-	assert.Equal(t, []string{
-		"+----------+",
-		"|    TT    |",
-		"+----------+",
-		"|  first   |",
-		"|  second  |",
-		"+----------+",
-	}, lines)
-}
-
-func captureTableLogs(t *testing.T, lines []string, title ...string) []string {
-	t.Helper()
-
-	var buf bytes.Buffer
-	logger := zerolog.New(&buf)
-
-	LogTable(&logger, lines, title...)
-
-	// nolint: prealloc
-	var messages []string
-	for _, line := range bytes.Split(bytes.TrimSpace(buf.Bytes()), []byte("\n")) {
-		var entry struct {
-			Message string `json:"message"`
-		}
-		require.NoError(t, json.Unmarshal(line, &entry))
-		messages = append(messages, entry.Message)
-	}
-
-	return messages
-}
@@ -1,84 +0,0 @@
-package cliutil
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/mattn/go-colorable"
-	"github.com/rs/zerolog"
-	"github.com/urfave/cli/v2"
-
-	"github.com/cloudflare/cloudflared/cfapi"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
-	"github.com/cloudflare/cloudflared/credentials"
-)
-
-// Error definitions for management token operations
-var (
-	ErrNoTunnelID      = errors.New("no tunnel ID provided")
-	ErrInvalidTunnelID = errors.New("unable to parse provided tunnel id as a valid UUID")
-)
-
-// GetManagementToken acquires a management token from Cloudflare API for the specified resource
-func GetManagementToken(c *cli.Context, log *zerolog.Logger, res cfapi.ManagementResource, buildInfo *BuildInfo) (string, error) {
-	userCreds, err := credentials.Read(c.String(cfdflags.OriginCert), log)
-	if err != nil {
-		return "", err
-	}
-
-	var apiURL string
-	if userCreds.IsFEDEndpoint() {
-		apiURL = credentials.FedRampBaseApiURL
-	} else {
-		apiURL = c.String(cfdflags.ApiURL)
-	}
-
-	client, err := userCreds.Client(apiURL, buildInfo.UserAgent(), log)
-	if err != nil {
-		return "", err
-	}
-
-	tunnelIDString := c.Args().First()
-	if tunnelIDString == "" {
-		return "", ErrNoTunnelID
-	}
-	tunnelID, err := uuid.Parse(tunnelIDString)
-	if err != nil {
-		return "", fmt.Errorf("%w: %v", ErrInvalidTunnelID, err)
-	}
-
-	token, err := client.GetManagementToken(tunnelID, res)
-	if err != nil {
-		return "", err
-	}
-
-	return token, nil
-}
-
-// CreateStderrLogger creates a logger that outputs to stderr to avoid interfering with stdout
-func CreateStderrLogger(c *cli.Context) *zerolog.Logger {
-	level, levelErr := zerolog.ParseLevel(c.String(cfdflags.LogLevel))
-	if levelErr != nil {
-		level = zerolog.InfoLevel
-	}
-	var writer io.Writer
-	switch c.String(cfdflags.LogFormatOutput) {
-	case cfdflags.LogFormatOutputValueJSON:
-		// zerolog by default outputs as JSON
-		writer = os.Stderr
-	case cfdflags.LogFormatOutputValueDefault:
-		// "default" and unset use the same logger output format
-		fallthrough
-	default:
-		writer = zerolog.ConsoleWriter{
-			Out:        colorable.NewColorable(os.Stderr),
-			TimeFormat: time.RFC3339,
-		}
-	}
-	log := zerolog.New(writer).With().Timestamp().Logger().Level(level)
-	return &log
-}
@@ -1,11 +1,6 @@
 package main

 import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"

@@ -13,85 +8,23 @@ import (
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/tunnel"
 )

-const (
-	defaultTokenFile = "token"
-)
-
-func ensureConfigDirExists(configDir string) error {
-	if err := os.Mkdir(configDir, 0o755); err != nil { //nolint:gosec // config dir must be traversable by non-root user
-		if errors.Is(err, os.ErrExist) {
-			return nil
-		}
-		return fmt.Errorf("create config dir at %s: %w", configDir, err)
-	}
-	return nil
-}
-
-func createTokenFileUnix(path string) error {
-	const tokenPerms os.FileMode = 0o600
-	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, tokenPerms) //nolint:gosec // All callers of this function construct path from constant strings or well-known env vars (e.g., $HOME)
-	if err != nil {
-		return fmt.Errorf("create token file at %s: %w", path, err)
-	}
-	defer func() { _ = f.Close() }()
-
-	// If the file already existed with unrestrictive permissions, os.OpenFile
-	// will not update its permissions, so perform an extra os.Chmod
-	if err := os.Chmod(path, tokenPerms); err != nil {
-		return fmt.Errorf("chmod token file at %s: %w", path, err)
-	}
-
-	return nil
-}
-
-// Write out the token file to the configuration directory with the correct
-// permissions. Since the method used to restrict the permissions is platform
-// dependent, make the function used to restrict the permissions an injectable
-// dependency
-func writeTokenToFile(path string, token string) error {
+func buildArgsForToken(c *cli.Context, log *zerolog.Logger) ([]string, error) {
+	token := c.Args().First()
 	if _, err := tunnel.ParseToken(token); err != nil {
-		return cliutil.UsageError("Provided tunnel token is not valid (%s).", err)
+		return nil, cliutil.UsageError("Provided tunnel token is not valid (%s).", err)
 	}

-	if err := createTokenFile(path); err != nil {
-		return fmt.Errorf("create token file at %s: %w", path, err)
-	}
-
-	// Won't update permissions as file already exists
-	if err := os.WriteFile(path, []byte(token), 0o600); err != nil {
-		return fmt.Errorf("write token to %s: %w", path, err)
-	}
-
-	return nil
-}
-
-func removeTokenFile(configDir string, log *zerolog.Logger) {
-	tp := tokenPath(configDir)
-	err := os.Remove(tp)
-
-	if err != nil && !errors.Is(err, os.ErrNotExist) {
-		log.Warn().Msgf("Could not remove service token file at %s: %v", tp, err)
-	}
-}
-
-func buildArgsForTokenFile(configDir string) []string {
 	return []string{
-		"tunnel", "run", "--token-file", tokenPath(configDir),
-	}
+		"tunnel", "run", "--token", token,
+	}, nil
 }

-func tokenPath(configDir string) string {
-	return filepath.Join(configDir, defaultTokenFile)
-}
-
-func writeTokenToConfigDir(c *cli.Context, configDir string) error {
-	if err := ensureConfigDirExists(configDir); err != nil {
-		return err
+func getServiceExtraArgsFromCliArgs(c *cli.Context, log *zerolog.Logger) ([]string, error) {
+	if c.NArg() > 0 {
+		// currently, we only support extra args for token
+		return buildArgsForToken(c, log)
+	} else {
+		// empty extra args
+		return make([]string, 0), nil
 	}
-
-	if err := writeTokenToFile(tokenPath(configDir), c.Args().First()); err != nil {
-		return err
-	}
-
-	return nil
 }
@@ -1,172 +0,0 @@
-package flags
-
-const (
-	// HaConnections specifies how many connections to make to the edge
-	HaConnections = "ha-connections"
-
-	// SshPort is the port on localhost the cloudflared ssh server will run on
-	SshPort = "local-ssh-port"
-
-	// SshIdleTimeout defines the duration a SSH session can remain idle before being closed
-	SshIdleTimeout = "ssh-idle-timeout"
-
-	// SshMaxTimeout defines the max duration a SSH session can remain open for
-	SshMaxTimeout = "ssh-max-timeout"
-
-	// SshLogUploaderBucketName is the bucket name to use for the SSH log uploader
-	SshLogUploaderBucketName = "bucket-name"
-
-	// SshLogUploaderRegionName is the AWS region name to use for the SSH log uploader
-	SshLogUploaderRegionName = "region-name"
-
-	// SshLogUploaderSecretID is the Secret id of SSH log uploader
-	SshLogUploaderSecretID = "secret-id"
-
-	// SshLogUploaderAccessKeyID is the Access key id of SSH log uploader
-	SshLogUploaderAccessKeyID = "access-key-id"
-
-	// SshLogUploaderSessionTokenID is the Session token of SSH log uploader
-	SshLogUploaderSessionTokenID = "session-token"
-
-	// SshLogUploaderS3URL is the S3 URL of SSH log uploader (e.g. don't use AWS s3 and use google storage bucket instead)
-	SshLogUploaderS3URL = "s3-url-host"
-
-	// HostKeyPath is the path of the dir to save SSH host keys too
-	HostKeyPath = "host-key-path"
-
-	// RpcTimeout is how long to wait for a Capnp RPC request to the edge
-	RpcTimeout = "rpc-timeout"
-
-	// WriteStreamTimeout sets if we should have a timeout when writing data to a stream towards the destination (edge/origin).
-	WriteStreamTimeout = "write-stream-timeout"
-
-	// QuicDisablePathMTUDiscovery sets if QUIC should not perform PTMU discovery and use a smaller (safe) packet size.
-	// Packets will then be at most 1252 (IPv4) / 1232 (IPv6) bytes in size.
-	// Note that this may result in packet drops for UDP proxying, since we expect being able to send at least 1280 bytes of inner packets.
-	QuicDisablePathMTUDiscovery = "quic-disable-pmtu-discovery"
-
-	// QuicConnLevelFlowControlLimit controls the max flow control limit allocated for a QUIC connection. This controls how much data is the
-	// receiver willing to buffer. Once the limit is reached, the sender will send a DATA_BLOCKED frame to indicate it has more data to write,
-	// but it's blocked by flow control
-	QuicConnLevelFlowControlLimit = "quic-connection-level-flow-control-limit"
-
-	// QuicStreamLevelFlowControlLimit is similar to quicConnLevelFlowControlLimit but for each QUIC stream. When the sender is blocked,
-	// it will send a STREAM_DATA_BLOCKED frame
-	QuicStreamLevelFlowControlLimit = "quic-stream-level-flow-control-limit"
-
-	// Ui is to enable launching cloudflared in interactive UI mode
-	Ui = "ui"
-
-	// ConnectorLabel is the command line flag to give a meaningful label to a specific connector
-	ConnectorLabel = "label"
-
-	// MaxActiveFlows is the command line flag to set the maximum number of flows that cloudflared can be processing at the same time
-	MaxActiveFlows = "max-active-flows"
-
-	// Tag is the command line flag to set custom tags used to identify this tunnel via added HTTP request headers to the origin
-	Tag = "tag"
-
-	// Protocol is the command line flag to set the protocol to use to connect to the Cloudflare Edge
-	Protocol = "protocol"
-
-	// PostQuantum is the command line flag to force the connection to Cloudflare Edge to use Post Quantum cryptography
-	PostQuantum = "post-quantum"
-
-	// Features is the command line flag to opt into various features that are still being developed or tested
-	Features = "features"
-
-	// EdgeIpVersion is the command line flag to set the Cloudflare Edge IP address version to connect with
-	EdgeIpVersion = "edge-ip-version"
-
-	// EdgeBindAddress is the command line flag to bind to IP address for outgoing connections to Cloudflare Edge
-	EdgeBindAddress = "edge-bind-address"
-
-	// CACert Certificate Authority authenticating connections with Cloudflare's edge network.
-	CACert = "cacert"
-
-	// Force is the command line flag to specify if you wish to force an action
-	Force = "force"
-
-	// Edge is the command line flag to set the address of the Cloudflare tunnel server. Only works in Cloudflare's internal testing environment
-	Edge = "edge"
-
-	// Region is the command line flag to set the Cloudflare Edge region to connect to
-	Region = "region"
-
-	// IsAutoUpdated is the command line flag to signal the new process that cloudflared has been autoupdated
-	IsAutoUpdated = "is-autoupdated"
-
-	// LBPool is the command line flag to set the name of the load balancing pool to add this origin to
-	LBPool = "lb-pool"
-
-	// Retries is the command line flag to set the maximum number of retries for connection/protocol errors
-	Retries = "retries"
-
-	// MaxEdgeAddrRetries is the command line flag to set the maximum number of times to retry on edge addrs before falling back to a lower protocol
-	MaxEdgeAddrRetries = "max-edge-addr-retries"
-
-	// GracePeriod is the command line flag to set the maximum amount of time that cloudflared waits to shut down if it is still serving requests
-	GracePeriod = "grace-period"
-
-	// ICMPV4Src is the command line flag to set the source address and the interface name to send/receive ICMPv4 messages
-	ICMPV4Src = "icmpv4-src"
-
-	// ICMPV6Src is the command line flag to set the source address and the interface name to send/receive ICMPv6 messages
-	ICMPV6Src = "icmpv6-src"
-
-	// Name is the command line to set the name of the tunnel
-	Name = "name"
-
-	// AutoUpdateFreq is the command line for setting the frequency that cloudflared checks for updates
-	AutoUpdateFreq = "autoupdate-freq"
-
-	// NoAutoUpdate is the command line flag to disable cloudflared from checking for updates
-	NoAutoUpdate = "no-autoupdate"
-
-	// NoPrechecks is the command line flag to skip connectivity pre-checks at startup.
-	NoPrechecks = "no-prechecks"
-
-	// LogLevel is the command line flag for the cloudflared logging level
-	LogLevel = "loglevel"
-
-	// LogLevelSSH is the command line flag for the cloudflared ssh logging level
-	LogLevelSSH = "log-level"
-
-	// TransportLogLevel is the command line flag for the transport logging level
-	TransportLogLevel = "transport-loglevel"
-
-	// LogFile is the command line flag to define the file where application logs will be stored
-	LogFile = "logfile"
-
-	// LogDirectory is the command line flag to define the directory where application logs will be stored.
-	LogDirectory = "log-directory"
-
-	// LogFormatOutput allows the command line logs to be output as JSON.
-	LogFormatOutput             = "output"
-	LogFormatOutputValueDefault = "default"
-	LogFormatOutputValueJSON    = "json"
-
-	// TraceOutput is the command line flag to set the name of trace output file
-	TraceOutput = "trace-output"
-
-	// OriginCert is the command line flag to define the path for the origin certificate used by cloudflared
-	OriginCert = "origincert"
-
-	// Metrics is the command line flag to define the address of the metrics server
-	Metrics = "metrics"
-
-	// MetricsUpdateFreq is the command line flag to define how frequently tunnel metrics are updated
-	MetricsUpdateFreq = "metrics-update-freq"
-
-	// ApiURL is the command line flag used to define the base URL of the API
-	ApiURL = "api-url"
-
-	// Virtual DNS resolver service resolver addresses to use instead of dynamically fetching them from the OS.
-	VirtualDNSServiceResolverAddresses = "dns-resolver-addrs"
-
-	// Management hostname to signify incoming management requests
-	ManagementHostname = "management-hostname"
-
-	// Automatically close the login interstitial browser window after the user makes a decision.
-	AutoCloseInterstitial = "auto-close"
-)
@@ -3,38 +3,11 @@
 package main

 import (
-	"fmt"
 	"os"

 	cli "github.com/urfave/cli/v2"
-
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 )

 func runApp(app *cli.App, graceShutdownC chan struct{}) {
-	app.Commands = append(app.Commands, &cli.Command{
-		Name:  "service",
-		Usage: "Manages the cloudflared system service (not supported on this operating system)",
-		Subcommands: []*cli.Command{
-			{
-				Name:   "install",
-				Usage:  "Install cloudflared as a system service (not supported on this operating system)",
-				Action: cliutil.ConfiguredAction(installGenericService),
-			},
-			{
-				Name:   "uninstall",
-				Usage:  "Uninstall the cloudflared service (not supported on this operating system)",
-				Action: cliutil.ConfiguredAction(uninstallGenericService),
-			},
-		},
-	})
 	app.Run(os.Args)
 }
-
-func installGenericService(c *cli.Context) error {
-	return fmt.Errorf("service installation is not supported on this operating system")
-}
-
-func uninstallGenericService(c *cli.Context) error {
-	return fmt.Errorf("service uninstallation is not supported on this operating system")
-}
@@ -1,39 +0,0 @@
-// Package inits provides detection of the init system managing the host
-// (systemd, OpenRC, or SysV). It is shared by the service installer and the
-// auto-updater so that init-system detection lives in a single place.
-//
-// The functions are safe to call on any GOOS; on non-Linux platforms they
-// report that no Linux init system is in use.
-package inits
-
-import (
-	"os"
-	"runtime"
-)
-
-// IsSystemd reports whether the host is managed by systemd.
-func IsSystemd() bool {
-	_, err := os.Stat("/run/systemd/system")
-	return err == nil
-}
-
-// IsOpenRC reports whether the host is managed by OpenRC.
-func IsOpenRC() bool {
-	for _, path := range []string{"/sbin/openrc-run", "/usr/sbin/openrc-run", "/usr/bin/openrc-run"} {
-		if _, err := os.Stat(path); err == nil {
-			return true
-		}
-	}
-	return false
-}
-
-// IsSysV reports whether the host relies on a SysV-style init system, i.e. a
-// Linux host that is managed by neither systemd nor OpenRC. systemd and OpenRC
-// keep the service alive themselves, so only SysV needs the process to restart
-// itself after an auto-update.
-func IsSysV() bool {
-	if runtime.GOOS != "linux" {
-		return false
-	}
-	return !IsSystemd() && !IsOpenRC()
-}
@@ -3,42 +3,26 @@
 package main

 import (
-	"errors"
 	"fmt"
-	"io"
 	"os"

 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/inits"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/tunnel"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/logger"
 )

-func runApp(app *cli.App, _ chan struct{}) {
+func runApp(app *cli.App, graceShutdownC chan struct{}) {
 	app.Commands = append(app.Commands, &cli.Command{
 		Name:  "service",
 		Usage: "Manages the cloudflared system service",
 		Subcommands: []*cli.Command{
 			{
-				Name:      "install",
-				Usage:     "Install cloudflared as a system service",
-				ArgsUsage: "[TOKEN]",
-				Description: `
-Installs cloudflared as a service using the detected init system (e.g., sysv,
-systemd, openrc).
-
-A token may optionally be provided. If a token is provided, it will be written
-to disk in the service configuration directory and the cloudflared service
-configured to use it via the --token-file argument.
-
-If no token is provided, cloudflared will attempt to find a configuration file
-with tunnel credentials from a predetermined list of configuration directory
-paths. If found, it will use that configuration file and credentials (or error
-out if no configuration file with credentials was found).`,
+				Name:   "install",
+				Usage:  "Install cloudflared as a system service",
 				Action: cliutil.ConfiguredAction(installLinuxService),
 				Flags: []cli.Flag{
 					noUpdateServiceFlag,
@@ -51,7 +35,7 @@ out if no configuration file with credentials was found).`,
 			},
 		},
 	})
-	_ = app.Run(os.Args)
+	app.Run(os.Args)
 }

 // The directory and files that are used by the service.
@@ -64,22 +48,18 @@ const (
 	cloudflaredService       = "cloudflared.service"
 	cloudflaredUpdateService = "cloudflared-update.service"
 	cloudflaredUpdateTimer   = "cloudflared-update.timer"
-	cloudflaredOpenRCService = "cloudflared"
 )

-// OS-specific function for token file creation
-var createTokenFile = createTokenFileUnix
-
 var systemdAllTemplates = map[string]ServiceTemplate{
 	cloudflaredService: {
 		Path: fmt.Sprintf("/etc/systemd/system/%s", cloudflaredService),
 		Content: `[Unit]
-Description=Cloudflare Tunnel client
+Description=cloudflared
 After=network-online.target
 Wants=network-online.target

 [Service]
-TimeoutStartSec=15
+TimeoutStartSec=0
 Type=notify
 ExecStart={{ .Path }} --no-autoupdate{{ range .ExtraArgs }} {{ . }}{{ end }}
 Restart=on-failure
@@ -116,12 +96,11 @@ WantedBy=timers.target

 var sysvTemplate = ServiceTemplate{
 	Path:     "/etc/init.d/cloudflared",
-	FileMode: 0o755,
-	// nolint: dupword
+	FileMode: 0755,
 	Content: `#!/bin/sh
 # For RedHat and cousins:
 # chkconfig: 2345 99 01
-# description: Cloudflare Tunnel client
+# description: cloudflared
 # processname: {{.Path}}
 ### BEGIN INIT INFO
 # Provides:          {{.Path}}
@@ -129,8 +108,8 @@ var sysvTemplate = ServiceTemplate{
 # Required-Stop:
 # Default-Start:     2 3 4 5
 # Default-Stop:      0 1 6
-# Short-Description: Cloudflare Tunnel client
-# Description:       Cloudflare Tunnel client
+# Short-Description: cloudflared
+# Description:       cloudflared agent
 ### END INIT INFO
 name=$(basename $(readlink -f $0))
 cmd="{{.Path}} --pidfile /var/run/$name.pid {{ range .ExtraArgs }} {{ . }}{{ end }}"
@@ -205,50 +184,19 @@ exit 0
 `,
 }

-var openrcTemplate = ServiceTemplate{
-	Path:     "/etc/init.d/" + cloudflaredOpenRCService,
-	FileMode: 0o755,
-	Content: `#!/sbin/openrc-run
+var (
+	noUpdateServiceFlag = &cli.BoolFlag{
+		Name:  "no-update-service",
+		Usage: "Disable auto-update of the cloudflared linux service, which restarts the server to upgrade for new versions.",
+		Value: false,
+	}
+)

-description="Cloudflare Tunnel client"
-
-: "${cloudflared_user:=root}"
-
-command="{{.Path}}"
-command_args="{{ range .ExtraArgs }} {{ . }}{{ end }}"
-command_user="${cloudflared_user}"
-
-pidfile="/run/${RC_SVCNAME}.pid"
-output_log="/var/log/${RC_SVCNAME}.log"
-error_log="/var/log/${RC_SVCNAME}.err"
-
-# Use OpenRC's supervisor so the tunnel is restarted on failure.
-supervisor="supervise-daemon"
-respawn_delay=5
-respawn_max=0
-
-depend() {
-	need net
-	use dns logger
-	after net firewall
-}
-`,
-}
-
-var openrcConfTemplate = ServiceTemplate{
-	Path:     "/etc/conf.d/" + cloudflaredOpenRCService,
-	FileMode: 0o644,
-	Content: `# Configuration for the cloudflared OpenRC service.
-
-# User the cloudflared daemon runs as. Defaults to root.
-#cloudflared_user="cloudflared"
-`,
-}
-
-var noUpdateServiceFlag = &cli.BoolFlag{
-	Name:  "no-update-service",
-	Usage: "Disable auto-update of the cloudflared linux service, which restarts the server to upgrade for new versions.",
-	Value: false,
+func isSystemd() bool {
+	if _, err := os.Stat("/run/systemd/system"); err == nil {
+		return true
+	}
+	return false
 }

 func installLinuxService(c *cli.Context) error {
@@ -262,46 +210,27 @@ func installLinuxService(c *cli.Context) error {
 		Path: etPath,
 	}

-	var extraArgs []string
+	// Check if the "no update flag" is set
+	autoUpdate := !c.IsSet(noUpdateServiceFlag.Name)
+
+	var extraArgsFunc func(c *cli.Context, log *zerolog.Logger) ([]string, error)
 	if c.NArg() == 0 {
-		// If passed no arguments e.g., "$ cloudflared service install",
-		// install the service using the detected config file (or error-out if
-		// no config exists).
-		if extraArgs, err = buildArgsForConfig(c, log); err != nil {
-			return err
-		}
+		extraArgsFunc = buildArgsForConfig
 	} else {
-		// If passed one argument e.g., "$ cloudflared service install <token>"
-		// write the token to the config directory and install the service
-		// using --token-file pointing to that file. This is the quick setup
-		// the tunnel UI suggests.
+		extraArgsFunc = buildArgsForToken
+	}

-		// Ensure token file is removed if install fails
-		defer func() {
-			if err != nil {
-				removeTokenFile(serviceConfigDir, log)
-			}
-		}()
-
-		if err = writeTokenToConfigDir(c, serviceConfigDir); err != nil {
-			return fmt.Errorf("could not write token to configuration directory: %w", err)
-		}
-
-		extraArgs = buildArgsForTokenFile(serviceConfigDir)
+	extraArgs, err := extraArgsFunc(c, log)
+	if err != nil {
+		return err
 	}

 	templateArgs.ExtraArgs = extraArgs

-	// Check if the "no update flag" is set
-	autoUpdate := !c.IsSet(noUpdateServiceFlag.Name)
-
 	switch {
-	case inits.IsSystemd():
+	case isSystemd():
 		log.Info().Msgf("Using Systemd")
 		err = installSystemd(&templateArgs, autoUpdate, log)
-	case inits.IsOpenRC():
-		log.Info().Msgf("Using OpenRC")
-		err = installOpenRC(&templateArgs, autoUpdate)
 	default:
 		log.Info().Msgf("Using SysV")
 		err = installSysv(&templateArgs, autoUpdate, log)
@@ -329,11 +258,14 @@ func buildArgsForConfig(c *cli.Context, log *zerolog.Logger) ([]string, error) {
 		return err == nil && val != ""
 	}
 	if src.TunnelID == "" || !configPresent(tunnel.CredFileFlag) {
-		return nil, fmt.Errorf("configuration file %s must contain entries for the tunnel to run and its associated credentials (tunnel: TUNNEL-UUID, credentials-file: CREDENTIALS-FILE)", src.Source())
+		return nil, fmt.Errorf(`Configuration file %s must contain entries for the tunnel to run and its associated credentials:
+tunnel: TUNNEL-UUID
+credentials-file: CREDENTIALS-FILE
+`, src.Source())
 	}
 	if src.Source() != serviceConfigPath {
 		if exists, err := config.FileExists(serviceConfigPath); err != nil || exists {
-			return nil, fmt.Errorf("possible conflicting configuration in %[1]s and %[2]s. Either remove %[2]s or run `cloudflared --config %[2]s service install`", src.Source(), serviceConfigPath)
+			return nil, fmt.Errorf("Possible conflicting configuration in %[1]s and %[2]s. Either remove %[2]s or run `cloudflared --config %[2]s service install`", src.Source(), serviceConfigPath)
 		}

 		if err := copyFile(src.Source(), serviceConfigPath); err != nil {
@@ -416,51 +348,22 @@ func installSysv(templateArgs *ServiceTemplateArgs, autoUpdate bool, log *zerolo
 	return runCommand("service", "cloudflared", "start")
 }

-func installOpenRC(templateArgs *ServiceTemplateArgs, autoUpdate bool) error {
-	if autoUpdate {
-		templateArgs.ExtraArgs = append([]string{"--autoupdate-freq", "24h0m0s"}, templateArgs.ExtraArgs...)
-	} else {
-		templateArgs.ExtraArgs = append([]string{"--no-autoupdate"}, templateArgs.ExtraArgs...)
-	}
-
-	if err := openrcConfTemplate.Generate(templateArgs); err != nil {
-		return fmt.Errorf("error generating OpenRC conf.d template: %w", err)
-	}
-	if err := openrcTemplate.Generate(templateArgs); err != nil {
-		return fmt.Errorf("error generating OpenRC service template: %w", err)
-	}
-
-	if err := runCommand("rc-update", "add", cloudflaredOpenRCService, "default"); err != nil {
-		return fmt.Errorf("rc-update add %s default: %w", cloudflaredOpenRCService, err)
-	}
-	if err := runCommand("rc-service", cloudflaredOpenRCService, "start"); err != nil {
-		return fmt.Errorf("rc-service %s start: %w", cloudflaredOpenRCService, err)
-	}
-	return nil
-}
-
 func uninstallLinuxService(c *cli.Context) error {
 	log := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)

 	var err error
 	switch {
-	case inits.IsSystemd():
+	case isSystemd():
 		log.Info().Msg("Using Systemd")
 		err = uninstallSystemd(log)
-	case inits.IsOpenRC():
-		log.Info().Msg("Using OpenRC")
-		err = uninstallOpenRC(log)
 	default:
 		log.Info().Msg("Using SysV")
 		err = uninstallSysv(log)
 	}

-	removeTokenFile(serviceConfigDir, log)
-
 	if err == nil {
 		log.Info().Msg("Linux service for cloudflared uninstalled successfully")
 	}
-
 	return err
 }

@@ -468,11 +371,7 @@ func uninstallSystemd(log *zerolog.Logger) error {
 	// Get only the installed services
 	installedServices := make(map[string]ServiceTemplate)
 	for serviceName, serviceTemplate := range systemdAllTemplates {
-		path, err := serviceTemplate.ResolvePath()
-		if err != nil {
-			return fmt.Errorf("error resolving path for service %q: %w", serviceName, err)
-		}
-		if _, err := os.Stat(path); err == nil {
+		if err := runCommand("systemctl", "list-units", "--all", "|", "grep", serviceName); err == nil {
 			installedServices[serviceName] = serviceTemplate
 		} else {
 			log.Info().Msgf("Service '%s' not installed, skipping its uninstall", serviceName)
@@ -531,49 +430,3 @@ func uninstallSysv(log *zerolog.Logger) error {
 	}
 	return nil
 }
-
-func uninstallOpenRC(log *zerolog.Logger) error {
-	if err := runCommand("rc-service", cloudflaredOpenRCService, "stop"); err != nil {
-		log.Warn().Err(err).Msg("could not stop cloudflared OpenRC service, continuing uninstall")
-	}
-	if err := runCommand("rc-update", "del", cloudflaredOpenRCService, "default"); err != nil {
-		log.Warn().Err(err).Msg("could not remove cloudflared from the default runlevel, continuing uninstall")
-	}
-	for _, template := range []ServiceTemplate{openrcTemplate, openrcConfTemplate} {
-		path, err := template.ResolvePath()
-		if err != nil {
-			return fmt.Errorf("error resolving OpenRC template path: %w", err)
-		}
-		if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) {
-			return fmt.Errorf("error removing %s: %w", path, err)
-		}
-	}
-	return nil
-}
-
-func copyFile(src, dest string) error {
-	srcFile, err := os.Open(src) //nolint:gosec // operator-provided service config path
-	if err != nil {
-		return err
-	}
-	defer func() { _ = srcFile.Close() }()
-
-	destFile, err := os.Create(dest) //nolint:gosec // operator-provided service config path
-	if err != nil {
-		return err
-	}
-	ok := false
-	defer func() {
-		_ = destFile.Close()
-		if !ok {
-			_ = os.Remove(dest)
-		}
-	}()
-
-	if _, err := io.Copy(destFile, srcFile); err != nil {
-		return err
-	}
-
-	ok = true
-	return nil
-}
@@ -5,9 +5,7 @@ package main
 import (
 	"fmt"
 	"os"
-	"path/filepath"

-	homedir "github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"

@@ -19,28 +17,14 @@ const (
 	launchdIdentifier = "com.cloudflare.cloudflared"
 )

-// OS-specific function for token file creation
-var createTokenFile = createTokenFileUnix
-
-func runApp(app *cli.App, _ chan struct{}) {
+func runApp(app *cli.App, graceShutdownC chan struct{}) {
 	app.Commands = append(app.Commands, &cli.Command{
 		Name:  "service",
 		Usage: "Manages the cloudflared launch agent",
 		Subcommands: []*cli.Command{
 			{
-				Name:      "install",
-				Usage:     "Install cloudflared as an user launch agent",
-				ArgsUsage: "[TOKEN]",
-				Description: `
-Installs cloudflared as a launchd-managed service.
-
-A token may optionally be provided. If a token is provided, it will be written
-to disk in the service configuration directory and the cloudflared service
-configured to use it via the --token-file argument.
-
-If no token is provided, cloudflared will run without the --token-file argument,
-causing it to look for credentials in a configuration file upon startup.`,
-
+				Name:   "install",
+				Usage:  "Install cloudflared as an user launch agent",
 				Action: cliutil.ConfiguredAction(installLaunchd),
 			},
 			{
@@ -91,45 +75,38 @@ func isRootUser() bool {
 	return os.Geteuid() == 0
 }

-func resolveLibraryPath(subPath, fileName string) (string, error) {
-	const libraryDirName = "Library"
-
-	// We use the system-wide /Library/... instead of ~/Library/... if the user is root
-	if isRootUser() {
-		return filepath.Join("/", libraryDirName, subPath, fileName), nil
-	}
-
-	// This returns the home dir of the executing user using OS-specific method
-	// for discovering the home dir. It's not recommended to call this when the
-	// user has root permission as $HOME depends on what options the user uses
-	// with sudo.
-	userHomeDir, err := homedir.Dir()
-	if err != nil {
-		return "", errors.Wrap(err, "Cannot determine home directory for the user")
-	}
-	return filepath.Join(userHomeDir, libraryDirName, subPath, fileName), nil
-}
-
-// For docs on these subdirectories, see:
-// https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/MacOSXDirectories/MacOSXDirectories.html
 func installPath() (string, error) {
-	subpath := "LaunchAgents"
+	// User is root, use /Library/LaunchDaemons instead of home directory
 	if isRootUser() {
-		subpath = "LaunchDaemons"
+		return fmt.Sprintf("/Library/LaunchDaemons/%s.plist", launchdIdentifier), nil
 	}
-	return resolveLibraryPath(subpath, launchdIdentifier+".plist")
+	userHomeDir, err := userHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/Library/LaunchAgents/%s.plist", userHomeDir, launchdIdentifier), nil
 }

 func stdoutPath() (string, error) {
-	return resolveLibraryPath("Logs", launchdIdentifier+".out.log")
+	if isRootUser() {
+		return fmt.Sprintf("/Library/Logs/%s.out.log", launchdIdentifier), nil
+	}
+	userHomeDir, err := userHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/Library/Logs/%s.out.log", userHomeDir, launchdIdentifier), nil
 }

 func stderrPath() (string, error) {
-	return resolveLibraryPath("Logs", launchdIdentifier+".err.log")
-}
-
-func configPath() (string, error) {
-	return resolveLibraryPath("Application Support", launchdIdentifier)
+	if isRootUser() {
+		return fmt.Sprintf("/Library/Logs/%s.err.log", launchdIdentifier), nil
+	}
+	userHomeDir, err := userHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/Library/Logs/%s.err.log", userHomeDir, launchdIdentifier), nil
 }

 func installLaunchd(c *cli.Context) error {
@@ -142,50 +119,23 @@ func installLaunchd(c *cli.Context) error {
 		log.Info().Msg("Installing cloudflared client as an user launch agent. " +
 			"Note that cloudflared client will only run when the user is logged in. " +
 			"If you want to run cloudflared client at boot, install with root permission. " +
-			"For more information, visit https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/configure-tunnels/local-management/as-a-service/macos/")
+			"For more information, visit https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/run-tunnel/run-as-service")
 	}
 	etPath, err := os.Executable()
 	if err != nil {
 		log.Err(err).Msg("Error determining executable path")
-		return fmt.Errorf("error determining executable path: %w", err)
+		return fmt.Errorf("Error determining executable path: %v", err)
 	}
 	installPath, err := installPath()
 	if err != nil {
 		log.Err(err).Msg("Error determining install path")
 		return errors.Wrap(err, "Error determining install path")
 	}
-
-	var extraArgs []string
-	if c.NArg() > 0 {
-		// The service has been installed using a token e.g.,
-		// $ cloudflared service install <token>
-		//
-		// Write the token file to a config directory so we can start the
-		// daemon with --token-file
-
-		// Don't use :=, if we did so we would create a new err variable and
-		// shadow the outer one, causing the defer below to not have access to
-		// the outer err
-		var cp string
-		cp, err = configPath()
-		if err != nil {
-			log.Err(err).Msg("Error determining path to config directory")
-			return err
-		}
-
-		// Ensure token file is removed if install fails at any point from now
-		// on
-		defer func() {
-			if err != nil {
-				removeTokenFile(cp, log)
-			}
-		}()
-
-		if err = writeTokenToConfigDir(c, cp); err != nil {
-			return fmt.Errorf("could not write token to configuration directory: %w", err)
-		}
-
-		extraArgs = buildArgsForTokenFile(cp)
+	extraArgs, err := getServiceExtraArgsFromCliArgs(c, log)
+	if err != nil {
+		errMsg := "Unable to determine extra arguments for launch daemon"
+		log.Err(err).Msg(errMsg)
+		return errors.Wrap(err, errMsg)
 	}

 	stdoutPath, err := stdoutPath()
@@ -255,13 +205,5 @@ func uninstallLaunchd(c *cli.Context) error {
 	if err == nil {
 		log.Info().Msg("Launchd for cloudflared was uninstalled successfully")
 	}
-
-	cp, err := configPath()
-	if err != nil {
-		log.Err(err).Msg("error determining path to config directory, not removing token file")
-		return err
-	}
-	removeTokenFile(cp, log)
-
-	return nil
+	return err
 }
@@ -2,18 +2,19 @@ package main

 import (
 	"fmt"
+	"math/rand"
 	"os"
 	"strings"
 	"time"

 	"github.com/getsentry/sentry-go"
+	homedir "github.com/mitchellh/go-homedir"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 	"go.uber.org/automaxprocs/maxprocs"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/access"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/management"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/proxydns"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/tail"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/tunnel"
@@ -51,8 +52,10 @@ var (
 func main() {
 	// FIXME: TUN-8148: Disable QUIC_GO ECN due to bugs in proper detection if supported
 	os.Setenv("QUIC_GO_DISABLE_ECN", "1")
+
+	rand.Seed(time.Now().UnixNano())
 	metrics.RegisterBuildInfo(BuildType, BuildTime, Version)
-	_, _ = maxprocs.Set()
+	maxprocs.Set()
 	bInfo := cliutil.GetBuildInfo(BuildType, Version)

 	// Graceful shutdown channel used by the app. When closed, app must terminate gracefully.
@@ -88,11 +91,10 @@ func main() {

 	tunnel.Init(bInfo, graceShutdownC) // we need this to support the tunnel sub command...
 	access.Init(graceShutdownC, Version)
-	updater.Init(bInfo)
+	updater.Init(Version)
 	tracing.Init(Version)
 	token.Init(Version)
 	tail.Init(bInfo)
-	management.Init(bInfo)
 	runApp(app, graceShutdownC)
 }

@@ -108,7 +110,7 @@ func commands(version func(c *cli.Context)) []*cli.Command {
 					Usage: "specify if you wish to update to the latest beta version",
 				},
 				&cli.BoolFlag{
-					Name:   cfdflags.Force,
+					Name:   "force",
 					Usage:  "specify if you wish to force an upgrade to the latest version regardless of the current version",
 					Hidden: true,
 				},
@@ -151,10 +153,9 @@ To determine if an update happened in a script, check for error code 11.`,
 		},
 	}
 	cmds = append(cmds, tunnel.Commands()...)
-	cmds = append(cmds, proxydns.Command()) // removed feature, only here for error message
+	cmds = append(cmds, proxydns.Command(false))
 	cmds = append(cmds, access.Commands()...)
 	cmds = append(cmds, tail.Command())
-	cmds = append(cmds, management.Command())
 	return cmds
 }

@@ -183,6 +184,18 @@ func action(graceShutdownC chan struct{}) cli.ActionFunc {
 	})
 }

+func userHomeDir() (string, error) {
+	// This returns the home dir of the executing user using OS-specific method
+	// for discovering the home dir. It's not recommended to call this function
+	// when the user has root permission as $HOME depends on what options the user
+	// use with sudo.
+	homeDir, err := homedir.Dir()
+	if err != nil {
+		return "", errors.Wrap(err, "Cannot determine home directory for the user")
+	}
+	return homeDir, nil
+}
+
 // In order to keep the amount of noise sent to Sentry low, typical network errors can be filtered out here by a substring match.
 func captureError(err error) {
 	errorMessage := err.Error()
@@ -1,105 +0,0 @@
-package management
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"github.com/urfave/cli/v2"
-
-	"github.com/cloudflare/cloudflared/cfapi"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
-	"github.com/cloudflare/cloudflared/credentials"
-)
-
-var buildInfo *cliutil.BuildInfo
-
-// Init initializes the management package with build info
-func Init(bi *cliutil.BuildInfo) {
-	buildInfo = bi
-}
-
-// Command returns the management command with its subcommands
-func Command() *cli.Command {
-	return &cli.Command{
-		Name:     "management",
-		Usage:    "Monitor cloudflared tunnels via management API",
-		Category: "Management",
-		Hidden:   true,
-		Subcommands: []*cli.Command{
-			buildTokenSubcommand(),
-		},
-	}
-}
-
-// buildTokenSubcommand creates the token subcommand
-func buildTokenSubcommand() *cli.Command {
-	return &cli.Command{
-		Name:        "token",
-		Action:      cliutil.ConfiguredAction(tokenCommand),
-		Usage:       "Get management access jwt for a specific resource",
-		UsageText:   "cloudflared management token --resource <resource> TUNNEL_ID",
-		Description: "Get management access jwt for a tunnel with specified resource permissions (logs, admin, host_details)",
-		Hidden:      true,
-		Flags: []cli.Flag{
-			&cli.StringFlag{
-				Name:     "resource",
-				Usage:    "Resource type for token permissions: logs, admin, or host_details",
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name:    cfdflags.OriginCert,
-				Usage:   "Path to the certificate generated for your origin when you run cloudflared login.",
-				EnvVars: []string{"TUNNEL_ORIGIN_CERT"},
-				Value:   credentials.FindDefaultOriginCertPath(),
-			},
-			&cli.StringFlag{
-				Name:    cfdflags.LogLevel,
-				Value:   "info",
-				Usage:   "Application logging level {debug, info, warn, error, fatal}",
-				EnvVars: []string{"TUNNEL_LOGLEVEL"},
-			},
-			cliutil.FlagLogOutput,
-		},
-	}
-}
-
-// tokenCommand handles the token subcommand execution
-func tokenCommand(c *cli.Context) error {
-	log := cliutil.CreateStderrLogger(c)
-
-	// Parse and validate resource flag
-	resourceStr := c.String("resource")
-	resource, err := parseResource(resourceStr)
-	if err != nil {
-		return fmt.Errorf("invalid resource '%s': %w", resourceStr, err)
-	}
-
-	// Get management token
-	token, err := cliutil.GetManagementToken(c, log, resource, buildInfo)
-	if err != nil {
-		return err
-	}
-
-	// Output JSON to stdout
-	tokenResponse := struct {
-		Token string `json:"token"`
-	}{Token: token}
-
-	return json.NewEncoder(os.Stdout).Encode(tokenResponse)
-}
-
-// parseResource converts resource string to ManagementResource enum
-func parseResource(resource string) (cfapi.ManagementResource, error) {
-	switch resource {
-	case "logs":
-		return cfapi.Logs, nil
-	case "admin":
-		return cfapi.Admin, nil
-	case "host_details":
-		return cfapi.HostDetails, nil
-	default:
-		return 0, fmt.Errorf("must be one of: logs, admin, host_details")
-	}
-}
@@ -1,71 +0,0 @@
-package management
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/cloudflare/cloudflared/cfapi"
-)
-
-func TestParseResource_ValidResources(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		input    string
-		expected cfapi.ManagementResource
-	}{
-		{"logs", cfapi.Logs},
-		{"admin", cfapi.Admin},
-		{"host_details", cfapi.HostDetails},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			t.Parallel()
-			result, err := parseResource(tt.input)
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestParseResource_InvalidResource(t *testing.T) {
-	t.Parallel()
-
-	invalid := []string{"invalid", "LOGS", "Admin", "", "metrics", "host-details"}
-
-	for _, input := range invalid {
-		t.Run(input, func(t *testing.T) {
-			t.Parallel()
-			_, err := parseResource(input)
-			require.Error(t, err)
-			assert.Contains(t, err.Error(), "must be one of")
-		})
-	}
-}
-
-func TestCommandStructure(t *testing.T) {
-	t.Parallel()
-
-	cmd := Command()
-
-	assert.Equal(t, "management", cmd.Name)
-	assert.True(t, cmd.Hidden)
-	assert.Len(t, cmd.Subcommands, 1)
-
-	tokenCmd := cmd.Subcommands[0]
-	assert.Equal(t, "token", tokenCmd.Name)
-	assert.True(t, tokenCmd.Hidden)
-
-	// Verify required flags exist
-	var hasResourceFlag bool
-	for _, flag := range tokenCmd.Flags {
-		if flag.Names()[0] == "resource" {
-			hasResourceFlag = true
-			break
-		}
-	}
-	assert.True(t, hasResourceFlag, "token command should have --resource flag")
-}
@@ -1,54 +1,115 @@
 package proxydns

 import (
-	"errors"
+	"context"
+	"net"
+	"os"
+	"os/signal"
+	"syscall"

 	"github.com/urfave/cli/v2"
-	"github.com/urfave/cli/v2/altsrc"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 	"github.com/cloudflare/cloudflared/logger"
+	"github.com/cloudflare/cloudflared/metrics"
+	"github.com/cloudflare/cloudflared/tunneldns"
 )

-const removedMessage = "dns-proxy feature is no longer supported"
-
-func Command() *cli.Command {
+func Command(hidden bool) *cli.Command {
 	return &cli.Command{
-		Name:            "proxy-dns",
-		Action:          cliutil.ConfiguredAction(Run),
-		Usage:           removedMessage,
-		SkipFlagParsing: true,
+		Name:   "proxy-dns",
+		Action: cliutil.ConfiguredAction(Run),
+
+		Usage: "Run a DNS over HTTPS proxy server.",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "metrics",
+				Value:   "localhost:",
+				Usage:   "Listen address for metrics reporting.",
+				EnvVars: []string{"TUNNEL_METRICS"},
+			},
+			&cli.StringFlag{
+				Name:    "address",
+				Usage:   "Listen address for the DNS over HTTPS proxy server.",
+				Value:   "localhost",
+				EnvVars: []string{"TUNNEL_DNS_ADDRESS"},
+			},
+			// Note TUN-3758 , we use Int because UInt is not supported with altsrc
+			&cli.IntFlag{
+				Name:    "port",
+				Usage:   "Listen on given port for the DNS over HTTPS proxy server.",
+				Value:   53,
+				EnvVars: []string{"TUNNEL_DNS_PORT"},
+			},
+			&cli.StringSliceFlag{
+				Name:    "upstream",
+				Usage:   "Upstream endpoint URL, you can specify multiple endpoints for redundancy.",
+				Value:   cli.NewStringSlice("https://1.1.1.1/dns-query", "https://1.0.0.1/dns-query"),
+				EnvVars: []string{"TUNNEL_DNS_UPSTREAM"},
+			},
+			&cli.StringSliceFlag{
+				Name:    "bootstrap",
+				Usage:   "bootstrap endpoint URL, you can specify multiple endpoints for redundancy.",
+				Value:   cli.NewStringSlice("https://162.159.36.1/dns-query", "https://162.159.46.1/dns-query", "https://[2606:4700:4700::1111]/dns-query", "https://[2606:4700:4700::1001]/dns-query"),
+				EnvVars: []string{"TUNNEL_DNS_BOOTSTRAP"},
+			},
+			&cli.IntFlag{
+				Name:    "max-upstream-conns",
+				Usage:   "Maximum concurrent connections to upstream. Setting to 0 means unlimited.",
+				Value:   tunneldns.MaxUpstreamConnsDefault,
+				EnvVars: []string{"TUNNEL_DNS_MAX_UPSTREAM_CONNS"},
+			},
+		},
+		ArgsUsage: " ", // can't be the empty string or we get the default output
+		Hidden:    hidden,
 	}
 }

+// Run implements a foreground runner
 func Run(c *cli.Context) error {
 	log := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)
-	err := errors.New(removedMessage)
-	log.Error().Msg("DNS Proxy is no longer supported since version 2026.2.0 (https://developers.cloudflare.com/changelog/2025-11-11-cloudflared-proxy-dns/). As an alternative consider using https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/dns-over-https-client/")

+	metricsListener, err := net.Listen("tcp", c.String("metrics"))
+	if err != nil {
+		log.Fatal().Err(err).Msg("Failed to open the metrics listener")
+	}
+
+	go metrics.ServeMetrics(metricsListener, context.Background(), metrics.Config{}, log)
+
+	listener, err := tunneldns.CreateListener(
+		c.String("address"),
+		// Note TUN-3758 , we use Int because UInt is not supported with altsrc
+		uint16(c.Int("port")),
+		c.StringSlice("upstream"),
+		c.StringSlice("bootstrap"),
+		c.Int("max-upstream-conns"),
+		log,
+	)
+
+	if err != nil {
+		log.Err(err).Msg("Failed to create the listeners")
+		return err
+	}
+
+	// Try to start the server
+	readySignal := make(chan struct{})
+	err = listener.Start(readySignal)
+	if err != nil {
+		log.Err(err).Msg("Failed to start the listeners")
+		return listener.Stop()
+	}
+	<-readySignal
+
+	// Wait for signal
+	signals := make(chan os.Signal, 10)
+	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)
+	defer signal.Stop(signals)
+	<-signals
+
+	// Shut down server
+	err = listener.Stop()
+	if err != nil {
+		log.Err(err).Msg("failed to stop")
+	}
 	return err
 }
-
-// Old flags used by the proxy-dns command, only kept to not break any script that might be setting these flags
-func ConfigureProxyDNSFlags(shouldHide bool) []cli.Flag {
-	return []cli.Flag{
-		altsrc.NewBoolFlag(&cli.BoolFlag{
-			Name: "proxy-dns",
-		}),
-		altsrc.NewIntFlag(&cli.IntFlag{
-			Name: "proxy-dns-port",
-		}),
-		altsrc.NewStringFlag(&cli.StringFlag{
-			Name: "proxy-dns-address",
-		}),
-		altsrc.NewStringSliceFlag(&cli.StringSliceFlag{
-			Name: "proxy-dns-upstream",
-		}),
-		altsrc.NewIntFlag(&cli.IntFlag{
-			Name: "proxy-dns-max-upstream-conns",
-		}),
-		altsrc.NewStringSliceFlag(&cli.StringSliceFlag{
-			Name: "proxy-dns-bootstrap",
-		}),
-	}
-}
@@ -1,16 +1,18 @@
 package main

 import (
+	"bufio"
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
-	"path/filepath"
+	"path"
 	"text/template"

 	homedir "github.com/mitchellh/go-homedir"
+
+	"github.com/cloudflare/cloudflared/config"
 )

 type ServiceTemplate struct {
@@ -42,7 +44,7 @@ func (st *ServiceTemplate) Generate(args *ServiceTemplateArgs) error {
 		return err
 	}
 	if _, err = os.Stat(resolvedPath); err == nil {
-		return errors.New(serviceAlreadyExistsWarn(resolvedPath))
+		return fmt.Errorf(serviceAlreadyExistsWarn(resolvedPath))
 	}

 	var buffer bytes.Buffer
@@ -55,7 +57,7 @@ func (st *ServiceTemplate) Generate(args *ServiceTemplateArgs) error {
 		fileMode = st.FileMode
 	}

-	plistFolder := filepath.Dir(resolvedPath)
+	plistFolder := path.Dir(resolvedPath)
 	err = os.MkdirAll(plistFolder, 0o755)
 	if err != nil {
 		return fmt.Errorf("error creating %s: %v", plistFolder, err)
@@ -107,3 +109,114 @@ func runCommand(command string, args ...string) error {
 	}
 	return nil
 }
+
+func ensureConfigDirExists(configDir string) error {
+	ok, err := config.FileExists(configDir)
+	if !ok && err == nil {
+		err = os.Mkdir(configDir, 0755)
+	}
+	return err
+}
+
+// openFile opens the file at path. If create is set and the file exists, returns nil, true, nil
+func openFile(path string, create bool) (file *os.File, exists bool, err error) {
+	expandedPath, err := homedir.Expand(path)
+	if err != nil {
+		return nil, false, err
+	}
+	if create {
+		fileInfo, err := os.Stat(expandedPath)
+		if err == nil && fileInfo.Size() > 0 {
+			return nil, true, nil
+		}
+		file, err = os.OpenFile(expandedPath, os.O_RDWR|os.O_CREATE, 0600)
+	} else {
+		file, err = os.Open(expandedPath)
+	}
+	return file, false, err
+}
+
+func copyCredential(srcCredentialPath, destCredentialPath string) error {
+	destFile, exists, err := openFile(destCredentialPath, true)
+	if err != nil {
+		return err
+	} else if exists {
+		// credentials already exist, do nothing
+		return nil
+	}
+	defer destFile.Close()
+
+	srcFile, _, err := openFile(srcCredentialPath, false)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	// Copy certificate
+	_, err = io.Copy(destFile, srcFile)
+	if err != nil {
+		return fmt.Errorf("unable to copy %s to %s: %v", srcCredentialPath, destCredentialPath, err)
+	}
+
+	return nil
+}
+
+func copyFile(src, dest string) error {
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	destFile, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	ok := false
+	defer func() {
+		destFile.Close()
+		if !ok {
+			_ = os.Remove(dest)
+		}
+	}()
+
+	if _, err := io.Copy(destFile, srcFile); err != nil {
+		return err
+	}
+
+	ok = true
+	return nil
+}
+
+func copyConfig(srcConfigPath, destConfigPath string) error {
+	// Copy or create config
+	destFile, exists, err := openFile(destConfigPath, true)
+	if err != nil {
+		return fmt.Errorf("cannot open %s with error: %s", destConfigPath, err)
+	} else if exists {
+		// config already exists, do nothing
+		return nil
+	}
+	defer destFile.Close()
+
+	srcFile, _, err := openFile(srcConfigPath, false)
+	if err != nil {
+		fmt.Println("Your service needs a config file that at least specifies the hostname option.")
+		fmt.Println("Type in a hostname now, or leave it blank and create the config file later.")
+		fmt.Print("Hostname: ")
+		reader := bufio.NewReader(os.Stdin)
+		input, _ := reader.ReadString('\n')
+		if input == "" {
+			return err
+		}
+		fmt.Fprintf(destFile, "hostname: %s\n", input)
+	} else {
+		defer srcFile.Close()
+		_, err = io.Copy(destFile, srcFile)
+		if err != nil {
+			return fmt.Errorf("unable to copy %s to %s: %v", srcConfigPath, destConfigPath, err)
+		}
+	}
+
+	return nil
+}
@@ -12,18 +12,20 @@ import (
 	"time"

 	"github.com/google/uuid"
+	"github.com/mattn/go-colorable"
 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 	"nhooyr.io/websocket"

-	"github.com/cloudflare/cloudflared/cfapi"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/credentials"
+	"github.com/cloudflare/cloudflared/logger"
 	"github.com/cloudflare/cloudflared/management"
 )

-var buildInfo *cliutil.BuildInfo
+var (
+	buildInfo *cliutil.BuildInfo
+)

 func Init(bi *cliutil.BuildInfo) {
 	buildInfo = bi
@@ -49,13 +51,12 @@ func buildTailManagementTokenSubcommand() *cli.Command {
 }

 func managementTokenCommand(c *cli.Context) error {
-	log := cliutil.CreateStderrLogger(c)
-
-	token, err := cliutil.GetManagementToken(c, log, cfapi.Logs, buildInfo)
+	log := createLogger(c)
+	token, err := getManagementToken(c, log)
 	if err != nil {
 		return err
 	}
-	tokenResponse := struct {
+	var tokenResponse = struct {
 		Token string `json:"token"`
 	}{Token: token}

@@ -99,7 +100,13 @@ func buildTailCommand(subcommands []*cli.Command) *cli.Command {
 				EnvVars: []string{"TUNNEL_MANAGEMENT_TOKEN"},
 			},
 			&cli.StringFlag{
-				Name:    cfdflags.ManagementHostname,
+				Name:    "output",
+				Usage:   "Output format for the logs (default, json)",
+				Value:   "default",
+				EnvVars: []string{"TUNNEL_MANAGEMENT_OUTPUT"},
+			},
+			&cli.StringFlag{
+				Name:    "management-hostname",
 				Usage:   "Management hostname to signify incoming management requests",
 				EnvVars: []string{"TUNNEL_MANAGEMENT_HOSTNAME"},
 				Hidden:  true,
@@ -112,18 +119,17 @@ func buildTailCommand(subcommands []*cli.Command) *cli.Command {
 				Value:  "",
 			},
 			&cli.StringFlag{
-				Name:    cfdflags.LogLevel,
+				Name:    logger.LogLevelFlag,
 				Value:   "info",
 				Usage:   "Application logging level {debug, info, warn, error, fatal}",
 				EnvVars: []string{"TUNNEL_LOGLEVEL"},
 			},
 			&cli.StringFlag{
-				Name:    cfdflags.OriginCert,
+				Name:    credentials.OriginCertFlag,
 				Usage:   "Path to the certificate generated for your origin when you run cloudflared login.",
 				EnvVars: []string{"TUNNEL_ORIGIN_CERT"},
 				Value:   credentials.FindDefaultOriginCertPath(),
 			},
-			cliutil.FlagLogOutput,
 		},
 		Subcommands: subcommands,
 	}
@@ -160,13 +166,26 @@ func handleValidationError(resp *http.Response, log *zerolog.Logger) {
 	}
 }

+// logger will be created to emit only against the os.Stderr as to not obstruct with normal output from
+// management requests
+func createLogger(c *cli.Context) *zerolog.Logger {
+	level, levelErr := zerolog.ParseLevel(c.String(logger.LogLevelFlag))
+	if levelErr != nil {
+		level = zerolog.InfoLevel
+	}
+	log := zerolog.New(zerolog.ConsoleWriter{
+		Out:        colorable.NewColorable(os.Stderr),
+		TimeFormat: time.RFC3339,
+	}).With().Timestamp().Logger().Level(level)
+	return &log
+}
+
 // parseFilters will attempt to parse provided filters to send to with the EventStartStreaming
 func parseFilters(c *cli.Context) (*management.StreamingFilters, error) {
 	var level *management.LogLevel
+	var events []management.LogEventType
 	var sample float64

-	events := make([]management.LogEventType, 0)
-
 	argLevel := c.String("level")
 	argEvents := c.StringSlice("event")
 	argSample := c.Float64("sample")
@@ -204,30 +223,46 @@ func parseFilters(c *cli.Context) (*management.StreamingFilters, error) {
 	}, nil
 }

-// buildURL will build the management url to contain the required query parameters to authenticate the request.
-func buildURL(c *cli.Context, log *zerolog.Logger, res cfapi.ManagementResource) (url.URL, error) {
-	var err error
+// getManagementToken will make a call to the Cloudflare API to acquire a management token for the requested tunnel.
+func getManagementToken(c *cli.Context, log *zerolog.Logger) (string, error) {
+	userCreds, err := credentials.Read(c.String(credentials.OriginCertFlag), log)
+	if err != nil {
+		return "", err
+	}

+	client, err := userCreds.Client(c.String("api-url"), buildInfo.UserAgent(), log)
+	if err != nil {
+		return "", err
+	}
+
+	tunnelIDString := c.Args().First()
+	if tunnelIDString == "" {
+		return "", errors.New("no tunnel ID provided")
+	}
+	tunnelID, err := uuid.Parse(tunnelIDString)
+	if err != nil {
+		return "", errors.New("unable to parse provided tunnel id as a valid UUID")
+	}
+
+	token, err := client.GetManagementToken(tunnelID)
+	if err != nil {
+		return "", err
+	}
+
+	return token, nil
+}
+
+// buildURL will build the management url to contain the required query parameters to authenticate the request.
+func buildURL(c *cli.Context, log *zerolog.Logger) (url.URL, error) {
+	var err error
+	managementHostname := c.String("management-hostname")
 	token := c.String("token")
 	if token == "" {
-		token, err = cliutil.GetManagementToken(c, log, res, buildInfo)
+		token, err = getManagementToken(c, log)
 		if err != nil {
 			return url.URL{}, fmt.Errorf("unable to acquire management token for requested tunnel id: %w", err)
 		}
 	}
-
-	claims, err := management.ParseToken(token)
-	if err != nil {
-		return url.URL{}, fmt.Errorf("failed to determine if token is FED: %w", err)
-	}
-
-	var managementHostname string
-	if claims.IsFed() {
-		managementHostname = credentials.FedRampHostname
-	} else {
-		managementHostname = c.String(cfdflags.ManagementHostname)
-	}
-
 	query := url.Values{}
 	query.Add("access_token", token)
 	connector := c.String("connector-id")
@@ -261,7 +296,7 @@ func printJSON(log *management.Log, logger *zerolog.Logger) {

 // Run implements a foreground runner
 func Run(c *cli.Context) error {
-	log := cliutil.CreateStderrLogger(c)
+	log := createLogger(c)

 	signals := make(chan os.Signal, 10)
 	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)
@@ -283,7 +318,7 @@ func Run(c *cli.Context) error {
 		return nil
 	}

-	u, err := buildURL(c, log, cfapi.Logs)
+	u, err := buildURL(c, log)
 	if err != nil {
 		log.Err(err).Msg("unable to construct management request URL")
 		return nil
@@ -296,7 +331,6 @@ func Run(c *cli.Context) error {
 		header["cf-trace-id"] = []string{trace}
 	}
 	ctx := c.Context
-	// nolint: bodyclose
 	conn, resp, err := websocket.Dial(ctx, u.String(), &websocket.DialOptions{
 		HTTPHeader: header,
 	})
@@ -0,0 +1,15 @@
+package tunnel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cloudflare/cloudflared/features"
+)
+
+func TestDedup(t *testing.T) {
+	expected := []string{"a", "b"}
+	actual := features.Dedup([]string{"a", "b", "a"})
+	require.ElementsMatch(t, expected, actual)
+}
@@ -10,23 +10,20 @@ import (
 	"strings"
 	"time"

+	"github.com/google/uuid"
 	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
 	"github.com/urfave/cli/v2/altsrc"
 	"golang.org/x/term"

-	"github.com/cloudflare/cloudflared/client"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/connection"
 	"github.com/cloudflare/cloudflared/edgediscovery"
 	"github.com/cloudflare/cloudflared/edgediscovery/allregions"
 	"github.com/cloudflare/cloudflared/features"
 	"github.com/cloudflare/cloudflared/ingress"
-	"github.com/cloudflare/cloudflared/ingress/origins"
 	"github.com/cloudflare/cloudflared/orchestration"
 	"github.com/cloudflare/cloudflared/supervisor"
 	"github.com/cloudflare/cloudflared/tlsconfig"
@@ -39,24 +36,24 @@ const (
 )

 var (
+	developerPortal = "https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup"
+	serviceUrl      = developerPortal + "/tunnel-guide/local/as-a-service/"
+	argumentsUrl    = developerPortal + "/tunnel-guide/local/local-management/arguments/"
+
 	secretFlags = [2]*altsrc.StringFlag{credentialsContentsFlag, tunnelTokenFlag}

-	configFlags = []string{
-		flags.AutoUpdateFreq,
-		flags.NoAutoUpdate,
-		flags.Retries,
-		flags.Protocol,
-		flags.LogLevel,
-		flags.TransportLogLevel,
-		flags.OriginCert,
-		flags.Metrics,
-		flags.MetricsUpdateFreq,
-		flags.EdgeIpVersion,
-		flags.EdgeBindAddress,
-		flags.MaxActiveFlows,
-	}
+	configFlags = []string{"autoupdate-freq", "no-autoupdate", "retries", "protocol", "loglevel", "transport-loglevel", "origincert", "metrics", "metrics-update-freq", "edge-ip-version", "edge-bind-address"}
 )

+func generateRandomClientID(log *zerolog.Logger) (string, error) {
+	u, err := uuid.NewRandom()
+	if err != nil {
+		log.Error().Msgf("couldn't create UUID for client ID %s", err)
+		return "", err
+	}
+	return u.String(), nil
+}
+
 func logClientOptions(c *cli.Context, log *zerolog.Logger) {
 	flags := make(map[string]interface{})
 	for _, flag := range c.FlagNames() {
@@ -111,6 +108,13 @@ func isSecretEnvVar(key string) bool {
 	return false
 }

+func dnsProxyStandAlone(c *cli.Context, namedTunnel *connection.TunnelProperties) bool {
+	return c.IsSet("proxy-dns") &&
+		!(c.IsSet("name") || // adhoc-named tunnel
+			c.IsSet(ingress.HelloWorldFlag) || // quick or named tunnel
+			namedTunnel != nil) // named tunnel
+}
+
 func prepareTunnelConfig(
 	ctx context.Context,
 	c *cli.Context,
@@ -119,34 +123,62 @@ func prepareTunnelConfig(
 	observer *connection.Observer,
 	namedTunnel *connection.TunnelProperties,
 ) (*supervisor.TunnelConfig, *orchestration.Config, error) {
-	transportProtocol := c.String(flags.Protocol)
-	isPostQuantumEnforced := c.Bool(flags.PostQuantum)
-	featureSelector, err := features.NewFeatureSelector(ctx, namedTunnel.Credentials.AccountTag, c.StringSlice(flags.Features), isPostQuantumEnforced, log)
+	clientID, err := uuid.NewRandom()
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "Failed to create feature selector")
+		return nil, nil, errors.Wrap(err, "can't generate connector UUID")
 	}
-
-	clientConfig, err := client.NewConfig(info.Version(), info.OSArch(), featureSelector)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	log.Info().Msgf("Generated Connector ID: %s", clientConfig.ConnectorID)
-
-	tags, err := NewTagSliceFromCLI(c.StringSlice(flags.Tag))
+	log.Info().Msgf("Generated Connector ID: %s", clientID)
+	tags, err := NewTagSliceFromCLI(c.StringSlice("tag"))
 	if err != nil {
 		log.Err(err).Msg("Tag parse failure")
 		return nil, nil, errors.Wrap(err, "Tag parse failure")
 	}
-	tags = append(tags, pogs.Tag{Name: "ID", Value: clientConfig.ConnectorID.String()})
+	tags = append(tags, pogs.Tag{Name: "ID", Value: clientID.String()})

+	transportProtocol := c.String("protocol")
+
+	clientFeatures := features.Dedup(append(c.StringSlice("features"), features.DefaultFeatures...))
+
+	staticFeatures := features.StaticFeatures{}
+	if c.Bool("post-quantum") {
+		if FipsEnabled {
+			return nil, nil, fmt.Errorf("post-quantum not supported in FIPS mode")
+		}
+		pqMode := features.PostQuantumStrict
+		staticFeatures.PostQuantumMode = &pqMode
+	}
+	featureSelector, err := features.NewFeatureSelector(ctx, namedTunnel.Credentials.AccountTag, staticFeatures, log)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "Failed to create feature selector")
+	}
+	pqMode := featureSelector.PostQuantumMode()
+	if pqMode == features.PostQuantumStrict {
+		// Error if the user tries to force a non-quic transport protocol
+		if transportProtocol != connection.AutoSelectFlag && transportProtocol != connection.QUIC.String() {
+			return nil, nil, fmt.Errorf("post-quantum is only supported with the quic transport")
+		}
+		transportProtocol = connection.QUIC.String()
+		clientFeatures = append(clientFeatures, features.FeaturePostQuantum)
+
+		log.Info().Msgf(
+			"Using hybrid post-quantum key agreement %s",
+			supervisor.PQKexName,
+		)
+	}
+
+	namedTunnel.Client = pogs.ClientInfo{
+		ClientID: clientID[:],
+		Features: clientFeatures,
+		Version:  info.Version(),
+		Arch:     info.OSArch(),
+	}
 	cfg := config.GetConfiguration()
 	ingressRules, err := ingress.ParseIngressFromConfigAndCLI(cfg, c, log)
 	if err != nil {
 		return nil, nil, err
 	}

-	protocolSelector, err := connection.NewProtocolSelector(transportProtocol, namedTunnel.Credentials.AccountTag, c.IsSet(TunnelTokenFlag), edgediscovery.ProtocolPercentage, connection.ResolveTTL, log)
+	protocolSelector, err := connection.NewProtocolSelector(transportProtocol, namedTunnel.Credentials.AccountTag, c.IsSet(TunnelTokenFlag), c.Bool("post-quantum"), edgediscovery.ProtocolPercentage, connection.ResolveTTL, log)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -158,7 +190,7 @@ func prepareTunnelConfig(
 		if tlsSettings == nil {
 			return nil, nil, fmt.Errorf("%s has unknown TLS settings", p)
 		}
-		edgeTLSConfig, err := tlsconfig.CreateTunnelConfig(c.String(flags.CACert), tlsSettings.ServerName)
+		edgeTLSConfig, err := tlsconfig.CreateTunnelConfig(c, tlsSettings.ServerName)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "unable to create TLS config to connect with edge")
 		}
@@ -172,11 +204,11 @@ func prepareTunnelConfig(
 	if err != nil {
 		return nil, nil, err
 	}
-	edgeIPVersion, err := parseConfigIPVersion(c.String(flags.EdgeIpVersion))
+	edgeIPVersion, err := parseConfigIPVersion(c.String("edge-ip-version"))
 	if err != nil {
 		return nil, nil, err
 	}
-	edgeBindAddr, err := parseConfigBindAddress(c.String(flags.EdgeBindAddress))
+	edgeBindAddr, err := parseConfigBindAddress(c.String("edge-bind-address"))
 	if err != nil {
 		return nil, nil, err
 	}
@@ -189,83 +221,48 @@ func prepareTunnelConfig(
 		log.Warn().Str("edgeIPVersion", edgeIPVersion.String()).Err(err).Msg("Overriding edge-ip-version")
 	}

-	region := c.String(flags.Region)
-	endpoint := namedTunnel.Credentials.Endpoint
-	var resolvedRegion string
-	// set resolvedRegion to either the region passed as argument
-	// or to the endpoint in the credentials.
-	// Region and endpoint are interchangeable
-	if region != "" && endpoint != "" {
-		return nil, nil, fmt.Errorf("region provided with a token that has an endpoint")
-	} else if region != "" {
-		resolvedRegion = region
-	} else if endpoint != "" {
-		resolvedRegion = endpoint
-	}
-
-	warpRoutingConfig := ingress.NewWarpRoutingConfig(&cfg.WarpRouting)
-
-	// Setup origin dialer service and virtual services
-	originDialerService := ingress.NewOriginDialer(ingress.OriginConfig{
-		DefaultDialer:   ingress.NewDialer(warpRoutingConfig),
-		TCPWriteTimeout: c.Duration(flags.WriteStreamTimeout),
-	}, log)
-
-	// Setup DNS Resolver Service
-	originMetrics := origins.NewMetrics(prometheus.DefaultRegisterer)
-	dnsResolverAddrs := c.StringSlice(flags.VirtualDNSServiceResolverAddresses)
-	dnsService := origins.NewDNSResolverService(origins.NewDNSDialer(), log, originMetrics)
-	if len(dnsResolverAddrs) > 0 {
-		addrs, err := parseResolverAddrPorts(dnsResolverAddrs)
-		if err != nil {
-			return nil, nil, fmt.Errorf("invalid %s provided: %w", flags.VirtualDNSServiceResolverAddresses, err)
-		}
-		dnsService = origins.NewStaticDNSResolverService(addrs, origins.NewDNSDialer(), log, originMetrics)
-	}
-	originDialerService.AddReservedService(dnsService, []netip.AddrPort{origins.VirtualDNSServiceAddr})
-
 	tunnelConfig := &supervisor.TunnelConfig{
-		ClientConfig:    clientConfig,
 		GracePeriod:     gracePeriod,
-		EdgeAddrs:       c.StringSlice(flags.Edge),
-		Region:          resolvedRegion,
+		ReplaceExisting: c.Bool("force"),
+		OSArch:          info.OSArch(),
+		ClientID:        clientID.String(),
+		EdgeAddrs:       c.StringSlice("edge"),
+		Region:          c.String("region"),
 		EdgeIPVersion:   edgeIPVersion,
 		EdgeBindAddr:    edgeBindAddr,
-		HAConnections:   c.Int(flags.HaConnections),
-		IsAutoupdated:   c.Bool(flags.IsAutoUpdated),
-		LBPool:          c.String(flags.LBPool),
+		HAConnections:   c.Int(haConnectionsFlag),
+		IsAutoupdated:   c.Bool("is-autoupdated"),
+		LBPool:          c.String("lb-pool"),
 		Tags:            tags,
 		Log:             log,
 		LogTransport:    logTransport,
 		Observer:        observer,
 		ReportedVersion: info.Version(),
 		// Note TUN-3758 , we use Int because UInt is not supported with altsrc
-		Retries:                             uint(c.Int(flags.Retries)), // nolint: gosec
+		Retries:                             uint(c.Int("retries")),
 		RunFromTerminal:                     isRunningFromTerminal(),
 		NamedTunnel:                         namedTunnel,
 		ProtocolSelector:                    protocolSelector,
 		EdgeTLSConfigs:                      edgeTLSConfigs,
-		MaxEdgeAddrRetries:                  uint8(c.Int(flags.MaxEdgeAddrRetries)), // nolint: gosec
-		RPCTimeout:                          c.Duration(flags.RpcTimeout),
-		WriteStreamTimeout:                  c.Duration(flags.WriteStreamTimeout),
-		DisableQUICPathMTUDiscovery:         c.Bool(flags.QuicDisablePathMTUDiscovery),
-		QUICConnectionLevelFlowControlLimit: c.Uint64(flags.QuicConnLevelFlowControlLimit),
-		QUICStreamLevelFlowControlLimit:     c.Uint64(flags.QuicStreamLevelFlowControlLimit),
-		NoPrechecks:                         c.Bool(flags.NoPrechecks),
-		OriginDNSService:                    dnsService,
-		OriginDialerService:                 originDialerService,
+		FeatureSelector:                     featureSelector,
+		MaxEdgeAddrRetries:                  uint8(c.Int("max-edge-addr-retries")),
+		RPCTimeout:                          c.Duration(rpcTimeout),
+		WriteStreamTimeout:                  c.Duration(writeStreamTimeout),
+		DisableQUICPathMTUDiscovery:         c.Bool(quicDisablePathMTUDiscovery),
+		QUICConnectionLevelFlowControlLimit: c.Uint64(quicConnLevelFlowControlLimit),
+		QUICStreamLevelFlowControlLimit:     c.Uint64(quicStreamLevelFlowControlLimit),
 	}
-	icmpRouter, err := newICMPRouter(c, log)
+	packetConfig, err := newPacketConfig(c, log)
 	if err != nil {
 		log.Warn().Err(err).Msg("ICMP proxy feature is disabled")
 	} else {
-		tunnelConfig.ICMPRouterServer = icmpRouter
+		tunnelConfig.PacketConfig = packetConfig
 	}
 	orchestratorConfig := &orchestration.Config{
-		Ingress:             &ingressRules,
-		WarpRouting:         warpRoutingConfig,
-		OriginDialerService: originDialerService,
-		ConfigurationFlags:  parseConfigFlags(c),
+		Ingress:            &ingressRules,
+		WarpRouting:        ingress.NewWarpRoutingConfig(&cfg.WarpRouting),
+		ConfigurationFlags: parseConfigFlags(c),
+		WriteTimeout:       c.Duration(writeStreamTimeout),
 	}
 	return tunnelConfig, orchestratorConfig, nil
 }
@@ -283,15 +280,15 @@ func parseConfigFlags(c *cli.Context) map[string]string {
 }

 func gracePeriod(c *cli.Context) (time.Duration, error) {
-	period := c.Duration(flags.GracePeriod)
+	period := c.Duration("grace-period")
 	if period > connection.MaxGracePeriod {
-		return time.Duration(0), fmt.Errorf("%s must be equal or less than %v", flags.GracePeriod, connection.MaxGracePeriod)
+		return time.Duration(0), fmt.Errorf("grace-period must be equal or less than %v", connection.MaxGracePeriod)
 	}
 	return period, nil
 }

 func isRunningFromTerminal() bool {
-	return term.IsTerminal(int(os.Stdout.Fd())) // nolint:gosec
+	return term.IsTerminal(int(os.Stdout.Fd()))
 }

 // ParseConfigIPVersion returns the IP version from possible expected values from config
@@ -332,7 +329,7 @@ func testIPBindable(ip net.IP) error {
 	if err != nil {
 		return err
 	}
-	_ = listener.Close()
+	listener.Close()
 	return nil
 }

@@ -354,39 +351,33 @@ func adjustIPVersionByBindAddress(ipVersion allregions.ConfigIPVersion, ip net.I
 	}
 }

-func newICMPRouter(c *cli.Context, logger *zerolog.Logger) (ingress.ICMPRouterServer, error) {
-	ipv4Src, ipv6Src, err := determineICMPSources(c, logger)
+func newPacketConfig(c *cli.Context, logger *zerolog.Logger) (*ingress.GlobalRouterConfig, error) {
+	ipv4Src, err := determineICMPv4Src(c.String("icmpv4-src"), logger)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to determine IPv4 source address for ICMP proxy")
 	}
-
-	icmpRouter, err := ingress.NewICMPRouter(ipv4Src, ipv6Src, logger, icmpFunnelTimeout)
-	if err != nil {
-		return nil, err
-	}
-	return icmpRouter, nil
-}
-
-func determineICMPSources(c *cli.Context, logger *zerolog.Logger) (netip.Addr, netip.Addr, error) {
-	ipv4Src, err := determineICMPv4Src(c.String(flags.ICMPV4Src), logger)
-	if err != nil {
-		return netip.Addr{}, netip.Addr{}, errors.Wrap(err, "failed to determine IPv4 source address for ICMP proxy")
-	}
-
 	logger.Info().Msgf("ICMP proxy will use %s as source for IPv4", ipv4Src)

-	ipv6Src, zone, err := determineICMPv6Src(c.String(flags.ICMPV6Src), logger, ipv4Src)
+	ipv6Src, zone, err := determineICMPv6Src(c.String("icmpv6-src"), logger, ipv4Src)
 	if err != nil {
-		return netip.Addr{}, netip.Addr{}, errors.Wrap(err, "failed to determine IPv6 source address for ICMP proxy")
+		return nil, errors.Wrap(err, "failed to determine IPv6 source address for ICMP proxy")
 	}
-
 	if zone != "" {
 		logger.Info().Msgf("ICMP proxy will use %s in zone %s as source for IPv6", ipv6Src, zone)
 	} else {
 		logger.Info().Msgf("ICMP proxy will use %s as source for IPv6", ipv6Src)
 	}

-	return ipv4Src, ipv6Src, nil
+	icmpRouter, err := ingress.NewICMPRouter(ipv4Src, ipv6Src, zone, logger, icmpFunnelTimeout)
+	if err != nil {
+		return nil, err
+	}
+	return &ingress.GlobalRouterConfig{
+		ICMPRouter: icmpRouter,
+		IPv4Src:    ipv4Src,
+		IPv6Src:    ipv6Src,
+		Zone:       zone,
+	}, nil
 }

 func determineICMPv4Src(userDefinedSrc string, logger *zerolog.Logger) (netip.Addr, error) {
@@ -416,12 +407,13 @@ type interfaceIP struct {

 func determineICMPv6Src(userDefinedSrc string, logger *zerolog.Logger, ipv4Src netip.Addr) (addr netip.Addr, zone string, err error) {
 	if userDefinedSrc != "" {
-		addr, err := netip.ParseAddr(userDefinedSrc)
+		userDefinedIP, zone, _ := strings.Cut(userDefinedSrc, "%")
+		addr, err := netip.ParseAddr(userDefinedIP)
 		if err != nil {
 			return netip.Addr{}, "", err
 		}
 		if addr.Is6() {
-			return addr, addr.Zone(), nil
+			return addr, zone, nil
 		}
 		return netip.Addr{}, "", fmt.Errorf("expect IPv6, but %s is IPv4", userDefinedSrc)
 	}
@@ -494,7 +486,7 @@ func findLocalAddr(dst net.IP, port int) (netip.Addr, error) {
 	if err != nil {
 		return netip.Addr{}, err
 	}
-	defer func() { _ = udpConn.Close() }()
+	defer udpConn.Close()
 	localAddrPort, err := netip.ParseAddrPort(udpConn.LocalAddr().String())
 	if err != nil {
 		return netip.Addr{}, err
@@ -502,19 +494,3 @@ func findLocalAddr(dst net.IP, port int) (netip.Addr, error) {
 	localAddr := localAddrPort.Addr()
 	return localAddr, nil
 }
-
-func parseResolverAddrPorts(input []string) ([]netip.AddrPort, error) {
-	// We don't allow more than 10 resolvers to be provided statically for the resolver service.
-	if len(input) > 10 {
-		return nil, errors.New("too many addresses provided, max: 10")
-	}
-	addrs := make([]netip.AddrPort, 0, len(input))
-	for _, val := range input {
-		addr, err := netip.ParseAddrPort(val)
-		if err != nil {
-			return nil, err
-		}
-		addrs = append(addrs, addr)
-	}
-	return addrs, nil
-}
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"path/filepath"

-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/credentials"

@@ -58,19 +57,17 @@ func newSearchByID(id uuid.UUID, c *cli.Context, log *zerolog.Logger, fs fileSys
 }

 func (s searchByID) Path() (string, error) {
-	originCertPath := s.c.String(cfdflags.OriginCert)
+	originCertPath := s.c.String(credentials.OriginCertFlag)
 	originCertLog := s.log.With().
 		Str("originCertPath", originCertPath).
 		Logger()

-	if originCertPath != "" {
-		// Look for tunnel credentials in the origin cert directory if the flag is provided
-		if originCertPath, err := credentials.FindOriginCert(originCertPath, &originCertLog); err == nil {
-			originCertDir := filepath.Dir(originCertPath)
-			if filePath, err := tunnelFilePath(s.id, originCertDir); err == nil {
-				if s.fs.validFilePath(filePath) {
-					return filePath, nil
-				}
+	// Fallback to look for tunnel credentials in the origin cert directory
+	if originCertPath, err := credentials.FindOriginCert(originCertPath, &originCertLog); err == nil {
+		originCertDir := filepath.Dir(originCertPath)
+		if filePath, err := tunnelFilePath(s.id, originCertDir); err == nil {
+			if s.fs.validFilePath(filePath) {
+				return filePath, nil
 			}
 		}
 	}
@@ -0,0 +1,3 @@
+package tunnel
+
+var FipsEnabled bool
@@ -12,7 +12,6 @@ import (
 	"github.com/urfave/cli/v2"

 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/credentials"
 	"github.com/cloudflare/cloudflared/logger"
@@ -20,31 +19,8 @@ import (
 )

 const (
-	baseLoginURL         = "https://dash.cloudflare.com/argotunnel"
-	callbackURL          = "https://login.cloudflareaccess.org/"
-	fedBaseLoginURL      = "https://dash.fed.cloudflare.com/argotunnel"
-	fedCallbackStoreURL  = "https://login.fed.cloudflareaccess.org/"
-	fedRAMPParamName     = "fedramp"
-	loginURLParamName    = "loginURL"
-	callbackURLParamName = "callbackURL"
-)
-
-var (
-	loginURL = &cli.StringFlag{
-		Name:  loginURLParamName,
-		Value: baseLoginURL,
-		Usage: "The URL used to login (default is https://dash.cloudflare.com/argotunnel)",
-	}
-	callbackStore = &cli.StringFlag{
-		Name:  callbackURLParamName,
-		Value: callbackURL,
-		Usage: "The URL used for the callback (default is https://login.cloudflareaccess.org/)",
-	}
-	fedramp = &cli.BoolFlag{
-		Name:    fedRAMPParamName,
-		Aliases: []string{"f"},
-		Usage:   "Login with FedRAMP High environment.",
-	}
+	baseLoginURL     = "https://dash.cloudflare.com/argotunnel"
+	callbackStoreURL = "https://login.cloudflareaccess.org/"
 )

 func buildLoginSubcommand(hidden bool) *cli.Command {
@@ -54,11 +30,6 @@ func buildLoginSubcommand(hidden bool) *cli.Command {
 		Usage:     "Generate a configuration file with your login details",
 		ArgsUsage: " ",
 		Hidden:    hidden,
-		Flags: []cli.Flag{
-			loginURL,
-			callbackStore,
-			fedramp,
-		},
 	}
 }

@@ -67,25 +38,15 @@ func login(c *cli.Context) error {

 	path, ok, err := checkForExistingCert()
 	if ok {
-		log.Error().Err(err).Msgf("You have an existing certificate at %s which login would overwrite.\nIf this is intentional, please move or delete that file then run this command again.\n", path)
+		fmt.Fprintf(os.Stdout, "You have an existing certificate at %s which login would overwrite.\nIf this is intentional, please move or delete that file then run this command again.\n", path)
 		return nil
 	} else if err != nil {
 		return err
 	}

-	var (
-		baseloginURL     = c.String(loginURLParamName)
-		callbackStoreURL = c.String(callbackURLParamName)
-	)
-
-	isFEDRamp := c.Bool(fedRAMPParamName)
-	if isFEDRamp {
-		baseloginURL = fedBaseLoginURL
-		callbackStoreURL = fedCallbackStoreURL
-	}
-
-	loginURL, err := url.Parse(baseloginURL)
+	loginURL, err := url.Parse(baseLoginURL)
 	if err != nil {
+		// shouldn't happen, URL is hardcoded
 		return err
 	}

@@ -97,37 +58,18 @@ func login(c *cli.Context) error {
 		callbackStoreURL,
 		false,
 		false,
-		c.Bool(cfdflags.AutoCloseInterstitial),
-		isFEDRamp,
 		log,
-		"",
 	)
 	if err != nil {
-		log.Error().Err(err).Msgf("Failed to write the certificate.\n\nYour browser will download the certificate instead. You will have to manually\ncopy it to the following path:\n\n%s\n", path)
+		fmt.Fprintf(os.Stderr, "Failed to write the certificate due to the following error:\n%v\n\nYour browser will download the certificate instead. You will have to manually\ncopy it to the following path:\n\n%s\n", err, path)
 		return err
 	}

-	cert, err := credentials.DecodeOriginCert(resourceData)
-	if err != nil {
-		log.Error().Err(err).Msg("failed to decode origin certificate")
-		return err
-	}
-
-	if isFEDRamp {
-		cert.Endpoint = credentials.FedEndpoint
-	}
-
-	resourceData, err = cert.EncodeOriginCert()
-	if err != nil {
-		log.Error().Err(err).Msg("failed to encode origin certificate")
-		return err
-	}
-
-	if err := os.WriteFile(path, resourceData, 0600); err != nil { // nolint: gosec
+	if err := os.WriteFile(path, resourceData, 0600); err != nil {
 		return errors.Wrap(err, fmt.Sprintf("error writing cert to %s", path))
 	}

-	log.Info().Msgf("You have successfully logged in.\nIf you wish to copy your credentials to a server, they have been saved to:\n%s\n", path)
+	fmt.Fprintf(os.Stdout, "You have successfully logged in.\nIf you wish to copy your credentials to a server, they have been saved to:\n%s\n", path)
 	return nil
 }

@@ -3,7 +3,6 @@ package tunnel
 import (
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
 	"strings"
 	"time"
@@ -11,14 +10,15 @@ import (
 	"github.com/google/uuid"
 	"github.com/pkg/errors"

-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/connection"
 )

 const httpTimeout = 15 * time.Second

-const disclaimer = "Thank you for trying Cloudflare Tunnel. Doing so, without a Cloudflare account, is a quick way to experiment and try it out. However, be aware that these account-less Tunnels have no uptime guarantee, are subject to the Cloudflare Online Services Terms of Use (https://www.cloudflare.com/website-terms/), and Cloudflare reserves the right to investigate your use of Tunnels for violations of such terms. If you intend to use Tunnels in production you should use a pre-created named tunnel by following: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps"
+const disclaimer = "Thank you for trying Cloudflare Tunnel. Doing so, without a Cloudflare account, is a quick way to" +
+	" experiment and try it out. However, be aware that these account-less Tunnels have no uptime guarantee. If you " +
+	"intend to use Tunnels in production you should use a pre-created named tunnel by following: " +
+	"https://developers.cloudflare.com/cloudflare-one/connections/connect-apps"

 // RunQuickTunnel requests a tunnel from the specified service.
 // We use this to power quick tunnels on trycloudflare.com, but the
@@ -45,19 +45,10 @@ func RunQuickTunnel(sc *subcommandContext) error {
 	if err != nil {
 		return errors.Wrap(err, "failed to request quick Tunnel")
 	}
-	defer func() { _ = resp.Body.Close() }()
-
-	// This will read the entire response into memory so we can print it in case of error
-	rsp_body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errors.Wrap(err, "failed to read quick-tunnel response")
-	}
+	defer resp.Body.Close()

 	var data QuickTunnelResponse
-	if err := json.Unmarshal(rsp_body, &data); err != nil {
-		rsp_string := string(rsp_body)
-		fields := map[string]interface{}{"status_code": resp.Status}
-		sc.log.Err(err).Fields(fields).Msgf("Error unmarshaling QuickTunnel response: %s", rsp_string)
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
 		return errors.Wrap(err, "failed to unmarshal quick Tunnel")
 	}

@@ -77,18 +68,20 @@ func RunQuickTunnel(sc *subcommandContext) error {
 		url = "https://" + url
 	}

-	cliutil.LogTable(sc.log, []string{
+	for _, line := range AsciiBox([]string{
 		"Your quick Tunnel has been created! Visit it at (it may take some time to be reachable):",
 		url,
-	})
+	}, 2) {
+		sc.log.Info().Msg(line)
+	}

-	if !sc.c.IsSet(flags.Protocol) {
-		_ = sc.c.Set(flags.Protocol, "quic")
+	if !sc.c.IsSet("protocol") {
+		sc.c.Set("protocol", "quic")
 	}

 	// Override the number of connections used. Quick tunnels shouldn't be used for production usage,
 	// so, use a single connection instead.
-	_ = sc.c.Set(flags.HaConnections, "1")
+	sc.c.Set(haConnectionsFlag, "1")
 	return StartServer(
 		sc.c,
 		buildInfo,
@@ -115,3 +108,26 @@ type QuickTunnel struct {
 	AccountTag string `json:"account_tag"`
 	Secret     []byte `json:"secret"`
 }
+
+// Print out the given lines in a nice ASCII box.
+func AsciiBox(lines []string, padding int) (box []string) {
+	maxLen := maxLen(lines)
+	spacer := strings.Repeat(" ", padding)
+	border := "+" + strings.Repeat("-", maxLen+(padding*2)) + "+"
+	box = append(box, border)
+	for _, line := range lines {
+		box = append(box, "|"+spacer+line+strings.Repeat(" ", maxLen-len(line))+spacer+"|")
+	}
+	box = append(box, border)
+	return
+}
+
+func maxLen(lines []string) int {
+	max := 0
+	for _, line := range lines {
+		if len(line) > max {
+			max = len(line)
+		}
+	}
+	return max
+}
@@ -0,0 +1,37 @@
+package tunnel
+
+import (
+	"fmt"
+
+	"github.com/cloudflare/cloudflared/tunneldns"
+
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
+	"github.com/urfave/cli/v2"
+)
+
+func runDNSProxyServer(c *cli.Context, dnsReadySignal chan struct{}, shutdownC <-chan struct{}, log *zerolog.Logger) error {
+	port := c.Int("proxy-dns-port")
+	if port <= 0 || port > 65535 {
+		return errors.New("The 'proxy-dns-port' must be a valid port number in <1, 65535> range.")
+	}
+	maxUpstreamConnections := c.Int("proxy-dns-max-upstream-conns")
+	if maxUpstreamConnections < 0 {
+		return fmt.Errorf("'%s' must be 0 or higher", "proxy-dns-max-upstream-conns")
+	}
+	listener, err := tunneldns.CreateListener(c.String("proxy-dns-address"), uint16(port), c.StringSlice("proxy-dns-upstream"), c.StringSlice("proxy-dns-bootstrap"), maxUpstreamConnections, log)
+	if err != nil {
+		close(dnsReadySignal)
+		listener.Stop()
+		return errors.Wrap(err, "Cannot create the DNS over HTTPS proxy server")
+	}
+
+	err = listener.Start(dnsReadySignal)
+	if err != nil {
+		return errors.Wrap(err, "Cannot start the DNS over HTTPS proxy server")
+	}
+	<-shutdownC
+	_ = listener.Stop()
+	log.Info().Msg("DNS server stopped")
+	return nil
+}
@@ -9,26 +9,22 @@ import (
 	"strings"

 	"github.com/google/uuid"
-	"github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"

 	"github.com/cloudflare/cloudflared/cfapi"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/connection"
 	"github.com/cloudflare/cloudflared/credentials"
 	"github.com/cloudflare/cloudflared/logger"
 )

-const fedRampBaseApiURL = "https://api.fed.cloudflare.com/client/v4"
-
-type invalidJSONCredentialError struct {
+type errInvalidJSONCredential struct {
 	err  error
 	path string
 }

-func (e invalidJSONCredentialError) Error() string {
+func (e errInvalidJSONCredential) Error() string {
 	return "Invalid JSON when parsing tunnel credentials file"
 }

@@ -55,12 +51,7 @@ func newSubcommandContext(c *cli.Context) (*subcommandContext, error) {
 // Returns something that can find the given tunnel's credentials file.
 func (sc *subcommandContext) credentialFinder(tunnelID uuid.UUID) CredFinder {
 	if path := sc.c.String(CredFileFlag); path != "" {
-		// Expand path if CredFileFlag contains `~`
-		absPath, err := homedir.Expand(path)
-		if err != nil {
-			return newStaticPath(path, sc.fs)
-		}
-		return newStaticPath(absPath, sc.fs)
+		return newStaticPath(path, sc.fs)
 	}
 	return newSearchByID(tunnelID, sc.c, sc.log, sc.fs)
 }
@@ -73,16 +64,7 @@ func (sc *subcommandContext) client() (cfapi.Client, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	var apiURL string
-	if cred.IsFEDEndpoint() {
-		sc.log.Info().Str("api-url", fedRampBaseApiURL).Msg("using fedramp base api")
-		apiURL = fedRampBaseApiURL
-	} else {
-		apiURL = sc.c.String(cfdflags.ApiURL)
-	}
-
-	sc.tunnelstoreClient, err = cred.Client(apiURL, buildInfo.UserAgent(), sc.log)
+	sc.tunnelstoreClient, err = cred.Client(sc.c.String("api-url"), buildInfo.UserAgent(), sc.log)
 	if err != nil {
 		return nil, err
 	}
@@ -91,7 +73,7 @@ func (sc *subcommandContext) client() (cfapi.Client, error) {

 func (sc *subcommandContext) credential() (*credentials.User, error) {
 	if sc.userCredential == nil {
-		uc, err := credentials.Read(sc.c.String(cfdflags.OriginCert), sc.log)
+		uc, err := credentials.Read(sc.c.String(credentials.OriginCertFlag), sc.log)
 		if err != nil {
 			return nil, err
 		}
@@ -112,13 +94,13 @@ func (sc *subcommandContext) readTunnelCredentials(credFinder CredFinder) (conne

 	var credentials connection.Credentials
 	if err = json.Unmarshal(body, &credentials); err != nil {
-		if filepath.Ext(filePath) == ".pem" {
+		if strings.HasSuffix(filePath, ".pem") {
 			return connection.Credentials{}, fmt.Errorf("The tunnel credentials file should be .json but you gave a .pem. " +
 				"The tunnel credentials file was originally created by `cloudflared tunnel create`. " +
 				"You may have accidentally used the filepath to cert.pem, which is generated by `cloudflared tunnel " +
 				"login`.")
 		}
-		return connection.Credentials{}, invalidJSONCredentialError{path: filePath, err: err}
+		return connection.Credentials{}, errInvalidJSONCredential{path: filePath, err: err}
 	}
 	return credentials, nil
 }
@@ -140,7 +122,7 @@ func (sc *subcommandContext) create(name string, credentialsFilePath string, sec
 		if err != nil {
 			return nil, errors.Wrap(err, "Couldn't decode tunnel secret from base64")
 		}
-		tunnelSecret = decodedSecret
+		tunnelSecret = []byte(decodedSecret)
 		if len(tunnelSecret) < 32 {
 			return nil, errors.New("Decoded tunnel secret must be at least 32 bytes long")
 		}
@@ -155,12 +137,10 @@ func (sc *subcommandContext) create(name string, credentialsFilePath string, sec
 	if err != nil {
 		return nil, err
 	}
-
 	tunnelCredentials := connection.Credentials{
 		AccountTag:   credential.AccountID(),
 		TunnelSecret: tunnelSecret,
 		TunnelID:     tunnel.ID,
-		Endpoint:     credential.Endpoint(),
 	}
 	usedCertPath := false
 	if credentialsFilePath == "" {
@@ -180,7 +160,7 @@ func (sc *subcommandContext) create(name string, credentialsFilePath string, sec
 			errorLines = append(errorLines, fmt.Sprintf("Cloudflared tried to delete the tunnel for you, but encountered an error. You should use `cloudflared tunnel delete %v` to delete the tunnel yourself, because the tunnel can't be run without the tunnelfile.", tunnel.ID))
 			errorLines = append(errorLines, fmt.Sprintf("The delete tunnel error is: %v", deleteErr))
 		} else {
-			errorLines = append(errorLines, "The tunnel was deleted, because the tunnel can't be run without the credentials file")
+			errorLines = append(errorLines, fmt.Sprintf("The tunnel was deleted, because the tunnel can't be run without the credentials file"))
 		}
 		errorMsg := strings.Join(errorLines, "\n")
 		return nil, errors.New(errorMsg)
@@ -209,7 +189,7 @@ func (sc *subcommandContext) list(filter *cfapi.TunnelFilter) ([]*cfapi.Tunnel,
 }

 func (sc *subcommandContext) delete(tunnelIDs []uuid.UUID) error {
-	forceFlagSet := sc.c.Bool(cfdflags.Force)
+	forceFlagSet := sc.c.Bool("force")

 	client, err := sc.client()
 	if err != nil {
@@ -249,7 +229,7 @@ func (sc *subcommandContext) findCredentials(tunnelID uuid.UUID) (connection.Cre
 	var err error
 	if credentialsContents := sc.c.String(CredContentsFlag); credentialsContents != "" {
 		if err = json.Unmarshal([]byte(credentialsContents), &credentials); err != nil {
-			err = invalidJSONCredentialError{path: "TUNNEL_CRED_CONTENTS", err: err}
+			err = errInvalidJSONCredential{path: "TUNNEL_CRED_CONTENTS", err: err}
 		}
 	} else {
 		credFinder := sc.credentialFinder(tunnelID)
@@ -265,7 +245,7 @@ func (sc *subcommandContext) findCredentials(tunnelID uuid.UUID) (connection.Cre
 func (sc *subcommandContext) run(tunnelID uuid.UUID) error {
 	credentials, err := sc.findCredentials(tunnelID)
 	if err != nil {
-		if e, ok := err.(invalidJSONCredentialError); ok {
+		if e, ok := err.(errInvalidJSONCredential); ok {
 			sc.log.Error().Msgf("The credentials file at %s contained invalid JSON. This is probably caused by passing the wrong filepath. Reminder: the credentials file is a .json file created via `cloudflared tunnel create`.", e.path)
 			sc.log.Error().Msgf("Invalid JSON when parsing credentials file: %s", e.err.Error())
 		}
@@ -5,8 +5,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"io"
-	"net/http"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -16,40 +14,28 @@ import (
 	"time"

 	"github.com/google/uuid"
-	"github.com/mitchellh/go-homedir"
+	homedir "github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 	"github.com/urfave/cli/v2/altsrc"
 	"golang.org/x/net/idna"
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"

 	"github.com/cloudflare/cloudflared/cfapi"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/updater"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/connection"
-	"github.com/cloudflare/cloudflared/diagnostic"
-	"github.com/cloudflare/cloudflared/fips"
-	"github.com/cloudflare/cloudflared/metrics"
 )

 const (
-	allSortByOptions        = "name, id, createdAt, deletedAt, numConnections"
-	connsSortByOptions      = "id, startedAt, numConnections, version"
-	CredFileFlagAlias       = "cred-file"
-	CredFileFlag            = "credentials-file"
-	CredContentsFlag        = "credentials-contents"
-	TunnelTokenFlag         = "token"
-	TunnelTokenFileFlag     = "token-file"
-	overwriteDNSFlagName    = "overwrite-dns"
-	noDiagLogsFlagName      = "no-diag-logs"
-	noDiagMetricsFlagName   = "no-diag-metrics"
-	noDiagSystemFlagName    = "no-diag-system"
-	noDiagRuntimeFlagName   = "no-diag-runtime"
-	noDiagNetworkFlagName   = "no-diag-network"
-	diagContainerIDFlagName = "diag-container-id"
-	diagPodFlagName         = "diag-pod-id"
+	allSortByOptions     = "name, id, createdAt, deletedAt, numConnections"
+	connsSortByOptions   = "id, startedAt, numConnections, version"
+	CredFileFlagAlias    = "cred-file"
+	CredFileFlag         = "credentials-file"
+	CredContentsFlag     = "credentials-contents"
+	TunnelTokenFlag      = "token"
+	overwriteDNSFlagName = "overwrite-dns"

 	LogFieldTunnelID = "tunnelID"
 )
@@ -61,7 +47,7 @@ var (
 		Usage:   "Include deleted tunnels in the list",
 	}
 	listNameFlag = &cli.StringFlag{
-		Name:    flags.Name,
+		Name:    "name",
 		Aliases: []string{"n"},
 		Usage:   "List tunnels with the given `NAME`",
 	}
@@ -109,7 +95,7 @@ var (
 		EnvVars: []string{"TUNNEL_LIST_INVERT_SORT"},
 	}
 	featuresFlag = altsrc.NewStringSliceFlag(&cli.StringSliceFlag{
-		Name:    flags.Features,
+		Name:    "features",
 		Aliases: []string{"F"},
 		Usage:   "Opt into various features that are still being developed or tested.",
 	})
@@ -127,23 +113,18 @@ var (
 	})
 	tunnelTokenFlag = altsrc.NewStringFlag(&cli.StringFlag{
 		Name:    TunnelTokenFlag,
-		Usage:   "The Tunnel token. When provided along with credentials, this will take precedence. Also takes precedence over token-file",
+		Usage:   "The Tunnel token. When provided along with credentials, this will take precedence.",
 		EnvVars: []string{"TUNNEL_TOKEN"},
 	})
-	tunnelTokenFileFlag = altsrc.NewStringFlag(&cli.StringFlag{
-		Name:    TunnelTokenFileFlag,
-		Usage:   "Filepath at which to read the tunnel token. When provided along with credentials, this will take precedence.",
-		EnvVars: []string{"TUNNEL_TOKEN_FILE"},
-	})
 	forceDeleteFlag = &cli.BoolFlag{
-		Name:    flags.Force,
+		Name:    "force",
 		Aliases: []string{"f"},
 		Usage: "Deletes a tunnel even if tunnel is connected and it has dependencies associated to it. (eg. IP routes)." +
 			" It is not possible to delete tunnels that have connections or non-deleted dependencies, without this flag.",
 		EnvVars: []string{"TUNNEL_RUN_FORCE_OVERWRITE"},
 	}
 	selectProtocolFlag = altsrc.NewStringFlag(&cli.StringFlag{
-		Name:    flags.Protocol,
+		Name:    "protocol",
 		Value:   connection.AutoSelectFlag,
 		Aliases: []string{"p"},
 		Usage:   fmt.Sprintf("Protocol implementation to connect with Cloudflare's edge network. %s", connection.AvailableProtocolFlagMessage),
@@ -151,11 +132,11 @@ var (
 		Hidden:  true,
 	})
 	postQuantumFlag = altsrc.NewBoolFlag(&cli.BoolFlag{
-		Name:    flags.PostQuantum,
+		Name:    "post-quantum",
 		Usage:   "When given creates an experimental post-quantum secure tunnel",
 		Aliases: []string{"pq"},
 		EnvVars: []string{"TUNNEL_POST_QUANTUM"},
-		Hidden:  fips.IsFipsEnabled(),
+		Hidden:  FipsEnabled,
 	})
 	sortInfoByFlag = &cli.StringFlag{
 		Name:    "sort-by",
@@ -187,65 +168,15 @@ var (
 		EnvVars: []string{"TUNNEL_CREATE_SECRET"},
 	}
 	icmpv4SrcFlag = &cli.StringFlag{
-		Name:    flags.ICMPV4Src,
+		Name:    "icmpv4-src",
 		Usage:   "Source address to send/receive ICMPv4 messages. If not provided cloudflared will dial a local address to determine the source IP or fallback to 0.0.0.0.",
 		EnvVars: []string{"TUNNEL_ICMPV4_SRC"},
 	}
 	icmpv6SrcFlag = &cli.StringFlag{
-		Name:    flags.ICMPV6Src,
+		Name:    "icmpv6-src",
 		Usage:   "Source address and the interface name to send/receive ICMPv6 messages. If not provided cloudflared will dial a local address to determine the source IP or fallback to ::.",
 		EnvVars: []string{"TUNNEL_ICMPV6_SRC"},
 	}
-	metricsFlag = &cli.StringFlag{
-		Name:  flags.Metrics,
-		Usage: "The metrics server address i.e.: 127.0.0.1:12345. If your instance is running in a Docker/Kubernetes environment you need to setup port forwarding for your application.",
-		Value: "",
-	}
-	diagContainerFlag = &cli.StringFlag{
-		Name:  diagContainerIDFlagName,
-		Usage: "Container ID or Name to collect logs from",
-		Value: "",
-	}
-	diagPodFlag = &cli.StringFlag{
-		Name:  diagPodFlagName,
-		Usage: "Kubernetes POD to collect logs from",
-		Value: "",
-	}
-	noDiagLogsFlag = &cli.BoolFlag{
-		Name:  noDiagLogsFlagName,
-		Usage: "Log collection will not be performed",
-		Value: false,
-	}
-	noDiagMetricsFlag = &cli.BoolFlag{
-		Name:  noDiagMetricsFlagName,
-		Usage: "Metric collection will not be performed",
-		Value: false,
-	}
-	noDiagSystemFlag = &cli.BoolFlag{
-		Name:  noDiagSystemFlagName,
-		Usage: "System information collection will not be performed",
-		Value: false,
-	}
-	noDiagRuntimeFlag = &cli.BoolFlag{
-		Name:  noDiagRuntimeFlagName,
-		Usage: "Runtime information collection will not be performed",
-		Value: false,
-	}
-	noDiagNetworkFlag = &cli.BoolFlag{
-		Name:  noDiagNetworkFlagName,
-		Usage: "Network diagnostics won't be performed",
-		Value: false,
-	}
-	maxActiveFlowsFlag = &cli.Uint64Flag{
-		Name:    flags.MaxActiveFlows,
-		Usage:   "Overrides the remote configuration for max active private network flows (TCP/UDP) that this cloudflared instance supports",
-		EnvVars: []string{"TUNNEL_MAX_ACTIVE_FLOWS"},
-	}
-	dnsResolverAddrsFlag = &cli.StringSliceFlag{
-		Name:    flags.VirtualDNSServiceResolverAddresses,
-		Usage:   "Overrides the dynamic DNS resolver resolution to use these address:port's instead.",
-		EnvVars: []string{"TUNNEL_DNS_RESOLVER_ADDRS"},
-	}
 )

 func buildCreateCommand() *cli.Command {
@@ -348,7 +279,7 @@ func listCommand(c *cli.Context) error {
 	if !c.Bool("show-deleted") {
 		filter.NoDeleted()
 	}
-	if name := c.String(flags.Name); name != "" {
+	if name := c.String("name"); name != "" {
 		filter.ByName(name)
 	}
 	if namePrefix := c.String("name-prefix"); namePrefix != "" {
@@ -421,7 +352,7 @@ func listCommand(c *cli.Context) error {

 func formatAndPrintTunnelList(tunnels []*cfapi.Tunnel, showRecentlyDisconnected bool) {
 	writer := tabWriter()
-	defer func() { _ = writer.Flush() }()
+	defer writer.Flush()

 	_, _ = fmt.Fprintln(writer, "You can obtain more detailed information for each tunnel with `cloudflared tunnel info <name/uuid>`")

@@ -442,16 +373,16 @@ func formatAndPrintTunnelList(tunnels []*cfapi.Tunnel, showRecentlyDisconnected
 }

 func fmtConnections(connections []cfapi.Connection, showRecentlyDisconnected bool) string {
+
 	// Count connections per colo
 	numConnsPerColo := make(map[string]uint, len(connections))
-	for _, cfConnections := range connections {
-		if !cfConnections.IsPendingReconnect || showRecentlyDisconnected {
-			numConnsPerColo[cfConnections.ColoName]++
+	for _, connection := range connections {
+		if !connection.IsPendingReconnect || showRecentlyDisconnected {
+			numConnsPerColo[connection.ColoName]++
 		}
 	}

 	// Get sorted list of colos
-	// nolint: prealloc
 	sortedColos := []string{}
 	for coloName := range numConnsPerColo {
 		sortedColos = append(sortedColos, coloName)
@@ -459,52 +390,13 @@ func fmtConnections(connections []cfapi.Connection, showRecentlyDisconnected boo
 	sort.Strings(sortedColos)

 	// Map each colo to its frequency, combine into output string.
-	output := make([]string, 0, len(sortedColos))
+	var output []string
 	for _, coloName := range sortedColos {
 		output = append(output, fmt.Sprintf("%dx%s", numConnsPerColo[coloName], coloName))
 	}
 	return strings.Join(output, ", ")
 }

-func buildReadyCommand() *cli.Command {
-	return &cli.Command{
-		Name:               "ready",
-		Action:             cliutil.ConfiguredAction(readyCommand),
-		Usage:              "Call /ready endpoint and return proper exit code",
-		UsageText:          "cloudflared tunnel [tunnel command options] ready [subcommand options]",
-		Description:        "cloudflared tunnel ready will return proper exit code based on the /ready endpoint",
-		Flags:              []cli.Flag{},
-		CustomHelpTemplate: commandHelpTemplate(),
-	}
-}
-
-func readyCommand(c *cli.Context) error {
-	metricsOpts := c.String(flags.Metrics)
-	if !c.IsSet(flags.Metrics) {
-		return errors.New("--metrics has to be provided")
-	}
-
-	requestURL := fmt.Sprintf("http://%s/ready", metricsOpts)
-	req, err := http.NewRequest(http.MethodGet, requestURL, nil)
-	if err != nil {
-		return err
-	}
-	// nolint: gosec // URL is constructed from the user-configured local metrics endpoint.
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = res.Body.Close() }()
-	if res.StatusCode != 200 {
-		body, err := io.ReadAll(res.Body)
-		if err != nil {
-			return err
-		}
-		return fmt.Errorf("http://%s/ready endpoint returned status code %d\n%s", metricsOpts, res.StatusCode, body)
-	}
-	return nil
-}
-
 func buildInfoCommand() *cli.Command {
 	return &cli.Command{
 		Name:        "info",
@@ -615,7 +507,7 @@ func getTunnel(sc *subcommandContext, tunnelID uuid.UUID) (*cfapi.Tunnel, error)

 func formatAndPrintConnectionsList(tunnelInfo Info, showRecentlyDisconnected bool) {
 	writer := tabWriter()
-	defer func() { _ = writer.Flush() }()
+	defer writer.Flush()

 	// Print the general tunnel info table
 	_, _ = fmt.Fprintf(writer, "NAME:     %s\nID:       %s\nCREATED:  %s\n\n", tunnelInfo.Name, tunnelInfo.ID, tunnelInfo.CreatedAt)
@@ -656,14 +548,14 @@ func formatAndPrintConnectionsList(tunnelInfo Info, showRecentlyDisconnected boo

 func tabWriter() *tabwriter.Writer {
 	const (
-		minWidth    = 0
-		tabWidth    = 8
-		padding     = 1
-		padChar     = ' '
-		formatFlags = 0
+		minWidth = 0
+		tabWidth = 8
+		padding  = 1
+		padChar  = ' '
+		flags    = 0
 	)

-	writer := tabwriter.NewWriter(os.Stdout, minWidth, tabWidth, padding, padChar, formatFlags)
+	writer := tabwriter.NewWriter(os.Stdout, minWidth, tabWidth, padding, padChar, flags)
 	return writer
 }

@@ -714,21 +606,17 @@ func renderOutput(format string, v interface{}) error {
 }

 func buildRunCommand() *cli.Command {
-	//nolint: prealloc
-	cliFlags := []cli.Flag{
+	flags := []cli.Flag{
 		credentialsFileFlag,
 		credentialsContentsFlag,
 		postQuantumFlag,
 		selectProtocolFlag,
 		featuresFlag,
 		tunnelTokenFlag,
-		tunnelTokenFileFlag,
 		icmpv4SrcFlag,
 		icmpv6SrcFlag,
-		maxActiveFlowsFlag,
-		dnsResolverAddrsFlag,
 	}
-	cliFlags = append(cliFlags, configureProxyFlags(false)...)
+	flags = append(flags, configureProxyFlags(false)...)
 	return &cli.Command{
 		Name:      "run",
 		Action:    cliutil.ConfiguredAction(runCommand),
@@ -743,7 +631,7 @@ func buildRunCommand() *cli.Command {
  If you experience other problems running the tunnel, "cloudflared tunnel cleanup" may help by removing
  any old connection records.
 `,
-		Flags:              cliFlags,
+		Flags:              flags,
 		CustomHelpTemplate: commandHelpTemplate(),
 	}
 }
@@ -764,23 +652,12 @@ func runCommand(c *cli.Context) error {
 			"your origin will not be reachable. You should remove the `hostname` property to avoid this warning.")
 	}

-	tokenStr := c.String(TunnelTokenFlag)
-	// Check if tokenStr is blank before checking for tokenFile
-	if tokenStr == "" {
-		if tokenFile := c.String(TunnelTokenFileFlag); tokenFile != "" {
-			// nolint: gosec
-			data, err := os.ReadFile(tokenFile)
-			if err != nil {
-				return cliutil.UsageError("Failed to read token file: %s", err.Error())
-			}
-			tokenStr = strings.TrimSpace(string(data))
-		}
-	}
 	// Check if token is provided and if not use default tunnelID flag method
-	if tokenStr != "" {
+	if tokenStr := c.String(TunnelTokenFlag); tokenStr != "" {
 		if token, err := ParseToken(tokenStr); err == nil {
 			return sc.runWithCredentials(token.Credentials())
 		}
+
 		return cliutil.UsageError("Provided Tunnel token is not valid.")
 	} else {
 		tunnelRef := c.Args().First()
@@ -985,10 +862,8 @@ func lbRouteFromArg(c *cli.Context) (cfapi.HostnameRoute, error) {
 	return cfapi.NewLBRoute(lbName, lbPool), nil
 }

-var (
-	nameRegex     = regexp.MustCompile("^[_a-zA-Z0-9][-_.a-zA-Z0-9]*$")
-	hostNameRegex = regexp.MustCompile("^[*_a-zA-Z0-9][-_.a-zA-Z0-9]*$")
-)
+var nameRegex = regexp.MustCompile("^[_a-zA-Z0-9][-_.a-zA-Z0-9]*$")
+var hostNameRegex = regexp.MustCompile("^[*_a-zA-Z0-9][-_.a-zA-Z0-9]*$")

 func validateName(s string, allowWildcardSubdomain bool) bool {
 	if allowWildcardSubdomain {
@@ -1076,79 +951,3 @@ SUBCOMMAND OPTIONS:
 `
 	return fmt.Sprintf(template, parentFlagsHelp)
 }
-
-func buildDiagCommand() *cli.Command {
-	return &cli.Command{
-		Name:        "diag",
-		Action:      cliutil.ConfiguredAction(diagCommand),
-		Usage:       "Creates a diagnostic report from a local cloudflared instance",
-		UsageText:   "cloudflared tunnel [tunnel command options] diag [subcommand options]",
-		Description: "cloudflared tunnel diag will create a diagnostic report of a local cloudflared instance. The diagnostic procedure collects: logs, metrics, system information, traceroute to Cloudflare Edge, and runtime information. Since there may be multiple instances of cloudflared running the --metrics option may be provided to target a specific instance.",
-		Flags: []cli.Flag{
-			metricsFlag,
-			diagContainerFlag,
-			diagPodFlag,
-			noDiagLogsFlag,
-			noDiagMetricsFlag,
-			noDiagSystemFlag,
-			noDiagRuntimeFlag,
-			noDiagNetworkFlag,
-		},
-		CustomHelpTemplate: commandHelpTemplate(),
-	}
-}
-
-func diagCommand(ctx *cli.Context) error {
-	sctx, err := newSubcommandContext(ctx)
-	if err != nil {
-		return err
-	}
-	log := sctx.log
-	options := diagnostic.Options{
-		KnownAddresses: metrics.GetMetricsKnownAddresses(metrics.Runtime),
-		Address:        sctx.c.String(flags.Metrics),
-		ContainerID:    sctx.c.String(diagContainerIDFlagName),
-		PodID:          sctx.c.String(diagPodFlagName),
-		Region:         sctx.c.String(flags.Region),
-		Toggles: diagnostic.Toggles{
-			NoDiagLogs:    sctx.c.Bool(noDiagLogsFlagName),
-			NoDiagMetrics: sctx.c.Bool(noDiagMetricsFlagName),
-			NoDiagSystem:  sctx.c.Bool(noDiagSystemFlagName),
-			NoDiagRuntime: sctx.c.Bool(noDiagRuntimeFlagName),
-			NoDiagNetwork: sctx.c.Bool(noDiagNetworkFlagName),
-		},
-	}
-
-	if options.Address == "" {
-		log.Info().Msg("If your instance is running in a Docker/Kubernetes environment you need to setup port forwarding for your application.")
-	}
-
-	states, err := diagnostic.RunDiagnostic(log, options)
-
-	if errors.Is(err, diagnostic.ErrMetricsServerNotFound) {
-		log.Warn().Msg("No instances found")
-		return nil
-	}
-	if errors.Is(err, diagnostic.ErrMultipleMetricsServerFound) {
-		if states != nil {
-			log.Info().Msgf("Found multiple instances running:")
-			for _, state := range states {
-				log.Info().Msgf("Instance: tunnel-id=%s connector-id=%s metrics-address=%s", state.TunnelID, state.ConnectorID, state.URL.String())
-			}
-			log.Info().Msgf("To select one instance use the option --metrics")
-		}
-		return nil
-	}
-
-	if errors.Is(err, diagnostic.ErrLogConfigurationIsInvalid) {
-		log.Info().Msg("Couldn't extract logs from the instance. If the instance is running in a containerized environment use the option --diag-container-id or --diag-pod-id. If there is no logging configuration use --no-diag-logs.")
-	}
-
-	if err != nil {
-		log.Warn().Msg("Diagnostic completed with one or more errors")
-	} else {
-		log.Info().Msg("Diagnostic completed")
-	}
-
-	return nil
-}
@@ -22,7 +22,7 @@ var (
 		Usage:   "The ID or name of the virtual network to which the route is associated to.",
 	}

-	errAddRoute = errors.New("You must supply exactly one argument, the ID or CIDR of the route you want to delete")
+	routeAddError = errors.New("You must supply exactly one argument, the ID or CIDR of the route you want to delete")
 )

 func buildRouteIPSubcommand() *cli.Command {
@@ -32,7 +32,7 @@ func buildRouteIPSubcommand() *cli.Command {
 		UsageText: "cloudflared tunnel [--config FILEPATH] route COMMAND [arguments...]",
 		Description: `cloudflared can provision routes for any IP space in your corporate network. Users enrolled in
 your Cloudflare for Teams organization can reach those IPs through the Cloudflare WARP
-client. You can then configure L7/L4 filtering on https://one.dash.cloudflare.com to
+client. You can then configure L7/L4 filtering on https://dash.teams.cloudflare.com to
 determine who can reach certain routes.
 By default IP routes all exist within a single virtual network. If you use the same IP
 space(s) in different physical private networks, all meant to be reachable via IP routes,
@@ -187,7 +187,7 @@ func deleteRouteCommand(c *cli.Context) error {
 	}

 	if c.NArg() != 1 {
-		return errAddRoute
+		return routeAddError
 	}

 	var routeId uuid.UUID
@@ -195,7 +195,7 @@ func deleteRouteCommand(c *cli.Context) error {
 	if err != nil {
 		_, network, err := net.ParseCIDR(c.Args().First())
 		if err != nil || network == nil {
-			return errAddRoute
+			return routeAddError
 		}

 		var vnetId *uuid.UUID
@@ -14,16 +14,13 @@ import (
 	"github.com/urfave/cli/v2"
 	"golang.org/x/term"

-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
-	cfdflags "github.com/cloudflare/cloudflared/cmd/cloudflared/flags"
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/inits"
 	"github.com/cloudflare/cloudflared/config"
 	"github.com/cloudflare/cloudflared/logger"
 )

 const (
 	DefaultCheckUpdateFreq        = time.Hour * 24
-	noUpdateInShellMessage        = "cloudflared will not automatically update when run from the shell. To enable auto-updates, run cloudflared as a service: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/configure-tunnels/local-management/as-a-service/"
+	noUpdateInShellMessage        = "cloudflared will not automatically update when run from the shell. To enable auto-updates, run cloudflared as a service: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/run-tunnel/as-a-service/"
 	noUpdateOnWindowsMessage      = "cloudflared will not automatically update on Windows systems."
 	noUpdateManagedPackageMessage = "cloudflared will not automatically update if installed by a package manager."
 	isManagedInstallFile          = ".installedFromPackageManager"
@@ -34,13 +31,12 @@ const (
 )

 var (
-	buildInfo              *cliutil.BuildInfo
+	version                string
 	BuiltForPackageManager = ""
 )

 // BinaryUpdated implements ExitCoder interface, the app will exit with status code 11
 // https://pkg.go.dev/github.com/urfave/cli/v2?tab=doc#ExitCoder
-// nolint: errname
 type statusSuccess struct {
 	newVersion string
 }
@@ -53,16 +49,16 @@ func (u *statusSuccess) ExitCode() int {
 	return 11
 }

-// statusError implements ExitCoder interface, the app will exit with status code 10
-type statusError struct {
+// UpdateErr implements ExitCoder interface, the app will exit with status code 10
+type statusErr struct {
 	err error
 }

-func (e *statusError) Error() string {
+func (e *statusErr) Error() string {
 	return fmt.Sprintf("failed to update cloudflared: %v", e.err)
 }

-func (e *statusError) ExitCode() int {
+func (e *statusErr) ExitCode() int {
 	return 10
 }

@@ -82,11 +78,11 @@ type UpdateOutcome struct {
 }

 func (uo *UpdateOutcome) noUpdate() bool {
-	return uo.Error == nil && !uo.Updated
+	return uo.Error == nil && uo.Updated == false
 }

-func Init(info *cliutil.BuildInfo) {
-	buildInfo = info
+func Init(v string) {
+	version = v
 }

 func CheckForUpdate(options updateOptions) (CheckResult, error) {
@@ -104,19 +100,18 @@ func CheckForUpdate(options updateOptions) (CheckResult, error) {
 		cfdPath = encodeWindowsPath(cfdPath)
 	}

-	s := NewWorkersService(buildInfo.CloudflaredVersion, url, cfdPath, Options{IsBeta: options.isBeta,
+	s := NewWorkersService(version, url, cfdPath, Options{IsBeta: options.isBeta,
 		IsForced: options.isForced, RequestedVersion: options.intendedVersion})

 	return s.Check()
 }
-
 func encodeWindowsPath(path string) string {
 	// We do this because Windows allows spaces in directories such as
 	// Program Files but does not allow these directories to be spaced in batch files.
-	targetPath := strings.ReplaceAll(path, "Program Files (x86)", "PROGRA~2")
+	targetPath := strings.Replace(path, "Program Files (x86)", "PROGRA~2", -1)
 	// This is to do the same in 32 bit systems. We do this second so that the first
 	// replace is for x86 dirs.
-	targetPath = strings.ReplaceAll(targetPath, "Program Files", "PROGRA~1")
+	targetPath = strings.Replace(targetPath, "Program Files", "PROGRA~1", -1)
 	return targetPath
 }

@@ -156,7 +151,7 @@ func Update(c *cli.Context) error {
 		log.Info().Msg("cloudflared is set to update from staging")
 	}

-	isForced := c.Bool(cfdflags.Force)
+	isForced := c.Bool("force")
 	if isForced {
 		log.Info().Msg("cloudflared is set to upgrade to the latest publish version regardless of the current version")
 	}
@@ -169,7 +164,7 @@ func Update(c *cli.Context) error {
 		intendedVersion: c.String("version"),
 	})
 	if updateOutcome.Error != nil {
-		return &statusError{updateOutcome.Error}
+		return &statusErr{updateOutcome.Error}
 	}

 	if updateOutcome.noUpdate() {
@@ -201,9 +196,10 @@ func loggedUpdate(log *zerolog.Logger, options updateOptions) UpdateOutcome {

 // AutoUpdater periodically checks for new version of cloudflared.
 type AutoUpdater struct {
-	configurable *configurable
-	listeners    *gracenet.Net
-	log          *zerolog.Logger
+	configurable     *configurable
+	listeners        *gracenet.Net
+	updateConfigChan chan *configurable
+	log              *zerolog.Logger
 }

 // AutoUpdaterConfigurable is the attributes of AutoUpdater that can be reconfigured during runtime
@@ -214,9 +210,10 @@ type configurable struct {

 func NewAutoUpdater(updateDisabled bool, freq time.Duration, listeners *gracenet.Net, log *zerolog.Logger) *AutoUpdater {
 	return &AutoUpdater{
-		configurable: createUpdateConfig(updateDisabled, freq, log),
-		listeners:    listeners,
-		log:          log,
+		configurable:     createUpdateConfig(updateDisabled, freq, log),
+		listeners:        listeners,
+		updateConfigChan: make(chan *configurable),
+		log:              log,
 	}
 }

@@ -235,27 +232,19 @@ func createUpdateConfig(updateDisabled bool, freq time.Duration, log *zerolog.Lo
 	}
 }

-// Run will perodically check for cloudflared updates, download them, and then restart the current cloudflared process
-// to use the new version. It delays the first update check by the configured frequency as to not attempt a
-// download immediately and restart after starting (in the case that there is an upgrade available).
 func (a *AutoUpdater) Run(ctx context.Context) error {
 	ticker := time.NewTicker(a.configurable.freq)
 	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-ticker.C:
-		}
 		updateOutcome := loggedUpdate(a.log, updateOptions{updateDisabled: !a.configurable.enabled})
 		if updateOutcome.Updated {
-			buildInfo.CloudflaredVersion = updateOutcome.Version
-			if inits.IsSysV() {
+			Init(updateOutcome.Version)
+			if IsSysV() {
 				// SysV doesn't have a mechanism to keep service alive, we have to restart the process
 				a.log.Info().Msg("Restarting service managed by SysV...")
 				pid, err := a.listeners.StartProcess()
 				if err != nil {
 					a.log.Err(err).Msg("Unable to restart server automatically")
-					return &statusError{err: err}
+					return &statusErr{err: err}
 				}
 				// stop old process after autoupdate. Otherwise we create a new process
 				// after each update
@@ -265,9 +254,25 @@ func (a *AutoUpdater) Run(ctx context.Context) error {
 		} else if updateOutcome.UserMessage != "" {
 			a.log.Warn().Msg(updateOutcome.UserMessage)
 		}
+
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case newConfigurable := <-a.updateConfigChan:
+			ticker.Stop()
+			a.configurable = newConfigurable
+			ticker = time.NewTicker(a.configurable.freq)
+			// Check if there is new version of cloudflared after receiving new AutoUpdaterConfigurable
+		case <-ticker.C:
+		}
 	}
 }

+// Update is the method to pass new AutoUpdaterConfigurable to a running AutoUpdater. It is safe to be called concurrently
+func (a *AutoUpdater) Update(updateDisabled bool, newFreq time.Duration) {
+	a.updateConfigChan <- createUpdateConfig(updateDisabled, newFreq, a.log)
+}
+
 func isAutoupdateEnabled(log *zerolog.Logger, updateDisabled bool, updateFreq time.Duration) bool {
 	if !supportAutoUpdate(log) {
 		return false
@@ -299,5 +304,16 @@ func wasInstalledFromPackageManager() bool {
 }

 func isRunningFromTerminal() bool {
-	return term.IsTerminal(int(os.Stdout.Fd())) // nolint:gosec
+	return term.IsTerminal(int(os.Stdout.Fd()))
+}
+
+func IsSysV() bool {
+	if runtime.GOOS != "linux" {
+		return false
+	}
+
+	if _, err := os.Stat("/run/systemd/system"); err == nil {
+		return false
+	}
+	return true
 }
@@ -9,14 +9,8 @@ import (
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/urfave/cli/v2"
-
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 )

-func init() {
-	Init(cliutil.GetBuildInfo("TEST", "TEST"))
-}
-
 func TestDisabledAutoUpdater(t *testing.T) {
 	listeners := &gracenet.Net{}
 	log := zerolog.Nop()
@@ -3,7 +3,6 @@ package updater
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"runtime"
 )
@@ -80,10 +79,6 @@ func (s *WorkersService) Check() (CheckResult, error) {
 	}
 	defer resp.Body.Close()

-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("unable to check for update: %d", resp.StatusCode)
-	}
-
 	var v VersionResponse
 	if err := json.NewDecoder(resp.Body).Decode(&v); err != nil {
 		return nil, err
@@ -3,6 +3,7 @@ package updater
 import (
 	"archive/tar"
 	"compress/gzip"
+	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io"
@@ -10,15 +11,11 @@ import (
 	"net/url"
 	"os"
 	"os/exec"
-	"path"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"text/template"
 	"time"
-
-	"github.com/getsentry/sentry-go"
-
-	"github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil"
 )

 const (
@@ -30,9 +27,9 @@ const (
 	// start the service
 	// exit with code 0 if we've reached this point indicating success.
 	windowsUpdateCommandTemplate = `sc stop cloudflared >nul 2>&1
-del "{{.OldPath}}"
 rename "{{.TargetPath}}" {{.OldName}}
 rename "{{.NewPath}}" {{.BinaryName}}
+del "{{.OldPath}}"
 sc start cloudflared >nul 2>&1
 exit /b 0`
 	batchFileName = "cfd_update.bat"
@@ -89,25 +86,8 @@ func (v *WorkersVersion) Apply() error {
 		return err
 	}

-	downloadSum, err := cliutil.FileChecksum(newFilePath)
-	if err != nil {
-		return err
-	}
-
-	// Check that the file downloaded matches what is expected.
-	if v.checksum != downloadSum {
-		return errors.New("checksum validation failed")
-	}
-
-	// Check if the currently running version has the same checksum
-	if downloadSum == buildInfo.Checksum {
-		// Currently running binary matches the downloaded binary so we have no reason to update. This is
-		// typically unexpected, as such we emit a sentry event.
-		localHub := sentry.CurrentHub().Clone()
-		err := errors.New("checksum validation matches currently running process")
-		localHub.CaptureException(err)
-		// Make sure to cleanup the new downloaded file since we aren't upgrading versions.
-		os.Remove(newFilePath)
+	// check that the file is what is expected
+	if err := isValidChecksum(v.checksum, newFilePath); err != nil {
 		return err
 	}

@@ -134,7 +114,7 @@ func (v *WorkersVersion) Apply() error {

 	if err := os.Rename(newFilePath, v.targetPath); err != nil {
 		//attempt rollback
-		_ = os.Rename(oldFilePath, v.targetPath)
+		os.Rename(oldFilePath, v.targetPath)
 		return err
 	}
 	os.Remove(oldFilePath)
@@ -181,7 +161,7 @@ func download(url, filepath string, isCompressed bool) error {
 		tr := tar.NewReader(gr)

 		// advance the reader pass the header, which will be the single binary file
-		_, _ = tr.Next()
+		tr.Next()

 		r = tr
 	}
@@ -198,7 +178,7 @@ func download(url, filepath string, isCompressed bool) error {

 // isCompressedFile is a really simple file extension check to see if this is a macos tar and gzipped
 func isCompressedFile(urlstring string) bool {
-	if path.Ext(urlstring) == ".tgz" {
+	if strings.HasSuffix(urlstring, ".tgz") {
 		return true
 	}

@@ -206,7 +186,28 @@ func isCompressedFile(urlstring string) bool {
 	if err != nil {
 		return false
 	}
-	return path.Ext(u.Path) == ".tgz"
+	return strings.HasSuffix(u.Path, ".tgz")
+}
+
+// checks if the checksum in the json response matches the checksum of the file download
+func isValidChecksum(checksum, filePath string) error {
+	f, err := os.Open(filePath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return err
+	}
+
+	hash := fmt.Sprintf("%x", h.Sum(nil))
+
+	if checksum != hash {
+		return errors.New("checksum validation failed")
+	}
+	return nil
 }

 // writeBatchFile writes a batch file out to disk
@@ -249,6 +250,7 @@ func runWindowsBatch(batchFile string) error {
 		if exitError, ok := err.(*exec.ExitError); ok {
 			return fmt.Errorf("Error during update : %s;", string(exitError.Stderr))
 		}
+
 	}
 	return err
 }
@@ -8,7 +8,6 @@ package main
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 	"syscall"
 	"time"
 	"unsafe"
@@ -27,13 +26,7 @@ import (
 const (
 	windowsServiceName        = "Cloudflared"
 	windowsServiceDescription = "Cloudflared agent"
-	windowsServiceUrl         = "https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/configure-tunnels/local-management/as-a-service/windows/"
-
-	// Env var that points to a directory for storing application-specific
-	// configuration and data (analogous to /etc/). Normally this points to
-	// C:\ProgramData.
-	programDataEnvVar = "PROGRAMDATA"
-	configDirName     = "cloudflared"
+	windowsServiceUrl         = "https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/run-tunnel/as-a-service/windows/"

 	recoverActionDelay      = time.Second * 20
 	failureCountResetPeriod = time.Hour * 24
@@ -55,18 +48,8 @@ func runApp(app *cli.App, graceShutdownC chan struct{}) {
 		Usage: "Manages the cloudflared Windows service",
 		Subcommands: []*cli.Command{
 			{
-				Name:      "install",
-				Usage:     "Install cloudflared as a Windows service",
-				ArgsUsage: "[TOKEN]",
-				Description: `
-Installs cloudflared as a Windows service
-
-A token may optionally be provided. If a token is provided, it will be written
-to disk in the service configuration directory and the cloudflared service
-configured to use it via the --token-file argument.
-
-If no token is provided, cloudflared will run without the --token-file argument,
-causing it to look for credentials in a configuration file upon startup.`,
+				Name:   "install",
+				Usage:  "Install cloudflared as a Windows service",
 				Action: cliutil.ConfiguredAction(installWindowsService),
 			},
 			{
@@ -113,105 +96,6 @@ causing it to look for credentials in a configuration file upon startup.`,
 	}
 }

-// Creates the token file at the given path, restricting its permissions by
-// modifying its Windows ACLs. We change the ACLs on the token file such that
-// the Administrators group and SYSTEM account (which is what cloudflared runs
-// as) have full access and all others are denied, with the Administrator group
-// owning the file.
-func createTokenFile(path string) error {
-	// This is a Windows Security Descriptor string describing the permissions
-	// we apply to the token file. This is the domain-specific language Windows
-	// uses for representing access rights.
-	//
-	// - O:BA         -> Set the owner to the builtin administrators group (BA)
-	// - D:           -> Start of discretionary access control list describing access rights
-	// - P            -> Set the SE_DACL_PROTECTED flag, which prevents the file from
-	//                   inheriting the (usually permissive) ACEs from its parent directory
-	// - (A;;FA;;;BA) -> ACE #1: Allow (A) Full access (FA) to the Builtin Administrators group (BA)
-	// - (A;;FA;;;SY) -> ACE #2: Ditto but for the Local System user (SY)
-	//
-	// Relevant Docs:
-	//
-	// - SecurityDescriptor string as a whole:
-	//     https://learn.microsoft.com/en-us/windows/win32/secauthz/security-descriptor-string-format
-	// - SID Strings such as BA/SY
-	//     https://learn.microsoft.com/en-us/windows/win32/secauthz/sid-strings
-	// - ACE Strings such as (A;;FA;;BA)
-	//     https://learn.microsoft.com/en-us/windows/win32/secauthz/ace-strings
-	const sdString = "O:BAD:P(A;;FA;;;BA)(A;;FA;;;SY)"
-	sd, err := windows.SecurityDescriptorFromString(sdString)
-	if err != nil {
-		return fmt.Errorf("create token security descriptor: %w", err)
-	}
-
-	pathRaw, err := windows.UTF16PtrFromString(path)
-	if err != nil {
-		return fmt.Errorf("convert path to UTF-16: %w", err)
-	}
-
-	f, err := windows.CreateFile(
-		pathRaw,
-		windows.GENERIC_WRITE,
-		0,
-		&windows.SecurityAttributes{
-			Length:             uint32(unsafe.Sizeof(windows.SecurityAttributes{})),
-			SecurityDescriptor: sd,
-			InheritHandle:      0,
-		},
-		windows.CREATE_ALWAYS, // Will truncate the file if it exists
-		windows.FILE_ATTRIBUTE_NORMAL,
-		0,
-	)
-
-	if err != nil {
-		return fmt.Errorf("create token file: %w", err)
-	}
-
-	if err := windows.CloseHandle(f); err != nil {
-		return fmt.Errorf("close token file: %w", err)
-	}
-
-	// As with os.CreateFile / os.OpenFile on Unix, if the file already exists
-	// windows.CreateFile will not update the permission information, so we do
-	// that explicitly after creating the file.
-
-	owner, _, err := sd.Owner()
-	if err != nil {
-		return fmt.Errorf("get token file owner: %w", err)
-	}
-
-	dacl, _, err := sd.DACL()
-	if err != nil {
-		return fmt.Errorf("get token file DACL: %w", err)
-	}
-
-	// Bitmask indicating which security info we want to set on the file:
-	//
-	// OWNER_SECURITY_INFORMATION
-	//	-> Set file owner
-	// DACL_SECURITY_INFORMATION
-	// 	-> Set ACEs
-	// PROTECTED_DACL_SECURITY_INFORMATION
-	//  -> Update DACL to be "protected' such that it cannot inherit entries from its parent
-	const securityInfo = windows.OWNER_SECURITY_INFORMATION |
-		windows.DACL_SECURITY_INFORMATION |
-		windows.PROTECTED_DACL_SECURITY_INFORMATION
-
-	if err := windows.SetNamedSecurityInfo(
-		path,
-		windows.SE_FILE_OBJECT,
-		securityInfo,
-		owner,
-		nil,
-		dacl,
-		nil,
-	); err != nil {
-		return fmt.Errorf("set token file security info: %w", err)
-	}
-
-	return nil
-}
-
 type windowsService struct {
 	app            *cli.App
 	graceShutdownC chan struct{}
@@ -289,15 +173,6 @@ func (s *windowsService) Execute(serviceArgs []string, r <-chan svc.ChangeReques
 	}
 }

-func getConfigDir() (string, error) {
-	progDat, progDatSet := os.LookupEnv(programDataEnvVar)
-	if !progDatSet {
-		return "", fmt.Errorf("could not find program data directory, %s env var must be set", programDataEnvVar)
-	}
-
-	return filepath.Join(progDat, configDirName), nil
-}
-
 func installWindowsService(c *cli.Context) error {
 	zeroLogger := logger.CreateLoggerFromContext(c, logger.EnableTerminalLog)

@@ -315,37 +190,13 @@ func installWindowsService(c *cli.Context) error {
 	log := zeroLogger.With().Str(LogFieldWindowsServiceName, windowsServiceName).Logger()
 	if err == nil {
 		s.Close()
-		return errors.New(serviceAlreadyExistsWarn(windowsServiceName))
+		return fmt.Errorf(serviceAlreadyExistsWarn(windowsServiceName))
 	}
-	var extraArgs []string
-	if c.NArg() > 0 {
-		// The service has been installed using a token e.g.,
-		// $ cloudflared service install <token>
-		//
-		// Write the token file to a config directory so we can start the
-		// service with --token-file.
-
-		// Don't use :=, if we did so we would create a new err variable and
-		// shadow the outer one, causing the defer below to not have access to
-		// the outer err
-		var configDir string
-		configDir, err = getConfigDir()
-		if err != nil {
-			return fmt.Errorf("locate config dir: %w", err)
-		}
-
-		// Remove token file if service install fails any point onwards from here
-		defer func() {
-			if err != nil {
-				removeTokenFile(configDir, zeroLogger)
-			}
-		}()
-
-		if err = writeTokenToConfigDir(c, configDir); err != nil {
-			return fmt.Errorf("write token to configuration directory at %s: %w", configDir, err)
-		}
-
-		extraArgs = buildArgsForTokenFile(configDir)
+	extraArgs, err := getServiceExtraArgsFromCliArgs(c, &log)
+	if err != nil {
+		errMsg := "Unable to determine extra arguments for windows service"
+		log.Err(err).Msg(errMsg)
+		return errors.Wrap(err, errMsg)
 	}

 	config := mgr.Config{StartType: mgr.StartAutomatic, DisplayName: windowsServiceDescription}
@@ -368,13 +219,10 @@ func installWindowsService(c *cli.Context) error {
 	}

 	err = s.Start()
-	if err != nil {
-		s.Delete()
-		return errors.Wrap(err, "Cannot start service")
+	if err == nil {
+		log.Info().Msg("Agent service for cloudflared installed successfully")
 	}
-
-	log.Info().Msg("Agent service for cloudflared installed successfully")
-	return nil
+	return err
 }

 func uninstallWindowsService(c *cli.Context) error {
@@ -390,7 +238,7 @@ func uninstallWindowsService(c *cli.Context) error {
 	defer m.Disconnect()
 	s, err := m.OpenService(windowsServiceName)
 	if err != nil {
-		return fmt.Errorf("agent service %s is not installed, so it could not be uninstalled", windowsServiceName)
+		return fmt.Errorf("Agent service %s is not installed, so it could not be uninstalled", windowsServiceName)
 	}
 	defer s.Close()

@@ -410,15 +258,6 @@ func uninstallWindowsService(c *cli.Context) error {
 	if err != nil {
 		return errors.Wrap(err, "Cannot remove event logger")
 	}
-
-	configDir, err := getConfigDir()
-	if err != nil {
-		// We don't need to hard-error out here, this isn't critical, but we should log it
-		log.Warn().Err(err).Msgf("Failed to find configuration directory, not removing secret token file")
-	} else {
-		removeTokenFile(configDir, &log)
-	}
-
 	return nil
 }

@@ -1,9 +1,9 @@
 # Requirements
-1. Python 3.10 or later with packages in the given `requirements.txt`
-   - E.g. with venv:
-   - `python3 -m venv ./.venv`  
-   - `source ./.venv/bin/activate`
-   - `python3 -m pip install -r requirements.txt`
+1. Python 3.7 or later with packages in the given `requirements.txt`
+   - E.g. with conda:
+   - `conda create -n component-tests python=3.7`  
+   - `conda activate component-tests`
+   - `pip3 install -r requirements.txt`

 2. Create a config yaml file, for example:
 ```
--- a/Show More
+++ b/Show More