refactor: one place for Key Vault collections and paging in the providers

- ObjectType.Collection names a type's segment in Key Vault URLs and links (secrets, keys, certificates), instead of four copies in ref, azure and fake.
- Azure lists through one pager helper instead of eight hand-written page loops; Value is VersionedValue without the version, rather than the two calling each other.
- Databricks' Key Vault fallback check lives in fallbackVault.
- The repo provider reads .lazysecrets.yaml in one place, builds plain and sops objects in one loop, and parses a file's sops metadata from the bytes Objects already read.

CHANGELOG.md

@@ -2,12 +2,6 @@
 
 Every release of lazysecrets, newest first.
 
-## v0.2.1 – 2026-10-15
-
-### Fixed
-
-- A link opens lazysecrets with your cache and next to your running instances ([#71](https://git.kebcloud.no/keb/lazysecrets/pulls/71)) ([bb41767](https://git.kebcloud.no/keb/lazysecrets/commit/bb41767cbad00bab4f1824f4e0754cc7abd98c59))
-
 ## v0.2.0 – 2026-10-14
 
 ### Added

README.md

@@ -23,7 +23,7 @@ A terminal UI for finding, reading and sharing secrets. Inspired by the fantasti
 - **Your way**: rebind any key, pick a theme, and add custom commands to run
   on a secret.
 - **Try it first**: `lazysecrets --demo` runs on built-in sample data.
-- **Sources**: Azure Key Vault, Databricks secret scopes, and SOPS, `.env` and Spring Boot config files in your git repos.
+- **Sources**: Azure Key Vault, Databricks secret scopes, and SOPS and `.env` files in your git repos.
 
 > **Early development:** expect rough edges. See [CHANGELOG.md](CHANGELOG.md) for what's new.
 
@@ -87,7 +87,7 @@ pickers and scripts: see [Integration](docs/integration.md#an-fzf-picker).
 - [Keys](docs/keys.md): every key, Go to, the layout, and rebinding keys
 - [Azure Key Vault](docs/azure.md): accounts, permissions, pinned vaults
 - [Databricks](docs/databricks.md): profiles and Key Vault-backed scopes
-- [SOPS, .env and Spring files](docs/repos.md): which repos and files, decrypting
+- [SOPS and .env files](docs/repos.md): which repos and files, decrypting
 - [Sharing](docs/sharing.md): links to secrets, encrypted env files, and
   opening links, also from the browser and chat
 - [Integration](docs/integration.md): how lazysecrets can integrate into other systems

cmd/lazysecrets/list.go

@@ -57,7 +57,6 @@ func listCmd(providers []provider.Provider, st *store.Store, cachePath string, t
 	expiry := fs.Bool("expiry", true, "mark and say which have expired (✗ expired) or expire within ui.expiryWarningDays (⚠ expires in 12d) (text)")
 	kinds := fs.String("kind", "", "only these kinds, comma-separated: "+strings.Join(listing.Kinds, ", ")+" (vault: also scopes and repo files)")
 	showErrors := fs.Bool("errors", true, "list the lists that can't be read, with why (text: ✗ lines; json: \"error\")")
-	hidden := fs.Bool("hidden", false, "list what's hidden too, as H does in the TUI: Spring config keys that don't look secret, and files and repos with only those (json: \"hidden\")")
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
@@ -130,7 +129,7 @@ func listCmd(providers []provider.Provider, st *store.Store, cachePath string, t
 		f = cachefile.Read(cachePath)
 	}
 	f, loaded := listing.Run(context.Background(), listing.Options{
-		Providers: providers, Cache: f, MaxAge: *maxAge, Cached: *cached, Kinds: only, Timeout: timeout, Hidden: *hidden,
+		Providers: providers, Cache: f, MaxAge: *maxAge, Cached: *cached, Kinds: only, Timeout: timeout,
 		Mark: func(link, account string) listing.Marks {
 			n := st.Node(link)
 			return listing.Marks{Starred: n.StarredFor(account), Recent: n.UsedLately(now),

cmd/lazysecrets/main.go

@@ -347,7 +347,6 @@ Flags:
 			repos := repo.New(repo.Settings{
 				Dir: startDir, Paths: pc.Repos.Paths, Roots: valueOr(pc.Repos.Roots, repo.DefaultRoots),
 				Starred: starredRepos(st), Include: pc.Repos.Include, Exclude: pc.Repos.Exclude,
-				SecretPatterns: pc.Repos.SecretPatterns, Types: map[string]repo.FileType{"spring": pc.Repos.Spring},
 			})
 			// The repo it started in (shown on top as Repo) and the
 			// others, checked for secret files in the background like

docs/config.md

@@ -74,7 +74,6 @@ theme:
   azureColor: ["#82aaff"]
   databricksColor: ["#ff757f"]
   repoColor: ["#c099ff"]
-  springColor: ["#c3e88d"]               # Spring Boot config files
 ```
 
 A role lazysecrets doesn't know, a typo or one from a newer version, is

docs/integration.md

@@ -51,7 +51,6 @@ so `^prod` finds names starting with prod.
 | `--cached` | only what's cached, at once: nothing is loaded from Azure or Databricks |
 | `--max-age 2m` | load cached lists older than this again |
 | `--errors=false` | leave out the vaults and sources it couldn't read |
-| `--hidden` | list what's [hidden](repos.md#spring-boot-config) too, as `H` shows it (json: `"hidden": true`) |
 | `--color never` | no colours, for scripts |
 | `--icons=false` | no provider icons |
 | `--stars=false` | no ★ before starred names (in `favouriteColor`) |

docs/keys.md

@@ -20,7 +20,6 @@ The rule: a letter in the lists, ctrl+ that letter where you type a filter
 | `[` / `]` | previous / next tab of the focused pane: Sources and Favourites in Sources; Secrets, Keys, Certs in Secrets |
 | `/` | filter the focused list by name or note ([how it matches](#searching)); `enter` keeps it, `esc` clears it. While typing: `ctrl+j`/`ctrl+k` move, `ctrl+y` copies, `ctrl+r` reveals, `ctrl+f` stars |
 | `` ` `` | switch the Sources pane between grouped by provider and a flat list; `enter`/`space` on a provider folds it |
-| `H` | show / hide what's hidden: [Spring keys](repos.md#spring-boot-config) that don't look secret, and files and repos with only those; shown dimmed |
 | `r` | refresh the focused pane |
 | `q`, `ctrl+c` | quit |
 
@@ -54,7 +53,7 @@ match case exactly.
 | `Y` | copy the reference (`@Microsoft.KeyVault(...)`, key/certificate URL, `{{secrets/scope/key}}`) |
 | `v` | versions of the selected item (Azure); `space`/`y`/`Y` then act on that version; `esc`, `⌫` or `v` to go back |
 | `o` | open the selected item in the browser (over SSH: copy the link) |
-| `e` | open the selected SOPS, `.env` or Spring file, or a secret's file at its line ([how](repos.md#opening-files)) |
+| `e` | open the selected SOPS or `.env` file, or a secret's file at its line ([how](repos.md#opening-files)) |
 | `s` / `S` | copy a [link](sharing.md) to the selected item / share menu (also env files, [encrypted](sharing.md#sharing-env-files)) |
 | `ctrl+o` | open a link or reference (or just paste one) |
 | `x` | [custom commands](custom-commands.md) |

docs/repos.md

@@ -1,9 +1,9 @@
-# SOPS, .env and Spring files in git repos
+# SOPS and .env files in git repos
 
 lazysecrets shows git repositories under **Repos**: their
 [SOPS](https://github.com/getsops/sops)-encrypted files (YAML, JSON,
-`.env`, INI), plain env files and [Spring Boot config](#spring-boot-config)
-as vaults, and the keys in them (`db.password`, `list[0]`) as secrets. A dot or bracket inside a key is
+`.env`, INI) and plain env files as vaults, and the keys in them
+(`db.password`, `list[0]`) as secrets. A dot or bracket inside a key is
 escaped, `app\.name`, so it doesn't read as nesting.
 
 ## Which repos
@@ -29,9 +29,8 @@ anything by hand.
 ## Which files
 
 **Env files**: `.env`, `.env.local`, `prod.env` and the like, also when
-git-ignored (as they usually are), in the folders git tracks files in.
-`.env.example`, `.sample`, `.template` and the like are listed hidden
-(`H` shows them): someone may have put a real value in one. They're read
+git-ignored (as they usually are), in the folders git tracks files in;
+not `.env.example`, `.sample`, `.template` and the like. They're read
 directly; a file with SOPS metadata is always treated as SOPS, whatever
 its name.
 
@@ -47,7 +46,7 @@ Folders of dependencies and caches are never looked in, tracked or not:
 3. where the repo's `.sops.yaml` `creation_rules` say SOPS files go,
 4. the whole repo.
 
-`include`/`exclude` apply to env and Spring files too.
+`include`/`exclude` apply to env files too.
 
 ```yaml
 providers:
@@ -66,61 +65,13 @@ sharing:
   key: https://kv-team.vault.azure.net/secrets/env-share   # or its lazysecrets:// link
 ```
 
-## Spring Boot config
-
-`application.yml`, `application-prod.properties`, `bootstrap.yaml` and the
-like, tracked by git (not those in a Helm chart's `templates/`). Most of
-their keys aren't secret, so only those that look like one are listed; the
-rest are hidden:
-
-- **keys** named like a secret: ending in `password`, `pwd`, `secret`,
-  `token`, `key`, `credentials`, `salt`, `connection-string` and the
-  like (`spring.datasource.password`, `client-secret`, `checkoutKey`),
-- **values** that look like one: Jasypt's `ENC(...)`, a URL with a
-  password (`jdbc:postgresql://app:pw@db/app`), or a connection string
-  with `AccountKey=`, `SharedAccessKey=` or `Password=`.
-
-A file with none is hidden too, and a repo with only such files. `H` shows
-what's hidden, dimmed, in the panes and in Go to (`lazysecrets list
---hidden` lists it); a pane's counter says how many it hides. A file's
-details count its hidden keys, and `e` opens it whole. A `${DB_PASSWORD}`
-value is marked as a reference: the secret is set elsewhere. A tracked
-file is marked in red only when a listed key has its value in plain text.
-
-The patterns are regexps, for all of a repo's config files and per type of
-file; each list replaces the one it falls back to, and `keys: [".*"]`
-lists every key:
-
-```yaml
-providers:
-  repos:
-    secretPatterns:                             # all config files
-      keys: ["(?i)(password|secret|token|key)$"]  # matched against the key's name
-      values: ["^ENC\\(.+\\)$"]                   # and against its value
-    spring:
-      secretPatterns:                           # Spring's: only what differs
-        keys: ["(?i)(password|secret)$", "bearer$"]
-```
-
-A repo's `.lazysecrets.yaml` can set them too, the same way
-(`secretPatterns:`, `spring: secretPatterns:`), for everyone. Each list
-comes from the first that sets it: the repo's for the type, the repo's,
-the config's for the type, the config's, the defaults.
-
-Keys are named as Spring names them, `spring.datasource.password`; in a
-file with several documents (`---`, or `#---` in `.properties`), a later
-document's keys get its profile, `spring.datasource.password (prod)`.
-Values Maven fills in at build time (`@project.version@`) are read as
-they are.
-
 ## Decrypting
 
-Listing never decrypts: SOPS and Jasypt encrypt values only, so keys and
-metadata (encryption, last modified) are read straight from the files.
-Revealing, copying or `lazysecrets get` decrypts one value; SOPS's with
-your `sops` binary, so whatever sops uses works (age keys, Azure Key Vault
-through az, AWS/GCP KMS, PGP). When sops can't decrypt, its whole error
-message is shown.
+Listing never decrypts: SOPS encrypts values only, so keys and metadata
+(encryption, last modified) are read straight from the files. Revealing,
+copying or `lazysecrets get` decrypts one value with your `sops` binary, so
+whatever sops uses works (age keys, Azure Key Vault through az, AWS/GCP
+KMS, PGP). When sops can't decrypt, its whole error message is shown.
 
 On a file, the right pane shows how it's encrypted and the keys it's
 encrypted for (public: age recipients, Key Vault keys, KMS ARNs, PGP
@@ -129,22 +80,6 @@ tracked, ignored or neither, and its last commit. A plain `.env` file that
 git tracks, or that isn't ignored, is marked in red: its values are in the
 repo's history, or easily could be.
 
-### Jasypt
-
-A value like `ENC(...)` in a plain `.env` or Spring file is
-[Jasypt](http://www.jasypt.org)'s, decrypted when it's revealed or copied
-with jasypt-spring-boot's default algorithm (3.0+:
-`PBEWITHHMACSHA512ANDAES_256`). The password is, as in Spring:
-
-1. `$JASYPT_ENCRYPTOR_PASSWORD`,
-2. the file's own: `jasypt.encryptor.password` in a Spring file,
-   `JASYPT_ENCRYPTOR_PASSWORD` in a `.env`; a `${VAR}` (or
-   `${VAR:default}`) in it is read from the environment.
-
-Environment variables are lazysecrets' own: a link opened from the browser
-starts it without your shell's. A `.env` whose values are all Jasypt's
-isn't marked in red.
-
 ## Opening files
 
 `e` opens the selected file, or on a secret, its file at that key's line:

internal/config/config.go

@@ -15,7 +15,6 @@ import (
 	"go.yaml.in/yaml/v3"
 
 	"git.kebcloud.no/keb/lazysecrets/internal/commands"
-	"git.kebcloud.no/keb/lazysecrets/internal/provider/repo"
 	"git.kebcloud.no/keb/lazysecrets/internal/share"
 	"git.kebcloud.no/keb/lazysecrets/internal/update"
 )
@@ -154,10 +153,6 @@ type Repos struct {
 	// a repo's .sops.yaml creation_rules say where to look.
 	Include []string `yaml:"include"`
 	Exclude []string `yaml:"exclude"`
-	// SecretPatterns say which keys of config files are secrets; Spring
-	// overrides them for Spring Boot's, list by list.
-	SecretPatterns repo.SecretPatterns `yaml:"secretPatterns"`
-	Spring         repo.FileType       `yaml:"spring"`
 }
 
 type Azure struct {
@@ -297,10 +292,6 @@ func (c Config) validate(path string) error {
 			return fmt.Errorf("%s: %s: %s is negative", path, name, d)
 		}
 	}
-	if err := errors.Join(c.Providers.Repos.SecretPatterns.Check("providers.repos.secretPatterns"),
-		c.Providers.Repos.Spring.SecretPatterns.Check("providers.repos.spring.secretPatterns")); err != nil {
-		return fmt.Errorf("%s: %w", path, err)
-	}
 	for i, v := range c.Providers.Azure.Vaults {
 		if !strings.HasPrefix(v, "https://") {
 			return fmt.Errorf("%s: providers.azure.vaults[%d]: %q is not an https:// vault URL", path, i, v)

internal/config/config_test.go

@@ -84,8 +84,6 @@ func TestLoadRejectsMistakes(t *testing.T) {
 		"workspace":  "sharing:\n  key: \"{{secrets/team/env-share}}\"\n",
 		"short keys": "sharing:\n  keyRules:\n    minLength: 8\n",
 		"classes":    "sharing:\n  keyRules:\n    minClasses: 5\n",
-		"regexp":     "providers:\n  repos:\n    secretPatterns:\n      keys: [\"(pass\"]\n",
-		"spring re":  "providers:\n  repos:\n    spring:\n      secretPatterns:\n        values: [\"(\"]\n",
 	} {
 		if _, err := LoadAll([]string{write(t, content)}); err == nil {
 			t.Errorf("%s: no error", name)

internal/jasypt/jasypt.go

@@ -1,67 +0,0 @@
-// Package jasypt decrypts values encrypted with Jasypt the way
-// jasypt-spring-boot 3.0 and later does by default: ENC(...) around the
-// base64 of a random salt, a random IV and the ciphertext, with
-// PBEWITHHMACSHA512ANDAES_256 (PBKDF2-HMAC-SHA512, 1000 iterations,
-// AES-256-CBC).
-package jasypt
-
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/pbkdf2"
-	"crypto/sha512"
-	"encoding/base64"
-	"errors"
-	"strings"
-	"unicode/utf8"
-)
-
-const iterations = 1000
-
-// ErrDecrypt is a value that doesn't decrypt with the password: a wrong
-// password, or one encrypted with another algorithm.
-var ErrDecrypt = errors.New("doesn't decrypt: a wrong password, or not Jasypt's default algorithm (PBEWITHHMACSHA512ANDAES_256)")
-
-// Is reports whether v is a Jasypt value, ENC(...).
-func Is(v string) bool {
-	return len(v) > len("ENC()") && strings.HasPrefix(v, "ENC(") && strings.HasSuffix(v, ")")
-}
-
-// Decrypt decrypts an ENC(...) value.
-func Decrypt(v, password string) (string, error) {
-	b, err := base64.StdEncoding.DecodeString(strings.TrimSuffix(strings.TrimPrefix(v, "ENC("), ")"))
-	if err != nil {
-		return "", errors.New("not Jasypt: ENC(...) isn't base64")
-	}
-	const size = aes.BlockSize // the salt's and the IV's too
-	if len(b) < 3*size || len(b)%size != 0 {
-		return "", ErrDecrypt
-	}
-	salt, iv, data := b[:size], b[size:2*size], b[2*size:]
-	key, err := pbkdf2.Key(sha512.New, password, salt, iterations, 32)
-	if err != nil {
-		return "", err
-	}
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return "", err
-	}
-	plain := make([]byte, len(data))
-	cipher.NewCBCDecrypter(block, iv).CryptBlocks(plain, data)
-	// A wrong password decrypts to noise: its padding is almost never
-	// valid, and the rest rarely UTF-8.
-	n := int(plain[len(plain)-1])
-	if n == 0 || n > size {
-		return "", ErrDecrypt
-	}
-	for _, c := range plain[len(plain)-n:] {
-		if int(c) != n {
-			return "", ErrDecrypt
-		}
-	}
-	plain = plain[:len(plain)-n]
-	if !utf8.Valid(plain) {
-		return "", ErrDecrypt
-	}
-	return string(plain), nil
-}

internal/jasypt/jasypt_test.go

@@ -1,37 +0,0 @@
-package jasypt
-
-import (
-	"errors"
-	"testing"
-)
-
-// Encrypted by Jasypt 1.9.3 itself, set up as jasypt-spring-boot's default
-// encryptor, with the password "test-password".
-var vectors = map[string]string{
-	"ENC(5IQUKT4B7j38TnZJ+BlWqo/zSkKHTjl4XRJyaQEHgkCy4r00avLt4dWqFB74X0Zw)":                         "hunter2",
-	"ENC(w4pm2JVZcbG5R+Ud9uKHg8VhJ/0aAK7sFXtNBv+Vo450SAchTQtfhw0TnIJ9gN+D0VFbwqJzfXU369coTJz2rw==)": "blåbærsyltetøy ✓",
-}
-
-func TestDecrypt(t *testing.T) {
-	for enc, want := range vectors {
-		if !Is(enc) {
-			t.Errorf("%s: not Jasypt", enc)
-		}
-		if got, err := Decrypt(enc, "test-password"); err != nil || got != want {
-			t.Errorf("%s: %q %v, want %q", enc, got, err, want)
-		}
-		if _, err := Decrypt(enc, "wrong"); !errors.Is(err, ErrDecrypt) {
-			t.Errorf("%s with a wrong password: %v", enc, err)
-		}
-	}
-	for _, v := range []string{"ENC(not base64!)", "ENC(aGVsbG8=)"} {
-		if _, err := Decrypt(v, "test-password"); err == nil {
-			t.Errorf("%s: no error", v)
-		}
-	}
-	for _, v := range []string{"ENC()", "hunter2", "ENC[AES256_GCM,data:x]", "${DB_PASSWORD}"} {
-		if Is(v) {
-			t.Errorf("%s: Jasypt", v)
-		}
-	}
-}

internal/listing/listing.go

@@ -56,9 +56,6 @@ type Entry struct {
 	// web page (portal, workspace), if any.
 	Reference string `json:"reference,omitempty"`
 	URL       string `json:"url,omitempty"`
-	// Hidden is left out by its provider's rules (a Spring file's key
-	// that doesn't look secret), listed only with Options.Hidden.
-	Hidden bool `json:"hidden,omitempty"`
 	// Error says why a source's vaults or a vault's secrets couldn't be
 	// listed. The entry is then that source or vault, again, or with an
 	// account's sources unreadable, the account without a link.
@@ -73,8 +70,6 @@ type Options struct {
 	MaxAge time.Duration
 	// Cached lists only what's cached (and repos): nothing is loaded.
 	Cached bool
-	// Hidden lists what providers hide too, as H does in the TUI.
-	Hidden bool
 	// Kinds are the kinds of entry to list (Kinds' names); none is all.
 	// Lists only needed for other kinds aren't loaded: sources and vaults
 	// alone don't load any secrets. Lists that fail are always listed.
@@ -185,9 +180,6 @@ func (l *lister) provider(p provider.Provider) {
 
 // source emits src, and what's cached under it, and queues what's not.
 func (l *lister) source(p provider.Provider, src provider.Source) {
-	if src.Hidden && !l.o.Hidden {
-		return
-	}
 	src.Provider, src.ProviderLabel = p.ID(), p.Label()
 	l.put(p, sourceEntry(src))
 	row := cachefile.Row(p.ID(), src.ID)
@@ -204,9 +196,6 @@ func (l *lister) source(p provider.Provider, src provider.Source) {
 
 func (l *lister) containers(p provider.Provider, src provider.Source, cs []provider.Container) {
 	for _, c := range sorted(cs, func(c provider.Container) string { return c.Name }) {
-		if c.Hidden && !l.o.Hidden {
-			continue
-		}
 		c.Source = src
 		l.put(p, containerEntry(c))
 		for _, t := range c.ObjectTypes() {
@@ -232,17 +221,17 @@ func (l *lister) objects(p provider.Provider, c provider.Container, objs []provi
 	for _, o := range sorted(objs, func(o provider.Object) string { return o.Name }) {
 		o.Container = c
 		r, err := ref.ForObject(o, "")
-		if err != nil || (o.Hidden && !l.o.Hidden) {
+		if err != nil {
 			continue
 		}
 		l.put(p, Entry{Link: r.String(), Kind: strings.ToLower(string(o.Type)), Provider: kindOf(c.Source.Kind),
 			Path: []string{c.Source.Name, c.Name, o.Name}, AccountLabel: accountOf(c.Source),
-			Expires: o.Expires, Enabled: o.Enabled, Reference: o.Reference, URL: o.URL, Hidden: o.Hidden})
+			Expires: o.Expires, Enabled: o.Enabled, Reference: o.Reference, URL: o.URL})
 	}
 }
 
 func sourceEntry(src provider.Source) Entry {
-	e := Entry{Kind: "source", Provider: kindOf(src.Kind), Path: []string{src.Name}, AccountLabel: accountOf(src), URL: src.URL, Hidden: src.Hidden}
+	e := Entry{Kind: "source", Provider: kindOf(src.Kind), Path: []string{src.Name}, AccountLabel: accountOf(src), URL: src.URL}
 	if r, err := ref.ForSource(src); err == nil {
 		e.Link = r.String()
 	}
@@ -250,7 +239,7 @@ func sourceEntry(src provider.Source) Entry {
 }
 
 func containerEntry(c provider.Container) Entry {
-	e := Entry{Kind: "vault", Provider: kindOf(c.Source.Kind), Path: []string{c.Source.Name, c.Name}, AccountLabel: accountOf(c.Source), URL: c.URL, Hidden: c.Hidden}
+	e := Entry{Kind: "vault", Provider: kindOf(c.Source.Kind), Path: []string{c.Source.Name, c.Name}, AccountLabel: accountOf(c.Source), URL: c.URL}
 	if r, err := ref.ForContainer(c, provider.TypeSecret); err == nil {
 		e.Link = r.String()
 	}

internal/provider/provider.go

@@ -73,10 +73,6 @@ type Source struct {
 	// Here marks the source lazysecrets was started in (the current git
 	// repo): listed first, starred or not, and labelled.
 	Here bool
-	// Hidden marks a source, container or object the provider's rules
-	// left out (a Spring file with no secret-looking keys): listed only
-	// while the app shows hidden ones.
-	Hidden bool `json:",omitempty"`
 }
 
 // ObjectType is the kind of object stored in a container.
@@ -113,8 +109,7 @@ type Container struct {
 	Types []ObjectType
 	URL   string // web page for the container, if any
 	// Attrs describe it further, from the listing (a vault's settings).
-	Attrs  []Attr `json:",omitempty"`
-	Hidden bool   `json:",omitempty"` // see Source.Hidden
+	Attrs []Attr `json:",omitempty"`
 }
 
 // ObjectTypes returns the container's object types, defaulting to secrets.
@@ -138,8 +133,6 @@ type Object struct {
 	Type        ObjectType
 	ID          string
 	Name        string
-	Detail      string // shown after the name, e.g. "jasypt" for how its value is kept
-	Hidden      bool   `json:",omitempty"` // see Source.Hidden
 	Version     string
 	Enabled     *bool
 	Updated     time.Time

internal/provider/repo/details.go

@@ -2,8 +2,6 @@ package repo
 
 import (
 	"context"
-	"fmt"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
@@ -24,12 +22,7 @@ func (p *Provider) Details(ctx context.Context, c provider.Container) ([]provide
 	}
 	var out []provider.Attr
 	meta, isSops := readMeta(c.ID)
-	// A plain file's values are at risk in git, unless they're all Jasypt;
-	// a Spring file's only when one of its secrets is in plain text.
-	plain := !isSops
-	if !isSops && IsSpring(c.ID) {
-		out, plain = p.springDetails(c)
-	} else if isSops {
+	if isSops {
 		out = append(out, provider.Attr{Label: "encryption", Value: "sops · " + strings.Join(meta.methods, ", ")})
 		for i, k := range meta.recipients {
 			label := ""
@@ -42,7 +35,7 @@ func (p *Provider) Details(ctx context.Context, c provider.Container) ([]provide
 			out = append(out, provider.Attr{Label: "encrypted", Value: meta.modified.Local().Format("2006-01-02 15:04")})
 		}
 	} else {
-		out, plain = envDetails(c.ID)
+		out = append(out, provider.Attr{Label: "encryption", Value: "none: plain text"})
 	}
 
 	git := func(args ...string) (string, bool) {
@@ -50,7 +43,7 @@ func (p *Provider) Details(ctx context.Context, c provider.Container) ([]provide
 		return strings.TrimSpace(string(b)), err == nil
 	}
 	switch _, tracked := git("ls-files", "--error-unmatch", "--", rel); {
-	case tracked && plain:
+	case tracked && !isSops:
 		out = append(out, provider.Attr{Label: "git", Value: "tracked: its values are in the repo's history", Warn: true})
 	case tracked:
 		out = append(out, provider.Attr{Label: "git", Value: "tracked"})
@@ -58,7 +51,7 @@ func (p *Provider) Details(ctx context.Context, c provider.Container) ([]provide
 		if _, ignored := git("check-ignore", "-q", "--", rel); ignored {
 			out = append(out, provider.Attr{Label: "git", Value: "ignored"})
 		} else {
-			out = append(out, provider.Attr{Label: "git", Value: "untracked and not ignored: easy to commit by mistake", Warn: plain})
+			out = append(out, provider.Attr{Label: "git", Value: "untracked and not ignored: easy to commit by mistake", Warn: !isSops})
 		}
 		return out, nil
 	}
@@ -67,28 +60,3 @@ func (p *Provider) Details(ctx context.Context, c provider.Container) ([]provide
 	}
 	return out, nil
 }
-
-// envDetails says how a plain env file's values are encrypted, and whether
-// any is in plain text.
-func envDetails(file string) (attrs []provider.Attr, plain bool) {
-	b, err := os.ReadFile(file)
-	if err != nil {
-		return []provider.Attr{{Label: "encryption", Value: err.Error(), Warn: true}}, true
-	}
-	keys, _ := parseKeys(file, b)
-	n := 0
-	for _, k := range keys {
-		if k.jasypt {
-			n++
-		}
-	}
-	return []provider.Attr{{Label: "encryption", Value: jasyptShare(n, len(keys))}}, n < len(keys)
-}
-
-// jasyptShare is how many of a plain file's values are Jasypt's.
-func jasyptShare(n, of int) string {
-	if n == 0 {
-		return "none: plain text"
-	}
-	return fmt.Sprintf("jasypt: %d of %d values", n, of)
-}

internal/provider/repo/jasypt.go

@@ -1,74 +0,0 @@
-package repo
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-
-	"git.kebcloud.no/keb/lazysecrets/internal/jasypt"
-	"git.kebcloud.no/keb/lazysecrets/internal/provider"
-)
-
-// jasyptEnv is where Spring looks for the password first, before the
-// config's jasypt.encryptor.password, and so does lazysecrets.
-const jasyptEnv = "JASYPT_ENCRYPTOR_PASSWORD"
-
-// jasyptValue decrypts v when it's a Jasypt value, ENC(...), from a plain
-// file; other values are as they are.
-func jasyptValue(file string, v provider.SecretValue) (provider.SecretValue, error) {
-	s := v.Reveal()
-	if !jasypt.Is(s) {
-		return v, nil
-	}
-	password, from, err := jasyptPassword(file)
-	if err != nil {
-		return provider.SecretValue{}, err
-	}
-	plain, err := jasypt.Decrypt(s, password)
-	if errors.Is(err, jasypt.ErrDecrypt) {
-		return provider.SecretValue{}, fmt.Errorf("jasypt: with the password from %s: %w", from, err)
-	}
-	if err != nil {
-		return provider.SecretValue{}, fmt.Errorf("jasypt: %w", err)
-	}
-	return provider.NewSecretValue([]byte(plain)), nil
-}
-
-// jasyptPassword is the password for a file's Jasypt values, and where it's
-// from: $JASYPT_ENCRYPTOR_PASSWORD, else the file's own setting
-// (jasypt.encryptor.password in a Spring file, JASYPT_ENCRYPTOR_PASSWORD
-// in an env file), with a ${VAR} in it read from the environment.
-func jasyptPassword(file string) (password, from string, err error) {
-	if v := os.Getenv(jasyptEnv); v != "" {
-		return v, "$" + jasyptEnv, nil
-	}
-	setting, read := jasyptEnv, plainValue
-	if IsSpring(file) {
-		setting, read = "jasypt.encryptor.password", springValue
-	}
-	v, err := read(file, setting)
-	if err != nil {
-		return "", "", fmt.Errorf("jasypt: no password: set $%s, or %s in %s", jasyptEnv, setting, filepath.Base(file))
-	}
-	return resolvePlaceholder(v.Reveal(), setting+" in "+filepath.Base(file))
-}
-
-// placeholder is Spring's ${VAR} or ${VAR:default}.
-var placeholder = regexp.MustCompile(`^\$\{([^:}]+)(:[^}]*)?\}$`)
-
-// resolvePlaceholder reads a ${VAR} value from the environment, falling
-// back to its default; other values are as they are.
-func resolvePlaceholder(v, from string) (string, string, error) {
-	m := placeholder.FindStringSubmatch(v)
-	switch {
-	case m == nil:
-		return v, from, nil
-	case os.Getenv(m[1]) != "":
-		return os.Getenv(m[1]), "$" + m[1] + " (" + from + ")", nil
-	case m[2] != "":
-		return m[2][1:], "the default in " + from, nil
-	}
-	return "", "", fmt.Errorf("jasypt: no password: %s is %s, and $%s isn't set", from, v, m[1])
-}

internal/provider/repo/jasypt_test.go

@@ -1,102 +0,0 @@
-package repo
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"git.kebcloud.no/keb/lazysecrets/internal/provider"
-)
-
-// hunter2, encrypted by Jasypt with the password "test-password".
-const jasyptHunter2 = "ENC(5IQUKT4B7j38TnZJ+BlWqo/zSkKHTjl4XRJyaQEHgkCy4r00avLt4dWqFB74X0Zw)"
-
-func TestJasyptPassword(t *testing.T) {
-	dir := t.TempDir()
-	value := func(name, body string) (string, error) {
-		file := filepath.Join(dir, name)
-		if err := os.WriteFile(file, []byte(body), 0o600); err != nil {
-			t.Fatal(err)
-		}
-		key := "app.token"
-		if !IsSpring(name) {
-			key = "TOKEN"
-		}
-		v, err := (&Provider{}).Value(context.Background(), provider.Object{ID: file + "\x00" + key, Name: key})
-		return v.Reveal(), err
-	}
-	t.Setenv("JASYPT_ENCRYPTOR_PASSWORD", "")
-	t.Setenv("MY_PASSWORD", "")
-	spring := func(password string) string {
-		return "jasypt.encryptor.password: " + password + "\napp.token: " + jasyptHunter2 + "\n"
-	}
-
-	for _, c := range []struct{ name, file, body, env, want string }{
-		{"the file's own", "application.yml", spring("test-password"), "", "hunter2"},
-		{"a ${VAR}", "application.yml", spring("${MY_PASSWORD}"), "test-password", "hunter2"},
-		{"a ${VAR}'s default", "application.yml", spring("${MY_PASSWORD:test-password}"), "", "hunter2"},
-		{"properties", "application-local.properties", "jasypt.encryptor.password=test-password\napp.token=" + jasyptHunter2 + "\n", "", "hunter2"},
-		{"env file", ".env", "JASYPT_ENCRYPTOR_PASSWORD=test-password\nTOKEN=" + jasyptHunter2 + "\n", "", "hunter2"},
-		{"not jasypt", ".env", "TOKEN=hunter2\n", "", "hunter2"},
-	} {
-		t.Setenv("MY_PASSWORD", c.env)
-		if got, err := value(c.file, c.body); err != nil || got != c.want {
-			t.Errorf("%s: %q %v", c.name, got, err)
-		}
-	}
-
-	// $JASYPT_ENCRYPTOR_PASSWORD wins over the file's, as in Spring.
-	t.Setenv("JASYPT_ENCRYPTOR_PASSWORD", "test-password")
-	if got, err := value("application.yml", spring("wrong")); err != nil || got != "hunter2" {
-		t.Errorf("environment first: %q %v", got, err)
-	}
-	t.Setenv("JASYPT_ENCRYPTOR_PASSWORD", "wrong")
-	if _, err := value("application.yml", spring("test-password")); err == nil || !strings.Contains(err.Error(), "the password from $JASYPT_ENCRYPTOR_PASSWORD") {
-		t.Errorf("a wrong one says where it's from: %v", err)
-	}
-
-	t.Setenv("JASYPT_ENCRYPTOR_PASSWORD", "")
-	t.Setenv("MY_PASSWORD", "")
-	for body, want := range map[string]string{
-		spring("${MY_PASSWORD}"):      "$MY_PASSWORD isn't set",
-		"app.token: " + jasyptHunter2: "set $JASYPT_ENCRYPTOR_PASSWORD, or jasypt.encryptor.password in application.yml",
-	} {
-		if _, err := value("application.yml", body); err == nil || !strings.Contains(err.Error(), want) {
-			t.Errorf("no password: %v, want %q", err, want)
-		}
-	}
-}
-
-func TestJasyptEnvFile(t *testing.T) {
-	root := gitRepo(t, map[string]string{
-		"jasypt.env": "TOKEN=" + jasyptHunter2 + "\n",
-		"mixed.env":  "TOKEN=" + jasyptHunter2 + "\nURL=https://example.com\n",
-	})
-	ctx := context.Background()
-	p := New(Settings{Dir: root})
-	srcs, _ := p.Sources(ctx)
-	cs, _ := p.Containers(ctx, srcs[0])
-	for _, c := range cs {
-		attrs, _ := p.Details(ctx, c)
-		got := map[string]provider.Attr{}
-		for _, a := range attrs {
-			got[a.Label] = a
-		}
-		switch c.Name {
-		case "jasypt.env":
-			if got["encryption"].Value != "jasypt: 1 of 1 values" || got["git"].Warn {
-				t.Errorf("all jasypt: %+v", got)
-			}
-			keys, _ := p.Objects(ctx, c, provider.TypeSecret)
-			if len(keys) != 1 || keys[0].Attrs[1].Value != "jasypt" || keys[0].Detail != "jasypt" {
-				t.Errorf("keys: %+v", keys)
-			}
-		case "mixed.env":
-			if got["encryption"].Value != "jasypt: 1 of 2 values" || !got["git"].Warn {
-				t.Errorf("mixed: %+v", got)
-			}
-		}
-	}
-}

internal/provider/repo/patterns.go

@@ -1,113 +0,0 @@
-package repo
-
-import (
-	"errors"
-	"fmt"
-	"path/filepath"
-	"regexp"
-)
-
-// Config files (Spring's) hold all of an app's config, most of it not
-// secret: of their keys, those named like a secret or with a value that
-// looks like one are listed, the rest hidden (H shows them). The patterns
-// can be set for all of a repo's files and per file type, in the config
-// and in a repo's .lazysecrets.yaml.
-
-// DefaultSecretKeys and DefaultSecretValues are the patterns used when
-// nothing sets them. The key pattern is anchored at the end of the name:
-// spring.datasource.password, client-secret, DB_PASSWORD and checkoutKey,
-// not the oauth2.*, keycloak.* and token-uri keys every Spring app has.
-// passord is Norwegian. They err on listing too much: a row too many is
-// cheap, a secret missed isn't.
-var (
-	DefaultSecretKeys = []string{
-		`(?i)(pass(word|wd|phrase|ord)?|pwd|secret|token|key|credentials?|salt|connection-?string)$`,
-	}
-	DefaultSecretValues = []string{
-		`^ENC\(.+\)$`,            // Jasypt
-		`://[^/\s:@]*:[^/\s@]+@`, // a URL with a password: jdbc:postgresql://user:pass@host
-		`(?i)(AccountKey|SharedAccessKey|Password|Pwd)=`, // a connection string with one
-	}
-)
-
-// SecretPatterns are regexps matched against a key's name and its value:
-// a key is a secret when either matches. A list that isn't set is taken
-// from the next place that sets it (see filterFor).
-type SecretPatterns struct {
-	Keys   *[]string `yaml:"keys"`
-	Values *[]string `yaml:"values"`
-}
-
-// FileType holds the settings of one type of file (spring:), for now its
-// own secret patterns.
-type FileType struct {
-	SecretPatterns SecretPatterns `yaml:"secretPatterns"`
-}
-
-// Check says which pattern doesn't compile; field is where they're set
-// (spring.secretPatterns), for the message.
-func (p SecretPatterns) Check(field string) error {
-	var errs []error
-	for name, list := range map[string]*[]string{"keys": p.Keys, "values": p.Values} {
-		if list == nil {
-			continue
-		}
-		for i, s := range *list {
-			if _, err := regexp.Compile(s); err != nil {
-				errs = append(errs, fmt.Errorf("%s.%s[%d]: %w", field, name, i, err))
-			}
-		}
-	}
-	return errors.Join(errs...)
-}
-
-type secretFilter struct{ keys, values []*regexp.Regexp }
-
-func (f secretFilter) secret(key, value string) bool {
-	return anyMatch(f.keys, key) || anyMatch(f.values, value)
-}
-
-// filterFor is the patterns for a repo's files of one type (spring), each
-// list from the first that sets it: the repo's .lazysecrets.yaml for the
-// type, then for all its files, the config for the type, then for all
-// repos, then the defaults.
-func (p *Provider) filterFor(root, fileType string) (secretFilter, error) {
-	f, err := readLazysecretsFile(root)
-	if err != nil {
-		return secretFilter{}, err
-	}
-	own := filepath.Join(root, ".lazysecrets.yaml") + ": "
-	type source struct {
-		field    string
-		patterns SecretPatterns
-	}
-	sources := []source{
-		{own + fileType + ".secretPatterns", f.types()[fileType].SecretPatterns},
-		{own + "secretPatterns", f.SecretPatterns},
-		{"providers.repos." + fileType + ".secretPatterns", p.s.Types[fileType].SecretPatterns},
-		{"providers.repos.secretPatterns", p.s.SecretPatterns},
-	}
-	pick := func(name string, list func(SecretPatterns) *[]string, defaults []string) ([]*regexp.Regexp, error) {
-		for _, s := range sources {
-			if l := list(s.patterns); l != nil {
-				return compileAll(*l, s.field+"."+name)
-			}
-		}
-		return compileAll(defaults, "default "+name)
-	}
-	keys, kerr := pick("keys", func(p SecretPatterns) *[]string { return p.Keys }, DefaultSecretKeys)
-	values, verr := pick("values", func(p SecretPatterns) *[]string { return p.Values }, DefaultSecretValues)
-	return secretFilter{keys, values}, errors.Join(kerr, verr)
-}
-
-func compileAll(patterns []string, field string) ([]*regexp.Regexp, error) {
-	out := make([]*regexp.Regexp, 0, len(patterns))
-	for i, s := range patterns {
-		re, err := regexp.Compile(s)
-		if err != nil {
-			return nil, fmt.Errorf("%s[%d]: %w", field, i, err)
-		}
-		out = append(out, re)
-	}
-	return out, nil
-}

internal/provider/repo/patterns_test.go

@@ -1,49 +0,0 @@
-package repo
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// Each list comes from the first that sets it: the repo's spring, the
-// repo's, the config's spring, the config's, the defaults.
-func TestSecretPatternsOrder(t *testing.T) {
-	list := func(s ...string) *[]string { return &s }
-	root := t.TempDir()
-	write := func(body string) {
-		if err := os.WriteFile(filepath.Join(root, ".lazysecrets.yaml"), []byte(body), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	p := New(Settings{
-		SecretPatterns: SecretPatterns{Keys: list("^config$"), Values: list("^config$")},
-		Types:          map[string]FileType{"spring": {SecretPatterns: SecretPatterns{Keys: list("^config-spring$")}}},
-	})
-	secret := func(key, value string) bool {
-		t.Helper()
-		f, err := p.filterFor(root, "spring")
-		if err != nil {
-			t.Fatal(err)
-		}
-		return f.secret(key, value)
-	}
-
-	if !secret("config-spring", "") || secret("config", "") || !secret("", "config") {
-		t.Error("the config's spring keys, its shared values")
-	}
-	write("secretPatterns:\n  keys: [\"^repo$\"]\n")
-	if !secret("repo", "") || secret("config-spring", "") || !secret("", "config") {
-		t.Error("the repo's shared keys over the config's")
-	}
-	write("secretPatterns:\n  keys: [\"^repo$\"]\nspring:\n  secretPatterns:\n    keys: [\"^repo-spring$\"]\n    values: []\n")
-	if !secret("repo-spring", "") || secret("repo", "") || secret("", "config") {
-		t.Error("the repo's spring over everything; an empty list matches nothing")
-	}
-
-	p = New(Settings{})
-	write("")
-	if !secret("spring.datasource.password", "") || secret("server.port", "") {
-		t.Error("the defaults")
-	}
-}

internal/provider/repo/repo.go

@@ -1,7 +1,6 @@
 // Package repo browses the encrypted secret files in git repositories:
 // a repo is a source, its secret files the containers (vault level), and
-// their keys the secrets. Secret files are SOPS files, plain env files and
-// Spring Boot config (spring.go).
+// their keys the secrets. Secret files are SOPS files and plain env files.
 //
 // Listing never decrypts: SOPS encrypts values only, so a file's keys and
 // metadata are read directly. A value is decrypted when it's revealed or
@@ -32,7 +31,6 @@ import (
 
 	"go.yaml.in/yaml/v3"
 
-	"git.kebcloud.no/keb/lazysecrets/internal/jasypt"
 	"git.kebcloud.no/keb/lazysecrets/internal/provider"
 )
 
@@ -51,11 +49,6 @@ type Settings struct {
 	// Include and Exclude are globs relative to a repo's root (** matches
 	// any depth), for repos without their own .lazysecrets.yaml.
 	Include, Exclude []string
-	// SecretPatterns say which keys of config files are secrets, Types
-	// per type of file (spring), for repos whose .lazysecrets.yaml
-	// doesn't.
-	SecretPatterns SecretPatterns
-	Types          map[string]FileType
 	// Sops is the sops binary; "sops" (on PATH) when empty.
 	Sops string
 }
@@ -192,19 +185,12 @@ func (p *Provider) Current(ctx context.Context) (provider.Source, bool) {
 		return provider.Source{}, false
 	}
 	src := p.source(r)
-	files, err := p.Containers(ctx, src)
-	if err == nil && len(files) == 0 {
+	if files, err := p.Containers(ctx, src); err == nil && len(files) == 0 {
 		return provider.Source{}, false
 	}
-	src.Hidden = err == nil && allHidden(files)
 	return src, true
 }
 
-// allHidden reports whether a repo's files are all hidden: the repo is too.
-func allHidden(files []provider.Container) bool {
-	return !slices.ContainsFunc(files, func(c provider.Container) bool { return !c.Hidden })
-}
-
 func (p *Provider) source(r repoInfo) provider.Source {
 	return provider.Source{
 		Kind: provider.KindRepo, Provider: p.ID(), ProviderLabel: p.Label(),
@@ -273,7 +259,6 @@ func (p *Provider) Sources(ctx context.Context) ([]provider.Source, error) {
 	parallel(len(srcs), func(i int) {
 		files, err := p.Containers(ctx, srcs[i])
 		keep[i] = err != nil || len(files) > 0
-		srcs[i].Hidden = err == nil && allHidden(files)
 	})
 	var out []provider.Source
 	for i, src := range srcs {
@@ -333,12 +318,8 @@ func (p *Provider) Containers(ctx context.Context, src provider.Source) ([]provi
 			c.Detail = "sops · " + strings.Join(meta.methods, ", ")
 		case isSops:
 			return // a SOPS file where .sops.yaml says SOPS files don't go
-		case isEnvNamed(f):
+		case IsEnv(f):
 			c.Detail = provider.DetailPlainEnv
-			c.Hidden = isExample(f)
-		case IsSpring(f):
-			c.Detail = "spring · " + springFormat(f)
-			c.Hidden = p.springHidden(r.root, path)
 		default:
 			return
 		}
@@ -376,9 +357,6 @@ func (p *Provider) Objects(_ context.Context, c provider.Container, t provider.O
 		return nil, err
 	}
 	meta, isSops := parseMeta(c.ID, b)
-	if !isSops && IsSpring(c.ID) {
-		return p.springObjects(c, b)
-	}
 	keys, err := parseKeys(c.ID, b)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", c.Name, err)
@@ -393,11 +371,8 @@ func (p *Provider) Objects(_ context.Context, c provider.Container, t provider.O
 			Container: c, Type: provider.TypeSecret,
 			ID: c.ID + "\x00" + k.extract, Name: k.name, Updated: meta.modified, Attrs: attrs,
 		}
-		switch {
-		case isSops && !k.encrypted:
+		if isSops && !k.encrypted {
 			o.Attrs = append(slices.Clip(attrs), provider.Attr{Label: "encrypted", Value: "no (left in plain text by the file's sops rules)"})
-		case !isSops && k.jasypt:
-			o.Attrs, o.Detail = []provider.Attr{attrs[0], {Label: "encrypted", Value: "jasypt"}}, "jasypt"
 		}
 		out = append(out, o)
 	}
@@ -412,29 +387,15 @@ func (p *Provider) Versions(context.Context, provider.Object) ([]provider.Object
 	return nil, provider.ErrUnsupported
 }
 
-// Value reads one key: from a plain file, decrypting a Jasypt value; from
-// a SOPS file, with sops.
+// Value decrypts one key with sops.
 func (p *Provider) Value(ctx context.Context, o provider.Object) (provider.SecretValue, error) {
 	file, extract, ok := strings.Cut(o.ID, "\x00")
 	if !ok { // made from a link: the repo's root, the file's path, the key
 		file = filePath(o.Container)
+		extract = extractFor(file, o.Name)
 	}
 	if _, isSops := readMeta(file); !isSops {
-		read := plainValue
-		if IsSpring(file) {
-			read = springValue
-		}
-		v, err := read(file, o.Name)
-		if err != nil {
-			return v, err
-		}
-		return jasyptValue(file, v)
-	}
-	if !ok {
-		var err error
-		if extract, err = extractOf(file, o.Name); err != nil {
-			return provider.SecretValue{}, err
-		}
+		return plainValue(file, o.Name)
 	}
 	cmd := exec.CommandContext(ctx, p.s.Sops, "decrypt", "--extract", extract, file)
 	cmd.Dir = filepath.Dir(file) // sops looks for .sops.yaml from here
@@ -477,12 +438,6 @@ func (p *Provider) File(c provider.Container, o *provider.Object) (provider.File
 	if o == nil {
 		return f, nil
 	}
-	if f.Sops == "" && IsSpring(path) {
-		if k, err := springKeyNamed(path, o.Name); err == nil {
-			f.Line = k.line
-		}
-		return f, nil
-	}
 	b, err := os.ReadFile(path)
 	if err != nil {
 		return f, err
@@ -634,21 +589,15 @@ func normalizeRemote(remote string) (string, string) {
 
 // lazysecretsFile is a repo's own .lazysecrets.yaml.
 type lazysecretsFile struct {
-	Include        []string       `yaml:"include"`
-	Exclude        []string       `yaml:"exclude"`
-	SecretPatterns SecretPatterns `yaml:"secretPatterns"`
-	Spring         FileType       `yaml:"spring"`
-	Sharing        struct {
+	Include []string `yaml:"include"`
+	Exclude []string `yaml:"exclude"`
+	Sharing struct {
 		// Key is the link to the secret that encrypts the repo's
 		// shared env files (package share).
 		Key string `yaml:"key"`
 	} `yaml:"sharing"`
 }
 
-func (f lazysecretsFile) types() map[string]FileType {
-	return map[string]FileType{"spring": f.Spring}
-}
-
 // ShareKey is the sharing.key of the repo's .lazysecrets.yaml, if any.
 func ShareKey(root string) (string, error) {
 	f, err := readLazysecretsFile(root)
@@ -718,7 +667,7 @@ func envFiles(root string, tracked []string) []string {
 	dirs := map[string]bool{".": true}
 	for _, f := range tracked {
 		isTracked[f] = true
-		if isEnvNamed(f) {
+		if IsEnv(f) {
 			out = append(out, f)
 		}
 		if d := path.Dir(f); !dirs[d] && !inPackages(f) {
@@ -732,7 +681,7 @@ func envFiles(root string, tracked []string) []string {
 		}
 		for _, e := range entries {
 			f := path.Join(d, e.Name())
-			if e.Type().IsRegular() && !isTracked[f] && isEnvNamed(f) {
+			if e.Type().IsRegular() && !isTracked[f] && IsEnv(f) {
 				out = append(out, f)
 			}
 		}
@@ -767,29 +716,16 @@ func inPackages(f string) bool {
 // .env, .env.local, prod.env; not .env.example and the like, nor one in
 // dependencies.
 func IsEnv(f string) bool {
-	return isEnvNamed(f) && !isExample(f)
-}
-
-// isEnvNamed reports whether a file outside dependencies is named like an
-// env file, examples too.
-func isEnvNamed(f string) bool {
+	if inPackages(f) {
+		return false
+	}
 	base := strings.ToLower(path.Base(f))
-	return !inPackages(f) && (base == ".env" || strings.HasPrefix(base, ".env.") || strings.HasSuffix(base, ".env"))
-}
-
-var exampleWords = []string{"example", "sample", "template", "dist", "tmpl"}
-
-// isExample reports whether a file is an example or template of another:
-// .env.example, docker-compose.example.yml. They're listed hidden: someone
-// may have put a real value in one.
-func isExample(f string) bool {
-	base := strings.ToLower(path.Base(f))
-	for _, w := range exampleWords {
-		if strings.HasSuffix(base, "."+w) || strings.Contains(base, "."+w+".") {
-			return true
+	for _, ext := range []string{".example", ".sample", ".template", ".dist", ".tmpl"} {
+		if strings.HasSuffix(base, ext) {
+			return false
 		}
 	}
-	return false
+	return base == ".env" || strings.HasPrefix(base, ".env.") || strings.HasSuffix(base, ".env")
 }
 
 // plainValue reads a key from a plain env file.
@@ -1085,8 +1021,7 @@ type key struct {
 	name      string // db.password, list[0], with . [ ] \ in keys escaped
 	extract   string // sops --extract: ["db"]["password"]
 	encrypted bool
-	jasypt    bool // a plain env file's ENC(...) value
-	line      int  // 1-based
+	line      int // 1-based
 }
 
 // parseKeys lists a sops file's keys without decrypting anything.
@@ -1110,8 +1045,7 @@ func parseKeys(file string, b []byte) ([]key, error) {
 			if !ok || strings.HasPrefix(k, "sops_") {
 				continue
 			}
-			sopsKey, _, _ := strings.Cut(line, "=") // sops keeps export and spaces in the key
-			out = append(out, key{name: k, extract: quote(sopsKey), encrypted: strings.HasPrefix(v, "ENC["), jasypt: jasypt.Is(v), line: i + 1})
+			out = append(out, key{name: k, extract: quote(k), encrypted: strings.HasPrefix(v, "ENC["), line: i + 1})
 		}
 		return out, nil
 	case "ini":
@@ -1176,23 +1110,48 @@ func escape(k string) string {
 	return strings.NewReplacer(`\`, `\\`, `.`, `\.`, `[`, `\[`, `]`, `\]`).Replace(k)
 }
 
-// extractOf is the sops --extract path of the key named name, for objects
-// made from a link.
-func extractOf(file, name string) (string, error) {
-	b, err := os.ReadFile(file)
-	if err != nil {
-		return "", err
+// extractFor rebuilds the extract path from a key name, for objects made
+// from a link (db.password, list[0], app\.name). A dotenv file is flat:
+// its names are the keys as they are.
+func extractFor(file, name string) string {
+	if formatOf(file) == "dotenv" {
+		return quote(name)
 	}
-	keys, err := parseKeys(file, b)
-	if err != nil {
-		return "", err
-	}
-	for _, k := range keys {
-		if k.name == name {
-			return k.extract, nil
+	var b, part strings.Builder
+	flush := func() {
+		if part.Len() > 0 {
+			b.WriteString(quote(part.String()))
+			part.Reset()
 		}
 	}
-	return "", fmt.Errorf("%s isn't in %s", name, filepath.Base(file))
+	for i := 0; i < len(name); i++ {
+		switch c := name[i]; c {
+		case '\\':
+			if i+1 < len(name) {
+				i++
+			}
+			part.WriteByte(name[i])
+		case '.':
+			flush()
+		case '[':
+			end := strings.IndexByte(name[i:], ']')
+			if end < 0 || !digits(name[i+1:i+end]) {
+				part.WriteByte(c)
+				continue
+			}
+			flush()
+			b.WriteString(name[i : i+end+1])
+			i += end
+		default:
+			part.WriteByte(c)
+		}
+	}
+	flush()
+	return b.String()
+}
+
+func digits(s string) bool {
+	return s != "" && strings.Trim(s, "0123456789") == ""
 }
 
 func absPath(p string) string {

internal/provider/repo/repo_test.go

@@ -237,25 +237,6 @@ func TestDecrypt(t *testing.T) {
 		t.Errorf("from a link: %q %v", v.Reveal(), err)
 	}
 
-	// A dotenv file's export lines: sops keeps export in the key.
-	os.WriteFile(plain, []byte("export TOKEN=s3cret\n"), 0o600)
-	enc, err = exec.Command("sops", "encrypt", "--age", recipient, "--input-type", "dotenv", "--output-type", "dotenv", plain).Output()
-	if err != nil {
-		t.Fatal(err)
-	}
-	envFile := filepath.Join(root, "prod.env")
-	os.WriteFile(envFile, enc, 0o600)
-	envC := provider.Container{Source: srcs[0], ID: envFile, Name: "prod.env"}
-	envKeys, _ := p.Objects(ctx, envC, provider.TypeSecret)
-	if len(envKeys) != 1 {
-		t.Fatalf("env keys: %v", envKeys)
-	}
-	for _, o := range []provider.Object{envKeys[0], {Container: provider.Container{Source: srcs[0], Name: "prod.env"}, Name: "TOKEN"}} {
-		if v, err := p.Value(ctx, o); err != nil || v.Reveal() != "s3cret" {
-			t.Errorf("export line (link: %t): %q %v", o.ID == "", v.Reveal(), err)
-		}
-	}
-
 	// Without the key: sops' own error.
 	t.Setenv("SOPS_AGE_KEY_FILE", filepath.Join(dir, "missing.txt"))
 	if _, err := p.Value(ctx, keys[0]); err == nil || !strings.Contains(err.Error(), "no identity matched any of the recipients") {
@@ -292,12 +273,9 @@ func TestPlainEnvFiles(t *testing.T) {
 	got := map[string]string{}
 	for _, c := range files {
 		got[c.Name] = c.Detail
-		if c.Hidden != (c.Name == ".env.example") {
-			t.Errorf("%s: hidden %t", c.Name, c.Hidden)
-		}
 	}
-	if len(got) != 3 || got[".env"] != "env · plain text" || got[".env.example"] != "env · plain text" || got["secrets/app.yaml"] != "sops · age" {
-		t.Fatalf("files %v (want .env, the example, hidden, and the sops file; not node_modules)", got)
+	if len(got) != 2 || got[".env"] != "env · plain text" || got["secrets/app.yaml"] != "sops · age" {
+		t.Fatalf("files %v (want .env and the sops file; not the example or node_modules)", got)
 	}
 
 	var env provider.Container
@@ -322,7 +300,7 @@ func TestPlainEnvFiles(t *testing.T) {
 	os.WriteFile(filepath.Join(root, ".sops.yaml"), []byte("creation_rules:\n  - path_regex: nowhere/.*\n"), 0o644)
 	exec.Command("git", "-C", root, "add", ".sops.yaml").Run()
 	files, _ = New(Settings{Dir: root}).Containers(ctx, srcs[0])
-	if names := names(files, func(c provider.Container) string { return c.Name }); !slices.Equal(names, []string{".env", ".env.example"}) {
+	if names := names(files, func(c provider.Container) string { return c.Name }); !slices.Equal(names, []string{".env"}) {
 		t.Errorf("with rules elsewhere: %v", names)
 	}
 }
@@ -576,22 +554,15 @@ func TestKeyNamesEscaped(t *testing.T) {
 	var got []string
 	for _, k := range keys {
 		got = append(got, k.name+" "+k.extract)
+		if e := extractFor("s.yaml", k.name); e != k.extract {
+			t.Errorf("extractFor(%q) = %s, want %s", k.name, e, k.extract)
+		}
 	}
 	want := `app\.name ["app.name"]|db.password ["db"]["password"]|list[0] ["list"][0]|list[1] ["list"][1]|odd\[1\] ["odd[1]"]`
 	if strings.Join(got, "|") != want {
 		t.Errorf("keys = %s\nwant   %s", strings.Join(got, "|"), want)
 	}
-
-	keys, err = parseKeys(".env", []byte("spring.url=a\nexport TOKEN=b\nSPACED = c\n"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	got = nil
-	for _, k := range keys {
-		got = append(got, k.name+" "+k.extract)
-	}
-	want = `spring.url ["spring.url"]|TOKEN ["export TOKEN"]|SPACED ["SPACED "]`
-	if strings.Join(got, "|") != want {
-		t.Errorf("dotenv keys = %s\nwant   %s", strings.Join(got, "|"), want)
+	if e := extractFor(".env", "spring.url"); e != `["spring.url"]` {
+		t.Errorf("dotenv: %s", e)
 	}
 }

internal/provider/repo/spring.go

@@ -1,341 +0,0 @@
-package repo
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"go.yaml.in/yaml/v3"
-
-	"git.kebcloud.no/keb/lazysecrets/internal/jasypt"
-	"git.kebcloud.no/keb/lazysecrets/internal/provider"
-)
-
-// Spring Boot config files: application*.properties/.yml and bootstrap*,
-// their keys filtered by the secret patterns (patterns.go).
-
-// springName is application.yml, application-prod.properties, bootstrap.yaml
-// and the like; not applications.yaml (Argo CD's) or application.yml.example.
-var springName = regexp.MustCompile(`^(application|bootstrap)(-[^.]+)?\.(properties|ya?ml)$`)
-
-// IsSpring reports whether f is named like a Spring Boot config file, and
-// isn't a Helm chart's template of one.
-func IsSpring(f string) bool {
-	return springName.MatchString(strings.ToLower(path.Base(f))) && path.Base(path.Dir(f)) != "templates"
-}
-
-func springFormat(f string) string {
-	if strings.ToLower(filepath.Ext(f)) == ".properties" {
-		return "properties"
-	}
-	return "yaml"
-}
-
-type springKey struct {
-	key   string // spring.datasource.password
-	name  string // key, with (profile) after it in a later document
-	value string
-	line  int // 1-based
-}
-
-// reference reports whether the value is only a placeholder, ${DB_PASSWORD}:
-// the secret is elsewhere. One with a default, ${DB_PASSWORD:hunter2}, has
-// the default in the file.
-func (k springKey) reference() bool {
-	return strings.HasPrefix(k.value, "${") && strings.HasSuffix(k.value, "}") &&
-		!strings.ContainsAny(k.value[2:len(k.value)-1], ":${}")
-}
-
-func (k springKey) jasypt() bool {
-	return jasypt.Is(k.value)
-}
-
-// plain reports whether the file holds the value itself, readable.
-func (k springKey) plain() bool {
-	return k.value != "" && !k.reference() && !k.jasypt()
-}
-
-// readSpring lists a Spring config file's keys, every one, with values.
-func readSpring(file string) ([]springKey, error) {
-	b, err := os.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-	return parseSpring(file, b)
-}
-
-func parseSpring(file string, b []byte) ([]springKey, error) {
-	if springFormat(file) == "properties" {
-		return parseProperties(b), nil
-	}
-	return parseSpringYAML(b)
-}
-
-// springDocs names the keys of a multi-document file's later documents
-// after the profile they're for, so each name is one key:
-// spring.datasource.password (prod).
-func springDocs(docs [][]springKey) []springKey {
-	var out []springKey
-	for i, doc := range docs {
-		suffix := ""
-		if i > 0 {
-			suffix = fmt.Sprintf(" (document %d)", i+1)
-			for _, k := range doc {
-				if k.key == "spring.config.activate.on-profile" || k.key == "spring.profiles" {
-					suffix = " (" + k.value + ")"
-				}
-			}
-		}
-		for _, k := range doc {
-			k.name = k.key + suffix
-			out = append(out, k)
-		}
-	}
-	return out
-}
-
-// mavenFiltered is a value Maven fills in at build time, @project.version@:
-// not YAML until it's quoted.
-var mavenFiltered = regexp.MustCompile(`(?m)(:[ \t]+|^[ \t]*-[ \t]+)(@[^\n]*?)[ \t]*$`)
-
-func parseSpringYAML(b []byte) ([]springKey, error) {
-	b = mavenFiltered.ReplaceAllFunc(b, func(m []byte) []byte {
-		sub := mavenFiltered.FindSubmatch(m)
-		return fmt.Appendf(nil, "%s'%s'", sub[1], bytes.ReplaceAll(sub[2], []byte("'"), []byte("''")))
-	})
-	dec := yaml.NewDecoder(bytes.NewReader(b))
-	var docs [][]springKey
-	for {
-		var doc yaml.Node
-		err := dec.Decode(&doc)
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			return nil, err
-		}
-		var keys []springKey
-		if len(doc.Content) > 0 {
-			springWalk(doc.Content[0], "", &keys)
-		}
-		docs = append(docs, keys)
-	}
-	return springDocs(docs), nil
-}
-
-// springWalk names keys the way Spring does: nested keys joined by dots,
-// list items by index (servers[0]).
-func springWalk(n *yaml.Node, name string, out *[]springKey) {
-	switch n.Kind {
-	case yaml.MappingNode:
-		for i := 0; i+1 < len(n.Content); i += 2 {
-			child := n.Content[i].Value
-			if name != "" {
-				child = name + "." + child
-			}
-			springWalk(n.Content[i+1], child, out)
-		}
-	case yaml.SequenceNode:
-		for i, c := range n.Content {
-			springWalk(c, fmt.Sprintf("%s[%d]", name, i), out)
-		}
-	case yaml.AliasNode:
-		if n.Alias != nil {
-			springWalk(n.Alias, name, out)
-		}
-	case yaml.ScalarNode:
-		if name != "" {
-			*out = append(*out, springKey{key: name, value: n.Value, line: n.Line})
-		}
-	}
-}
-
-// parseProperties reads a Java .properties file: key=value, key: value or
-// key value, lines continued with a trailing backslash, # and ! comments,
-// and #--- between documents (Spring Boot 2.4+).
-func parseProperties(b []byte) []springKey {
-	lines := strings.Split(strings.ReplaceAll(string(b), "\r\n", "\n"), "\n")
-	var docs [][]springKey
-	var doc []springKey
-	for i := 0; i < len(lines); i++ {
-		start := i + 1
-		line := strings.TrimLeftFunc(lines[i], unicode.IsSpace)
-		if line == "#---" || line == "!---" {
-			docs, doc = append(docs, doc), nil
-			continue
-		}
-		if line == "" || line[0] == '#' || line[0] == '!' {
-			continue
-		}
-		for continued(line) && i+1 < len(lines) {
-			i++
-			line = line[:len(line)-1] + strings.TrimLeftFunc(lines[i], unicode.IsSpace)
-		}
-		k, v := splitProperty(line)
-		doc = append(doc, springKey{key: unescapeProperty(k), value: unescapeProperty(v), line: start})
-	}
-	return springDocs(append(docs, doc))
-}
-
-// continued reports whether the line ends in an odd number of backslashes.
-func continued(line string) bool {
-	n := len(line) - len(strings.TrimRight(line, `\`))
-	return n%2 == 1
-}
-
-// splitProperty cuts a logical line at its first unescaped =, : or
-// whitespace; whitespace around the separator isn't part of either side.
-func splitProperty(line string) (key, value string) {
-	const space = " \t\f"
-	for i := 0; i < len(line); i++ {
-		switch c := line[i]; {
-		case c == '\\':
-			i++
-		case c == '=' || c == ':':
-			return line[:i], strings.TrimLeft(line[i+1:], space)
-		case strings.IndexByte(space, c) >= 0:
-			rest := strings.TrimLeft(line[i:], space)
-			if rest != "" && (rest[0] == '=' || rest[0] == ':') {
-				rest = strings.TrimLeft(rest[1:], space)
-			}
-			return line[:i], rest
-		}
-	}
-	return line, ""
-}
-
-func unescapeProperty(s string) string {
-	if !strings.Contains(s, `\`) {
-		return s
-	}
-	var b strings.Builder
-	for i := 0; i < len(s); i++ {
-		if s[i] != '\\' || i+1 == len(s) {
-			b.WriteByte(s[i])
-			continue
-		}
-		i++
-		switch s[i] {
-		case 't':
-			b.WriteByte('\t')
-		case 'n':
-			b.WriteByte('\n')
-		case 'r':
-			b.WriteByte('\r')
-		case 'f':
-			b.WriteByte('\f')
-		case 'u':
-			if i+5 <= len(s) {
-				if r, err := strconv.ParseUint(s[i+1:i+5], 16, 32); err == nil {
-					b.WriteRune(rune(r))
-					i += 4
-					continue
-				}
-			}
-			b.WriteByte('u')
-		default:
-			b.WriteByte(s[i])
-		}
-	}
-	return b.String()
-}
-
-// springHidden reports whether a Spring file has no secret keys. One that
-// can't be read isn't hidden: its error is worth seeing.
-func (p *Provider) springHidden(root, file string) bool {
-	keys, err := readSpring(file)
-	if err != nil {
-		return false
-	}
-	filter, err := p.filterFor(root, "spring")
-	if err != nil {
-		return false
-	}
-	return !slices.ContainsFunc(keys, func(k springKey) bool { return filter.secret(k.key, k.value) })
-}
-
-// springObjects lists the file's keys, those that don't look like secrets
-// hidden.
-func (p *Provider) springObjects(c provider.Container, b []byte) ([]provider.Object, error) {
-	keys, err := parseSpring(c.ID, b)
-	if err != nil {
-		return nil, fmt.Errorf("%s: %w", c.Name, err)
-	}
-	filter, err := p.filterFor(c.Source.ID, "spring")
-	if err != nil {
-		return nil, err
-	}
-	format := provider.Attr{Label: "format", Value: "spring " + springFormat(c.ID)}
-	var out []provider.Object
-	for _, k := range keys {
-		state, detail := provider.Attr{Label: "encrypted", Value: "no: plain text in the file"}, ""
-		switch {
-		case k.reference():
-			state, detail = provider.Attr{Label: "value", Value: "a reference: the secret is set elsewhere"}, "reference"
-		case k.jasypt():
-			state, detail = provider.Attr{Label: "encrypted", Value: "jasypt"}, "jasypt"
-		}
-		out = append(out, provider.Object{
-			Container: c, Type: provider.TypeSecret, ID: c.ID + "\x00" + k.name, Name: k.name, Detail: detail,
-			Hidden: !filter.secret(k.key, k.value), Attrs: []provider.Attr{format, state},
-		})
-	}
-	return out, nil
-}
-
-func springValue(file, name string) (provider.SecretValue, error) {
-	k, err := springKeyNamed(file, name)
-	if err != nil {
-		return provider.SecretValue{}, err
-	}
-	return provider.NewSecretValue([]byte(k.value)), nil
-}
-
-func springKeyNamed(file, name string) (springKey, error) {
-	keys, err := readSpring(file)
-	if err != nil {
-		return springKey{}, err
-	}
-	for _, k := range keys {
-		if k.name == name {
-			return k, nil
-		}
-	}
-	return springKey{}, fmt.Errorf("%s isn't in %s", name, filepath.Base(file))
-}
-
-// springDetails says how many of the file's keys aren't listed, and
-// whether any listed one is in plain text.
-func (p *Provider) springDetails(c provider.Container) (attrs []provider.Attr, plain bool) {
-	keys, err := readSpring(c.ID)
-	if err != nil {
-		return []provider.Attr{{Label: "keys", Value: err.Error(), Warn: true}}, false
-	}
-	filter, err := p.filterFor(c.Source.ID, "spring")
-	if err != nil {
-		return []provider.Attr{{Label: "keys", Value: err.Error(), Warn: true}}, false
-	}
-	secrets, jasypt := 0, 0
-	for _, k := range keys {
-		if filter.secret(k.key, k.value) {
-			secrets++
-			plain = plain || k.plain()
-		}
-		if k.jasypt() {
-			jasypt++
-		}
-	}
-	return []provider.Attr{
-		{Label: "encryption", Value: jasyptShare(jasypt, len(keys))},
-		{Label: "hidden keys", Value: fmt.Sprintf("%d, not matched by the secret patterns", len(keys)-secrets)},
-	}, plain
-}

internal/provider/repo/spring_test.go

@@ -1,255 +0,0 @@
-package repo
-
-import (
-	"context"
-	"maps"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"git.kebcloud.no/keb/lazysecrets/internal/provider"
-)
-
-func TestIsSpring(t *testing.T) {
-	for f, want := range map[string]bool{
-		"src/main/resources/application.yml":        true,
-		"application-prod.properties":               true,
-		"config/application-local.yaml":             true,
-		"bootstrap.yml":                             true,
-		"applicationset/dev/applications.yaml":      false, // Argo CD's
-		"chart/templates/application.yaml":          false, // Helm's
-		"application.yml.example":                   false,
-		"application.json":                          false,
-		"src/main/resources/applicationContext.xml": false,
-	} {
-		if IsSpring(f) != want {
-			t.Errorf("%s: %t", f, !want)
-		}
-	}
-}
-
-func springNames(keys []springKey) map[string]string {
-	out := map[string]string{}
-	for _, k := range keys {
-		out[k.name] = k.value
-	}
-	return out
-}
-
-func TestParseProperties(t *testing.T) {
-	got := springNames(parseProperties([]byte(`# a comment
-! another
-a=1
-b : 2
-c 3
-d\:e=4
-long=one, \
-     two
-unicode=café
-empty=
-#---
-spring.config.activate.on-profile=prod
-a=prod-1
-`)))
-	want := map[string]string{
-		"a": "1", "b": "2", "c": "3", "d:e": "4", "long": "one, two", "unicode": "café", "empty": "",
-		"spring.config.activate.on-profile (prod)": "prod", "a (prod)": "prod-1",
-	}
-	if !maps.Equal(got, want) {
-		t.Errorf("got  %v\nwant %v", got, want)
-	}
-}
-
-func TestParseSpringYAML(t *testing.T) {
-	keys, err := parseSpringYAML([]byte(`info.version: @project.version@
-artifacts:
-  - @project.artifactId@
-spring:
-  datasource:
-    password: ${DB_PASSWORD}
-servers:
-  - name: a
-    secret: x
-logging.level:
-  com.example: DEBUG
----
-spring:
-  config.activate.on-profile: prod
-  datasource:
-    password: hunter2
----
-other: y
-`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := map[string]string{
-		"info.version": "@project.version@", "artifacts[0]": "@project.artifactId@",
-		"spring.datasource.password": "${DB_PASSWORD}", "servers[0].name": "a", "servers[0].secret": "x",
-		"logging.level.com.example":                "DEBUG",
-		"spring.config.activate.on-profile (prod)": "prod", "spring.datasource.password (prod)": "hunter2",
-		"other (document 3)": "y",
-	}
-	if got := springNames(keys); !maps.Equal(got, want) {
-		t.Errorf("got  %v\nwant %v", got, want)
-	}
-}
-
-func TestSpringDefaults(t *testing.T) {
-	f, err := (&Provider{}).filterFor(t.TempDir(), "spring")
-	if err != nil {
-		t.Fatal(err)
-	}
-	for key, value := range map[string]string{
-		"spring.datasource.password":                                 "x",
-		"spring.security.oauth2.client.registration.a.client-secret": "x",
-		"profapp.payment.checkoutKey":                                "x",
-		"app.clients.sgig.sgig-passord":                              "x",
-		"jasypt.encryptor.password":                                  "${JASYPT_ENCRYPTOR_PASSWORD}",
-		"spring.datasource.url":                                      "jdbc:postgresql://app:hunter2@db:5432/app",
-		"app.servicebus.connection":                                  "Endpoint=sb://x/;SharedAccessKeyName=a;SharedAccessKey=b",
-		"app.name":                                                   "ENC(abc==)",
-	} {
-		if !f.secret(key, value) {
-			t.Errorf("%s=%s isn't listed", key, value)
-		}
-	}
-	for key, value := range map[string]string{
-		"spring.security.oauth2.client.provider.a.token-uri":                    "https://idp/token",
-		"spring.security.oauth2.client.registration.a.authorization-grant-type": "client_credentials",
-		"app.frontend.keycloak.url":                                             "https://keycloak",
-		"server.port":                                                           "8080",
-		"spring.datasource.url":                                                 "jdbc:postgresql://db:5432/app",
-	} {
-		if f.secret(key, value) {
-			t.Errorf("%s=%s is listed", key, value)
-		}
-	}
-}
-
-func TestSpringFiles(t *testing.T) {
-	root := gitRepo(t, map[string]string{
-		"src/main/resources/application.yml": `server:
-  port: 8080
-spring:
-  datasource:
-    url: jdbc:postgresql://db/app
-    password: ${DB_PASSWORD}
-jasypt:
-  encryptor:
-    password: ${JASYPT_ENCRYPTOR_PASSWORD}
-app:
-  api-key: ENC(5IQUKT4B7j38TnZJ+BlWqo/zSkKHTjl4XRJyaQEHgkCy4r00avLt4dWqFB74X0Zw)
-`,
-		"src/main/resources/application-local.properties": "server.port=8081\nspring.datasource.password=hunter2\n",
-		"applicationset/applications.yaml":                "kind: ApplicationSet\n",
-	})
-	ctx := context.Background()
-	details := func(p *Provider, c provider.Container) map[string]provider.Attr {
-		attrs, err := p.Details(ctx, c)
-		if err != nil {
-			t.Fatal(err)
-		}
-		out := map[string]provider.Attr{}
-		for _, a := range attrs {
-			out[a.Label] = a
-		}
-		return out
-	}
-
-	p := New(Settings{Dir: root})
-	srcs, _ := p.Sources(ctx)
-	cs, err := p.Containers(ctx, srcs[0])
-	if err != nil {
-		t.Fatal(err)
-	}
-	var files []string
-	for _, c := range cs {
-		files = append(files, c.Name+" · "+c.Detail)
-	}
-	if want := []string{
-		"src/main/resources/application-local.properties · spring · properties",
-		"src/main/resources/application.yml · spring · yaml",
-	}; !slices.Equal(files, want) {
-		t.Fatalf("files %v\nwant  %v", files, want)
-	}
-	local, yml := cs[0], cs[1]
-
-	listed, _ := p.Objects(ctx, yml, provider.TypeSecret)
-	keys := shown(listed)
-	var names []string
-	for _, k := range keys {
-		names = append(names, strings.TrimSpace(k.Name+" "+k.Detail))
-	}
-	if len(listed) != 5 || !listed[0].Hidden || listed[0].Name != "server.port" {
-		t.Errorf("hidden keys: %+v", listed)
-	}
-	if want := []string{"spring.datasource.password reference", "jasypt.encryptor.password reference", "app.api-key jasypt"}; !slices.Equal(names, want) {
-		t.Errorf("keys %v, want %v", names, want)
-	}
-	t.Setenv("JASYPT_ENCRYPTOR_PASSWORD", "test-password")
-	if v, err := p.Value(ctx, keys[2]); err != nil || v.Reveal() != "hunter2" {
-		t.Errorf("value: %q %v", v.Reveal(), err)
-	}
-	link := provider.Object{Container: provider.Container{Source: srcs[0], Name: "src/main/resources/application.yml"}, Name: "spring.datasource.password"}
-	if v, err := p.Value(ctx, link); err != nil || v.Reveal() != "${DB_PASSWORD}" {
-		t.Errorf("from a link: %q %v", v.Reveal(), err)
-	}
-	if f, _ := p.File(yml, &keys[1]); f.Line != 9 || f.Sops != "" {
-		t.Errorf("file: %+v", f)
-	}
-
-	// References and Jasypt aren't plain text in git; a password is.
-	if d := details(p, yml); d["hidden keys"].Value != "2, not matched by the secret patterns" || d["git"].Warn || d["encryption"].Value != "jasypt: 1 of 5 values" {
-		t.Errorf("yml: %+v", d)
-	}
-	if d := details(p, local); !d["git"].Warn {
-		t.Errorf("local: %+v", d)
-	}
-
-	// The config's patterns, and the repo's over them.
-	all := []string{".*"}
-	p = New(Settings{Dir: root, SecretPatterns: SecretPatterns{Keys: &all}})
-	if keys, _ := p.Objects(ctx, yml, provider.TypeSecret); len(shown(keys)) != 5 {
-		t.Errorf("every key: %d", len(shown(keys)))
-	}
-	lazysecrets := filepath.Join(root, ".lazysecrets.yaml")
-	os.WriteFile(lazysecrets, []byte("spring:\n  secretPatterns:\n    keys: [\"url$\"]\n    values: []\n"), 0o644)
-	if keys, _ := p.Objects(ctx, yml, provider.TypeSecret); len(shown(keys)) != 1 || shown(keys)[0].Name != "spring.datasource.url" {
-		t.Errorf("repo's patterns: %v", keys)
-	}
-	os.WriteFile(lazysecrets, []byte("spring:\n  secretPatterns:\n    keys: [\"(\"]\n"), 0o644)
-	if _, err := p.Objects(ctx, yml, provider.TypeSecret); err == nil || !strings.Contains(err.Error(), ".lazysecrets.yaml: spring.secretPatterns.keys[0]") {
-		t.Errorf("bad pattern: %v", err)
-	}
-}
-
-func shown(objects []provider.Object) []provider.Object {
-	return slices.DeleteFunc(slices.Clone(objects), func(o provider.Object) bool { return o.Hidden })
-}
-
-func TestHiddenFiles(t *testing.T) {
-	root := gitRepo(t, map[string]string{
-		"a/application.yml": "server:\n  port: 8080\n",
-		"b/application.yml": "spring.datasource.password: x\n",
-	})
-	ctx := context.Background()
-	p := New(Settings{Dir: root})
-	srcs, _ := p.Sources(ctx)
-	if len(srcs) != 1 || srcs[0].Hidden {
-		t.Fatalf("sources: %+v", srcs)
-	}
-	cs, _ := p.Containers(ctx, srcs[0])
-	if len(cs) != 2 || !cs[0].Hidden || cs[1].Hidden {
-		t.Errorf("files: %+v", cs)
-	}
-
-	// A repo with only hidden files is hidden too.
-	root = gitRepo(t, map[string]string{"application.yml": "server:\n  port: 8080\n"})
-	srcs, _ = New(Settings{Dir: root}).Sources(ctx)
-	if len(srcs) != 1 || !srcs[0].Hidden {
-		t.Errorf("hidden repo: %+v", srcs)
-	}
-}

internal/ui/app/app.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"image/color"
+	"math"
 	"os"
 	"os/exec"
 	"strings"
@@ -232,7 +233,6 @@ type Model struct {
 	// provider finds it (provider.Current), before Sources lists them all.
 	current     *provider.Source
 	flatSources bool // Sources pane without provider groups
-	showHidden  bool // H: what providers hide is listed too, dimmed
 	sourcesFavs bool // Sources pane on its Favourites tab
 	history     bool // count uses of items (usage.go)
 	onActive    func()
@@ -470,7 +470,6 @@ func New(providers []provider.Provider, opts Options) Model {
 		Filter:      func(c provider.Container) string { return c.Name },
 		FilterExtra: func(c provider.Container) string { return m.store.Node(storeKey(c)).Note },
 		Render:      m.containerRender(false),
-		Hidden:      func(c provider.Container) bool { return c.Hidden },
 	})
 
 	m.secrets = panes.NewList("[3] Secrets", panes.Item[provider.Object]{
@@ -480,7 +479,6 @@ func New(providers []provider.Provider, opts Options) Model {
 		// Typing "expir" finds what has expired or soon will.
 		FilterExtra: func(o provider.Object) string { return m.store.Node(objectKey(o)).Note + " " + m.expiryWord(o) },
 		Render:      m.objectRender(),
-		Hidden:      func(o provider.Object) bool { return o.Hidden },
 	})
 	m.secrets.Empty = "no secrets"
 	m.objType, m.wantType = provider.TypeSecret, provider.TypeSecret
@@ -727,7 +725,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.versionsOf != nil {
 				m.setVersions(msg.items)
 			} else {
-				m.secrets.SetItems(m.starredObjectsFirst(msg.items))
+				m.secrets.SetItems(m.starredFirst(msg.items))
 				cmds = append(cmds, m.refreshShown(before))
 			}
 		}
@@ -982,8 +980,6 @@ func (m *Model) handleKey(msg tea.KeyPressMsg) (cmd tea.Cmd, quit bool) {
 		m.cycleZoom(-1)
 	case key.Matches(msg, k.SourcesView):
 		m.toggleSourcesView()
-	case key.Matches(msg, k.ToggleHidden):
-		m.toggleHidden()
 	case key.Matches(msg, k.Versions):
 		if m.versionsOf != nil {
 			m.closeVersions()
@@ -1261,7 +1257,7 @@ func (m *Model) showObjects(c provider.Container, key string) tea.Cmd {
 		m.secrets.SetLoading()
 		return m.loadObjects(c, m.objType, key)
 	}
-	m.secrets.SetItems(m.starredObjectsFirst(e.value))
+	m.secrets.SetItems(m.starredFirst(e.value))
 	m.secrets.Select(m.cache.cursor[key])
 	if e.fresh(m.now()) {
 		return nil
@@ -1680,8 +1676,12 @@ func (m *Model) copyText(label, text string, sensitive bool) tea.Cmd {
 
 // clipTick fires when the countdown's displayed second next changes.
 func (m *Model) clipTick() tea.Cmd {
+	wait := m.clipDeadline.Sub(m.now()) % time.Second
+	if wait <= 0 {
+		wait = time.Second
+	}
 	token := m.clipToken
-	return tea.Tick(untilNextSecond(m.clipDeadline, m.now()), func(time.Time) tea.Msg { return clipTickMsg{token: token} })
+	return tea.Tick(wait, func(time.Time) tea.Msg { return clipTickMsg{token: token} })
 }
 
 func (m *Model) cancelClipClear() {
@@ -1788,15 +1788,13 @@ func (m Model) footerView() string {
 	} else if l != nil && l.Filtering() {
 		help = m.helpBar(keys.FilterHelp{Map: m.keys}.ShortHelp(), 2)
 	} else {
-		reveal := "show"
-		if m.detail.State() == panes.ValueShown {
-			reveal = "hide"
-		}
-		help = m.helpBar(contextHelp{k: m.keys, focus: m.focus, of: m.detailOf(), commands: len(m.commandsHere()) > 0, account: m.fields.Shown(), reveal: reveal}.ShortHelp(), 2)
+		revealed := m.detail.State() == panes.ValueShown
+		help = m.helpBar(contextHelp{k: m.keys, focus: m.focus, of: m.detailOf(), commands: len(m.commandsHere()) > 0, account: m.fields.Shown(), revealed: &revealed}.ShortHelp(), 2)
 	}
 	var lines []string
 	if !m.clipDeadline.IsZero() {
-		lines = append(lines, m.flashLine(done(fmt.Sprintf("copied %s · clipboard clears in %ds", m.clipLabel, secondsLeft(m.clipDeadline, m.now())))))
+		left := max(0, int(math.Ceil(m.clipDeadline.Sub(m.now()).Seconds())))
+		lines = append(lines, m.flashLine(done(fmt.Sprintf("copied %s · clipboard clears in %ds", m.clipLabel, left))))
 	}
 	if m.flash.text != "" {
 		lines = append(lines, m.flashLine(m.flash))

internal/ui/app/app_test.go

@@ -1344,34 +1344,3 @@ func TestErrorLog(t *testing.T) {
 		t.Errorf("log %+v", d.m.errLog)
 	}
 }
-
-// hiding marks the secret db-password hidden, as the repo provider does
-// a Spring key that doesn't look secret.
-type hiding struct{ provider.Provider }
-
-func (h hiding) Objects(ctx context.Context, c provider.Container, t provider.ObjectType) ([]provider.Object, error) {
-	objs, err := h.Provider.Objects(ctx, c, t)
-	for i := range objs {
-		objs[i].Hidden = objs[i].Name == "db-password"
-	}
-	return objs, err
-}
-
-func TestToggleHidden(t *testing.T) {
-	t.Parallel()
-	d := newDriver(t, hiding{fake.Azure(0)})
-	if _, _, s := d.selected(); s == "db-password" || s == "" {
-		t.Fatalf("selected %q: the hidden one, or none", s)
-	}
-	if strings.Contains(d.screen(), "db-password") || !strings.Contains(d.screen(), "1 hidden") {
-		t.Fatalf("hidden one listed:\n%s", d.screen())
-	}
-	d.keys("H")
-	if !strings.Contains(d.screen(), "db-password") || !strings.Contains(d.screen(), "showing hidden") {
-		t.Fatalf("H doesn't show it:\n%s", d.screen())
-	}
-	d.keys("H")
-	if strings.Contains(d.screen(), "db-password") {
-		t.Fatalf("H again doesn't hide it:\n%s", d.screen())
-	}
-}

internal/ui/app/commands.go

@@ -306,6 +306,3 @@ func newTextInput(prompt string, width int) textinput.Model {
 	in.SetWidth(width)
 	return in
 }
-
-// pathInputWidth fits a link or a folder path in a prompt, in the window.
-func (m Model) pathInputWidth() int { return max(20, min(m.w-12, 64)) }

internal/ui/app/favourites.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	tea "charm.land/bubbletea/v2"
-	"github.com/charmbracelet/x/ansi"
 
 	"git.kebcloud.no/keb/lazysecrets/internal/cachefile"
 	"git.kebcloud.no/keb/lazysecrets/internal/expiry"
@@ -102,14 +101,11 @@ func (m Model) containerRender(withSource bool) func(styles.Styles, provider.Con
 		n := st.Node(storeKey(c))
 		line := c.Name
 		if c.Source.Kind == provider.KindRepo {
-			// A secret file: a lock for an encrypted one, a leaf
-			// for Spring config, a file in the warning colour for plain
-			// text, and its type after it ("sops · age", "env · plain text").
+			// A secret file: a lock for an encrypted one, a file in the
+			// warning colour for plain text, and its type after it
+			// ("sops · age", "env · plain text").
 			icon, style := iconSet.Encrypted, sty.KindRepo
-			switch {
-			case strings.HasPrefix(c.Detail, "spring"):
-				icon, style = iconSet.Spring, sty.Spring
-			case !strings.HasPrefix(c.Detail, "sops"):
+			if !strings.HasPrefix(c.Detail, "sops") {
 				icon, style = iconSet.PlainFile, sty.Warning
 			}
 			if icon != "" {
@@ -117,10 +113,10 @@ func (m Model) containerRender(withSource bool) func(styles.Styles, provider.Con
 			}
 			line += sty.Muted.Render("  " + c.Detail)
 		}
-		line = dimIf(sty, c.Hidden, marks(sty, n, c.Source.Provider, m.recentIcon, m.now())+line)
+		line = marks(sty, n, c.Source.Provider, m.recentIcon, m.now()) + line
 		if withSource {
 			src := c.Source.Name
-			if account := accountOf(c.Source); account != "" {
+			if account, ok := strings.CutPrefix(c.Source.ProviderLabel, string(c.Source.Kind)+" · "); ok {
 				src = account + " / " + src
 			}
 			line += sty.Muted.Render(" · " + src)
@@ -138,10 +134,6 @@ func (m Model) objectRender() func(styles.Styles, provider.Object, int) string {
 			line = sty.Muted.Render(o.Name + " (disabled)")
 		}
 		line = marks(sty, n, o.Container.Source.Provider, m.recentIcon, m.now()) + line
-		if o.Detail != "" {
-			line += sty.Muted.Render("  " + o.Detail)
-		}
-		line = dimIf(sty, o.Hidden, line)
 		switch state, left := m.expiry(o); state {
 		case expiry.Expired:
 			line += " " + sty.Error.Render("✗ expired")
@@ -152,45 +144,24 @@ func (m Model) objectRender() func(styles.Styles, provider.Object, int) string {
 	}
 }
 
-// dimIf draws a hidden item's row (shown with H) in the muted colour,
-// whole, so it stands apart from what's listed by the provider's rules.
-func dimIf(sty styles.Styles, hidden bool, line string) string {
-	if !hidden {
-		return line
-	}
-	return sty.Muted.Render(ansi.Strip(line))
-}
-
-// starredFirst moves starred items to the front, keeping the order
-// otherwise. It doesn't modify items, which may be cached.
-func starredFirst[T any](items []T, starred func(T) bool) []T {
-	rank := func(x T) int {
-		if starred(x) {
-			return 0
-		}
-		return 1
-	}
+// starredContainersFirst moves starred vaults and scopes to the front,
+// keeping the order otherwise. It doesn't modify items, which may be cached.
+func (m Model) starredContainersFirst(items []provider.Container) []provider.Container {
 	out := slices.Clone(items)
-	slices.SortStableFunc(out, func(a, b T) int { return rank(a) - rank(b) })
+	slices.SortStableFunc(out, func(a, b provider.Container) int {
+		return boolRank(m.store.Node(storeKey(a)).StarredFor(a.Source.Provider)) - boolRank(m.store.Node(storeKey(b)).StarredFor(b.Source.Provider))
+	})
 	return out
 }
 
-func (m Model) starredSourcesFirst(sources []provider.Source) []provider.Source {
-	return starredFirst(sources, func(s provider.Source) bool {
-		return m.store.Node(sourceKey(s)).StarredFor(s.Provider)
-	})
-}
-
-func (m Model) starredContainersFirst(items []provider.Container) []provider.Container {
-	return starredFirst(items, func(c provider.Container) bool {
-		return m.store.Node(storeKey(c)).StarredFor(c.Source.Provider)
-	})
-}
-
-func (m Model) starredObjectsFirst(items []provider.Object) []provider.Object {
-	return starredFirst(items, func(o provider.Object) bool {
-		return m.store.Node(objectKey(o)).StarredFor(o.Container.Source.Provider)
+// starredFirst moves starred objects to the front, keeping the order
+// otherwise. It doesn't modify items, which may be cached.
+func (m Model) starredFirst(items []provider.Object) []provider.Object {
+	out := slices.Clone(items)
+	slices.SortStableFunc(out, func(a, b provider.Object) int {
+		return boolRank(m.store.Node(objectKey(a)).StarredFor(a.Container.Source.Provider)) - boolRank(m.store.Node(objectKey(b)).StarredFor(b.Container.Source.Provider))
 	})
+	return out
 }
 
 // showLinkedContainers lists the vaults opened from links.
@@ -228,7 +199,7 @@ func (m *Model) resortStarred() {
 		m.containers.SetItems(m.starredContainersFirst(m.containers.Items()))
 	}
 	if m.versionsOf == nil {
-		m.secrets.SetItems(m.starredObjectsFirst(m.secrets.Items()))
+		m.secrets.SetItems(m.starredFirst(m.secrets.Items()))
 	}
 }
 
@@ -274,7 +245,7 @@ func (m *Model) toggleFavourite() tea.Cmd {
 		c := o.Container
 		toggle := func(n *store.Node) { on = n.ToggleStar(c.Source.Provider) }
 		if err = m.remember(objectKey(o), o.Name, []string{c.Source.Name, c.Name}, c.Source, toggle); err == nil {
-			m.secrets.SetItems(m.starredObjectsFirst(m.secrets.Items()))
+			m.secrets.SetItems(m.starredFirst(m.secrets.Items()))
 		}
 	}
 	switch {

internal/ui/app/help.go

@@ -39,9 +39,10 @@ type contextHelp struct {
 	commands bool // custom commands apply here
 	account  bool // the fourth pane shows Fields (fields.go)
 	of       pane // what the fourth pane describes
-	// reveal, when set, is what the reveal key will do, "show" or "hide":
-	// the same width so the bar doesn't shift.
-	reveal string
+	// revealed, when set, says whether the selected value is shown, so
+	// the reveal key says just what it'll do: show or hide, the same
+	// width so the bar doesn't shift.
+	revealed *bool
 }
 
 func (c contextHelp) ShortHelp() []key.Binding {
@@ -69,8 +70,8 @@ func (c contextHelp) ShortHelp() []key.Binding {
 		b = append(b, k.Enter, k.Share, k.ShareMenu, k.Favourite, k.Open, k.Filter)
 	default:
 		reveal := k.Reveal
-		if c.reveal != "" {
-			reveal = key.NewBinding(key.WithKeys(k.Reveal.Keys()...), key.WithHelp(k.Reveal.Help().Key, c.reveal))
+		if c.revealed != nil {
+			reveal = key.NewBinding(key.WithKeys(k.Reveal.Keys()...), key.WithHelp(k.Reveal.Help().Key, map[bool]string{false: "show", true: "hide"}[*c.revealed]))
 		}
 		b = append(b, reveal, k.Copy, k.Share, k.ShareMenu, k.Versions, k.Favourite, k.Filter)
 	}
@@ -258,7 +259,11 @@ func hint(b key.Binding, desc string) keyHint { return keyHint{keys.Name(b), des
 
 // move is "↑/↓ move" for an up and a down binding.
 func move(up, down key.Binding) keyHint {
-	return keyHint{joinKeys(up, down), "move"}
+	u, d := keys.Name(up), keys.Name(down)
+	if u == "" || d == "" {
+		return keyHint{u + d, "move"}
+	}
+	return keyHint{u + "/" + d, "move"}
 }
 
 // withKey fills a hint's format with the binding's key ("· %s loads

internal/ui/app/jump.go

@@ -38,13 +38,11 @@ func (m *Model) storeEntries() (favs, recent []option) {
 			return nil
 		}
 		var out []entry
-		detail := m.objectDetail(key)
 		add := func(path []string, acct string, depth int, run func(*Model) tea.Cmd) {
 			account := ""
 			if p, ok := m.byID[acct]; ok {
 				account = accountOf(provider.Source{Kind: p.Kind(), ProviderLabel: p.Label()})
 			}
-			account = strings.Trim(detail+" · "+account, " ·")
 			sort := strings.ToLower(strings.Join(path, "/")) + " " + account
 			out = append(out, entry{depth, sort, option{
 				label: m.pathLabel(r.Kind, path, account), note: n.Note, mark: " ",
@@ -159,19 +157,6 @@ func (m Model) inPlainEnv(r ref.Ref) bool {
 	return false
 }
 
-// objectDetail is the Detail of the secret with the store key key, as far
-// as the lists loaded tell.
-func (m Model) objectDetail(key string) string {
-	for _, e := range m.cache.objects {
-		for _, o := range e.value {
-			if o.Detail != "" && objectKey(o) == key {
-				return o.Detail
-			}
-		}
-	}
-	return ""
-}
-
 // repoLabel draws a repo, or a file in it, as everywhere else: the repo
 // icon and colour, "app / apps/api/.env".
 func (m Model) repoLabel(repo string, file ...string) string {
@@ -214,7 +199,18 @@ func (m *Model) jumpTo(r ref.Ref, n store.Node) tea.Cmd {
 		m.startNav(r, actGo, sourceRowKey(n.Account, n.Source))
 		return nil
 	}
-	choices := m.openWith(r.Kind, func(src provider.Source) bool { return src.ID == n.Source && n.Source != "" })
+	var choices []choice
+	for _, p := range m.providers {
+		if p.Kind() != r.Kind {
+			continue
+		}
+		for _, src := range m.sourceResults[p.ID()].sources {
+			if src.ID == n.Source && n.Source != "" {
+				row := sourceRowKey(p.ID(), src.ID)
+				choices = append(choices, choice{label: "Open with " + m.sourceLabel(row), sourceRow: row})
+			}
+		}
+	}
 	switch len(choices) {
 	case 0:
 		return m.openRef(r, actGo)

internal/ui/app/links.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"time"
 
+	"charm.land/bubbles/v2/textinput"
 	tea "charm.land/bubbletea/v2"
 
 	"git.kebcloud.no/keb/lazysecrets/internal/cachefile"
@@ -209,7 +210,18 @@ const defaultResolveTimeout = 30 * time.Second
 // openSource goes to a subscription or workspace, asking which account
 // when several list it. Sources are loaded already, so it needs no lookup.
 func (m *Model) openSource(r ref.Ref) {
-	choices := m.openWith(r.Kind, func(src provider.Source) bool { return sourceMatches(r, src) })
+	var choices []choice
+	for _, p := range m.providers {
+		if p.Kind() != r.Kind {
+			continue
+		}
+		for _, src := range m.sourceResults[p.ID()].sources {
+			if sourceMatches(r, src) {
+				row := sourceRowKey(p.ID(), src.ID)
+				choices = append(choices, choice{label: "Open with " + m.sourceLabel(row), sourceRow: row})
+			}
+		}
+	}
 	if row, ok := preferredRow(r, choices); ok {
 		choices = []choice{{sourceRow: row}}
 	}
@@ -231,24 +243,6 @@ func (m *Model) openSource(r ref.Ref) {
 	}
 }
 
-// openWith offers each loaded source of kind that matches, one per
-// account that lists it.
-func (m Model) openWith(kind provider.Kind, matches func(provider.Source) bool) []choice {
-	var choices []choice
-	for _, p := range m.providers {
-		if p.Kind() != kind {
-			continue
-		}
-		for _, src := range m.sourceResults[p.ID()].sources {
-			if matches(src) {
-				row := sourceRowKey(p.ID(), src.ID)
-				choices = append(choices, choice{label: "Open with " + m.sourceLabel(row), sourceRow: row})
-			}
-		}
-	}
-	return choices
-}
-
 // refLabel draws what a link points at like the favourites list: the
 // provider's icon and the path in its colour, "󰠅 platform-prod /
 // kv-app-prod / api-key", with the type and version after it. The
@@ -837,8 +831,10 @@ func (m *Model) shareObject(o provider.Object, k string) tea.Cmd {
 }
 
 func (m *Model) startOpenPrompt() tea.Cmd {
-	in := newTextInput("open: ", m.pathInputWidth())
+	in := textinput.New()
+	in.Prompt = "open: "
 	in.Placeholder = "lazysecrets:// link, Key Vault URL or reference"
+	in.SetWidth(max(20, min(m.w-12, 64)))
 	m.prompt = &modal{
 		title: "Open a link", input: &in,
 		lines:  []string{m.st.Muted.Render("lazysecrets:// link, Key Vault URL or reference")},

internal/ui/app/modal.go

@@ -75,8 +75,10 @@ type modal struct {
 
 // showFilterMenu opens a menu with a filter input above the options.
 func (m *Model) showFilterMenu(title string, options []option) tea.Cmd {
-	in := newTextInput("/", 40)
+	in := textinput.New()
+	in.Prompt = "/"
 	in.Placeholder = "type to filter"
+	in.SetWidth(40)
 	m.prompt = &modal{title: title, options: options, all: options, filter: &in}
 	m.prompt.move(0)
 	m.flash = flash{}

internal/ui/app/notes.go

@@ -3,6 +3,7 @@ package app
 import (
 	"strings"
 
+	"charm.land/bubbles/v2/textinput"
 	tea "charm.land/bubbletea/v2"
 	"github.com/charmbracelet/x/ansi"
 
@@ -57,9 +58,11 @@ func (m *Model) editNote() tea.Cmd {
 		c := o.Container
 		key, name, path, src = objectKey(o), o.Name, []string{c.Source.Name, c.Name}, c.Source
 	}
-	in := newTextInput("note: ", 48)
+	in := textinput.New()
+	in.Prompt = "note: "
 	in.Placeholder = "e.g. prod SQL admin"
 	in.CharLimit = 80
+	in.SetWidth(48)
 	in.SetValue(m.store.Node(key).Note)
 	in.CursorEnd()
 	m.prompt = &modal{

internal/ui/app/persist.go

@@ -29,43 +29,41 @@ type persistTickMsg struct{}
 
 type persistedMsg struct{ err error }
 
-// keepers report whether a provider ID, or a cache key's, is an account
-// that still exists and isn't a repo.
-func (m *Model) keepers() (keep, keepKey func(string) bool) {
-	keep = cachefile.Keep(m.providers)
-	return keep, func(key string) bool { return keep(cachefile.ProviderOf(key)) }
-}
+// keepCached reports whether a cache key's account still exists and
+// isn't a repo: every key starts with the provider ID.
+func (m *Model) keepCached(key string) bool { return m.keepProvider(cachefile.ProviderOf(key)) }
+
+func (m *Model) keepProvider(id string) bool { return cachefile.Keep(m.providers)(id) }
 
 // loadCacheFile fills the cache from the file, leaving out what's too
 // old or belongs to accounts that aren't signed in any more.
 func (m *Model) loadCacheFile() {
 	f := cachefile.Read(m.cachePath)
-	keep, keepKey := m.keepers()
 	now := m.now()
 	recent := func(at time.Time) bool { return now.Sub(at) < cachefile.MaxAge }
 	for id, e := range f.Sources {
-		if keep(id) && recent(e.At) {
+		if m.keepProvider(id) && recent(e.At) {
 			m.sourceResults[id] = sourcesMsg{gen: m.sourcesGen, provider: id, sources: e.Value}
 			m.sourcesAt[id] = e.At
 		}
 	}
 	for k, e := range f.Containers {
-		if keepKey(k) && recent(e.At) {
+		if m.keepCached(k) && recent(e.At) {
 			m.cache.containers[k] = entry[[]provider.Container]{e.Value, e.At}
 		}
 	}
 	for k, e := range f.Objects {
-		if keepKey(k) && recent(e.At) {
+		if m.keepCached(k) && recent(e.At) {
 			m.cache.objects[k] = entry[[]provider.Object]{e.Value, e.At}
 		}
 	}
 	for k, e := range f.Details {
-		if keepKey(k) && recent(e.At) {
+		if m.keepCached(k) && recent(e.At) {
 			m.cache.details[k] = entry[provider.Object]{e.Value, e.At}
 		}
 	}
 	for k, v := range f.Cursor {
-		if keepKey(k) {
+		if m.keepCached(k) {
 			m.cache.cursor[k] = v
 		}
 	}
@@ -74,30 +72,29 @@ func (m *Model) loadCacheFile() {
 // cacheSnapshot is the cache as the file holds it.
 func (m *Model) cacheSnapshot() cachefile.File {
 	f := cachefile.New()
-	keep, keepKey := m.keepers()
 	f.Dropped, m.cacheDropped = m.cacheDropped, nil
 	for id, r := range m.sourceResults {
-		if r.err == nil && keep(id) {
+		if r.err == nil && m.keepProvider(id) {
 			f.Sources[id] = cachefile.Stamped[[]provider.Source]{At: m.sourcesAt[id], Value: r.sources}
 		}
 	}
 	for k, e := range m.cache.containers {
-		if keepKey(k) {
+		if m.keepCached(k) {
 			f.Containers[k] = cachefile.Stamped[[]provider.Container]{At: e.at, Value: e.value}
 		}
 	}
 	for k, e := range m.cache.objects {
-		if keepKey(k) {
+		if m.keepCached(k) {
 			f.Objects[k] = cachefile.Stamped[[]provider.Object]{At: e.at, Value: e.value}
 		}
 	}
 	for k, e := range m.cache.details {
-		if keepKey(k) {
+		if m.keepCached(k) {
 			f.Details[k] = cachefile.Stamped[provider.Object]{At: e.at, Value: e.value}
 		}
 	}
 	for k, v := range m.cache.cursor {
-		if keepKey(k) {
+		if m.keepCached(k) {
 			f.Cursor[k] = v
 		}
 	}

internal/ui/app/reveal.go

@@ -28,22 +28,12 @@ func (m *Model) startRevealTimer() tea.Cmd {
 
 // revealTickCmd fires when the displayed second next changes.
 func (m *Model) revealTickCmd() tea.Cmd {
-	token := m.revealToken
-	return tea.Tick(untilNextSecond(m.revealDeadline, m.now()), func(time.Time) tea.Msg { return revealTickMsg{token} })
-}
-
-// untilNextSecond is how long until a countdown to deadline shows its
-// next whole second.
-func untilNextSecond(deadline, now time.Time) time.Duration {
-	if wait := deadline.Sub(now) % time.Second; wait > 0 {
-		return wait
+	wait := m.revealDeadline.Sub(m.now()) % time.Second
+	if wait <= 0 {
+		wait = time.Second
 	}
-	return time.Second
-}
-
-// secondsLeft is a countdown to deadline, in whole seconds rounded up.
-func secondsLeft(deadline, now time.Time) int {
-	return max(0, int(math.Ceil(deadline.Sub(now).Seconds())))
+	token := m.revealToken
+	return tea.Tick(wait, func(time.Time) tea.Msg { return revealTickMsg{token} })
 }
 
 func (m *Model) revealTick(msg revealTickMsg) tea.Cmd {
@@ -59,7 +49,8 @@ func (m *Model) revealTick(msg revealTickMsg) tea.Cmd {
 }
 
 func (m *Model) showHidesIn() {
-	m.detail.SetHidesIn(fmt.Sprintf("%ds", secondsLeft(m.revealDeadline, m.now())))
+	left := max(0, int(math.Ceil(m.revealDeadline.Sub(m.now()).Seconds())))
+	m.detail.SetHidesIn(fmt.Sprintf("%ds", left))
 }
 
 // hideValue hides the revealed value and stops its countdown.

internal/ui/app/search.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 
 	tea "charm.land/bubbletea/v2"
-	"github.com/charmbracelet/x/ansi"
 
 	"git.kebcloud.no/keb/lazysecrets/internal/cachefile"
 	"git.kebcloud.no/keb/lazysecrets/internal/provider"
@@ -67,44 +66,31 @@ func (m *Model) searchEntries() (sources, items []option) {
 				mark: mark, run: run, reload: reload, id: sort, group: row, kind: kind}})
 		return &es[len(es)-1].opt
 	}
-	// What providers hide is left out, unless H shows it, dimmed.
-	skip := func(hidden bool) bool { return hidden && !m.showHidden }
-	dim := func(hidden bool, e *option) {
-		if hidden {
-			e.label = m.st.Muted.Render(ansi.Strip(e.label))
-		}
-	}
 	for _, p := range m.providers {
 		for _, src := range m.sourceResults[p.ID()].sources {
-			if skip(src.Hidden) {
-				continue
-			}
 			src.Provider, src.ProviderLabel = p.ID(), p.Label()
 			row := sourceRowKey(p.ID(), src.ID)
-			dim(src.Hidden, add(0, row, src.Kind, []string{src.Name}, accountOf(src), sourceKey(src), m.sourceMark(row), func(m *Model) tea.Cmd {
+			add(0, row, src.Kind, []string{src.Name}, accountOf(src), sourceKey(src), m.sourceMark(row), func(m *Model) tea.Cmd {
 				m.nav = &nav{sourceRow: row, sourceOnly: true}
 				return nil
-			}, func(m *Model) tea.Cmd { return m.loadSource(src) }))
+			}, func(m *Model) tea.Cmd { return m.loadSource(src) })
 			for _, c := range m.cache.containers[row].value {
-				if skip(c.Hidden) {
-					continue
-				}
 				r, err := ref.ForContainer(c, provider.TypeSecret)
 				if err != nil {
 					continue
 				}
 				reload := func(m *Model) tea.Cmd { return m.loadContainer(c) }
-				dim(c.Hidden, add(1, row, c.Source.Kind, []string{src.Name, c.Name}, accountOf(src), storeKey(c), m.vaultMark(c), func(m *Model) tea.Cmd {
+				add(1, row, c.Source.Kind, []string{src.Name, c.Name}, accountOf(src), storeKey(c), m.vaultMark(c), func(m *Model) tea.Cmd {
 					m.startNav(r, actGo, row)
 					return nil
-				}, reload))
+				}, reload)
 				for _, t := range []provider.ObjectType{provider.TypeSecret, provider.TypeKey, provider.TypeCertificate} {
 					for _, o := range m.cache.objects[cachefile.ObjectsKey(c, t)].value {
 						r, err := ref.ForObject(o, "")
-						if err != nil || skip(o.Hidden) {
+						if err != nil {
 							continue
 						}
-						suffix := strings.Trim(o.Detail+" · "+accountOf(src), " ·")
+						suffix := accountOf(src)
 						if t != provider.TypeSecret {
 							typ := strings.TrimSuffix(strings.ToLower(pluralLabels[t]), "s") // "key"
 							suffix = strings.Trim(typ+" · "+suffix, " ·")
@@ -114,7 +100,6 @@ func (m *Model) searchEntries() (sources, items []option) {
 							return nil
 						}, reload)
 						e.plain = c.Detail == provider.DetailPlainEnv
-						dim(o.Hidden, e)
 					}
 				}
 			}
@@ -356,19 +341,6 @@ func (m *Model) handleCrawl(msg crawlMsg) tea.Cmd {
 	return cmd
 }
 
-// vaultsLoaded counts the vaults whose secrets are cached or can't be
-// read, and says whether any are loading.
-func (m *Model) vaultsLoaded(vaults []provider.Container) (loaded int, loading bool) {
-	for _, c := range vaults {
-		key := cachefile.ObjectsKey(c, provider.TypeSecret)
-		loading = loading || m.crawl.pending[key]
-		if _, ok := m.cache.objects[key]; ok || m.crawl.failed[key] {
-			loaded++
-		}
-	}
-	return loaded, loading
-}
-
 // sourceMark shows how much of a subscription or workspace is loaded:
 // ○ nothing, ◐ some vaults, ● every vault, ◌ loading, ✗ unreadable.
 func (m *Model) sourceMark(row string) string {
@@ -382,7 +354,14 @@ func (m *Model) sourceMark(row string) string {
 	if !ok {
 		return m.st.Muted.Render("○")
 	}
-	loaded, loading := m.vaultsLoaded(e.value)
+	loaded, loading := 0, false
+	for _, c := range e.value {
+		key := cachefile.ObjectsKey(c, provider.TypeSecret)
+		loading = loading || m.crawl.pending[key]
+		if _, ok := m.cache.objects[key]; ok || m.crawl.failed[key] {
+			loaded++
+		}
+	}
 	switch {
 	case loading:
 		return m.st.Muted.Render("◌")

internal/ui/app/searchview.go

@@ -95,7 +95,9 @@ func (m *Model) showFavourites() tea.Cmd { return m.openGoTo(tabFavs, false) }
 func (m *Model) showRecent() tea.Cmd     { return m.openGoTo(tabRecent, false) }
 
 func (m *Model) openGoTo(tab int, typing bool) tea.Cmd {
-	in := newTextInput("/", searchWidth(m.w)-6) // as wide as the popup
+	in := textinput.New()
+	in.Prompt = "/"
+	in.SetWidth(searchWidth(m.w) - 6) // as wide as the popup
 	v := &searchView{input: in, tab: tab, results: true}
 	v.favs, v.recent = m.storeEntries()
 	m.search = v
@@ -614,7 +616,13 @@ func (m Model) loadHint() string {
 		}
 		return m.st.Warning.Render("⚠ not loaded" + withKey(m.loadKey(), " · %s loads "+name))
 	}
-	loaded, _ := m.vaultsLoaded(e.value)
+	loaded := 0
+	for _, c := range e.value {
+		key := cachefile.ObjectsKey(c, provider.TypeSecret)
+		if _, ok := m.cache.objects[key]; ok || m.crawl.failed[key] {
+			loaded++
+		}
+	}
 	if loaded == len(e.value) {
 		return ""
 	}
@@ -762,7 +770,7 @@ func (m Model) searchViewBox() string {
 				body = append(body, " "+m.st.Error.Render(l))
 			}
 		}
-		body = append(body, "", " "+panes.Tabs(m.st, ts, tabNames[:], m.search.tab))
+		body = append(body, "", " "+m.goToTabs(ts))
 	}
 	body = append(body, " "+v.input.View(), "")
 	for _, l := range strings.Split(lists, "\n") {
@@ -795,7 +803,7 @@ func (m Model) searchViewBox() string {
 	// Tabs in the title, the current one underlined, like the panes; a
 	// picker has its own title, and the tabs over the input.
 	if v.picker == nil {
-		head := ts.Render(goToTitle+" ") + panes.Tabs(m.st, ts, tabNames[:], m.search.tab)
+		head := ts.Render(goToTitle+" ") + m.goToTabs(ts)
 		return panes.Box(m.st, head, foot, body, w, len(body)+2, focused)
 	}
 	// A picker: in its own border, under what it's for.
@@ -848,3 +856,19 @@ func pickable(o option) (ref.Ref, bool) {
 	}
 	return r, true
 }
+
+// goToTabs draws Go to's tabs, the current one underlined.
+func (m Model) goToTabs(ts lipgloss.Style) string {
+	var out string
+	for i, name := range tabNames {
+		if i > 0 {
+			out += ts.Render(" - ")
+		}
+		if i == m.search.tab {
+			out += ts.Underline(true).Render(name)
+		} else {
+			out += m.st.Muted.Render(name)
+		}
+	}
+	return out
+}

internal/ui/app/sharefiles.go

@@ -10,6 +10,7 @@ import (
 	"slices"
 	"strings"
 
+	"charm.land/bubbles/v2/textinput"
 	tea "charm.land/bubbletea/v2"
 	"github.com/charmbracelet/x/ansi"
 
@@ -71,7 +72,7 @@ func (m *Model) shareFiles(src provider.Source, cs []provider.Container) tea.Cmd
 				return msg
 			}
 			for _, c := range all {
-				if c.Detail == provider.DetailPlainEnv && !c.Hidden { // not .env.example
+				if c.Detail == provider.DetailPlainEnv {
 					cs = append(cs, c)
 				}
 			}
@@ -337,7 +338,9 @@ func (m *Model) openFailed(s share.Sealed, err error, whole bool) {
 // askShareDir asks where to save files from a repo that isn't here. It
 // stays until they're saved, saying why when they can't be.
 func (m *Model) askShareDir(msg shareOpenedMsg) tea.Cmd {
-	in := newTextInput("folder: ", m.pathInputWidth())
+	in := textinput.New()
+	in.Prompt = "folder: "
+	in.SetWidth(max(20, min(m.w-12, 64)))
 	dir := m.placeDir
 	if dir == "" {
 		dir, _ = os.Getwd()

internal/ui/app/sources.go

@@ -59,7 +59,6 @@ func sourceRowID(r sourceRow) string {
 }
 
 func newSourcesList(iconSet icons.Set, mem *store.Store, recent bool) panes.List[sourceRow] {
-	render := renderSourceRow(iconSet, mem, recent)
 	return panes.NewList("[1] Sources", panes.Item[sourceRow]{
 		ID: sourceRowID,
 		// Headers have no filter text, so filtering shows just sources.
@@ -78,48 +77,40 @@ func newSourcesList(iconSet icons.Set, mem *store.Store, recent bool) panes.List
 			return cmp.Or(r.source.ProviderLabel, string(r.group)) + " " + mem.Node(sourceKey(r.source)).Note
 		},
 		Render: func(st styles.Styles, r sourceRow, width int) string {
-			return dimIf(st, r.kind == rowSource && r.source.Hidden, render(st, r, width))
+			node := mem.Node(sourceKey(r.source))
+			kind := st.Kind(r.group)
+			starred := ""
+			if r.kind == rowSource {
+				starred = marks(st, node, r.source.Provider, recent, time.Now())
+			}
+			switch {
+			case r.kind == rowLinks:
+				return st.Notice.Render("↗ Opened links") + " " + st.Muted.Render(fmt.Sprintf("(%s)", r.status))
+			case r.kind == rowSource && r.top:
+				return withNote(st, kind.Render(iconSet.Prefix(r.group)+"Repo · ")+starred+kind.Render(r.source.Name), node.Note, width)
+			case r.kind == rowSource && r.flat:
+				line := kind.Render(iconSet.Prefix(r.group)+fmt.Sprintf("%-10s", r.group)) + " " + starred + r.source.Name
+				if r.account != "" {
+					line += st.Muted.Render(" · " + r.account)
+				}
+				return withNote(st, line+here(st, r.source), node.Note, width)
+			case r.kind == rowSource:
+				// The provider's colour, so long groups stay recognisable.
+				return withNote(st, "  "+starred+kind.Render(r.source.Name), node.Note, width)
+			}
+			arrow := "▾"
+			if r.collapsed {
+				arrow = "▸"
+			}
+			status := st.Muted.Render(fmt.Sprintf("(%s)", r.status))
+			if r.status == "!" {
+				status = st.Error.Render("(!)")
+			}
+			return kind.Render(arrow+" "+iconSet.Prefix(r.group)+r.label) + " " + status
 		},
 	})
 }
 
-// renderSourceRow draws a source, a provider's header or the Opened links
-// row.
-func renderSourceRow(iconSet icons.Set, mem *store.Store, recent bool) func(styles.Styles, sourceRow, int) string {
-	return func(st styles.Styles, r sourceRow, width int) string {
-		node := mem.Node(sourceKey(r.source))
-		kind := st.Kind(r.group)
-		starred := ""
-		if r.kind == rowSource {
-			starred = marks(st, node, r.source.Provider, recent, time.Now())
-		}
-		switch {
-		case r.kind == rowLinks:
-			return st.Notice.Render("↗ Opened links") + " " + st.Muted.Render(fmt.Sprintf("(%s)", r.status))
-		case r.kind == rowSource && r.top:
-			return withNote(st, kind.Render(iconSet.Prefix(r.group)+"Repo · ")+starred+kind.Render(r.source.Name), node.Note, width)
-		case r.kind == rowSource && r.flat:
-			line := kind.Render(iconSet.Prefix(r.group)+fmt.Sprintf("%-10s", r.group)) + " " + starred + r.source.Name
-			if r.account != "" {
-				line += st.Muted.Render(" · " + r.account)
-			}
-			return withNote(st, line+here(st, r.source), node.Note, width)
-		case r.kind == rowSource:
-			// The provider's colour, so long groups stay recognisable.
-			return withNote(st, "  "+starred+kind.Render(r.source.Name), node.Note, width)
-		}
-		arrow := "▾"
-		if r.collapsed {
-			arrow = "▸"
-		}
-		status := st.Muted.Render(fmt.Sprintf("(%s)", r.status))
-		if r.status == "!" {
-			status = st.Error.Render("(!)")
-		}
-		return kind.Render(arrow+" "+iconSet.Prefix(r.group)+r.label) + " " + status
-	}
-}
-
 // rebuildSources lays out the Sources pane from the per-provider results.
 func (m *Model) rebuildSources() {
 	// While filtering, headers drop out, so rows show their provider and
@@ -138,16 +129,20 @@ func (m *Model) rebuildSources() {
 	}
 	// The repo lazysecrets started in gets a row of its own on top, so it
 	// opens on it; flat, it sorts first instead.
-	if src, ok := m.currentSource(); ok && !flat && (!src.Hidden || m.showHidden) {
+	if src, ok := m.currentSource(); ok && !flat {
 		rows = append(rows, sourceRow{kind: rowSource, group: src.Kind, provider: src.Provider, top: true, source: src})
 	}
 	for _, p := range m.providers {
 		kind, id := p.Kind(), p.ID()
-		account := accountOf(provider.Source{Kind: kind, ProviderLabel: p.Label()})
+		account, _ := strings.CutPrefix(p.Label(), string(kind)+" · ")
+		if account == p.Label() {
+			account = ""
+		}
 		r, done := m.sourceResults[id]
-		sources := slices.DeleteFunc(slices.Clone(r.sources), func(s provider.Source) bool {
-			return (s.Here && !flat) || (s.Hidden && !m.showHidden)
-		})
+		sources := r.sources
+		if !flat {
+			sources = slices.DeleteFunc(slices.Clone(sources), func(s provider.Source) bool { return s.Here })
+		}
 		if kind == provider.KindRepo && !(done && (r.err != nil || len(sources) > 0)) {
 			continue // repos show once some are found to have secret files
 		}
@@ -220,6 +215,17 @@ func (m Model) currentSource() (provider.Source, bool) {
 	return provider.Source{}, false
 }
 
+// starredSourcesFirst moves starred sources to the front, keeping the
+// order otherwise. It doesn't modify sources.
+func (m Model) starredSourcesFirst(sources []provider.Source) []provider.Source {
+	out := slices.Clone(sources)
+	rank := func(s provider.Source) int {
+		return boolRank(m.store.Node(sourceKey(s)).StarredFor(s.Provider))
+	}
+	slices.SortStableFunc(out, func(a, b provider.Source) int { return rank(a) - rank(b) })
+	return out
+}
+
 // starRank orders the Favourites row, then starred sources, then the rest.
 func starRank(mem *store.Store, r sourceRow) int {
 	switch {
@@ -233,6 +239,13 @@ func starRank(mem *store.Store, r sourceRow) int {
 	return 3
 }
 
+func boolRank(starred bool) int {
+	if starred {
+		return 0
+	}
+	return 1
+}
+
 // selectedSource is the source under the cursor; false on a header.
 func (m Model) selectedSource() (provider.Source, bool) {
 	r, ok := m.sources.Selected()
@@ -247,18 +260,6 @@ func (m Model) onLinks() bool {
 	return m.sources.SelectedID() == linksRowID
 }
 
-// toggleHidden lists what providers hide, dimmed, or leaves it out again.
-func (m *Model) toggleHidden() {
-	m.showHidden = !m.showHidden
-	m.containers.SetShowHidden(m.showHidden)
-	m.secrets.SetShowHidden(m.showHidden)
-	m.rebuildSources()
-	m.flash = flash{text: "hidden items hidden"}
-	if m.showHidden {
-		m.flash = flash{text: "showing hidden items, dimmed"}
-	}
-}
-
 // toggleSourcesView switches between grouped and flat, keeping the cursor
 // on the same source.
 func (m *Model) toggleSourcesView() {

internal/ui/app/update.go

@@ -2,11 +2,13 @@ package app
 
 import (
 	"context"
+	"errors"
 	"strings"
 	"time"
 
 	tea "charm.land/bubbletea/v2"
 
+	"git.kebcloud.no/keb/lazysecrets/internal/browser"
 	"git.kebcloud.no/keb/lazysecrets/internal/store"
 	"git.kebcloud.no/keb/lazysecrets/internal/update"
 )
@@ -128,7 +130,15 @@ func (m *Model) showUpdate() {
 		run: func(m *Model) tea.Cmd { return m.install(r) }}}
 	if r.URL != "" {
 		opts = append(opts, option{key: "o", label: "Open the release page", run: func(m *Model) tea.Cmd {
-			return m.openPage("the release page", r.URL, func() {})
+			switch err := m.openURL(r.URL); {
+			case errors.Is(err, browser.ErrRemote):
+				cmd := m.copyText("link to the release", r.URL, false)
+				m.flash.text += " (can't open a browser over SSH)"
+				return cmd
+			case err != nil:
+				m.flash = flash{text: "open: " + err.Error(), isErr: true}
+			}
+			return nil
 		}})
 	}
 	m.showMenu("lazysecrets "+r.Tag, lines, opts)

internal/ui/icons/icons.go

@@ -11,7 +11,6 @@ type Set struct {
 	Repo       string
 	Encrypted  string // an encrypted file (SOPS)
 	PlainFile  string // a plain text secrets file (.env)
-	Spring     string // a Spring Boot config file
 	Note       string // has a note (lazysecrets list)
 }
 
@@ -26,7 +25,6 @@ var NerdFont = Set{
 	Repo:       "\U000F02A2", // md-git
 	Encrypted:  "\U000F033E", // md-lock
 	PlainFile:  "\U000F0214", // md-file
-	Spring:     "\U000F032A", // md-leaf
 	Note:       "\U000F09ED",
 }
 

internal/ui/keys/keys.go

@@ -45,7 +45,6 @@ type Map struct {
 	Recent                            key.Binding
 	Note, Share, ShareMenu, OpenRef   key.Binding
 	Search, SourcesView, Commands     key.Binding
-	ToggleHidden                      key.Binding
 	SplitLeft, SplitRight, SplitReset key.Binding
 	Taller, Shorter, ZoomIn, ZoomOut  key.Binding
 	Login, Refresh, Help, Quit        key.Binding
@@ -103,7 +102,6 @@ func (m *Map) Actions() []Action {
 		a(Lists, "prevTab", &m.PrevTab, "prev tab", "lists", "Previous tab of the focused pane: Sources and Favourites in Sources; Secrets, Keys, Certs in Secrets."),
 		a(Lists, "nextTab", &m.NextTab, "next tab", "lists", "Next tab of the focused pane."),
 		a(Lists, "sourcesView", &m.SourcesView, "grouped/flat sources", "lists", "Switch the Sources pane between grouped by provider and a flat list."),
-		a(Lists, "toggleHidden", &m.ToggleHidden, "show/hide hidden", "lists", "Show or hide what's hidden: Spring config keys that don't look like secrets, and files and repos with only those. Shown, they're dimmed; Go to finds them too."),
 		a(Lists, "star", &m.Favourite, "star", "lists", "Star or unstar the selected subscription, vault or secret, for the account showing it. Starred items get a ★ and sort first."),
 		a(Lists, "goTo", &m.Search, "search", "lists", "Go to anything: search every vault and secret loaded and jump to one. Again in Go to: only the source or group you're in, and back to all. On the left, the scope: All, an account (or Databricks, or Repos), or one source (○ ◐ ● for how much of it is loaded)."),
 		a(Lists, "favourites", &m.Favourites, "favourites", "lists", "Go to, on Favourites: everything you've starred, to search and jump to."),
@@ -187,7 +185,7 @@ var defaults = map[string][]string{
 	"lists.nextPane": {"tab"}, "lists.prevPane": {"shift+tab", "h", "left"}, "lists.details": {"l", "right"},
 	"lists.pane1": {"1"}, "lists.pane2": {"2"}, "lists.pane3": {"3"}, "lists.pane4": {"4"}, "lists.pane0": {"0"},
 	"lists.open": {"enter"}, "lists.back": {"esc", "backspace"},
-	"lists.filter": {"/"}, "lists.prevTab": {"["}, "lists.nextTab": {"]"}, "lists.sourcesView": {"`"}, "lists.toggleHidden": {"H"},
+	"lists.filter": {"/"}, "lists.prevTab": {"["}, "lists.nextTab": {"]"}, "lists.sourcesView": {"`"},
 	"lists.star": {"f"}, "lists.favourites": {"F"}, "lists.recent": {"R"}, "lists.goTo": {"ctrl+s"}, "lists.note": {"n"},
 	"lists.commands": {"x"},
 	"lists.reveal":   {"space"}, "lists.copyValue": {"y"}, "lists.copyReference": {"Y"},

internal/ui/panes/box.go

@@ -69,20 +69,3 @@ func TitleStyle(st styles.Styles, focused bool) lipgloss.Style {
 	}
 	return st.TitleBlurred
 }
-
-// Tabs draws tab names for a title in style ts, the current one
-// underlined and the rest muted.
-func Tabs(st styles.Styles, ts lipgloss.Style, names []string, current int) string {
-	var out string
-	for i, name := range names {
-		if i > 0 {
-			out += ts.Render(" - ")
-		}
-		if i == current {
-			out += ts.Underline(true).Render(name)
-		} else {
-			out += st.Muted.Render(name)
-		}
-	}
-	return out
-}

internal/ui/panes/detail.go

@@ -188,31 +188,20 @@ func carryStyle(lines []string) []string {
 	return lines
 }
 
-var valueIndent = strings.Repeat(" ", 12)
-
-// fieldLabel starts a detail line: the label, padded so values line up
-// at valueIndent.
-func fieldLabel(st styles.Styles, label string) string {
-	return " " + st.Label.Render(fmt.Sprintf("%-10s", label)) + " "
-}
-
 // lines renders the body, wrapped to the pane width.
 func (d Detail) lines(st styles.Styles) []string {
 	inner := max(1, d.w-3)
 	var out []string
 	field := func(label, value string) {
+		prefix := " " + st.Label.Render(fmt.Sprintf("%-10s", label)) + " "
+		indent := strings.Repeat(" ", 12)
 		wrapped := carryStyle(strings.Split(ansi.Hardwrap(value, max(1, inner-11), true), "\n"))
-		out = append(out, fieldLabel(st, label)+wrapped[0])
+		out = append(out, prefix+wrapped[0])
 		for _, w := range wrapped[1:] {
-			out = append(out, valueIndent+w)
+			out = append(out, indent+w)
 		}
 	}
 	muted := st.Muted.Render
-	note := func() {
-		if d.note != "" {
-			field("note", st.Favourite.Render(d.note))
-		}
-	}
 
 	if d.container == nil {
 		return []string{muted(" Select a vault or scope to browse its secrets.")}
@@ -222,27 +211,30 @@ func (d Detail) lines(st styles.Styles) []string {
 	if containerLabel == "" {
 		containerLabel = "vault"
 	}
-	source := d.Icons.Prefix(c.Source.Kind) + cmp.Or(c.Source.ProviderLabel, string(c.Source.Kind)) + " / " + c.Source.Name
 
 	if d.secret == nil {
 		field(containerLabel, c.Name)
-		note()
+		if d.note != "" {
+			field("note", st.Favourite.Render(d.note))
+		}
 		if c.Detail != "" {
 			field("", muted(c.Detail))
 		}
-		field("source", source)
+		field("source", d.Icons.Prefix(c.Source.Kind)+cmp.Or(c.Source.ProviderLabel, string(c.Source.Kind))+" / "+c.Source.Name)
 		out = append(out, "", muted(" Select a secret to see its details."))
 		return out
 	}
 
 	s := *d.secret
 	field("name", s.Name)
-	note()
+	if d.note != "" {
+		field("note", st.Favourite.Render(d.note))
+	}
 	field(containerLabel, c.Name)
 	if c.Source.Kind != provider.KindAzure && c.Detail != "" {
 		field("", muted(c.Detail))
 	}
-	field("source", source)
+	field("source", d.Icons.Prefix(c.Source.Kind)+cmp.Or(c.Source.ProviderLabel, string(c.Source.Kind))+" / "+c.Source.Name)
 	if s.Version != "" {
 		field("version", s.Version)
 	}
@@ -306,12 +298,14 @@ func (d Detail) lines(st styles.Styles) []string {
 	case provider.TypeCertificate:
 		label, hidden, reveal = "cert", "", "show the certificate"
 	}
+	indent := strings.Repeat(" ", 12)
+
 	out = append(out, "")
 	switch d.state {
 	case ValueHidden:
 		if hidden != "" {
 			field(label, hidden)
-			out = append(out, valueIndent+hints(reveal))
+			out = append(out, indent+hints(reveal))
 		} else {
 			field(label, hints(reveal))
 		}
@@ -328,29 +322,23 @@ func (d Detail) lines(st styles.Styles) []string {
 			for j, w := range strings.Split(ansi.Wrap(text, max(1, inner-11-len(lead)), ""), "\n") {
 				w = lead + w
 				if i == 0 && j == 0 {
-					out = append(out, fieldLabel(st, label)+st.Error.Render(w))
+					out = append(out, " "+st.Label.Render(fmt.Sprintf("%-10s", label))+" "+st.Error.Render(w))
 				} else {
-					out = append(out, valueIndent+st.Error.Render(w))
+					out = append(out, strings.Repeat(" ", 12)+st.Error.Render(w))
 				}
 			}
 		}
 	case ValueShown:
-		if d.value.Reveal() == "" {
-			// Not in the value's colour, nor a word a value could be.
-			field(label, st.Muted.Italic(true).Render("∅ no value (an empty string)"))
-			out = append(out, valueIndent+hints("hide"))
-			break
-		}
 		// Where the dots were, continuing under itself; the keys below.
 		first := true
 		lines, note := valueView(d.value.Reveal())
 		for _, line := range lines {
 			for _, w := range strings.Split(ansi.Hardwrap(line, max(1, inner-11), true), "\n") {
 				if first {
-					out = append(out, fieldLabel(st, label)+st.Value.Render(w))
+					out = append(out, " "+st.Label.Render(fmt.Sprintf("%-10s", label))+" "+st.Value.Render(w))
 					first = false
 				} else {
-					out = append(out, valueIndent+st.Value.Render(w))
+					out = append(out, indent+st.Value.Render(w))
 				}
 			}
 		}
@@ -364,7 +352,7 @@ func (d Detail) lines(st styles.Styles) []string {
 		if d.hidesIn != "" {
 			more = append(more, "hides in "+d.hidesIn)
 		}
-		out = append(out, valueIndent+hints("hide", more...))
+		out = append(out, indent+hints("hide", more...))
 	}
 	return append(out, d.versionLines(st)...)
 }
@@ -385,7 +373,7 @@ func (d Detail) versionLines(st styles.Styles) []string {
 			head += muted(" · " + d.VersionsKey + " to browse")
 		}
 	}
-	out := []string{"", fieldLabel(st, "versions") + head}
+	out := []string{"", " " + st.Label.Render(fmt.Sprintf("%-10s", "versions")) + " " + head}
 	current := d.versions[0].Version
 	for i, v := range d.versions {
 		if i == maxVersionLines {

internal/ui/panes/detail_test.go

@@ -3,12 +3,6 @@ package panes
 import (
 	"strings"
 	"testing"
-
-	"github.com/charmbracelet/x/ansi"
-
-	"git.kebcloud.no/keb/lazysecrets/internal/provider"
-	"git.kebcloud.no/keb/lazysecrets/internal/ui/icons"
-	"git.kebcloud.no/keb/lazysecrets/internal/ui/styles"
 )
 
 func TestWrappedValueKeepsItsStyle(t *testing.T) {
@@ -21,17 +15,3 @@ func TestWrappedValueKeepsItsStyle(t *testing.T) {
 		t.Errorf("the style went on past its reset: %q", got[2])
 	}
 }
-
-func TestEmptyValue(t *testing.T) {
-	d := NewDetail(icons.None)
-	d.SetSize(80, 20)
-	d.ShowSecret(provider.Object{Name: "spring.datasource.password", Type: provider.TypeSecret})
-	d.SetValue(provider.NewSecretValue(nil))
-	if view := ansi.Strip(d.View(styles.Default(), true, "")); !strings.Contains(view, "∅ no value (an empty string)") {
-		t.Errorf("empty value:\n%s", view)
-	}
-	d.SetValue(provider.NewSecretValue([]byte("empty")))
-	if view := ansi.Strip(d.View(styles.Default(), true, "")); strings.Contains(view, "∅") || !strings.Contains(view, "empty") {
-		t.Errorf("the word empty:\n%s", view)
-	}
-}

internal/ui/panes/list.go

@@ -22,9 +22,6 @@ type Item[T any] struct {
 	// text the row doesn't show (e.g. the provider of a grouped source).
 	FilterExtra func(T) string
 	Render      func(st styles.Styles, v T, width int) string
-	// Hidden, if set, says which items are listed only while the list
-	// shows hidden ones (SetShowHidden).
-	Hidden func(T) bool
 }
 
 // List is a scrollable, filterable list pane with loading and error states.
@@ -56,9 +53,6 @@ type List[T any] struct {
 
 	input     textinput.Model
 	filtering bool
-
-	showHidden bool
-	hidden     int // items left out for being hidden
 }
 
 func NewList[T any](title string, item Item[T]) List[T] {
@@ -83,12 +77,6 @@ func (l *List[T]) SetItems(items []T) {
 	l.applyFilter(prev)
 }
 
-// SetShowHidden lists hidden items too, or leaves them out again.
-func (l *List[T]) SetShowHidden(on bool) {
-	l.showHidden = on
-	l.applyFilter(l.SelectedID())
-}
-
 // Reset clears items, error, filter and cursor.
 func (l *List[T]) Reset() {
 	l.items, l.visible = nil, nil
@@ -249,28 +237,21 @@ func (l *List[T]) UpdateFilter(msg tea.Msg) tea.Cmd {
 // applyFilter recomputes the visible items and puts the cursor back on the
 // item with ID keep if it is still visible.
 func (l *List[T]) applyFilter(keep string) {
-	l.visible, l.hits, l.hidden = l.visible[:0], nil, 0
-	shown := make([]int, 0, len(l.items))
-	for i, v := range l.items {
-		if !l.showHidden && l.item.Hidden != nil && l.item.Hidden(v) {
-			l.hidden++
-			continue
-		}
-		shown = append(shown, i)
-	}
+	l.visible, l.hits = l.visible[:0], nil
 	if q := l.input.Value(); q == "" {
-		l.visible = append(l.visible, shown...)
+		for i := range l.items {
+			l.visible = append(l.visible, i)
+		}
 	} else {
 		// The row's own text is the name; FilterExtra (a note, a provider)
 		// is context, matched too but ranked lower.
-		items := make([]match.Item, len(shown))
-		for j, i := range shown {
-			v := l.items[i]
+		items := make([]match.Item, len(l.items))
+		for i, v := range l.items {
 			text := l.item.Filter(v)
-			items[j] = match.Item{Text: text, NameEnd: utf8.RuneCountInString(text)}
+			items[i] = match.Item{Text: text, NameEnd: utf8.RuneCountInString(text)}
 			if l.item.FilterExtra != nil {
 				if extra := l.item.FilterExtra(v); extra != "" {
-					items[j].Text += " " + extra
+					items[i].Text += " " + extra
 				}
 			}
 		}
@@ -281,7 +262,7 @@ func (l *List[T]) applyFilter(keep string) {
 					hits = append(hits, p)
 				}
 			}
-			l.visible = append(l.visible, shown[h.Index])
+			l.visible = append(l.visible, h.Index)
 			l.hits = append(l.hits, hits)
 		}
 	}
@@ -348,7 +329,17 @@ func (l List[T]) View(st styles.Styles, focused bool, spin string) string {
 	ts := TitleStyle(st, focused)
 	title := ts.Render(l.Title)
 	if len(l.Tabs) > 1 {
-		title += ts.Render(" ") + Tabs(st, ts, l.Tabs, l.Tab)
+		for i, tab := range l.Tabs {
+			sep := " - "
+			if i == 0 {
+				sep = " "
+			}
+			if i == l.Tab {
+				title += ts.Render(sep) + ts.Underline(true).Render(tab)
+			} else {
+				title += ts.Render(sep) + st.Muted.Render(tab)
+			}
+		}
 	}
 	if q := l.input.Value(); q != "" && !l.filtering {
 		title += ts.Render(" /" + q)
@@ -372,22 +363,33 @@ func (l List[T]) View(st styles.Styles, focused bool, spin string) string {
 		for _, line := range wrapLines(l.Err.Error(), inner-1) {
 			body = append(body, st.Error.Render(" "+line))
 		}
-	case len(l.visible) == 0 && len(l.items) > l.hidden:
+	case len(l.visible) == 0 && len(l.items) > 0:
 		body = append(body, st.Muted.Render(" no matches"))
-	case len(l.visible) == 0 && l.hidden > 0:
-		body = append(body, st.Muted.Render(fmt.Sprintf(" %s (%d hidden)", l.Empty, l.hidden)))
 	case len(l.visible) == 0:
 		body = append(body, st.Muted.Render(" "+l.Empty))
 	default:
 		for i := l.offset; i < len(l.visible) && i < l.offset+rows; i++ {
 			line := l.item.Render(st, l.items[l.visible[i]], inner-1)
-			line = " " + MarkMatches(line, l.highlight(i, ansi.Strip(line)), st.Match)
+			plain := ansi.Strip(line)
+			hits := l.highlight(i, plain)
 			if i == l.cursor {
 				base := st.SelectedBlurred
 				if focused {
 					base = st.Selected
 				}
-				line = Highlight(ansi.Truncate(line, inner, "…"), base, inner)
+				text := " " + line
+				if len(hits) > 0 {
+					for j := range hits {
+						hits[j]++ // leading space
+					}
+					text = lipgloss.StyleRanges(text, matchRanges(" "+plain, hits, st.Match)...)
+				}
+				line = Highlight(ansi.Truncate(text, inner, "…"), base, inner)
+			} else if len(hits) > 0 {
+				// Style just the matches, keeping the row's own colours.
+				line = " " + lipgloss.StyleRanges(line, matchRanges(plain, hits, st.Match)...)
+			} else {
+				line = " " + line
 			}
 			body = append(body, line)
 		}
@@ -397,9 +399,6 @@ func (l List[T]) View(st styles.Styles, focused bool, spin string) string {
 	if len(l.visible) > 0 {
 		counter = fmt.Sprintf("%d of %d", l.cursor+1, len(l.visible))
 	}
-	if l.hidden > 0 {
-		counter = strings.Trim(counter+fmt.Sprintf(" · %d hidden", l.hidden), " ·")
-	}
 	if l.Loading && l.Age != "" && len(l.items) > 0 {
 		counter = "cached " + l.Age + " · " + counter
 	}

internal/ui/panes/list_test.go

@@ -201,41 +201,3 @@ func TestListHeader(t *testing.T) {
 		t.Errorf("no room, the text:\n%s", v)
 	}
 }
-
-func TestListHidden(t *testing.T) {
-	l := NewList("Items", Item[string]{
-		ID:     func(s string) string { return s },
-		Filter: func(s string) string { return s },
-		Render: func(_ styles.Styles, s string, _ int) string { return s },
-		Hidden: func(s string) bool { return strings.HasPrefix(s, "hidden") },
-	})
-	l.SetSize(40, 7)
-	l.SetItems([]string{"shown-a", "hidden-b", "shown-c"})
-	view := ansi.Strip(l.View(styles.Default(), true, ""))
-	if l.Len() != 2 || strings.Contains(view, "hidden-b") || !strings.Contains(view, "1 hidden") {
-		t.Fatalf("hidden listed:\n%s", view)
-	}
-	l.Move(1)
-	l.SetShowHidden(true)
-	if l.Len() != 3 || l.SelectedID() != "shown-c" {
-		t.Fatalf("shown: %d, selected %q", l.Len(), l.SelectedID())
-	}
-	l.StartFilter()
-	l.input.SetValue("hid")
-	l.applyFilter("")
-	if l.Len() != 1 || l.SelectedID() != "hidden-b" {
-		t.Fatalf("filtered with hidden shown: %d %q", l.Len(), l.SelectedID())
-	}
-
-	l = NewList("Items", Item[string]{
-		ID: func(s string) string { return s }, Filter: func(s string) string { return s },
-		Render: func(_ styles.Styles, s string, _ int) string { return s },
-		Hidden: func(string) bool { return true },
-	})
-	l.Empty = "no secrets"
-	l.SetSize(40, 7)
-	l.SetItems([]string{"a", "b"})
-	if view := ansi.Strip(l.View(styles.Default(), true, "")); !strings.Contains(view, "no secrets (2 hidden)") {
-		t.Fatalf("all hidden:\n%s", view)
-	}
-}

internal/ui/styles/styles.go

@@ -34,7 +34,6 @@ type Styles struct {
 	KindAzure      lipgloss.Style
 	KindDatabricks lipgloss.Style
 	KindRepo       lipgloss.Style
-	Spring         lipgloss.Style // Spring Boot config files
 
 	// themed marks the selection colours as set by the theme, so
 	// OnBackground leaves them.
@@ -71,7 +70,6 @@ func Default() Styles {
 		KindAzure:      lipgloss.NewStyle().Foreground(lipgloss.Blue),
 		KindDatabricks: lipgloss.NewStyle().Foreground(lipgloss.Red),
 		KindRepo:       lipgloss.NewStyle().Foreground(lipgloss.Magenta),
-		Spring:         lipgloss.NewStyle().Foreground(lipgloss.Green),
 	}
 }
 

internal/ui/styles/theme.go

@@ -42,7 +42,6 @@ var Roles = map[string]string{
 	"azureColor":                      "Azure sources and vaults",
 	"databricksColor":                 "Databricks workspaces and scopes",
 	"repoColor":                       "repos and their secret files (SOPS)",
-	"springColor":                     "Spring Boot config files",
 }
 
 // FromTheme returns the default styles with the theme's roles applied, and
@@ -100,8 +99,6 @@ func FromTheme(theme map[string][]string) (Styles, color.Color, error) {
 			st.KindDatabricks = v.fg(lipgloss.NewStyle())
 		case "repoColor":
 			st.KindRepo = v.fg(lipgloss.NewStyle())
-		case "springColor":
-			st.Spring = v.fg(lipgloss.NewStyle())
 		}
 	}
 	return st, fg, nil