Merge pull request 'Complete API token gRPC authorization' (#3) from feature/api-token-grpc-authz into main

Reviewed-on: #3

.codex/skills/keepassgo-ship-it/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: keepassgo-ship-it
+description: KeePassGO-specific ship workflow. Use when the user says `ship it` in this repository and expects the current work to be committed, the Arch package rebuilt and installed, the Android APK rebuilt and zipped, the ZIP uploaded to Nextcloud, and the rebuilt app launched in the emulator with a controlled demo vault opened.
+---
+
+# KeePassGO Ship It
+
+Use this skill only in the KeePassGO repository. This is not a global shorthand.
+
+Use it together with:
+- `android-emulator-debug` for emulator and `adb` mechanics
+- `keepass-credentials` for Nextcloud credentials
+- `public-repo-sanitization` before the commit/push step
+
+## Meaning Of `ship it`
+
+When the user says `ship it`, do all of this unless they narrow the scope:
+
+1. Commit the relevant KeePassGO source changes first.
+2. Build and install the Arch package from that committed source.
+3. Build the Android APK from that same committed source.
+4. Zip the APK.
+5. Upload the ZIP to the user's configured Nextcloud DAV destination for this repository.
+6. Install the rebuilt APK in the emulator.
+7. Launch the rebuilt app in the emulator.
+8. Open a controlled demo vault in the emulator.
+
+Do not stop after the commit or after the package build. `ship it` means finish the full loop.
+
+## Required Sequence
+
+### 1. Commit First
+
+- Make sure the worktree state intended for shipping is committed before building.
+- If the repo is dirty in unrelated ways, commit only the relevant changes.
+- Before the commit or push, run the public-repo sanitization checks.
+
+### 2. Build And Install The Arch Package
+
+From the repo root:
+
+```sh
+make archlinux-pkgbuild
+cd packaging/archlinux/keepassgo-git
+makepkg -si --noconfirm
+```
+
+The installed package version must correspond to the committed source, not a dirty worktree.
+
+### 3. Build The APK
+
+Use the repo's known-good local JDK unless the environment already proves otherwise:
+
+```sh
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk make apk
+```
+
+If that JDK is unavailable on the current host, use the working replacement already established for the machine and say so in the closeout.
+
+### 4. Zip The APK
+
+- Create the ZIP under the globally required temporary secret-safe directory.
+- Use a name that includes the commit, for example:
+  `keepassgo-<shortsha>-apk.zip`
+
+### 5. Upload To Nextcloud
+
+- Get credentials and the DAV endpoint with `keepass-http`, not by asking the user if KeePass likely has them.
+- Prefer the established KeePass entry and DAV destination already in use for this repository's shipping workflow.
+- Use the globally required temporary secret-safe directory for any temporary curl config or secret material.
+- Ensure that directory exists with mode `700`.
+- Create secret temp files with mode `600`.
+- After upload, zero and unlink the temp secret file. Do not use `rm -f` or `rm -rf`.
+
+### 6. Emulator Install And Launch
+
+- Reuse the existing emulator session if one is already running.
+- Install with replacement:
+
+```sh
+adb install -r build/keepassgo.apk
+```
+
+- Launch KeePassGO and confirm it is focused.
+- Treat the emulator as timing-sensitive. If Android shows a transient "Wait" style ANR dialog and the user says the app is otherwise fine, do not misclassify that as an app-logic failure.
+
+### 7. Open A Controlled Demo Vault
+
+- Do not rely on the user's real vault for this step.
+- Use a controlled/sanitized demo vault that you can unlock yourself.
+- Open it in the emulator before closing out `ship it`.
+- Capture a screenshot if needed to verify the app really rendered and opened the vault.
+
+## Closeout Requirements
+
+When reporting back after `ship it`, include:
+- the commit that was shipped
+- the installed Arch package version
+- the APK path
+- the uploaded ZIP URL
+- confirmation that the emulator app was launched
+- confirmation that the controlled demo vault was opened
+
+## Constraints
+
+- Keep this workflow specific to KeePassGO.
+- Preserve emulator state; do not kill or reset it unless the user explicitly asks.
+- Do not use `rm -rf`.
+- Do not use `rm -f`.

.gitea/workflows/ci.yml

@@ -128,7 +128,7 @@ jobs:
             fi
             out="${DIST_DIR}/keepassgo-${goos}-${goarch}${ext}"
             GOOS="${goos}" GOARCH="${goarch}" CGO_ENABLED="${cgo_enabled}" \
-              go build -ldflags "-X main.appVersion=${app_version}" -o "${out}" .
+              go build -ldflags "-X git.julianfamily.org/keepassgo.appVersion=${app_version}" -o "${out}" ./cmd/keepassgo
           done
 
       - name: Build APK

.gitignore

@@ -1,6 +1,7 @@
 build/
 *.apk
-keepassgo
+/keepassgo
+android/keepassgo-android.jar
 packaging/archlinux/keepassgo-git/*.pkg.tar.zst
 packaging/archlinux/keepassgo-git/PKGBUILD
 packaging/archlinux/keepassgo-git/pkg/

.golangci.yml

@@ -1,8 +1,19 @@
 linters:
   enable:
     - errcheck
+    - gocyclo
     - gosimple
     - govet
     - ineffassign
     - staticcheck
     - unused
+
+linters-settings:
+  gocyclo:
+    min-complexity: 15
+
+issues:
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - gocyclo

AGENTS.md

@@ -118,6 +118,20 @@ These features are product requirements, not “nice to have” ideas.
 - Prefer behavior-oriented tests that describe expected product behavior rather than implementation details.
 - Provide a secure gRPC API as a first-class programmatic surface, not as a thin wrapper around UI state.
 - Design browser-extension and automation integrations against the gRPC API, not against ad hoc local protocols.
+- Treat the vault model as local-first across all platforms:
+  every usable vault is a local KDBX file first, and remote sync attaches to
+  that local vault rather than replacing it as the primary object.
+- Keep the remote-sync model standardized across desktop, Android phone, and
+  Android tablet:
+  shared remote configuration belongs in the vault,
+  cross-platform workflow stays the same,
+  and only Android's initial KDBX share/import transport may differ.
+- Do not persist remote credentials in plaintext app-local state.
+  Keep only non-secret binding metadata outside the vault.
+- When working on remote-sync behavior, preserve the local cache / local-first
+  design:
+  opening or creating the local vault is the main workflow,
+  and remote setup, remote settings, and remote use attach to that vault.
 
 ## Delivery Discipline
 
@@ -144,6 +158,13 @@ These features are product requirements, not “nice to have” ideas.
 - Plan for direct KDBX support.
 - Plan for direct WebDAV-based workflows.
 - Avoid adding npm-based or browser-stack dependencies.
+- Keep remote configuration and synchronization local-first:
+  the app should maintain a live local KDBX cache even when using a remote
+  store, so remote outage does not eliminate vault access.
+- Prefer vault-backed remote setup and lookup over ad hoc local credential
+  storage.
+- On Android, use system picker/share mechanisms for local vault import/export
+  rather than raw path entry when a user is selecting or sharing a vault file.
 
 ## Tooling
 
@@ -166,6 +187,10 @@ These features are product requirements, not “nice to have” ideas.
   Use an isolated `KEEPASSGO_STATE_DIR` for host-side validation, and when emulator testing requires seeded vault data, use sanitized test/demo vaults rather than the user’s real vault files whenever possible.
 - When running tests or other automated validation that may touch persisted UI state, set `KEEPASSGO_STATE_DIR` to an isolated temporary directory so recent-vault history and other local state do not pollute the user’s real config.
 - Prefer commands shaped like `KEEPASSGO_STATE_DIR=\"$(mktemp -d)\" go test ./...` for ad hoc local validation unless a test already manages its own isolated state directory.
+- For the Arch package, treat
+  `packaging/archlinux/keepassgo-git/PKGBUILD.tmpl`
+  as the source of truth and regenerate `PKGBUILD` from the template before
+  building.
 - Do not assume the agent can decrypt SOPS-encrypted secrets in this repository.
 - If work requires plaintext from a SOPS-encrypted secret, stop and ask the user to decrypt it or otherwise provide the needed plaintext.
 - Do not commit generated binaries.

APK.md

@@ -29,12 +29,12 @@ Installed machine prerequisites expected by this repo:
 The repo tracks `gogio` as a Go tool, so the build runs through:
 
 ```sh
-go tool gogio -target android ...
+go tool gogio -target android ./cmd/keepassgo ...
 ```
 
 The Android build uses the branded icon asset at:
 
-- `assets/keepassgo-icon.png`
+- `internal/assets/keepassgo-icon.png`
 
 Note:
 

Makefile

@@ -6,7 +6,7 @@ APP_ID ?= org.julianfamily.keepassgo
 APK_OUT ?= build/keepassgo.apk
 APK_VERSION ?= 0.1.0.1
 APP_VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo dev)
-GO_LDFLAGS ?= -X main.appVersion=$(APP_VERSION)
+GO_LDFLAGS ?= -X git.julianfamily.org/keepassgo/internal/appui.appVersion=$(APP_VERSION)
 ANDROID_MIN_SDK ?= 28
 ANDROID_TARGET_SDK ?= 35
 SIGNKEY ?=
@@ -47,8 +47,8 @@ apk: android/keepassgo-android.jar
 		-version $(APK_VERSION) \
 		-minsdk $(ANDROID_MIN_SDK) \
 		-targetsdk $(ANDROID_TARGET_SDK) \
-		-icon assets/keepassgo-icon.png \
-		.
+		-icon internal/assets/keepassgo-icon.png \
+		./cmd/keepassgo
 
 android/keepassgo-android.jar: $(shell find androidsrc -type f | sort)
 	@test -x "$(JAVA_HOME)/bin/javac" || { echo "JAVA_HOME must point to a working JDK install"; exit 1; }

README.md

@@ -38,14 +38,14 @@ KDBX security and KDF compatibility notes are documented in [`docs/kdbx-compatib
 Desktop build:
 
 ```bash
-go build ./...
+go build ./cmd/keepassgo
 ```
 
 By default, build outputs stamp the app version from `git describe --tags --always --dirty`.
 You can override the version shown in KeePassGO with:
 
 ```bash
-go build -ldflags "-X main.appVersion=v0.0.1" ./...
+go build -ldflags "-X git.julianfamily.org/keepassgo/internal/appui.appVersion=v0.0.1" ./cmd/keepassgo
 ```
 
 ## Arch Linux Package
@@ -89,7 +89,7 @@ go get -tool gioui.org/cmd/gogio@latest
 Package:
 
 ```bash
-go tool gogio -target android -icon assets/keepassgo-icon.png .
+go tool gogio -target android -icon internal/assets/keepassgo-icon.png ./cmd/keepassgo
 ```
 
 You will need the Android SDK and NDK installed and configured for real device or release packaging.

TODO.md

@@ -132,195 +132,6 @@ These are important, but they should likely move behind a dedicated settings gea
 - Phone and desktop layouts both present a clear information hierarchy.
 - The Android open flow is reliable enough to review and use without ANR during ordinary vault-open operations.
 
-## API Token And gRPC Authorization Parallel Segments
-
-These segments define the work for programmatic access control over gRPC.
-They are designed to be independently landable wherever file overlap permits.
-The feature is not complete until all segment exit criteria and the global exit criteria are satisfied.
-
-### API Segment A: Token Domain Model
-
-Scope:
-- Represent API tokens as first-class vault-backed records.
-- Mark token entries explicitly as API credentials rather than generic passwords.
-- Store token metadata:
-  token id,
-  hashed secret or verifier,
-  display name,
-  client name,
-  created at,
-  expires at,
-  disabled state.
-- Keep the persisted representation compatible with KDBX entry fields.
-
-Exit criteria:
-- A domain type exists for API tokens and round-trips through the persisted vault model.
-- Generic entry listing can distinguish API token entries from ordinary secrets.
-- Tests cover create, load, save, and parse behavior for API token entries.
-- `go test ./...` passes.
-
-### API Segment B: Token Issuance And Rotation
-
-Scope:
-- Generate new API tokens for external tools.
-- Return the cleartext token only at creation or explicit rotation time.
-- Rotate an existing token while preserving its identity and policy linkage.
-- Revoke or disable a token without deleting policy history.
-
-Exit criteria:
-- Token issuance, rotation, disable, and revoke operations exist in the domain/service layer.
-- Cleartext token material is only exposed on creation or rotation paths.
-- Tests cover generation, rotation, and disable/revoke semantics.
-- `go test ./...` passes.
-
-### API Segment C: Token Expiration
-
-Scope:
-- Allow tokens to have optional expiration timestamps.
-- Treat expired tokens as unauthenticated.
-- Surface expiration in UI and gRPC management views.
-- Support non-expiring tokens explicitly.
-
-Exit criteria:
-- Expired tokens are rejected by the gRPC authentication path.
-- Token expiration can be created, edited, and removed through the service layer.
-- Tests cover valid, expired, and non-expiring token behavior.
-- `go test ./...` passes.
-
-### API Segment D: Authorization Policy Model
-
-Scope:
-- Define an authorization model for token-scoped access.
-- Support allow and deny rules over:
-  folders/groups,
-  specific entries,
-  entry fields where needed,
-  and operation types.
-- Keep specific deny rules higher priority than broad allow rules.
-- Model “not yet decided” separately from “denied”.
-
-Exit criteria:
-- A policy evaluator exists for token, resource, and operation tuples.
-- Explicit deny overrides allow.
-- Unspecified access is distinguishable from denied access.
-- Tests cover allow, deny, inherited group scope, and exact-entry scope behavior.
-- `go test ./...` passes.
-
-### API Segment E: gRPC Authentication And Authorization Enforcement
-
-Scope:
-- Replace the current single static bearer-token interceptor with token-backed auth.
-- Authenticate callers using issued KeePassGO API tokens.
-- Authorize every gRPC method against token policy.
-- Apply scope checks to lifecycle, list, read, mutation, copy, and password-generation RPCs.
-
-Exit criteria:
-- gRPC requests authenticate through stored API tokens rather than one static shared secret.
-- Every RPC enforces token-specific authorization before mutating or revealing vault data.
-- Unauthorized requests return the correct authz/authn gRPC status.
-- Integration tests cover permitted, denied, expired, and revoked token behavior.
-- `go test ./...` passes.
-
-### API Segment F: Approval Queue And Pending Access Requests
-
-Scope:
-- When a token requests access to a resource that is neither explicitly allowed nor denied:
-  create a pending approval request.
-- Include:
-  token identity,
-  client name,
-  requested operation,
-  requested group/entry scope,
-  requested time,
-  and permanence choice.
-- Allow the request to be accepted, denied, or canceled by the user.
-
-Exit criteria:
-- Unspecified access creates a pending approval instead of silently denying or allowing.
-- Pending approvals are queryable from the application layer.
-- Canceling the prompt results in the API request failing without granting access.
-- Tests cover pending creation, approval, denial, and cancellation.
-- `go test ./...` passes.
-
-### API Segment G: Approval UI
-
-Scope:
-- Show a user-facing approval screen/dialog when a pending API request needs a decision.
-- Provide actions:
-  allow once,
-  deny once,
-  allow permanently,
-  deny permanently,
-  cancel.
-- Make the requested scope and operation clear to the user.
-- Ensure the dialog appears only for requests not already decided.
-
-Exit criteria:
-- A pending request triggers a visible approval surface in the app.
-- The user can allow, deny, or cancel from the UI.
-- Permanent decisions become persisted policy rules.
-- UI tests cover each approval outcome.
-- `go test ./...` passes.
-
-### API Segment H: gRPC Request Blocking And Resume Behavior
-
-Scope:
-- Define how an in-flight gRPC call waits for or fails on user approval.
-- Hold the request while approval is pending within a bounded timeout.
-- Return unauthenticated or permission-denied when denied/canceled/expired.
-- Resume the original call automatically when approval is granted.
-
-Exit criteria:
-- Pending requests block safely without leaking goroutines.
-- Allowed requests resume and complete without the client reissuing the call where practical.
-- Denied and canceled requests return a consistent gRPC status code and message.
-- Tests cover timeout, allow, deny, and cancel paths.
-- `go test ./...` passes.
-
-### API Segment I: Token Management UI
-
-Scope:
-- Add UI for listing API tokens.
-- Create token flow with one-time secret display.
-- Edit token display metadata and expiration.
-- Disable, revoke, and rotate tokens.
-- Show effective policy summary per token.
-
-Exit criteria:
-- Users can manage API tokens from the app UI end to end.
-- One-time token display is explicit and not re-shown later.
-- Expiration and disable state are visible.
-- UI tests cover create, rotate, disable, revoke, and edit flows.
-- `go test ./...` passes.
-
-### API Segment J: Policy Management UI
-
-Scope:
-- Let users define folder, entry, and operation scopes for each token.
-- Show explicit allow and deny rules.
-- Show inherited implications of a folder-level rule.
-- Let users review prior permanent decisions created from approval prompts.
-
-Exit criteria:
-- Users can inspect and edit token policy from the UI.
-- Folder-level and entry-level rules are distinguishable and editable.
-- Permanent prompt decisions are visible as policy.
-- UI tests cover rule creation, update, and deletion.
-- `go test ./...` passes.
-
-### API Segment K: Audit And Event History
-
-Scope:
-- Record token issuance, rotation, revoke, approval, deny, and prompt outcomes.
-- Record authorization failures and expirations without logging secret material.
-- Provide a bounded event history visible in the UI and/or gRPC admin surface.
-
-Exit criteria:
-- Security-relevant API token events are captured without secret leakage.
-- Approval outcomes and policy changes are auditable.
-- Tests cover audit generation for the main token lifecycle and approval actions.
-- `go test ./...` passes.
-
 ### Segment 1: Application State Ownership
 
 Scope:
@@ -389,19 +200,6 @@ Exit criteria:
 - Validation and visible error states exist for missing or invalid key material.
 - `go test ./...` passes.
 
-### Segment 5: KDBX Security Settings Preservation
-
-Scope:
-- Preserve supported cipher and KDF settings when reopening and saving.
-- Surface relevant settings in product-facing docs or UI where appropriate.
-- Document unsupported settings explicitly.
-
-Exit criteria:
-- Reopen-and-save cycles preserve supported KDBX security settings.
-- Compatibility notes are current in `docs/kdbx-compatibility.md`.
-- Tests cover settings preservation across save cycles.
-- `go test ./...` passes.
-
 ### Segment 6: Entry CRUD UI
 
 Scope:
@@ -607,33 +405,6 @@ Exit criteria:
 - UI tests or controller-integrated tests cover these states.
 - `go test ./...` passes.
 
-### Segment 18: Desktop Automation Resolution
-
-Scope:
-- Either implement a desktop login automation mechanism comparable in purpose to KeePass auto-type,
-- or explicitly finalize the design that secure gRPC supersedes auto-type.
-- Keep the decision documented in-repo.
-
-Exit criteria:
-- The desktop automation requirement is explicitly resolved in code or docs.
-- The chosen approach is documented in `docs/desktop-automation.md`.
-- Any implemented behavior is tested.
-- `go test ./...` passes.
-
-### Segment 19: Packaging And Runbook
-
-Scope:
-- Keep the app runnable from source.
-- Document desktop build and run steps.
-- Document Android packaging with `gogio`.
-- Add icon and metadata placeholders if missing.
-
-Exit criteria:
-- `README.md` is accurate for local build, run, and Android packaging guidance.
-- Placeholder metadata exists where needed for packaging.
-- The app still builds from the repo.
-- `go test ./...` passes.
-
 ### Segment 20: Regression And Integration Coverage
 
 Scope:
@@ -651,11 +422,10 @@ Exit criteria:
 
 Do not treat the product as complete until all of the following are true:
 
-- Segment 1 through Segment 20 are all complete.
+- All remaining numbered segments, API segments, and UI review follow-ups are complete.
 - KeePassGO can create, open, edit, save, save-as, lock, and unlock local KDBX databases through the UI.
 - KeePassGO can open and save remote WebDAV-backed KDBX databases through the UI, including visible conflict and error handling.
 - KeePassGO supports master password, key file, and composite key workflows in the product.
-- KeePassGO preserves supported KDBX security and KDF settings and documents unsupported settings.
 - KeePassGO supports nested groups, path-aware navigation, explicit template navigation, and explicit recycle-bin navigation.
 - KeePassGO supports entry create, edit, duplicate, delete, restore, history browse, and history restore through the UI.
 - KeePassGO supports title, username, password, URL, notes, tags, and custom string fields through the UI.
@@ -665,17 +435,7 @@ Do not treat the product as complete until all of the following are true:
 - KeePassGO supports copy username, copy password, copy URL, and reveal or hide password behavior end to end.
 - KeePassGO exposes password generation profiles through both UI and gRPC.
 - The secure gRPC API is broad enough for trusted automation and browser-extension-style integration.
-- The desktop automation requirement is explicitly resolved.
 - Keyboard-first navigation and common shortcuts exist for major product workflows.
 - The UI no longer depends on prototype-only mock behavior for any core workflow.
-- Build and run instructions exist for desktop, and packaging guidance exists for Android.
 - `go test ./...` passes.
 - `go tool golangci-lint run ./...` passes.
-
-## Remaining Gaps Against AGENTS.md
-
-None currently identified.
-
-The last explicitly tracked gaps are now closed:
-- KDBX security settings are product-configurable at the major cipher/KDF family level for both new vault creation and existing sessions.
-- The current accessibility support boundary is documented in `docs/accessibility.md`, while in-repo focus and labeling behavior remains tested.

android_share_stub.go

@@ -1,7 +0,0 @@
-//go:build !android
-
-package main
-
-func newPlatformVaultSharer(goos string) vaultSharer {
-	return nil
-}

buildapk/config.go

@@ -13,10 +13,10 @@ const (
 	DefaultAppID     = "org.julianfamily.keepassgo"
 	DefaultAPKOut    = "build/keepassgo.apk"
 	DefaultVersion   = "0.1.0.1"
-	DefaultLdflags   = "-X main.appVersion=dev"
+	DefaultLdflags   = "-X git.julianfamily.org/keepassgo/internal/appui.appVersion=dev"
 	DefaultMinSDK    = "28"
 	DefaultTargetSDK = "35"
-	DefaultIconPath  = "assets/keepassgo-icon.png"
+	DefaultIconPath  = "internal/assets/keepassgo-icon.png"
 )
 
 type Config struct {
@@ -58,7 +58,7 @@ func (c Config) GogioArgs() []string {
 		"-minsdk", c.MinSDK,
 		"-targetsdk", c.TargetSDK,
 		"-icon", c.IconPath,
-		".",
+		"./cmd/keepassgo",
 	}
 }
 

buildapk/config_test.go

@@ -21,7 +21,7 @@ func TestDefaultConfigGogioArgs(t *testing.T) {
 		"-minsdk", DefaultMinSDK,
 		"-targetsdk", DefaultTargetSDK,
 		"-icon", DefaultIconPath,
-		".",
+		"./cmd/keepassgo",
 	}
 
 	if got := cfg.GogioArgs(); !slices.Equal(got, want) {

cmd/keepassgo/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "git.julianfamily.org/keepassgo/internal/appui"
+
+func main() {
+	appui.Main()
+}

go.mod

@@ -2,8 +2,6 @@ module git.julianfamily.org/keepassgo
 
 go 1.26
 
-replace gioui.org/cmd => ./third_party/gioui-cmd
-
 require (
 	gioui.org v0.8.0
 	gioui.org/x v0.8.0

go.sum

@@ -39,6 +39,8 @@ eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d h1:ARo7NCVvN2NdhLlJE9xAbKw
 eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d/go.mod h1:OYVuxibdk9OSLX8vAqydtRPP87PyTFcT9uH3MlEGBQA=
 gioui.org v0.8.0 h1:QV5p5JvsmSmGiIXVYOKn6d9YDliTfjtLlVf5J+BZ9Pg=
 gioui.org v0.8.0/go.mod h1:vEMmpxMOd/iwJhXvGVIzWEbxMWhnMQ9aByOGQdlQ8rc=
+gioui.org/cmd v0.8.0 h1:oy5qOlc1UXcglc5HBCMZQELiIzQ2obhT98mw+SuWafQ=
+gioui.org/cmd v0.8.0/go.mod h1:wKLAyAgRR25VMYFzGX2Ecia0m0Td562wDcZ3LaPHPTI=
 gioui.org/cpu v0.0.0-20210808092351-bfe733dd3334/go.mod h1:A8M0Cn5o+vY5LTMlnRoK3O5kG+rH0kWfJjeKd9QpBmQ=
 gioui.org/shader v1.0.8 h1:6ks0o/A+b0ne7RzEqRZK5f4Gboz2CfG+mVliciy6+qA=
 gioui.org/shader v1.0.8/go.mod h1:mWdiME581d/kV7/iEhLmUgUK5iZ09XR5XpduXzbePVM=

internal/api/host.go

@@ -7,26 +7,26 @@ import (
 	"strings"
 	"sync"
 
-	"git.julianfamily.org/keepassgo/clipboard"
-	"git.julianfamily.org/keepassgo/passwords"
+	"git.julianfamily.org/keepassgo/internal/clipboard"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
 	keepassgov1 "git.julianfamily.org/keepassgo/proto/keepassgo/v1"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
 	"google.golang.org/grpc"
 )
 
 type DirtyProvider func() bool
 
 type Host struct {
-	server       *Server
-	grpcServer   *grpc.Server
-	listener     net.Listener
-	lifecycle    lifecycleBackend
-	dirty        DirtyProvider
-	mu           sync.Mutex
-	lastModel    vault.Model
-	started      bool
-	listenAddr   string
+	server     *Server
+	grpcServer *grpc.Server
+	listener   net.Listener
+	lifecycle  lifecycleBackend
+	dirty      DirtyProvider
+	mu         sync.Mutex
+	lastModel  vault.Model
+	started    bool
+	listenAddr string
 }
 
 func StartHost(addr string, lifecycle lifecycleBackend, profiles map[string]passwords.Profile, clipboardWriter clipboard.Writer, dirty DirtyProvider) (*Host, error) {
@@ -41,7 +41,7 @@ func StartHost(addr string, lifecycle lifecycleBackend, profiles map[string]pass
 	}
 
 	service := NewServerWithLifecycle(vault.Model{}, profiles, clipboardWriter, lifecycle)
-	server := grpc.NewServer(grpc.UnaryInterceptor(AuthInterceptor(service)))
+	server := grpc.NewServer()
 	keepassgov1.RegisterVaultServiceServer(server, service)
 
 	host := &Host{

internal/api/host_test.go

@@ -5,10 +5,11 @@ import (
 	"net"
 	"testing"
 
-	"git.julianfamily.org/keepassgo/passwords"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
 	keepassgov1 "git.julianfamily.org/keepassgo/proto/keepassgo/v1"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )
@@ -19,7 +20,16 @@ func TestStartHostServesVaultLifecycleAndSyncsSessionState(t *testing.T) {
 	lifecycle := &session.Manager{}
 	if err := lifecycle.Create(vault.Model{
 		Entries: []vault.Entry{
-			testAPITokenEntry(t),
+			testAPITokenEntry(t,
+				apitokens.PolicyRule{
+					Effect:    apitokens.EffectAllow,
+					Operation: apitokens.OperationManageVault,
+					Resource: apitokens.Resource{
+						Kind: apitokens.ResourceGroup,
+						Path: []string{"Root"},
+					},
+				},
+			),
 			{ID: "entry-1", Title: "Vault Console", Path: []string{"Root", "Internet"}},
 		},
 	}, vault.MasterKey{Password: "correct horse battery staple"}); err != nil {

internal/api/server.go

@@ -10,16 +10,15 @@ import (
 	"sync"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apiaudit"
-	"git.julianfamily.org/keepassgo/apiapproval"
-	"git.julianfamily.org/keepassgo/apitokens"
-	"git.julianfamily.org/keepassgo/clipboard"
-	"git.julianfamily.org/keepassgo/passwords"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/clipboard"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 	keepassgov1 "git.julianfamily.org/keepassgo/proto/keepassgo/v1"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
@@ -89,7 +88,10 @@ func (s *Server) SetSessionState(model vault.Model, locked, dirty bool) {
 	s.dirty = dirty
 }
 
-func (s *Server) GetSessionStatus(_ context.Context, _ *keepassgov1.GetSessionStatusRequest) (*keepassgov1.GetSessionStatusResponse, error) {
+func (s *Server) GetSessionStatus(ctx context.Context, _ *keepassgov1.GetSessionStatusRequest) (*keepassgov1.GetSessionStatusResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
@@ -100,7 +102,10 @@ func (s *Server) GetSessionStatus(_ context.Context, _ *keepassgov1.GetSessionSt
 	}, nil
 }
 
-func (s *Server) OpenVault(_ context.Context, req *keepassgov1.OpenVaultRequest) (*keepassgov1.OpenVaultResponse, error) {
+func (s *Server) OpenVault(ctx context.Context, req *keepassgov1.OpenVaultRequest) (*keepassgov1.OpenVaultResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	if s.lifecycle == nil {
 		return nil, status.Error(codes.FailedPrecondition, "vault lifecycle backend is not configured")
 	}
@@ -124,7 +129,10 @@ func (s *Server) OpenVault(_ context.Context, req *keepassgov1.OpenVaultRequest)
 	return &keepassgov1.OpenVaultResponse{}, nil
 }
 
-func (s *Server) OpenRemoteVault(_ context.Context, req *keepassgov1.OpenRemoteVaultRequest) (*keepassgov1.OpenRemoteVaultResponse, error) {
+func (s *Server) OpenRemoteVault(ctx context.Context, req *keepassgov1.OpenRemoteVaultRequest) (*keepassgov1.OpenRemoteVaultResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	if s.lifecycle == nil {
 		return nil, status.Error(codes.FailedPrecondition, "vault lifecycle backend is not configured")
 	}
@@ -153,7 +161,10 @@ func (s *Server) OpenRemoteVault(_ context.Context, req *keepassgov1.OpenRemoteV
 	return &keepassgov1.OpenRemoteVaultResponse{}, nil
 }
 
-func (s *Server) SaveVault(_ context.Context, _ *keepassgov1.SaveVaultRequest) (*keepassgov1.SaveVaultResponse, error) {
+func (s *Server) SaveVault(ctx context.Context, _ *keepassgov1.SaveVaultRequest) (*keepassgov1.SaveVaultResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	if s.lifecycle == nil {
 		return nil, status.Error(codes.FailedPrecondition, "vault lifecycle backend is not configured")
 	}
@@ -169,7 +180,10 @@ func (s *Server) SaveVault(_ context.Context, _ *keepassgov1.SaveVaultRequest) (
 	return &keepassgov1.SaveVaultResponse{}, nil
 }
 
-func (s *Server) LockVault(_ context.Context, _ *keepassgov1.LockVaultRequest) (*keepassgov1.LockVaultResponse, error) {
+func (s *Server) LockVault(ctx context.Context, _ *keepassgov1.LockVaultRequest) (*keepassgov1.LockVaultResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	if s.lifecycle == nil {
 		return nil, status.Error(codes.FailedPrecondition, "vault lifecycle backend is not configured")
 	}
@@ -185,7 +199,10 @@ func (s *Server) LockVault(_ context.Context, _ *keepassgov1.LockVaultRequest) (
 	return &keepassgov1.LockVaultResponse{}, nil
 }
 
-func (s *Server) UnlockVault(_ context.Context, req *keepassgov1.UnlockVaultRequest) (*keepassgov1.UnlockVaultResponse, error) {
+func (s *Server) UnlockVault(ctx context.Context, req *keepassgov1.UnlockVaultRequest) (*keepassgov1.UnlockVaultResponse, error) {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationManageVault); err != nil {
+		return nil, err
+	}
 	if s.lifecycle == nil {
 		return nil, status.Error(codes.FailedPrecondition, "vault lifecycle backend is not configured")
 	}
@@ -465,7 +482,10 @@ func (s *Server) RestoreEntryHistory(ctx context.Context, req *keepassgov1.Resto
 	return &keepassgov1.RestoreEntryHistoryResponse{Entry: entryToProto(entry)}, nil
 }
 
-func (s *Server) ListTemplates(_ context.Context, _ *keepassgov1.ListTemplatesRequest) (*keepassgov1.ListTemplatesResponse, error) {
+func (s *Server) ListTemplates(ctx context.Context, _ *keepassgov1.ListTemplatesRequest) (*keepassgov1.ListTemplatesResponse, error) {
+	if _, err := s.authorizeTemplateCollectionRequest(ctx, apitokens.OperationListTemplates); err != nil {
+		return nil, err
+	}
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
@@ -483,10 +503,13 @@ func (s *Server) ListTemplates(_ context.Context, _ *keepassgov1.ListTemplatesRe
 	return resp, nil
 }
 
-func (s *Server) UpsertTemplate(_ context.Context, req *keepassgov1.UpsertTemplateRequest) (*keepassgov1.UpsertTemplateResponse, error) {
+func (s *Server) UpsertTemplate(ctx context.Context, req *keepassgov1.UpsertTemplateRequest) (*keepassgov1.UpsertTemplateResponse, error) {
 	if req.GetTemplate() == nil {
 		return nil, status.Error(codes.InvalidArgument, "missing template")
 	}
+	if _, err := s.authorizeTemplateRequest(ctx, apitokens.OperationMutateTemplate, req.GetTemplate().GetId()); err != nil {
+		return nil, err
+	}
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -502,7 +525,10 @@ func (s *Server) UpsertTemplate(_ context.Context, req *keepassgov1.UpsertTempla
 	return &keepassgov1.UpsertTemplateResponse{Template: entryToProto(entry)}, nil
 }
 
-func (s *Server) DeleteTemplate(_ context.Context, req *keepassgov1.DeleteTemplateRequest) (*keepassgov1.DeleteTemplateResponse, error) {
+func (s *Server) DeleteTemplate(ctx context.Context, req *keepassgov1.DeleteTemplateRequest) (*keepassgov1.DeleteTemplateResponse, error) {
+	if _, err := s.authorizeTemplateRequest(ctx, apitokens.OperationMutateTemplate, req.GetId()); err != nil {
+		return nil, err
+	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -521,10 +547,16 @@ func (s *Server) DeleteTemplate(_ context.Context, req *keepassgov1.DeleteTempla
 	return &keepassgov1.DeleteTemplateResponse{}, nil
 }
 
-func (s *Server) InstantiateTemplate(_ context.Context, req *keepassgov1.InstantiateTemplateRequest) (*keepassgov1.InstantiateTemplateResponse, error) {
+func (s *Server) InstantiateTemplate(ctx context.Context, req *keepassgov1.InstantiateTemplateRequest) (*keepassgov1.InstantiateTemplateResponse, error) {
 	if req.GetOverrides() == nil {
 		return nil, status.Error(codes.InvalidArgument, "missing overrides")
 	}
+	if _, err := s.authorizeTemplateRequest(ctx, apitokens.OperationListTemplates, req.GetTemplateId()); err != nil {
+		return nil, err
+	}
+	if _, err := s.authorizePathRequest(ctx, apitokens.OperationMutateEntry, req.GetOverrides().GetPath()); err != nil {
+		return nil, err
+	}
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -685,12 +717,11 @@ func (s *Server) CopyEntryField(ctx context.Context, req *keepassgov1.CopyEntryF
 }
 
 func (s *Server) GeneratePassword(ctx context.Context, req *keepassgov1.GeneratePasswordRequest) (*keepassgov1.GeneratePasswordResponse, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if _, err := s.authenticateRequest(ctx); err != nil {
+	if _, err := s.authorizeVaultRequest(ctx, apitokens.OperationGeneratePassword); err != nil {
 		return nil, err
 	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
 
 	if s.locked {
 		return nil, status.Error(codes.FailedPrecondition, "vault is locked")
@@ -784,6 +815,11 @@ func (s *Server) snapshotModel() (vault.Model, bool) {
 
 var timeNow = func() time.Time { return time.Now().UTC() }
 
+var (
+	vaultPolicyPath    = []string{"Root"}
+	templatePolicyPath = []string{"Root", "Templates"}
+)
+
 func (s *Server) authenticateRequest(ctx context.Context) (apitokens.Token, error) {
 	md, ok := metadata.FromIncomingContext(ctx)
 	if !ok {
@@ -826,6 +862,14 @@ func (s *Server) authorizePathRequest(ctx context.Context, op apitokens.Operatio
 	return s.authorizeResourceRequest(ctx, token, op, apitokens.Resource{Kind: apitokens.ResourceGroup, Path: path})
 }
 
+func (s *Server) authorizeVaultRequest(ctx context.Context, op apitokens.Operation) (apitokens.Token, error) {
+	return s.authorizePathRequest(ctx, op, vaultPolicyPath)
+}
+
+func (s *Server) authorizeTemplateCollectionRequest(ctx context.Context, op apitokens.Operation) (apitokens.Token, error) {
+	return s.authorizePathRequest(ctx, op, templatePolicyPath)
+}
+
 func (s *Server) authorizeEntryRequest(ctx context.Context, op apitokens.Operation, entry vault.Entry) (apitokens.Token, error) {
 	token, err := s.authenticateRequest(ctx)
 	if err != nil {
@@ -834,6 +878,18 @@ func (s *Server) authorizeEntryRequest(ctx context.Context, op apitokens.Operati
 	return s.authorizeResourceRequest(ctx, token, op, apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: entry.ID, Path: entry.Path})
 }
 
+func (s *Server) authorizeTemplateRequest(ctx context.Context, op apitokens.Operation, templateID string) (apitokens.Token, error) {
+	token, err := s.authenticateRequest(ctx)
+	if err != nil {
+		return apitokens.Token{}, err
+	}
+	return s.authorizeResourceRequest(ctx, token, op, apitokens.Resource{
+		Kind:    apitokens.ResourceEntry,
+		Path:    templatePolicyPath,
+		EntryID: templateID,
+	})
+}
+
 func (s *Server) authorizeResourceRequest(ctx context.Context, token apitokens.Token, op apitokens.Operation, resource apitokens.Resource) (apitokens.Token, error) {
 	switch apitokens.Evaluate(token, op, resource) {
 	case apitokens.DecisionAllow:
@@ -955,25 +1011,3 @@ func copyOperation(target string) apitokens.Operation {
 		return apitokens.OperationCopyPassword
 	}
 }
-
-func AuthInterceptor(server *Server) grpc.UnaryServerInterceptor {
-	return func(
-		ctx context.Context,
-		req any,
-		info *grpc.UnaryServerInfo,
-		handler grpc.UnaryHandler,
-	) (any, error) {
-		switch info.FullMethod {
-		case "/keepassgo.v1.VaultService/GetSessionStatus",
-			"/keepassgo.v1.VaultService/OpenVault",
-			"/keepassgo.v1.VaultService/OpenRemoteVault",
-			"/keepassgo.v1.VaultService/SaveVault",
-			"/keepassgo.v1.VaultService/LockVault",
-			"/keepassgo.v1.VaultService/UnlockVault":
-			if _, err := server.authenticateRequest(ctx); err != nil {
-				return nil, err
-			}
-		}
-		return handler(ctx, req)
-	}
-}

internal/api/server_test.go

@@ -10,14 +10,14 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apiaudit"
-	"git.julianfamily.org/keepassgo/apiapproval"
-	"git.julianfamily.org/keepassgo/apitokens"
-	"git.julianfamily.org/keepassgo/passwords"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 	keepassgov1 "git.julianfamily.org/keepassgo/proto/keepassgo/v1"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
@@ -99,6 +99,66 @@ func TestVaultServiceRejectsUnauthorizedEntryAccess(t *testing.T) {
 	}
 }
 
+func TestVaultServiceRejectsUnauthorizedVaultManagement(t *testing.T) {
+	t.Parallel()
+
+	client, _, cleanup := newTestClientForModel(t, vault.Model{
+		Entries: []vault.Entry{
+			testAPITokenEntry(t,
+				apitokens.PolicyRule{Effect: apitokens.EffectDeny, Operation: apitokens.OperationManageVault, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+			),
+		},
+	})
+	defer cleanup()
+
+	_, err := client.GetSessionStatus(tokenContext(defaultTestTokenSecret), &keepassgov1.GetSessionStatusRequest{})
+	if status.Code(err) != codes.PermissionDenied {
+		t.Fatalf("GetSessionStatus() code = %v, want %v", status.Code(err), codes.PermissionDenied)
+	}
+}
+
+func TestVaultServiceRejectsUnauthorizedTemplateMutation(t *testing.T) {
+	t.Parallel()
+
+	client, _, cleanup := newTestClientForModel(t, vault.Model{
+		Entries: []vault.Entry{
+			testAPITokenEntry(t,
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListTemplates, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root", "Templates"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectDeny, Operation: apitokens.OperationMutateTemplate, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root", "Templates"}}},
+			),
+		},
+		Templates: []vault.Entry{
+			{ID: "website-login", Title: "Website Login", Path: []string{"Templates"}},
+		},
+	})
+	defer cleanup()
+
+	_, err := client.UpsertTemplate(tokenContext(defaultTestTokenSecret), &keepassgov1.UpsertTemplateRequest{
+		Template: &keepassgov1.Entry{Id: "website-login", Title: "Updated"},
+	})
+	if status.Code(err) != codes.PermissionDenied {
+		t.Fatalf("UpsertTemplate() code = %v, want %v", status.Code(err), codes.PermissionDenied)
+	}
+}
+
+func TestVaultServiceRejectsUnauthorizedPasswordGeneration(t *testing.T) {
+	t.Parallel()
+
+	client, _, cleanup := newTestClientForModel(t, vault.Model{
+		Entries: []vault.Entry{
+			testAPITokenEntry(t,
+				apitokens.PolicyRule{Effect: apitokens.EffectDeny, Operation: apitokens.OperationGeneratePassword, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+			),
+		},
+	})
+	defer cleanup()
+
+	_, err := client.GeneratePassword(tokenContext(defaultTestTokenSecret), &keepassgov1.GeneratePasswordRequest{Profile: "strong"})
+	if status.Code(err) != codes.PermissionDenied {
+		t.Fatalf("GeneratePassword() code = %v, want %v", status.Code(err), codes.PermissionDenied)
+	}
+}
+
 func TestVaultServicePromptsAndResumesWhenApproved(t *testing.T) {
 	t.Parallel()
 
@@ -1053,64 +1113,67 @@ func testAPITokenEntry(t *testing.T, rules ...apitokens.PolicyRule) vault.Entry
 func newTestClient(t *testing.T) (keepassgov1.VaultServiceClient, *memoryClipboardWriter, func()) {
 	t.Helper()
 	model := vault.Model{
-			Entries: []vault.Entry{
-				{
-					ID:       "vault-console",
-					Title:    "Vault Console",
-					Username: "dannyocean",
-					Password: "token-1",
-					URL:      "https://vault.crew.example.invalid",
-					Fields: map[string]string{
-						"X-Role": "automation",
-					},
-					History: []vault.Entry{
-						{
-							ID:       "vault-console-h1",
-							Title:    "Vault Console",
-							Username: "dannyocean",
-							Password: "token-0",
-							URL:      "https://vault.crew.example.invalid",
-							Path:     []string{"Root", "Internet"},
-						},
-					},
-					Path: []string{"Root", "Internet"},
+		Entries: []vault.Entry{
+			{
+				ID:       "vault-console",
+				Title:    "Vault Console",
+				Username: "dannyocean",
+				Password: "token-1",
+				URL:      "https://vault.crew.example.invalid",
+				Fields: map[string]string{
+					"X-Role": "automation",
 				},
-				{
-					ID:       "surveillance-console",
-					Title:    "Surveillance Console",
-					Username: "codex",
-					Password: "token-2",
-					URL:      "https://surveillance.crew.example.invalid",
-					Path:     []string{"Root", "Home Assistant"},
+				History: []vault.Entry{
+					{
+						ID:       "vault-console-h1",
+						Title:    "Vault Console",
+						Username: "dannyocean",
+						Password: "token-0",
+						URL:      "https://vault.crew.example.invalid",
+						Path:     []string{"Root", "Internet"},
+					},
 				},
-				testAPITokenEntry(t,
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationManageVault, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListEntries, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListGroups, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationMutateGroup, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationMutateEntry, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationReadEntry, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyPassword, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyUsername, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
-					apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyURL, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
-				),
+				Path: []string{"Root", "Internet"},
 			},
-			Templates: []vault.Entry{
-				{
-					ID:       "website-login",
-					Title:    "Website Login",
-					Username: "template-user",
-					Password: "template-password",
-					URL:      "https://example.com",
-					Notes:    "Reusable template for website accounts.",
-					Fields: map[string]string{
-						"Environment": "prod",
-					},
-					Tags: []string{"template", "web"},
-					Path: []string{"Templates"},
-				},
+			{
+				ID:       "surveillance-console",
+				Title:    "Surveillance Console",
+				Username: "codex",
+				Password: "token-2",
+				URL:      "https://surveillance.crew.example.invalid",
+				Path:     []string{"Root", "Home Assistant"},
 			},
-		}
+			testAPITokenEntry(t,
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationManageVault, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListEntries, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListGroups, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationListTemplates, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root", "Templates"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationMutateGroup, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationMutateEntry, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationMutateTemplate, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root", "Templates"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationReadEntry, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationGeneratePassword, Resource: apitokens.Resource{Kind: apitokens.ResourceGroup, Path: []string{"Root"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyPassword, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyUsername, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
+				apitokens.PolicyRule{Effect: apitokens.EffectAllow, Operation: apitokens.OperationCopyURL, Resource: apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: "vault-console", Path: []string{"Root", "Internet"}}},
+			),
+		},
+		Templates: []vault.Entry{
+			{
+				ID:       "website-login",
+				Title:    "Website Login",
+				Username: "template-user",
+				Password: "template-password",
+				URL:      "https://example.com",
+				Notes:    "Reusable template for website accounts.",
+				Fields: map[string]string{
+					"Environment": "prod",
+				},
+				Tags: []string{"template", "web"},
+				Path: []string{"Templates"},
+			},
+		},
+	}
 	return newTestClientForModel(t, model)
 }
 
@@ -1125,7 +1188,7 @@ func newTestHarnessForModel(t *testing.T, model vault.Model) (keepassgov1.VaultS
 	listener := bufconn.Listen(1024 * 1024)
 	clipboardWriter := &memoryClipboardWriter{}
 	service := NewServer(model, passwords.DefaultProfiles(), clipboardWriter)
-	server := grpc.NewServer(grpc.UnaryInterceptor(AuthInterceptor(service)))
+	server := grpc.NewServer()
 	keepassgov1.RegisterVaultServiceServer(server, service)
 
 	go func() {
@@ -1168,7 +1231,7 @@ func newTestHarnessWithLifecycle(t *testing.T, lifecycle *stubLifecycle) (keepas
 	))
 	lifecycle.model = model
 	service := NewServerWithLifecycle(model, passwords.DefaultProfiles(), clipboardWriter, lifecycle)
-	server := grpc.NewServer(grpc.UnaryInterceptor(AuthInterceptor(service)))
+	server := grpc.NewServer()
 	keepassgov1.RegisterVaultServiceServer(server, service)
 
 	go func() {

internal/apiapproval/approval.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apitokens"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
 )
 
 var (
@@ -22,20 +22,20 @@ var (
 type Outcome string
 
 const (
-	OutcomeAllowOnce        Outcome = "allow-once"
-	OutcomeDenyOnce         Outcome = "deny-once"
-	OutcomeAllowPermanent   Outcome = "allow-permanent"
-	OutcomeDenyPermanent    Outcome = "deny-permanent"
-	OutcomeCancel           Outcome = "cancel"
+	OutcomeAllowOnce      Outcome = "allow-once"
+	OutcomeDenyOnce       Outcome = "deny-once"
+	OutcomeAllowPermanent Outcome = "allow-permanent"
+	OutcomeDenyPermanent  Outcome = "deny-permanent"
+	OutcomeCancel         Outcome = "cancel"
 )
 
 type Request struct {
-	ID         string
-	TokenID    string
-	TokenName  string
-	ClientName string
-	Operation  apitokens.Operation
-	Resource   apitokens.Resource
+	ID          string
+	TokenID     string
+	TokenName   string
+	ClientName  string
+	Operation   apitokens.Operation
+	Resource    apitokens.Resource
 	RequestedAt time.Time
 }
 

internal/apiapproval/approval_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apitokens"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
 )
 
 func TestBrokerCreatesPendingRequestAndAllowsOnce(t *testing.T) {

internal/apiaudit/audit.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apitokens"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
 )
 
 type EventType string
@@ -16,6 +16,12 @@ const (
 	EventApprovalDenied    EventType = "approval_denied"
 	EventApprovalCanceled  EventType = "approval_canceled"
 	EventApprovalTimedOut  EventType = "approval_timed_out"
+	EventTokenIssued       EventType = "token_issued"
+	EventTokenUpdated      EventType = "token_updated"
+	EventTokenRotated      EventType = "token_rotated"
+	EventTokenDisabled     EventType = "token_disabled"
+	EventTokenRevoked      EventType = "token_revoked"
+	EventTokenDeleted      EventType = "token_deleted"
 	EventAutofillFound     EventType = "autofill_found"
 	EventAutofillAmbiguous EventType = "autofill_ambiguous"
 	EventAutofillBlocked   EventType = "autofill_blocked"

internal/apiaudit/audit_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apitokens"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
 )
 
 func TestLogKeepsNewestEventsWithinBound(t *testing.T) {

internal/apitokens/tokens.go

@@ -12,7 +12,7 @@ import (
 	"strings"
 	"time"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 const (
@@ -55,15 +55,18 @@ const (
 	DecisionDeny   Decision = "deny"
 	DecisionPrompt Decision = "prompt"
 
-	OperationListEntries  Operation = "list_entries"
-	OperationListGroups   Operation = "list_groups"
-	OperationReadEntry    Operation = "read_entry"
-	OperationCopyPassword Operation = "copy_password"
-	OperationCopyUsername Operation = "copy_username"
-	OperationCopyURL      Operation = "copy_url"
-	OperationMutateEntry  Operation = "mutate_entry"
-	OperationMutateGroup  Operation = "mutate_group"
-	OperationManageVault  Operation = "manage_vault"
+	OperationListEntries      Operation = "list_entries"
+	OperationListGroups       Operation = "list_groups"
+	OperationListTemplates    Operation = "list_templates"
+	OperationReadEntry        Operation = "read_entry"
+	OperationCopyPassword     Operation = "copy_password"
+	OperationCopyUsername     Operation = "copy_username"
+	OperationCopyURL          Operation = "copy_url"
+	OperationMutateEntry      Operation = "mutate_entry"
+	OperationMutateGroup      Operation = "mutate_group"
+	OperationMutateTemplate   Operation = "mutate_template"
+	OperationGeneratePassword Operation = "generate_password"
+	OperationManageVault      Operation = "manage_vault"
 )
 
 type Resource struct {

internal/apitokens/tokens_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 func TestTokenEntryRoundTripsThroughVaultEntry(t *testing.T) {

internal/appstate/remote_binding.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"strings"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 type SyncMode string

internal/appstate/remote_binding_test.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 func TestRemoteBindingResolveUsesVaultProfileAndCredentialEntry(t *testing.T) {

internal/appstate/state.go

@@ -7,10 +7,11 @@ import (
 	"strings"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apiapproval"
-	"git.julianfamily.org/keepassgo/apitokens"
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 )
 
 type Section string
@@ -101,6 +102,7 @@ type ApprovalManager interface {
 type State struct {
 	Session         CurrentSession
 	Approvals       ApprovalManager
+	AuditLog        *apiaudit.Log
 	Section         Section
 	CurrentPath     []string
 	SearchQuery     string
@@ -195,6 +197,7 @@ func (s *State) IssueAPIToken(name, clientName string, expiresAt *time.Time, now
 	apitokens.Upsert(&model, token)
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenIssued, token, "issued API token")
 	return token, secret, nil
 }
 
@@ -218,6 +221,7 @@ func (s *State) RotateAPIToken(id string, now time.Time) (apitokens.Token, strin
 	apitokens.Upsert(&model, token)
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenRotated, token, "rotated API token")
 	return token, secret, nil
 }
 
@@ -233,6 +237,7 @@ func (s *State) UpsertAPIToken(token apitokens.Token) error {
 	apitokens.Upsert(&model, token)
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenUpdated, token, "updated API token")
 	return nil
 }
 
@@ -249,9 +254,11 @@ func (s *State) DisableAPIToken(id string) error {
 	if err != nil {
 		return err
 	}
-	apitokens.Upsert(&model, apitokens.Disable(token))
+	token = apitokens.Disable(token)
+	apitokens.Upsert(&model, token)
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenDisabled, token, "disabled API token")
 	return nil
 }
 
@@ -268,9 +275,11 @@ func (s *State) RevokeAPIToken(id string, when time.Time) error {
 	if err != nil {
 		return err
 	}
-	apitokens.Upsert(&model, apitokens.Revoke(token, when))
+	token = apitokens.Revoke(token, when)
+	apitokens.Upsert(&model, token)
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenRevoked, token, "revoked API token")
 	return nil
 }
 
@@ -283,14 +292,37 @@ func (s *State) DeleteAPIToken(id string) error {
 	if err != nil {
 		return err
 	}
+	token, err := apitokens.Find(model, id)
+	if err != nil {
+		return err
+	}
 	if err := apitokens.Delete(&model, id); err != nil {
 		return err
 	}
 	session.Replace(model)
 	s.Dirty = true
+	s.recordTokenAudit(apiaudit.EventTokenDeleted, token, "deleted API token")
 	return nil
 }
 
+func (s *State) recordTokenAudit(eventType apiaudit.EventType, token apitokens.Token, message string) {
+	if s.AuditLog == nil {
+		return
+	}
+	s.AuditLog.Record(apiaudit.Event{
+		Type:       eventType,
+		TokenID:    token.ID,
+		TokenName:  token.Name,
+		ClientName: token.ClientName,
+		Resource: apitokens.Resource{
+			Kind:    apitokens.ResourceEntry,
+			Path:    apitokens.EntryPath,
+			EntryID: token.ID,
+		},
+		Message: message,
+	})
+}
+
 func (s *State) SecuritySettings() (vault.SecuritySettings, error) {
 	security, ok := s.Session.(SecurityConfigurableSession)
 	if !ok {

internal/appstate/state_test.go

@@ -6,11 +6,12 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/apiapproval"
-	"git.julianfamily.org/keepassgo/apitokens"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 )
 
 func TestVisibleEntriesFollowsCurrentPathWithoutSearch(t *testing.T) {
@@ -109,7 +110,8 @@ func TestIssueRotateDisableRevokeAndDeleteAPIToken(t *testing.T) {
 	t.Parallel()
 
 	session := &mutableStubSession{model: vault.Model{}}
-	state := State{Session: session}
+	auditLog := apiaudit.New(10)
+	state := State{Session: session, AuditLog: auditLog}
 	now := time.Date(2026, 3, 29, 12, 0, 0, 0, time.UTC)
 	expiresAt := now.Add(24 * time.Hour)
 
@@ -162,6 +164,24 @@ func TestIssueRotateDisableRevokeAndDeleteAPIToken(t *testing.T) {
 	if len(tokens) != 0 {
 		t.Fatalf("APITokens() after delete = %#v, want empty", tokens)
 	}
+
+	events := auditLog.Events()
+	if len(events) != 5 {
+		t.Fatalf("len(AuditLog.Events()) = %d, want 5", len(events))
+	}
+	if events[0].Type != apiaudit.EventTokenDeleted ||
+		events[1].Type != apiaudit.EventTokenRevoked ||
+		events[2].Type != apiaudit.EventTokenDisabled ||
+		events[3].Type != apiaudit.EventTokenRotated ||
+		events[4].Type != apiaudit.EventTokenIssued {
+		t.Fatalf("AuditLog.Events() types = %#v, want deleted/revoked/disabled/rotated/issued", events)
+	}
+	if events[0].TokenID != issued.ID || events[0].Resource.EntryID != issued.ID {
+		t.Fatalf("delete audit event = %#v, want token/resource id %q", events[0], issued.ID)
+	}
+	if events[4].TokenName != "CLI" || events[4].ClientName != "grpc-cli" {
+		t.Fatalf("issued audit event = %#v, want CLI/grpc-cli metadata", events[4])
+	}
 }
 
 func TestRemoteProfilesReturnsVaultProfiles(t *testing.T) {

internal/appui/api/model.go

@@ -0,0 +1,93 @@
+package api
+
+import (
+	"strings"
+
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+)
+
+type AuditQuickFilter struct {
+	Label string
+	Query string
+}
+
+func Operations() []apitokens.Operation {
+	return []apitokens.Operation{
+		apitokens.OperationListEntries,
+		apitokens.OperationListGroups,
+		apitokens.OperationListTemplates,
+		apitokens.OperationReadEntry,
+		apitokens.OperationCopyPassword,
+		apitokens.OperationCopyUsername,
+		apitokens.OperationCopyURL,
+		apitokens.OperationMutateEntry,
+		apitokens.OperationMutateGroup,
+		apitokens.OperationMutateTemplate,
+		apitokens.OperationGeneratePassword,
+		apitokens.OperationManageVault,
+	}
+}
+
+func AuditDecisionLabel(eventType apiaudit.EventType) string {
+	switch eventType {
+	case apiaudit.EventApprovalRequested:
+		return "Requested"
+	case apiaudit.EventApprovalAllowed:
+		return "Allowed"
+	case apiaudit.EventApprovalDenied:
+		return "Denied"
+	case apiaudit.EventApprovalCanceled:
+		return "Canceled"
+	case apiaudit.EventApprovalTimedOut:
+		return "Timed Out"
+	case apiaudit.EventAuthRejected:
+		return "Auth Rejected"
+	default:
+		return strings.ReplaceAll(string(eventType), "_", " ")
+	}
+}
+
+func AuditOperationLabel(operation apitokens.Operation) string {
+	if strings.TrimSpace(string(operation)) == "" {
+		return "Other"
+	}
+	return strings.ReplaceAll(string(operation), "_", " ")
+}
+
+func CompactAuditFilterLabel(label string) string {
+	label = strings.TrimSpace(label)
+	if len(label) <= 22 {
+		return label
+	}
+	return label[:19] + "..."
+}
+
+func AuditEventSearchTerms(event apiaudit.Event) string {
+	parts := []string{
+		string(event.Type),
+		AuditDecisionLabel(event.Type),
+		event.TokenName,
+		event.ClientName,
+		string(event.Operation),
+		AuditOperationLabel(event.Operation),
+		strings.Join(event.Resource.Path, " / "),
+		event.Resource.EntryID,
+		event.Message,
+	}
+	switch event.Type {
+	case apiaudit.EventApprovalAllowed:
+		parts = append(parts, "allow approved")
+	case apiaudit.EventApprovalDenied:
+		parts = append(parts, "deny denied")
+	case apiaudit.EventApprovalRequested:
+		parts = append(parts, "prompt requested")
+	case apiaudit.EventApprovalCanceled:
+		parts = append(parts, "cancel canceled")
+	case apiaudit.EventApprovalTimedOut:
+		parts = append(parts, "timeout timed out")
+	case apiaudit.EventAuthRejected:
+		parts = append(parts, "rejected unauthorized")
+	}
+	return strings.ToLower(strings.Join(parts, " "))
+}

internal/appui/api_views.go

@@ -1,4 +1,4 @@
-package main
+package appui
 
 import (
 	"fmt"
@@ -10,91 +10,12 @@ import (
 	"gioui.org/unit"
 	"gioui.org/widget"
 	"gioui.org/widget/material"
-	"git.julianfamily.org/keepassgo/apiaudit"
-	"git.julianfamily.org/keepassgo/apitokens"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	apiui "git.julianfamily.org/keepassgo/internal/appui/api"
 )
 
-func apiOperations() []apitokens.Operation {
-	return []apitokens.Operation{
-		apitokens.OperationListEntries,
-		apitokens.OperationListGroups,
-		apitokens.OperationReadEntry,
-		apitokens.OperationCopyPassword,
-		apitokens.OperationCopyUsername,
-		apitokens.OperationCopyURL,
-		apitokens.OperationMutateEntry,
-		apitokens.OperationMutateGroup,
-		apitokens.OperationManageVault,
-	}
-}
-
-type apiAuditQuickFilter struct {
-	Label string
-	Query string
-}
-
-func apiAuditDecisionLabel(eventType apiaudit.EventType) string {
-	switch eventType {
-	case apiaudit.EventApprovalRequested:
-		return "Requested"
-	case apiaudit.EventApprovalAllowed:
-		return "Allowed"
-	case apiaudit.EventApprovalDenied:
-		return "Denied"
-	case apiaudit.EventApprovalCanceled:
-		return "Canceled"
-	case apiaudit.EventApprovalTimedOut:
-		return "Timed Out"
-	case apiaudit.EventAuthRejected:
-		return "Auth Rejected"
-	default:
-		return strings.ReplaceAll(string(eventType), "_", " ")
-	}
-}
-
-func apiAuditOperationLabel(operation apitokens.Operation) string {
-	if strings.TrimSpace(string(operation)) == "" {
-		return "Other"
-	}
-	return strings.ReplaceAll(string(operation), "_", " ")
-}
-
-func compactAuditFilterLabel(label string) string {
-	label = strings.TrimSpace(label)
-	if len(label) <= 22 {
-		return label
-	}
-	return label[:19] + "..."
-}
-
-func apiAuditEventSearchTerms(event apiaudit.Event) string {
-	parts := []string{
-		string(event.Type),
-		apiAuditDecisionLabel(event.Type),
-		event.TokenName,
-		event.ClientName,
-		string(event.Operation),
-		apiAuditOperationLabel(event.Operation),
-		strings.Join(event.Resource.Path, " / "),
-		event.Resource.EntryID,
-		event.Message,
-	}
-	switch event.Type {
-	case apiaudit.EventApprovalAllowed:
-		parts = append(parts, "allow approved")
-	case apiaudit.EventApprovalDenied:
-		parts = append(parts, "deny denied")
-	case apiaudit.EventApprovalRequested:
-		parts = append(parts, "prompt requested")
-	case apiaudit.EventApprovalCanceled:
-		parts = append(parts, "cancel canceled")
-	case apiaudit.EventApprovalTimedOut:
-		parts = append(parts, "timeout timed out")
-	case apiaudit.EventAuthRejected:
-		parts = append(parts, "rejected unauthorized")
-	}
-	return strings.ToLower(strings.Join(parts, " "))
-}
+type apiAuditQuickFilter = apiui.AuditQuickFilter
 
 func apiAuditFilterButtons(clicks *[]widget.Clickable, filters []apiAuditQuickFilter) []widget.Clickable {
 	if len(filters) == 0 {
@@ -126,7 +47,7 @@ func (u *ui) apiAuditQuickFilters(events []apiaudit.Event) ([]apiAuditQuickFilte
 		}
 		if _, ok := decisionSeen[event.Type]; !ok {
 			decisionSeen[event.Type] = struct{}{}
-			label := apiAuditDecisionLabel(event.Type)
+			label := apiui.AuditDecisionLabel(event.Type)
 			decisions = append(decisions, apiAuditQuickFilter{Label: label, Query: label})
 		}
 		if strings.TrimSpace(string(event.Operation)) == "" {
@@ -136,7 +57,7 @@ func (u *ui) apiAuditQuickFilters(events []apiaudit.Event) ([]apiAuditQuickFilte
 			continue
 		}
 		operationSeen[event.Operation] = struct{}{}
-		label := apiAuditOperationLabel(event.Operation)
+		label := apiui.AuditOperationLabel(event.Operation)
 		operations = append(operations, apiAuditQuickFilter{Label: label, Query: label})
 	}
 
@@ -208,7 +129,22 @@ func (u *ui) ensureAPIPolicyRemoveClickables(count int) []widget.Clickable {
 	return clicks
 }
 
+func (u *ui) ensureAPIPolicyEditClickables(count int) []widget.Clickable {
+	if count <= 0 {
+		u.apiPolicyEdits = nil
+		return nil
+	}
+	if len(u.apiPolicyEdits) == count {
+		return u.apiPolicyEdits
+	}
+	clicks := make([]widget.Clickable, count)
+	copy(clicks, u.apiPolicyEdits)
+	u.apiPolicyEdits = clicks
+	return clicks
+}
+
 func (u *ui) loadSelectedAPITokenIntoEditor() {
+	u.selectedAPIPolicyIndex = -1
 	token, ok := u.selectedAPIToken()
 	if !ok {
 		u.apiTokenSecret = ""
@@ -222,6 +158,7 @@ func (u *ui) loadSelectedAPITokenIntoEditor() {
 		u.apiPolicyAllow.Value = true
 		u.apiPolicyGroupScope = true
 		u.apiPolicyGroupScopeW.Value = true
+		u.ensureAPIPolicyEditClickables(0)
 		u.ensureAPIPolicyRemoveClickables(0)
 		return
 	}
@@ -233,6 +170,7 @@ func (u *ui) loadSelectedAPITokenIntoEditor() {
 		u.apiTokenExpiresAt.SetText("")
 	}
 	u.apiTokenDisabled.Value = token.Disabled
+	u.ensureAPIPolicyEditClickables(len(token.Policies))
 	u.ensureAPIPolicyRemoveClickables(len(token.Policies))
 }
 
@@ -321,7 +259,7 @@ func parseAPITokenExpiry(text string) (*time.Time, error) {
 
 func parseAPIPolicyOperation(text string) (apitokens.Operation, error) {
 	value := apitokens.Operation(strings.TrimSpace(text))
-	for _, operation := range apiOperations() {
+	for _, operation := range apiui.Operations() {
 		if operation == value {
 			return value, nil
 		}
@@ -329,14 +267,10 @@ func parseAPIPolicyOperation(text string) (apitokens.Operation, error) {
 	return "", fmt.Errorf("unknown API operation %q", text)
 }
 
-func (u *ui) addAPIPolicyRuleAction() error {
-	token, ok := u.selectedAPIToken()
-	if !ok {
-		return fmt.Errorf("no API token selected")
-	}
+func (u *ui) apiPolicyRuleFromEditor() (apitokens.PolicyRule, error) {
 	operation, err := parseAPIPolicyOperation(u.apiPolicyOperation.Text())
 	if err != nil {
-		return err
+		return apitokens.PolicyRule{}, err
 	}
 	rule := apitokens.PolicyRule{
 		Operation: operation,
@@ -349,16 +283,28 @@ func (u *ui) addAPIPolicyRuleAction() error {
 	if u.apiPolicyGroupScope {
 		path := parsePath(u.apiPolicyPath.Text())
 		if len(path) == 0 {
-			return fmt.Errorf("policy path is required for group scope")
+			return apitokens.PolicyRule{}, fmt.Errorf("policy path is required for group scope")
 		}
 		rule.Resource = apitokens.Resource{Kind: apitokens.ResourceGroup, Path: path}
 	} else {
 		entryID := strings.TrimSpace(u.apiPolicyEntryID.Text())
 		if entryID == "" {
-			return fmt.Errorf("entry id is required for entry scope")
+			return apitokens.PolicyRule{}, fmt.Errorf("entry id is required for entry scope")
 		}
 		rule.Resource = apitokens.Resource{Kind: apitokens.ResourceEntry, EntryID: entryID}
 	}
+	return rule, nil
+}
+
+func (u *ui) addAPIPolicyRuleAction() error {
+	token, ok := u.selectedAPIToken()
+	if !ok {
+		return fmt.Errorf("no API token selected")
+	}
+	rule, err := u.apiPolicyRuleFromEditor()
+	if err != nil {
+		return err
+	}
 	if !uiHasPolicyRule(token.Policies, rule) {
 		token.Policies = append(token.Policies, rule)
 	}
@@ -369,6 +315,63 @@ func (u *ui) addAPIPolicyRuleAction() error {
 	return nil
 }
 
+func (u *ui) editAPIPolicyRuleAction(index int) error {
+	token, ok := u.selectedAPIToken()
+	if !ok {
+		return fmt.Errorf("no API token selected")
+	}
+	if index < 0 || index >= len(token.Policies) {
+		return fmt.Errorf("policy index %d out of range", index)
+	}
+	rule := token.Policies[index]
+	u.selectedAPIPolicyIndex = index
+	u.apiPolicyOperation.SetText(string(rule.Operation))
+	u.apiPolicyAllow.Value = rule.Effect == apitokens.EffectAllow
+	if rule.Resource.Kind == apitokens.ResourceEntry {
+		u.apiPolicyGroupScope = false
+		u.apiPolicyGroupScopeW.Value = false
+		u.apiPolicyEntryID.SetText(strings.TrimSpace(rule.Resource.EntryID))
+		u.apiPolicyPath.SetText("")
+		return nil
+	}
+	u.apiPolicyGroupScope = true
+	u.apiPolicyGroupScopeW.Value = true
+	u.apiPolicyPath.SetText(strings.Join(rule.Resource.Path, " / "))
+	u.apiPolicyEntryID.SetText("")
+	return nil
+}
+
+func (u *ui) saveAPIPolicyRuleAction() error {
+	token, ok := u.selectedAPIToken()
+	if !ok {
+		return fmt.Errorf("no API token selected")
+	}
+	index := u.selectedAPIPolicyIndex
+	if index < 0 || index >= len(token.Policies) {
+		return fmt.Errorf("no API policy rule selected")
+	}
+	rule, err := u.apiPolicyRuleFromEditor()
+	if err != nil {
+		return err
+	}
+	for i, existing := range token.Policies {
+		if i != index && uiHasPolicyRule([]apitokens.PolicyRule{existing}, rule) {
+			token.Policies = append(token.Policies[:index], token.Policies[index+1:]...)
+			if err := u.state.UpsertAPIToken(token); err != nil {
+				return err
+			}
+			u.loadSelectedAPITokenIntoEditor()
+			return nil
+		}
+	}
+	token.Policies[index] = rule
+	if err := u.state.UpsertAPIToken(token); err != nil {
+		return err
+	}
+	u.loadSelectedAPITokenIntoEditor()
+	return nil
+}
+
 func (u *ui) apiPolicyGroupPathSummary() string {
 	path := parsePath(u.apiPolicyPath.Text())
 	if len(path) == 0 {
@@ -436,6 +439,11 @@ func (u *ui) removeAPIPolicyRuleAction(index int) error {
 	return nil
 }
 
+func (u *ui) cancelAPIPolicyEditAction() error {
+	u.loadSelectedAPITokenIntoEditor()
+	return nil
+}
+
 func (u *ui) apiAuditEvents() []apiaudit.Event {
 	if u.auditLog == nil {
 		return nil
@@ -450,7 +458,7 @@ func (u *ui) apiAuditEvents() []apiaudit.Event {
 	}
 	filtered := make([]apiaudit.Event, 0, len(events))
 	for _, event := range events {
-		haystack := apiAuditEventSearchTerms(event)
+		haystack := apiui.AuditEventSearchTerms(event)
 		if strings.Contains(haystack, query) {
 			filtered = append(filtered, event)
 		}
@@ -785,7 +793,7 @@ func (u *ui) apiAuditQuickFilterRow(gtx layout.Context, title string, filters []
 					click := &buttons[i]
 					selected := strings.EqualFold(strings.TrimSpace(u.search.Text()), strings.TrimSpace(filter.Query))
 					column = append(column, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						return u.auditQuickFilterButton(gtx, click, compactAuditFilterLabel(filter.Label), selected, filter.Query)
+						return u.auditQuickFilterButton(gtx, click, apiui.CompactAuditFilterLabel(filter.Label), selected, filter.Query)
 					}))
 				}
 				return layout.Flex{Axis: layout.Vertical}.Layout(gtx, column...)
@@ -799,7 +807,7 @@ func (u *ui) apiAuditQuickFilterRow(gtx layout.Context, title string, filters []
 				click := &buttons[i]
 				selected := strings.EqualFold(strings.TrimSpace(u.search.Text()), strings.TrimSpace(filter.Query))
 				flexChildren = append(flexChildren, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					return u.auditQuickFilterButton(gtx, click, compactAuditFilterLabel(filter.Label), selected, filter.Query)
+					return u.auditQuickFilterButton(gtx, click, apiui.CompactAuditFilterLabel(filter.Label), selected, filter.Query)
 				}))
 			}
 			return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx, flexChildren...)
@@ -828,8 +836,10 @@ func (u *ui) auditQuickFilterButton(gtx layout.Context, click *widget.Clickable,
 
 func (u *ui) apiTokenDetailPanel(gtx layout.Context) layout.Dimensions {
 	token, ok := u.selectedAPIToken()
+	editClicks := u.ensureAPIPolicyEditClickables(0)
 	removeClicks := u.ensureAPIPolicyRemoveClickables(0)
 	if ok {
+		editClicks = u.ensureAPIPolicyEditClickables(len(token.Policies))
 		removeClicks = u.ensureAPIPolicyRemoveClickables(len(token.Policies))
 	}
 	rows := []layout.Widget{
@@ -997,6 +1007,10 @@ func (u *ui) apiTokenDetailPanel(gtx layout.Context) layout.Dimensions {
 												return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
 													layout.Flexed(1, detailLine(u.theme, "Effect", effect)),
 													layout.Rigid(layout.Spacer{Width: unit.Dp(12)}.Layout),
+													layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+														return tonedButton(gtx, u.theme, &editClicks[index], "Edit")
+													}),
+													layout.Rigid(layout.Spacer{Width: unit.Dp(6)}.Layout),
 													layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 														return tonedButton(gtx, u.theme, &removeClicks[index], "Remove")
 													}),
@@ -1030,15 +1044,23 @@ func (u *ui) apiTokenDetailPanel(gtx layout.Context) layout.Dimensions {
 	rows = append(rows,
 		func(gtx layout.Context) layout.Dimensions {
 			return card(gtx, func(gtx layout.Context) layout.Dimensions {
+				actionLabel := "Add Rule"
+				title := "Policy Composer"
+				description := "Rules are evaluated per operation. Explicit deny rules override allow rules."
+				if 0 <= u.selectedAPIPolicyIndex {
+					actionLabel = "Save Rule"
+					title = "Policy Editor"
+					description = "Editing an existing rule. Save the updated scope or cancel to return to a blank composer."
+				}
 				return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						lbl := material.Label(u.theme, unit.Sp(14), "Policy Composer")
+						lbl := material.Label(u.theme, unit.Sp(14), title)
 						lbl.Color = accentColor
 						return lbl.Layout(gtx)
 					}),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						lbl := material.Label(u.theme, unit.Sp(12), "Rules are evaluated per operation. Explicit deny rules override allow rules.")
+						lbl := material.Label(u.theme, unit.Sp(12), description)
 						lbl.Color = mutedColor
 						return lbl.Layout(gtx)
 					}),
@@ -1051,7 +1073,7 @@ func (u *ui) apiTokenDetailPanel(gtx layout.Context) layout.Dimensions {
 						return material.CheckBox(u.theme, &u.apiPolicyGroupScopeW, "Group scope (unchecked means exact entry scope)").Layout(gtx)
 					}),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-					layout.Rigid(labeledEditorHelp(u.theme, "Operation", "Valid operations: "+strings.Join(stringOps(apiOperations()), ", "), &u.apiPolicyOperation, false)),
+					layout.Rigid(labeledEditorHelp(u.theme, "Operation", "Valid operations: "+strings.Join(stringOps(apiui.Operations()), ", "), &u.apiPolicyOperation, false)),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 						if u.apiPolicyGroupScopeW.Value {
@@ -1093,7 +1115,22 @@ func (u *ui) apiTokenDetailPanel(gtx layout.Context) layout.Dimensions {
 					}),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						return tonedButton(gtx, u.theme, &u.addAPIPolicyRule, "Add Rule")
+						return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								if 0 <= u.selectedAPIPolicyIndex {
+									return tonedButton(gtx, u.theme, &u.saveAPIPolicyRule, actionLabel)
+								}
+								return tonedButton(gtx, u.theme, &u.addAPIPolicyRule, actionLabel)
+							}),
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								if u.selectedAPIPolicyIndex < 0 {
+									return layout.Dimensions{}
+								}
+								return layout.Inset{Left: unit.Dp(6)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+									return tonedButton(gtx, u.theme, &u.cancelAPIPolicyEdit, "Cancel Edit")
+								})
+							}),
+						)
 					}),
 				)
 			})

internal/appui/detail/layout/mode.go

@@ -0,0 +1,26 @@
+package layout
+
+type Mode string
+
+const (
+	ModeLocked Mode = "locked"
+	ModeStatic Mode = "static"
+	ModeEmpty  Mode = "empty"
+	ModeEditor Mode = "editor"
+	ModeView   Mode = "view"
+)
+
+func Resolve(isLocked bool, hasStaticPanel bool, hasSelectedEntry bool, editing bool) Mode {
+	switch {
+	case isLocked:
+		return ModeLocked
+	case hasStaticPanel:
+		return ModeStatic
+	case !hasSelectedEntry && !editing:
+		return ModeEmpty
+	case editing:
+		return ModeEditor
+	default:
+		return ModeView
+	}
+}

internal/appui/detail/model.go

@@ -0,0 +1,17 @@
+package detail
+
+type EmptyState struct {
+	Title string
+	Body  string
+}
+
+type VaultSummary struct {
+	Title   string
+	Detail  string
+	Context string
+}
+
+type AttachmentItem struct {
+	Name string
+	Size int
+}

internal/appui/editor/model.go

@@ -0,0 +1,64 @@
+package editor
+
+import "strings"
+
+type Field string
+
+const (
+	FieldID              Field = "id"
+	FieldTitle           Field = "title"
+	FieldUsername        Field = "username"
+	FieldPassword        Field = "password"
+	FieldURL             Field = "url"
+	FieldPath            Field = "path"
+	FieldTags            Field = "tags"
+	FieldPasswordProfile Field = "password-profile"
+	FieldNotes           Field = "notes"
+	FieldFields          Field = "fields"
+	FieldHistoryIndex    Field = "history-index"
+)
+
+func Label(field Field) string {
+	switch field {
+	case FieldID:
+		return "ID"
+	case FieldTitle:
+		return "Title"
+	case FieldUsername:
+		return "Username"
+	case FieldPassword:
+		return "Password"
+	case FieldURL:
+		return "URL"
+	case FieldPath:
+		return "Path"
+	case FieldTags:
+		return "Tags"
+	case FieldPasswordProfile:
+		return "Password Profile"
+	case FieldNotes:
+		return "Notes"
+	case FieldFields:
+		return "Custom Fields"
+	case FieldHistoryIndex:
+		return "History Index"
+	default:
+		return strings.ReplaceAll(string(field), "-", " ")
+	}
+}
+
+func FocusOrder() []Field {
+	return []Field{
+		FieldID,
+		FieldTitle,
+		FieldUsername,
+		FieldPassword,
+		FieldURL,
+		FieldPath,
+		FieldTags,
+		FieldPasswordProfile,
+		FieldNotes,
+		FieldFields,
+		FieldHistoryIndex,
+	}
+}

internal/appui/entry_editor.go

@@ -1,4 +1,4 @@
-package main
+package appui
 
 import (
 	"fmt"
@@ -8,9 +8,9 @@ import (
 	"strings"
 
 	"gioui.org/widget"
-	"git.julianfamily.org/keepassgo/clipboard"
-	"git.julianfamily.org/keepassgo/passwords"
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/clipboard"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 func (u *ui) attachmentInput() (string, []byte, error) {

internal/appui/header.go

@@ -0,0 +1,335 @@
+package appui
+
+import (
+	"fmt"
+	"image"
+
+	"gioui.org/layout"
+	"gioui.org/op"
+	"gioui.org/op/paint"
+	"gioui.org/unit"
+	"gioui.org/widget"
+	"gioui.org/widget/material"
+	headerview "git.julianfamily.org/keepassgo/internal/appui/header"
+	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
+)
+
+func (u *ui) header(gtx layout.Context) layout.Dimensions {
+	if u.usesCompactViewport() {
+		if u.shouldShowLifecycleSetup() || u.isVaultLocked() {
+			return layout.Dimensions{}
+		}
+		gtx.Constraints.Min.X = gtx.Constraints.Max.X
+		return u.headerActions(gtx)
+	}
+	if u.shouldShowDesktopWorkingHeader() {
+		return layout.Dimensions{}
+	}
+	return card(gtx, func(gtx layout.Context) layout.Dimensions {
+		return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return u.brandMark(gtx, 196, 56)
+			}),
+			layout.Flexed(1, u.headerActions),
+		)
+	})
+}
+
+func (u *ui) headerActions(gtx layout.Context) layout.Dimensions {
+	if u.shouldShowLifecycleSetup() || u.isVaultLocked() {
+		return layout.Dimensions{}
+	}
+	cluster := u.newHeaderActionCluster(gtx)
+	rowDims := cluster.layout(gtx, u)
+	if u.usesCompactViewport() {
+		u.maybeLogHeaderBounds(newHeaderButtonBounds(image.Pt(u.frameInsetPx, u.frameInsetPx), cluster.Metrics.Bounds()))
+	}
+
+	if u.usesCompactViewport() {
+		cluster.prepareCompactMenus(gtx, u)
+		return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, rowDims.Size.Y)}
+	}
+	return rowDims
+}
+
+type headerActionCluster struct {
+	Metrics  headerlayout.ActionMetrics
+	SyncMenu layout.Widget
+	MainMenu layout.Widget
+}
+
+func (c headerActionCluster) ShowSyncMenu() bool { return c.SyncMenu != nil }
+
+func (c headerActionCluster) ShowMainMenu() bool { return c.MainMenu != nil }
+
+func (u *ui) newHeaderActionCluster(gtx layout.Context) headerActionCluster {
+	cluster := headerActionCluster{
+		SyncMenu: u.syncMenuWidget(),
+		MainMenu: u.mainMenuWidget(),
+	}
+	spacing := gtx.Dp(unit.Dp(8))
+	cluster.Metrics = headerlayout.ActionMetrics{Spacing: spacing, SyncInnerSpacing: gtx.Dp(unit.Dp(3))}
+	if !u.usesCompactViewport() {
+		cluster.Metrics.SyncInnerSpacing = gtx.Dp(unit.Dp(4))
+	}
+	return cluster
+}
+
+func (c *headerActionCluster) layout(gtx layout.Context, u *ui) layout.Dimensions {
+	rowOps := op.Record(gtx.Ops)
+	c.Metrics.RowDims = c.layoutRow(gtx, u)
+	rowCall := rowOps.Stop()
+	c.Metrics.RowOriginX = max(0, gtx.Constraints.Max.X-c.Metrics.RowDims.Size.X)
+	return layout.E.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+		rowCall.Add(gtx.Ops)
+		return c.Metrics.RowDims
+	})
+}
+
+func (c headerActionCluster) activeMenu() layout.Widget {
+	switch {
+	case c.ShowSyncMenu():
+		return c.SyncMenu
+	case c.ShowMainMenu():
+		return c.MainMenu
+	default:
+		return nil
+	}
+}
+
+func (c *headerActionCluster) layoutRow(gtx layout.Context, u *ui) layout.Dimensions {
+	return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			c.Metrics.SyncDims, c.Metrics.SyncPrimaryDims, c.Metrics.SyncToggleDims = u.syncButtonGroupWithMetrics(gtx)
+			return c.Metrics.SyncDims
+		}),
+		layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			btn := material.Button(u.theme, &u.lockVault, "Lock")
+			c.Metrics.LockDims = btn.Layout(gtx)
+			return c.Metrics.LockDims
+		}),
+		layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			c.Metrics.MainDims = u.mainMenuButtonGroup(gtx)
+			return c.Metrics.MainDims
+		}),
+	)
+}
+
+func (c *headerActionCluster) prepareCompactMenus(gtx layout.Context, u *ui) {
+	compactSurface := headerlayout.DropdownSurface{
+		ContainerWidth: gtx.Constraints.Max.X,
+		LeftInset:      u.frameInsetPx,
+		TopInset:       u.frameInsetPx,
+	}
+	if c.ShowSyncMenu() {
+		u.phoneSyncMenuVisible = true
+		u.maybeLogHeaderMenuToggle("sync-visible", true)
+		placement, menuCall := compactSurface.Place(gtx, c.Metrics.SyncAnchor(), c.SyncMenu)
+		u.phoneSyncMenuOrigin = placement.Origin
+		u.phoneSyncMenuSize = placement.Size
+		u.phoneSyncMenuCall = menuCall
+		u.maybeLogHeaderMenuPlacement("sync-phone", compactSurface, placement)
+	}
+	if c.ShowMainMenu() {
+		u.phoneMainMenuVisible = true
+		u.maybeLogHeaderMenuToggle("main-visible", true)
+		placement, menuCall := compactSurface.Place(gtx, c.Metrics.MainAnchor(), c.MainMenu)
+		u.phoneMainMenuOrigin = placement.Origin
+		u.phoneMainMenuSize = placement.Size
+		u.phoneMainMenuCall = menuCall
+		u.maybeLogHeaderMenuPlacement("main-phone", compactSurface, placement)
+	}
+}
+
+func (c headerActionCluster) layoutMenuRow(gtx layout.Context) layout.Dimensions {
+	menu := c.activeMenu()
+	if menu == nil {
+		return layout.Dimensions{}
+	}
+	fullWidthGTX := gtx
+	fullWidthGTX.Constraints.Min = image.Point{}
+	fullWidthGTX.Constraints.Min.X = fullWidthGTX.Constraints.Max.X
+	dims := layout.E.Layout(fullWidthGTX, menu)
+	return layout.Dimensions{Size: image.Pt(fullWidthGTX.Constraints.Max.X, dims.Size.Y)}
+}
+
+type headerButtonBounds struct {
+	SyncPrimary image.Rectangle
+	SyncToggle  image.Rectangle
+	Lock        image.Rectangle
+	MainMenu    image.Rectangle
+}
+
+func newHeaderButtonBounds(origin image.Point, bounds headerlayout.ActionBounds) headerButtonBounds {
+	return headerButtonBounds{
+		SyncPrimary: bounds.SyncPrimary.Add(origin),
+		SyncToggle:  bounds.SyncToggle.Add(origin),
+		Lock:        bounds.Lock.Add(origin),
+		MainMenu:    bounds.MainMenu.Add(origin),
+	}
+}
+
+func (b headerButtonBounds) logLine(mode string) string {
+	return fmt.Sprintf(
+		"keepassgo header-bounds mode=%s sync=%s sync_toggle=%s lock=%s menu=%s",
+		mode,
+		formatHeaderRect(b.SyncPrimary),
+		formatHeaderRect(b.SyncToggle),
+		formatHeaderRect(b.Lock),
+		formatHeaderRect(b.MainMenu),
+	)
+}
+
+func formatHeaderRect(rect image.Rectangle) string {
+	return fmt.Sprintf("%d,%d-%d,%d", rect.Min.X, rect.Min.Y, rect.Max.X, rect.Max.Y)
+}
+
+func (u *ui) topRightActionOrder() []string {
+	if u.isVaultLocked() {
+		return nil
+	}
+	return []string{"Sync", "Lock", "Menu"}
+}
+
+func (u *ui) phoneHeaderMenus(gtx layout.Context) layout.Dimensions {
+	if !u.usesCompactViewport() || (!u.syncMenuVisibleOnPhone() && !u.mainMenuVisibleOnPhone()) {
+		return layout.Dimensions{}
+	}
+
+	cluster := u.newHeaderActionCluster(gtx)
+	if u.syncMenuVisibleOnPhone() {
+		return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+			stack := op.Offset(image.Pt(0, max(0, u.phoneSyncMenuOrigin.Y-u.frameInsetPx))).Push(gtx.Ops)
+			defer stack.Pop()
+			dims := cluster.layoutMenuRow(gtx)
+			return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, max(dims.Size.Y, u.phoneSyncMenuOrigin.Y))}
+		})
+	}
+	if u.mainMenuVisibleOnPhone() {
+		return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+			stack := op.Offset(image.Pt(0, max(0, u.phoneMainMenuOrigin.Y-u.frameInsetPx))).Push(gtx.Ops)
+			defer stack.Pop()
+			dims := cluster.layoutMenuRow(gtx)
+			return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, max(dims.Size.Y, u.phoneMainMenuOrigin.Y))}
+		})
+	}
+	return layout.Dimensions{}
+}
+
+func (u *ui) desktopHeaderMenus(gtx layout.Context) layout.Dimensions {
+	if u.usesCompactViewport() || (!u.syncMenuOpen && !u.mainMenuOpen) {
+		return layout.Dimensions{}
+	}
+	cluster := u.newHeaderActionCluster(gtx)
+	dims := cluster.layoutMenuRow(gtx)
+	if dims.Size.Y == 0 {
+		return dims
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions { return dims }),
+	)
+}
+
+func (u *ui) syncMenuVisibleOnPhone() bool {
+	return u.usesCompactViewport() && u.phoneSyncMenuVisible && u.syncMenuOpen
+}
+
+func (u *ui) mainMenuVisibleOnPhone() bool {
+	return u.usesCompactViewport() && u.phoneMainMenuVisible && u.mainMenuOpen
+}
+
+func (u *ui) syncMenuDropsBelowTrigger() bool { return true }
+
+func (u *ui) syncMenuRightAlignsToTrigger() bool { return true }
+
+func (u *ui) headerMenusUseOverlayModel() bool { return true }
+
+func (u *ui) mainMenuDropsBelowTrigger() bool { return true }
+
+func (u *ui) mainMenuRightAlignsToTrigger() bool { return true }
+
+func (u *ui) lifecycleBranding(gtx layout.Context) layout.Dimensions {
+	if !u.usesCompactViewport() {
+		return layout.Dimensions{}
+	}
+	return layout.Dimensions{}
+}
+
+func (u *ui) brandMark(gtx layout.Context, widthDP, heightDP float32) layout.Dimensions {
+	if u.usesCompactViewport() {
+		return u.brandImage(gtx, u.splashSquare, widthDP, heightDP)
+	}
+	return u.brandImage(gtx, u.logoHorizontal, widthDP, heightDP)
+}
+
+func (u *ui) brandImage(gtx layout.Context, src paint.ImageOp, widthDP, heightDP float32) layout.Dimensions {
+	width := gtx.Dp(unit.Dp(widthDP))
+	height := gtx.Dp(unit.Dp(heightDP))
+	if width > gtx.Constraints.Max.X {
+		width = gtx.Constraints.Max.X
+	}
+	if height > gtx.Constraints.Max.Y && gtx.Constraints.Max.Y > 0 {
+		height = gtx.Constraints.Max.Y
+	}
+	img := widget.Image{
+		Src:      src,
+		Fit:      widget.Contain,
+		Position: layout.W,
+		Scale:    1.0 / gtx.Metric.PxPerDp,
+	}
+	gtx.Constraints.Min = image.Point{}
+	gtx.Constraints.Max = image.Pt(width, height)
+	return img.Layout(gtx)
+}
+
+func (u *ui) mainMenuWidget() layout.Widget {
+	if !u.mainMenuOpen {
+		return nil
+	}
+	return u.mainMenu
+}
+
+func (u *ui) mainMenu(gtx layout.Context) layout.Dimensions {
+	rows := []layout.Widget{
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.showEntries, "Entries")
+		},
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.showRecycle, "Recycle Bin")
+		},
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.showAPITokens, "API Tokens")
+		},
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.showAPIAudit, "API Audit")
+		},
+		func(gtx layout.Context) layout.Dimensions { return tonedButton(gtx, u.theme, &u.showAbout, "About") },
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.openSecuritySettings, "Settings")
+		},
+	}
+	return headerview.MainMenu(gtx, u.theme, rows, compactCard, nil)
+}
+
+func (u *ui) mainMenuButtonGroup(gtx layout.Context) layout.Dimensions {
+	icon := u.menuIcon
+	if icon == nil {
+		icon = u.settingsIcon
+	}
+	return headerview.MainMenuButtonGroup(gtx, u.theme, &u.toggleMainMenu, icon, u.mainMenuOpen, selectedColor, accentColor)
+}
+
+func intrinsicCompactCard(gtx layout.Context, w layout.Widget) layout.Dimensions {
+	return headerlayout.IntrinsicCompactCard(gtx, w, compactCard, nil)
+}
+
+func menuActionWidth(gtx layout.Context, rows []layout.Widget) int {
+	return headerlayout.MenuActionWidth(gtx, rows)
+}
+
+func rightAlignedMenuAction(gtx layout.Context, width int, child layout.Widget) layout.Dimensions {
+	return headerlayout.RightAlignedAction(gtx, width, child)
+}

internal/appui/header/layout/dropdown.go

@@ -0,0 +1,131 @@
+package layout
+
+import (
+	"image"
+
+	"gioui.org/layout"
+	"gioui.org/op"
+	"gioui.org/unit"
+)
+
+func AnchoredMenuX(triggerWidth, menuWidth int) int {
+	return triggerWidth - menuWidth
+}
+
+func AnchoredMenuOriginX(containerWidth, rowOriginX, triggerRightX, menuWidth int) int {
+	x := rowOriginX + triggerRightX - menuWidth
+	if x < 0 {
+		return 0
+	}
+	if x+menuWidth > containerWidth {
+		return max(0, containerWidth-menuWidth)
+	}
+	return x
+}
+
+type DropdownAnchor struct {
+	TriggerRightX  int
+	TriggerBottomY int
+}
+
+func (a DropdownAnchor) Point() image.Point {
+	return image.Pt(a.TriggerRightX, a.TriggerBottomY)
+}
+
+type DropdownSurface struct {
+	ContainerWidth int
+	LeftInset      int
+	TopInset       int
+}
+
+type DropdownPlacement struct {
+	Anchor DropdownAnchor
+	Origin image.Point
+	Size   image.Point
+}
+
+func (s DropdownSurface) MenuConstraints(gtx layout.Context) layout.Context {
+	menuGTX := gtx
+	menuGTX.Constraints.Min = image.Point{}
+	menuGTX.Constraints.Max.X = max(0, s.ContainerWidth)
+	return menuGTX
+}
+
+func (s DropdownSurface) Origin(anchor DropdownAnchor, menuWidth int) image.Point {
+	x := s.LeftInset + AnchoredMenuOriginX(s.ContainerWidth, 0, anchor.TriggerRightX, menuWidth)
+	y := s.TopInset + anchor.TriggerBottomY
+	return image.Pt(x, y)
+}
+
+func (s DropdownSurface) Place(gtx layout.Context, anchor DropdownAnchor, menu layout.Widget) (DropdownPlacement, op.CallOp) {
+	menuGTX := s.MenuConstraints(gtx)
+	menuOps := op.Record(gtx.Ops)
+	menuDims := layout.Inset{Top: unit.Dp(6)}.Layout(menuGTX, menu)
+	menuCall := menuOps.Stop()
+	menuOrigin := s.Origin(anchor, menuDims.Size.X)
+	return DropdownPlacement{
+		Anchor: anchor,
+		Origin: menuOrigin,
+		Size:   menuDims.Size,
+	}, menuCall
+}
+
+func (s DropdownSurface) Draw(gtx layout.Context, anchor DropdownAnchor, menu layout.Widget) layout.Dimensions {
+	placement, menuCall := s.Place(gtx, anchor, menu)
+	stack := op.Offset(placement.Origin).Push(gtx.Ops)
+	menuCall.Add(gtx.Ops)
+	stack.Pop()
+	return layout.Dimensions{Size: gtx.Constraints.Max}
+}
+
+type ActionMetrics struct {
+	RowOriginX       int
+	Spacing          int
+	SyncInnerSpacing int
+	RowDims          layout.Dimensions
+	SyncDims         layout.Dimensions
+	SyncPrimaryDims  layout.Dimensions
+	SyncToggleDims   layout.Dimensions
+	LockDims         layout.Dimensions
+	MainDims         layout.Dimensions
+}
+
+func (m ActionMetrics) SyncAnchor() DropdownAnchor {
+	return DropdownAnchor{
+		TriggerRightX:  m.RowOriginX + m.SyncDims.Size.X,
+		TriggerBottomY: m.RowDims.Size.Y,
+	}
+}
+
+func (m ActionMetrics) MainAnchor() DropdownAnchor {
+	triggerRightX := m.SyncDims.Size.X + m.Spacing + m.LockDims.Size.X + m.Spacing + m.MainDims.Size.X
+	return DropdownAnchor{
+		TriggerRightX:  m.RowOriginX + triggerRightX,
+		TriggerBottomY: m.RowDims.Size.Y,
+	}
+}
+
+type ActionBounds struct {
+	SyncPrimary image.Rectangle
+	SyncToggle  image.Rectangle
+	Lock        image.Rectangle
+	MainMenu    image.Rectangle
+}
+
+func (m ActionMetrics) Bounds() ActionBounds {
+	top := 0
+	syncLeft := m.RowOriginX
+	syncPrimary := image.Rect(syncLeft, top, syncLeft+m.SyncPrimaryDims.Size.X, top+m.SyncPrimaryDims.Size.Y)
+	syncToggleLeft := syncPrimary.Max.X + m.SyncInnerSpacing
+	syncToggle := image.Rect(syncToggleLeft, top, syncToggleLeft+m.SyncToggleDims.Size.X, top+m.SyncToggleDims.Size.Y)
+	lockLeft := syncLeft + m.SyncDims.Size.X + m.Spacing
+	lock := image.Rect(lockLeft, top, lockLeft+m.LockDims.Size.X, top+m.LockDims.Size.Y)
+	mainLeft := lock.Max.X + m.Spacing
+	mainMenu := image.Rect(mainLeft, top, mainLeft+m.MainDims.Size.X, top+m.MainDims.Size.Y)
+	return ActionBounds{
+		SyncPrimary: syncPrimary,
+		SyncToggle:  syncToggle,
+		Lock:        lock,
+		MainMenu:    mainMenu,
+	}
+}

internal/appui/header/layout/menu.go

@@ -0,0 +1,59 @@
+package layout
+
+import (
+	"image"
+
+	"gioui.org/layout"
+	"gioui.org/op"
+	"gioui.org/unit"
+)
+
+func IntrinsicCompactCard(gtx layout.Context, w layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions, logger func(name string, constraints layout.Constraints, dims layout.Dimensions)) layout.Dimensions {
+	measureGTX := gtx
+	measureGTX.Constraints.Min = image.Point{}
+	measureGTX.Constraints.Max.X = gtx.Constraints.Max.X
+	macro := op.Record(gtx.Ops)
+	contentDims := w(measureGTX)
+	_ = macro.Stop()
+	if logger != nil {
+		logger("intrinsic-measure", measureGTX.Constraints, contentDims)
+	}
+	width := contentDims.Size.X + gtx.Dp(unit.Dp(20))
+	maxWidth := gtx.Constraints.Max.X
+	if maxWidth > 0 && width > maxWidth {
+		width = maxWidth
+	}
+	if width > 0 {
+		gtx.Constraints.Min.X = width
+		gtx.Constraints.Max.X = width
+	}
+	dims := card(gtx, w)
+	if logger != nil {
+		logger("intrinsic-card", gtx.Constraints, dims)
+	}
+	return dims
+}
+
+func MenuActionWidth(gtx layout.Context, rows []layout.Widget) int {
+	width := 0
+	for _, row := range rows {
+		measureGTX := gtx
+		measureGTX.Constraints.Min = image.Point{}
+		macro := op.Record(gtx.Ops)
+		dims := row(measureGTX)
+		_ = macro.Stop()
+		if dims.Size.X > width {
+			width = dims.Size.X
+		}
+	}
+	return width
+}
+
+func RightAlignedAction(gtx layout.Context, width int, child layout.Widget) layout.Dimensions {
+	if width <= 0 {
+		return child(gtx)
+	}
+	gtx.Constraints.Min.X = width
+	gtx.Constraints.Max.X = width
+	return layout.E.Layout(gtx, child)
+}

internal/appui/header/menu.go

@@ -0,0 +1,54 @@
+package header
+
+import (
+	"image/color"
+	"image"
+
+	"gioui.org/layout"
+	"gioui.org/unit"
+	"gioui.org/widget"
+	"gioui.org/widget/material"
+	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
+)
+
+func MainMenu(gtx layout.Context, theme *material.Theme, rows []layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions, logger func(name string, constraints layout.Constraints, dims layout.Dimensions)) layout.Dimensions {
+	rowWidth := headerlayout.MenuActionWidth(gtx, rows)
+	if logger != nil {
+		logger("row-width", gtx.Constraints, layout.Dimensions{Size: image.Pt(rowWidth, 0)})
+	}
+	dims := headerlayout.IntrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
+		children := make([]layout.FlexChild, 0, (len(rows)*2)-1)
+		for i, row := range rows {
+			if i > 0 {
+				children = append(children, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+			}
+			current := row
+			children = append(children, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return headerlayout.RightAlignedAction(gtx, rowWidth, current)
+			}))
+		}
+		dims := layout.Flex{Axis: layout.Vertical}.Layout(gtx, children...)
+		if logger != nil {
+			logger("rows", gtx.Constraints, dims)
+		}
+		return dims
+	}, card, logger)
+	if logger != nil {
+		logger("card", gtx.Constraints, dims)
+	}
+	return dims
+}
+
+func MainMenuButtonGroup(gtx layout.Context, theme *material.Theme, click *widget.Clickable, icon *widget.Icon, open bool, selectedColor, accentColor color.NRGBA) layout.Dimensions {
+	btn := material.IconButton(theme, click, icon, "Menu")
+	if open {
+		btn.Background = accentColor
+		btn.Color = color.NRGBA{R: 255, G: 252, B: 247, A: 255}
+	} else {
+		btn.Background = selectedColor
+		btn.Color = accentColor
+	}
+	btn.Size = unit.Dp(18)
+	btn.Inset = layout.UniformInset(unit.Dp(8))
+	return btn.Layout(gtx)
+}

internal/appui/header_sync_menu.go

@@ -0,0 +1,362 @@
+package appui
+
+import (
+	"image"
+	"image/color"
+	"runtime"
+	"strings"
+
+	"gioui.org/layout"
+	"gioui.org/op"
+	"gioui.org/unit"
+	"gioui.org/widget"
+	"gioui.org/widget/material"
+	"git.julianfamily.org/keepassgo/internal/appstate"
+	syncmodel "git.julianfamily.org/keepassgo/internal/appui/sync"
+	"git.julianfamily.org/keepassgo/internal/vault"
+)
+
+func (u *ui) syncButtonGroupWithMetrics(gtx layout.Context) (layout.Dimensions, layout.Dimensions, layout.Dimensions) {
+	spacing := unit.Dp(4)
+	if u.usesCompactViewport() {
+		spacing = unit.Dp(3)
+	}
+	var primaryDims layout.Dimensions
+	var toggleDims layout.Dimensions
+	groupDims := layout.Flex{Alignment: layout.Middle}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			primaryDims = syncPrimaryButton(gtx, u.theme, &u.synchronizeVault, "Sync", u.usesCompactViewport())
+			return primaryDims
+		}),
+		layout.Rigid(layout.Spacer{Width: spacing}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			toggleDims = u.syncMenuToggle(gtx)
+			return toggleDims
+		}),
+	)
+	return groupDims, primaryDims, toggleDims
+}
+
+func (u *ui) syncMenuToggle(gtx layout.Context) layout.Dimensions {
+	btn := material.IconButton(u.theme, &u.toggleSyncMenu, u.chevronDownIcon, "More synchronize actions")
+	if u.syncMenuOpen {
+		btn.Background = accentColor
+		btn.Color = color.NRGBA{R: 255, G: 252, B: 247, A: 255}
+	} else {
+		btn.Background = color.NRGBA{R: 231, G: 236, B: 232, A: 255}
+		btn.Color = accentColor
+	}
+	btn.Size = unit.Dp(18)
+	btn.Inset = layout.UniformInset(unit.Dp(8))
+	if u.usesCompactViewport() {
+		btn.Size = unit.Dp(16)
+		btn.Inset = layout.UniformInset(unit.Dp(7))
+	}
+	return btn.Layout(gtx)
+}
+
+func (u *ui) syncMenuWidget() layout.Widget {
+	if !u.syncMenuOpen {
+		return nil
+	}
+	return u.syncMenu
+}
+
+func (u *ui) syncMenu(gtx layout.Context) layout.Dimensions {
+	model := u.buildSyncMenuModel()
+	profiles := u.availableRemoteProfiles()
+	credentials := u.availableRemoteCredentialEntries()
+	if len(u.vaultRemoteProfileClicks) < len(profiles) {
+		u.vaultRemoteProfileClicks = make([]widget.Clickable, len(profiles))
+	}
+	if len(u.vaultRemoteCredentialClicks) < len(credentials) {
+		u.vaultRemoteCredentialClicks = make([]widget.Clickable, len(credentials))
+	}
+	actionRows := u.syncMenuActionRows(model)
+	actionWidth := menuActionWidth(gtx, actionRows)
+	menu := func(gtx layout.Context) layout.Dimensions {
+		return intrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
+			return layout.Flex{Axis: layout.Vertical}.Layout(gtx, u.syncMenuRows(model, profiles, credentials, actionWidth)...)
+		})
+	}
+	reserveWidth := u.syncMenuTrailingReserveWidth(gtx)
+	if reserveWidth <= 0 {
+		return menu(gtx)
+	}
+	return layout.Flex{}.Layout(gtx,
+		layout.Rigid(menu),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return layout.Dimensions{Size: image.Pt(reserveWidth, 0)}
+		}),
+	)
+}
+
+func (u *ui) syncMenuTrailingReserveWidth(gtx layout.Context) int {
+	spacing := gtx.Dp(unit.Dp(8))
+	if u.usesCompactViewport() {
+		spacing = gtx.Dp(unit.Dp(8))
+	}
+
+	measureGTX := gtx
+	measureGTX.Constraints.Min = image.Point{}
+
+	lockOps := op.Record(gtx.Ops)
+	lockDims := func(gtx layout.Context) layout.Dimensions {
+		btn := material.Button(u.theme, &u.lockVault, "Lock")
+		return btn.Layout(gtx)
+	}(measureGTX)
+	_ = lockOps.Stop()
+
+	menuOps := op.Record(gtx.Ops)
+	menuDims := u.mainMenuButtonGroup(measureGTX)
+	_ = menuOps.Stop()
+
+	return spacing + lockDims.Size.X + spacing + menuDims.Size.X
+}
+
+func (u *ui) syncMenuActionRows(model syncmodel.MenuModel) []layout.Widget {
+	rows := []layout.Widget{
+		func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.openAdvancedSync, "Open Advanced Sync")
+		},
+	}
+	if model.ShowShare {
+		rows = append(rows, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.shareCurrentVault, "Share Vault")
+		})
+	}
+	if model.ShowRemoteSyncSetupShortcut() {
+		rows = append(rows, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.useSavedAdvancedSyncRemote, model.RemoteSyncSetupShortcutLabel())
+		})
+	}
+	if model.ShowDirectRemoteSyncShortcut() {
+		rows = append(rows, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.openSelectedVaultRemote, model.DirectRemoteSyncShortcutLabel())
+		})
+	}
+	if model.ShowRemoteSyncSettingsShortcut() {
+		rows = append(rows, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.useSavedAdvancedSyncRemote, model.RemoteSyncSettingsShortcutLabel())
+		})
+	}
+	if model.ShowRemoveRemoteSyncShortcut() {
+		rows = append(rows, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.removeSelectedRemoteBinding, model.RemoveRemoteSyncShortcutLabel())
+		})
+	}
+	return rows
+}
+
+func (u *ui) syncMenuRows(model syncmodel.MenuModel, profiles []vault.RemoteProfile, credentials []vault.Entry, actionWidth int) []layout.FlexChild {
+	rows := u.syncMenuPrimaryRows(model, actionWidth)
+	rows = append(rows, u.syncMenuSavedBindingRows(model, profiles, credentials)...)
+	if model.ShowSaveCurrentBinding {
+		rows = append(rows, u.syncMenuSaveBindingRows(model)...)
+	}
+	return rows
+}
+
+func (u *ui) syncMenuPrimaryRows(model syncmodel.MenuModel, actionWidth int) []layout.FlexChild {
+	rows := []layout.FlexChild{}
+	if model.ShowShare {
+		rows = append(rows, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+					return rightAlignedMenuAction(gtx, actionWidth, func(gtx layout.Context) layout.Dimensions {
+						return tonedButton(gtx, u.theme, &u.shareCurrentVault, "Share Vault")
+					})
+				}),
+				layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+			)
+		}))
+	}
+	rows = append(rows, u.syncMenuActionRow(actionWidth, &u.openAdvancedSync, "Open Advanced Sync"))
+	if model.ShowRemoteSyncSetupShortcut() {
+		rows = append(rows, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+		rows = append(rows, u.syncMenuActionRow(actionWidth, &u.useSavedAdvancedSyncRemote, model.RemoteSyncSetupShortcutLabel()))
+	}
+	if model.ShowDirectRemoteSyncShortcut() {
+		rows = append(rows, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+		rows = append(rows, u.syncMenuActionRow(actionWidth, &u.openSelectedVaultRemote, model.DirectRemoteSyncShortcutLabel()))
+	}
+	if model.ShowRemoteSyncSettingsShortcut() {
+		rows = append(rows, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+		rows = append(rows, u.syncMenuActionRow(actionWidth, &u.useSavedAdvancedSyncRemote, model.RemoteSyncSettingsShortcutLabel()))
+	}
+	if model.ShowRemoveRemoteSyncShortcut() {
+		rows = append(rows, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+		rows = append(rows, u.syncMenuActionRow(actionWidth, &u.removeSelectedRemoteBinding, model.RemoveRemoteSyncShortcutLabel()))
+	}
+	return rows
+}
+
+func (u *ui) syncMenuActionRow(actionWidth int, click *widget.Clickable, label string) layout.FlexChild {
+	return layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+		return rightAlignedMenuAction(gtx, actionWidth, func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, click, label)
+		})
+	})
+}
+
+func (u *ui) syncMenuSavedBindingRows(model syncmodel.MenuModel, profiles []vault.RemoteProfile, credentials []vault.Entry) []layout.FlexChild {
+	if !u.hasOpenVault() || len(profiles) == 0 || len(credentials) == 0 {
+		return nil
+	}
+	rows := []layout.FlexChild{
+		layout.Rigid(layout.Spacer{Height: unit.Dp(10)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			lbl := material.Label(u.theme, unit.Sp(11), model.SavedBindingHeading())
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+	}
+	if !model.ShowSelectors {
+		rows = append(rows, layout.Rigid(u.syncMenuSavedBindingSummary(model)))
+	} else {
+		rows = append(rows, u.syncMenuSelectorRows(model, profiles, credentials)...)
+	}
+	if _, ok := u.selectedVaultRemoteProfile(); ok {
+		if _, ok := u.selectedVaultRemoteCredentialEntry(); ok {
+			rows = append(rows,
+				layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+					return tonedButton(gtx, u.theme, &u.openSelectedVaultRemote, u.openSelectedVaultRemoteButtonLabel())
+				}),
+			)
+		}
+	}
+	return rows
+}
+
+func (u *ui) syncMenuSavedBindingSummary(model syncmodel.MenuModel) layout.Widget {
+	return func(gtx layout.Context) layout.Dimensions {
+		summary := model.SavedBindingSummary
+		if !summary.OK {
+			return layout.Dimensions{}
+		}
+		return layout.Background{}.Layout(gtx, fill(color.NRGBA{R: 242, G: 245, B: 240, A: 255}), func(gtx layout.Context) layout.Dimensions {
+			return layout.UniformInset(unit.Dp(10)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+				return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						lbl := material.Label(u.theme, unit.Sp(13), summary.ProfileLabel)
+						lbl.Color = accentColor
+						return lbl.Layout(gtx)
+					}),
+					layout.Rigid(layout.Spacer{Height: unit.Dp(2)}.Layout),
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						lbl := material.Label(u.theme, unit.Sp(12), "Credential: "+summary.CredentialLabel)
+						lbl.Color = mutedColor
+						return lbl.Layout(gtx)
+					}),
+					layout.Rigid(layout.Spacer{Height: unit.Dp(2)}.Layout),
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						lbl := material.Label(u.theme, unit.Sp(12), summary.SyncLabel)
+						lbl.Color = mutedColor
+						return lbl.Layout(gtx)
+					}),
+				)
+			})
+		})
+	}
+}
+
+func (u *ui) syncMenuSaveBindingRows(model syncmodel.MenuModel) []layout.FlexChild {
+	return []layout.FlexChild{
+		layout.Rigid(layout.Spacer{Height: unit.Dp(10)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			lbl := material.Label(u.theme, unit.Sp(11), model.SaveCurrentRemoteBindingHeading())
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.saveCurrentRemoteBinding, model.SaveCurrentRemoteBindingButtonLabel())
+		}),
+	}
+}
+
+func (u *ui) syncMenuSelectorRows(_ syncmodel.MenuModel, profiles []vault.RemoteProfile, credentials []vault.Entry) []layout.FlexChild {
+	rows := make([]layout.FlexChild, 0, len(profiles)+len(credentials)+4)
+	for i, profile := range profiles {
+		i := i
+		profile := profile
+		rows = append(rows, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			selected := u.selectedVaultRemoteProfileID == profile.ID
+			return layout.Inset{Bottom: unit.Dp(4)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+				return recentSelectionCard(gtx, selected, func(gtx layout.Context) layout.Dimensions {
+					return u.vaultRemoteProfileClicks[i].Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+						lbl := material.Label(u.theme, unit.Sp(13), profile.Name)
+						lbl.Color = accentColor
+						return lbl.Layout(gtx)
+					})
+				})
+			})
+		}))
+	}
+	rows = append(rows, layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout))
+	for i, entry := range credentials {
+		i := i
+		entry := entry
+		rows = append(rows, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			selected := u.selectedVaultRemoteCredentialEntryID == entry.ID
+			label := entry.Title
+			if entry.Username != "" {
+				label += " · " + entry.Username
+			}
+			return layout.Inset{Bottom: unit.Dp(4)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+				return recentSelectionCard(gtx, selected, func(gtx layout.Context) layout.Dimensions {
+					return u.vaultRemoteCredentialClicks[i].Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+						lbl := material.Label(u.theme, unit.Sp(13), label)
+						lbl.Color = accentColor
+						return lbl.Layout(gtx)
+					})
+				})
+			})
+		}))
+	}
+	return rows
+}
+
+func (u *ui) buildSyncMenuModel() syncmodel.MenuModel {
+	model := syncmodel.MenuModel{
+		HasOpenVault:          u.hasOpenVault(),
+		ShowSelectors:         u.shouldShowSavedRemoteBindingSelectors(),
+		ShowShare:             supportsVaultShare(runtime.GOOS) && u.vaultSharer != nil && strings.TrimSpace(u.currentShareableVaultPath()) != "",
+		RemoteBaseURL:         strings.TrimSpace(u.remoteBaseURL.Text()),
+		RemotePath:            strings.TrimSpace(u.remotePath.Text()),
+		RemoteUsername:        strings.TrimSpace(u.remoteUsername.Text()),
+		RemotePassword:        u.remotePassword.Text(),
+		SelectedVaultSyncMode: normalizeUISyncMode(u.selectedVaultRemoteSyncMode),
+	}
+	_, model.HasSelectedBinding = u.selectedVaultRemoteBinding()
+	model.SavedBindingSummary = u.computeSavedRemoteBindingSummary()
+	model.ShowSaveCurrentBinding = model.HasOpenVault && model.RemoteBaseURL != "" && model.RemotePath != "" && model.RemoteUsername != "" && model.RemotePassword != ""
+	return model
+}
+
+func (u *ui) computeSavedRemoteBindingSummary() syncmodel.MenuBindingSummary {
+	profile, ok := u.selectedVaultRemoteProfile()
+	if !ok {
+		return syncmodel.MenuBindingSummary{}
+	}
+	entry, ok := u.selectedVaultRemoteCredentialEntry()
+	if !ok {
+		return syncmodel.MenuBindingSummary{}
+	}
+	credentialLabel := entry.Title
+	if strings.TrimSpace(entry.Username) != "" {
+		credentialLabel += " · " + strings.TrimSpace(entry.Username)
+	}
+	syncLabel := "Sync manually when you choose Use Remote Sync."
+	if normalizeUISyncMode(u.selectedVaultRemoteSyncMode) == appstate.SyncModeAutomaticOnOpenSave {
+		syncLabel = "Syncs automatically on open and save."
+	}
+	return syncmodel.MenuBindingSummary{
+		ProfileLabel:    profile.Name,
+		CredentialLabel: credentialLabel,
+		SyncLabel:       syncLabel,
+		OK:              true,
+	}
+}

internal/appui/input.go

@@ -1,32 +1,46 @@
-package main
+package appui
 
 import (
 	"fmt"
 	"strconv"
 	"strings"
 
+	"gioui.org/io/event"
 	"gioui.org/io/key"
-	"git.julianfamily.org/keepassgo/appstate"
+	"gioui.org/layout"
+	"git.julianfamily.org/keepassgo/internal/appstate"
+	editormodel "git.julianfamily.org/keepassgo/internal/appui/editor"
+	"git.julianfamily.org/keepassgo/internal/clipboard"
 )
 
 type focusID string
 
-type detailField string
+type detailField = editormodel.Field
 
 const (
 	focusSearch focusID = "search"
 
-	detailFieldID              detailField = "id"
-	detailFieldTitle           detailField = "title"
-	detailFieldUsername        detailField = "username"
-	detailFieldPassword        detailField = "password"
-	detailFieldURL             detailField = "url"
-	detailFieldPath            detailField = "path"
-	detailFieldTags            detailField = "tags"
-	detailFieldPasswordProfile detailField = "password-profile"
-	detailFieldNotes           detailField = "notes"
-	detailFieldFields          detailField = "fields"
-	detailFieldHistoryIndex    detailField = "history-index"
+	detailFieldID              = editormodel.FieldID
+	detailFieldTitle           = editormodel.FieldTitle
+	detailFieldUsername        = editormodel.FieldUsername
+	detailFieldPassword        = editormodel.FieldPassword
+	detailFieldURL             = editormodel.FieldURL
+	detailFieldPath            = editormodel.FieldPath
+	detailFieldTags            = editormodel.FieldTags
+	detailFieldPasswordProfile = editormodel.FieldPasswordProfile
+	detailFieldNotes           = editormodel.FieldNotes
+	detailFieldFields          = editormodel.FieldFields
+	detailFieldHistoryIndex    = editormodel.FieldHistoryIndex
+)
+
+const (
+	shortcutSearch       = "search"
+	shortcutSave         = "save"
+	shortcutLock         = "lock"
+	shortcutNewEntry     = "new-entry"
+	shortcutCopyUser     = "copy-user"
+	shortcutCopyPassword = "copy-password"
+	shortcutCopyURL      = "copy-url"
 )
 
 func breadcrumbFocusID(index int) focusID {
@@ -41,6 +55,68 @@ func detailFocusID(field detailField) focusID {
 	return focusID("detail:" + string(field))
 }
 
+func (u *ui) processShortcuts(gtx layout.Context) {
+	event.Op(gtx.Ops, u)
+	for {
+		ev, ok := gtx.Event(
+			key.Filter{Name: "F", Required: key.ModShortcut},
+			key.Filter{Name: "S", Required: key.ModShortcut},
+			key.Filter{Name: "L", Required: key.ModShortcut},
+			key.Filter{Name: "N", Required: key.ModShortcut},
+			key.Filter{Name: "U", Required: key.ModShortcut},
+			key.Filter{Name: "P", Required: key.ModShortcut},
+			key.Filter{Name: "O", Required: key.ModShortcut},
+			key.Filter{Name: key.NameTab, Optional: key.ModShift},
+			key.Filter{Name: key.NameLeftArrow},
+			key.Filter{Name: key.NameRightArrow},
+			key.Filter{Name: key.NameUpArrow},
+			key.Filter{Name: key.NameDownArrow},
+			key.Filter{Name: key.NameReturn},
+			key.Filter{Name: key.NameBack},
+			key.Filter{Name: key.NameEscape},
+		)
+		if !ok {
+			break
+		}
+
+		ke, ok := ev.(key.Event)
+		if !ok || ke.State != key.Press {
+			continue
+		}
+
+		u.handleKeyPress(ke.Name, ke.Modifiers)
+		if ke.Name == key.NameBack || ke.Name == key.NameEscape {
+			_ = u.handlePhoneBack()
+		}
+	}
+}
+
+func (u *ui) performShortcut(name string) error {
+	switch name {
+	case shortcutSearch:
+		u.keyboardFocus = focusSearch
+		return nil
+	case shortcutSave:
+		return u.saveAction()
+	case shortcutLock:
+		return u.lockAction()
+	case shortcutNewEntry:
+		u.state.BeginNewEntry()
+		u.loadSelectedEntryIntoEditor()
+		u.entryPath.SetText(strings.Join(u.state.CurrentPath, " / "))
+		u.keyboardFocus = detailFocusID(detailFieldTitle)
+		return nil
+	case shortcutCopyUser:
+		return u.copySelectedFieldAction(clipboard.TargetUsername)
+	case shortcutCopyPassword:
+		return u.copySelectedFieldAction(clipboard.TargetPassword)
+	case shortcutCopyURL:
+		return u.copySelectedFieldAction(clipboard.TargetURL)
+	default:
+		return nil
+	}
+}
+
 func (u *ui) handleKeyPress(name key.Name, modifiers key.Modifiers) bool {
 	if u.handleShortcutKey(name, modifiers) {
 		return true
@@ -336,19 +412,7 @@ func (u *ui) focusedDetailIndex() int {
 }
 
 func detailFocusOrder() []detailField {
-	return []detailField{
-		detailFieldID,
-		detailFieldTitle,
-		detailFieldUsername,
-		detailFieldPassword,
-		detailFieldURL,
-		detailFieldPath,
-		detailFieldTags,
-		detailFieldPasswordProfile,
-		detailFieldNotes,
-		detailFieldFields,
-		detailFieldHistoryIndex,
-	}
+	return editormodel.FocusOrder()
 }
 
 func canonicalFocusID(id focusID) focusID {

internal/appui/lifecycle/model.go

@@ -0,0 +1,9 @@
+package lifecycle
+
+type OpenIntent string
+
+const (
+	OpenIntentNone               OpenIntent = ""
+	OpenIntentRemoteSyncSetup    OpenIntent = "remote_sync_setup"
+	OpenIntentRemoteSyncSettings OpenIntent = "remote_sync_settings"
+)

internal/appui/lifecycle_actions.go

@@ -0,0 +1,778 @@
+package appui
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"gioui.org/layout"
+	"gioui.org/x/explorer"
+	"git.julianfamily.org/keepassgo/internal/appstate"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
+)
+
+func (u *ui) createVaultAction() error {
+	key, err := u.currentMasterKey()
+	defer u.clearMasterPassword()
+	if err != nil {
+		return err
+	}
+	if err := u.state.ConfigureSecurity(vault.SecuritySettings{
+		Cipher: strings.TrimSpace(u.securityCipher.Text()),
+		KDF:    strings.TrimSpace(u.securityKDF.Text()),
+	}); err != nil {
+		return err
+	}
+	if err := u.state.CreateVault(key); err != nil {
+		return err
+	}
+	if u.lifecycleMode == "local" {
+		u.selectedVaultRemoteProfileID = ""
+		u.selectedVaultRemoteCredentialEntryID = ""
+		u.selectedVaultRemoteSyncMode = appstate.SyncModeManual
+		u.remoteBaseURL.SetText("")
+		u.remotePath.SetText("")
+		u.remoteUsername.SetText("")
+		u.remotePassword.SetText("")
+		if err := u.state.SaveAs(u.saveAsTargetPath()); err != nil {
+			return err
+		}
+		u.vaultPath.SetText(u.saveAsTargetPath())
+		u.noteRecentVault(u.saveAsTargetPath())
+	}
+	u.resetPasswordPeek()
+	u.currentPath = append([]string(nil), u.state.CurrentPath...)
+	u.loadSecuritySettingsFromSession()
+	u.editingEntry = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) openVaultAction() error {
+	key, err := u.currentMasterKey()
+	defer u.clearMasterPassword()
+	if err != nil {
+		return err
+	}
+	path := strings.TrimSpace(u.vaultPath.Text())
+	if path == "" {
+		return errors.New(errVaultPathRequired)
+	}
+	if err := u.state.OpenVault(path, key); err != nil {
+		return err
+	}
+	u.noteRecentVault(path)
+	u.resetPasswordPeek()
+	u.currentPath = append([]string(nil), u.state.CurrentPath...)
+	u.restoreRecentVaultGroup(path)
+	u.syncSavedRemoteBindingSelection()
+	if err := u.synchronizeSelectedRemoteBindingOnOpen(); err != nil {
+		u.showStatusMessage("Remote sync on open failed: " + err.Error())
+	}
+	u.loadSecuritySettingsFromSession()
+	u.editingEntry = false
+	u.filter()
+	u.applyPendingLifecycleOpenIntent()
+	return nil
+}
+
+func (u *ui) startOpenVaultAction() {
+	manager, ok := u.state.Session.(*session.Manager)
+	if !ok {
+		u.runAction("open vault", u.openVaultAction)
+		return
+	}
+	key, err := u.currentMasterKey()
+	u.clearMasterPassword()
+	if err != nil {
+		u.state.ErrorMessage = u.describeActionError("open vault", err)
+		u.requestMasterPassFocus = true
+		return
+	}
+	path := strings.TrimSpace(u.vaultPath.Text())
+	if path == "" {
+		u.state.ErrorMessage = u.describeActionError("open vault", errors.New(errVaultPathRequired))
+		u.requestMasterPassFocus = true
+		return
+	}
+	u.lastLifecycleAction = "open vault"
+	u.runBackgroundAction("open vault", func() (func() error, error) {
+		prepared, err := session.PrepareLocalOpen(path, key)
+		if err != nil {
+			return nil, err
+		}
+		return func() error {
+			manager.ApplyPreparedLocalOpen(prepared)
+			u.noteRecentVault(path)
+			u.resetPasswordPeek()
+			u.currentPath = append([]string(nil), u.state.CurrentPath...)
+			u.restoreRecentVaultGroup(path)
+			u.syncSavedRemoteBindingSelection()
+			if err := u.synchronizeSelectedRemoteBindingOnOpen(); err != nil {
+				u.showStatusMessage("Remote sync on open failed: " + err.Error())
+			}
+			u.loadSecuritySettingsFromSession()
+			u.editingEntry = false
+			u.filter()
+			u.applyPendingLifecycleOpenIntent()
+			return nil
+		}, nil
+	})
+}
+
+func (u *ui) shouldShowLifecycleRemoteSyncAction() bool {
+	return strings.TrimSpace(u.vaultPath.Text()) != ""
+}
+
+func (u *ui) lifecycleRemoteSyncActionLabel() string {
+	path := strings.TrimSpace(u.vaultPath.Text())
+	if path == "" {
+		return "Open Vault And Set Up Remote Sync"
+	}
+	if hasBoundRecentRemote(u.recentRemotes, path) {
+		return "Open Vault And Open Remote Sync Settings"
+	}
+	return "Open Vault And Set Up Remote Sync"
+}
+
+func (u *ui) beginLifecycleRemoteSyncOpen() {
+	path := strings.TrimSpace(u.vaultPath.Text())
+	switch {
+	case path == "":
+		u.pendingLifecycleOpenIntent = lifecycleOpenIntentNone
+	case hasBoundRecentRemote(u.recentRemotes, path):
+		u.pendingLifecycleOpenIntent = lifecycleOpenIntentRemoteSyncSettings
+	default:
+		u.pendingLifecycleOpenIntent = lifecycleOpenIntentRemoteSyncSetup
+	}
+	u.startOpenVaultAction()
+}
+
+func (u *ui) applyPendingLifecycleOpenIntent() {
+	intent := u.pendingLifecycleOpenIntent
+	u.pendingLifecycleOpenIntent = lifecycleOpenIntentNone
+	switch intent {
+	case lifecycleOpenIntentRemoteSyncSetup, lifecycleOpenIntentRemoteSyncSettings:
+		u.openRemoteSyncSetupDialog()
+	}
+}
+
+func (u *ui) saveAction() error {
+	if err := u.state.Save(); err != nil {
+		return err
+	}
+	if err := u.synchronizeSelectedRemoteBindingOnSave(); err != nil {
+		return err
+	}
+	u.filter()
+	return nil
+}
+
+func (u *ui) saveAsAction() error {
+	path := u.saveAsTargetPath()
+	if err := u.state.SaveAs(path); err != nil {
+		return err
+	}
+	u.vaultPath.SetText(path)
+	u.noteRecentVault(path)
+	u.filter()
+	return nil
+}
+
+func (u *ui) openRemoteAction() error {
+	key, err := u.currentMasterKey()
+	defer u.clearMasterPassword()
+	if err != nil {
+		return err
+	}
+	if binding, resolved, ok, err := u.bootstrapSelectedVaultRemoteBinding(key); err != nil {
+		return err
+	} else if ok {
+		if err := u.state.OpenBoundRemoteVault(binding, key); err != nil {
+			return err
+		}
+		u.remoteBaseURL.SetText(resolved.Profile.BaseURL)
+		u.remotePath.SetText(resolved.Profile.Path)
+		u.noteRecentRemote(resolved.Profile.BaseURL, resolved.Profile.Path)
+		u.resetPasswordPeek()
+		u.restoreRecentRemoteGroup(resolved.Profile.BaseURL, resolved.Profile.Path)
+		u.loadSecuritySettingsFromSession()
+		u.editingEntry = false
+		u.filter()
+		return nil
+	}
+	client := webdav.Client{
+		BaseURL:  strings.TrimSpace(u.remoteBaseURL.Text()),
+		Username: strings.TrimSpace(u.remoteUsername.Text()),
+		Password: u.remotePassword.Text(),
+	}
+	if err := u.state.OpenRemoteVault(client, strings.TrimSpace(u.remotePath.Text()), key); err != nil {
+		return err
+	}
+	if err := u.materializeCurrentRemoteCache(); err != nil {
+		return err
+	}
+	u.noteRecentRemote(
+		strings.TrimSpace(u.remoteBaseURL.Text()),
+		strings.TrimSpace(u.remotePath.Text()),
+	)
+	u.resetPasswordPeek()
+	u.restoreRecentRemoteGroup(strings.TrimSpace(u.remoteBaseURL.Text()), strings.TrimSpace(u.remotePath.Text()))
+	u.loadSecuritySettingsFromSession()
+	u.editingEntry = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) startOpenRemoteAction() {
+	manager, ok := u.state.Session.(*session.Manager)
+	if !ok {
+		u.runAction("open remote vault", u.openRemoteAction)
+		return
+	}
+	key, err := u.currentMasterKey()
+	u.clearMasterPassword()
+	if err != nil {
+		u.state.ErrorMessage = u.describeActionError("open remote vault", err)
+		u.requestMasterPassFocus = true
+		return
+	}
+	client := webdav.Client{
+		BaseURL:  strings.TrimSpace(u.remoteBaseURL.Text()),
+		Username: strings.TrimSpace(u.remoteUsername.Text()),
+		Password: u.remotePassword.Text(),
+	}
+	remotePath := strings.TrimSpace(u.remotePath.Text())
+	u.lastLifecycleAction = "open remote vault"
+	u.runBackgroundAction("open remote vault", func() (func() error, error) {
+		binding, bindingOK := u.selectedVaultRemoteBinding()
+		if bindingOK && !u.hasOpenVault() && strings.TrimSpace(binding.LocalVaultPath) != "" {
+			preparedLocal, err := session.PrepareLocalOpen(binding.LocalVaultPath, key)
+			if err != nil {
+				return nil, err
+			}
+			resolved, err := binding.Resolve(preparedLocal.Model)
+			if err != nil {
+				return nil, err
+			}
+			preparedRemote, err := session.PrepareRemoteOpen(webdav.Client{
+				BaseURL:  resolved.Profile.BaseURL,
+				Username: resolved.Credentials.Username,
+				Password: resolved.Credentials.Password,
+			}, resolved.Profile.Path, key)
+			if err != nil {
+				return nil, err
+			}
+			return func() error {
+				manager.ApplyPreparedLocalOpen(preparedLocal)
+				u.vaultPath.SetText(binding.LocalVaultPath)
+				u.noteRecentVault(binding.LocalVaultPath)
+				u.restoreRecentVaultGroup(binding.LocalVaultPath)
+				manager.ApplyPreparedRemoteOpen(preparedRemote)
+				u.remoteBaseURL.SetText(resolved.Profile.BaseURL)
+				u.remotePath.SetText(resolved.Profile.Path)
+				u.noteRecentRemote(resolved.Profile.BaseURL, resolved.Profile.Path)
+				u.resetPasswordPeek()
+				u.restoreRecentRemoteGroup(resolved.Profile.BaseURL, resolved.Profile.Path)
+				u.loadSecuritySettingsFromSession()
+				u.editingEntry = false
+				u.filter()
+				return nil
+			}, nil
+		}
+		if u.hasOpenVault() {
+			if _, resolved, ok, err := u.resolvedSelectedVaultRemoteBinding(); err != nil {
+				return nil, err
+			} else if ok {
+				client = webdav.Client{
+					BaseURL:  resolved.Profile.BaseURL,
+					Username: resolved.Credentials.Username,
+					Password: resolved.Credentials.Password,
+				}
+				remotePath = resolved.Profile.Path
+				u.remoteBaseURL.SetText(resolved.Profile.BaseURL)
+				u.remotePath.SetText(resolved.Profile.Path)
+			}
+		}
+		prepared, err := session.PrepareRemoteOpen(client, remotePath, key)
+		if err != nil {
+			return nil, err
+		}
+		return func() error {
+			manager.ApplyPreparedRemoteOpen(prepared)
+			if err := u.materializeCurrentRemoteCache(); err != nil {
+				return err
+			}
+			u.noteRecentRemote(
+				strings.TrimSpace(u.remoteBaseURL.Text()),
+				remotePath,
+			)
+			u.resetPasswordPeek()
+			u.restoreRecentRemoteGroup(strings.TrimSpace(u.remoteBaseURL.Text()), remotePath)
+			u.loadSecuritySettingsFromSession()
+			u.editingEntry = false
+			u.filter()
+			return nil
+		}, nil
+	})
+}
+
+func (u *ui) lockAction() error {
+	u.clearMasterPassword()
+	if err := u.state.Lock(); err != nil {
+		return err
+	}
+	u.requestMasterPassFocus = true
+	u.currentPath = append([]string(nil), u.state.CurrentPath...)
+	u.resetPasswordPeek()
+	u.editingEntry = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) unlockAction() error {
+	key, err := u.currentMasterKey()
+	defer u.clearMasterPassword()
+	if err != nil {
+		return err
+	}
+	if err := u.state.Unlock(key); err != nil {
+		return err
+	}
+	u.resetPasswordPeek()
+	u.currentPath = append([]string(nil), u.state.CurrentPath...)
+	u.loadSecuritySettingsFromSession()
+	u.editingEntry = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) startUnlockAction() {
+	manager, ok := u.state.Session.(*session.Manager)
+	if !ok {
+		u.runAction("unlock vault", u.unlockAction)
+		return
+	}
+	key, err := u.currentMasterKey()
+	u.clearMasterPassword()
+	if err != nil {
+		u.state.ErrorMessage = u.describeActionError("unlock vault", err)
+		u.requestMasterPassFocus = true
+		return
+	}
+	encoded := append([]byte(nil), manager.EncodedBytes()...)
+	u.runBackgroundAction("unlock vault", func() (func() error, error) {
+		prepared, err := session.PrepareUnlock(encoded, key)
+		if err != nil {
+			return nil, err
+		}
+		return func() error {
+			manager.ApplyPreparedUnlock(prepared)
+			u.resetPasswordPeek()
+			u.currentPath = append([]string(nil), u.state.CurrentPath...)
+			u.loadSecuritySettingsFromSession()
+			u.editingEntry = false
+			u.filter()
+			return nil
+		}, nil
+	})
+}
+
+func (u *ui) changeMasterKeyAction() error {
+	key, err := u.currentMasterKey()
+	defer u.clearMasterPassword()
+	if err != nil {
+		return err
+	}
+	return u.state.ChangeMasterKey(key)
+}
+
+func (u *ui) loadSecuritySettingsFromSession() {
+	settings, err := u.state.SecuritySettings()
+	if err != nil {
+		return
+	}
+	u.securityCipher.SetText(settings.Cipher)
+	u.securityKDF.SetText(settings.KDF)
+}
+
+func (u *ui) clearMasterPassword() {
+	u.masterPassword.SetText("")
+}
+
+func (u *ui) synchronizeAction() error {
+	if err := u.state.Synchronize(); err != nil {
+		return err
+	}
+	u.syncMenuOpen = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) openAdvancedSyncDialog() {
+	u.syncDialogOpen = true
+	u.syncMenuOpen = false
+	u.showSyncPassword = false
+	u.syncDialogList.Position = layout.Position{}
+	u.syncDialogPurpose = syncDialogPurposeAdvanced
+	u.syncSourceMode = u.syncDefaultSourceMode
+	u.syncDirection = u.syncDefaultDirection
+	if strings.TrimSpace(u.syncLocalPath.Text()) == "" {
+		u.syncLocalPath.SetText(strings.TrimSpace(u.vaultPath.Text()))
+	}
+	u.syncSavedRemoteBindingSelection()
+	u.prefillAdvancedSyncRemoteFromSavedBinding()
+}
+
+func (u *ui) openRemoteSyncSetupDialog() {
+	u.syncDialogOpen = true
+	u.syncMenuOpen = false
+	u.showSyncPassword = false
+	u.syncDialogList.Position = layout.Position{}
+	u.syncDialogPurpose = syncDialogPurposeRemoteSetup
+	u.syncSourceMode = syncSourceRemote
+	u.syncDirection = syncDirectionPush
+	u.syncSetupAutomatic.Value = true
+	if strings.TrimSpace(u.syncLocalPath.Text()) == "" {
+		u.syncLocalPath.SetText(strings.TrimSpace(u.vaultPath.Text()))
+	}
+	u.syncSavedRemoteBindingSelection()
+	u.prefillAdvancedSyncRemoteFromSavedBinding()
+	if _, ok := u.selectedVaultRemoteBinding(); ok && u.selectedVaultRemoteSyncMode == appstate.SyncModeManual {
+		u.syncSetupAutomatic.Value = false
+	}
+}
+
+func (u *ui) clearSyncLocalImport() {
+	u.syncLocalImportName = ""
+	u.syncLocalImportContent = nil
+}
+
+func (u *ui) selectedSyncLocalImport() (string, []byte, bool) {
+	name := strings.TrimSpace(u.syncLocalImportName)
+	if name == "" || name != strings.TrimSpace(u.syncLocalPath.Text()) || len(u.syncLocalImportContent) == 0 {
+		return "", nil, false
+	}
+	return name, append([]byte(nil), u.syncLocalImportContent...), true
+}
+
+func sanitizeSyncSourceMode(mode syncSourceMode) syncSourceMode {
+	switch mode {
+	case syncSourceRemote:
+		return syncSourceRemote
+	default:
+		return syncSourceLocal
+	}
+}
+
+func sanitizeSyncDirection(direction syncDirection) syncDirection {
+	switch direction {
+	case syncDirectionPush:
+		return syncDirectionPush
+	default:
+		return syncDirectionPull
+	}
+}
+
+func (u *ui) advancedSyncAction() error {
+	switch u.syncDirection {
+	case syncDirectionPush:
+		return u.advancedSyncToAction()
+	default:
+		return u.advancedSyncFromAction()
+	}
+}
+
+func (u *ui) advancedSyncFromAction() error {
+	switch u.syncSourceMode {
+	case syncSourceRemote:
+		client := webdav.Client{
+			BaseURL:  strings.TrimSpace(u.syncRemoteBaseURL.Text()),
+			Username: strings.TrimSpace(u.syncRemoteUsername.Text()),
+			Password: u.syncRemotePassword.Text(),
+		}
+		if err := u.state.SynchronizeFromRemote(client, strings.TrimSpace(u.syncRemotePath.Text())); err != nil {
+			return err
+		}
+	default:
+		if name, content, ok := u.selectedSyncLocalImport(); ok {
+			if err := u.state.SynchronizeFromLocalBytes(name, content); err != nil {
+				return err
+			}
+			break
+		}
+		path := strings.TrimSpace(u.syncLocalPath.Text())
+		if path == "" {
+			return errors.New(errVaultPathRequired)
+		}
+		if err := u.state.SynchronizeFromLocal(path); err != nil {
+			return err
+		}
+	}
+	u.syncDialogOpen = false
+	u.showSyncPassword = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) startChooseSyncLocalSourceAction() {
+	if runtime.GOOS != "android" || u.fileExplorer == nil {
+		u.runAction("choose sync path", func() error {
+			u.clearSyncLocalImport()
+			return u.chooseExistingFileAction(&u.syncLocalPath)
+		})
+		return
+	}
+	u.runBackgroundAction("choose sync file", func() (func() error, error) {
+		file, err := u.fileExplorer.ChooseFile(".kdbx")
+		if err != nil {
+			if errors.Is(err, explorer.ErrUserDecline) {
+				return func() error { return nil }, nil
+			}
+			return nil, err
+		}
+		defer file.Close()
+		content, err := io.ReadAll(file)
+		if err != nil {
+			return nil, err
+		}
+		label := "Selected Android vault"
+		return func() error {
+			u.syncLocalImportName = label
+			u.syncLocalImportContent = append([]byte(nil), content...)
+			u.syncLocalPath.SetText(label)
+			return nil
+		}, nil
+	})
+}
+
+func pickedDocumentName(file io.ReadCloser, fallback string) string {
+	if named, ok := file.(interface{ Name() string }); ok {
+		if base := filepath.Base(strings.TrimSpace(named.Name())); base != "" && base != "." && base != string(filepath.Separator) {
+			return base
+		}
+	}
+	fallback = filepath.Base(strings.TrimSpace(fallback))
+	if fallback == "" || fallback == "." || fallback == string(filepath.Separator) {
+		return "selected-vault.kdbx"
+	}
+	return fallback
+}
+
+func (u *ui) startChooseVaultPathAction() {
+	if runtime.GOOS != "android" || u.fileExplorer == nil {
+		u.runAction("choose vault path", func() error { return u.chooseExistingFileAction(&u.vaultPath) })
+		return
+	}
+	u.runBackgroundAction("choose vault file", func() (func() error, error) {
+		file, err := u.fileExplorer.ChooseFile(".kdbx")
+		if err != nil {
+			if errors.Is(err, explorer.ErrUserDecline) {
+				return func() error { return nil }, nil
+			}
+			return nil, err
+		}
+		defer file.Close()
+		content, err := io.ReadAll(file)
+		if err != nil {
+			return nil, err
+		}
+		name := pickedDocumentName(file, "selected-vault.kdbx")
+		return func() error {
+			return u.importSharedVaultBytesAction(name, content)
+		}, nil
+	})
+}
+
+func (u *ui) startImportSharedVaultAction() {
+	if !supportsSharedVaultImport(runtime.GOOS) || u.fileExplorer == nil {
+		return
+	}
+	u.runBackgroundAction("import shared vault", func() (func() error, error) {
+		file, err := u.fileExplorer.ChooseFile(".kdbx")
+		if err != nil {
+			if errors.Is(err, explorer.ErrUserDecline) {
+				return func() error { return nil }, nil
+			}
+			return nil, err
+		}
+		defer file.Close()
+		content, err := io.ReadAll(file)
+		if err != nil {
+			return nil, err
+		}
+		return func() error {
+			return u.importSharedVaultBytesAction("shared-vault.kdbx", content)
+		}, nil
+	})
+}
+
+func (u *ui) advancedSyncToAction() error {
+	switch u.syncSourceMode {
+	case syncSourceRemote:
+		baseURL := strings.TrimSpace(u.syncRemoteBaseURL.Text())
+		remotePath := strings.TrimSpace(u.syncRemotePath.Text())
+		client := webdav.Client{
+			BaseURL:  baseURL,
+			Username: strings.TrimSpace(u.syncRemoteUsername.Text()),
+			Password: u.syncRemotePassword.Text(),
+		}
+		if err := u.state.SynchronizeToRemote(client, remotePath); err != nil {
+			return err
+		}
+		if u.syncDialogPurpose == syncDialogPurposeRemoteSetup {
+			if err := u.persistSyncDialogRemoteBinding(baseURL, remotePath); err != nil {
+				return err
+			}
+			u.showStatusMessage("Remote sync is set up for this vault.")
+		}
+	default:
+		path := strings.TrimSpace(u.syncLocalPath.Text())
+		if path == "" {
+			return errors.New(errVaultPathRequired)
+		}
+		if err := u.state.SynchronizeToLocal(path); err != nil {
+			return err
+		}
+	}
+	u.syncDialogOpen = false
+	u.showSyncPassword = false
+	u.filter()
+	return nil
+}
+
+func (u *ui) persistSyncDialogRemoteBinding(baseURL, remotePath string) error {
+	baseURL = strings.TrimSpace(baseURL)
+	remotePath = strings.TrimSpace(remotePath)
+	if baseURL == "" || remotePath == "" {
+		return fmt.Errorf("remote setup requires base URL and path")
+	}
+	input := appstate.RemoteBindingInput{
+		LocalVaultPath:    strings.TrimSpace(u.vaultPath.Text()),
+		RemoteProfileID:   "remote-profile-" + remoteBindingSuffix(baseURL, remotePath, strings.TrimSpace(u.syncRemoteUsername.Text())),
+		RemoteProfileName: friendlyRecentRemoteLabel(recentRemoteRecord{BaseURL: baseURL, Path: remotePath}),
+		BaseURL:           baseURL,
+		RemotePath:        remotePath,
+		CredentialEntryID: "remote-credential-" + remoteBindingSuffix(baseURL, remotePath, strings.TrimSpace(u.syncRemoteUsername.Text())),
+		CredentialTitle: "WebDAV Sign-In" + func() string {
+			if user := strings.TrimSpace(u.syncRemoteUsername.Text()); user != "" {
+				return " · " + user
+			}
+			return ""
+		}(),
+		Username:       strings.TrimSpace(u.syncRemoteUsername.Text()),
+		Password:       u.syncRemotePassword.Text(),
+		CredentialPath: append([]string(nil), u.currentPath...),
+		SyncMode:       u.syncSetupMode(),
+	}
+	binding, err := u.state.ConfigureRemoteBinding(input)
+	if err != nil {
+		return err
+	}
+	if err := u.state.Save(); err != nil {
+		return err
+	}
+	u.selectedVaultRemoteProfileID = binding.RemoteProfileID
+	u.selectedVaultRemoteCredentialEntryID = binding.CredentialEntryID
+	u.selectedVaultRemoteSyncMode = binding.SyncMode
+	u.remoteBaseURL.SetText(baseURL)
+	u.remotePath.SetText(remotePath)
+	u.remoteUsername.SetText(strings.TrimSpace(u.syncRemoteUsername.Text()))
+	u.remotePassword.SetText(u.syncRemotePassword.Text())
+	u.noteRecentRemote(baseURL, remotePath)
+	return nil
+}
+
+func (u *ui) saveAsTargetPath() string {
+	path := strings.TrimSpace(u.saveAsPath.Text())
+	if path != "" {
+		return path
+	}
+	return u.defaultSaveAsPath
+}
+
+func (u *ui) importedVaultDestination(name string) string {
+	baseTarget := u.saveAsTargetPath()
+	baseDir := filepath.Dir(baseTarget)
+	baseName := filepath.Base(strings.TrimSpace(name))
+	switch {
+	case baseName == "" || baseName == "." || baseName == string(filepath.Separator):
+		return baseTarget
+	case strings.HasSuffix(strings.ToLower(baseName), ".kdbx"):
+		return filepath.Join(baseDir, baseName)
+	default:
+		return baseTarget
+	}
+}
+
+func (u *ui) consumePendingSharedVaultImport() {
+	path := strings.TrimSpace(u.pendingSharedVaultPath)
+	if path == "" {
+		return
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			u.state.ErrorMessage = fmt.Sprintf("import shared vault: %v", err)
+		}
+		return
+	}
+	name := "shared-vault.kdbx"
+	if namePath := strings.TrimSpace(u.pendingSharedVaultNamePath); namePath != "" {
+		if rawName, err := os.ReadFile(namePath); err == nil {
+			if trimmed := strings.TrimSpace(string(rawName)); trimmed != "" {
+				name = trimmed
+			}
+		}
+	}
+	if err := u.importSharedVaultBytesAction(name, content); err != nil {
+		u.state.ErrorMessage = fmt.Sprintf("import shared vault: %v", err)
+		return
+	}
+	_ = os.Remove(path)
+	if namePath := strings.TrimSpace(u.pendingSharedVaultNamePath); namePath != "" {
+		_ = os.Remove(namePath)
+	}
+}
+
+func (u *ui) importSharedVaultBytesAction(name string, content []byte) error {
+	target := u.importedVaultDestination(name)
+	if err := os.MkdirAll(filepath.Dir(target), 0o700); err != nil {
+		return err
+	}
+	if err := os.WriteFile(target, append([]byte(nil), content...), 0o600); err != nil {
+		return err
+	}
+	u.lifecycleMode = "local"
+	u.vaultPath.SetText(target)
+	u.noteRecentVault(target)
+	u.state.ErrorMessage = ""
+	u.state.StatusMessage = ""
+	u.requestMasterPassFocus = true
+	u.filter()
+	return nil
+}
+
+func (u *ui) currentShareableVaultPath() string {
+	return strings.TrimSpace(u.vaultPath.Text())
+}
+
+func (u *ui) shareCurrentVaultAction() error {
+	if u.vaultSharer == nil {
+		return fmt.Errorf("vault sharing is not available on this platform")
+	}
+	path := u.currentShareableVaultPath()
+	if path == "" {
+		return errors.New(errVaultPathRequired)
+	}
+	if err := u.state.Save(); err != nil {
+		return err
+	}
+	return u.vaultSharer.ShareVault(path, friendlyRecentVaultLabel(path))
+}

internal/appui/lifecycle_forms.go

@@ -1,4 +1,4 @@
-package main
+package appui
 
 import (
 	"fmt"
@@ -15,99 +15,30 @@ import (
 	"gioui.org/unit"
 	"gioui.org/widget"
 	"gioui.org/widget/material"
-	"git.julianfamily.org/keepassgo/appstate"
+	"git.julianfamily.org/keepassgo/internal/appstate"
 )
 
+func (u *ui) lifecycleScreen(gtx layout.Context) layout.Dimensions {
+	panel := card
+	if u.usesCompactViewport() {
+		panel = compactCard
+	}
+	return panel(gtx, func(gtx layout.Context) layout.Dimensions {
+		rows := []layout.Widget{
+			u.lifecycleBranding,
+			layout.Spacer{Height: unit.Dp(8)}.Layout,
+			u.lifecycleControls,
+		}
+		return material.List(u.theme, &u.lifecycleList).Layout(gtx, len(rows), func(gtx layout.Context, i int) layout.Dimensions {
+			return rows[i](gtx)
+		})
+	})
+}
+
 func (u *ui) lifecycleControls(gtx layout.Context) layout.Dimensions {
 	busy := u.lifecycleBusy()
 	showLocalChooser := u.showLocalVaultChooser()
 	selectedLocalPath := strings.TrimSpace(u.vaultPath.Text())
-	advancedSection := func(gtx layout.Context) layout.Dimensions {
-		if busy {
-			return layout.Dimensions{}
-		}
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-			layout.Rigid(u.lifecycleAdvancedDisclosure),
-			layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				if u.lifecycleAdvancedHidden {
-					return layout.Dimensions{}
-				}
-				if u.lifecycleMode == "remote" {
-					return layout.Dimensions{}
-				}
-				return compactCard(gtx, func(gtx layout.Context) layout.Dimensions {
-					return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-						layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-							lbl := material.Label(u.theme, unit.Sp(13), "Vault settings")
-							lbl.Color = accentColor
-							return lbl.Layout(gtx)
-						}),
-						layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
-						layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-							lbl := material.Label(u.theme, unit.Sp(12), u.lifecycleSecuritySettingsSummary())
-							lbl.Color = mutedColor
-							return lbl.Layout(gtx)
-						}),
-						layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
-						layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-							return tonedButton(gtx, u.theme, &u.openSecuritySettings, "Open Vault Settings")
-						}),
-					)
-				})
-			}),
-		)
-	}
-	primaryActionsSection := func(gtx layout.Context) layout.Dimensions {
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				label := "Open Vault"
-				if busy {
-					label = "Opening Vault..."
-				}
-				if busy {
-					return passiveTonedButton(gtx, u.theme, label)
-				}
-				return tonedButton(gtx, u.theme, &u.openVault, label)
-			}),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				if busy || !u.shouldShowLifecycleRemoteSyncAction() {
-					return layout.Dimensions{}
-				}
-				return layout.Spacer{Height: unit.Dp(6)}.Layout(gtx)
-			}),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				if busy || !u.shouldShowLifecycleRemoteSyncAction() {
-					return layout.Dimensions{}
-				}
-				return tonedButton(gtx, u.theme, &u.lifecycleRemoteSyncAction, u.lifecycleRemoteSyncActionLabel())
-			}),
-			layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				lbl := material.Label(u.theme, unit.Sp(11), "Need a fresh database instead?")
-				lbl.Color = mutedColor
-				return lbl.Layout(gtx)
-			}),
-			layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				if busy {
-					return passiveSectionTab(gtx, u.theme, "Create New Vault", false)
-				}
-				return sectionTabButton(gtx, u.theme, &u.createVault, "Create New Vault", false)
-			}),
-		)
-	}
-	selectedVaultSection := func(gtx layout.Context) layout.Dimensions {
-		if busy || selectedLocalPath == "" {
-			return layout.Dimensions{}
-		}
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-			layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				return u.selectedLocalVaultCard(gtx, selectedLocalPath)
-			}),
-		)
-	}
 	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
 		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 			lbl := material.Label(u.theme, unit.Sp(12), "OPEN A VAULT")
@@ -123,70 +54,7 @@ func (u *ui) lifecycleControls(gtx layout.Context) layout.Dimensions {
 		}),
 		layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
 		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser {
-						return layout.Dimensions{}
-					}
-					lbl := material.Label(u.theme, unit.Sp(12), "RECENT VAULTS")
-					lbl.Color = mutedColor
-					return lbl.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser {
-						return layout.Dimensions{}
-					}
-					return layout.Spacer{Height: unit.Dp(4)}.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser || busy {
-						return layout.Dimensions{}
-					}
-					return u.recentVaultList(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser || busy || !supportsSharedVaultImport(runtime.GOOS) {
-						return layout.Dimensions{}
-					}
-					return layout.Spacer{Height: unit.Dp(6)}.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser || busy || !supportsSharedVaultImport(runtime.GOOS) {
-						return layout.Dimensions{}
-					}
-					return tonedButton(gtx, u.theme, &u.importSharedVault, "Import Shared Vault")
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser {
-						return layout.Dimensions{}
-					}
-					return layout.Spacer{Height: unit.Dp(8)}.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser {
-						return layout.Dimensions{}
-					}
-					lbl := material.Label(u.theme, unit.Sp(12), "VAULT FILE")
-					lbl.Color = mutedColor
-					return lbl.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					if !showLocalChooser {
-						return layout.Dimensions{}
-					}
-					return layout.Spacer{Height: unit.Dp(4)}.Layout(gtx)
-				}),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					switch {
-					case busy:
-						return labeledEditorHelp(u.theme, "Vault Path", localVaultPathHelp(), &u.vaultPath, false)(gtx)
-					case selectedLocalPath == "":
-						return localPathSelector(u.theme, &u.vaultPath, &u.pickVaultPath)(gtx)
-					default:
-						return layout.Dimensions{}
-					}
-				}),
-			)
+			return u.lifecycleVaultChooserSection(gtx, busy, showLocalChooser, selectedLocalPath)
 		}),
 		layout.Rigid(layout.Spacer{Height: unit.Dp(10)}.Layout),
 		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
@@ -207,65 +75,193 @@ func (u *ui) lifecycleControls(gtx layout.Context) layout.Dimensions {
 		}),
 		layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
 		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			if u.shouldPrioritizeLifecyclePrimaryActions() {
-				return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-					layout.Rigid(primaryActionsSection),
-					layout.Rigid(selectedVaultSection),
-					layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
-					layout.Rigid(advancedSection),
-				)
+			return u.lifecycleControlsFooter(gtx, busy, selectedLocalPath)
+		}),
+	)
+}
+
+func (u *ui) lifecycleVaultChooserSection(gtx layout.Context, busy, showLocalChooser bool, selectedLocalPath string) layout.Dimensions {
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser {
+				return layout.Dimensions{}
 			}
-			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-				layout.Rigid(advancedSection),
-				layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
-				layout.Rigid(primaryActionsSection),
-				layout.Rigid(selectedVaultSection),
-			)
+			lbl := material.Label(u.theme, unit.Sp(12), "RECENT VAULTS")
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser {
+				return layout.Dimensions{}
+			}
+			return layout.Spacer{Height: unit.Dp(4)}.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser || busy {
+				return layout.Dimensions{}
+			}
+			return u.recentVaultList(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return u.lifecycleImportSharedVaultButton(gtx, busy, showLocalChooser)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser {
+				return layout.Dimensions{}
+			}
+			return layout.Spacer{Height: unit.Dp(8)}.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser {
+				return layout.Dimensions{}
+			}
+			lbl := material.Label(u.theme, unit.Sp(12), "VAULT FILE")
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if !showLocalChooser {
+				return layout.Dimensions{}
+			}
+			return layout.Spacer{Height: unit.Dp(4)}.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return u.lifecycleVaultPathSelector(gtx, busy, selectedLocalPath)
+		}),
+	)
+}
+
+func (u *ui) lifecycleImportSharedVaultButton(gtx layout.Context, busy, showLocalChooser bool) layout.Dimensions {
+	if !showLocalChooser || busy || !supportsSharedVaultImport(runtime.GOOS) {
+		return layout.Dimensions{}
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return tonedButton(gtx, u.theme, &u.importSharedVault, "Import Shared Vault")
+		}),
+	)
+}
+
+func (u *ui) lifecycleVaultPathSelector(gtx layout.Context, busy bool, selectedLocalPath string) layout.Dimensions {
+	switch {
+	case busy:
+		return labeledEditorHelp(u.theme, "Vault Path", localVaultPathHelp(), &u.vaultPath, false)(gtx)
+	case selectedLocalPath == "":
+		return localPathSelector(u.theme, &u.vaultPath, &u.pickVaultPath)(gtx)
+	default:
+		return layout.Dimensions{}
+	}
+}
+
+func (u *ui) lifecycleControlsFooter(gtx layout.Context, busy bool, selectedLocalPath string) layout.Dimensions {
+	if u.shouldPrioritizeLifecyclePrimaryActions() {
+		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions { return u.lifecyclePrimaryActionsSection(gtx, busy) }),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return u.lifecycleSelectedVaultSection(gtx, busy, selectedLocalPath)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions { return u.lifecycleAdvancedSection(gtx, busy) }),
+		)
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions { return u.lifecycleAdvancedSection(gtx, busy) }),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions { return u.lifecyclePrimaryActionsSection(gtx, busy) }),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return u.lifecycleSelectedVaultSection(gtx, busy, selectedLocalPath)
+		}),
+	)
+}
+
+func (u *ui) lifecycleAdvancedSection(gtx layout.Context, busy bool) layout.Dimensions {
+	if busy {
+		return layout.Dimensions{}
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(u.lifecycleAdvancedDisclosure),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(u.lifecycleAdvancedCard),
+	)
+}
+
+func (u *ui) lifecycleAdvancedCard(gtx layout.Context) layout.Dimensions {
+	if u.lifecycleAdvancedHidden || u.lifecycleMode == "remote" {
+		return layout.Dimensions{}
+	}
+	return compactCard(gtx, func(gtx layout.Context) layout.Dimensions {
+		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				lbl := material.Label(u.theme, unit.Sp(13), "Vault settings")
+				lbl.Color = accentColor
+				return lbl.Layout(gtx)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				lbl := material.Label(u.theme, unit.Sp(12), u.lifecycleSecuritySettingsSummary())
+				lbl.Color = mutedColor
+				return lbl.Layout(gtx)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return tonedButton(gtx, u.theme, &u.openSecuritySettings, "Open Vault Settings")
+			}),
+		)
+	})
+}
+
+func (u *ui) lifecyclePrimaryActionsSection(gtx layout.Context, busy bool) layout.Dimensions {
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			label := "Open Vault"
+			if busy {
+				return passiveTonedButton(gtx, u.theme, "Opening Vault...")
+			}
+			return tonedButton(gtx, u.theme, &u.openVault, label)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if busy || !u.shouldShowLifecycleRemoteSyncAction() {
+				return layout.Dimensions{}
+			}
+			return layout.Spacer{Height: unit.Dp(6)}.Layout(gtx)
+		}),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if busy || !u.shouldShowLifecycleRemoteSyncAction() {
+				return layout.Dimensions{}
+			}
+			return tonedButton(gtx, u.theme, &u.lifecycleRemoteSyncAction, u.lifecycleRemoteSyncActionLabel())
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			lbl := material.Label(u.theme, unit.Sp(11), "Need a fresh database instead?")
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			if busy {
+				return passiveSectionTab(gtx, u.theme, "Create New Vault", false)
+			}
+			return sectionTabButton(gtx, u.theme, &u.createVault, "Create New Vault", false)
+		}),
+	)
+}
+
+func (u *ui) lifecycleSelectedVaultSection(gtx layout.Context, busy bool, selectedLocalPath string) layout.Dimensions {
+	if busy || selectedLocalPath == "" {
+		return layout.Dimensions{}
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return u.selectedLocalVaultCard(gtx, selectedLocalPath)
 		}),
 	)
 }
 
 func (u *ui) shouldPrioritizeLifecyclePrimaryActions() bool {
-	return u.mode == "phone"
-}
-
-func (u *ui) selectedRemoteConnectionCard(gtx layout.Context) layout.Dimensions {
-	heading := u.selectedRemoteCardHeading()
-	primary := u.selectedRemoteCardPrimaryText()
-	details := u.selectedRemoteCardDetailLines()
-	return compactCard(gtx, func(gtx layout.Context) layout.Dimensions {
-		return layout.UniformInset(unit.Dp(10)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
-			children := []layout.FlexChild{
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					lbl := material.Label(u.theme, unit.Sp(12), heading)
-					lbl.Color = mutedColor
-					return lbl.Layout(gtx)
-				}),
-				layout.Rigid(layout.Spacer{Height: unit.Dp(2)}.Layout),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					lbl := material.Label(u.theme, unit.Sp(14), primary)
-					lbl.Color = accentColor
-					return lbl.Layout(gtx)
-				}),
-			}
-			for _, line := range details {
-				line := line
-				children = append(children, layout.Rigid(layout.Spacer{Height: unit.Dp(2)}.Layout))
-				children = append(children, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					lbl := material.Label(u.theme, unit.Sp(11), line)
-					lbl.Color = mutedColor
-					return lbl.Layout(gtx)
-				}))
-			}
-			children = append(children,
-				layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					return tonedButton(gtx, u.theme, &u.clearRemoteSelection, "Open Different Connection")
-				}),
-			)
-			return layout.Flex{Axis: layout.Vertical}.Layout(gtx, children...)
-		})
-	})
+	return u.usesCompactViewport()
 }
 
 func (u *ui) selectedRemoteCardHeading() string {
@@ -478,71 +474,6 @@ func (u *ui) recentVaultList(gtx layout.Context) layout.Dimensions {
 	)
 }
 
-func (u *ui) recentRemoteList(gtx layout.Context) layout.Dimensions {
-	if len(u.recentRemotes) == 0 {
-		return layout.Dimensions{}
-	}
-	if len(u.recentRemoteClicks) < len(u.recentRemotes) {
-		u.recentRemoteClicks = make([]widget.Clickable, len(u.recentRemotes))
-	}
-	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			lbl := material.Label(u.theme, unit.Sp(12), "RECENT CONNECTIONS")
-			lbl.Color = mutedColor
-			return lbl.Layout(gtx)
-		}),
-		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			maxY := gtx.Dp(unit.Dp(180))
-			if gtx.Constraints.Max.Y > maxY {
-				gtx.Constraints.Max.Y = maxY
-			}
-			if gtx.Constraints.Min.Y > gtx.Constraints.Max.Y {
-				gtx.Constraints.Min.Y = gtx.Constraints.Max.Y
-			}
-			return material.List(u.theme, &u.recentRemoteListState).Layout(gtx, len(u.recentRemotes), func(gtx layout.Context, i int) layout.Dimensions {
-				record := u.recentRemotes[i]
-				label := friendlyRecentRemoteLabel(record)
-				selected := strings.TrimSpace(u.remoteBaseURL.Text()) == record.BaseURL && strings.TrimSpace(u.remotePath.Text()) == record.Path
-				return layout.Inset{Bottom: unit.Dp(6)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
-					return recentSelectionCard(gtx, selected, func(gtx layout.Context) layout.Dimensions {
-						return u.recentRemoteClicks[i].Layout(gtx, func(gtx layout.Context) layout.Dimensions {
-							return layout.UniformInset(unit.Dp(10)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
-								return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-									layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-										lbl := material.Label(u.theme, unit.Sp(14), label)
-										lbl.Color = accentColor
-										return lbl.Layout(gtx)
-									}),
-									layout.Rigid(layout.Spacer{Height: unit.Dp(2)}.Layout),
-									layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-										lbl := material.Label(u.theme, unit.Sp(11), "Path: "+strings.TrimSpace(record.Path))
-										lbl.Color = mutedColor
-										return lbl.Layout(gtx)
-									}),
-									layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-										lbl := material.Label(u.theme, unit.Sp(11), "Server: "+normalizedRemoteHost(record.BaseURL))
-										lbl.Color = mutedColor
-										return lbl.Layout(gtx)
-									}),
-									layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-										if len(record.LastGroup) == 0 {
-											return layout.Dimensions{}
-										}
-										lbl := material.Label(u.theme, unit.Sp(11), "Last group: "+strings.Join(u.displayEntryPath(record.LastGroup), " / "))
-										lbl.Color = mutedColor
-										return lbl.Layout(gtx)
-									}),
-								)
-							})
-						})
-					})
-				})
-			})
-		}),
-	)
-}
-
 func recentSelectionCard(gtx layout.Context, selected bool, w layout.Widget) layout.Dimensions {
 	if !selected {
 		return compactCard(gtx, w)
@@ -938,7 +869,7 @@ func (u *ui) groupControlsDisclosure(gtx layout.Context) layout.Dimensions {
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 						label := "Group Tools"
 						size := unit.Sp(12)
-						if u.mode == "phone" {
+						if u.usesCompactViewport() {
 							size = unit.Sp(11)
 						}
 						lbl := material.Label(u.theme, size, label)
@@ -948,7 +879,7 @@ func (u *ui) groupControlsDisclosure(gtx layout.Context) layout.Dimensions {
 				)
 			})
 		}
-		if u.mode == "phone" {
+		if u.usesCompactViewport() {
 			return content(gtx)
 		}
 		return compactCard(gtx, content)
@@ -1013,7 +944,7 @@ func (u *ui) entryEditorPanel(gtx layout.Context) layout.Dimensions {
 					}),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						if u.mode == "phone" {
+						if u.usesCompactViewport() {
 							return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
 								layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 									return tonedButton(gtx, u.theme, &u.copyPass, "Copy Password")
@@ -1072,7 +1003,7 @@ func (u *ui) entryEditorPanel(gtx layout.Context) layout.Dimensions {
 					layout.Rigid(labeledEditor(u.theme, "Export Attachment Path", &u.exportAttachmentPath, false)),
 					layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
 					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-						if u.mode == "phone" {
+						if u.usesCompactViewport() {
 							return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
 								layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 									return tonedButton(gtx, u.theme, &u.addAttachment, "Add Attachment")
@@ -1140,13 +1071,17 @@ func labeledEditorHelp(th *material.Theme, label, help string, editor *widget.Ed
 	return labeledEditorHelpFocus(th, defaultAccessibilityPreferences(), label, help, editor, sensitive, false)
 }
 
-func localVaultPathHelp() string {
-	if supportsDesktopFilePicker(runtime.GOOS) {
+func localVaultPathHelpForRuntime(goos string) string {
+	if supportsDesktopFilePicker(goos) || supportsSharedVaultImport(goos) {
 		return "Choose the existing .kdbx file to open."
 	}
 	return "Enter the shared-storage path to the existing .kdbx file, for example /sdcard/Download/vault.kdbx."
 }
 
+func localVaultPathHelp() string {
+	return localVaultPathHelpForRuntime(runtime.GOOS)
+}
+
 func keyFileHelp() string {
 	if supportsDesktopFilePicker(runtime.GOOS) {
 		return "Optional path to a KeePass-compatible key file."
@@ -1155,7 +1090,7 @@ func keyFileHelp() string {
 }
 
 func localPathSelector(th *material.Theme, editor *widget.Editor, click *widget.Clickable) layout.Widget {
-	if supportsDesktopFilePicker(runtime.GOOS) {
+	if supportsDesktopFilePicker(runtime.GOOS) || supportsSharedVaultImport(runtime.GOOS) {
 		return selectorEditorHelp(th, "Vault Path", localVaultPathHelp(), editor, click, "Choose File", false)
 	}
 	return labeledEditorHelp(th, "Vault Path", localVaultPathHelp(), editor, false)

internal/appui/list/layout/sections.go

@@ -0,0 +1,12 @@
+package layout
+
+type TopSection string
+
+const (
+	TopSearch     TopSection = "search"
+	TopNavigation TopSection = "navigation"
+	TopPath       TopSection = "path"
+	TopGroup      TopSection = "group"
+	TopGroupTools TopSection = "group_tools"
+	TopPrimary    TopSection = "primary"
+)

internal/appui/list/model.go

@@ -0,0 +1,8 @@
+package list
+
+type EntriesSectionState struct {
+	Path            []string
+	SearchQuery     string
+	SelectedEntryID string
+	Editing         bool
+}

internal/appui/main_test.go

@@ -1,4 +1,4 @@
-package main
+package appui
 
 import (
 	"bytes"
@@ -21,15 +21,17 @@ import (
 	"gioui.org/unit"
 	"gioui.org/widget"
 
-	"git.julianfamily.org/keepassgo/apiapproval"
-	"git.julianfamily.org/keepassgo/apiaudit"
-	"git.julianfamily.org/keepassgo/apitokens"
-	"git.julianfamily.org/keepassgo/appstate"
-	"git.julianfamily.org/keepassgo/clipboard"
-	"git.julianfamily.org/keepassgo/passwords"
-	"git.julianfamily.org/keepassgo/session"
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apiaudit"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/appstate"
+	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
+	listlayout "git.julianfamily.org/keepassgo/internal/appui/list/layout"
+	"git.julianfamily.org/keepassgo/internal/clipboard"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 )
 
 func TestMain(m *testing.M) {
@@ -159,6 +161,42 @@ func TestUIMasterPasswordUsesPasswordInputHint(t *testing.T) {
 	}
 }
 
+func TestLocalVaultPathHelpForAndroidUsesChooserLanguage(t *testing.T) {
+	t.Parallel()
+
+	if got := localVaultPathHelpForRuntime("android"); got != "Choose the existing .kdbx file to open." {
+		t.Fatalf("localVaultPathHelpForRuntime(android) = %q, want chooser guidance", got)
+	}
+}
+
+func TestPickedDocumentNameUsesFileBaseName(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "mint-ledger.kdbx")
+	if err := os.WriteFile(path, []byte("mint"), 0o600); err != nil {
+		t.Fatalf("WriteFile(%q) error = %v", path, err)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("Open(%q) error = %v", path, err)
+	}
+	t.Cleanup(func() { _ = file.Close() })
+
+	if got := pickedDocumentName(file, "selected-vault.kdbx"); got != "mint-ledger.kdbx" {
+		t.Fatalf("pickedDocumentName(file, fallback) = %q, want mint-ledger.kdbx", got)
+	}
+}
+
+func TestPickedDocumentNameFallsBackWhenUnnamed(t *testing.T) {
+	t.Parallel()
+
+	reader := io.NopCloser(strings.NewReader("mint"))
+	if got := pickedDocumentName(reader, "crew-ledger.kdbx"); got != "crew-ledger.kdbx" {
+		t.Fatalf("pickedDocumentName(reader, fallback) = %q, want crew-ledger.kdbx", got)
+	}
+}
+
 func TestUISearchBehaviorIsConsistentAcrossDesktopAndPhoneLayouts(t *testing.T) {
 	t.Parallel()
 
@@ -215,6 +253,290 @@ func TestUISearchBehaviorIsConsistentAcrossDesktopAndPhoneLayouts(t *testing.T)
 	}
 }
 
+func TestUIListPanelTopSectionsMatchAcrossDesktopAndPhoneForEntries(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithModel("desktop", vault.Model{})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithModel("phone", vault.Model{})
+	phone.state.Section = appstate.SectionEntries
+
+	want := []listlayout.TopSection{
+		listlayout.TopSearch,
+		listlayout.TopNavigation,
+		listlayout.TopPath,
+		listlayout.TopGroup,
+		listlayout.TopGroupTools,
+		listlayout.TopPrimary,
+	}
+	if got := desktop.listPanelTopSections(); !slices.Equal(got, want) {
+		t.Fatalf("desktop.listPanelTopSections() = %v, want %v", got, want)
+	}
+	if got := phone.listPanelTopSections(); !slices.Equal(got, want) {
+		t.Fatalf("phone.listPanelTopSections() = %v, want %v", got, want)
+	}
+}
+
+func TestUINavigationHeaderMatchesAcrossDesktopAndPhoneForEntries(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithModel("desktop", vault.Model{})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithModel("phone", vault.Model{})
+	phone.state.Section = appstate.SectionEntries
+
+	if got := desktop.navigationHeaderLabel(); got != "Group Tools" {
+		t.Fatalf("desktop.navigationHeaderLabel() = %q, want %q", got, "Group Tools")
+	}
+	if got := phone.navigationHeaderLabel(); got != "Group Tools" {
+		t.Fatalf("phone.navigationHeaderLabel() = %q, want %q", got, "Group Tools")
+	}
+}
+
+func TestUIGroupBarDoesNotShowExplicitNavigationButtonsAcrossModes(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithModel("desktop", vault.Model{})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithModel("phone", vault.Model{})
+	phone.state.Section = appstate.SectionEntries
+
+	if desktop.groupBarShowsExplicitNavigationButtons() {
+		t.Fatal("desktop.groupBarShowsExplicitNavigationButtons() = true, want false")
+	}
+	if phone.groupBarShowsExplicitNavigationButtons() {
+		t.Fatal("phone.groupBarShowsExplicitNavigationButtons() = true, want false")
+	}
+}
+
+func TestUITopRightActionOrderMatchesAcrossModes(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithSession("desktop", summarySession{hasVault: true})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithSession("phone", summarySession{hasVault: true})
+	phone.state.Section = appstate.SectionEntries
+
+	want := []string{"Sync", "Lock", "Menu"}
+	if got := desktop.topRightActionOrder(); !slices.Equal(got, want) {
+		t.Fatalf("desktop.topRightActionOrder() = %v, want %v", got, want)
+	}
+	if got := phone.topRightActionOrder(); !slices.Equal(got, want) {
+		t.Fatalf("phone.topRightActionOrder() = %v, want %v", got, want)
+	}
+}
+
+func TestUISyncMenuAnchorsMatchAcrossModes(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithSession("desktop", summarySession{hasVault: true})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithSession("phone", summarySession{hasVault: true})
+	phone.state.Section = appstate.SectionEntries
+
+	if !desktop.syncMenuDropsBelowTrigger() || !phone.syncMenuDropsBelowTrigger() {
+		t.Fatal("sync menu should drop below trigger across desktop and phone")
+	}
+	if !desktop.syncMenuRightAlignsToTrigger() || !phone.syncMenuRightAlignsToTrigger() {
+		t.Fatal("sync menu should right-align to trigger across desktop and phone")
+	}
+}
+
+func TestUIMainMenuAnchorsMatchAcrossModes(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithSession("desktop", summarySession{hasVault: true})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithSession("phone", summarySession{hasVault: true})
+	phone.state.Section = appstate.SectionEntries
+
+	if !desktop.mainMenuDropsBelowTrigger() || !phone.mainMenuDropsBelowTrigger() {
+		t.Fatal("main menu should drop below trigger across desktop and phone")
+	}
+	if !desktop.mainMenuRightAlignsToTrigger() || !phone.mainMenuRightAlignsToTrigger() {
+		t.Fatal("main menu should right-align to trigger across desktop and phone")
+	}
+}
+
+func TestUIHeaderMenusUseOverlayModelAcrossModes(t *testing.T) {
+	t.Parallel()
+
+	desktop := newUIWithSession("desktop", summarySession{hasVault: true})
+	desktop.state.Section = appstate.SectionEntries
+	phone := newUIWithSession("phone", summarySession{hasVault: true})
+	phone.state.Section = appstate.SectionEntries
+
+	if !desktop.headerMenusUseOverlayModel() || !phone.headerMenusUseOverlayModel() {
+		t.Fatal("header menus should use the same overlay model across desktop and phone")
+	}
+}
+
+func TestAnchoredMenuXAllowsWiderMenusToExtendLeft(t *testing.T) {
+	t.Parallel()
+
+	if got := headerlayout.AnchoredMenuX(48, 160); got != -112 {
+		t.Fatalf("anchoredMenuX(48, 160) = %d, want -112", got)
+	}
+	if got := headerlayout.AnchoredMenuX(160, 48); got != 112 {
+		t.Fatalf("anchoredMenuX(160, 48) = %d, want 112", got)
+	}
+}
+
+func TestAnchoredMenuOriginXClampsToVisibleContainer(t *testing.T) {
+	t.Parallel()
+
+	if got := headerlayout.AnchoredMenuOriginX(360, 312, 360, 140); got != 220 {
+		t.Fatalf("anchoredMenuOriginX should keep a right-aligned menu visible, got %d want 220", got)
+	}
+	if got := headerlayout.AnchoredMenuOriginX(360, 0, 44, 160); got != 0 {
+		t.Fatalf("anchoredMenuOriginX should clamp oversized left overflow to zero, got %d want 0", got)
+	}
+}
+
+func TestHeaderActionMetricsComputeTriggerAnchors(t *testing.T) {
+	t.Parallel()
+
+	metrics := headerlayout.ActionMetrics{
+		RowOriginX: 24,
+		Spacing:    8,
+		RowDims:    layout.Dimensions{Size: image.Pt(180, 40)},
+		SyncDims:   layout.Dimensions{Size: image.Pt(52, 40)},
+		LockDims:   layout.Dimensions{Size: image.Pt(44, 40)},
+		MainDims:   layout.Dimensions{Size: image.Pt(36, 40)},
+	}
+
+	if got := metrics.SyncAnchor(); got != (headerlayout.DropdownAnchor{TriggerRightX: 76, TriggerBottomY: 40}) {
+		t.Fatalf("metrics.syncAnchor() = %+v, want right=76 bottom=40", got)
+	}
+	if got := metrics.MainAnchor(); got != (headerlayout.DropdownAnchor{TriggerRightX: 172, TriggerBottomY: 40}) {
+		t.Fatalf("metrics.mainAnchor() = %+v, want right=172 bottom=40", got)
+	}
+}
+
+func TestDropdownSurfaceOriginKeepsMenusWithinVisibleArea(t *testing.T) {
+	t.Parallel()
+
+	surface := headerlayout.DropdownSurface{ContainerWidth: 320, LeftInset: 16, TopInset: 16}
+	anchor := headerlayout.DropdownAnchor{TriggerRightX: 300, TriggerBottomY: 42}
+
+	if got := surface.Origin(anchor, 140); got != image.Pt(176, 58) {
+		t.Fatalf("surface.origin(anchor, 140) = %v, want (176,58)", got)
+	}
+
+	leftAnchor := headerlayout.DropdownAnchor{TriggerRightX: 36, TriggerBottomY: 42}
+	if got := surface.Origin(leftAnchor, 120); got != image.Pt(16, 58) {
+		t.Fatalf("surface.origin(leftAnchor, 120) = %v, want (16,58)", got)
+	}
+}
+
+func TestBuildSyncMenuModelForUnboundVault(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{
+		Entries: []vault.Entry{
+			{ID: "mint-ledger", Title: "Mint Ledger"},
+		},
+	})
+	u.state.Section = appstate.SectionEntries
+
+	model := u.buildSyncMenuModel()
+	if !model.ShowRemoteSyncSetupShortcut() {
+		t.Fatal("model.ShowRemoteSyncSetupShortcut() = false, want true for an unbound open vault")
+	}
+	if model.ShowDirectRemoteSyncShortcut() {
+		t.Fatal("model.ShowDirectRemoteSyncShortcut() = true, want false without a saved binding")
+	}
+	if got := model.ActionLabels(); !slices.Equal(got, []string{"Open Advanced Sync", "Set Up Remote Sync"}) {
+		t.Fatalf("model.ActionLabels() = %v, want [Open Advanced Sync Set Up Remote Sync]", got)
+	}
+}
+
+func TestBuildSyncMenuModelForBoundVault(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{
+		Entries: []vault.Entry{
+			{
+				ID:       "mint-credential",
+				Title:    "Mint Credentials",
+				Username: "verbal-kint",
+			},
+		},
+		RemoteProfiles: []vault.RemoteProfile{
+			{
+				ID:      "mint-profile",
+				Name:    "Downtown Mint",
+				Backend: vault.RemoteBackendWebDAV,
+				BaseURL: "https://mint.example.invalid/remote.php/dav",
+				Path:    "/files/kint/mint.kdbx",
+			},
+		},
+	})
+	u.state.Section = appstate.SectionEntries
+	u.selectedVaultRemoteProfileID = "mint-profile"
+	u.selectedVaultRemoteCredentialEntryID = "mint-credential"
+	u.selectedVaultRemoteSyncMode = appstate.SyncModeAutomaticOnOpenSave
+
+	model := u.buildSyncMenuModel()
+	if model.ShowRemoteSyncSetupShortcut() {
+		t.Fatal("model.ShowRemoteSyncSetupShortcut() = true, want false for a bound vault")
+	}
+	if !model.ShowDirectRemoteSyncShortcut() {
+		t.Fatal("model.ShowDirectRemoteSyncShortcut() = false, want true for a bound vault")
+	}
+	if !model.ShowRemoteSyncSettingsShortcut() {
+		t.Fatal("model.ShowRemoteSyncSettingsShortcut() = false, want true for a bound vault")
+	}
+	if !model.ShowRemoveRemoteSyncShortcut() {
+		t.Fatal("model.ShowRemoveRemoteSyncShortcut() = false, want true for a bound vault")
+	}
+	summary := model.SavedBindingSummary
+	if !summary.OK {
+		t.Fatal("model.SavedBindingSummary.OK = false, want true")
+	}
+	if summary.ProfileLabel != "Downtown Mint" {
+		t.Fatalf("model.SavedBindingSummary.ProfileLabel = %q, want Downtown Mint", summary.ProfileLabel)
+	}
+	if summary.CredentialLabel != "Mint Credentials · verbal-kint" {
+		t.Fatalf("model.SavedBindingSummary.CredentialLabel = %q, want Mint Credentials · verbal-kint", summary.CredentialLabel)
+	}
+	if summary.SyncLabel != "Syncs automatically on open and save." {
+		t.Fatalf("model.SavedBindingSummary.SyncLabel = %q, want automatic-sync summary", summary.SyncLabel)
+	}
+}
+
+func TestBuildSyncMenuModelShowsSaveCurrentBindingOnlyWithCompleteRemoteInput(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{
+		Entries: []vault.Entry{
+			{ID: "mint-ledger", Title: "Mint Ledger"},
+		},
+	})
+	u.state.Section = appstate.SectionEntries
+
+	model := u.buildSyncMenuModel()
+	if model.ShowSaveCurrentBinding {
+		t.Fatal("model.ShowSaveCurrentBinding = true, want false without remote input")
+	}
+
+	u.remoteBaseURL.SetText("https://mint.example.invalid/remote.php/dav")
+	u.remotePath.SetText("/files/kint/mint.kdbx")
+	u.remoteUsername.SetText("verbal-kint")
+	u.remotePassword.SetText("kobayashi")
+
+	model = u.buildSyncMenuModel()
+	if !model.ShowSaveCurrentBinding {
+		t.Fatal("model.ShowSaveCurrentBinding = false, want true with complete remote input")
+	}
+	if got := model.SaveCurrentRemoteBindingHeading(); got != "Bind this local vault to the current remote target" {
+		t.Fatalf("model.SaveCurrentRemoteBindingHeading() = %q, want vault binding guidance", got)
+	}
+	if got := model.SaveCurrentRemoteBindingButtonLabel(); got != "Save Remote In Vault" {
+		t.Fatalf("model.SaveCurrentRemoteBindingButtonLabel() = %q, want Save Remote In Vault", got)
+	}
+}
+
 func TestUICurrentVaultSummary(t *testing.T) {
 	t.Parallel()
 
@@ -432,6 +754,23 @@ func TestUIAPITokenLifecycleManagement(t *testing.T) {
 		t.Fatal("apiTokenSecret after rotate = empty, want one-time secret")
 	}
 
+	u.apiTokenName.SetText("Browser Extension Updated")
+	u.apiTokenClientName.SetText("firefox-desktop")
+	u.apiTokenExpiresAt.SetText("2026-05-01T00:00:00Z")
+	if err := u.saveAPITokenAction(); err != nil {
+		t.Fatalf("saveAPITokenAction() error = %v", err)
+	}
+	updated, ok := u.selectedAPIToken()
+	if !ok {
+		t.Fatal("selectedAPIToken() ok = false, want true after save")
+	}
+	if updated.Name != "Browser Extension Updated" || updated.ClientName != "firefox-desktop" {
+		t.Fatalf("updated token = %#v, want renamed/firefox-desktop", updated)
+	}
+	if updated.ExpiresAt == nil || updated.ExpiresAt.UTC().Format(time.RFC3339) != "2026-05-01T00:00:00Z" {
+		t.Fatalf("updated.ExpiresAt = %#v, want 2026-05-01T00:00:00Z", updated.ExpiresAt)
+	}
+
 	if err := u.disableAPITokenAction(); err != nil {
 		t.Fatalf("disableAPITokenAction() error = %v", err)
 	}
@@ -439,9 +778,17 @@ func TestUIAPITokenLifecycleManagement(t *testing.T) {
 	if !ok || !disabled.Disabled {
 		t.Fatalf("selectedAPIToken() = %#v, want disabled token", disabled)
 	}
+
+	if err := u.revokeAPITokenAction(); err != nil {
+		t.Fatalf("revokeAPITokenAction() error = %v", err)
+	}
+	revoked, ok := u.selectedAPIToken()
+	if !ok || revoked.RevokedAt == nil {
+		t.Fatalf("selectedAPIToken() = %#v, want revoked token", revoked)
+	}
 }
 
-func TestUIAPITokenPolicyRulesCanBeAddedAndRemoved(t *testing.T) {
+func TestUIAPITokenPolicyRulesCanBeCreatedUpdatedAndRemoved(t *testing.T) {
 	t.Parallel()
 
 	u := newUIWithSession("desktop", &session.Manager{}, statePaths{
@@ -477,6 +824,33 @@ func TestUIAPITokenPolicyRulesCanBeAddedAndRemoved(t *testing.T) {
 	if token.Policies[0].Resource.Kind != apitokens.ResourceGroup {
 		t.Fatalf("rule kind = %q, want group", token.Policies[0].Resource.Kind)
 	}
+	if len(u.apiPolicyEdits) != 1 {
+		t.Fatalf("len(apiPolicyEdits) = %d, want 1", len(u.apiPolicyEdits))
+	}
+
+	u.apiPolicyEdits[0].Click()
+	u.handleAPIPolicyClicks(layout.Context{})
+	if u.selectedAPIPolicyIndex != 0 {
+		t.Fatalf("selectedAPIPolicyIndex = %d, want 0 after edit click", u.selectedAPIPolicyIndex)
+	}
+	if got := u.apiPolicyPath.Text(); got != "Root / Internet" {
+		t.Fatalf("apiPolicyPath = %q, want Root / Internet after edit load", got)
+	}
+
+	u.apiPolicyPath.SetText("Root / Security")
+	u.saveAPIPolicyRule.Click()
+	u.handleAPIPolicyClicks(layout.Context{})
+
+	token, ok = u.selectedAPIToken()
+	if !ok || len(token.Policies) != 1 {
+		t.Fatalf("selectedAPIToken().Policies after save = %#v, want 1 rule", token.Policies)
+	}
+	if got := strings.Join(token.Policies[0].Resource.Path, " / "); got != "Root / Security" {
+		t.Fatalf("updated policy path = %q, want Root / Security", got)
+	}
+	if u.selectedAPIPolicyIndex != -1 {
+		t.Fatalf("selectedAPIPolicyIndex after save = %d, want -1", u.selectedAPIPolicyIndex)
+	}
 
 	if err := u.removeAPIPolicyRuleAction(0); err != nil {
 		t.Fatalf("removeAPIPolicyRuleAction() error = %v", err)
@@ -1014,6 +1388,67 @@ func TestUIPhoneBackClosesSettingsDialog(t *testing.T) {
 	}
 }
 
+func TestUIWidePhoneViewportUsesDesktopLayout(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("phone", vault.Model{
+		Entries: []vault.Entry{{ID: "entry-1", Title: "Vault Console"}},
+	})
+	u.state.ShowSection(appstate.SectionEntries)
+	u.updateViewportLayoutMode(layout.Context{
+		Ops:         new(op.Ops),
+		Constraints: layout.Exact(image.Pt(1200, 900)),
+		Metric:      unit.Metric{PxPerDp: 1, PxPerSp: 1},
+	})
+
+	if u.usesCompactViewport() {
+		t.Fatal("usesCompactViewport() = true, want false for wide phone viewport")
+	}
+	if !u.shouldShowDesktopWorkingHeader() {
+		t.Fatal("shouldShowDesktopWorkingHeader() = false, want true for wide phone viewport")
+	}
+}
+
+func TestUINarrowDesktopViewportUsesCompactLayout(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{
+		Entries: []vault.Entry{{ID: "entry-1", Title: "Vault Console"}},
+	})
+	u.state.ShowSection(appstate.SectionEntries)
+	u.updateViewportLayoutMode(layout.Context{
+		Ops:         new(op.Ops),
+		Constraints: layout.Exact(image.Pt(540, 900)),
+		Metric:      unit.Metric{PxPerDp: 1, PxPerSp: 1},
+	})
+
+	if !u.usesCompactViewport() {
+		t.Fatal("usesCompactViewport() = false, want true for narrow desktop viewport")
+	}
+	if u.shouldShowDesktopWorkingHeader() {
+		t.Fatal("shouldShowDesktopWorkingHeader() = true, want false for narrow desktop viewport")
+	}
+}
+
+func TestUIWidePhoneViewportKeepsAndroidBackBehavior(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("phone", vault.Model{})
+	u.securityDialogOpen = true
+	u.updateViewportLayoutMode(layout.Context{
+		Ops:         new(op.Ops),
+		Constraints: layout.Exact(image.Pt(1200, 900)),
+		Metric:      unit.Metric{PxPerDp: 1, PxPerSp: 1},
+	})
+
+	if !u.handlePhoneBack() {
+		t.Fatal("handlePhoneBack() = false, want true for wide phone viewport")
+	}
+	if u.securityDialogOpen {
+		t.Fatal("securityDialogOpen = true after back, want false")
+	}
+}
+
 func TestUISecurityDialogContentDoesNotPanicWithSmallViewport(t *testing.T) {
 	t.Parallel()
 
@@ -4475,6 +4910,112 @@ func TestUIResolvePendingApprovalDelegatesToApprovalManager(t *testing.T) {
 	}
 }
 
+func TestUIApprovalDialogVisibleForPendingRequest(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{})
+	u.state.Approvals = &mainStubApprovalManager{
+		pending: []apiapproval.Request{{
+			ID:         "approval-1",
+			TokenName:  "CLI",
+			ClientName: "grpc-cli",
+			Operation:  apitokens.OperationReadEntry,
+			Resource: apitokens.Resource{
+				Kind:    apitokens.ResourceEntry,
+				EntryID: "vault-console",
+			},
+		}},
+	}
+
+	dims := u.approvalDialogContent(layout.Context{
+		Ops:         new(op.Ops),
+		Constraints: layout.Exact(image.Pt(800, 600)),
+	})
+	if dims.Size.X == 0 || dims.Size.Y == 0 {
+		t.Fatalf("approvalDialogContent() = %v, want visible dimensions for pending approval", dims.Size)
+	}
+}
+
+func TestUIApprovalButtonsResolveAllOutcomes(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		click   func(*ui)
+		want    apiapproval.Outcome
+		wantMsg string
+	}{
+		{
+			name: "allow once",
+			click: func(u *ui) {
+				u.allowApprovalOnce.Click()
+			},
+			want:    apiapproval.OutcomeAllowOnce,
+			wantMsg: "allow API request complete",
+		},
+		{
+			name: "allow permanently",
+			click: func(u *ui) {
+				u.allowApprovalPermanent.Click()
+			},
+			want:    apiapproval.OutcomeAllowPermanent,
+			wantMsg: "allow API request permanently complete",
+		},
+		{
+			name: "deny once",
+			click: func(u *ui) {
+				u.denyApprovalOnce.Click()
+			},
+			want:    apiapproval.OutcomeDenyOnce,
+			wantMsg: "deny API request complete",
+		},
+		{
+			name: "deny permanently",
+			click: func(u *ui) {
+				u.denyApprovalPermanent.Click()
+			},
+			want:    apiapproval.OutcomeDenyPermanent,
+			wantMsg: "deny API request permanently complete",
+		},
+		{
+			name: "cancel",
+			click: func(u *ui) {
+				u.cancelApproval.Click()
+			},
+			want:    apiapproval.OutcomeCancel,
+			wantMsg: "cancel API request complete",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			manager := &mainStubApprovalManager{
+				pending: []apiapproval.Request{{
+					ID:         "approval-1",
+					TokenName:  "CLI",
+					ClientName: "grpc-cli",
+					Operation:  apitokens.OperationReadEntry,
+				}},
+			}
+			u := newUIWithModel("desktop", vault.Model{})
+			u.state.Approvals = manager
+
+			tt.click(u)
+			u.handleApprovalClicks(layout.Context{})
+
+			if manager.lastID != "approval-1" || manager.lastOutcome != tt.want {
+				t.Fatalf("handleApprovalClicks() delegated (%q, %q), want (approval-1, %q)", manager.lastID, manager.lastOutcome, tt.want)
+			}
+			if got := u.state.StatusMessage; got != tt.wantMsg {
+				t.Fatalf("state.StatusMessage = %q, want %q", got, tt.wantMsg)
+			}
+		})
+	}
+}
+
 func TestUIRequiresExplicitEditModeForEntryEditor(t *testing.T) {
 	t.Parallel()
 
@@ -5077,6 +5618,28 @@ func TestUISyncDefaultsPersistInSettings(t *testing.T) {
 	}
 }
 
+func TestUIDebugHeaderBoundsPersistInSettings(t *testing.T) {
+	t.Parallel()
+
+	configPath := filepath.Join(t.TempDir(), "settings.json")
+
+	first := newUIWithSession("phone", &session.Manager{}, statePaths{
+		SettingsPath: configPath,
+	})
+	first.debugLogHeaderBounds = true
+	first.saveSettings()
+
+	second := newUIWithSession("phone", &session.Manager{}, statePaths{
+		SettingsPath: configPath,
+	})
+	second.debugLogHeaderBounds = false
+	second.loadSettings()
+
+	if !second.debugLogHeaderBounds {
+		t.Fatal("debugLogHeaderBounds = false, want true after reload")
+	}
+}
+
 func TestUILoadSettingsFallsBackToLegacySyncDefaultsInUIPreferences(t *testing.T) {
 	t.Parallel()
 
@@ -5169,6 +5732,39 @@ func TestUISaveSecuritySettingsPersistsSyncDefaults(t *testing.T) {
 	}
 }
 
+func TestUISaveSecuritySettingsPersistsDebugHeaderBounds(t *testing.T) {
+	t.Parallel()
+
+	manager := &session.Manager{}
+	dir := t.TempDir()
+	u := newUIWithSession("phone", manager, statePaths{
+		DefaultSaveAsPath: filepath.Join(dir, "vault.kdbx"),
+		SettingsPath:      filepath.Join(dir, "settings.json"),
+		UIPreferencesPath: filepath.Join(dir, "ui-prefs.json"),
+	})
+	u.masterPassword.SetText("correct horse battery staple")
+	if err := u.createVaultAction(); err != nil {
+		t.Fatalf("createVaultAction() error = %v", err)
+	}
+	u.securityCipher.SetText(vault.CipherAES256)
+	u.securityKDF.SetText(vault.KDFAES)
+	u.loadSettingsDraft()
+	u.settingsDebugHeaderBounds.Value = true
+
+	if err := u.saveSecuritySettingsAction(); err != nil {
+		t.Fatalf("saveSecuritySettingsAction() error = %v", err)
+	}
+
+	reloaded := newUIWithSession("phone", &session.Manager{}, statePaths{
+		SettingsPath: u.settingsPath,
+	})
+	reloaded.loadSettings()
+
+	if !reloaded.debugLogHeaderBounds {
+		t.Fatal("reloaded debugLogHeaderBounds = false, want true")
+	}
+}
+
 func TestUIAccessibilityPreferencesPersist(t *testing.T) {
 	t.Parallel()
 
@@ -8247,6 +8843,28 @@ func TestUIPasswordRevealTogglesDisplayedPasswordAndLockResetsIt(t *testing.T) {
 	}
 }
 
+func TestUIPasswordTogglePresentationMatchesVisibility(t *testing.T) {
+	t.Parallel()
+
+	u := newUIWithModel("desktop", vault.Model{})
+
+	icon, desc := u.passwordTogglePresentation(false)
+	if icon != u.eyeOffIcon {
+		t.Fatal("passwordTogglePresentation(false) should use slashed eye icon")
+	}
+	if desc != "Show password" {
+		t.Fatalf("passwordTogglePresentation(false) desc = %q, want %q", desc, "Show password")
+	}
+
+	icon, desc = u.passwordTogglePresentation(true)
+	if icon != u.eyeIcon {
+		t.Fatal("passwordTogglePresentation(true) should use unslashed eye icon")
+	}
+	if desc != "Hide password" {
+		t.Fatalf("passwordTogglePresentation(true) desc = %q, want %q", desc, "Hide password")
+	}
+}
+
 type memoryClipboardWriter struct {
 	content string
 }

internal/appui/platform/android_log_android.go

@@ -0,0 +1,22 @@
+//go:build android
+
+package platform
+
+/*
+#cgo CFLAGS: -Werror
+#cgo LDFLAGS: -landroid
+
+#include <android/log.h>
+#include <stdlib.h>
+*/
+import "C"
+
+import "unsafe"
+
+func LogInfo(tag, msg string) {
+	ctag := C.CString(tag)
+	defer C.free(unsafe.Pointer(ctag))
+	cmsg := C.CString(msg)
+	defer C.free(unsafe.Pointer(cmsg))
+	C.__android_log_write(C.ANDROID_LOG_INFO, ctag, cmsg)
+}

internal/appui/platform/android_share_android.go

@@ -1,6 +1,6 @@
 //go:build android
 
-package main
+package platform
 
 /*
 #cgo CFLAGS: -Werror
@@ -71,7 +71,7 @@ func gioJavaVM() *C.JavaVM
 //go:linkname gioRunInJVM gioui.org/app.runInJVM
 func gioRunInJVM(jvm *C.JavaVM, f func(env *C.JNIEnv))
 
-func newPlatformVaultSharer(goos string) vaultSharer {
+func NewVaultSharer(goos string) VaultSharer {
 	return androidVaultSharer{}
 }
 

internal/appui/platform/android_share_stub.go

@@ -0,0 +1,13 @@
+//go:build !android
+
+package platform
+
+import "log"
+
+func NewVaultSharer(goos string) VaultSharer {
+	return nil
+}
+
+func LogInfo(tag, msg string) {
+	log.Printf("%s: %s", tag, msg)
+}

internal/appui/platform/clipboard_gio.go

@@ -1,4 +1,4 @@
-package main
+package platform
 
 import (
 	"io"
@@ -8,23 +8,27 @@ import (
 	gioclipboard "gioui.org/io/clipboard"
 	"gioui.org/layout"
 
-	appclipboard "git.julianfamily.org/keepassgo/clipboard"
+	appclipboard "git.julianfamily.org/keepassgo/internal/clipboard"
 )
 
+type VaultSharer interface {
+	ShareVault(path, title string) error
+}
+
 type clipboardCommandWriter struct {
 	mu         sync.Mutex
 	pending    []string
 	invalidate func()
 }
 
-func newPlatformClipboardWriter(goos string, invalidate func()) appclipboard.Writer {
+func NewClipboardWriter(goos string, invalidate func()) appclipboard.Writer {
 	if strings.EqualFold(goos, "android") {
 		return &clipboardCommandWriter{invalidate: invalidate}
 	}
 	return nil
 }
 
-func processClipboardWrites(gtx layout.Context, writer appclipboard.Writer) {
+func ProcessClipboardWrites(gtx layout.Context, writer appclipboard.Writer) {
 	commandWriter, ok := writer.(*clipboardCommandWriter)
 	if !ok {
 		return

internal/appui/platform/clipboard_gio_test.go

@@ -1,4 +1,4 @@
-package main
+package platform
 
 import (
 	"slices"
@@ -8,17 +8,17 @@ import (
 func TestNewPlatformClipboardWriterUsesCommandWriterOnAndroid(t *testing.T) {
 	t.Parallel()
 
-	writer := newPlatformClipboardWriter("android", nil)
+	writer := NewClipboardWriter("android", nil)
 	if _, ok := writer.(*clipboardCommandWriter); !ok {
-		t.Fatalf("newPlatformClipboardWriter(android) = %T, want *clipboardCommandWriter", writer)
+		t.Fatalf("NewClipboardWriter(android) = %T, want *clipboardCommandWriter", writer)
 	}
 }
 
 func TestNewPlatformClipboardWriterUsesSystemClipboardOffAndroid(t *testing.T) {
 	t.Parallel()
 
-	if writer := newPlatformClipboardWriter("linux", nil); writer != nil {
-		t.Fatalf("newPlatformClipboardWriter(linux) = %T, want nil", writer)
+	if writer := NewClipboardWriter("linux", nil); writer != nil {
+		t.Fatalf("NewClipboardWriter(linux) = %T, want nil", writer)
 	}
 }
 

internal/appui/runtime.go

@@ -0,0 +1,192 @@
+package appui
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+
+	"gioui.org/app"
+	"gioui.org/op"
+	"gioui.org/unit"
+	"gioui.org/x/explorer"
+	"git.julianfamily.org/keepassgo/internal/api"
+	"git.julianfamily.org/keepassgo/internal/apiapproval"
+	"git.julianfamily.org/keepassgo/internal/apitokens"
+	"git.julianfamily.org/keepassgo/internal/appui/platform"
+	"git.julianfamily.org/keepassgo/internal/passwords"
+	"git.julianfamily.org/keepassgo/internal/session"
+	"git.julianfamily.org/keepassgo/internal/vault"
+)
+
+func Main() {
+	mode := flag.String("mode", "", "window mode: desktop or phone")
+	stateDir := flag.String("state-dir", "", "directory for KeePassGO state such as recent-vault history and default save targets")
+	grpcAddr := flag.String("grpc-addr", "", "address for the local gRPC API listener; use 'off' to disable")
+	flag.Parse()
+
+	resolvedMode := resolveFlagOrEnv(*mode, "KEEPASSGO_MODE", defaultModeForRuntime(runtime.GOOS))
+	resolvedStateDir := resolveFlagOrEnv(*stateDir, "KEEPASSGO_STATE_DIR", "")
+	resolvedGRPCAddr := resolveFlagOrEnv(*grpcAddr, "KEEPASSGO_GRPC_ADDR", defaultGRPCAddr(runtime.GOOS))
+
+	width := unit.Dp(1180)
+	height := unit.Dp(760)
+	if strings.EqualFold(resolvedMode, "phone") {
+		width = unit.Dp(412)
+		height = unit.Dp(915)
+	}
+
+	go func() {
+		w := new(app.Window)
+		options := []app.Option{app.Title(productName)}
+		if shouldUsePreviewWindowSize(resolvedMode, runtime.GOOS) {
+			options = append(options, app.Size(width, height))
+		}
+		w.Option(options...)
+		if err := run(w, strings.ToLower(resolvedMode), defaultStatePaths(resolvedStateDir), resolvedGRPCAddr); err != nil {
+			panic(err)
+		}
+		if !strings.EqualFold(runtime.GOOS, "android") {
+			os.Exit(0)
+		}
+	}()
+	app.Main()
+}
+
+func defaultGRPCAddr(goos string) string {
+	if strings.EqualFold(strings.TrimSpace(goos), "android") {
+		return "off"
+	}
+	return "127.0.0.1:47777"
+}
+
+func run(w *app.Window, mode string, paths statePaths, grpcAddr string) error {
+	var ops op.Ops
+	manager := &session.Manager{}
+	ui := newUIWithSession(mode, manager, paths)
+	ui.fileExplorer = explorer.NewExplorer(w)
+	ui.invalidate = w.Invalidate
+	ui.clipboardWriter = platform.NewClipboardWriter(runtime.GOOS, w.Invalidate)
+	host, err := api.StartHost(grpcAddr, manager, passwords.DefaultProfiles(), ui.clipboardWriter, func() bool { return ui.state.Dirty })
+	if err != nil {
+		ui.state.ErrorMessage = fmt.Sprintf("start gRPC API: %v", err)
+	} else if host != nil {
+		ui.apiHost = host
+		ui.auditLog = host.Server().AuditLog()
+		ui.state.AuditLog = ui.auditLog
+		ui.grpcAddress = host.Address()
+		ui.state.Approvals = &uiApprovalManager{server: host.Server()}
+		defer func() { _ = host.Stop() }()
+	}
+	for {
+		e := w.Event()
+		ui.fileExplorer.ListenEvents(e)
+		switch e := e.(type) {
+		case app.DestroyEvent:
+			return e.Err
+		case app.FrameEvent:
+			gtx := app.NewContext(&ops, e)
+			ui.processBackgroundActions()
+			ui.layout(gtx)
+			platform.ProcessClipboardWrites(gtx, ui.clipboardWriter)
+			e.Frame(gtx.Ops)
+		}
+	}
+}
+
+type uiApprovalManager struct {
+	server *api.Server
+}
+
+func (m *uiApprovalManager) Pending() []apiapproval.Request {
+	if m == nil || m.server == nil {
+		return nil
+	}
+	return m.server.ApprovalBroker().Pending()
+}
+
+func (m *uiApprovalManager) Resolve(id string, outcome apiapproval.Outcome) (apiapproval.Request, *apitokens.PolicyRule, error) {
+	if m == nil || m.server == nil {
+		return apiapproval.Request{}, nil, fmt.Errorf("approval manager is not configured")
+	}
+	return m.server.ResolveApproval(id, outcome)
+}
+
+type uiSession struct {
+	model  vault.Model
+	locked bool
+}
+
+func (s *uiSession) HasVault() bool {
+	return len(s.model.Entries) > 0 || len(s.model.Templates) > 0 || len(s.model.RecycleBin) > 0 || len(s.model.Groups) > 0 || s.locked
+}
+
+func (s *uiSession) IsLocked() bool {
+	return s.locked
+}
+
+func (s *uiSession) IsRemote() bool {
+	return false
+}
+
+func (s *uiSession) Current() (vault.Model, error) {
+	if s.locked {
+		return vault.Model{}, session.ErrLocked
+	}
+	return s.model, nil
+}
+
+func (s *uiSession) Replace(model vault.Model) {
+	s.model = model
+}
+
+func (s *uiSession) Lock() error {
+	s.locked = true
+	return nil
+}
+
+func (s *uiSession) Unlock(vault.MasterKey) error {
+	if !s.locked {
+		return nil
+	}
+	s.locked = false
+	return nil
+}
+
+func pickExistingFile() (string, error) {
+	if path, err := runFilePicker("kdialog", "--getopenfilename", "--title", "Choose KeePass file"); err == nil {
+		return path, nil
+	}
+	if path, err := runFilePicker("zenity", "--file-selection", "--title=Choose KeePass file"); err == nil {
+		return path, nil
+	}
+	return "", fmt.Errorf("no supported file picker found; install kdialog or zenity")
+}
+
+func runFilePicker(name string, args ...string) (string, error) {
+	if _, err := exec.LookPath(name); err != nil {
+		return "", err
+	}
+	cmd := exec.Command(name, args...)
+	output, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return parsePickedFilePath(output)
+}
+
+func parsePickedFilePath(output []byte) (string, error) {
+	lines := strings.Split(strings.ReplaceAll(string(output), "\r\n", "\n"), "\n")
+	for i := len(lines) - 1; i >= 0; i-- {
+		line := strings.TrimSpace(lines[i])
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "/") || strings.HasPrefix(line, "~/") {
+			return line, nil
+		}
+	}
+	return "", fmt.Errorf("file picker did not return a path")
+}

internal/appui/settings.go

@@ -1,7 +1,9 @@
-package main
+package appui
 
 import (
 	"encoding/json"
+	"fmt"
+	"image"
 	"image/color"
 	"os"
 	"path/filepath"
@@ -9,32 +11,34 @@ import (
 	"time"
 
 	"gioui.org/layout"
+	"gioui.org/op/clip"
+	"gioui.org/op/paint"
 	"gioui.org/unit"
 	"gioui.org/widget"
 	"gioui.org/widget/material"
-	"git.julianfamily.org/keepassgo/vault"
+	editormodel "git.julianfamily.org/keepassgo/internal/appui/editor"
+	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
+	"git.julianfamily.org/keepassgo/internal/appui/platform"
+	settingsmodel "git.julianfamily.org/keepassgo/internal/appui/settings"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 const (
-	displayDensityDense       = "dense"
-	displayDensityComfortable = "comfortable"
+	displayDensityDense       = settingsmodel.DisplayDensityDense
+	displayDensityComfortable = settingsmodel.DisplayDensityComfortable
 
-	contrastStandard = "standard"
-	contrastHigh     = "high"
+	contrastStandard = settingsmodel.ContrastStandard
+	contrastHigh     = settingsmodel.ContrastHigh
 
-	keyboardFocusStandard  = "standard"
-	keyboardFocusProminent = "prominent"
+	keyboardFocusStandard  = settingsmodel.KeyboardFocusStandard
+	keyboardFocusProminent = settingsmodel.KeyboardFocusProminent
 )
 
-type accessibilityPreferences struct {
-	DisplayDensity string
-	Contrast       string
-	ReducedMotion  bool
-	KeyboardFocus  string
-}
+type accessibilityPreferences = settingsmodel.AccessibilityPreferences
 
 type settingsFile struct {
-	Sync syncSettings `json:"sync,omitempty"`
+	Sync  syncSettings  `json:"sync,omitempty"`
+	Debug debugSettings `json:"debug,omitempty"`
 }
 
 type syncSettings struct {
@@ -42,6 +46,10 @@ type syncSettings struct {
 	DirectionDefault string `json:"directionDefault,omitempty"`
 }
 
+type debugSettings struct {
+	LogHeaderBounds bool `json:"logHeaderBounds,omitempty"`
+}
+
 type syncSettingsDraft struct {
 	SourceDefault    syncSourceMode
 	DirectionDefault syncDirection
@@ -50,6 +58,7 @@ type syncSettingsDraft struct {
 type settingsDraft struct {
 	Accessibility accessibilityPreferences
 	Sync          syncSettingsDraft
+	Debug         debugSettings
 }
 
 type legacySyncPreferences struct {
@@ -63,37 +72,23 @@ type choiceSpec struct {
 	Active bool
 }
 
+type focusAppearance struct {
+	BorderColor  color.NRGBA
+	OutlineColor color.NRGBA
+	OutlineWidth int
+	MinHeight    int
+}
+
 func defaultAccessibilityPreferences() accessibilityPreferences {
-	return accessibilityPreferences{
-		DisplayDensity: displayDensityForDenseLayout(true),
-		Contrast:       contrastStandard,
-		KeyboardFocus:  keyboardFocusStandard,
-	}
+	return settingsmodel.DefaultAccessibilityPreferences()
 }
 
 func displayDensityForDenseLayout(dense bool) string {
-	if dense {
-		return displayDensityDense
-	}
-	return displayDensityComfortable
+	return settingsmodel.DisplayDensityForDenseLayout(dense)
 }
 
 func normalizeAccessibilityPreferences(prefs accessibilityPreferences) accessibilityPreferences {
-	normalized := defaultAccessibilityPreferences()
-	switch prefs.DisplayDensity {
-	case displayDensityDense, displayDensityComfortable:
-		normalized.DisplayDensity = prefs.DisplayDensity
-	}
-	switch prefs.Contrast {
-	case contrastStandard, contrastHigh:
-		normalized.Contrast = prefs.Contrast
-	}
-	switch prefs.KeyboardFocus {
-	case keyboardFocusStandard, keyboardFocusProminent:
-		normalized.KeyboardFocus = prefs.KeyboardFocus
-	}
-	normalized.ReducedMotion = prefs.ReducedMotion
-	return normalized
+	return settingsmodel.NormalizeAccessibilityPreferences(prefs)
 }
 
 func (u *ui) applyAccessibilityPreferences(prefs accessibilityPreferences) {
@@ -102,6 +97,96 @@ func (u *ui) applyAccessibilityPreferences(prefs accessibilityPreferences) {
 	u.accessibilityPrefs = normalized
 }
 
+func fieldFocusAppearance(metric unit.Metric, prefs accessibilityPreferences, focused bool) focusAppearance {
+	prefs = normalizeAccessibilityPreferences(prefs)
+	appearance := focusAppearance{
+		BorderColor:  color.NRGBA{R: 202, G: 194, B: 180, A: 255},
+		OutlineColor: color.NRGBA{A: 0},
+		OutlineWidth: max(1, metric.Dp(unit.Dp(1))),
+		MinHeight:    metric.Dp(unit.Dp(44)),
+	}
+	if prefs.DisplayDensity == displayDensityComfortable {
+		appearance.MinHeight = metric.Dp(unit.Dp(52))
+	}
+	if prefs.Contrast == contrastHigh {
+		appearance.BorderColor = color.NRGBA{R: 108, G: 101, B: 90, A: 255}
+	}
+	if focused {
+		appearance.BorderColor = accentColor
+		appearance.OutlineColor = color.NRGBA{R: 28, G: 83, B: 63, A: 72}
+		appearance.OutlineWidth = max(2, metric.Dp(unit.Dp(2)))
+		if prefs.Contrast == contrastHigh {
+			appearance.BorderColor = color.NRGBA{R: 16, G: 60, B: 44, A: 255}
+			appearance.OutlineColor = color.NRGBA{R: 20, G: 74, B: 55, A: 124}
+		}
+		if prefs.KeyboardFocus == keyboardFocusProminent {
+			appearance.OutlineWidth = max(3, metric.Dp(unit.Dp(3)))
+			appearance.OutlineColor = color.NRGBA{R: 20, G: 74, B: 55, A: 148}
+		}
+	}
+	return appearance
+}
+
+func buttonFocusColors(prefs accessibilityPreferences, focused bool) (background color.NRGBA, text color.NRGBA) {
+	prefs = normalizeAccessibilityPreferences(prefs)
+	background = color.NRGBA{R: 231, G: 239, B: 235, A: 255}
+	text = accentColor
+	if prefs.Contrast == contrastHigh {
+		background = color.NRGBA{R: 225, G: 235, B: 230, A: 255}
+		text = color.NRGBA{R: 19, G: 57, B: 43, A: 255}
+	}
+	if focused {
+		background = color.NRGBA{R: 214, G: 229, B: 221, A: 255}
+		if prefs.Contrast == contrastHigh || prefs.KeyboardFocus == keyboardFocusProminent {
+			background = color.NRGBA{R: 202, G: 222, B: 212, A: 255}
+		}
+	}
+	return background, text
+}
+
+func (u *ui) accessibilityLabel(id focusID) string {
+	switch {
+	case id == focusSearch:
+		return "Search vault"
+	case strings.HasPrefix(string(id), "breadcrumb:"):
+		index := focusIndex(id)
+		crumbs := u.breadcrumbLabels()
+		if index >= 0 && index < len(crumbs) {
+			return fmt.Sprintf("Navigate to %s", crumbs[index])
+		}
+	case strings.HasPrefix(string(id), "list:"):
+		index := focusIndex(id)
+		if index >= 0 && index < len(u.visible) {
+			return fmt.Sprintf("Select entry %s", u.visible[index].Title)
+		}
+	case strings.HasPrefix(string(id), "detail:"):
+		name := strings.TrimPrefix(string(id), "detail:")
+		return fmt.Sprintf("Edit %s", detailFieldLabel(detailField(name)))
+	}
+	return ""
+}
+
+func drawFocusOutline(gtx layout.Context, appearance focusAppearance, size image.Point) layout.Dimensions {
+	if appearance.OutlineColor.A == 0 || appearance.OutlineWidth <= 0 {
+		return layout.Dimensions{Size: size}
+	}
+
+	width := appearance.OutlineWidth
+	paint.FillShape(gtx.Ops, appearance.OutlineColor, clip.Rect{Max: image.Pt(size.X, width)}.Op())
+	paint.FillShape(gtx.Ops, appearance.OutlineColor, clip.Rect{Min: image.Pt(0, size.Y-width), Max: image.Pt(size.X, size.Y)}.Op())
+	paint.FillShape(gtx.Ops, appearance.OutlineColor, clip.Rect{Max: image.Pt(width, size.Y)}.Op())
+	paint.FillShape(gtx.Ops, appearance.OutlineColor, clip.Rect{Min: image.Pt(size.X-width, 0), Max: image.Pt(size.X, size.Y)}.Op())
+	return layout.Dimensions{Size: size}
+}
+
+func (u *ui) isFocused(id focusID) bool {
+	return u.keyboardFocus == id
+}
+
+func detailFieldLabel(field detailField) string {
+	return editormodel.Label(field)
+}
+
 func (u *ui) loadSettingsDraft() {
 	u.settingsDraft = settingsDraft{
 		Accessibility: accessibilityPreferences{
@@ -114,7 +199,11 @@ func (u *ui) loadSettingsDraft() {
 			SourceDefault:    u.syncDefaultSourceMode,
 			DirectionDefault: u.syncDefaultDirection,
 		},
+		Debug: debugSettings{
+			LogHeaderBounds: u.debugLogHeaderBounds,
+		},
 	}
+	u.settingsDebugHeaderBounds.Value = u.settingsDraft.Debug.LogHeaderBounds
 }
 
 func (u *ui) saveSecuritySettingsAction() error {
@@ -136,9 +225,14 @@ func (u *ui) applySecuritySettingsLive() error {
 	if u.settingsDraft.Accessibility.DisplayDensity == displayDensityForDenseLayout(u.denseLayout) {
 		u.settingsDraft.Accessibility.DisplayDensity = displayDensityForDenseLayout(u.settingsDenseLayout.Value)
 	}
+	u.settingsDraft.Debug.LogHeaderBounds = u.settingsDebugHeaderBounds.Value
 	u.settingsDenseLayout.Value = u.settingsDraft.Accessibility.DisplayDensity == displayDensityDense
 	u.syncDefaultSourceMode = sanitizeSyncSourceMode(u.settingsDraft.Sync.SourceDefault)
 	u.syncDefaultDirection = sanitizeSyncDirection(u.settingsDraft.Sync.DirectionDefault)
+	u.debugLogHeaderBounds = u.settingsDraft.Debug.LogHeaderBounds
+	if !u.debugLogHeaderBounds {
+		u.lastHeaderBoundsLog = ""
+	}
 	u.applySettingsFormToPreferences()
 	u.applyAccessibilityPreferences(u.settingsDraft.Accessibility)
 	u.saveSettings()
@@ -157,6 +251,7 @@ func (u *ui) loadSettings() {
 			if json.Unmarshal(content, &settings) == nil {
 				u.syncDefaultSourceMode = sanitizeSyncSourceMode(syncSourceMode(settings.Sync.SourceDefault))
 				u.syncDefaultDirection = sanitizeSyncDirection(syncDirection(settings.Sync.DirectionDefault))
+				u.debugLogHeaderBounds = settings.Debug.LogHeaderBounds
 				return
 			}
 		}
@@ -193,6 +288,9 @@ func (u *ui) saveSettings() {
 			SourceDefault:    string(u.syncDefaultSourceMode),
 			DirectionDefault: string(u.syncDefaultDirection),
 		},
+		Debug: debugSettings{
+			LogHeaderBounds: u.debugLogHeaderBounds,
+		},
 	}, "", "  ")
 	if err != nil {
 		return
@@ -200,6 +298,44 @@ func (u *ui) saveSettings() {
 	_ = os.WriteFile(u.settingsPath, content, 0o600)
 }
 
+func (u *ui) maybeLogHeaderBounds(bounds headerButtonBounds) {
+	if !u.debugLogHeaderBounds {
+		return
+	}
+	line := bounds.logLine(u.mode)
+	if line == u.lastHeaderBoundsLog {
+		return
+	}
+	platform.LogInfo("KeePassGO", line)
+	u.lastHeaderBoundsLog = line
+}
+
+func (u *ui) maybeLogHeaderMenuToggle(menu string, open bool) {
+	if !u.debugLogHeaderBounds {
+		return
+	}
+	platform.LogInfo("KeePassGO", fmt.Sprintf("keepassgo header-menu-toggle menu=%s open=%t", menu, open))
+}
+
+func (u *ui) maybeLogHeaderMenuPlacement(menu string, surface headerlayout.DropdownSurface, placement headerlayout.DropdownPlacement) {
+	if !u.debugLogHeaderBounds {
+		return
+	}
+	platform.LogInfo("KeePassGO", fmt.Sprintf(
+		"keepassgo header-menu-placement menu=%s anchor=%d,%d origin=%d,%d size=%dx%d container=%d inset=%d,%d",
+		menu,
+		placement.Anchor.TriggerRightX,
+		placement.Anchor.TriggerBottomY,
+		placement.Origin.X,
+		placement.Origin.Y,
+		placement.Size.X,
+		placement.Size.Y,
+		surface.ContainerWidth,
+		surface.LeftInset,
+		surface.TopInset,
+	))
+}
+
 func (u *ui) showStatusMessage(message string) {
 	u.state.StatusMessage = message
 	if u.accessibilityPrefs.ReducedMotion {

internal/appui/settings/model.go

@@ -0,0 +1,50 @@
+package settings
+
+type AccessibilityPreferences struct {
+	DisplayDensity string
+	Contrast       string
+	ReducedMotion  bool
+	KeyboardFocus  string
+}
+
+const (
+	DisplayDensityDense       = "dense"
+	DisplayDensityComfortable = "comfortable"
+	ContrastStandard          = "standard"
+	ContrastHigh              = "high"
+	KeyboardFocusStandard     = "standard"
+	KeyboardFocusProminent    = "prominent"
+)
+
+func DefaultAccessibilityPreferences() AccessibilityPreferences {
+	return AccessibilityPreferences{
+		DisplayDensity: DisplayDensityDense,
+		Contrast:       ContrastStandard,
+		KeyboardFocus:  KeyboardFocusStandard,
+	}
+}
+
+func DisplayDensityForDenseLayout(dense bool) string {
+	if dense {
+		return DisplayDensityDense
+	}
+	return DisplayDensityComfortable
+}
+
+func NormalizeAccessibilityPreferences(prefs AccessibilityPreferences) AccessibilityPreferences {
+	normalized := DefaultAccessibilityPreferences()
+	switch prefs.DisplayDensity {
+	case DisplayDensityDense, DisplayDensityComfortable:
+		normalized.DisplayDensity = prefs.DisplayDensity
+	}
+	switch prefs.Contrast {
+	case ContrastStandard, ContrastHigh:
+		normalized.Contrast = prefs.Contrast
+	}
+	switch prefs.KeyboardFocus {
+	case KeyboardFocusStandard, KeyboardFocusProminent:
+		normalized.KeyboardFocus = prefs.KeyboardFocus
+	}
+	normalized.ReducedMotion = prefs.ReducedMotion
+	return normalized
+}

internal/appui/sync/model.go

@@ -0,0 +1,119 @@
+package sync
+
+import "git.julianfamily.org/keepassgo/internal/appstate"
+
+type SourceMode string
+
+const (
+	SourceLocal  SourceMode = "local"
+	SourceRemote SourceMode = "remote"
+)
+
+type Direction string
+
+const (
+	DirectionPull Direction = "pull"
+	DirectionPush Direction = "push"
+)
+
+type DialogPurpose string
+
+const (
+	DialogPurposeAdvanced    DialogPurpose = "advanced"
+	DialogPurposeRemoteSetup DialogPurpose = "remote-setup"
+)
+
+type MenuModel struct {
+	HasOpenVault           bool
+	HasSelectedBinding     bool
+	ShowSelectors          bool
+	ShowShare              bool
+	ShowSaveCurrentBinding bool
+	SavedBindingSummary    MenuBindingSummary
+	RemoteBaseURL          string
+	RemotePath             string
+	RemoteUsername         string
+	RemotePassword         string
+	SelectedVaultSyncMode  appstate.SyncMode
+}
+
+type MenuBindingSummary struct {
+	ProfileLabel    string
+	CredentialLabel string
+	SyncLabel       string
+	OK              bool
+}
+
+func (m MenuModel) SavedBindingHeading() string {
+	if !m.ShowSelectors {
+		return "Use this vault's saved remote sync target"
+	}
+	return "Use a saved remote profile from this vault"
+}
+
+func (m MenuModel) OpenSelectedButtonLabel() string {
+	if !m.ShowSelectors {
+		return "Use Remote Sync"
+	}
+	return "Open Saved Remote"
+}
+
+func (m MenuModel) ShowDirectRemoteSyncShortcut() bool {
+	return m.HasOpenVault && m.HasSelectedBinding
+}
+
+func (m MenuModel) DirectRemoteSyncShortcutLabel() string { return "Use Remote Sync" }
+
+func (m MenuModel) ShowRemoteSyncSettingsShortcut() bool {
+	return m.HasOpenVault && m.HasSelectedBinding
+}
+
+func (m MenuModel) RemoteSyncSettingsShortcutLabel() string { return "Remote Sync Settings" }
+
+func (m MenuModel) ShowRemoveRemoteSyncShortcut() bool { return m.ShowRemoteSyncSettingsShortcut() }
+
+func (m MenuModel) RemoveRemoteSyncShortcutLabel() string { return "Stop Using Remote Sync" }
+
+func (m MenuModel) ShowRemoteSyncSetupShortcut() bool {
+	return m.HasOpenVault && !m.HasSelectedBinding
+}
+
+func (m MenuModel) RemoteSyncSetupShortcutLabel() string { return "Set Up Remote Sync" }
+
+func (m MenuModel) ActionLabels() []string {
+	labels := []string{"Open Advanced Sync"}
+	if m.ShowRemoteSyncSetupShortcut() {
+		labels = append(labels, m.RemoteSyncSetupShortcutLabel())
+	}
+	if m.ShowDirectRemoteSyncShortcut() {
+		labels = append(labels, m.DirectRemoteSyncShortcutLabel())
+	}
+	if m.ShowRemoteSyncSettingsShortcut() {
+		labels = append(labels, m.RemoteSyncSettingsShortcutLabel())
+	}
+	if m.ShowRemoveRemoteSyncShortcut() {
+		labels = append(labels, m.RemoveRemoteSyncShortcutLabel())
+	}
+	return labels
+}
+
+func (m MenuModel) SaveCurrentRemoteBindingHeading() string {
+	return "Bind this local vault to the current remote target"
+}
+
+func (m MenuModel) SaveCurrentRemoteBindingButtonLabel() string { return "Save Remote In Vault" }
+
+func SummaryText(purpose DialogPurpose, source SourceMode, direction Direction) string {
+	if purpose == DialogPurposeRemoteSetup {
+		return "Push this local vault to a WebDAV target and save that target for future sync."
+	}
+	sourceLabel := "another local vault file"
+	if source == SourceRemote {
+		sourceLabel = "another WebDAV-backed vault"
+	}
+	action := "Pull changes from"
+	if direction == DirectionPush {
+		action = "Push the current vault into"
+	}
+	return action + " " + sourceLabel + "."
+}

internal/appui/sync_dialog.go

@@ -0,0 +1,223 @@
+package appui
+
+import (
+	"image/color"
+	"runtime"
+	"strings"
+
+	"gioui.org/layout"
+	"gioui.org/op/clip"
+	"gioui.org/op/paint"
+	"gioui.org/unit"
+	"gioui.org/widget"
+	"gioui.org/widget/material"
+)
+
+func (u *ui) syncDialog(gtx layout.Context) layout.Dimensions {
+	return layout.Stack{}.Layout(gtx,
+		layout.Expanded(func(gtx layout.Context) layout.Dimensions {
+			paint.FillShape(gtx.Ops, color.NRGBA{A: 90}, clip.Rect{Max: gtx.Constraints.Max}.Op())
+			return layout.Dimensions{Size: gtx.Constraints.Max}
+		}),
+		layout.Stacked(func(gtx layout.Context) layout.Dimensions {
+			return layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+				width := gtx.Dp(unit.Dp(620))
+				if width > gtx.Constraints.Max.X {
+					width = gtx.Constraints.Max.X - gtx.Dp(unit.Dp(24))
+				}
+				if width < 1 {
+					width = gtx.Constraints.Max.X
+				}
+				gtx.Constraints.Min.X = width
+				gtx.Constraints.Max.X = width
+				return card(gtx, u.syncDialogContent)
+			})
+		}),
+	)
+}
+
+func (u *ui) syncDialogContent(gtx layout.Context) layout.Dimensions {
+	matchingCredentials := u.matchingAdvancedSyncRemoteCredentialEntries()
+	if len(u.syncRemoteCredentialClicks) < len(matchingCredentials) {
+		u.syncRemoteCredentialClicks = make([]widget.Clickable, len(matchingCredentials))
+	}
+	return material.List(u.theme, &u.syncDialogList).Layout(gtx, 1, func(gtx layout.Context, _ int) layout.Dimensions {
+		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				lbl := material.Label(u.theme, unit.Sp(20), u.syncDialogTitle())
+				lbl.Color = accentColor
+				return lbl.Layout(gtx)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				lbl := material.Label(u.theme, unit.Sp(14), u.syncDialogDescription())
+				lbl.Color = mutedColor
+				return lbl.Layout(gtx)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(12)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				if !u.shouldShowSyncDirectionChoices() {
+					return layout.Dimensions{}
+				}
+				return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+					layout.Rigid(syncDialogSectionLabel(u.theme, "Direction")),
+					layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								return syncChoiceButton(gtx, u.theme, &u.showSyncPull, "Pull Into Current Vault", u.syncDirection == syncDirectionPull)
+							}),
+							layout.Rigid(layout.Spacer{Width: unit.Dp(6)}.Layout),
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								return syncChoiceButton(gtx, u.theme, &u.showSyncPush, "Push Current Vault Out", u.syncDirection == syncDirectionPush)
+							}),
+						)
+					}),
+				)
+			}),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				if !u.shouldShowSyncDirectionChoices() {
+					return layout.Dimensions{}
+				}
+				return layout.Spacer{Height: unit.Dp(12)}.Layout(gtx)
+			}),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				if !u.shouldShowSyncSourceChoices() {
+					return layout.Dimensions{}
+				}
+				return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+					layout.Rigid(syncDialogSectionLabel(u.theme, "Other Source")),
+					layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								return syncChoiceButton(gtx, u.theme, &u.showSyncLocal, "Local File", u.syncSourceMode == syncSourceLocal)
+							}),
+							layout.Rigid(layout.Spacer{Width: unit.Dp(6)}.Layout),
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								return syncChoiceButton(gtx, u.theme, &u.showSyncRemote, "Remote WebDAV", u.syncSourceMode == syncSourceRemote)
+							}),
+						)
+					}),
+				)
+			}),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				if !u.shouldShowSyncSourceChoices() {
+					return layout.Dimensions{}
+				}
+				return layout.Spacer{Height: unit.Dp(12)}.Layout(gtx)
+			}),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return syncDialogSummaryCard(gtx, u.theme, u.syncDialogPurpose, u.syncSourceMode, u.syncDirection)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(12)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				if u.syncSourceMode == syncSourceRemote {
+					children := []layout.FlexChild{
+						layout.Rigid(labeledEditorHelp(u.theme, "Remote Base URL", "WebDAV base URL for the other source.", &u.syncRemoteBaseURL, false)),
+						layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+						layout.Rigid(labeledEditorHelp(u.theme, "Remote Path", "Path to the other remote .kdbx file.", &u.syncRemotePath, false)),
+						layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+						layout.Rigid(labeledEditorHelp(u.theme, "Remote Username", "Username for the other WebDAV source.", &u.syncRemoteUsername, false)),
+						layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+						layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+							return u.syncPasswordField(gtx)
+						}),
+					}
+					if u.syncDialogPurpose == syncDialogPurposeRemoteSetup {
+						children = append(children,
+							layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								check := material.CheckBox(u.theme, &u.syncSetupAutomatic, "Sync automatically on open and save")
+								check.Color = accentColor
+								return check.Layout(gtx)
+							}),
+						)
+					}
+					if len(matchingCredentials) > 0 {
+						children = append(children,
+							layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
+							layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+								lbl := material.Label(u.theme, unit.Sp(11), "Matching vault credentials")
+								lbl.Color = mutedColor
+								return lbl.Layout(gtx)
+							}),
+						)
+						for i, entry := range matchingCredentials {
+							i := i
+							entry := entry
+							children = append(children,
+								layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
+								layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+									label := entry.Title
+									if strings.TrimSpace(entry.Username) != "" {
+										label += " · " + strings.TrimSpace(entry.Username)
+									}
+									selected := strings.TrimSpace(u.selectedSyncRemoteCredentialEntryID) == entry.ID
+									return recentSelectionCard(gtx, selected, func(gtx layout.Context) layout.Dimensions {
+										return u.syncRemoteCredentialClicks[i].Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+											lbl := material.Label(u.theme, unit.Sp(13), label)
+											lbl.Color = accentColor
+											return lbl.Layout(gtx)
+										})
+									})
+								}),
+							)
+						}
+					}
+					return layout.Flex{Axis: layout.Vertical}.Layout(gtx, children...)
+				}
+				if supportsDesktopFilePicker(runtime.GOOS) {
+					return selectorEditorHelp(u.theme, "Local Vault Path", "Choose the other local .kdbx file to synchronize with.", &u.syncLocalPath, &u.pickSyncLocalPath, "Choose File", false)(gtx)
+				}
+				return labeledEditorHelp(u.theme, "Local Vault Path", "Enter the shared-storage path to the other local .kdbx file to synchronize with.", &u.syncLocalPath, false)(gtx)
+			}),
+			layout.Rigid(layout.Spacer{Height: unit.Dp(14)}.Layout),
+			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+				return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						return tonedButton(gtx, u.theme, &u.runAdvancedSync, u.syncDialogConfirmButtonLabel())
+					}),
+					layout.Rigid(layout.Spacer{Width: unit.Dp(6)}.Layout),
+					layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+						return tonedButton(gtx, u.theme, &u.closeAdvancedSync, "Cancel")
+					}),
+				)
+			}),
+		)
+	})
+}
+
+func (u *ui) syncPasswordField(gtx layout.Context) layout.Dimensions {
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			lbl := material.Label(u.theme, unit.Sp(12), "REMOTE PASSWORD")
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			field := func(gtx layout.Context) layout.Dimensions {
+				editor := material.Editor(u.theme, &u.syncRemotePassword, "Remote Password")
+				editor.Color = u.theme.Palette.Fg
+				editor.HintColor = mutedColor
+				return layout.UniformInset(unit.Dp(10)).Layout(gtx, editor.Layout)
+			}
+			return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
+				layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
+					return u.outlinedFieldState(gtx, false, field)
+				}),
+				layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
+				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+					return u.inlinePasswordToggle(gtx, &u.toggleSyncPassword, u.showSyncPassword)
+				}),
+			)
+		}),
+		layout.Rigid(layout.Spacer{Height: unit.Dp(4)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			lbl := material.Label(u.theme, unit.Sp(12), "Password or app token for the other WebDAV source.")
+			lbl.Color = mutedColor
+			return lbl.Layout(gtx)
+		}),
+	)
+}

internal/autofillcache/cache.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 	"time"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 type Entry struct {

internal/autofillcache/cache_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 func TestBuildFiltersAndNormalizesEntries(t *testing.T) {

internal/clipboard/service.go

@@ -5,7 +5,7 @@ import (
 
 	systemclipboard "github.com/atotto/clipboard"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 var ErrUnsupportedTarget = errors.New("unsupported clipboard target")

internal/clipboard/service_test.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"testing"
 
-	"git.julianfamily.org/keepassgo/vault"
+	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
 func TestServiceCopiesUsernamePasswordAndURL(t *testing.T) {

internal/session/session.go

@@ -11,8 +11,8 @@ import (
 	"slices"
 	"strings"
 
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 )
 
 var (

internal/session/session_test.go

@@ -10,8 +10,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"git.julianfamily.org/keepassgo/vault"
-	"git.julianfamily.org/keepassgo/webdav"
+	"git.julianfamily.org/keepassgo/internal/vault"
+	"git.julianfamily.org/keepassgo/internal/webdav"
 	"github.com/tobischo/gokeepasslib/v3"
 	w "github.com/tobischo/gokeepasslib/v3/wrappers"
 )

internal/vault/security.go

@@ -13,10 +13,10 @@ type SecuritySettings struct {
 }
 
 const (
-	CipherAES256  = "aes256"
+	CipherAES256   = "aes256"
 	CipherChaCha20 = "chacha20"
-	KDFAES        = "aes-kdf"
-	KDFArgon2     = "argon2"
+	KDFAES         = "aes-kdf"
+	KDFArgon2      = "argon2"
 )
 
 func SupportedSecuritySettings() (ciphers []string, kdfs []string) {

packaging/archlinux/keepassgo-git/PKGBUILD.tmpl

@@ -41,16 +41,16 @@ build() {
   export GOFLAGS="-trimpath"
   local app_version
   app_version="$(git describe --tags --always --dirty)"
-  go build -ldflags "-X main.appVersion=${app_version}" -o keepassgo .
+  go build -ldflags "-X git.julianfamily.org/keepassgo/internal/appui.appVersion=${app_version}" -o keepassgo ./cmd/keepassgo
 }
 
 package() {
   cd "$(_repo_dir)"
 
   install -Dm755 keepassgo "${pkgdir}/usr/bin/keepassgo"
-  install -Dm644 assets/keepassgo-icon.png \
+  install -Dm644 internal/assets/keepassgo-icon.png \
     "${pkgdir}/usr/share/icons/hicolor/512x512/apps/keepassgo.png"
-  install -Dm644 assets/keepassgo-icon.svg \
+  install -Dm644 internal/assets/keepassgo-icon.svg \
     "${pkgdir}/usr/share/icons/hicolor/scalable/apps/keepassgo.svg"
   install -Dm644 packaging/archlinux/keepassgo-git/keepassgo.desktop \
     "${pkgdir}/usr/share/applications/keepassgo.desktop"

third_party/gioui-cmd/.builds/apple.yml

@@ -1,67 +0,0 @@
-# SPDX-License-Identifier: Unlicense OR MIT
-image: debian/testing
-packages:
- - clang
- - cmake
- - curl
- - autoconf
- - libxml2-dev
- - libssl-dev
- - libz-dev
- - llvm-dev # for cctools
- - uuid-dev ## for cctools
- - libplist-utils # for gogio
-sources:
- - https://git.sr.ht/~eliasnaur/gio-cmd
- - https://git.sr.ht/~eliasnaur/applesdks
- - https://git.sr.ht/~eliasnaur/giouiorg
- - https://github.com/tpoechtrager/cctools-port.git
- - https://github.com/tpoechtrager/apple-libtapi.git
- - https://github.com/mackyle/xar.git
-environment:
-   APPLE_TOOLCHAIN_ROOT: /home/build/appletools
-   PATH: /home/build/sdk/go/bin:/home/build/go/bin:/usr/bin
-tasks:
- - install_go: |
-     mkdir -p /home/build/sdk
-     curl -s https://dl.google.com/go/go1.19.8.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
- - prepare_toolchain: |
-     mkdir -p $APPLE_TOOLCHAIN_ROOT
-     cd $APPLE_TOOLCHAIN_ROOT
-     tar xJf /home/build/applesdks/applesdks.tar.xz
-     mkdir bin tools
-     cd bin
-     ln -s ../toolchain/bin/x86_64-apple-darwin19-ld ld
-     ln -s ../toolchain/bin/x86_64-apple-darwin19-ar ar
-     ln -s /home/build/cctools-port/cctools/misc/lipo lipo
-     ln -s ../tools/appletoolchain xcrun
-     ln -s /usr/bin/plistutil plutil
-     cd ../tools
-     ln -s appletoolchain clang-ios
-     ln -s appletoolchain clang-macos
- - install_appletoolchain: |
-     cd giouiorg
-     go build -o $APPLE_TOOLCHAIN_ROOT/tools ./cmd/appletoolchain
- - build_xar: |
-     cd xar/xar
-     ac_cv_lib_crypto_OpenSSL_add_all_ciphers=yes CC=clang ./autogen.sh --prefix=/usr
-     make
-     sudo make install
- - build_libtapi: |
-     cd apple-libtapi
-     INSTALLPREFIX=$APPLE_TOOLCHAIN_ROOT/libtapi ./build.sh
-     ./install.sh
- - build_cctools: |
-     cd cctools-port/cctools
-     ./configure --prefix $APPLE_TOOLCHAIN_ROOT/toolchain --with-libtapi=$APPLE_TOOLCHAIN_ROOT/libtapi --target=x86_64-apple-darwin19
-     make install
- - install_gogio: |
-     cd gio-cmd
-     go install ./gogio
- - test_ios_gogio: |
-     mkdir tmp
-     cd tmp
-     go mod init example.com
-     go get -d gioui.org/example/kitchen
-     export PATH=/home/build/appletools/bin:$PATH
-     gogio -target ios -o app.app gioui.org/example/kitchen

third_party/gioui-cmd/.builds/freebsd.yml

@@ -1,22 +0,0 @@
-# SPDX-License-Identifier: Unlicense OR MIT
-image: freebsd/13.x
-packages:
- - libX11
- - libxkbcommon
- - libXcursor
- - libXfixes
- - vulkan-headers
- - wayland
- - mesa-libs
- - xorg-vfbserver
-sources:
- - https://git.sr.ht/~eliasnaur/gio-cmd
-environment:
- PATH: /home/build/sdk/go/bin:/bin:/usr/local/bin:/usr/bin
-tasks:
- - install_go: |
-     mkdir -p /home/build/sdk
-     curl https://dl.google.com/go/go1.19.8.freebsd-amd64.tar.gz | tar -C /home/build/sdk -xzf -
- - test_cmd: |
-     cd gio-cmd
-     go test ./...

third_party/gioui-cmd/.builds/linux.yml

@@ -1,91 +0,0 @@
-# SPDX-License-Identifier: Unlicense OR MIT
-image: debian/bookworm
-packages:
- - curl
- - pkg-config
- - libwayland-dev
- - libx11-dev
- - libx11-xcb-dev
- - libxkbcommon-dev
- - libxkbcommon-x11-dev
- - libgles2-mesa-dev
- - libegl1-mesa-dev
- - libffi-dev
- - libvulkan-dev
- - libxcursor-dev
- - libxrandr-dev
- - libxinerama-dev
- - libxi-dev
- - libxxf86vm-dev
- - mesa-vulkan-drivers
- - wine
- - xvfb
- - xdotool
- - scrot
- - sway
- - grim
- - wine
- - unzip
-sources:
- - https://git.sr.ht/~eliasnaur/gio-cmd
-environment:
- PATH: /home/build/sdk/go/bin:/usr/bin:/home/build/go/bin:/home/build/android/tools/bin
- ANDROID_SDK_ROOT: /home/build/android
- android_sdk_tools_zip: sdk-tools-linux-3859397.zip
- android_ndk_zip: android-ndk-r20-linux-x86_64.zip
- github_mirror: git@github.com:gioui/gio-cmd
-secrets:
- - fdc570bf-87f4-4528-8aee-4d1711b1c86f
-tasks:
- - install_go: |
-     mkdir -p /home/build/sdk
-     curl -s https://dl.google.com/go/go1.19.8.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
- - check_gofmt: |
-     cd gio-cmd
-     test -z "$(gofmt -s -l .)"
- - check_sign_off: |
-     set +x -e
-     cd gio-cmd
-     for hash in $(git log -n 20 --format="%H"); do
-        message=$(git log -1 --format=%B $hash)
-        if [[ ! "$message" =~ "Signed-off-by: " ]]; then
-            echo "Missing 'Signed-off-by' in commit $hash"
-            exit 1
-        fi
-     done
- - mirror: |
-     # mirror to github
-     ssh-keyscan github.com > "$HOME"/.ssh/known_hosts && cd gio-cmd && git push --mirror "$github_mirror" || echo "failed mirroring"
- - install_chrome: |
-     curl -s https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
-     sudo sh -c 'echo "deb [arch=amd64] https://dl-ssl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
-     sudo apt-get -qq update
-     sudo apt-get -qq install -y google-chrome-stable
- - test: |
-     cd gio-cmd
-     go test ./...
-     go test -race ./...
- - install_jdk8: |
-     curl -so jdk.deb "https://cdn.azul.com/zulu/bin/zulu8.42.0.21-ca-jdk8.0.232-linux_amd64.deb"
-     sudo apt-get -qq install -y -f ./jdk.deb
- - install_android: |
-     mkdir android
-     cd android
-     curl -so sdk-tools.zip https://dl.google.com/android/repository/$android_sdk_tools_zip
-     unzip -q sdk-tools.zip
-     rm sdk-tools.zip
-     curl -so ndk.zip https://dl.google.com/android/repository/$android_ndk_zip
-     unzip -q ndk.zip
-     rm ndk.zip
-     mv android-ndk-* ndk-bundle
-     yes|sdkmanager --licenses
-     sdkmanager "platforms;android-31" "build-tools;32.0.0"
- - install_gogio: |
-     cd gio-cmd
-     go install ./gogio
- - test_android_gogio: |
-     mkdir tmp
-     cd tmp
-     go mod init example.com
-     go get -d gioui.org/example/kitchen
-     gogio -target android gioui.org/example/kitchen

third_party/gioui-cmd/.builds/openbsd.yml

@@ -1,18 +0,0 @@
-# SPDX-License-Identifier: Unlicense OR MIT
-image: openbsd/latest
-packages:
- - libxkbcommon
- - go
-sources:
- - https://git.sr.ht/~eliasnaur/gio-cmd
-environment:
- PATH: /home/build/sdk/go/bin:/bin:/usr/local/bin:/usr/bin
-tasks:
- - install_go: |
-     mkdir -p /home/build/sdk
-     curl https://dl.google.com/go/go1.19.8.src.tar.gz | tar -C /home/build/sdk -xzf -
-     cd /home/build/sdk/go/src
-     ./make.bash
- - test_cmd: |
-     cd gio-cmd
-     go test ./...

third_party/gioui-cmd/LICENSE

@@ -1,63 +0,0 @@
-This project is provided under the terms of the UNLICENSE or
-the MIT license denoted by the following SPDX identifier:
-
-SPDX-License-Identifier: Unlicense OR MIT
-
-You may use the project under the terms of either license.
-
-Both licenses are reproduced below.
-
-----
-The MIT License (MIT)
-
-Copyright (c) 2019 The Gio authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
----
-
-
-
----
-The UNLICENSE
-
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org/>
----

third_party/gioui-cmd/README.md

@@ -1,21 +0,0 @@
-# Gio Tools
-
-Tools for the [Gio project](https://gioui.org), most notably `gogio` for packaging Gio programs.
-
-[![builds.sr.ht status](https://builds.sr.ht/~eliasnaur/gio-cmd.svg)](https://builds.sr.ht/~eliasnaur/gio-cmd)
-
-## Issues
-
-File bugs and TODOs through the [issue tracker](https://todo.sr.ht/~eliasnaur/gio) or send an email
-to [~eliasnaur/gio@todo.sr.ht](mailto:~eliasnaur/gio@todo.sr.ht). For general discussion, use the
-mailing list: [~eliasnaur/gio@lists.sr.ht](mailto:~eliasnaur/gio@lists.sr.ht).
-
-## Contributing
-
-Post discussion to the [mailing list](https://lists.sr.ht/~eliasnaur/gio) and patches to
-[gio-patches](https://lists.sr.ht/~eliasnaur/gio-patches). No Sourcehut
-account is required and you can post without being subscribed.
-
-See the [contribution guide](https://gioui.org/doc/contribute) for more details.
-
-An [official GitHub mirror](https://github.com/gioui/gio-cmd) is available.

third_party/gioui-cmd/go.mod

@@ -1,28 +0,0 @@
-module gioui.org/cmd
-
-go 1.21
-
-require (
-	gioui.org v0.8.0
-	github.com/akavel/rsrc v0.10.1
-	github.com/chromedp/cdproto v0.0.0-20191114225735-6626966fbae4
-	github.com/chromedp/chromedp v0.5.2
-	golang.org/x/image v0.18.0
-	golang.org/x/sync v0.7.0
-	golang.org/x/text v0.16.0
-	golang.org/x/tools v0.23.0
-)
-
-require (
-	gioui.org/shader v1.0.8 // indirect
-	github.com/go-text/typesetting v0.2.1 // indirect
-	github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee // indirect
-	github.com/gobwas/pool v0.2.0 // indirect
-	github.com/gobwas/ws v1.0.2 // indirect
-	github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 // indirect
-	github.com/mailru/easyjson v0.7.0 // indirect
-	golang.org/x/exp v0.0.0-20240707233637-46b078467d37 // indirect
-	golang.org/x/exp/shiny v0.0.0-20240707233637-46b078467d37 // indirect
-	golang.org/x/mod v0.19.0 // indirect
-	golang.org/x/sys v0.22.0 // indirect
-)

third_party/gioui-cmd/go.sum

@@ -1,44 +0,0 @@
-eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d h1:ARo7NCVvN2NdhLlJE9xAbKweuI9L6UgfTbYb0YwPacY=
-eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d/go.mod h1:OYVuxibdk9OSLX8vAqydtRPP87PyTFcT9uH3MlEGBQA=
-gioui.org v0.8.0 h1:QV5p5JvsmSmGiIXVYOKn6d9YDliTfjtLlVf5J+BZ9Pg=
-gioui.org v0.8.0/go.mod h1:vEMmpxMOd/iwJhXvGVIzWEbxMWhnMQ9aByOGQdlQ8rc=
-gioui.org/cpu v0.0.0-20210808092351-bfe733dd3334/go.mod h1:A8M0Cn5o+vY5LTMlnRoK3O5kG+rH0kWfJjeKd9QpBmQ=
-gioui.org/shader v1.0.8 h1:6ks0o/A+b0ne7RzEqRZK5f4Gboz2CfG+mVliciy6+qA=
-gioui.org/shader v1.0.8/go.mod h1:mWdiME581d/kV7/iEhLmUgUK5iZ09XR5XpduXzbePVM=
-github.com/akavel/rsrc v0.10.1 h1:hCCPImjmFKVNGpeLZyTDRHEFC283DzyTXTo0cO0Rq9o=
-github.com/akavel/rsrc v0.10.1/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
-github.com/chromedp/cdproto v0.0.0-20191114225735-6626966fbae4 h1:QD3KxSJ59L2lxG6MXBjNHxiQO2RmxTQ3XcK+wO44WOg=
-github.com/chromedp/cdproto v0.0.0-20191114225735-6626966fbae4/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
-github.com/chromedp/chromedp v0.5.2 h1:W8xBXQuUnd2dZK0SN/lyVwsQM7KgW+kY5HGnntms194=
-github.com/chromedp/chromedp v0.5.2/go.mod h1:rsTo/xRo23KZZwFmWk2Ui79rBaVRRATCjLzNQlOFSiA=
-github.com/go-text/typesetting v0.2.1 h1:x0jMOGyO3d1qFAPI0j4GSsh7M0Q3Ypjzr4+CEVg82V8=
-github.com/go-text/typesetting v0.2.1/go.mod h1:mTOxEwasOFpAMBjEQDhdWRckoLLeI/+qrQeBCTGEt6M=
-github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066 h1:qCuYC+94v2xrb1PoS4NIDe7DGYtLnU2wWiQe9a1B1c0=
-github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066/go.mod h1:DDxDdQEnB70R8owOx3LVpEFvpMK9eeH1o2r0yZhFI9o=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 h1:V0an7KRw92wmJysvFvtqtKMAPmvS5O0jtB0nYo6t+gs=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08/go.mod h1:dFWs1zEqDjFtnBXsd1vPOZaLsESovai349994nHx3e0=
-github.com/mailru/easyjson v0.7.0 h1:aizVhC/NAAcKWb+5QsU1iNOZb4Yws5UO2I+aIprQITM=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-golang.org/x/exp v0.0.0-20240707233637-46b078467d37 h1:uLDX+AfeFCct3a2C7uIWBKMJIR3CJMhcgfrUAqjRK6w=
-golang.org/x/exp v0.0.0-20240707233637-46b078467d37/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
-golang.org/x/exp/shiny v0.0.0-20240707233637-46b078467d37 h1:SOSg7+sueresE4IbmmGM60GmlIys+zNX63d6/J4CMtU=
-golang.org/x/exp/shiny v0.0.0-20240707233637-46b078467d37/go.mod h1:3F+MieQB7dRYLTmnncoFbb1crS5lfQoTfDgQy6K4N0o=
-golang.org/x/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
-golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
-golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
-golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20191113165036-4c7a9d0fe056/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
-golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=

third_party/gioui-cmd/gogio/android_test.go

@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: Unlicense OR MIT
-
-package main_test
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"image"
-	"image/png"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-)
-
-type AndroidTestDriver struct {
-	driverBase
-
-	sdkDir  string
-	adbPath string
-}
-
-var rxAdbDevice = regexp.MustCompile(`(.*)\s+device$`)
-
-func (d *AndroidTestDriver) Start(path string) {
-	d.sdkDir = os.Getenv("ANDROID_SDK_ROOT")
-	if d.sdkDir == "" {
-		d.Skipf("Android SDK is required; set $ANDROID_SDK_ROOT")
-	}
-	d.adbPath = filepath.Join(d.sdkDir, "platform-tools", "adb")
-	if _, err := os.Stat(d.adbPath); os.IsNotExist(err) {
-		d.Skipf("adb not found")
-	}
-
-	devOut := bytes.TrimSpace(d.adb("devices"))
-	devices := rxAdbDevice.FindAllSubmatch(devOut, -1)
-	switch len(devices) {
-	case 0:
-		d.Skipf("no Android devices attached via adb; skipping")
-	case 1:
-	default:
-		d.Skipf("multiple Android devices attached via adb; skipping")
-	}
-
-	// If the device is attached but asleep, it's probably just charging.
-	// Don't use it; the screen needs to be on and unlocked for the test to
-	// work.
-	if !bytes.Contains(
-		d.adb("shell", "dumpsys", "power"),
-		[]byte(" mWakefulness=Awake"),
-	) {
-		d.Skipf("Android device isn't awake; skipping")
-	}
-
-	// First, build the app.
-	apk := filepath.Join(d.tempDir("gio-endtoend-android"), "e2e.apk")
-	d.gogio("-target=android", "-appid="+appid, "-o="+apk, path)
-
-	// Make sure the app isn't installed already, and try to uninstall it
-	// when we finish. Previous failed test runs might have left the app.
-	d.tryUninstall()
-	d.adb("install", apk)
-	d.Cleanup(d.tryUninstall)
-
-	// Force our e2e app to be fullscreen, so that the android system bar at
-	// the top doesn't mess with our screenshots.
-	// TODO(mvdan): is there a way to do this via gio, so that we don't need
-	// to set up a global Android setting via the shell?
-	d.adb("shell", "settings", "put", "global", "policy_control", "immersive.full="+appid)
-
-	// Make sure the app isn't already running.
-	d.adb("shell", "pm", "clear", appid)
-
-	// Start listening for log messages.
-	{
-		ctx, cancel := context.WithCancel(context.Background())
-		cmd := exec.CommandContext(ctx, d.adbPath,
-			"logcat",
-			"-s",       // suppress other logs
-			"-T1",      // don't show previous log messages
-			appid+":*", // show all logs from our gio app ID
-		)
-		output, err := cmd.StdoutPipe()
-		if err != nil {
-			d.Fatal(err)
-		}
-		cmd.Stderr = cmd.Stdout
-		d.output = output
-		if err := cmd.Start(); err != nil {
-			d.Fatal(err)
-		}
-		d.Cleanup(cancel)
-	}
-
-	// Start the app.
-	d.adb("shell", "monkey", "-p", appid, "1")
-
-	// Wait for the gio app to render.
-	d.waitForFrame()
-}
-
-func (d *AndroidTestDriver) Screenshot() image.Image {
-	out := d.adb("shell", "screencap", "-p")
-	img, err := png.Decode(bytes.NewReader(out))
-	if err != nil {
-		d.Fatal(err)
-	}
-	return img
-}
-
-func (d *AndroidTestDriver) tryUninstall() {
-	cmd := exec.Command(d.adbPath, "shell", "pm", "uninstall", appid)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		if bytes.Contains(out, []byte("Unknown package")) {
-			// The package is not installed. Don't log anything.
-			return
-		}
-		d.Logf("could not uninstall: %v\n%s", err, out)
-	}
-}
-
-func (d *AndroidTestDriver) adb(args ...interface{}) []byte {
-	strs := []string{}
-	for _, arg := range args {
-		strs = append(strs, fmt.Sprint(arg))
-	}
-	cmd := exec.Command(d.adbPath, strs...)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		d.Errorf("%s", out)
-		d.Fatal(err)
-	}
-	return out
-}
-
-func (d *AndroidTestDriver) Click(x, y int) {
-	d.adb("shell", "input", "tap", x, y)
-
-	// Wait for the gio app to render after this click.
-	d.waitForFrame()
-}

third_party/gioui-cmd/gogio/build_info.go

@@ -1,206 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-type buildInfo struct {
-	appID          string
-	archs          []string
-	ldflags        string
-	minsdk         int
-	targetsdk      int
-	name           string
-	pkgDir         string
-	pkgPath        string
-	iconPath       string
-	tags           string
-	target         string
-	version        Semver
-	key            string
-	password       string
-	notaryAppleID  string
-	notaryPassword string
-	notaryTeamID   string
-}
-
-type Semver struct {
-	Major, Minor, Patch int
-	VersionCode         uint32
-}
-
-func newBuildInfo(pkgPath string) (*buildInfo, error) {
-	pkgMetadata, err := getPkgMetadata(pkgPath)
-	if err != nil {
-		return nil, err
-	}
-	appID := getAppID(pkgMetadata)
-	appIcon := filepath.Join(pkgMetadata.Dir, "appicon.png")
-	if *iconPath != "" {
-		appIcon = *iconPath
-	}
-	appName := getPkgName(pkgMetadata)
-	if *name != "" {
-		appName = *name
-	}
-	ver, err := parseSemver(*version)
-	if err != nil {
-		return nil, err
-	}
-	bi := &buildInfo{
-		appID:          appID,
-		archs:          getArchs(),
-		ldflags:        getLdFlags(appID),
-		minsdk:         *minsdk,
-		targetsdk:      *targetsdk,
-		name:           appName,
-		pkgDir:         pkgMetadata.Dir,
-		pkgPath:        pkgPath,
-		iconPath:       appIcon,
-		tags:           *extraTags,
-		target:         *target,
-		version:        ver,
-		key:            *signKey,
-		password:       *signPass,
-		notaryAppleID:  *notaryID,
-		notaryPassword: *notaryPass,
-		notaryTeamID:   *notaryTeamID,
-	}
-	return bi, nil
-}
-
-// UppercaseName returns a string with its first rune in uppercase.
-func UppercaseName(name string) string {
-	ch, w := utf8.DecodeRuneInString(name)
-	return string(unicode.ToUpper(ch)) + name[w:]
-}
-
-func (s Semver) String() string {
-	return fmt.Sprintf("%d.%d.%d.%d", s.Major, s.Minor, s.Patch, s.VersionCode)
-}
-
-func parseSemver(v string) (Semver, error) {
-	var sv Semver
-	_, err := fmt.Sscanf(v, "%d.%d.%d.%d", &sv.Major, &sv.Minor, &sv.Patch, &sv.VersionCode)
-	if err != nil {
-		return Semver{}, fmt.Errorf("invalid semver: %q", v)
-	}
-	if sv.String() != v {
-		return Semver{}, fmt.Errorf("invalid semver: %q", v)
-	}
-	return sv, nil
-}
-
-func getArchs() []string {
-	if *archNames != "" {
-		return strings.Split(*archNames, ",")
-	}
-	switch *target {
-	case "js":
-		return []string{"wasm"}
-	case "ios", "tvos":
-		// Only 64-bit support.
-		return []string{"arm64", "amd64"}
-	case "android":
-		return []string{"arm", "arm64", "386", "amd64"}
-	case "windows":
-		goarch := os.Getenv("GOARCH")
-		if goarch == "" {
-			goarch = runtime.GOARCH
-		}
-		return []string{goarch}
-	case "macos":
-		return []string{"arm64", "amd64"}
-	default:
-		// TODO: Add flag tests.
-		panic("The target value has already been validated, this will never execute.")
-	}
-}
-
-func getLdFlags(appID string) string {
-	var ldflags []string
-	if extra := *extraLdflags; extra != "" {
-		ldflags = append(ldflags, strings.Split(extra, " ")...)
-	}
-	// Pass appID along, to be used for logging on platforms like Android.
-	ldflags = append(ldflags, fmt.Sprintf("-X gioui.org/app.ID=%s", appID))
-	// Support earlier Gio versions that had a separate app id recorded.
-	// TODO: delete this in the future.
-	ldflags = append(ldflags, fmt.Sprintf("-X gioui.org/app/internal/log.appID=%s", appID))
-	// Pass along all remaining arguments to the app.
-	if appArgs := flag.Args()[1:]; len(appArgs) > 0 {
-		ldflags = append(ldflags, fmt.Sprintf("-X gioui.org/app.extraArgs=%s", strings.Join(appArgs, "|")))
-	}
-	if m := *linkMode; m != "" {
-		ldflags = append(ldflags, "-linkmode="+m)
-	}
-	return strings.Join(ldflags, " ")
-}
-
-type packageMetadata struct {
-	PkgPath string
-	Dir     string
-}
-
-func getPkgMetadata(pkgPath string) (*packageMetadata, error) {
-	pkgImportPath, err := runCmd(exec.Command("go", "list", "-tags", *extraTags, "-f", "{{.ImportPath}}", pkgPath))
-	if err != nil {
-		return nil, err
-	}
-	pkgDir, err := runCmd(exec.Command("go", "list", "-tags", *extraTags, "-f", "{{.Dir}}", pkgPath))
-	if err != nil {
-		return nil, err
-	}
-	return &packageMetadata{
-		PkgPath: pkgImportPath,
-		Dir:     pkgDir,
-	}, nil
-}
-
-func getAppID(pkgMetadata *packageMetadata) string {
-	if *appID != "" {
-		return *appID
-	}
-	elems := strings.Split(pkgMetadata.PkgPath, "/")
-	domain := strings.Split(elems[0], ".")
-	name := ""
-	if len(elems) > 1 {
-		name = "." + elems[len(elems)-1]
-	}
-	if len(elems) < 2 && len(domain) < 2 {
-		name = "." + domain[0]
-		domain[0] = "localhost"
-	} else {
-		for i := 0; i < len(domain)/2; i++ {
-			opp := len(domain) - 1 - i
-			domain[i], domain[opp] = domain[opp], domain[i]
-		}
-	}
-
-	pkgDomain := strings.Join(domain, ".")
-	appid := []rune(pkgDomain + name)
-
-	// a Java-language-style package name may contain upper- and lower-case
-	// letters and underscores with individual parts separated by '.'.
-	// https://developer.android.com/guide/topics/manifest/manifest-element
-	for i, c := range appid {
-		if !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' ||
-			c == '_' || c == '.') {
-			appid[i] = '_'
-		}
-	}
-	return string(appid)
-}
-
-func getPkgName(pkgMetadata *packageMetadata) string {
-	return path.Base(pkgMetadata.PkgPath)
-}