ci: add workflow to warn PRs modifying frozen bash scripts

The bash implementations of kubectx/kubens are frozen and no longer accepting improvements. This workflow comments on PRs that modify these files to redirect contributors to the Go implementation. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-10 16:02:14 +00:00 · 2026-03-08 16:47:53 -07:00
45 changed files with 502 additions and 437 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,7 +25,7 @@ jobs:
    - name: Setup Go
      uses: actions/setup-go@v6
      with:
-        go-version: '1.25'
+        go-version: '1.22'
    - id: go-cache-paths
      run: |
        echo "::set-output name=go-build::$(go env GOCACHE)"
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -24,12 +24,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@master
    - run: git fetch --tags
    - name: Setup Go
      uses: actions/setup-go@v6
      with:
-        go-version: '1.25'
+        go-version: '1.22'
    - name: Install Snapcraft
      uses: samuelmeuli/action-snapcraft@v3
    - name: Setup Snapcraft
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -15,7 +15,7 @@
 # limitations under the License.

 # This is an example goreleaser.yaml file with some sane defaults.
-# Make sure to check the documentation at https://goreleaser.com
+# Make sure to check the documentation at http://goreleaser.com

 version: 2
 before:
@@ -69,11 +69,11 @@ archives:
      {{- else -}}v{{- . -}}
      {{- end -}}
    {{- end -}}
-  ids:
+  builds:
    - kubectx
  format_overrides:
    - goos: windows
-      formats: [zip]
+      format: zip
  files: ["LICENSE"]
 - id: kubens-archive
  name_template: |-
@@ -89,11 +89,11 @@ archives:
      {{- else -}}v{{- . -}}
      {{- end -}}
    {{- end -}}
-  ids:
+  builds:
    - kubens
  format_overrides:
    - goos: windows
-      formats: [zip]
+      format: zip
  files: ["LICENSE"]
 checksum:
  name_template: "checksums.txt"
@@ -111,7 +111,7 @@ snapcrafts:
      kubens is a tool to switch between Kubernetes namespaces (and configure them for kubectl) easily.
    grade: stable
    confinement: classic
-    base: core24
+    base: core20
    apps:
      kubectx:
        command: kubectx
--- a/README.md
+++ b/README.md
@@ -72,23 +72,139 @@ names anymore.

 ## Installation

-| Package manager | Command |
-|---|---|
-| [Homebrew](https://brew.sh/) (macOS & Linux) | `brew install kubectx` |
-| [MacPorts](https://www.macports.org) (macOS) | `sudo port install kubectx` |
-| apt (Debian/Ubuntu) | `sudo apt install kubectx` |
-| pacman (Arch Linux) | `sudo pacman -S kubectx` |
-| [Chocolatey](https://chocolatey.org/) (Windows) | `choco install kubens kubectx` |
-| [Scoop](https://scoop.sh/) (Windows) | `scoop bucket add main && scoop install main/kubens main/kubectx` |
-| [winget](https://learn.microsoft.com/en-us/windows/package-manager/) (Windows) | `winget install --id ahmetb.kubectx && winget install --id ahmetb.kubens` |
-| [Krew](https://github.com/kubernetes-sigs/krew/) (kubectl plugin) | `kubectl krew install ctx && kubectl krew install ns` |
+Stable versions of `kubectx` and `kubens` are small bash scripts that you
+can find in this repository.

-Alternatively, download binaries from the [**Releases page &rarr;**](https://github.com/ahmetb/kubectx/releases) and add them to somewhere in your `PATH`.
+Starting with v0.9.0, `kubectx` and `kubens` **are now rewritten in Go**.  They
+should work the same way (and we'll keep the bash-based implementations around)
+but the new features will be added to the new Go programs.  Please help us test
+this new Go implementation by downloading the binaries from the [**Releases page
+&rarr;**](https://github.com/ahmetb/kubectx/releases)

-<details>
-<summary>Shell completion scripts</summary>
+**Installation options:**

-#### zsh (with [antibody](https://getantibody.github.io))
+- [as kubectl plugins (macOS & Linux)](#kubectl-plugins-macos-and-linux)
+- [with Homebrew (macOS & Linux)](#homebrew-macos-and-linux)
+- [with MacPorts (macOS)](#macports-macos)
+- [with apt (Debian)](#apt-debian)
+- [with pacman (Arch Linux)](#pacman-arch-linux)
+- [with Chocolatey (Windows)](#windows-installation-using-chocolatey)
+- [Windows Installation (using Scoop)](#windows-installation-using-scoop)
+- [with winget (Windows)](#windows-installation-using-winget)
+- [manually (macOS & Linux)](#manual-installation-macos-and-linux)
+
+If you like to add context/namespace information to your shell prompt (`$PS1`),
+you can try out [kube-ps1].
+
+[kube-ps1]: https://github.com/jonmosco/kube-ps1
+
+### Kubectl Plugins (macOS and Linux)
+
+You can install and use the [Krew](https://github.com/kubernetes-sigs/krew/) kubectl
+plugin manager to get `kubectx` and `kubens`.
+
+**Note:** This will not install the shell completion scripts. If you want them,
+*choose another installation method
+or install the scripts [manually](#manual-installation-macos-and-linux).
+
+```sh
+kubectl krew install ctx
+kubectl krew install ns
+```
+
+After installing, the tools will be available as `kubectl ctx` and `kubectl ns`.
+
+### Homebrew (macOS and Linux)
+
+If you use [Homebrew](https://brew.sh/) you can install like this:
+
+```sh
+brew install kubectx
+```
+
+This command will set up bash/zsh/fish completion scripts automatically. Make sure you [configure your shell](https://docs.brew.sh/Shell-Completion) to load completions for installed Homebrew formulas.
+
+
+### MacPorts (macOS)
+
+If you use [MacPorts](https://www.macports.org) you can install like this:
+
+```sh
+sudo port install kubectx
+```
+
+### apt (Debian)
+
+``` bash
+sudo apt install kubectx
+```
+Newer versions might be available on repos like
+[Debian Buster (testing)](https://packages.debian.org/buster/kubectx),
+[Sid (unstable)](https://packages.debian.org/sid/kubectx)
+(_if you are unfamiliar with the Debian release process and how to enable
+testing/unstable repos, check out the
+[Debian Wiki](https://wiki.debian.org/DebianReleases)_):
+
+
+### pacman (Arch Linux)
+
+Available as official Arch Linux package. Install it via:
+
+```bash
+sudo pacman -S kubectx
+```
+
+### Windows Installation (using Chocolatey)
+
+Available as packages on [Chocolatey](https://chocolatey.org/why-chocolatey)
+```pwsh
+choco install kubens kubectx
+```
+
+### Windows Installation (using Scoop)
+
+Available as packages on [Scoop](https://scoop.sh/)
+```pwsh
+scoop bucket add main
+scoop install main/kubens main/kubectx
+```
+
+### Windows Installation (using winget)
+
+Available as packages on [winget](https://learn.microsoft.com/en-us/windows/package-manager/)
+```pwsh
+winget install --id ahmetb.kubectx
+winget install --id ahmetb.kubens
+```
+
+### Manual Installation (macOS and Linux)
+
+Since `kubectx` and `kubens` are written in Bash, you should be able to install
+them to any POSIX environment that has Bash installed.
+
+- Download the `kubectx`, and `kubens` scripts.
+- Either:
+  - save them all to somewhere in your `PATH`,
+  - or save them to a directory, then create symlinks to `kubectx`/`kubens` from
+    somewhere in your `PATH`, like `/usr/local/bin`
+- Make `kubectx` and `kubens` executable (`chmod +x ...`)
+
+Example installation steps:
+
+``` bash
+sudo git clone https://github.com/ahmetb/kubectx /opt/kubectx
+sudo ln -s /opt/kubectx/kubectx /usr/local/bin/kubectx
+sudo ln -s /opt/kubectx/kubens /usr/local/bin/kubens
+```
+
+If you also want to have shell completions, pick an installation method for the
+[completion scripts](completion/) that fits your system best: [`zsh` with
+`antibody`](#completion-scripts-for-zsh-with-antibody), [plain
+`zsh`](#completion-scripts-for-plain-zsh),
+[`bash`](#completion-scripts-for-bash) or
+[`fish`](#completion-scripts-for-fish).
+
+#### Completion scripts for `zsh` with [antibody](https://getantibody.github.io)

 Add this line to your [Plugins File](https://getantibody.github.io/usage/) (e.g.
 `~/.zsh_plugins.txt`):
@@ -101,9 +217,9 @@ Depending on your setup, you might or might not need to call `compinit` or
 `autoload -U compinit && compinit` in your `~/.zshrc` after you load the Plugins
 file. If you use [oh-my-zsh](https://github.com/ohmyzsh/ohmyzsh), load the
 completions before you load `oh-my-zsh` because `oh-my-zsh` will call
-`compinit`.
+`compinit`. 

-#### zsh (plain)
+#### Completion scripts for plain `zsh`

 The completion scripts have to be in a path that belongs to `$fpath`. Either
 link or copy them to an existing folder.
@@ -128,7 +244,7 @@ depending on the `$fpath` of your zsh installation.

 In case of errors, calling `compaudit` might help.

-#### bash
+#### Completion scripts for `bash`

 ```bash
 git clone https://github.com/ahmetb/kubectx.git ~/.kubectx
@@ -143,7 +259,7 @@ export PATH=~/.kubectx:\$PATH
 EOF
 ```

-#### fish
+#### Completion scripts for `fish`

 ```fish
 mkdir -p ~/.config/fish/completions
@@ -151,12 +267,6 @@ ln -s /opt/kubectx/completion/kubectx.fish ~/.config/fish/completions/
 ln -s /opt/kubectx/completion/kubens.fish ~/.config/fish/completions/
 ```

-</details>
-
-> [!NOTE]
-> Tip: Show context/namespace in your shell prompt with [oh-my-posh](https://ohmyposh.dev/) or
-> simply with [kube-ps1](https://github.com/jonmosco/kube-ps1).
-
 -----

 ### Interactive mode
@@ -167,12 +277,12 @@ with fuzzy searching, you just need to [install

 ![kubectx interactive search with fzf](img/kubectx-interactive.gif)

-Caveats:
- If you have `fzf` installed, but want to opt out of using this feature, set the
-  environment variable `KUBECTX_IGNORE_FZF=1`.
- If you want to keep `fzf` interactive mode but need the default behavior of the
-  command, you can do it by piping the output to another command (e.g. `kubectx |
-  cat `).
+If you have `fzf` installed, but want to opt out of using this feature, set the
+environment variable `KUBECTX_IGNORE_FZF=1`.
+
+If you want to keep `fzf` interactive mode but need the default behavior of the
+command, you can do it by piping the output to another command (e.g. `kubectx |
+cat `).

 -----

@@ -196,7 +306,7 @@ Colors in the output can be disabled by setting the
 If you liked `kubectx`, you may like my
 [`kubectl-aliases`](https://github.com/ahmetb/kubectl-aliases) project, too. I
 recommend pairing kubectx and kubens with [fzf](#interactive-mode) and
-[kube-ps1](https://github.com/jonmosco/kube-ps1).
+[kube-ps1].

 #### Stargazers over time

--- a/cmd/kubectx/current.go
+++ b/cmd/kubectx/current.go
@@ -15,10 +15,11 @@
 package main

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

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 )

@@ -32,18 +33,13 @@ func (_op CurrentOp) Run(stdout, _ io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

-	v, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	v := kc.GetCurrentContext()
 	if v == "" {
 		return errors.New("current-context is not set")
 	}
-	if _, err := fmt.Fprintln(stdout, v); err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	_, err := fmt.Fprintln(stdout, v)
+	return errors.Wrap(err, "write error")
 }
--- a/cmd/kubectx/delete.go
+++ b/cmd/kubectx/delete.go
@@ -15,10 +15,10 @@
 package main

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

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 	"github.com/ahmetb/kubectx/internal/printer"
 )
@@ -37,14 +37,14 @@ func (op DeleteOp) Run(_, stderr io.Writer) error {
 		// TODO inefficiency here. we open/write/close the same file many times.
 		deletedName, wasActiveContext, err := deleteContext(ctx)
 		if err != nil {
-			return fmt.Errorf("error deleting context \"%s\": %w", deletedName, err)
+			return errors.Wrapf(err, "error deleting context \"%s\"", deletedName)
 		}
 		if wasActiveContext {
 			printer.Warning(stderr, "You deleted the current context. Use \"%s\" to select a new context.",
 				selfName())
 		}

-		_ = printer.Success(stderr, `Deleted context %s.`, printer.SuccessColor.Sprint(deletedName))
+		printer.Success(stderr, `Deleted context %s.`, printer.SuccessColor.Sprint(deletedName))
 	}
 	return nil
 }
@@ -55,13 +55,10 @@ func deleteContext(name string) (deleteName string, wasActiveContext bool, err e
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return deleteName, false, fmt.Errorf("kubeconfig error: %w", err)
+		return deleteName, false, errors.Wrap(err, "kubeconfig error")
 	}

-	cur, err := kc.GetCurrentContext()
-	if err != nil {
-		return deleteName, false, fmt.Errorf("failed to get current context: %w", err)
-	}
+	cur := kc.GetCurrentContext()
 	// resolve "." to a real name
 	if name == "." {
 		if cur == "" {
@@ -71,19 +68,12 @@ func deleteContext(name string) (deleteName string, wasActiveContext bool, err e
 		name = cur
 	}

-	exists, err := kc.ContextExists(name)
-	if err != nil {
-		return name, false, fmt.Errorf("failed to check context: %w", err)
-	}
-	if !exists {
+	if !kc.ContextExists(name) {
 		return name, false, errors.New("context does not exist")
 	}

 	if err := kc.DeleteContextEntry(name); err != nil {
-		return name, false, fmt.Errorf("failed to modify yaml doc: %w", err)
+		return name, false, errors.Wrap(err, "failed to modify yaml doc")
 	}
-	if err := kc.Save(); err != nil {
-		return name, wasActiveContext, fmt.Errorf("failed to save modified kubeconfig file: %w", err)
-	}
-	return name, wasActiveContext, nil
+	return name, wasActiveContext, errors.Wrap(kc.Save(), "failed to save modified kubeconfig file")
 }
--- a/cmd/kubectx/fzf.go
+++ b/cmd/kubectx/fzf.go
@@ -16,13 +16,14 @@ package main

 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 	"strings"

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/cmdutil"
 	"github.com/ahmetb/kubectx/internal/env"
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
@@ -43,22 +44,14 @@ func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 	}
 	// parse kubeconfig just to see if it can be loaded
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
-	defer kc.Close()
 	if err := kc.Parse(); err != nil {
 		if cmdutil.IsNotFoundErr(err) {
 			printer.Warning(stderr, "kubeconfig file not found")
 			return nil
 		}
-		return fmt.Errorf("kubeconfig error: %w", err)
-	}
-
-	ctxNames, err := kc.ContextNames()
-	if err != nil {
-		return fmt.Errorf("failed to get context names: %w", err)
-	}
-	if len(ctxNames) == 0 {
-		return errors.New("no contexts found in the kubeconfig file")
+		return errors.Wrap(err, "kubeconfig error")
 	}
+	kc.Close()

 	cmd := exec.Command("fzf", "--ansi", "--no-preview")
 	var out bytes.Buffer
@@ -70,8 +63,7 @@ func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 		fmt.Sprintf("FZF_DEFAULT_COMMAND=%s", op.SelfCmd),
 		fmt.Sprintf("%s=1", env.EnvForceColor))
 	if err := cmd.Run(); err != nil {
-		var exitErr *exec.ExitError
-		if !errors.As(err, &exitErr) {
+		if _, ok := err.(*exec.ExitError); !ok {
 			return err
 		}
 	}
@@ -81,9 +73,9 @@ func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 	}
 	name, err := switchContext(choice)
 	if err != nil {
-		return fmt.Errorf("failed to switch context: %w", err)
+		return errors.Wrap(err, "failed to switch context")
 	}
-	_ = printer.Success(stderr, "Switched to context \"%s\".", printer.SuccessColor.Sprint(name))
+	printer.Success(stderr, "Switched to context \"%s\".", printer.SuccessColor.Sprint(name))
 	return nil
 }

@@ -93,20 +85,16 @@ func (op InteractiveDeleteOp) Run(_, stderr io.Writer) error {
 	}
 	// parse kubeconfig just to see if it can be loaded
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
-	defer kc.Close()
 	if err := kc.Parse(); err != nil {
 		if cmdutil.IsNotFoundErr(err) {
 			printer.Warning(stderr, "kubeconfig file not found")
 			return nil
 		}
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}
+	kc.Close()

-	ctxNames, err := kc.ContextNames()
-	if err != nil {
-		return fmt.Errorf("failed to get context names: %w", err)
-	}
-	if len(ctxNames) == 0 {
+	if len(kc.ContextNames()) == 0 {
 		return errors.New("no contexts found in config")
 	}

@@ -120,8 +108,7 @@ func (op InteractiveDeleteOp) Run(_, stderr io.Writer) error {
 		fmt.Sprintf("FZF_DEFAULT_COMMAND=%s", op.SelfCmd),
 		fmt.Sprintf("%s=1", env.EnvForceColor))
 	if err := cmd.Run(); err != nil {
-		var exitErr *exec.ExitError
-		if !errors.As(err, &exitErr) {
+		if _, ok := err.(*exec.ExitError); !ok {
 			return err
 		}
 	}
@@ -133,7 +120,7 @@ func (op InteractiveDeleteOp) Run(_, stderr io.Writer) error {

 	name, wasActiveContext, err := deleteContext(choice)
 	if err != nil {
-		return fmt.Errorf("failed to delete context: %w", err)
+		return errors.Wrap(err, "failed to delete context")
 	}

 	if wasActiveContext {
@@ -141,7 +128,7 @@ func (op InteractiveDeleteOp) Run(_, stderr io.Writer) error {
 			selfName())
 	}

-	_ = printer.Success(stderr, `Deleted context %s.`, printer.SuccessColor.Sprint(name))
+	printer.Success(stderr, `Deleted context %s.`, printer.SuccessColor.Sprint(name))

 	return nil
 }
--- a/cmd/kubectx/help.go
+++ b/cmd/kubectx/help.go
@@ -20,6 +20,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/pkg/errors"
 )

 // HelpOp describes printing help.
@@ -48,10 +50,7 @@ func printUsage(out io.Writer) error {
 	help = strings.ReplaceAll(help, "%SPAC%", strings.Repeat(" ", len(selfName())))

 	_, err := fmt.Fprintf(out, "%s\n", help)
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }

 // selfName guesses how the user invoked the program.
--- a/cmd/kubectx/isolated_shell_guard.go
+++ b/cmd/kubectx/isolated_shell_guard.go
@@ -19,6 +19,6 @@ func checkIsolatedMode() error {
 		return fmt.Errorf("you are in a locked single-context shell, use 'exit' to leave")
 	}

-	cur, _ := kc.GetCurrentContext()
+	cur := kc.GetCurrentContext()
 	return fmt.Errorf("you are in a locked single-context shell (\"%s\"), use 'exit' to leave", cur)
 }
--- a/cmd/kubectx/list.go
+++ b/cmd/kubectx/list.go
@@ -19,6 +19,7 @@ import (
 	"io"

 	"facette.io/natsort"
+	"github.com/pkg/errors"

 	"github.com/ahmetb/kubectx/internal/cmdutil"
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
@@ -39,19 +40,13 @@ func (_ ListOp) Run(stdout, stderr io.Writer) error {
 			printer.Warning(stderr, "kubeconfig file not found")
 			return nil
 		}
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

-	ctxs, err := kc.ContextNames()
-	if err != nil {
-		return fmt.Errorf("failed to get context names: %w", err)
-	}
+	ctxs := kc.ContextNames()
 	natsort.Sort(ctxs)

-	cur, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	cur := kc.GetCurrentContext()
 	for _, c := range ctxs {
 		s := c
 		if c == cur {
--- a/cmd/kubectx/main.go
+++ b/cmd/kubectx/main.go
@@ -34,7 +34,7 @@ func main() {

 	op := parseArgs(os.Args[1:])
 	if err := op.Run(color.Output, color.Error); err != nil {
-		printer.Error(color.Error, "%s", err)
+		printer.Error(color.Error, err.Error())

 		if _, ok := os.LookupEnv(env.EnvDebug); ok {
 			// print stack trace in verbose mode
--- a/cmd/kubectx/rename.go
+++ b/cmd/kubectx/rename.go
@@ -15,10 +15,11 @@
 package main

 import (
-	"fmt"
 	"io"
 	"strings"

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 	"github.com/ahmetb/kubectx/internal/printer"
 )
@@ -32,8 +33,12 @@ type RenameOp struct {
 // parseRenameSyntax parses A=B form into [A,B] and returns
 // whether it is parsed correctly.
 func parseRenameSyntax(v string) (string, string, bool) {
-	new, old, ok := strings.Cut(v, "=")
-	if !ok || new == "" || old == "" {
+	s := strings.Split(v, "=")
+	if len(s) != 2 {
+		return "", "", false
+	}
+	new, old := s[0], s[1]
+	if new == "" || old == "" {
 		return "", "", false
 	}
 	return new, old, true
@@ -49,48 +54,37 @@ func (op RenameOp) Run(_, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

-	cur, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	cur := kc.GetCurrentContext()
 	if op.Old == "." {
 		op.Old = cur
 	}

-	oldExists, err := kc.ContextExists(op.Old)
-	if err != nil {
-		return fmt.Errorf("failed to check context: %w", err)
-	}
-	if !oldExists {
-		return fmt.Errorf("context \"%s\" not found, can't rename it", op.Old)
+	if !kc.ContextExists(op.Old) {
+		return errors.Errorf("context \"%s\" not found, can't rename it", op.Old)
 	}

-	newExists, err := kc.ContextExists(op.New)
-	if err != nil {
-		return fmt.Errorf("failed to check context: %w", err)
-	}
-	if newExists {
+	if kc.ContextExists(op.New) {
 		printer.Warning(stderr, "context \"%s\" exists, overwriting it.", op.New)
 		if err := kc.DeleteContextEntry(op.New); err != nil {
-			return fmt.Errorf("failed to delete new context to overwrite it: %w", err)
+			return errors.Wrap(err, "failed to delete new context to overwrite it")
 		}
 	}

 	if err := kc.ModifyContextName(op.Old, op.New); err != nil {
-		return fmt.Errorf("failed to change context name: %w", err)
+		return errors.Wrap(err, "failed to change context name")
 	}
 	if op.Old == cur {
 		if err := kc.ModifyCurrentContext(op.New); err != nil {
-			return fmt.Errorf("failed to set current-context to new name: %w", err)
+			return errors.Wrap(err, "failed to set current-context to new name")
 		}
 	}
 	if err := kc.Save(); err != nil {
-		return fmt.Errorf("failed to save modified kubeconfig: %w", err)
+		return errors.Wrap(err, "failed to save modified kubeconfig")
 	}
-	_ = printer.Success(stderr, "Context %s renamed to %s.",
+	printer.Success(stderr, "Context %s renamed to %s.",
 		printer.SuccessColor.Sprint(op.Old),
 		printer.SuccessColor.Sprint(op.New))
 	return nil
--- a/cmd/kubectx/shell.go
+++ b/cmd/kubectx/shell.go
@@ -8,6 +8,7 @@ import (
 	"runtime"

 	"github.com/fatih/color"
+	"github.com/pkg/errors"

 	"github.com/ahmetb/kubectx/internal/env"
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
@@ -33,37 +34,30 @@ func (op ShellOp) Run(_, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}
-	exists, err := kc.ContextExists(op.Target)
-	if err != nil {
-		return fmt.Errorf("failed to check context: %w", err)
-	}
-	if !exists {
+	if !kc.ContextExists(op.Target) {
 		return fmt.Errorf("no context exists with the name: \"%s\"", op.Target)
 	}
-	previousCtx, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	previousCtx := kc.GetCurrentContext()

 	// Extract minimal kubeconfig using kubectl
 	data, err := extractMinimalKubeconfig(kubectlPath, op.Target)
 	if err != nil {
-		return fmt.Errorf("failed to extract kubeconfig for context: %w", err)
+		return errors.Wrap(err, "failed to extract kubeconfig for context")
 	}

 	// Write to temp file
 	tmpFile, err := os.CreateTemp("", "kubectx-shell-*.yaml")
 	if err != nil {
-		return fmt.Errorf("failed to create temp kubeconfig file: %w", err)
+		return errors.Wrap(err, "failed to create temp kubeconfig file")
 	}
 	tmpPath := tmpFile.Name()
 	defer os.Remove(tmpPath)

 	if _, err := tmpFile.Write(data); err != nil {
 		tmpFile.Close()
-		return fmt.Errorf("failed to write temp kubeconfig: %w", err)
+		return errors.Wrap(err, "failed to write temp kubeconfig")
 	}
 	tmpFile.Close()

--- a/cmd/kubectx/shell_test.go
+++ b/cmd/kubectx/shell_test.go
@@ -2,6 +2,7 @@ package main

 import (
 	"bytes"
+	"os"
 	"runtime"
 	"testing"

@@ -32,7 +33,13 @@ func Test_detectShell_unix(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("SHELL", tt.shellEnv)
+			orig := os.Getenv("SHELL")
+			defer os.Setenv("SHELL", orig)
+
+			os.Setenv("SHELL", tt.shellEnv)
+			if tt.shellEnv == "" {
+				os.Unsetenv("SHELL")
+			}

 			got := detectShell()
 			if got != tt.want {
@@ -44,7 +51,9 @@ func Test_detectShell_unix(t *testing.T) {

 func Test_ShellOp_blockedWhenNested(t *testing.T) {
 	// Simulate being inside an isolated shell
-	t.Setenv(env.EnvIsolatedShell, "1")
+	orig := os.Getenv(env.EnvIsolatedShell)
+	defer os.Setenv(env.EnvIsolatedShell, orig)
+	os.Setenv(env.EnvIsolatedShell, "1")

 	op := ShellOp{Target: "some-context"}
 	var stdout, stderr bytes.Buffer
@@ -66,7 +75,10 @@ func Test_ShellOp_blockedWhenNested(t *testing.T) {
 }

 func Test_resolveKubectl_envVar(t *testing.T) {
-	t.Setenv("KUBECTL", "/custom/path/kubectl")
+	orig := os.Getenv("KUBECTL")
+	defer os.Setenv("KUBECTL", orig)
+
+	os.Setenv("KUBECTL", "/custom/path/kubectl")
 	got, err := resolveKubectl()
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -77,7 +89,9 @@ func Test_resolveKubectl_envVar(t *testing.T) {
 }

 func Test_resolveKubectl_inPath(t *testing.T) {
-	t.Setenv("KUBECTL", "")
+	orig := os.Getenv("KUBECTL")
+	defer os.Setenv("KUBECTL", orig)
+	os.Unsetenv("KUBECTL")

 	// kubectl should be findable in PATH on most dev machines
 	got, err := resolveKubectl()
@@ -90,7 +104,9 @@ func Test_resolveKubectl_inPath(t *testing.T) {
 }

 func Test_checkIsolatedMode_notSet(t *testing.T) {
-	t.Setenv(env.EnvIsolatedShell, "")
+	orig := os.Getenv(env.EnvIsolatedShell)
+	defer os.Setenv(env.EnvIsolatedShell, orig)
+	os.Unsetenv(env.EnvIsolatedShell)

 	err := checkIsolatedMode()
 	if err != nil {
@@ -99,7 +115,9 @@ func Test_checkIsolatedMode_notSet(t *testing.T) {
 }

 func Test_checkIsolatedMode_set(t *testing.T) {
-	t.Setenv(env.EnvIsolatedShell, "1")
+	orig := os.Getenv(env.EnvIsolatedShell)
+	defer os.Setenv(env.EnvIsolatedShell, orig)
+	os.Setenv(env.EnvIsolatedShell, "1")

 	err := checkIsolatedMode()
 	if err == nil {
--- a/cmd/kubectx/state.go
+++ b/cmd/kubectx/state.go
@@ -15,26 +15,27 @@
 package main

 import (
-	"errors"
-	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/cmdutil"
 )

 func kubectxPrevCtxFile() (string, error) {
-	dir := cmdutil.CacheDir()
-	if dir == "" {
+	home := cmdutil.HomeDir()
+	if home == "" {
 		return "", errors.New("HOME or USERPROFILE environment variable not set")
 	}
-	return filepath.Join(dir, "kubectx"), nil
+	return filepath.Join(home, ".kube", "kubectx"), nil
 }

 // readLastContext returns the saved previous context
 // if the state file exists, otherwise returns "".
 func readLastContext(path string) (string, error) {
-	b, err := os.ReadFile(path)
+	b, err := ioutil.ReadFile(path)
 	if os.IsNotExist(err) {
 		return "", nil
 	}
@@ -46,7 +47,7 @@ func readLastContext(path string) (string, error) {
 func writeLastContext(path, value string) error {
 	dir := filepath.Dir(path)
 	if err := os.MkdirAll(dir, 0755); err != nil {
-		return fmt.Errorf("failed to create parent directories: %w", err)
+		return errors.Wrap(err, "failed to create parent directories")
 	}
-	return os.WriteFile(path, []byte(value), 0644)
+	return ioutil.WriteFile(path, []byte(value), 0644)
 }
--- a/cmd/kubectx/state_test.go
+++ b/cmd/kubectx/state_test.go
@@ -15,9 +15,12 @@
 package main

 import (
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
 )

 func Test_readLastContext_nonExistingFile(t *testing.T) {
@@ -31,11 +34,8 @@ func Test_readLastContext_nonExistingFile(t *testing.T) {
 }

 func Test_readLastContext(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "testfile")
-	if err := os.WriteFile(path, []byte("foo"), 0644); err != nil {
-		t.Fatal(err)
-	}
+	path, cleanup := testutil.TempFile(t, "foo")
+	defer cleanup()

 	s, err := readLastContext(path)
 	if err != nil {
@@ -55,7 +55,10 @@ func Test_writeLastContext_err(t *testing.T) {
 }

 func Test_writeLastContext(t *testing.T) {
-	dir := t.TempDir()
+	dir, err := ioutil.TempDir(os.TempDir(), "state-file-test")
+	if err != nil {
+		t.Fatal(err)
+	}
 	path := filepath.Join(dir, "foo", "bar")

 	if err := writeLastContext(path, "ctx1"); err != nil {
@@ -72,8 +75,9 @@ func Test_writeLastContext(t *testing.T) {
 }

 func Test_kubectxFilePath(t *testing.T) {
-	t.Setenv("HOME", filepath.FromSlash("/foo/bar"))
-	t.Setenv("XDG_CACHE_HOME", "")
+	origHome := os.Getenv("HOME")
+	os.Setenv("HOME", filepath.FromSlash("/foo/bar"))
+	defer os.Setenv("HOME", origHome)

 	expected := filepath.Join(filepath.FromSlash("/foo/bar"), ".kube", "kubectx")
 	v, err := kubectxPrevCtxFile()
@@ -85,22 +89,13 @@ func Test_kubectxFilePath(t *testing.T) {
 	}
 }

-func Test_kubectxFilePath_xdgCacheHome(t *testing.T) {
-	t.Setenv("XDG_CACHE_HOME", filepath.FromSlash("/tmp/xdg-cache"))
-
-	expected := filepath.Join(filepath.FromSlash("/tmp/xdg-cache"), "kubectx")
-	v, err := kubectxPrevCtxFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if v != expected {
-		t.Fatalf("expected=\"%s\" got=\"%s\"", expected, v)
-	}
-}
-
 func Test_kubectxFilePath_error(t *testing.T) {
-	t.Setenv("HOME", "")
-	t.Setenv("USERPROFILE", "")
+	origHome := os.Getenv("HOME")
+	origUserprofile := os.Getenv("USERPROFILE")
+	os.Unsetenv("HOME")
+	os.Unsetenv("USERPROFILE")
+	defer os.Setenv("HOME", origHome)
+	defer os.Setenv("USERPROFILE", origUserprofile)

 	_, err := kubectxPrevCtxFile()
 	if err == nil {
--- a/cmd/kubectx/switch.go
+++ b/cmd/kubectx/switch.go
@@ -15,10 +15,10 @@
 package main

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

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 	"github.com/ahmetb/kubectx/internal/printer"
 )
@@ -40,48 +40,39 @@ func (op SwitchOp) Run(_, stderr io.Writer) error {
 		newCtx, err = switchContext(op.Target)
 	}
 	if err != nil {
-		return fmt.Errorf("failed to switch context: %w", err)
+		return errors.Wrap(err, "failed to switch context")
 	}
-	if err = printer.Success(stderr, "Switched to context \"%s\".", printer.SuccessColor.Sprint(newCtx)); err != nil {
-		return fmt.Errorf("print error: %w", err)
-	}
-	return nil
+	err = printer.Success(stderr, "Switched to context \"%s\".", printer.SuccessColor.Sprint(newCtx))
+	return errors.Wrap(err, "print error")
 }

 // switchContext switches to specified context name.
 func switchContext(name string) (string, error) {
 	prevCtxFile, err := kubectxPrevCtxFile()
 	if err != nil {
-		return "", fmt.Errorf("failed to determine state file: %w", err)
+		return "", errors.Wrap(err, "failed to determine state file")
 	}

 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return "", fmt.Errorf("kubeconfig error: %w", err)
+		return "", errors.Wrap(err, "kubeconfig error")
 	}

-	prev, err := kc.GetCurrentContext()
-	if err != nil {
-		return "", fmt.Errorf("failed to get current context: %w", err)
-	}
-	exists, err := kc.ContextExists(name)
-	if err != nil {
-		return "", fmt.Errorf("failed to check context: %w", err)
-	}
-	if !exists {
-		return "", fmt.Errorf("no context exists with the name: \"%s\"", name)
+	prev := kc.GetCurrentContext()
+	if !kc.ContextExists(name) {
+		return "", errors.Errorf("no context exists with the name: \"%s\"", name)
 	}
 	if err := kc.ModifyCurrentContext(name); err != nil {
 		return "", err
 	}
 	if err := kc.Save(); err != nil {
-		return "", fmt.Errorf("failed to save kubeconfig: %w", err)
+		return "", errors.Wrap(err, "failed to save kubeconfig")
 	}

 	if prev != name {
 		if err := writeLastContext(prevCtxFile, prev); err != nil {
-			return "", fmt.Errorf("failed to save previous context name: %w", err)
+			return "", errors.Wrap(err, "failed to save previous context name")
 		}
 	}
 	return name, nil
@@ -91,11 +82,11 @@ func switchContext(name string) (string, error) {
 func swapContext() (string, error) {
 	prevCtxFile, err := kubectxPrevCtxFile()
 	if err != nil {
-		return "", fmt.Errorf("failed to determine state file: %w", err)
+		return "", errors.Wrap(err, "failed to determine state file")
 	}
 	prev, err := readLastContext(prevCtxFile)
 	if err != nil {
-		return "", fmt.Errorf("failed to read previous context file: %w", err)
+		return "", errors.Wrap(err, "failed to read previous context file")
 	}
 	if prev == "" {
 		return "", errors.New("no previous context found")
--- a/cmd/kubectx/unset.go
+++ b/cmd/kubectx/unset.go
@@ -15,9 +15,10 @@
 package main

 import (
-	"fmt"
 	"io"

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 	"github.com/ahmetb/kubectx/internal/printer"
 )
@@ -32,19 +33,16 @@ func (_ UnsetOp) Run(_, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

 	if err := kc.UnsetCurrentContext(); err != nil {
-		return fmt.Errorf("error while modifying current-context: %w", err)
+		return errors.Wrap(err, "error while modifying current-context")
 	}
 	if err := kc.Save(); err != nil {
-		return fmt.Errorf("failed to save kubeconfig file after modification: %w", err)
+		return errors.Wrap(err, "failed to save kubeconfig file after modification")
 	}

 	err := printer.Success(stderr, "Active context unset for kubectl.")
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }
--- a/cmd/kubectx/version.go
+++ b/cmd/kubectx/version.go
@@ -3,6 +3,8 @@ package main
 import (
 	"fmt"
 	"io"
+
+	"github.com/pkg/errors"
 )

 var (
@@ -14,8 +16,5 @@ type VersionOp struct{}

 func (_ VersionOp) Run(stdout, _ io.Writer) error {
 	_, err := fmt.Fprintf(stdout, "%s\n", version)
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }
--- a/cmd/kubens/current.go
+++ b/cmd/kubens/current.go
@@ -15,10 +15,11 @@
 package main

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

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 )

@@ -28,23 +29,17 @@ func (c CurrentOp) Run(stdout, _ io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

-	ctx, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	ctx := kc.GetCurrentContext()
 	if ctx == "" {
 		return errors.New("current-context is not set")
 	}
 	ns, err := kc.NamespaceOfContext(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to read namespace of \"%s\": %w", ctx, err)
+		return errors.Wrapf(err, "failed to read namespace of \"%s\"", ctx)
 	}
 	_, err = fmt.Fprintln(stdout, ns)
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }
--- a/cmd/kubens/fzf.go
+++ b/cmd/kubens/fzf.go
@@ -16,13 +16,14 @@ package main

 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 	"strings"

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/cmdutil"
 	"github.com/ahmetb/kubectx/internal/env"
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
@@ -37,22 +38,14 @@ type InteractiveSwitchOp struct {
 func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 	// parse kubeconfig just to see if it can be loaded
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
-	defer kc.Close()
 	if err := kc.Parse(); err != nil {
 		if cmdutil.IsNotFoundErr(err) {
 			printer.Warning(stderr, "kubeconfig file not found")
 			return nil
 		}
-		return fmt.Errorf("kubeconfig error: %w", err)
-	}
-
-	ctxNames, err := kc.ContextNames()
-	if err != nil {
-		return fmt.Errorf("failed to get context names: %w", err)
-	}
-	if len(ctxNames) == 0 {
-		return errors.New("no contexts found in the kubeconfig file")
+		return errors.Wrap(err, "kubeconfig error")
 	}
+	defer kc.Close()

 	cmd := exec.Command("fzf", "--ansi", "--no-preview")
 	var out bytes.Buffer
@@ -64,8 +57,7 @@ func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 		fmt.Sprintf("FZF_DEFAULT_COMMAND=%s", op.SelfCmd),
 		fmt.Sprintf("%s=1", env.EnvForceColor))
 	if err := cmd.Run(); err != nil {
-		var exitErr *exec.ExitError
-		if !errors.As(err, &exitErr) {
+		if _, ok := err.(*exec.ExitError); !ok {
 			return err
 		}
 	}
@@ -75,8 +67,8 @@ func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
 	}
 	name, err := switchNamespace(kc, choice, false)
 	if err != nil {
-		return fmt.Errorf("failed to switch namespace: %w", err)
+		return errors.Wrap(err, "failed to switch namespace")
 	}
-	_ = printer.Success(stderr, "Active namespace is \"%s\".", printer.SuccessColor.Sprint(name))
+	printer.Success(stderr, "Active namespace is \"%s\".", printer.SuccessColor.Sprint(name))
 	return nil
 }
--- a/cmd/kubens/help.go
+++ b/cmd/kubens/help.go
@@ -20,6 +20,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/pkg/errors"
 )

 // HelpOp describes printing help.
@@ -44,10 +46,7 @@ func printUsage(out io.Writer) error {
 	help = strings.ReplaceAll(help, "%PROG%", selfName())

 	_, err := fmt.Fprintf(out, "%s\n", help)
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }

 // selfName guesses how the user invoked the program.
--- a/cmd/kubens/list.go
+++ b/cmd/kubens/list.go
@@ -16,12 +16,11 @@ package main

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

+	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	_ "k8s.io/client-go/plugin/pkg/client/auth"
@@ -37,24 +36,21 @@ func (op ListOp) Run(stdout, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

-	ctx, err := kc.GetCurrentContext()
-	if err != nil {
-		return fmt.Errorf("failed to get current context: %w", err)
-	}
+	ctx := kc.GetCurrentContext()
 	if ctx == "" {
 		return errors.New("current-context is not set")
 	}
 	curNs, err := kc.NamespaceOfContext(ctx)
 	if err != nil {
-		return fmt.Errorf("cannot read current namespace: %w", err)
+		return errors.Wrap(err, "cannot read current namespace")
 	}

 	ns, err := queryNamespaces(kc)
 	if err != nil {
-		return fmt.Errorf("could not list namespaces (is the cluster accessible?): %w", err)
+		return errors.Wrap(err, "could not list namespaces (is the cluster accessible?)")
 	}

 	for _, c := range ns {
@@ -74,7 +70,7 @@ func queryNamespaces(kc *kubeconfig.Kubeconfig) ([]string, error) {

 	clientset, err := newKubernetesClientSet(kc)
 	if err != nil {
-		return nil, fmt.Errorf("failed to initialize k8s REST client: %w", err)
+		return nil, errors.Wrap(err, "failed to initialize k8s REST client")
 	}

 	var out []string
@@ -87,10 +83,9 @@ func queryNamespaces(kc *kubeconfig.Kubeconfig) ([]string, error) {
 				Continue: next,
 			})
 		if err != nil {
-			return nil, fmt.Errorf("failed to list namespaces from k8s API: %w", err)
+			return nil, errors.Wrap(err, "failed to list namespaces from k8s API")
 		}
 		next = list.Continue
-		out = slices.Grow(out, len(list.Items))
 		for _, it := range list.Items {
 			out = append(out, it.Name)
 		}
@@ -104,11 +99,11 @@ func queryNamespaces(kc *kubeconfig.Kubeconfig) ([]string, error) {
 func newKubernetesClientSet(kc *kubeconfig.Kubeconfig) (*kubernetes.Clientset, error) {
 	b, err := kc.Bytes()
 	if err != nil {
-		return nil, fmt.Errorf("failed to convert in-memory kubeconfig to yaml: %w", err)
+		return nil, errors.Wrap(err, "failed to convert in-memory kubeconfig to yaml")
 	}
 	cfg, err := clientcmd.RESTConfigFromKubeConfig(b)
 	if err != nil {
-		return nil, fmt.Errorf("failed to initialize config: %w", err)
+		return nil, errors.Wrap(err, "failed to initialize config")
 	}
 	return kubernetes.NewForConfig(cfg)
 }
--- a/cmd/kubens/main.go
+++ b/cmd/kubens/main.go
@@ -33,7 +33,7 @@ func main() {
 	cmdutil.PrintDeprecatedEnvWarnings(color.Error, os.Environ())
 	op := parseArgs(os.Args[1:])
 	if err := op.Run(color.Output, color.Error); err != nil {
-		printer.Error(color.Error, "%s", err)
+		printer.Error(color.Error, err.Error())

 		if _, ok := os.LookupEnv(env.EnvDebug); ok {
 			// print stack trace in verbose mode
--- a/cmd/kubens/statefile.go
+++ b/cmd/kubens/statefile.go
@@ -16,6 +16,7 @@ package main

 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -24,7 +25,7 @@ import (
 	"github.com/ahmetb/kubectx/internal/cmdutil"
 )

-var defaultDir = filepath.Join(cmdutil.CacheDir(), "kubens")
+var defaultDir = filepath.Join(cmdutil.HomeDir(), ".kube", "kubens")

 type NSFile struct {
 	dir string
@@ -44,7 +45,7 @@ func (f NSFile) path() string {

 // Load reads the previous namespace setting, or returns empty if not exists.
 func (f NSFile) Load() (string, error) {
-	b, err := os.ReadFile(f.path())
+	b, err := ioutil.ReadFile(f.path())
 	if err != nil {
 		if os.IsNotExist(err) {
 			return "", nil
@@ -60,7 +61,7 @@ func (f NSFile) Save(value string) error {
 	if err := os.MkdirAll(d, 0755); err != nil {
 		return err
 	}
-	return os.WriteFile(f.path(), []byte(value), 0644)
+	return ioutil.WriteFile(f.path(), []byte(value), 0644)
 }

 // isWindows determines if the process is running on windows OS.
--- a/cmd/kubens/statefile_test.go
+++ b/cmd/kubens/statefile_test.go
@@ -15,13 +15,21 @@
 package main

 import (
+	"io/ioutil"
+	"os"
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
 )

 func TestNSFile(t *testing.T) {
-	td := t.TempDir()
+	td, err := ioutil.TempDir(os.TempDir(), "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(td)

 	f := NewNSFile("foo")
 	f.dir = td
@@ -48,7 +56,7 @@ func TestNSFile(t *testing.T) {
 }

 func TestNSFile_path_windows(t *testing.T) {
-	t.Setenv("_FORCE_GOOS", "windows")
+	defer testutil.WithEnvVar("_FORCE_GOOS", "windows")()
 	fp := NewNSFile("a:b:c").path()

 	if expected := "a__b__c"; !strings.HasSuffix(fp, expected) {
@@ -66,7 +74,7 @@ func Test_isWindows(t *testing.T) {
 		t.Fatalf("isWindows() returned true for %s", runtime.GOOS)
 	}

-	t.Setenv("_FORCE_GOOS", "windows")
+	defer testutil.WithEnvVar("_FORCE_GOOS", "windows")()
 	if !isWindows() {
 		t.Fatalf("isWindows() failed to detect windows with env override.")
 	}
--- a/cmd/kubens/switch.go
+++ b/cmd/kubens/switch.go
@@ -16,11 +16,10 @@ package main

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

+	"github.com/pkg/errors"
 	errors2 "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

@@ -37,7 +36,7 @@ func (s SwitchOp) Run(_, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

 	toNS, err := switchNamespace(kc, s.Target, s.Force)
@@ -49,27 +48,24 @@ func (s SwitchOp) Run(_, stderr io.Writer) error {
 }

 func switchNamespace(kc *kubeconfig.Kubeconfig, ns string, force bool) (string, error) {
-	ctx, err := kc.GetCurrentContext()
-	if err != nil {
-		return "", fmt.Errorf("failed to get current context: %w", err)
-	}
+	ctx := kc.GetCurrentContext()
 	if ctx == "" {
 		return "", errors.New("current-context is not set")
 	}
 	curNS, err := kc.NamespaceOfContext(ctx)
 	if err != nil {
-		return "", fmt.Errorf("failed to get current namespace: %w", err)
+		return "", errors.Wrap(err, "failed to get current namespace")
 	}

 	f := NewNSFile(ctx)
 	prev, err := f.Load()
 	if err != nil {
-		return "", fmt.Errorf("failed to load previous namespace from file: %w", err)
+		return "", errors.Wrap(err, "failed to load previous namespace from file")
 	}

 	if ns == "-" {
 		if prev == "" {
-			return "", fmt.Errorf("No previous namespace found for current context (%s)", ctx)
+			return "", errors.Errorf("No previous namespace found for current context (%s)", ctx)
 		}
 		ns = prev
 	}
@@ -77,22 +73,22 @@ func switchNamespace(kc *kubeconfig.Kubeconfig, ns string, force bool) (string,
 	if !force {
 		ok, err := namespaceExists(kc, ns)
 		if err != nil {
-			return "", fmt.Errorf("failed to query if namespace exists (is cluster accessible?): %w", err)
+			return "", errors.Wrap(err, "failed to query if namespace exists (is cluster accessible?)")
 		}
 		if !ok {
-			return "", fmt.Errorf("no namespace exists with name \"%s\"", ns)
+			return "", errors.Errorf("no namespace exists with name \"%s\"", ns)
 		}
 	}

 	if err := kc.SetNamespace(ctx, ns); err != nil {
-		return "", fmt.Errorf("failed to change to namespace \"%s\": %w", ns, err)
+		return "", errors.Wrapf(err, "failed to change to namespace \"%s\"", ns)
 	}
 	if err := kc.Save(); err != nil {
-		return "", fmt.Errorf("failed to save kubeconfig file: %w", err)
+		return "", errors.Wrap(err, "failed to save kubeconfig file")
 	}
 	if curNS != ns {
 		if err := f.Save(curNS); err != nil {
-			return "", fmt.Errorf("failed to save the previous namespace to file: %w", err)
+			return "", errors.Wrap(err, "failed to save the previous namespace to file")
 		}
 	}
 	return ns, nil
@@ -106,15 +102,13 @@ func namespaceExists(kc *kubeconfig.Kubeconfig, ns string) (bool, error) {

 	clientset, err := newKubernetesClientSet(kc)
 	if err != nil {
-		return false, fmt.Errorf("failed to initialize k8s REST client: %w", err)
+		return false, errors.Wrap(err, "failed to initialize k8s REST client")
 	}

 	namespace, err := clientset.CoreV1().Namespaces().Get(context.Background(), ns, metav1.GetOptions{})
 	if errors2.IsNotFound(err) {
 		return false, nil
 	}
-	if err != nil {
-		return false, fmt.Errorf("failed to query namespace %q from k8s API: %w", ns, err)
-	}
-	return namespace != nil, nil
+	return namespace != nil, errors.Wrapf(err, "failed to query "+
+		"namespace %q from k8s API", ns)
 }
--- a/cmd/kubens/unset.go
+++ b/cmd/kubens/unset.go
@@ -15,10 +15,10 @@
 package main

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

+	"github.com/pkg/errors"
+
 	"github.com/ahmetb/kubectx/internal/kubeconfig"
 	"github.com/ahmetb/kubectx/internal/printer"
 )
@@ -30,7 +30,7 @@ func (_ UnsetOp) Run(_, stderr io.Writer) error {
 	kc := new(kubeconfig.Kubeconfig).WithLoader(kubeconfig.DefaultLoader)
 	defer kc.Close()
 	if err := kc.Parse(); err != nil {
-		return fmt.Errorf("kubeconfig error: %w", err)
+		return errors.Wrap(err, "kubeconfig error")
 	}

 	ns, err := clearNamespace(kc)
@@ -42,20 +42,17 @@ func (_ UnsetOp) Run(_, stderr io.Writer) error {
 }

 func clearNamespace(kc *kubeconfig.Kubeconfig) (string, error) {
-	ctx, err := kc.GetCurrentContext()
-	if err != nil {
-		return "", fmt.Errorf("failed to get current context: %w", err)
-	}
+	ctx := kc.GetCurrentContext()
 	ns := "default"
 	if ctx == "" {
 		return "", errors.New("current-context is not set")
 	}

 	if err := kc.SetNamespace(ctx, ns); err != nil {
-		return "", fmt.Errorf("failed to clear namespace: %w", err)
+		return "", errors.Wrapf(err, "failed to clear namespace")
 	}
 	if err := kc.Save(); err != nil {
-		return "", fmt.Errorf("failed to save kubeconfig file: %w", err)
+		return "", errors.Wrap(err, "failed to save kubeconfig file")
 	}
 	return ns, nil
 }
--- a/cmd/kubens/version.go
+++ b/cmd/kubens/version.go
@@ -3,6 +3,8 @@ package main
 import (
 	"fmt"
 	"io"
+
+	"github.com/pkg/errors"
 )

 var (
@@ -14,8 +16,5 @@ type VersionOp struct{}

 func (_ VersionOp) Run(stdout, _ io.Writer) error {
 	_, err := fmt.Fprintf(stdout, "%s\n", version)
-	if err != nil {
-		return fmt.Errorf("write error: %w", err)
-	}
-	return nil
+	return errors.Wrap(err, "write error")
 }
--- a/go.mod
+++ b/go.mod
@@ -7,6 +7,7 @@ require (
 	github.com/fatih/color v1.18.0
 	github.com/google/go-cmp v0.7.0
 	github.com/mattn/go-isatty v0.0.20
+	github.com/pkg/errors v0.9.1
 	k8s.io/apimachinery v0.35.2
 	k8s.io/client-go v0.35.2
 	sigs.k8s.io/kustomize/kyaml v0.21.1
--- a/go.sum
+++ b/go.sum
@@ -65,6 +65,8 @@ github.com/onsi/ginkgo/v2 v2.27.2 h1:LzwLj0b89qtIy6SSASkzlNvX6WktqurSHwkk2ipF/Ns
 github.com/onsi/ginkgo/v2 v2.27.2/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
 github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
 github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
--- a/internal/cmdutil/util.go
+++ b/internal/cmdutil/util.go
@@ -15,9 +15,9 @@
 package cmdutil

 import (
-	"errors"
 	"os"
-	"path/filepath"
+
+	"github.com/pkg/errors"
 )

 func HomeDir() string {
@@ -28,20 +28,8 @@ func HomeDir() string {
 	return home
 }

-// CacheDir returns XDG_CACHE_HOME if set, otherwise $HOME/.kube,
-// matching the bash scripts' behavior: ${XDG_CACHE_HOME:-$HOME/.kube}.
-func CacheDir() string {
-	if xdg := os.Getenv("XDG_CACHE_HOME"); xdg != "" {
-		return xdg
-	}
-	home := HomeDir()
-	if home == "" {
-		return ""
-	}
-	return filepath.Join(home, ".kube")
-}
-
-// IsNotFoundErr determines if the underlying error is os.IsNotExist.
+// IsNotFoundErr determines if the underlying error is os.IsNotExist. Right now
+// errors from github.com/pkg/errors doesn't work with os.IsNotExist.
 func IsNotFoundErr(err error) bool {
 	for e := err; e != nil; e = errors.Unwrap(e) {
 		if os.IsNotExist(e) {
--- a/internal/cmdutil/util_test.go
+++ b/internal/cmdutil/util_test.go
@@ -15,8 +15,9 @@
 package cmdutil

 import (
-	"path/filepath"
 	"testing"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
 )

 func Test_homeDir(t *testing.T) {
@@ -62,40 +63,18 @@ func Test_homeDir(t *testing.T) {

 	for _, c := range cases {
 		t.Run(c.name, func(tt *testing.T) {
+			var unsets []func()
 			for _, e := range c.envs {
-				tt.Setenv(e.k, e.v)
+				unsets = append(unsets, testutil.WithEnvVar(e.k, e.v))
 			}

 			got := HomeDir()
 			if got != c.want {
 				t.Errorf("expected:%q got:%q", c.want, got)
 			}
+			for _, u := range unsets {
+				u()
+			}
 		})
 	}
 }
-
-func TestCacheDir(t *testing.T) {
-	t.Run("XDG_CACHE_HOME set", func(t *testing.T) {
-		t.Setenv("XDG_CACHE_HOME", "/tmp/xdg-cache")
-		t.Setenv("HOME", "/home/user")
-		if got := CacheDir(); got != "/tmp/xdg-cache" {
-			t.Errorf("expected:%q got:%q", "/tmp/xdg-cache", got)
-		}
-	})
-	t.Run("XDG_CACHE_HOME unset, falls back to HOME/.kube", func(t *testing.T) {
-		t.Setenv("XDG_CACHE_HOME", "")
-		t.Setenv("HOME", "/home/user")
-		want := filepath.Join("/home/user", ".kube")
-		if got := CacheDir(); got != want {
-			t.Errorf("expected:%q got:%q", want, got)
-		}
-	})
-	t.Run("neither set", func(t *testing.T) {
-		t.Setenv("XDG_CACHE_HOME", "")
-		t.Setenv("HOME", "")
-		t.Setenv("USERPROFILE", "")
-		if got := CacheDir(); got != "" {
-			t.Errorf("expected:%q got:%q", "", got)
-		}
-	})
-}
--- a/internal/kubeconfig/contexts.go
+++ b/internal/kubeconfig/contexts.go
@@ -15,10 +15,7 @@
 package kubeconfig

 import (
-	"errors"
-	"fmt"
-	"slices"
-
+	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )

@@ -45,30 +42,29 @@ func (k *Kubeconfig) contextNode(name string) (*yaml.RNode, error) {
 		return nil, err
 	}
 	if context == nil {
-		return nil, fmt.Errorf("context with name \"%s\" not found", name)
+		return nil, errors.Errorf("context with name \"%s\" not found", name)
 	}
 	return context, nil
 }

-func (k *Kubeconfig) ContextNames() ([]string, error) {
+func (k *Kubeconfig) ContextNames() []string {
 	contexts, err := k.config.Pipe(yaml.Get("contexts"))
 	if err != nil {
-		return nil, fmt.Errorf("failed to get contexts: %w", err)
-	}
-	if contexts == nil {
-		return nil, nil
+		return nil
 	}
 	names, err := contexts.ElementValues("name")
 	if err != nil {
-		return nil, fmt.Errorf("failed to get context names: %w", err)
+		return nil
 	}
-	return names, nil
+	return names
 }

-func (k *Kubeconfig) ContextExists(name string) (bool, error) {
-	names, err := k.ContextNames()
-	if err != nil {
-		return false, err
+func (k *Kubeconfig) ContextExists(name string) bool {
+	ctxNames := k.ContextNames()
+	for _, v := range ctxNames {
+		if v == name {
+			return true
+		}
 	}
-	return slices.Contains(names, name), nil
+	return false
 }
--- a/internal/kubeconfig/contexts_test.go
+++ b/internal/kubeconfig/contexts_test.go
@@ -33,10 +33,7 @@ func TestKubeconfig_ContextNames(t *testing.T) {
 		t.Fatal(err)
 	}

-	ctx, err := kc.ContextNames()
-	if err != nil {
-		t.Fatal(err)
-	}
+	ctx := kc.ContextNames()
 	expected := []string{"abc", "def", "ghi"}
 	if diff := cmp.Diff(expected, ctx); diff != "" {
 		t.Fatalf("%s", diff)
@@ -49,10 +46,7 @@ func TestKubeconfig_ContextNames_noContextsEntry(t *testing.T) {
 	if err := kc.Parse(); err != nil {
 		t.Fatal(err)
 	}
-	ctx, err := kc.ContextNames()
-	if err != nil {
-		t.Fatal(err)
-	}
+	ctx := kc.ContextNames()
 	var expected []string = nil
 	if diff := cmp.Diff(expected, ctx); diff != "" {
 		t.Fatalf("%s", diff)
@@ -65,9 +59,10 @@ func TestKubeconfig_ContextNames_nonArrayContextsEntry(t *testing.T) {
 	if err := kc.Parse(); err != nil {
 		t.Fatal(err)
 	}
-	_, err := kc.ContextNames()
-	if err == nil {
-		t.Fatal("expected error for non-array contexts entry")
+	ctx := kc.ContextNames()
+	var expected []string = nil
+	if diff := cmp.Diff(expected, ctx); diff != "" {
+		t.Fatalf("%s", diff)
 	}
 }

@@ -82,15 +77,13 @@ func TestKubeconfig_CheckContextExists(t *testing.T) {
 		t.Fatal(err)
 	}

-	if exists, err := kc.ContextExists("c1"); err != nil || !exists {
+	if !kc.ContextExists("c1") {
 		t.Fatal("c1 actually exists; reported false")
 	}
-	if exists, err := kc.ContextExists("c2"); err != nil || !exists {
+	if !kc.ContextExists("c2") {
 		t.Fatal("c2 actually exists; reported false")
 	}
-	if exists, err := kc.ContextExists("c3"); err != nil {
-		t.Fatal(err)
-	} else if exists {
+	if kc.ContextExists("c3") {
 		t.Fatal("c3 does not exist; but reported true")
 	}
 }
--- a/internal/kubeconfig/currentcontext.go
+++ b/internal/kubeconfig/currentcontext.go
@@ -15,19 +15,17 @@
 package kubeconfig

 import (
-	"fmt"
-
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )

 // GetCurrentContext returns "current-context" value in given
-// kubeconfig object Node, or returns ("", nil) if not found.
-func (k *Kubeconfig) GetCurrentContext() (string, error) {
+// kubeconfig object Node, or returns "" if not found.
+func (k *Kubeconfig) GetCurrentContext() string {
 	v, err := k.config.Pipe(yaml.Get("current-context"))
 	if err != nil {
-		return "", fmt.Errorf("failed to read current-context: %w", err)
+		return ""
 	}
-	return yaml.GetValue(v), nil
+	return yaml.GetValue(v)
 }

 func (k *Kubeconfig) UnsetCurrentContext() error {
--- a/internal/kubeconfig/currentcontext_test.go
+++ b/internal/kubeconfig/currentcontext_test.go
@@ -26,10 +26,7 @@ func TestKubeconfig_GetCurrentContext(t *testing.T) {
 	if err := kc.Parse(); err != nil {
 		t.Fatal(err)
 	}
-	v, err := kc.GetCurrentContext()
-	if err != nil {
-		t.Fatal(err)
-	}
+	v := kc.GetCurrentContext()

 	expected := "foo"
 	if v != expected {
@@ -43,10 +40,7 @@ func TestKubeconfig_GetCurrentContext_missingField(t *testing.T) {
 	if err := kc.Parse(); err != nil {
 		t.Fatal(err)
 	}
-	v, err := kc.GetCurrentContext()
-	if err != nil {
-		t.Fatal(err)
-	}
+	v := kc.GetCurrentContext()

 	expected := ""
 	if v != expected {
--- a/internal/kubeconfig/kubeconfig.go
+++ b/internal/kubeconfig/kubeconfig.go
@@ -15,10 +15,9 @@
 package kubeconfig

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

+	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )

@@ -55,7 +54,7 @@ func (k *Kubeconfig) Close() error {
 func (k *Kubeconfig) Parse() error {
 	files, err := k.loader.Load()
 	if err != nil {
-		return fmt.Errorf("failed to load: %w", err)
+		return errors.Wrap(err, "failed to load")
 	}

 	// TODO since we don't support multiple kubeconfig files at the moment, there's just 1 file
@@ -64,7 +63,7 @@ func (k *Kubeconfig) Parse() error {
 	k.f = f
 	var v yaml.Node
 	if err := yaml.NewDecoder(f).Decode(&v); err != nil {
-		return fmt.Errorf("failed to decode: %w", err)
+		return errors.Wrap(err, "failed to decode")
 	}
 	k.config = yaml.NewRNode(&v)
 	if k.config.YNode().Kind != yaml.MappingNode {
@@ -83,12 +82,9 @@ func (k *Kubeconfig) Bytes() ([]byte, error) {

 func (k *Kubeconfig) Save() error {
 	if err := k.f.Reset(); err != nil {
-		return fmt.Errorf("failed to reset file: %w", err)
+		return errors.Wrap(err, "failed to reset file")
 	}
 	enc := yaml.NewEncoder(k.f)
 	enc.SetIndent(0)
-	if err := enc.Encode(k.config.YNode()); err != nil {
-		return err
-	}
-	return enc.Close()
+	return enc.Encode(k.config.YNode())
 }
--- a/internal/kubeconfig/kubeconfigloader.go
+++ b/internal/kubeconfig/kubeconfigloader.go
@@ -15,12 +15,11 @@
 package kubeconfig

 import (
-	"errors"
-	"fmt"
+	"github.com/ahmetb/kubectx/internal/cmdutil"
 	"os"
 	"path/filepath"

-	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/pkg/errors"
 )

 var (
@@ -34,15 +33,15 @@ type kubeconfigFile struct{ *os.File }
 func (*StandardKubeconfigLoader) Load() ([]ReadWriteResetCloser, error) {
 	cfgPath, err := kubeconfigPath()
 	if err != nil {
-		return nil, fmt.Errorf("cannot determine kubeconfig path: %w", err)
+		return nil, errors.Wrap(err, "cannot determine kubeconfig path")
 	}

 	f, err := os.OpenFile(cfgPath, os.O_RDWR, 0)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return nil, fmt.Errorf("kubeconfig file not found: %w", err)
+			return nil, errors.Wrap(err, "kubeconfig file not found")
 		}
-		return nil, fmt.Errorf("failed to open file: %w", err)
+		return nil, errors.Wrap(err, "failed to open file")
 	}

 	// TODO we'll return all kubeconfig files when we start implementing multiple kubeconfig support
@@ -51,12 +50,10 @@ func (*StandardKubeconfigLoader) Load() ([]ReadWriteResetCloser, error) {

 func (kf *kubeconfigFile) Reset() error {
 	if err := kf.Truncate(0); err != nil {
-		return fmt.Errorf("failed to truncate file: %w", err)
+		return errors.Wrap(err, "failed to truncate file")
 	}
-	if _, err := kf.Seek(0, 0); err != nil {
-		return fmt.Errorf("failed to seek in file: %w", err)
-	}
-	return nil
+	_, err := kf.Seek(0, 0)
+	return errors.Wrap(err, "failed to seek in file")
 }

 func kubeconfigPath() (string, error) {
--- a/internal/kubeconfig/kubeconfigloader_test.go
+++ b/internal/kubeconfig/kubeconfigloader_test.go
@@ -15,16 +15,17 @@
 package kubeconfig

 import (
+	"github.com/ahmetb/kubectx/internal/cmdutil"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"

-	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/testutil"
 )

 func Test_kubeconfigPath(t *testing.T) {
-	t.Setenv("HOME", "/x/y/z")
+	defer testutil.WithEnvVar("HOME", "/x/y/z")()

 	expected := filepath.FromSlash("/x/y/z/.kube/config")
 	got, err := kubeconfigPath()
@@ -37,9 +38,9 @@ func Test_kubeconfigPath(t *testing.T) {
 }

 func Test_kubeconfigPath_noEnvVars(t *testing.T) {
-	t.Setenv("XDG_CACHE_HOME", "")
-	t.Setenv("HOME", "")
-	t.Setenv("USERPROFILE", "")
+	defer testutil.WithEnvVar("XDG_CACHE_HOME", "")()
+	defer testutil.WithEnvVar("HOME", "")()
+	defer testutil.WithEnvVar("USERPROFILE", "")()

 	_, err := kubeconfigPath()
 	if err == nil {
@@ -48,7 +49,7 @@ func Test_kubeconfigPath_noEnvVars(t *testing.T) {
 }

 func Test_kubeconfigPath_envOvveride(t *testing.T) {
-	t.Setenv("KUBECONFIG", "foo")
+	defer testutil.WithEnvVar("KUBECONFIG", "foo")()

 	v, err := kubeconfigPath()
 	if err != nil {
@@ -61,7 +62,7 @@ func Test_kubeconfigPath_envOvveride(t *testing.T) {

 func Test_kubeconfigPath_envOvverideDoesNotSupportPathSeparator(t *testing.T) {
 	path := strings.Join([]string{"file1", "file2"}, string(os.PathListSeparator))
-	t.Setenv("KUBECONFIG", path)
+	defer testutil.WithEnvVar("KUBECONFIG", path)()

 	_, err := kubeconfigPath()
 	if err == nil {
@@ -70,7 +71,7 @@ func Test_kubeconfigPath_envOvverideDoesNotSupportPathSeparator(t *testing.T) {
 }

 func TestStandardKubeconfigLoader_returnsNotFoundErr(t *testing.T) {
-	t.Setenv("KUBECONFIG", "foo")
+	defer testutil.WithEnvVar("KUBECONFIG", "foo")()
 	kc := new(Kubeconfig).WithLoader(DefaultLoader)
 	err := kc.Parse()
 	if err == nil {
--- a/internal/printer/color_test.go
+++ b/internal/printer/color_test.go
@@ -18,6 +18,8 @@ import (
 	"testing"

 	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
 )

 var (
@@ -25,8 +27,8 @@ var (
 )

 func Test_useColors_forceColors(t *testing.T) {
-	t.Setenv("_KUBECTX_FORCE_COLOR", "1")
-	t.Setenv("NO_COLOR", "1")
+	defer testutil.WithEnvVar("_KUBECTX_FORCE_COLOR", "1")()
+	defer testutil.WithEnvVar("NO_COLOR", "1")()

 	if v := useColors(); !cmp.Equal(v, &tr) {
 		t.Fatalf("expected useColors() = true; got = %v", v)
@@ -34,7 +36,7 @@ func Test_useColors_forceColors(t *testing.T) {
 }

 func Test_useColors_disableColors(t *testing.T) {
-	t.Setenv("NO_COLOR", "1")
+	defer testutil.WithEnvVar("NO_COLOR", "1")()

 	if v := useColors(); !cmp.Equal(v, &fa) {
 		t.Fatalf("expected useColors() = false; got = %v", v)
@@ -42,8 +44,8 @@ func Test_useColors_disableColors(t *testing.T) {
 }

 func Test_useColors_default(t *testing.T) {
-	t.Setenv("NO_COLOR", "")
-	t.Setenv("_KUBECTX_FORCE_COLOR", "")
+	defer testutil.WithEnvVar("NO_COLOR", "")()
+	defer testutil.WithEnvVar("_KUBECTX_FORCE_COLOR", "")()

 	if v := useColors(); v != nil {
 		t.Fatalf("expected useColors() = nil; got=%v", *v)
--- a/internal/printer/printer.go
+++ b/internal/printer/printer.go
@@ -43,17 +43,17 @@ func init() {
 	}
 }

-func Error(w io.Writer, format string, args ...any) error {
-	_, err := io.WriteString(w, ErrorColor.Sprint("error: ")+fmt.Sprintf(format, args...)+"\n")
+func Error(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, ErrorColor.Sprint("error: ")+format+"\n", args...)
 	return err
 }

-func Warning(w io.Writer, format string, args ...any) error {
-	_, err := io.WriteString(w, WarningColor.Sprint("warning: ")+fmt.Sprintf(format, args...)+"\n")
+func Warning(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, WarningColor.Sprint("warning: ")+format+"\n", args...)
 	return err
 }

-func Success(w io.Writer, format string, args ...any) error {
-	_, err := io.WriteString(w, SuccessColor.Sprint("✔ ")+fmt.Sprintf(format, args...)+"\n")
+func Success(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, SuccessColor.Sprint("✔ ")+fmt.Sprintf(format+"\n", args...))
 	return err
 }
--- a/internal/testutil/kubeconfigbuilder.go
+++ b/internal/testutil/kubeconfigbuilder.go
@@ -31,7 +31,7 @@ type Context struct {
 func Ctx(name string) *Context           { return &Context{Name: name} }
 func (c *Context) Ns(ns string) *Context { c.Context.Namespace = ns; return c }

-type Kubeconfig map[string]any
+type Kubeconfig map[string]interface{}

 func KC() *Kubeconfig {
 	return &Kubeconfig{
@@ -39,9 +39,9 @@ func KC() *Kubeconfig {
 		"kind":       "Config"}
 }

-func (k *Kubeconfig) Set(key string, v any) *Kubeconfig   { (*k)[key] = v; return k }
-func (k *Kubeconfig) WithCurrentCtx(s string) *Kubeconfig { (*k)["current-context"] = s; return k }
-func (k *Kubeconfig) WithCtxs(c ...*Context) *Kubeconfig  { (*k)["contexts"] = c; return k }
+func (k *Kubeconfig) Set(key string, v interface{}) *Kubeconfig { (*k)[key] = v; return k }
+func (k *Kubeconfig) WithCurrentCtx(s string) *Kubeconfig       { (*k)["current-context"] = s; return k }
+func (k *Kubeconfig) WithCtxs(c ...*Context) *Kubeconfig        { (*k)["contexts"] = c; return k }

 func (k *Kubeconfig) ToYAML(t *testing.T) string {
 	t.Helper()
--- a/internal/testutil/tempfile.go
+++ b/internal/testutil/tempfile.go
@@ -0,0 +1,40 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testutil
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TempFile(t *testing.T, contents string) (path string, cleanup func()) {
+	// TODO consider removing, used only in one place.
+	t.Helper()
+
+	f, err := ioutil.TempFile(os.TempDir(), "test-file")
+	if err != nil {
+		t.Fatalf("failed to create test file: %v", err)
+	}
+	path = f.Name()
+	if _, err := f.Write([]byte(contents)); err != nil {
+		t.Fatalf("failed to write to test file: %v", err)
+	}
+
+	return path, func() {
+		f.Close()
+		os.Remove(path)
+	}
+}
--- a/internal/testutil/testutil.go
+++ b/internal/testutil/testutil.go
@@ -0,0 +1,31 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testutil
+
+import "os"
+
+// WithEnvVar sets an env var temporarily. Call its return value
+// in defer to restore original value in env (if exists).
+func WithEnvVar(key, value string) func() {
+	orig, ok := os.LookupEnv(key)
+	os.Setenv(key, value)
+	return func() {
+		if ok {
+			os.Setenv(key, orig)
+		} else {
+			os.Unsetenv(key)
+		}
+	}
+}