What it connects to
TelemetryNone
AccountsNone
CredentialsStay on your computer
LicenseApache 2.0
- The clusters in your kubeconfig, and those you add in Lumovi, with their credentials. Checking a cluster you’re adding asks its server for its version, with no credentials, before anything else.
- The Prometheus or VictoriaMetrics you use for usage history, reached through the cluster’s API server with your own credentials. Nothing is port-forwarded or exposed for it.
- Artifact Hub, only when you search it for a chart to install.
- The chart repositories and registries you choose, when you upgrade or install a Helm release from one.
- GitHub, to look for new versions of Lumovi. Help → Check for Updates Automatically turns that off.
- GitHub, for newer plugins: only when you open All plugins, or press Check now there, and when you install or update one. It asks for the latest release of Lumovi-plugins and its files, from
github.comand GitHub’s downloads, and sends nothing about you or your clusters. A policy can turn it off (pluginStore: off). - dl.k8s.io, Kubernetes’ own downloads, when you open a terminal, for a kubectl that matches its cluster. It asks which patch of the cluster’s minor version is newest, like 1.34, and downloads that kubectl for your system and architecture, once, with the checksum, signature and certificate published beside it, from dl.k8s.io too: checking the signature asks no one else. So dl.k8s.io learns your address, the minor versions of the clusters you open terminals for, your system and architecture, and when you open them: no cluster’s name or address. It goes through the same proxy and certificate authorities as Lumovi’s other connections. It’s on by default: View → Match kubectl to Each Cluster turns it off, as can your organization’s policy, which can also name a mirror, over
https, instead. - GitHub’s
raw.githubusercontent.com, for the sidebar’s sponsor card: 3 seconds after Lumovi starts, then every hour. It sends nothing but the request, and can’t be turned off.
The sponsor card
The sidebar has one card above its footer, under the label Sponsor: Lumovi’s own, “Help keep Lumovi free.”, which leads to Lumovi’s GitHub Sponsors page, a sponsor’s, or none. Which one is insponsor.json, in the public Lumovi/main-sponsor repository, so it changes without a release. Lumovi reads it from its main branch, at https://raw.githubusercontent.com/Lumovi/main-sponsor/refs/heads/main/: the desktop app 3 seconds after it starts, and a server, or a fleet’s hub, as it starts; then every hour. There’s no switch to turn it off.
- Nothing is sent but the request: a plain
GETofsponsor.json, and of the two pictures it names, by Lumovi itself, not the page. No cookies, no credentials, no referrer, nothing about you or your clusters, and no header of Lumovi’s own: only those Node’sfetchsends by itself,Accept: */*,Accept-Language: *,Accept-Encoding,Sec-Fetch-Mode: corsandUser-Agent: node. A picture read before is asked for with theETagGitHub gave it, inIf-None-Match, so an unchanged one isn’t downloaded again. So GitHub learns your address, and when Lumovi asked, as for any download. Lumovi counts nothing: no views, no clicks. - It goes the way Lumovi’s other connections go: through the proxy and with the certificate authorities they use. It follows no redirect, and stops reading past 16 KB for
sponsor.jsonand 500 KB for a picture. - What it gets is checked before it’s shown, in Lumovi itself, and again by the repository’s own check on every change:
sponsor.jsonmust have only the fields it may, the words must be one line of plain text, short, with no emoji, links, or control or invisible characters, the link anhttpsaddress on a domain, with no user or password in it. The pictures must be PNG, GIF or WebP by what they are, not their name, exactly 408 × 136, up to 150 KB, or 500 KB for an animated one, which must play once, for 5 seconds at most. - It’s shown from Lumovi’s own copy: the page gets the pictures from Lumovi, and fetches nothing. One for light mode and one for dark; an animated one plays once, and shows only its first frame, still, to people who ask their system for less motion. Pointed at, or reached with the keyboard, the card shows the link’s domain. It opens in your browser, which tells the sponsor nothing of where it came from. Under 720 pixels tall, the window leaves the card out.
- Who decides it: Lumovi’s maintainers, by a pull request to Lumovi/main-sponsor that its check must pass, and no one can push to its main branch, or make, move or delete a tag; every change is in its public history. The card isn’t signed: whoever can write to that repository, the maintainer’s GitHub account or a token with write access to it, changes what every Lumovi shows within the hour, with no release of the app. What they can show is only what Lumovi checks for: a 408 × 136 picture, one for light mode and one for dark, one line of checked words, and an
httpslink, shown with its domain and opened in your browser; never anything that runs. Its pictures are drawn by the app’s page, which is sandboxed, as any picture on a web page is: keeping Lumovi up to date keeps what draws them current. - When it can’t be had, the card stays what Lumovi read last, or, with nothing read, is Lumovi’s own, and Lumovi tries again in 5 minutes. An answer that doesn’t pass shows Lumovi’s own card, and so do a sponsor’s card past its last day and pictures the page can’t draw within 3 seconds. Lumovi never shows an error, an empty card or a wait for it.
sponsor/kept.json, in its folder for app data, and checks it again as it starts, so the card is there at once. A server keeps it in memory.
AI assistants on this computer can connect to the desktop app, once you turn them on: Lumovi listens for them on 127.0.0.1, and answers only those that send its token. It doesn’t connect to any AI service itself, and needs no API key. What an assistant reads through Lumovi, it handles as it handles everything else you show it, which for most means sending it to their AI provider. See Security.
Your credentials
Kubeconfig credentials stay in the app’s main process: tokens, client keys and the output of credential plugins. Every request to a cluster is made by the main process, after it checks what the page, or an assistant, asked for. AI assistants never have them. The page you see doesn’t hold them either, but for a kubeconfig you paste or import to add a cluster, while you add it: editing one later, it shows(kept by Lumovi) in their place. That keeps them off your screen, and out of a screen share. Before a cluster’s credentials run a program, send a file, go to a server that isn’t verified, or go somewhere you moved it, the page asks you, and the main process waits for your answer. That protects you from a kubeconfig that does more than it says.
Neither is a wall against the page itself. The page can open a terminal, which is your own shell, so a page that had been compromised could read your files and run what you can, as any program running as you could. What keeps the page from being compromised is how it’s built: see below.
Lumovi reads your kubeconfig and never changes it, or any other file it reads. A cluster you add in Lumovi is kept in a file of its own, in Lumovi’s folder. Signing in to a cloud provider is left to the tools made for it.
A terminal gets a kubeconfig of its own that names the cluster and namespace, and no credentials: kubectl there finds those in your files, as in any terminal.
How the app is built
- The page is sandboxed. It runs with context isolation, no Node.js integration and a strict Content Security Policy. It can’t navigate away or open new windows.
- Every request is checked. The main process only answers calls from the app’s own page, and validates every argument.
- Terminals run in the main process. A terminal’s shell is started by the main process, on your computer and as you, like any terminal app’s. The page shows what it prints, and passes on what you type.
- No browser permissions. The page can’t use the camera, notifications or anything else a website could ask for. It can only copy to the clipboard.
- Changes go through a small set of operations. Each is checked against what you’ve made read-only, and refused for those clusters, or for all of them with
LUMOVI_READ_ONLY, or for those your organization’s policy makes read-only. See Read-only mode. - Plugins’ code runs in a box of its own. The pages a plugin draws with its code run in a sealed process of their own, apart from the app’s page, with no network, no Node.js, and none of Lumovi’s storage or credentials. Its code is handed only what its file says it may read, read by the main process as you, and any change it proposes waits for you in Lumovi’s own dialog. Run its code turns a plugin’s code off, and your organization’s policy can too.
- Links are limited. Only
https://links, andhttp://localhost:<port>for your own port forwards, are handed to the operating system. Besides those, Add to Cursor and Add to VS Code hand it Cursor’s and VS Code’s own links to add Lumovi, with its address and token in them. - The stdio bridge makes sure it’s Lumovi before it sends Lumovi’s token. An assistant that starts Lumovi as a program, as Claude Desktop does, talks to it through this bridge. Before every request, it sends a random challenge, and sends the token only when what listens on Lumovi’s port answers with the challenge’s HMAC-SHA256, keyed with the token, which only Lumovi can make. Something else listening there while Lumovi isn’t running gets nothing, and the bridge doesn’t start Lumovi over it.
- On Windows, Lumovi’s program can also run as Node.js. An assistant that starts Lumovi as a program talks to it over its standard input, and a Windows app’s own process can’t read that, so Lumovi starts the bridge with its own program in Node.js’s place (
ELECTRON_RUN_AS_NODE=1). The same is open to any program on the computer: it can run a script of its own with Lumovi’s signed program, and a list of allowed programs that trusts Lumovi’s signature won’t tell the two apart. It gives that script nothing of Lumovi’s that you don’t already have: it runs as you, outside the app. On macOS and Linux, Lumovi’s program can’t run as Node.js. - AI assistants connect only from this computer, and only once you turn them on: on
127.0.0.1, with Lumovi’s token. Requests from web pages are refused, and so are requests addressed to any name but127.0.0.1orlocalhost, and messages over 4 MB. Each change they ask for goes through the same operations as yours, and waits for you. See AI assistants. - Updates are verified. New versions come from the project’s GitHub releases over HTTPS. Each download is checked against the SHA-512 checksum the release lists, and the new version must be signed as this one is: on macOS with the same Developer ID, and on Windows by Open Source Developer Péter Kóta.
What’s checked, and what isn’t
A terminal’s kubectl is checked against Kubernetes’ own signature, on your computer. Kubernetes signs each kubectl in its release, with a certificate Sigstore’s certificate authority, Fulcio, gives it for those few minutes. Lumovi ships Sigstore’s public trust root, and checks against it:- When the certificate was issued, by the timestamp a certificate transparency log Sigstore runs signed for it, and that the certificate was valid then.
- That it’s from Sigstore’s certificate authority, through its chain to Fulcio’s root.
- That it’s Kubernetes’ release’s: issued to
krel-staging@k8s-releng-prod.iam.gserviceaccount.com, signed in withhttps://accounts.google.com, exactly, as Kubernetes’ instructions for checking its signatures name them. - That it’s for signing code, as Fulcio’s certificates are.
- That its key signed these very bytes.
- When it was signed. Only Sigstore’s transparency log, Rekor, knows that, and asking it would be one more place that learns what you download. So a signature made later, with that certificate’s key, would pass: the key is the release’s own, for those minutes.
- Kubernetes’ own release process. A signature says Kubernetes’ release made the kubectl, not that nothing went wrong there.
On your organization’s computers
A company rolling Lumovi out can set what it does on every computer, in a policy only an administrator can write: clusters read-only, AI assistants off or limited, updates left to IT, the mirror terminals get kubectl from, and whether it must be signed, whether people may choose the kubeconfig files Lumovi reads, and the proxy and certificate authorities to use. What it sets is locked in the app, which says so: “Set by your organization”. Lumovi reads the policy as it starts, and saves none of it over your settings. It sets what Lumovi does, and isn’t a wall against you: your kubeconfig’s credentials work withkubectl too, and what you may do in a cluster is its RBAC’s to say.
Secrets on screen
Lumovi is careful with what it shows:- Lists of Secrets carry only the names of their keys. Values are blanked before they reach the page.
- Values stay hidden until you reveal them. An open Secret shows each key with its size, and
••••••••for its value. Reveal one key, or all of them, when you need to. Copying a value works without revealing it. - The YAML is hidden too. The YAML tab hides values until you choose Reveal values, and so does the
last-applied-configurationannotation, which holds a copy of them. - AI assistants get what you let them. By default, they read a Secret’s keys, with
(hidden by Lumovi)for each value, and nothing of thelast-applied-configurationannotation. Your AI permissions can show them the values somewhere, or hide Secrets altogether. See What’s hidden.
What it keeps on your computer
The desktop app keeps these on your computer, and none of it leaves it:- Settings, in
settings.json: your theme, the window’s size and place, the kubeconfig files and folders you chose or added for it to read (where they are, not what’s in them), what you allowed a folder’s kubeconfig to do (as digests, not the commands or files themselves), each cluster’s settings (its name, color, group, labels and namespace, whether it’s production or hidden, and whether it notifies you of new warnings, in which namespaces), which clusters you made read-only, where each one’s usage history comes from, the namespace and image of its node shells, whether Lumovi looks for new versions by itself, whether terminals get a kubectl to match their cluster, and which plugins’ code you turned off. For AI assistants: whether they may connect, the port and the token, what they may do, and how Lumovi was last started, for the stdio bridge to start it the same way. On macOS and Linux, only your account can readsettings.json: Lumovi sets that each time it writes the file. - Clusters you added, in the
clustersfolder: each a kubeconfig of its own, with its credentials, named after the cluster, likepayments-us.yaml. On macOS and Linux, only your account can read the folder and its files. - The key for what you allowed, in
consent.key: 32 random bytes that make the digests of what a folder’s kubeconfig may do, so that a digest written intosettings.jsonfrom elsewhere (copied from another computer, say) doesn’t count, and Lumovi asks again. Only your account can read it. One that’s a link, the wrong size, or readable by anyone else is replaced, and everything allowed is asked again. It doesn’t stand against a program already running as you, which can read it as Lumovi does. - The audit log, in the
auditfolder: what was done through Lumovi, a file a day (audit-2026-10-06.jsonl), each kept for 90 days. Each event names your computer’s account, the kubeconfig user Lumovi used, the cluster, the object and the command: never a Secret’s values, what a change set, Helm values, or tokens. On macOS and Linux, only your account can read the folder and its files: Lumovi makes them so as it starts. If the folder can’t be used, it keeps the log in memory until it quits, and the Audit log page says why. - kubectl, in the
kubectlfolder: each one Lumovi downloaded for terminals, in a folder named for its version, likekubectl/v1.34.9. As Lumovi starts, it keeps only the newest patch of each minor version, and the newest signed one where that came from a mirror without a signature. Beside each, a file,signedorunsigned, says how it was checked, where it came from, and the kubectl’s SHA-256. Beside them,clusters.jsonremembers each cluster’s minor version, by its context’s name, like"prod": "1.34", so a cluster that can’t be reached still gets its kubectl. - Conveniences the page remembers: the namespace you picked per cluster, your recent clusters, the kinds you pinned to the sidebar, the objects you pinned and the views you saved in each cluster, the custom resources you opened last, the detail panel’s width, the terminal dock’s height, the time range metrics charts open with, and which chart on your computer each Helm release was last deployed from.
- Plugins you installed, in
plugins/installed: each plugin’s files, and the version before it, to go back to. Your settings keep each one’s SHA-256 and what you agreed to, checked each time Lumovi reads them. - The sponsor card read last, in
sponsor/kept.json:sponsor.json, and its pictures.
Lumovi also reads your own plugins from
~/.lumovi/plugins, or the folder LUMOVI_PLUGINS_DIR names. It never writes there. When you upgrade or install a Helm release, the values go to helm in a temporary folder, which Lumovi deletes as soon as helm is done.
Each terminal gets a small kubeconfig, in a folder of its own in the system’s temporary folder, named lumovi-terminal-, the app’s process ID, and six random characters. It holds the context’s name, its cluster’s and user’s names, and the namespace: no addresses, and no credentials. On macOS and Linux, only you can read it. Lumovi deletes it when the terminal’s shell ends: when the shell exits, when you close its tab, and when you quit. If Lumovi doesn’t get to quit, because it crashed or was killed, it deletes what’s left the next time it starts.
The activity log of the changes you made lives in memory, and is gone when you quit. The audit log is what stays.
Lumovi changes another app’s files in one case: Add to Claude Desktop adds Lumovi to Claude Desktop’s settings, claude_desktop_config.json, or updates its entry there, and leaves the rest of the file as it was. It writes the file whole, through a copy it puts in its place, so it’s never left half-written. When Claude Desktop then starts Lumovi to talk to it, that Lumovi keeps what it needs in a folder of its own, lumovi-mcp-stdio, in the system’s temporary folder. See Connect an assistant.