Skip to main content
Lumovi has no telemetry and no accounts. It doesn’t send anything about you or your clusters anywhere you didn’t ask it to.

What it connects to

TelemetryNone
AccountsNone
CredentialsStay on your computer
LicenseApache 2.0
The desktop app talks to:
  • 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.com and 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.
Behind a company’s proxy, it reaches them through the proxy your shell uses, and trusts the certificate authorities your computer does: see Proxies and certificates. That’s all. Links to anything else, like a release’s notes, open in your browser. Fonts come with the app, the icons of terminals’ prompts included, so nothing is downloaded for them. What you run in a terminal is yours: it connects wherever it would in any other terminal.

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 in sponsor.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 GET of sponsor.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’s fetch sends by itself, Accept: */*, Accept-Language: *, Accept-Encoding, Sec-Fetch-Mode: cors and User-Agent: node. A picture read before is asked for with the ETag GitHub gave it, in If-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.json and 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.json must 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 an https address 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 https link, 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.
The desktop app keeps what it read last in 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, and http://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 but 127.0.0.1 or localhost, 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.
The source is on GitHub, so you can check any of this. Every release’s installers come with checksums, signed build provenance, and an attested bill of materials, which lists the helm the app ships with and the Go modules it’s built from: see Verify your download.

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 with https://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.
What isn’t checked:
  • 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.
Nothing is asked of anyone else for it: the signature and certificate come from where the kubectl does, and the trust root ships with Lumovi. It’s taken through Sigstore’s TUF repository, as Sigstore’s own clients take it: used only once Sigstore’s signed metadata says it’s the one Sigstore published. Each week, Lumovi’s repository takes it again, and proposes the new one for a release when Sigstore has changed it, and checks that Kubernetes’ instructions still name the signer above. When Sigstore changes its certificate authority or its logs, or Kubernetes how it signs, a kubectl signed after that change can’t be checked until a release of Lumovi knows the new ones: until then, terminals use your kubectl, or the newest one kept, and say Lumovi needs an update. See When it can’t have one.

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 with kubectl 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-configuration annotation, 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 the last-applied-configuration annotation. Your AI permissions can show them the values somewhere, or hide Secrets altogether. See What’s hidden.
See Config and storage for how Secrets are shown and edited.

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 read settings.json: Lumovi sets that each time it writes the file.
  • Clusters you added, in the clusters folder: each a kubeconfig of its own, with its credentials, named after the cluster, like payments-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 into settings.json from 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 audit folder: 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 kubectl folder: each one Lumovi downloaded for terminals, in a folder named for its version, like kubectl/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, signed or unsigned, says how it was checked, where it came from, and the kubectl’s SHA-256. Beside them, clusters.json remembers 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.
They live in Lumovi’s folder for app data: 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.

In your cluster

When Lumovi runs in a cluster for a team, people sign in, and it acts with their own permissions. That has its own model: how sign-in works, what its service account may do, and how to keep it locked down. See Security. It keeps an audit log for the team, on a volume, which its auditors read: see Audit log for your team. Its admins can let people do less through it than their RBAC allows: see Access for your team. AI assistants sign in to it through Lumovi too, with tokens it keeps in memory: see AI assistants for your team. A server, and a fleet’s hub, read the sponsor card too, as they start and every hour, for the pages they serve. Without a way out to GitHub, they show Lumovi’s own card. A fleet’s Lumovi, for many clusters, also holds credentials for each of them, which should allow nothing but impersonating people, and clusters it can’t reach connect to it through their agents. See the fleet’s security.

Reporting a vulnerability

Please report vulnerabilities privately, by email to security@lumovi.dev, through a GitHub security advisory, or as the security policy describes. Please don’t open a public issue. Include what you found, how to reproduce it, and the impact you expect. You’ll get an acknowledgement within a few days. Security fixes go into the latest release.