perf(daemon): persistent backend + content cache — hot path 1s→300ms

Pre-connect MprBackend at per-MPR daemon startup (--mpr-path flag).
Reuse the connection across requests via noOpConnectBackend wrapper that
overrides Connect/Disconnect/IsConnected as no-ops. The concrete
*MprBackend is embedded (not the interface) so duck-type checks
(microflowsRepoProvider etc.) resolve correctly — fixing a nil-panic
crash on show microflows in persistent mode.

Reader.contentCache: in-memory store for mxunit file bytes, enabled via
Reader.EnableContentCache() and MprBackend.EnableContentCache(). First
request populates the cache; subsequent requests skip all file I/O.
Cache is cleared (map reset, not nil) by InvalidateCache() so writes
invalidate without disabling the cache.

Add daemonRequestMu to serialize concurrent requests: SQLite is
single-writer and os.Chdir is process-global.

Result (minimal.mpr, Windows):
  cold start: ~25s (daemon spawn + SQLite open + buildUnitCache)
  hot path:   ~300ms (was ~1000ms) — mainly launcher process startup

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: engalar

cmd/mxcli-launcher/mpr_daemon.go

@@ -51,6 +51,7 @@ func (e *Env) ensureMPRDaemon(mprAbsPath string) (string, error) {
 		e.daemonBinaryPath(),
 		"--serve", sockPath,
 		"--idle-timeout", mprDaemonIdleTimeout.String(),
+		"--mpr-path", mprAbsPath,
 	)
 	cmd.Stdout = nil
 	cmd.Stderr = nil

cmd/mxcli/daemon_backend.go

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+
+	mprbackend "github.com/mendixlabs/mxcli/mdl/backend/mpr"
+)
+
+// persistentDaemonBackend holds the pre-connected backend for the daemon process.
+// Non-nil only in --serve + --mpr-path mode (per-MPR daemon).
+// Kept as concrete type so duck-type checks (microflowsRepoProvider etc.) work.
+// Never modified after main() sets it.
+var persistentDaemonBackend *mprbackend.MprBackend
+
+// daemonRequestMu serializes command execution on the persistent backend.
+// SQLite is single-writer; os.Chdir is process-global — both require serialization.
+var daemonRequestMu sync.Mutex
+
+// noOpConnectBackend wraps *mprbackend.MprBackend (not the interface) so that
+// duck-type checks like b.(microflowsRepoProvider) still succeed — the concrete
+// type's Microflows() / Nanoflows() / etc. methods are promoted and visible.
+// Only Connect / Disconnect / IsConnected are overridden to be no-ops so the
+// persistent SQLite connection is never closed between daemon requests.
+type noOpConnectBackend struct{ *mprbackend.MprBackend }
+
+func (n *noOpConnectBackend) Connect(string) error { return nil }
+func (n *noOpConnectBackend) Disconnect() error    { return nil }
+func (n *noOpConnectBackend) IsConnected() bool    { return true }
+
+// openPersistentBackend opens an MprBackend and returns it as FullBackend.
+// Called once at daemon startup; the connection lives for the daemon's lifetime.
+// EnableContentCache is called so mxunit file reads are cached in memory:
+// the first request populates the cache; subsequent requests skip all file I/O.
+func openPersistentBackend(mprPath string) (*mprbackend.MprBackend, error) {
+	b := mprbackend.New()
+	if err := b.Connect(mprPath); err != nil {
+		return nil, fmt.Errorf("pre-connect %s: %w", mprPath, err)
+	}
+	b.EnableContentCache()
+	return b, nil
+}
+
+// extractMPRPath scans args for "--mpr-path <path>" or "--mpr-path=<path>".
+func extractMPRPath(args []string) string {
+	const flag = "--mpr-path"
+	for i, a := range args {
+		if a == flag && i+1 < len(args) {
+			return args[i+1]
+		}
+		if strings.HasPrefix(a, flag+"=") {
+			return a[len(flag)+1:]
+		}
+	}
+	return ""
+}
+
+// closePersistentBackend is called (deferred) when the daemon exits.
+func closePersistentBackend() {
+	if persistentDaemonBackend != nil {
+		_ = persistentDaemonBackend.Disconnect()
+		// Also log to stderr so it's visible in diagnostic output.
+		fmt.Fprintln(os.Stderr, "mxcli-daemon: persistent backend closed")
+	}
+}

cmd/mxcli/daemon_server.go

@@ -70,6 +70,10 @@ func runDaemonServer(sockPath string, idleTimeout time.Duration, onReady func())
 			mu.Lock()
 			lastReq = time.Now()
 			mu.Unlock()
+			// Serialize command execution: SQLite is single-writer and os.Chdir
+			// is process-global, so concurrent requests would corrupt state.
+			daemonRequestMu.Lock()
+			defer daemonRequestMu.Unlock()
 			handleConn(conn)
 		}()
 	}

cmd/mxcli/main.go

@@ -32,6 +32,16 @@ func main() {
 	// Intercept --serve <socket-path> BEFORE cobra parses flags.
 	if sockPath := extractServeSocket(os.Args[1:]); sockPath != "" {
 		idleTimeout := extractIdleTimeout(os.Args[1:])
+		// Per-MPR daemon: pre-connect and hold the backend for the process lifetime.
+		if mprPath := extractMPRPath(os.Args[1:]); mprPath != "" {
+			b, err := openPersistentBackend(mprPath)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "mxcli-daemon: %v\n", err)
+				os.Exit(1)
+			}
+			persistentDaemonBackend = b
+			defer closePersistentBackend()
+		}
 		runDaemonServer(sockPath, idleTimeout, nil)
 		return
 	}
@@ -185,7 +195,18 @@ func resolveFormat(cmd *cobra.Command, defaultFormat string) string {
 func newLoggedExecutor(mode string, out io.Writer) (*executor.Executor, *diaglog.Logger) {
 	logger := diaglog.Init(version, mode, globalVerboseLevel)
 	exec := executor.New(out)
-	exec.SetBackendFactory(func() backend.FullBackend { return mprbackend.New() })
+	if persistentDaemonBackend != nil {
+		// Per-MPR daemon: wrap the concrete *MprBackend (not the interface) so
+		// duck-type checks (microflowsRepoProvider etc.) still resolve correctly,
+		// while Connect/Disconnect are no-ops to keep the SQLite connection and
+		// Reader.unitCache alive across requests.
+		pb := persistentDaemonBackend
+		exec.SetBackendFactory(func() backend.FullBackend {
+			return &noOpConnectBackend{pb}
+		})
+	} else {
+		exec.SetBackendFactory(func() backend.FullBackend { return mprbackend.New() })
+	}
 	exec.SetLogger(logger)
 	if globalJSONFlag {
 		exec.SetFormat(executor.FormatJSON)

mdl/backend/mpr/backend.go

@@ -122,6 +122,15 @@ func (b *MprBackend) Disconnect() error {
 func (b *MprBackend) IsConnected() bool { return b.reader != nil }
 func (b *MprBackend) Path() string      { return b.path }
 
+// EnableContentCache activates in-memory caching of mxunit file contents.
+// Call once after Connect when the backend will be held persistently across
+// multiple requests (per-MPR daemon mode). The cache is cleared on any write.
+func (b *MprBackend) EnableContentCache() {
+	if b.reader != nil {
+		b.reader.EnableContentCache()
+	}
+}
+
 func (b *MprBackend) Version() types.MPRVersion { return types.MPRVersion(b.msdkReader.Version()) }
 func (b *MprBackend) ProjectVersion() *types.ProjectVersion {
 	return convertProjectVersionFromMsdk(b.msdkReader.ProjectVersion())

modelsdk/mpr/reader.go

@@ -40,6 +40,12 @@ type Reader struct {
 	unitCache      []cachedUnit
 	unitCacheValid bool
 
+	// contentCache stores raw BSON bytes per unit ID (MPR v2 only).
+	// Populated on first read; survives across requests when the Reader is
+	// held persistently by the per-MPR daemon. Cleared by InvalidateCache.
+	// nil means caching is disabled (zero cost on the normal per-request path).
+	contentCache map[string][]byte
+
 	// overlay holds unit bytes injected by BufferedUnitStore so that reads
 	// within the same import file see buffered (uncommitted) writes.
 	// nil means no overlay is active — zero cost on the normal path.

modelsdk/mpr/reader_units.go

@@ -188,30 +188,61 @@ func (r *Reader) buildUnitCache() error {
 	return nil
 }
 
-// InvalidateCache marks the unit cache as invalid.
+// InvalidateCache marks the unit cache as invalid and clears content cache entries.
 // Should be called after any write operation.
 func (r *Reader) InvalidateCache() {
 	r.unitCacheValid = false
+	// Clear content cache entries but keep the map non-nil so caching stays active.
+	// If contentCache is nil (per-request mode), remain disabled.
+	if r.contentCache != nil {
+		clear(r.contentCache)
+	}
+}
+
+// EnableContentCache activates the in-memory content cache for this reader.
+// Call once after Connect in persistent daemon mode. The cache survives across
+// requests; InvalidateCache empties it (but keeps caching active) on writes.
+func (r *Reader) EnableContentCache() {
+	if r.contentCache == nil {
+		r.contentCache = make(map[string][]byte)
+	}
 }
 
 // readMprContents reads content from the mprcontents folder for v2 format.
 // The path is: mprcontents/XX/YY/UUID.mxunit where XX and YY are first two chars of UUID.
+//
+// When r.contentCache is non-nil (persistent daemon mode), the result is cached
+// in memory so subsequent reads of the same unit skip the file I/O entirely.
+// The cache is invalidated by InvalidateCache (called after every write).
 func (r *Reader) readMprContents(unitUUID string) ([]byte, error) {
 	if len(unitUUID) < 4 {
 		return nil, fmt.Errorf("invalid unit UUID: %s", unitUUID)
 	}
 
+	// Fast path: content cache hit (persistent daemon only).
+	if r.contentCache != nil {
+		if data, ok := r.contentCache[unitUUID]; ok {
+			return data, nil
+		}
+	}
+
 	// Build path: mprcontents/XX/YY/UUID.mxunit
-	// UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-	// First two chars are positions 0-1, next two are positions 2-3
 	path := filepath.Join(
 		r.contentsDir,
 		unitUUID[0:2],
 		unitUUID[2:4],
 		unitUUID+".mxunit",
 	)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
 
-	return os.ReadFile(path)
+	// Populate cache (persistent daemon only).
+	if r.contentCache != nil {
+		r.contentCache[unitUUID] = data
+	}
+	return data, nil
 }
 
 // getTypeFromContents extracts the $Type field from BSON contents.