Skip to main content
Lumovi’s terminals are your own shell, in a dock at the bottom of a cluster’s pages. kubectl, helm and the rest are already pointed at the cluster you’re looking at, and the namespace you picked, in that terminal only. Your kubeconfig and your other terminals stay as they were. Any command Lumovi shows can be pasted into one, to read, change and run yourself.
The Deployments list, with the terminal dock open below it on a tab named production. Its first line says kubectl points at production in this terminal, and kubectl get deployments -n shop lists the shop namespace's deployments.The Deployments list, with the terminal dock open below it on a tab named production. Its first line says kubectl points at production in this terminal, and kubectl get deployments -n shop lists the shop namespace's deployments.

A terminal under the cluster's pages, with kubectl pointed at the cluster.

Desktop app only: a terminal runs a shell on your computer, so there are none when Lumovi runs in your cluster. There, open a shell in a container or on a node instead.

Open the dock

A thin bar, Tabs below, runs along the bottom of every cluster’s pages. It’s always there, and shows the terminals that are running, and any objects kept open below. To open a terminal:
  • Click Terminal at the bar’s left: Show the terminal when one is running, Open a terminal when none is.
  • Press ⌃` anywhere in a cluster (Ctrl` on Windows and Linux). Press it again to hide the dock.
  • Choose View → Terminal (on Windows and Linux, from the Menu button at the window’s top left).
  • Choose New terminal in the command palette (⌘K, or CtrlK on Windows and Linux).
When no terminal is running, the dock starts one for the cluster you’re in, and its namespace: the one you picked in the namespace menu, or else the context’s own. Otherwise it opens on the terminal you had last. The terminal has focus, so you can type right away. To start another, choose + (New terminal) in the bar, press ⌃⇧` anywhere in a cluster, or choose View → New Terminal. Click a tab in the bar to open the dock on it. The start screen has no dock: there’s no cluster to point a terminal at.

Your own shell

Each tab runs a shell on your computer, as you, starting in your home folder: To start another, choose it in Settings, under Terminal: one the computer lists (in /etc/shells, or on Windows PowerShell 7), or Another… by its full path. On Windows it must be a PowerShell. A shell that isn’t there says “The shell Settings names, path, isn’t there: choose another in Settings.” On Windows, if PowerShell hasn’t drawn anything 5 seconds after a terminal opens, the terminal says ”› PowerShell is still starting. Your profile or a virus scan can slow it down.” The line goes once PowerShell draws, and what you typed meanwhile still reaches it. See Troubleshooting for what helps. It gets the environment Lumovi started with and, on macOS and Linux, the PATH your login shell sets up, so the tools you use in other terminals are there. Lumovi sets a few variables of its own:

kubectl points at the cluster

When a terminal starts, Lumovi writes a small kubeconfig for it, and puts it first in the terminal’s KUBECONFIG, before your own files: the ones Lumovi reads, so kubectl there sees the same clusters. Those are the files chosen in Lumovi, or else the ones in KUBECONFIG when Lumovi started (as full paths, so a relative one still works), or ~/.kube/config, then any added in Lumovi. The kubeconfigs in a folder you added aren’t among them, and a terminal doesn’t open for one of their clusters: kubectl would run what their credentials run without asking you. The small kubeconfig names the context, with its cluster, user and namespace, and holds nothing else:
kubectl takes the current context, and each context, from the first file that has them. So in this terminal, it uses this cluster and namespace, and finds the cluster’s address and your credentials in your own files, as always. Nothing secret is copied.
  • This terminal only. Your other terminals, and kubectl anywhere else, keep your kubeconfig’s current context.
  • helm, k9s and other tools that read KUBECONFIG follow it too.
  • kubectl config use-context in a terminal changes that terminal only: kubectl writes it to the terminal’s own file.
  • Your credentials stay in your files. Credential plugins work as in any terminal, and a token kubectl refreshes is saved with your user, in your files.
  • The namespace is the one picked in the namespace menu when the terminal started. With All namespaces, it’s the context’s own, if your kubeconfig sets one. Picking another namespace later doesn’t change a running terminal: start a new one.
The terminal’s first line says where it points, and which kubectl it is:
Lumovi deletes the terminal’s kubeconfig when its shell ends: when the shell exits, when you close its tab, and when you quit. If Lumovi crashed or was killed before it could, it deletes what’s left the next time it starts. See Privacy and security.
If kubectl in a terminal uses another cluster, your shell’s startup files probably set KUBECONFIG, which replaces the terminal’s. Have them add to it instead, so the terminal’s own file stays first. echo $KUBECONFIG shows what the shell has ($env:KUBECONFIG in PowerShell).

A kubectl that matches the cluster

kubectl works with clusters one minor version either side of its own, so one kubectl may be too old, or too new, for some of your clusters. Each terminal gets the kubectl for the version the cluster says it runs: the newest patch of that minor version, like v1.34.9 for a cluster that says v1.34.1. None older than 1.25, Lumovi’s oldest: an older kubectl lacks years of fixes, and a cluster doesn’t get to choose one for you.
  • From Kubernetes, signed by Kubernetes. Lumovi asks dl.k8s.io for that minor version’s newest patch (release/stable-1.34.txt), then downloads it, with the checksum, the signature and the certificate published beside it. It checks the download against the checksum, and against Kubernetes’ own signature: that Kubernetes’ release signed these very bytes, with a certificate from Sigstore. That’s checked on your computer, asking no one else: see What’s checked, and what isn’t. From dl.k8s.io, a kubectl without Kubernetes’ signature, or with one that doesn’t hold, isn’t used. It goes through the proxy and certificate authorities Lumovi’s other connections use.
  • Downloaded once. Each is kept in Lumovi’s folder for app data, under kubectl/v1.34.9, for the terminals of every cluster on that minor version. As Lumovi starts, it keeps only each minor version’s newest patch, and, where that one came from a mirror without a signature, the newest signed one too, for a policy that requires signatures. It removes what a crash left half-downloaded, and any kubectl kept before Lumovi checked signatures: that one is downloaded again, and checked, the next time a terminal needs it. Beside each, Lumovi notes how it was checked, and the kubectl’s SHA-256: each time a terminal would use it, the kubectl must still match it, or it isn’t used, and the newest is downloaded again. It remembers which patch is newest for six hours.
  • Each cluster’s version, remembered. Lumovi keeps the minor version each cluster last said it runs, by its context’s name, in kubectl/clusters.json, across restarts. So a cluster that can’t be reached gets the kubectl kept for it, at once. After a cluster’s upgrade, the first terminal can still get the kubectl for its old version, and the ones after get the new.
  • First on the terminal’s PATH, even after your startup files have run, as they may put theirs first, the way macOS’s path_helper does, in zsh, bash, sh, dash, ksh and fish, and in PowerShell, after your profile. Type kubectl, and it’s this one. Other shells, like csh, tcsh or nushell, start with it first, but their own startup files can put another kubectl ahead of it.
While it downloads, the terminal says so: › Getting kubectl v1.34.9, to match the cluster…. From a mirror that keeps no signatures, only the checksum the mirror publishes is checked, and each terminal that uses that kubectl says so, after which one it is:
A mirror that keeps them has its kubectl checked against Kubernetes’ signature, as dl.k8s.io’s is. Your organization’s policy can require them from a mirror too: one it keeps none for then isn’t used.

When it can’t have one

A terminal is often opened because something’s wrong, so it doesn’t wait long. It waits 3 seconds for the cluster to say its version, the first time Lumovi asks it, and 10 seconds for the kubectl. Past that, or when Lumovi can’t get one, the terminal starts with the kubectl on your PATH, and its first line says why:
When the newest can’t be had, offline say, or because it isn’t signed, the newest kubectl of that minor version Lumovi kept does: one checked against Kubernetes’ signature, where your organization’s policy requires it. What failed isn’t tried again for 10 minutes, so the terminals you open meanwhile don’t wait for it to fail again.

Turn it off

Choose View → Match kubectl to Each Cluster, on by default, to turn it off: terminals opened from then on use the kubectl on your PATH, and say nothing of it. Your organization’s policy can turn it off for you ("kubectl": false), and the item is then off and disabled, or name a mirror of dl.k8s.io to get kubectl from, and require Kubernetes’ signature from it ("kubectlSignatures": "required"). Without a policy, LUMOVI_KUBECTL_MIRROR names one: see Environment variables. A mirror is used over https only, or on this computer. What Lumovi writes on a terminal’s first line can quote a cluster or a mirror: it leaves out control characters and the marks that reorder text, which a terminal would act on, and cuts what it quotes short, so nothing can write over its own words.

helm

The desktop app ships with helm, which its Helm actions run. Its folder is last on each terminal’s PATH, so helm runs yours where you have one, and Lumovi’s where you don’t. With LUMOVI_HELM set to a full path, that helm’s folder is.

Read-only clusters

Lumovi’s read-only switch doesn’t apply to terminals. A terminal is your own shell: what you run there can change the cluster as far as your account allows, as in any other terminal. When the cluster is read-only in Lumovi, a new terminal says so, after where kubectl points: “Lumovi’s read-only switch doesn’t apply to what you run here.” To keep a cluster from changing at all, use an account that can only read, like one with the built-in view ClusterRole. See Permissions.

Tabs

Each tab shows its cluster, and its namespace when it has one, so terminals for different clusters sit side by side. Every cluster’s pages show them all.
  • Switch by clicking a tab, or with the keys below.
  • Rename a tab by double-clicking it, pressing F2 on it, or choosing Rename… from its menu. ↵ keeps the name, and Esc leaves it as it was. An empty name goes back to the cluster’s.
  • Close a tab with its ×. That ends its shell. Closing the last one hides the dock.
Right-click a tab for its menu:

In a window of its own

In the desktop app, Move to a new window opens the terminal alone in a smaller window, over the one it came from, under a band that names it with its namespace and cluster. Its shell goes on running there, with what it showed.
  • Put back below, in the band, returns it below in the window it came from, else in the one in front on its cluster, else the one in front, its shell still running. With no other Lumovi window open, its own becomes one, with the terminal below. It’s there only while the shell runs.
  • Closing the window closes the tab, and ends its shell.
  • After a quit, the window opens again where it was, its terminal ended, as below.

They keep running

Terminals keep running while the dock is hidden, while you look at other pages and other clusters, and on the start screen. Back in a cluster, they’re as you left them. They end when you close their tab and when you quit Lumovi. They also end when Lumovi’s window loads its page again, as Reload on an error screen does, because terminals belong to the page that started them.

When a shell ends

When the shell exits, its tab says exited, the terminal dims, and a notice says why. Restart starts a new shell in the same tab, with the same name, cluster and namespace. When Lumovi starts again, the terminals it had come back as tabs, each ended: “The shell ended when Lumovi quit.” Its name, cluster and namespace are kept, and Start a new shell starts one there. Nothing starts until you choose it, since a shell runs your profile. See Opened again as it was.

The dock

  • Resize it by dragging its top edge. Or press Tab until the edge has focus, and press ↑ or ↓. Lumovi remembers the height.
  • Maximize the tabs below, on the right of the bar, makes them as tall as they go. Restore the tabs below brings them back.
  • Hide the tabs below, the arrow at the end of the bar, hides them; Show the tabs below shows them again, on the tab shown last. ⌃` shows or hides the terminal. Hidden from a terminal, the page has focus again.
The terminal fits the dock, and the shell learns its new size when you resize it. It uses the app’s colors, in light and dark, and keeps 10,000 lines of scrollback.

Keys

In a terminal, keys go to the shell, as in any terminal, except the dock’s own and, on a Mac, the menus’ ⌘ shortcuts. The dock’s differ by platform: On a Mac, ⌘T, ⌘N, ⌘W and ⌘K are the terminal’s while a terminal has focus, as in Terminal and iTerm. Everywhere else in Lumovi they keep their usual meaning: ⌘N is Create…, ⌘W closes the window, and ⌘K opens the command palette. On Windows and Linux, a shell keeps CtrlW, CtrlK and the rest for itself, so the dock’s keys add ⇧, as Windows Terminal’s do. They, and the keys that switch terminals, work while the dock is open and has focus. The shortcut sheet (?) lists them under Terminal. See Keyboard shortcuts.

Paste a command

Every action dialog shows its Equivalent command. Hover it for its buttons: next to Copy command, Paste in terminal types it into a terminal and closes the dialog, without making the change. Nothing runs until you press ↵ in the terminal, so you can read the command, change it, and run it yourself.
  • It goes into the terminal the dock shows, or showed last. When there’s none, or its shell has ended, a new one starts for the cluster you’re in.
  • Commands name their cluster and namespace, like --context dev -n shop, so they act on the dialog’s cluster whichever one the terminal points at.
  • A command with several lines, like one for each namespace in Several at once, is typed as one line: joined with &&, so each runs only if the one before it worked, or with ; on Windows, where Windows PowerShell has no &&.
  • A terminal that’s still starting gets the command once its shell has drawn its prompt.

Icons in your prompt

Prompts that draw icons, like Starship, Powerlevel10k and oh-my-posh, show them without a font to install. Lumovi brings the symbols of Nerd Fonts (Symbols Nerd Font Mono 3.5.1), sized to the terminal’s characters, and uses them only for what its own font doesn’t have. Nothing is downloaded for them. Shells in containers and on nodes show them too.

Shells and debug containers

A terminal inside a container, or a debug container with tools.

Changing things safely

The equivalent command, and the other guard rails.