Security fixes
A server could be made to fetch from inside its own network. On a server that fetches charts from public addresses alone (the default, withhelm.allowPrivateCharts off), the address a chart came from was checked apart from the fetch.- Redirects (1.0.0 to 1.23.0). A chart given by a repository’s URL, an
oci://reference or a URL was fetched by Helm, which followed redirects without the check. So a public address that redirected to a private one reached it. Listing a repository’s versions followed redirects unchecked too. - Names that change (1.0.0 to 1.23.0). A name could give the check a public address and the fetch another, such as an address in the cluster’s or your company’s network, or a cloud metadata endpoint. In 1.23.0 this held for the repositories Lumovi keeps, and their icons, too.
192.0.0.0/24, 198.18.0.0/15 and 240.0.0.0/4) are refused too. Through a proxy (HTTPS_PROXY), the proxy resolves each name, so what the server can reach through it is the proxy’s to limit. See Charts and private networks.The audit log records an install or upgrade from a chart’s URL, a repository’s URL or an oci:// reference, with that address and how it ended: look there for one from an address you don’t know. Asking for a chart’s versions or default values isn’t recorded, so those requests leave nothing in Lumovi’s log; your network’s own records of the server’s connections are where to look. Where the server’s pod could reach a cloud metadata endpoint, or a service in your network that answers without a sign-in, treat what they answer as possibly read in part, and limit where the server connects.Release notes1.23.1 makes Lumovi for Linux start again. From 1.18.0 to 1.23.0, three to five of each version’s six Linux downloads were packed with the other architecture’s terminals, and stopped as they started: which ones is under Fixed below. It also keeps a log you’re following at its newest line.
Fixed
- A log you’re following keeps its newest line in view. Once a search, a level or a pod had narrowed the lines, showing them all again could leave the log at its top while new lines arrived unseen. Now only you stop following, by scrolling up or stepping to a match, and the Follow button shows as off whenever the newest line isn’t held in view; press it to go back to the end. See Read them.
- Lumovi for Linux starts again. From 1.18.0 to 1.23.0, the downloads listed below stopped as they started, with “Failed to load native module: pty.node”: each was packed with the other architecture’s terminals. Every Linux download of 1.23.1 is packed with its own: the AppImage, .deb and .rpm, for x86_64 and for ARM. A copy that didn’t start can’t update itself, so download 1.23.1 from GitHub and install it over it.
- 1.23.0: the x86_64 AppImage, .deb and .rpm, and the ARM AppImage and .rpm.
- 1.22.1: the x86_64 AppImage, .deb and .rpm, and the ARM AppImage.
- 1.22.0: the x86_64 AppImage and .deb, and the ARM AppImage, .deb and .rpm.
- 1.21.0: the x86_64 AppImage, .deb and .rpm.
- 1.20.0: the x86_64 AppImage and .deb, and the ARM AppImage, .deb and .rpm.
- 1.19.0: the x86_64 AppImage, and the ARM AppImage, .deb and .rpm.
- 1.18.0: the x86_64 AppImage, .deb and .rpm, and the ARM AppImage.
Security fixes
1.23.0 has two: every object’s name and namespace is checked before the cluster is asked, and an answer that isn’t the object asked for is refused; and on a server, people’s groups follow the sign-in provider, and someone it disables is signed out.- Single sign-on: groups follow the provider, and someone it disables is signed out. Given a refresh token, a server keeps it, sealed, asks the provider again before each ID token expires, and revokes it at sign-out where the provider can. Someone’s groups are as the provider says now, from their next request, and a provider that won’t renew a sign-in ends the session at once. A change to someone’s groups is in the audit log. See Groups that follow the provider.
-
A name that isn’t one could reach more than one object, or another one. Asked for an object by a name like ”.” or ”..”, which no object can have, or for a pod by a name with a backslash, Lumovi could send the cluster an address that reaches more than that object, or something else.
- Reads, on a server (1.6.0 to 1.22.1). A read of one object could bring back every object of its kind in the namespace, handed back as if it were the one. Where your access shows someone only a Secret’s keys, the Secrets in that list came with their values.
- Shells, attaching and file copies, on a server (1.6.0 to 1.22.1). A pod’s name with a backslash could open a shell in a container, attach to one, or copy files to or from one, in another namespace than the one Lumovi’s access checked.
- Deletes, on the desktop and on a server. A delete by such a name could delete every object of its kind in the namespace (or, for a kind outside namespaces, like nodes, every one), or the namespace itself. Lumovi’s own pages never asked for such a name: it took an assistant’s delete or a plugin’s proposed change, approved in a dialog that named ”.” or ”..”.
Finding and seeing
- Search the cluster, by part of a name or by labels, in the namespaces picked, grouped by kind; searches can be saved. See Search.
- Map, the whole cluster in one picture: what routes traffic, the services, workloads, pods and what they use, in bands by namespace, node or app. See The Map page.
- Several clusters in one list: their Workloads, Pods, Nodes and Events together, each read with your own access. See Several clusters in one list.
- Compare with… sets an object beside another of its kind, in another namespace or cluster, its ConfigMaps and Secrets too. See Compare with another.
- Certificates in Secrets: who each is for, its chain, and when it ends, with an Expires column in the list. See Certificates.
- Quotas show how full they are, and Resource Quotas and Limit Ranges have lists of their own. See Resource quotas and limit ranges.
- Links to what you’re looking at,
lumovi://links that only show and always ask first; a policy can turn them off. See Links.
Settings and the desktop app
- Settings: theme, accent, density, text size, time zone and clock, the terminal’s font and shell, and which namespace a cluster opens in. An organization can set and lock them. See Settings.
- Keyboard shortcuts of your own, changed in Settings, or set by an organization. See Change a shortcut.
- A tab below moves to a window of its own, a terminal’s shell still running, and back below. See In a window of its own.
- Add EKS clusters from AWS, found with your own
awscommand, only when you ask. See From AWS. - A kubeconfig user with
auth-provider: oidcstays signed in, renewing as kubectl does and writing its tokens back where kubectl keeps them. See Signing in with OIDC.
Helm
- Repositories, a chart browser, and Update available, a repository’s sign-in sent only to it and kept in the keychain or sealed. See Repositories.
- Wait, undo and a timeout on install and upgrade, and a rollback shows what it changes. See Waiting, undoing and a timeout.
Plugins
- A plugin’s file can withhold fields Lumovi then never shows or hands on, like the line around a secret Trivy found: trivy-operator 1.1.0 withholds it. See
withholds. - A plugin’s tables download as CSV, written from what Lumovi shows. See The kit.
- Built with Lumovi-plugins 1.5.2.
In your cluster
- Microsoft Entra ID: someone in more than 200 groups signs in with their groups, read from Microsoft Graph. See Microsoft Entra ID and many groups.
- Adding a cluster to a fleet says what’s wrong with its certificates, and what to do. See Add a cluster to a fleet.
Fixed
- Lists no longer scroll sideways: the least important columns give way first, and a list’s bar keeps to its pane.
- A row of tabs no longer runs past its edge: the rest are under More, and the open tab always has a place.
- No view breaks on an object that leaves out a field the API doesn’t require.
- The Overview draws for an account that may not list nodes, and says why there’s no live usage where node metrics can’t be read.
- The AI assistants page lists only the assistants connected now.
- A dialog that closes leaves the keyboard where you put it.
- On the events timeline, a mark’s card stays with its own event, and a short bar’s count no longer covers the next mark.
- A plugin’s lists, tables and switches look and behave as Lumovi’s own.
- On Windows, a terminal says when PowerShell is still starting, and what was typed meanwhile still reaches it.
- How long something has run reads in days past a day: “15d 17h”.
- A plugin’s page looks and works like Lumovi’s own. A page that is one list, such as Argo CD’s Applications, is drawn as Lumovi’s lists are, with their count, chips, filter and pages of rows. Every plugin’s page is framed as Lumovi’s are, named in the bar for the page that’s open, and its tabs are words alone.
- What a plugin may do is in the bar’s More (⋯) and the command palette’s Actions, as What Argo CD may do for Argo CD’s. No line above the page says whose it is now, and Lumovi’s own change dialog still names the plugin and its version. See Pages drawn by a plugin’s code.
- A plugin’s page, tab or command can’t be called by one of Lumovi’s own pages, lists or commands, nor as though it said what the plugin may do, like Permissions. A file that does isn’t used, and its problem says why. Overview is still a plugin’s to use.
- Fixed: CloudNativePG’s Backup health, which Lumovi stopped as it opened, now draws, and its tiles count as the table under them shows. Prometheus Operator’s Target health draws no tiles about targets it never read. Argo CD’s Applications shows an application’s project under its name. “Comes with Lumovi” stays whole on a narrow Plugins page.
- Built with Lumovi-plugins 1.4.3.
Plugins
- Add-ons are plugins. A plugin is one file: its place in the sidebar and a view for each kind it shows. All plugins lists every one, with what each asks for, read from its file. See Plugins.
- Installed and updated from Lumovi-plugins, in the desktop app: what a plugin may do is shown first, in Lumovi’s words, and nothing changes until you agree. Back to returns to the version before. See Install and update plugins.
- Pages drawn by a plugin’s code, in a sealed box that reads only what its file says, as you: Argo CD’s, CloudNativePG’s, Karpenter’s and Prometheus Operator’s. A change a page proposes is confirmed in Lumovi’s own dialog, with what it would harm in red. See Pages drawn by a plugin’s code and Included plugins.
- Your own plugins, in
~/.lumovi/plugins, are held as Lumovi’s are, and Developer mode runs their code once you’ve agreed. See Your own plugins. - An organization’s policy can hold plugins to what it allows, keep their code off, and turn off the store. See Policy.
Lists, pins and views
- Lists choose their columns, add one from a label or an annotation, never scroll sideways, and copy or download what they show. See Columns.
- The namespace picker picks several, up to 20, and the address carries them. See Pick several.
- Pins and saved views: an object in the sidebar, ⌥1 to ⌥9, and a list’s columns, sort and filters kept by name. See Pin an object.
- Lists and opened objects update as the cluster changes, within a second, where you may
watch; an idle one is read once a minute. See Permissions. - Access control has pages of its own: roles, cluster roles, their bindings and service accounts, linked both ways. See Access control.
Create and YAML
- Create has a form beside its YAML, for nine kinds, each side following the other, a Secret’s values hidden until asked for. See The Create form.
- YAML is checked against the cluster’s schema as you type, with fields offered as you write. See Checked as you type.
Events, alerts and logs
- Events as a timeline, on the Events page and an object’s Events tab. See On a timeline.
- Alerts, a page of what the cluster’s Prometheus fires and has pending, worst first, each with its object and runbook. See Alerts.
- Notifications of new warnings, off until you turn them on for a cluster, each message cut where it could carry what only you may read. See Notifications of new warnings.
- Log search by regular expression, case, or the lines without a match, from any time, over a strip of the lines. See Logs.
- Attach to a container’s main process, as
kubectl attach -itdoes. See Attach to its main process.
The desktop app
- More than one window: File → New Window (⇧⌘N), each with its own pages and what it starts. See More than one window.
- Keep open below: an object stays open beside the terminals while the pages go elsewhere. See Keep it open below.
- Opened again as it was: each window, with what it had below. Terminals come back ended, and nothing signs in by itself as Lumovi starts: a cluster that signs in through a program says Signs in when opened. See Opened again as it was.
- Lumovi notices your kubeconfig changing, and Add a folder… reads every kubeconfig in one; a folder’s credentials that run a program ask first. See It notices a change and A folder of kubeconfigs.
- Node taints, added and removed without YAML, and a drain with kubectl’s options. See Taints.
- AI assistants find a cause in fewer steps, with two new tools. See Tools.
In your cluster
- A server’s web UI works on a phone and a tablet. See On a phone.
- A server acts only on requests from Lumovi’s own page, by
Sec-Fetch-Site, andLUMOVI_URLnames one host. See Requests from Lumovi’s own page.
Fixed
- Create answers for YAML whose alias names no anchor set before it.
- What you type while a terminal is still opening reaches the shell once it’s open.
- On a phone, tabs are big enough to tap, and a failed refresh’s notice shows its whole reason.
- On Windows, a name with room for all of it is shown whole.
- An equivalent command breaks between its words.
Files, to and from a pod
- Download files… and Upload files…, in a running pod’s actions. A download takes a file or a folder from a container by its path; an upload puts a file or a folder into a folder there. Both work as
kubectl cpdoes, by runningtarin the container, and each shows the command that does the same, its progress, and Stop. A copy stops by itself when nothing moves for a minute. See Copy files to and from a pod. - Where it lands. The desktop app asks where to save, in your system’s dialog. On a server, your browser downloads it, a folder as a
.tar, streamed from the container with nothing kept on the server. A download that ends early leaves nothing behind. - Nothing a container sends is trusted. Only files and folders under the path you asked for are kept. Links, devices and pipes are left out and counted, and an entry that names anything else ends the copy. See What’s kept of a download.
- Without
tar, Lumovi says so, with thekubectl debugcommand that reaches the container’s files instead. See What it needs. - Who may copy. A download needs what a shell needs, and works in a read-only cluster, since it changes nothing. An upload also needs changes allowed, is refused where the cluster is read-only, and asks for the pod’s name on a production cluster. AI assistants can’t copy files. See Who may copy.
- Recorded. The audit log has an entry when a copy begins and one for how it ended: who, the pod, the container, the path and the size. Never the files’ contents, the names of files in a folder, or what the container said. See What’s recorded.
- 2 GiB a copy, unless you say otherwise: the chart’s
fileCopy.maxByteson a server, orfileCopyin your organization’s policy on the desktop.fileCopy.enabled: false, or the policy, turns copying off. See How much one copy carries.
Fixed
- Two servers on one volume never both keep its audit history. Starting together, or one reading the other’s lock as it was renewed, could leave both writing it, numbering events the same. The lock is now always whole, one of any number takes it, and a server reads it before each event: one that finds another has taken its history over writes nothing more to it, and says so. A lock nobody renews is told by watching it for 30 seconds, not by comparing two computers’ clocks. See Where it’s kept.
- The check names two servers as a cause, where a history was kept by two at once: no event is lost, and the check lists where their numbers meet. See On the page.
- The Metrics page with a Prometheus that keeps each node’s own network series. Choosing Network in or Network out could replace the page with an error. Network usage now counts only pods’ traffic, on the page and in a node’s charts.
- A list’s bar keeps to one row beside an open object: its label selector and filter shrink instead of dropping to a second line. With less room still, the label selector is a button that opens its field under it.
- The Map opens beside a custom resource that owns both its pods and the Services that select them, as CloudNativePG’s
Clusterdoes. Opening one of its Secrets from the Cluster’s Map showed an error in place of the Secret.
One place to sponsor Lumovi
- Every Sponsor link opens Lumovi’s listing on GitHub Sponsors, github.com/sponsors/Lumovi: Help → Sponsor Lumovi… in the desktop app, the sidebar’s sponsor card when it’s Lumovi’s own, and the links in the README.
Usage history, where a cluster has no Prometheus
- Lumovi offers to install a small metrics stack, so the Metrics page, each object’s charts and right-sizing have history: Prometheus and kube-state-metrics, in a namespace of their own,
lumovi-metrics. Nothing is made before the review, which shows what will run, the values, and a dry run on the API server with every object. An install that fails is undone. See Lumovi’s metrics stack. - What it installs is pinned. The chart ships with Lumovi and is checked against its SHA-256 before every use, so Lumovi downloads nothing, and both images are pinned by digest. See What it installs.
- It collects only what Lumovi reads: CPU, memory and network use, and restarts, of pods’ containers. Its two cluster roles read nodes, their kubelets’ metrics and pods: no Secrets, no ConfigMaps. History is kept for 7 days on the node’s disk, without a volume. See What it can read.
- Who may install it. On the desktop, anyone the cluster lets: without its permission for all of it, Lumovi says what’s missing and installs nothing. On a server, only Lumovi’s admins, and nobody where it names none. It isn’t offered on a read-only cluster, and assistants can’t install it. Installing and removing are in the audit log, with a
helmcommand that does the same. See Who may install it. - Removing it is under Metrics source: Lumovi uninstalls the release and deletes the namespace, and the two cluster roles and their bindings go as well. A namespace Lumovi didn’t make is never taken or removed. See Removing it.
- Turning the offer off. An organization sets
"metricsStack": falsein its policy; on a server,metrics.stack: falsein the chart’s values (LUMOVI_METRICS_STACK=off). See Turning it off.
A fleet’s clusters, added and shared from its page
- A private cluster, connected from the Fleet page. Lumovi’s admins choose Add cluster, then Connect with an agent…, give it a name, labels and groups, and run one command with their own access to the cluster. It installs the cluster’s agent, which dials Lumovi: the cluster opens no port, and nobody pastes its credentials into Lumovi. The page waits for it, with the time left, and a card with Cancel it. See Connect one from the Fleet page.
- A join token works once, for an hour. It’s shown once, read from the terminal, not the command line, and Lumovi keeps only its SHA-256. The agent trades it for a token of its own, kept in a Secret in its cluster, so the join token is no use once it’s joined. Until an admin checks the certificate authority the agent sent, only admins see the cluster. See Trusting it, by its SHA-256.
- Each cluster’s name, labels and groups, from its card. Its ⋯, then Settings…: the name it’s shown by, the labels to filter and group by, and the groups that see it besides admins, which applies at once. What a cluster’s source sets, like a Secret’s annotations or
LUMOVI_FLEET_AGENTS, stays the source’s, shown locked, with where to change it. See Settings on the Fleet page. - Admins see every cluster, whatever its groups, and open it as themselves: in it, they may do what its RBAC lets them. See Admins see every cluster.
- A cluster added by kubeconfig or token, where the chart allows it (
fleet.addFromPage, off unless you set it): Add cluster, then Paste a kubeconfig… or Use a token…. Lumovi checks it first: it reads, what it signs in with is in it, its server ishttpsand checked against its certificate authority, and its credentials work and may act as each person. It’s kept as a Secret of Lumovi’s in a namespace of its own, the only place the chart then lets Lumovi write Secrets, and Remove from the fleet… deletes that Secret, never one Lumovi didn’t make. See From the Fleet page. - Admins only, and recorded. Connecting, cancelling, joining, adding, removing and each change of settings need Lumovi to have admins and to keep its state, and are in the audit log, with who saw a cluster before and after. See Settings in the audit log’s events.
The app’s menu, on Windows and Linux
- A Menu button, at the window’s top left, in every view, since the window has no menu bar there: Help, View, Go and the rest are reachable with the mouse. Alt on its own, or F10, opens it too, except while a terminal has the focus. See Desktop app only.
- Help → Documentation opens these docs, on every platform.
Changed
- The project’s contact address is peter@lumovi.dev: in the Code of Conduct, the Linux and AUR packages’ maintainer, and the chart repository’s owner on Artifact Hub.
Fixed
- A connection a server refuses can’t stop it. Before, one cut off after it was refused could stop Lumovi served from a cluster, or a fleet’s hub, without anyone signing in. The desktop app and agents weren’t affected.
The clusters page
- Every cluster, a tile, on the page the desktop app opens on: in its color, with its status on its corner, its name and where it is, and its version and response time, or what went wrong. The ones you opened last come first, then Lumovi’s groups (or a label’s values, or none). Search finds a cluster by its name, context, server or labels. Its actions are on its ⋯, on right-click, or on .: its settings, the line for kubectl, its file in Finder, hiding it, or removing one added in Lumovi. See The start screen.
- The kubeconfig files it reads, chosen in it, from the page’s footer: one in place of
KUBECONFIG’s (or~/.kube/config), or more after them. Each says where it’s from and how many clusters it has, or that it’s gone or can’t be read, and the others still load. Lumovi never writes them, and its terminals get the same files. Your organization’s policy can keep it toKUBECONFIG’s or~/.kube/config:"kubeconfigFiles": "locked". See Choose your kubeconfig files and kubeconfigFiles. - A cluster added from a pasted kubeconfig, or a file. Lumovi checks that it reads, that its server answers and that its credentials work, then keeps it in its own folder, where only you can read it, never in your kubeconfig. See Add a cluster.
- Nothing runs, or is sent, until you allow it. A credential that runs a program on your computer, or sends a file to the server, is shown exactly as it would run. So is sending credentials to a server Lumovi can’t verify, or unencrypted over
http://. See Credentials that run a program, send a file, or go unverified. - Edited, or removed. An added cluster’s connection can be changed while its secrets stay in Lumovi, shown as
(kept by Lumovi); sent somewhere else, they’re asked about again. Copy for kubectl gives the line that has kubectl use it, in any terminal. See Change or remove it. - Each cluster’s settings, kept in Lumovi (⌘I): its name, color, group and labels, the namespace it opens in, and whether it’s production, read-only or hidden. Production, set by hand, wins over Lumovi’s guess from its name, for its badge and for the names typed to delete and drain. Its name shows in the switcher, the command palette and the window’s title. See Cluster settings.
Statuses that look as the brand’s
- One word, one look. Statuses look as they do on the website and in these docs: in progress is neutral, not blue, its dot pulsing and its icon turning once every 3 seconds (both still when you ask for less motion). Every status’s mark reaches 3:1 contrast and its words 4.5:1, on each surface, in light and dark, and the orange of “serious” is gone, YAML’s numbers and booleans included. A job still running says In progress: Running is a pod’s, and healthy. See Health and status.
- Blue is for what you can act on. Links and text buttons use the stronger blue, which reads at 4.5:1 on every surface. Access’s notes of what’s to know, and a live terminal’s tab, are neutral.
- Dark mode’s primary buttons are the same blue as in light, with white on it at 4.6:1, and a primary or danger button turns deeper when hovered, not lighter.
Fixed
- A link that sorts a list by a column that doesn’t sort (
?sort=ready), or one the list doesn’t have, shows the list in its usual order instead of failing. - Copy kubectl describe and Copy kubectl logs name the cluster (
--context), and a custom kind’s API group, so they run against the right one wherever they’re pasted. - The Workloads page cuts a long image at its start, so its tag shows.
- Lists’ headers show whole at the default window size, with room for the sort arrow, and a table no longer runs a few pixels past its edge.
Read-only, not undone quietly, and a sponsor card
- Changed outside Lumovi, it fails closed. A cluster’s settings deleted, or an older copy put back, where the server keeps them are found within 10 seconds, and Lumovi keeps each setting as whichever copy set it last: read-only if either has it, and its metrics source and node shells as it last set them. Each setting carries the count of the write that last set it, so a running server tells its own changes from those made by hand, whichever replica finds them. A change made while no replica runs is taken as found. See Changed outside Lumovi.
- Recorded, and shown. It’s in the audit log, by Lumovi itself, with
outside: true: “Changed outside Lumovi: production’s read-only was turned off, as its setting was deleted where Lumovi keeps it, and Lumovi made it read-only again”. Lumovi’s admins see it on the cluster’s pages, on every replica, until read-only is set again: Keep it read-only or Allow changes, each recorded as theirs. Made read-only by an older copy, Lumovi names nobody: the switch says “Turned on outside Lumovi”, and what the server refuses “it was made so outside Lumovi”. - A key change lets go of the old key’s entries within 15 minutes of the rollout’s last replica on the old key stopping: what an old key, a leaked one say, opens doesn’t outlive it in the state. What isn’t even shaped like Lumovi’s goes at once.
- One replica, without kept state. The chart refuses more than one replica without
auth.keepSessions: each would keep who’s signed in, and what’s set for everyone, in its own memory. A server keeping its state in memory says, as it starts, to run a single replica. - Read-only, offered to those who may. The command palette offers to make a cluster read-only, or allow changes, only to Lumovi’s admins, or anyone where it has none. What the server refuses says who made a cluster read-only: “production is read-only for everyone on this server: jane@example.com made it so.” The switch says when, in your time.
- One card, above the sidebar’s footer, in the desktop app, the web UI Lumovi serves from a cluster, and a fleet’s hub: Lumovi’s own, “Help keep Lumovi free.”, which leads to GitHub Sponsors, a sponsor’s, with their picture, one line and a link, or none. It opens in your browser, and shows the link’s domain as you point at it.
- Read from GitHub, sending nothing but the request. Lumovi reads
sponsor.jsonin Lumovi/main-sponsor, and the pictures it names, fromraw.githubusercontent.com: the desktop app 3 seconds after it starts, a server as it starts, then every hour. No cookies, no IDs, nothing about you or your clusters, and nothing counted. It can’t be turned off. See The sponsor card. - Checked before it’s shown. Only plain words, an
httpslink, and pictures that are PNG, GIF or WebP by what they are, at 408 × 136, small enough, and played once, shown from Lumovi’s own copy. What doesn’t pass shows Lumovi’s own card, with no error and no wait. Offline, the card stays what Lumovi read last: an egress policy that leaves GitHub out costs only the sponsor’s card. - A dialog’s error is always in view, just above its buttons, in a tall one too, like a drain’s list of pods or a chart’s values: the button no longer seems to do nothing. In Create from YAML, what each object came to is brought into view.
- A chart’s reference lines (requests, limits, allocatable, and what right-sizing recommends) are labelled where their labels sit clear of the plotted lines, and of each other.
A terminal’s kubectl: signatures your organization can require
- A mirror’s kubectl, only with Kubernetes’ signature. Your organization’s policy can require it,
"kubectlSignatures": "required", as dl.k8s.io’s always is. A kubectl the mirror keeps no.sigand.certfor isn’t used: the terminal uses yours, or one kept and signed, and says “artifacts.corp.example.com published no signature for kubectl v1.34.9, and your organization’s policy requires one”. A kubectl taken from the mirror unsigned before isn’t used while the policy requires signatures, and a policy that can’t be used gets no kubectl at all, so terminals use the one installed. See kubectlSignatures. - A refused kubectl may have been changed, or Lumovi may need an update. A terminal says a kubectl “couldn’t be verified as Kubernetes’ own, and may have been changed”, and why. Where it isn’t signed as this Lumovi knows Kubernetes signs, or under Sigstore’s authority and logs as it knows them, it says which of them may have changed instead, and that Lumovi then needs an update. See When it can’t have one.
- Kept kubectls, checked before each use. Lumovi notes each kubectl’s SHA-256 beside it as it checks it, and uses a kept one only while it still matches. It keeps the newest signed one of each minor version too, for a policy that requires signatures.
- Sigstore’s trust root, through TUF. The trust root Lumovi checks signatures against is taken through Sigstore’s TUF repository, checked against its signed metadata. Each week, Lumovi’s repository takes it again, and proposes the new one for a release when Sigstore changes it, and checks that Kubernetes’ instructions still name the signer Lumovi checks for. See What’s checked, and what isn’t.
- Releases, immutable. Once a release is published, GitHub keeps its files and its tag from being changed or replaced, and
gh release verify-assetchecks that a download is the one it was published with. See Verify your download.
Proxy sign-in and fleet agents, safe by default
- Behind an authenticating proxy, only the proxy’s pods reach Lumovi. With
auth.mode: proxy, the chart’s NetworkPolicy is always on, and the chart won’t install withoutnetworkPolicy.fromnaming the proxy’s pods: whoever else could reach Lumovi could say they’re anyone. It needs a network plugin that enforces NetworkPolicies. See Authenticating proxy. - An agent’s cluster is trusted by its certificate authority. A fleet trusts only the one
caSha256names for an agent inLUMOVI_FLEET_AGENTS, or else the one the agent first sends, kept and recorded in the audit log (agent.pinned). Lumovi’s log names each agent withoutcaSha256as it starts, and the chart’s notes say so too. Another certificate authority is refused (agent.refused), and the cluster’s card says Agent not trusted. See Its cluster’s certificate authority. - Admins trust an agent by its SHA-256, from its cluster, or anyone signed in where Lumovi has no admins. Agents to check, on the fleet’s page, lists one refused, with Trust it…, and one trusted as it first connected, with Check it…, showing only the start of each hash it sends. Either takes the SHA-256 of the cluster’s certificate authority, as
openssl x509 -noout -fingerprint -sha256prints it, and Lumovi trusts the agent only if that’s what it sends (agent.trusted). See Trusting it, by its SHA-256. caSha256takes openssl’s line as it is,sha256 Fingerprint=AB:CD:…, or just the hash.- An agent is ready only once Lumovi trusts its cluster. Until then, its
/healthzanswers503,connected, not yet trusted, orconnected, but refused:and why. - Agents connect over https. The chart refuses an
httpagent.hubUrl, and an agent anhttpLUMOVI_HUB_URL, but on the same machine: its token and its cluster’s would cross the network as they are.
A terminal’s kubectl, checked against Kubernetes’ signature
- Signed by Kubernetes. The kubectl a terminal downloads is checked against Kubernetes’ own signature, not only the SHA-256 published beside it. From dl.k8s.io, a kubectl without Kubernetes’ signature, or with one that doesn’t hold, isn’t used: the terminal says why, and uses yours, or the newest one kept. A kubectl kept by an earlier Lumovi is downloaded again, and checked.
- Checked on your computer, against Sigstore’s trust root as Lumovi ships it: no new connection, and nobody else learns what you download. See What’s checked, and what isn’t.
- Mirrors. A mirror that keeps Kubernetes’
.sigand.certhas its kubectl checked against them too. One that keeps none is checked against its SHA-256 only, and each terminal says so: “artifacts.corp.example.com has no Kubernetes signature for it, so Lumovi checked it against its SHA-256 only.”
A fuller bill of materials
- helm’s Go modules. The desktop app’s bill of materials (
Lumovi-<version>.cdx.json) lists the Go modules the helm it ships is built from, and the Go it’s built with, so a scanner such as grype sees a vulnerability in any of them. See Verify your download.
Any AI assistant, and Codex
- Any AI assistant or agent that speaks MCP works through Lumovi, and the AI assistants page says so, rather than naming a few. See AI assistants.
- A Codex tab under Connect an assistant: on the desktop, the settings for Codex’s
config.toml, with Lumovi’s token; on a server, one command, then Codex signs in with OAuth. See Connect an assistant, and AI assistants on a server.
A cluster’s settings are the server’s
On your team’s Lumovi, a cluster made read-only is read-only for everyone on the server, and their AI assistants.- Read-only, for everyone. The cluster switcher says who turned it on, and when, and so does every change it turns off or the server refuses: “production is read-only for everyone on this server: jane@example.com made it so on 2026-10-07.”
- Where metrics come from, and where node shells run, are the server’s too, the same for everyone.
- Lumovi’s admins change them, or anyone, where there are none. For everyone else, the switch and the dialogs say “Only Lumovi’s admins change what’s set for everyone on this server.”
- In the audit log:
read-only.changed,metrics-source.changedandnode-shell.changed, attempts by those who may not included, as refused. - Kept across restarts where the server keeps its state: the chart’s
auth.keepSessions, orLUMOVI_DATA_DIR. With more than one replica, a change reaches the others within 10 seconds. - In the desktop app, they stay your own, and changing where a cluster’s metrics come from is in its audit log too.
- See Read-only mode.
A signed Windows installer
- The Windows installer is signed, and so is everything it installs: by Open Source Developer Péter Kóta, with a Certum certificate. Windows says who it’s from, though it may still warn while the certificate is new, and Lumovi installs only updates signed the same way. See Install.
- Long text stays in its place, everywhere. Names, labels, annotations, images and messages as long as Kubernetes allows are cut short with an ellipsis, all of it on hover, or wrap where there’s room. A long name has a line of its own in a panel, and an image is cut at its start, so its tag shows.
Fixed
- A sign-out the server couldn’t keep says so on the sign-in page, however slow the server’s answer.
- The bridge an AI assistant starts follows no redirect, so Lumovi’s token goes nowhere else.
kubectl/clusters.json, which names your contexts, is yours alone, and written whole or not at all.- A terminal opened as Lumovi starts keeps the kubectl download it began.
- A terminal that won’t use
LUMOVI_KUBECTL_MIRRORdoesn’t show a user and password the URL has, and the policy’s message aboutkubectlsays what it takes: anhttpsmirror, or anhttpone on this computer. - Menus and popovers grow from what opened them, and those that open upward rise.
Security fixes
What an AI assistant’s bridge, a cluster or a kubectl mirror can do is narrower.Fixed
- Claude Desktop’s bridge proves it’s talking to Lumovi before it sends Lumovi’s token. While Lumovi wasn’t running, another program on the computer could listen on its port and be given the token. Now, before every request, the bridge sends a challenge that only what holds the token can answer, a keyed hash of it, and it doesn’t start Lumovi over something else. See Security.
- What a cluster says can’t write over a terminal’s first line. Lumovi’s own lines leave out control characters and the marks that reorder text, and cut short what they quote from a cluster or a mirror.
- No kubectl older than 1.25, Lumovi’s oldest. A cluster can’t choose how old a kubectl a terminal gets: older clusters’ terminals use yours, saying why.
- kubectl mirrors over HTTPS only, or on this computer: over plain http, the checksum comes from the same place, and both could be changed on the way. That goes for an organization’s policy and for
LUMOVI_KUBECTL_MIRROR. An emptyLUMOVI_KUBECTL_MIRRORis as good as none. - Each cluster’s version is remembered across restarts, so a terminal for a cluster that can’t be reached as Lumovi starts gets the kubectl kept for it. A download a crash cut short is cleaned up as Lumovi starts.
Tools of its own
The desktop app brings what its Helm actions and terminals need.- A kubectl that matches the cluster, in each terminal. The kubectl for the version the cluster says it runs: the newest patch of that minor version, as kubectl works a minor version either side of its cluster. It’s downloaded from dl.k8s.io once, checked against the checksum published beside it, and kept for every cluster on that version. It’s first on the terminal’s
PATH, even after your startup files (zsh, bash, sh, dash, ksh, fish and PowerShell), and the terminal’s first line says which: “It’s v1.34.9, to match the cluster.”- A terminal never waits long for it. A cluster that doesn’t say its version within 3 seconds, or a kubectl still downloading after 10, and the terminal starts with yours, saying why; the terminals opened after get it. Offline, the newest one kept does.
- View → Match kubectl to Each Cluster turns it off. An organization’s policy can too (
"kubectl": false), or name a mirror of dl.k8s.io to get it from, as canLUMOVI_KUBECTL_MIRROR. - See A kubectl that matches the cluster.
- helm, shipped with the app, and listed in its bill of materials. Helm 4.3.0, the same as the image’s, runs its Helm actions: installing, upgrading, rolling back and uninstalling releases need no helm of your own.
LUMOVI_HELMstill names another. Terminals have it last on theirPATH, for when you have none. See Which helm runs.
A restart signs nobody out
Upgrading, or restarting, your team’s Lumovi keeps everyone signed in, and the AI assistants they allowed connected.- What’s kept: sessions, the AI assistants people allowed with their tokens, and what each person made read-only for their assistants.
- Where it’s kept:
- With the chart, in a Secret it makes,
<release>-state, which Lumovi may onlygetandpatch(auth.keepSessions, on by default). - Without the chart, in that Secret (
LUMOVI_STATE_SECRET), or underLUMOVI_DATA_DIR.
- With the chart, in a Secret it makes,
- Sealed, with a key kept apart. Each entry is sealed (AES-256-GCM), and filed under an HMAC of what it is. The key is in a Secret of its own: the chart makes
<release>-state-keyand keeps it, or you giveauth.stateKeySecretwhere the chart is rendered withhelm template, as with Argo CD. Without Kubernetes, the key is instate.key, besidestate.json. Reading the state shows nothing, not even who’s signed in, and writing it can’t make, change or move an entry that opens. - No credential in it either. Cookies and assistants’ tokens are kept by their hash. A token a session passes on to the cluster (its person’s own, with a token, or with single sign-on that forwards theirs) is sealed again, with a key only its cookie gives. It’s unsealed when its browser comes back, and renewed from then on.
- Sign-outs stay signed out. A sign-out, and an assistant let go or signed out, is kept before Lumovi says it’s done. When that can’t be kept, Lumovi says so.
- Assistants after a restart. Until its person opens Lumovi again, an assistant whose session passes their own token on says Lumovi restarted, and to open it. It carries on once they do. Assistants behind a proxy, or whose sessions pass no token on, carry on at once.
- See Across restarts.
The desktop app with Homebrew
brew install --cask lumovi/tap/lumovi, from Lumovi’s own tap, which follows each release once GitHub attests that the release workflow built its installers. Lumovi keeps updating itself. See Install.
Behind a company’s proxy
Lumovi’s own connections go through a company’s proxy, and trust its certificate authorities, askubectl and helm do.- The proxy. Lumovi uses
HTTPS_PROXYandHTTP_PROXY(http://where they give no scheme) for clusters, single sign-on, Helm repositories, the audit webhook and a fleet agent’s hub. It skips whatNO_PROXYleaves out: names and what’s under them, and addresses, each with a port or for any, the same for all of them (not ranges). A cluster’sproxy-urlin its kubeconfig is used where it has one. A proxy that wants credentials (407), or won’t open a tunnel, says so. Its credentials are never said, nor is a proxy that isn’t a URL. - The desktop app takes the proxy from your login shell, as it takes
PATH. A server leaves out the cluster’s API server and services. - Certificate authorities. The operating system’s are trusted besides Node’s: that’s where IT installs the one an HTTPS-inspecting proxy signs with. On a server, so are those in the files
LUMOVI_CA_FILEnames, which Helm is given too. A certificate Lumovi doesn’t trust, an expired one, or one for another name says which, and what usually causes it behind such a proxy. A file of them that can’t be read says which. - In the chart:
proxy.https,proxy.httpandproxy.noProxy, orproxy.secretfor a proxy with credentials: a Secret withHTTPS_PROXY, andHTTP_PROXYif plain http goes through one;extraCA: a ConfigMap’s or a Secret’s certificate authorities;- OpenShift’s restricted SCC (
restricted-v2), which chooses the pod’s user, group and fsGroup (openshift: auto).
- See Proxies and certificate authorities, and on your computer, Proxies and certificates.
A policy for your organization’s computers
A policy sets what the desktop app does on every computer. It’s deployed by an MDM, Group Policy, Intune or configuration management, where only an administrator can write it:- on macOS,
/Library/Application Support/Lumovi/policy.json, root’s, as is its folder; - on Linux,
/etc/lumovi/policy.json, root’s, as is its folder; - on Windows, the registry’s
HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Lumovi, itsPolicyvalue.
- Read-only: every cluster, or those whose names match.
- AI assistants: off, or limited by rules like a server’s
LUMOVI_ASSISTANT_RULES. - Updates: Lumovi’s own turned off, for IT to deploy new versions.
- The network: the proxy and certificate authorities to use.
Checkable releases
- Bills of materials. Each installer comes with an attested CycloneDX bill of materials (
Lumovi-<version>.cdx.json): every package the app bundles or ships, and Electron. The image carries its JavaScript’s, attested with it, and its system’s. - Signed with cosign, keyless, by the release workflow from
main: the image and the chart, both as a Sigstore bundle and with the.sigtag older admission controllers look for. See Check a release. - A hardening guide for a production installation: sign-in, the network, the service account, Access, the audit log, and an image pinned by digest whose signature an admission controller requires. See Harden it for production.
- Report a vulnerability by email too: security@lumovi.dev.
Fixed
- When the desktop app starts, it waits for the login shell’s environment before asking anything of a cluster. So nothing is sent before it knows the proxy, or a credential plugin’s
PATH.
An audit log
What was done through Lumovi, by whom, from where, and how it went.- Recorded as it happens. Changes from the page and from AI assistants, with how each was approved: by whom, after how long, with your note, or made without asking. Helm installs, upgrades, rollbacks and uninstalls. Shells and node shells, with how long they ran, and port forwards. Logs, Secrets and Helm releases’ values read, or refused. On a server, sign-ins and sign-outs (failed ones too, up to 60 a minute, then counted), and assistants allowed, denied and let go. Each tool an assistant calls. Changes to read-only, where node shells run, and AI permissions. Each change comes with the
kubectlorhelmcommand that does the same. Never Secrets’ values, what a change set, Helm values, tokens or manifests, nor what the cluster says in an error about a Secret, and each event is one line of 64 KiB at most. See The audit log. - The Audit log page, from the sidebar, the command palette, the Activity log and the AI assistants’ Activity tab. Search it, filter it with the filters kept in the address, follow events as they happen, see everything about one, and export to CSV or JSON Lines. Each object’s Audit tab shows its own.
- Chained. Each event holds its chain’s id and the hash of the one before it. Check integrity lists every place the chain doesn’t hold, and anyone can check it with jq and sha256sum (
jq -jcS 'del(.hash)' | sha256sum). The newest’s hash, compared with a copy kept elsewhere, shows what the chain alone can’t: the newest removed, or all of it rewritten. See Check it hasn’t changed. - In your cluster:
- People see their own events, and the auditors you name in
audit.auditors(LUMOVI_AUDITORS) see everyone’s. - Each event is also a JSON line on Lumovi’s output, and can go to a webhook (
audit.webhook), in batches, tried again until it’s taken. What can’t be kept or sent is counted, said in the log, recorded, and shown to auditors. - The history is kept on a 2 GiB volume, from the cluster’s default storage class, which uninstalling keeps, by one Lumovi at a time. A cluster without a default class needs
audit.persistence.storageClass, oraudit.persistence.enabled: false, which keeps it in memory. audit.level: changesrecords less.- See Audit log for your team.
- People see their own events, and the auditors you name in
- The desktop app keeps its own on your computer, for 90 days, or in memory, saying why, if its folder can’t be used.
Who may do what, team by team
On your team’s Lumovi, its admins decide what people may do through it: within their RBAC, and never more.- Profiles, grants and limits. What everyone signed in gets. Lumovi’s own groups, made of your identity provider’s groups and people by name, whatever the case of their name. Profiles, each a level of changes, shells, node shells, logs, Secrets (hidden, keys only, values), Helm (upgrade, or install), AI assistants (off, changes ask first, as they set them) and the audit log (their own, or everyone’s). Grants that give groups a profile in some clusters and namespaces, by name, pattern or label. And limits that hold anyone back wherever they match. See Access for your team.
- The server decides. Changes, shells, node shells, logs, Secrets, Helm releases and AI assistants are refused where people may not, saying which grant or limit decided. Changes, shells, logs, Secret reads and Helm refused this way are recorded in the audit log as refused. Secrets’ values never leave the server for someone shown only their keys, not even in a change’s answer, nor do Helm releases’ values and manifests.
-
The Access pages, for the admins named in
access.admins(LUMOVI_ADMINS):- groups, with who’s in each, and the provider’s groups seen at sign-in (named, for Microsoft Entra ID’s IDs);
- profiles side by side;
- grants and limits, with how far each reaches;
- someone checked anywhere;
- and every change, from the audit log.
- Your access, for everyone: what they may do, cluster by cluster, and why. Every refusal says why where it happens, and links to it. See Your access.
-
In the chart:
access.policy(LUMOVI_ACCESS), which admins see but can’t change, withonandofftaken as meant, quoted or not. What admins set is kept in a ConfigMap the chart makes, and read again every 15 seconds, so replicas follow. A change made there by hand is recorded too, as made outside Lumovi, even one made while Lumovi wasn’t running. With no admins, everyone may do all their RBAC allows. - AI assistants never do more than their person may. Someone who may use them nowhere can’t allow one.
Fixed
- Saving AI rules on a server keeps the chart’s
helm.sh/resource-policy: keepon their ConfigMap, so turning AI assistants off withhelm upgradekeeps everyone’s rules. - AI rules changed just as someone else’s save landed are no longer lost.
What AI assistants may do, and where
You decide what your AI assistants see, change and read: everywhere, and differently in some clusters and namespaces.- A page of their own. AI assistants opens a page, from the sidebar, the command palette or View, in place of its dialog: Connect, Your assistants (on a server), Permissions, and Activity, what they changed or asked to. See AI assistants.
- Five settings. Visibility, Changes (Without asking, Ask you, Never), Secrets (Values, Keys only, Hidden), Env values (Show, Hide sensitive, Hide all) and Logs (Read, Don’t read). By default, changes ask, Secrets show their keys only, and env values that look sensitive are hidden: by a word in their name, like
DB_PASSWORDorapiKey, or a value that carries credentials, like a URL with a password or a token, or a webhook’s address. See What assistants may do. - Rules for some clusters and namespaces, by name, pattern (
tenant-*) or label (team=payments), or leaving one out (!kube-system). Where they overlap, the strictest wins. A namespace a rule hides isn’t there for assistants, and every refusal says which rule decided. A change to a cluster’s own objects (nodes, CustomResourceDefinitions, cluster roles, webhooks…) can reach every namespace, so it’s decided as the strictest of them all: not made where one is hidden, refused or hides its Secrets. - Checked as you go. The tab counts what assistants see, change and read in every namespace, checks any one and says why, and shows what assistants are told as they start. Changes apply at once, to connected assistants too.
- Without asking, carefully. Deletions, changes that take fields over, and changes that make a workload read a Secret it didn’t before still ask you, unless assistants may read Secrets’ values there.
- On a server, each person’s are kept on the server, the same in every browser: in a ConfigMap the Helm chart makes, a file under
LUMOVI_DATA_DIR, or memory. Administrators set limits nobody’s own loosen, withassistants.rules(LUMOVI_ASSISTANT_RULES), matching a cluster of its own by the labels inclusterLabels(LUMOVI_CLUSTER_LABELS). Allow an AI assistant? says what it will be able to do. See AI assistants for your team. - Changed:
assistants.changesis a limit now.askandnevercap what people choose, andallowleaves it to them. The chart no longer sets it, so after upgrading, people may let their assistants change things without asking, or read Secrets’ values. To keep 1.4’s limits, add{ name: Limits, changes: ask, secrets: keys }underassistants.rules: see Upgrading. In the desktop app, each cluster’s Ask, Allow or Never becomes a rule, and works as before.
AI assistants on your team’s Lumovi
Claude Code, Cursor, VS Code and other MCP clients connect to a Lumovi server, or a fleet, at its address, and act as whoever allows them.- Signed in through Lumovi. Add
https://lumovi.example.com/mcpto the assistant, and it opens Lumovi in the browser: you sign in as you always do, with a token, single sign-on or your company’s login, and allow it. No token to copy. See AI assistants on a server. - As you, until you say. It reads the clusters you can see, a fleet’s too, with your RBAC on each, and changes nothing in the clusters you made read-only. It lasts until you disconnect it in Lumovi, sign out, or your session ends; behind a proxy, as long as a session lasts.
- Your answer, on your pages. The changes it asks for wait on your own Lumovi pages, in the same approval dialog as on the desktop. Notify me lets the browser tell you while the tab is in the background, and with no page open, a change waits for the next one.
- On after upgrading, with someone’s say. Assistants are on unless you turn them off (
assistants.enabled,LUMOVI_ASSISTANTS), and each one needs someone to sign in and allow it. Say what their changes do, for every cluster or each one (assistants.changesandassistants.clusters, orLUMOVI_ASSISTANT_CHANGES=ask,staging=allow,production=never); deletions always ask. The server’s log records each assistant allowed or let go, and what became of every change. See AI assistants for your team. - Sent back only where they may be. After someone allows one, Lumovi sends them back only to their own computer, an app, VS Code’s site, or sites you name (
assistants.redirectHosts,LUMOVI_ASSISTANT_REDIRECT_HOSTS). A refresh token that comes back after it was used ends what was allowed. - One replica. What assistants are allowed lives in Lumovi’s memory, so the chart keeps one replica while they’re on, and refuses more. Below a base path, its ingress routes the two addresses at the origin’s root where assistants look for how to sign in. Behind an authenticating proxy, let the assistants’ paths through: see Authenticating proxy.
Fixed
- The desktop app’s bridge for assistants that start Lumovi themselves, like Claude Desktop, connects only to Lumovi on this computer. A port in Lumovi’s settings that named another host would have sent it the bridge’s token.
Your AI assistant, with you in charge
Assistants read your clusters through Lumovi, and the changes they ask for wait for your approval. And right-sizing for clusters of thousands of namespaces.AI assistants
Claude Code, Claude Desktop, Cursor, VS Code and other assistants that speak MCP can read your clusters through the desktop app, and ask you before they change anything.- They read with Lumovi’s tools: your clusters, the kinds each one serves, lists with each object’s health, one object as YAML, events and logs, and what’s wrong in a cluster or namespace in one answer. A Secret’s keys, never its values. See Assistant tools.
- They ask. Applying a manifest, scaling, restarting and deleting are checked by the cluster with a dry run first, then wait in Lumovi with the assistant’s reason, the diff, whose fields they’d take over (Helm’s, Argo CD’s…) and the
kubectlcommand, for you to approve, or reject with a note the assistant reads. A notification says when one’s waiting; unanswered, it ends after five minutes, and the assistant keeps waiting for your answer withwait_for_change. See Approving changes. - Made as you saw it. Once you approve a change, Lumovi tries it again, and makes it only if it still does what the diff showed; a deletion is only ever of the object you saw. Approving the deletion of a namespace, a node or another object that’s hard to get back, or anything in a cluster named like production, asks for its name, as Lumovi’s own Delete does.
- Each cluster decides whether its assistants’ changes are asked about, made without asking (deletions, and changes that take fields over from others, still ask), or never made. Read-only clusters and your own RBAC always apply. The Activity log shows each change, and which assistant asked.
- Set up in a click. AI assistants, at the bottom of the sidebar, in the command palette or under View, turns it on and adds Lumovi to Claude Desktop, Cursor and VS Code, or gives Claude Code a command to paste. Claude Desktop starts Lumovi when it isn’t running.
- Only on this computer. Lumovi listens on
127.0.0.1, for assistants with its token, kept in settings only you can read on macOS and Linux, and refuses web pages. It calls no AI service, and needs no API key. See AI assistants.
Changed
- Right-sizing on big clusters. It asks Prometheus about many namespaces at once, up to a thousand containers’ worth, biggest first, instead of one namespace at a time: a cluster of thousands of namespaces takes dozens of queries. A batch Prometheus finds too big is asked about in halves. What’s measured shows while the rest is, and the workloads come 50 a page. See Big clusters.
Hands on: shells on nodes, and terminals
A shell on any node, as root, through a pod Lumovi starts and deletes again. And on the desktop, terminals on your computer, with kubectl already pointed at the cluster you’re looking at.Shells on nodes
- A node’s Shell tab starts a privileged pod on it and opens a shell on the node itself, as root in its own namespaces, or in the pod, with the node’s files under
/host. The pod is deleted when the shell ends. See Shells on nodes. - It says what it will do, before anything starts, shows each step as it happens, and says what went wrong in words that say what to do: a namespace whose Pod Security doesn’t allow privileged pods, an image the node can’t pull or without
nsenter, a node with no shell of its own (Talos, Bottlerocket). - Your RBAC decides, as with
kubectl debug node. Where the pods run and their image are settings for each cluster. In your cluster, the chart’snodeShellvalues set them for everyone, or turn node shells off. See Helm values.
Terminals on this computer
- A dock of terminals, in the desktop app, along the bottom of every cluster’s pages. Open it from the Terminal bar, with ⌃`, View → Terminal, or New terminal in the command palette, and another with ⌃⇧`. See Terminals.
- Your own shell, pointed at the cluster. Each tab is your shell, with kubectl, helm and the rest pointed at a cluster and namespace, in that terminal only. A kubeconfig of Lumovi’s comes first in
KUBECONFIGand only names them, so your credentials stay in your files. - A terminal’s keys. Tabs can be renamed. In a terminal on macOS, ⌘T (or ⌘N) opens another, ⌘W closes one, ⌘K clears it, and ⌘⇧[ and ⌘⇧] move between them; on Windows and Linux, Ctrl⇧T, Ctrl⇧W and CtrlPgUp / CtrlPgDn. See Keyboard shortcuts.
- Paste in terminal. Every action’s equivalent command can be typed into a terminal, on one line, to read, change and run with ↵. See The equivalent command.
- Icons in your prompt. Nerd Fonts’ symbols come with the app, so prompts like Starship’s show their icons without a font to install.
Fleet: many clusters in one Lumovi
One Lumovi can now show your team many clusters in a browser, private ones too. It runs in a cluster, or without Kubernetes, on a machine of its own or a platform like Sevalla. This release also fixes five things, on the desktop and in your cluster.Fleet
- Every cluster on one page. Lumovi’s home page sums up each cluster as its overview would: nodes, pods, workloads, warnings, CPU and memory, its version and how fast it answers. What needs attention comes first, and a cluster that can’t be reached says why. Filter by status and labels, group by a label, and find a workload by name or namespace in every cluster. The cluster switcher and the command palette move between clusters, and back to all of them. See Clusters in a fleet.
- Each person’s own RBAC. People sign in once, with single sign-on or through a proxy. Lumovi impersonates them in each cluster, or passes their own token on to clusters that trust your identity provider. See A fleet of clusters.
- Where clusters come from. A kubeconfig, in a setting (
LUMOVI_FLEET_KUBECONFIG, as YAML or base64 on one line) or in files read again as they change; Secrets of the cluster Lumovi runs in, its own, Cluster API’s and Argo CD’s; and that cluster itself. A context’slumovi.devextension, or a Secret’s annotations, give a cluster labels, the groups who see it, and whether people’s own tokens are passed on. - Agents for private clusters. For a cluster Lumovi can’t reach, an agent in it dials out to Lumovi over a WebSocket, and relays its connections to the API server. TLS runs from Lumovi to the API server through it, so the agent passes on only what it can’t read. It reconnects by itself, also when its connection goes quiet, and passes on its service account’s new token when Kubernetes rotates it.
- The Helm chart installs a fleet (its
fleetvalues), what a cluster needs to join one (mode: member: a service account that may only impersonate, and its token, with the kubeconfig entry printed after installing), or an agent (mode: agent). - Without Kubernetes. On platforms that set
PORT, like Sevalla, Lumovi listens on it unlessLUMOVI_PORTis set, and takes every setting from the environment. - To try it from source,
npm run dev:server -- --fleetserves a fleet of the demo clusters, signed in to with a mock single sign-on. See Build from source.
Fixed
- Views from the Helm chart are used. Kubernetes mounts the chart’s
viewsvalue as links, which Lumovi left out. A view file that can’t be read is now listed as a problem, and the rest load. - The Map shows other namespaces’ gateways and services. A Gateway or a Service in another namespace that a route refers to, like a shared gateway, no longer says Not found. It’s shown without a status, and opens.
- Right-sizing loads without VerticalPodAutoscalers or nodes. When the Vertical Pod Autoscaler is installed but your account can’t list its autoscalers, the page loads, and says what that means. It also loads for accounts that can’t list nodes.
- Esc closes a Helm release’s panel, as its close button says. See Helm releases.
- The distribution on Usage history counts in the singular when it should: “1 namespace”, not “1 namespaces”.
The first version of Lumovi
Lumovi is the Kubernetes dashboard that was called KubeStacks. This first version under its new name has everything KubeStacks had. Coming from KubeStacks? See the FAQ for what doesn’t carry over.Two ways to run it
- On your desktop. An app for macOS, Windows and Linux that opens every cluster in your kubeconfig, with client certificates, tokens and credential plugins found on your login shell’s
PATH. It updates itself: new versions download in the background and install when you restart or quit. Help → Check for Updates… looks right away. - In your cluster. A container image,
ghcr.io/lumovi/lumoviforlinux/amd64andlinux/arm64, and a Helm chart serve the same app as a dashboard your team opens in a browser. People sign in with a token the cluster accepts, with single sign-on (OpenID Connect), or through an authenticating proxy, and see and change what their own RBAC allows. Every page has an address you can share.
Seeing what’s going on
- Overview with node, pod, workload and warning health, CPU and memory against capacity, and what needs attention.
- Lists for every kind, with health, sorting, filters and label selectors. Big lists load in chunks and stop at 5,000 objects, so huge clusters stay fast.
- Workloads of every kind in one list, pods that nothing manages included, with status, ready pods, autoscaler ranges and usage.
- A detail panel next to the list, with kind-specific facts, containers, conditions, events, logs and YAML. Secret values stay hidden until revealed.
- Map, a tab on every object: what leads to it, from gateways and ingresses to services, and what it owns, uses and runs on, down to the nodes. What’s missing, and what nothing uses, stands out.
- Logs streamed as they’re written, one pod’s or every pod’s of a workload merged by time, with search and filters.
- Usage history from Prometheus or VictoriaMetrics, found for you: a Metrics page that ranks namespaces, workloads, pods and nodes, and a Metrics tab on pods, workloads and nodes.
- Right-sizing, a tab of Metrics: what each Deployment, StatefulSet and DaemonSet should request, from a week of its usage, and why. A recommendation is applied once the API server has checked it, with undo.
- Helm releases, read from where Helm 3 and 4 keep them, with values, the objects they made, notes and diffs between revisions.
Custom resources, views and add-ons
- Every kind the cluster serves, found through API discovery, with the columns
kubectl getprints and a status read from their conditions. - Views describe a kind’s columns, status, details, links, related objects and actions as data. Lumovi ships its own, and yours in
~/.lumovi/viewsadd to them or replace them. - Add-ons give each tool the cluster runs an entry in the sidebar, with everything of its kinds in one list, failing first. Lumovi has add-ons for 32 tools, from Argo CD, cert-manager and Flux to Istio, KEDA and Velero.
- Karpenter’s add-on opens on an overview: node pools against their limits, the nodes they launched, what’s being disrupted and why, and the pods waiting for a node.
Changing things
- Actions to scale, restart, change images, roll back, pause and resume rollouts, run CronJobs, suspend and resume, cordon, uncordon and drain, evict and force-delete, change autoscaler ranges, expand volumes, and edit labels, annotations and YAML.
- Shells and debug containers, and port forwards on the desktop.
- Helm upgrades and installs, reviewed as a server-side dry run first, and rollbacks and uninstalls, all with your own
helm. - Bulk actions with progress per object and a retry for failures, and create from YAML with templates, checked by the cluster before anything is created.
- Guard rails: permission checks, the
kubectlcommand in every dialog, typed confirmation for risky deletes, undo, an activity log and read-only mode.
Around the app
- A command palette, keyboard shortcuts, a native menu with the same commands, and light and dark themes.
- Calm errors: a banner when a cluster stops responding, the last data kept on screen, and error pages with details to copy or report.