Speed up devices list by using local cache for lastUsedTime

.claude/settings.json

@@ -1,4 +1,11 @@
 {
+  "pluginConfigs": {
+    "typescript-lsp@claude-plugins-official": {
+      "options": {
+        "tsserver.path": "shared/node_modules/typescript/bin/tsserver"
+      }
+    }
+  },
   "permissions": {
     "allow": [
       "Bash(yarn lint)",

go/engine/device_history.go

@@ -141,15 +141,26 @@ func (e *DeviceHistory) loadDevices(m libkb.MetaContext, user *libkb.User) error
 		if err != nil {
 			return err
 		}
+		// If any active device is absent from the cache (e.g. a paper key
+		// provisioned after the last secrets sync), force a network sync so
+		// every device gets a real LastUsedTime on this first load.
+		for _, detail := range e.devices {
+			if detail.RevokedAt != nil {
+				continue
+			}
+			if _, ok := lastUsedTimes[detail.Device.DeviceID]; !ok {
+				lastUsedTimes, err = e.getLastUsedTimesForce(m)
+				if err != nil {
+					return err
+				}
+				break
+			}
+		}
 		for i := range e.devices {
 			detail := &e.devices[i]
 			lastUsedTime, ok := lastUsedTimes[detail.Device.DeviceID]
 			if !ok {
-				if detail.RevokedAt != nil {
-					// The server only provides last used times for active devices.
-					continue
-				}
-				return fmt.Errorf("Failed to load last used time for device %s", detail.Device.DeviceID)
+				continue
 			}
 			detail.Device.LastUsedTime = keybase1.TimeFromSeconds(lastUsedTime.Unix())
 		}
@@ -183,10 +194,18 @@ func (e *DeviceHistory) getLastUsedTimes(m libkb.MetaContext) (ret map[keybase1.
 	defer m.Trace("DeviceHistory#getLastUsedTimes", &err)()
 	var devs libkb.DeviceKeyMap
 	var ss *libkb.SecretSyncer
-	ss, err = m.ActiveDevice().SyncSecretsForce(m)
+	// Use local cache to avoid a blocking network call on every page load.
+	// Falls back to a forced network sync when the cache is empty.
+	ss, err = m.ActiveDevice().SyncSecretsFromCache(m)
 	if err != nil {
 		return nil, err
 	}
+	if !ss.HasDevices() {
+		ss, err = m.ActiveDevice().SyncSecretsForce(m)
+		if err != nil {
+			return nil, err
+		}
+	}
 	devs, err = ss.ActiveDevices(libkb.AllDeviceTypes)
 	if err != nil {
 		return nil, err
@@ -197,3 +216,20 @@ func (e *DeviceHistory) getLastUsedTimes(m libkb.MetaContext) (ret map[keybase1.
 	}
 	return ret, nil
 }
+
+func (e *DeviceHistory) getLastUsedTimesForce(m libkb.MetaContext) (ret map[keybase1.DeviceID]time.Time, err error) {
+	defer m.Trace("DeviceHistory#getLastUsedTimesForce", &err)()
+	ss, err := m.ActiveDevice().SyncSecretsForce(m)
+	if err != nil {
+		return nil, err
+	}
+	devs, err := ss.ActiveDevices(libkb.AllDeviceTypes)
+	if err != nil {
+		return nil, err
+	}
+	ret = map[keybase1.DeviceID]time.Time{}
+	for deviceID, dev := range devs {
+		ret[deviceID] = time.Unix(dev.LastUsedTime, 0)
+	}
+	return ret, nil
+}

go/libkb/active_device.go

@@ -600,6 +600,24 @@ func (a *ActiveDevice) SyncSecretsForce(m MetaContext) (ret *SecretSyncer, err e
 	return a.SyncSecretsForUID(m, zed, true /* force */)
 }
 
+func (a *ActiveDevice) SyncSecretsFromCache(m MetaContext) (ret *SecretSyncer, err error) {
+	defer m.Trace("ActiveDevice#SyncSecretsFromCache", &err)()
+	a.RLock()
+	s := a.secretSyncer
+	uid := a.uv.Uid
+	a.RUnlock()
+	if s == nil {
+		return nil, fmt.Errorf("Can't sync secrets: nil secret syncer")
+	}
+	if uid.IsNil() {
+		return nil, fmt.Errorf("can't run secret syncer without a UID")
+	}
+	if err = RunSyncerCached(m, s, uid); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
 func (a *ActiveDevice) CheckForUsername(m MetaContext, n NormalizedUsername, suppressNetworkErrors bool) (err error) {
 	a.RLock()
 	uid := a.uv.Uid

go/libkb/notify_router.go

@@ -40,6 +40,7 @@ type NotifyListener interface {
 	SimpleFSArchiveStatusChanged(status keybase1.SimpleFSArchiveStatus)
 	PaperKeyCached(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID)
 	KeyfamilyChanged(uid keybase1.UID)
+	DeviceHistoryChanged()
 	NewChatActivity(uid keybase1.UID, activity chat1.ChatActivity, source chat1.ChatActivitySource)
 	NewChatKBFSFileEditActivity(uid keybase1.UID, activity chat1.ChatActivity)
 	ChatIdentifyUpdate(update keybase1.CanonicalTLFNameAndIDWithBreaks)
@@ -154,6 +155,7 @@ func (n *NoopNotifyListener) SimpleFSArchiveStatusChanged(status keybase1.Simple
 func (n *NoopNotifyListener) PaperKeyCached(uid keybase1.UID, encKID keybase1.KID, sigKID keybase1.KID) {
 }
 func (n *NoopNotifyListener) KeyfamilyChanged(uid keybase1.UID) {}
+func (n *NoopNotifyListener) DeviceHistoryChanged()             {}
 func (n *NoopNotifyListener) NewChatActivity(uid keybase1.UID, activity chat1.ChatActivity,
 	source chat1.ChatActivitySource) {
 }
@@ -2049,6 +2051,30 @@ func (n *NotifyRouter) HandleKeyfamilyChanged(uid keybase1.UID) {
 	n.G().Log.Debug("- Sent keyfamily changed notification")
 }
 
+// HandleDeviceHistoryChanged is called whenever the device history list is refreshed.
+func (n *NotifyRouter) HandleDeviceHistoryChanged() {
+	if n == nil {
+		return
+	}
+
+	n.G().Log.Debug("+ Sending device history changed notification")
+	n.cm.ApplyAll(func(id ConnectionID, xp rpc.Transporter) bool {
+		if n.getNotificationChannels(id).Devicehistory {
+			go func() {
+				_ = (keybase1.NotifyDeviceHistoryClient{
+					Cli: rpc.NewClient(xp, NewContextifiedErrorUnwrapper(n.G()), nil),
+				}).DeviceHistoryChanged(context.Background())
+			}()
+		}
+		return true
+	})
+
+	n.runListeners(func(listener NotifyListener) {
+		listener.DeviceHistoryChanged()
+	})
+	n.G().Log.Debug("- Sent device history changed notification")
+}
+
 // HandleServiceShutdown is called whenever the service shuts down.
 func (n *NotifyRouter) HandleServiceShutdown() {
 	if n == nil {

go/service/device.go

@@ -7,6 +7,8 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"sync"
+	"time"
 
 	"github.com/keybase/client/go/engine"
 	"github.com/keybase/client/go/gregor"
@@ -15,11 +17,15 @@ import (
 	"github.com/keybase/go-framed-msgpack-rpc/rpc"
 )
 
+const deviceSyncTTL = 30 * time.Second
+
 // DeviceHandler is the RPC handler for the device interface.
 type DeviceHandler struct {
 	*BaseHandler
 	libkb.Contextified
-	gregor *gregorHandler
+	gregor         *gregorHandler
+	syncMu         sync.Mutex
+	lastDeviceSync time.Time
 }
 
 // NewDeviceHandler creates a DeviceHandler for the xp transport.
@@ -57,9 +63,33 @@ func (h *DeviceHandler) DeviceHistoryList(nctx context.Context, sessionID int) (
 	if err := engine.RunEngine2(m, eng); err != nil {
 		return nil, err
 	}
+	// After returning cached data quickly, refresh secrets in the background
+	// so lastUsedTime values stay current. Fires deviceHistoryChanged when done
+	// so the UI reloads. Debounced to avoid redundant syncs.
+	h.syncMu.Lock()
+	defer h.syncMu.Unlock()
+	if time.Since(h.lastDeviceSync) > deviceSyncTTL {
+		h.lastDeviceSync = time.Now()
+		go h.backgroundSyncDevices()
+	}
 	return eng.Devices(), nil
 }
 
+func (h *DeviceHandler) backgroundSyncDevices() {
+	mctx := libkb.NewMetaContext(context.Background(), h.G())
+	if _, err := mctx.ActiveDevice().SyncSecretsForce(mctx); err != nil {
+		mctx.Debug("DeviceHandler#backgroundSyncDevices error: %v", err)
+		// Reset so the next UI refresh can retry instead of waiting out the TTL.
+		h.syncMu.Lock()
+		defer h.syncMu.Unlock()
+		h.lastDeviceSync = time.Time{}
+		return
+	}
+	if nr := h.G().NotifyRouter; nr != nil {
+		nr.HandleDeviceHistoryChanged()
+	}
+}
+
 // DeviceAdd starts the kex2 device provisioning on the
 // provisioner (device X/C1)
 func (h *DeviceHandler) DeviceAdd(c context.Context, sessionID int) error {

protocol/avdl/keybase1/notify_ctl.avdl

@@ -42,6 +42,7 @@ protocol notifyCtl {
     // and can skip updates for things not currently on the screen.
     boolean allowChatNotifySkips;
     boolean chatarchive;
+    boolean devicehistory;
   }
 
   void setNotifications(NotificationChannels channels);

protocol/avdl/keybase1/notify_device_history.avdl

@@ -0,0 +1,4 @@
+@namespace("keybase.1")
+protocol NotifyDeviceHistory {
+  void deviceHistoryChanged() oneway;
+}

protocol/bin/enabled-calls.json

@@ -154,6 +154,7 @@
   "keybase.1.NotifyAudit.boxAuditError": {"incoming":true},
   "keybase.1.NotifyAudit.rootAuditError": {"incoming":true},
   "keybase.1.NotifyBadges.badgeState": {"incoming":true},
+  "keybase.1.NotifyDeviceHistory.deviceHistoryChanged": {"incoming":true},
   "keybase.1.NotifyEmailAddress.emailAddressVerified": {"custom":true},
   "keybase.1.NotifyEmailAddress.emailsChanged": {"custom":true},
   "keybase.1.NotifyFS.FSActivity": {"incoming":true},

shared/constants/init/shared.tsx

@@ -365,7 +365,7 @@ export const onEngineConnected = () => {
             allowChatNotifySkips: true, app: true, audit: true, badges: true, chat: true, chatarchive: true,
             chatattachments: true, chatdev: false, chatemoji: false, chatemojicross: false, chatkbfsedits: false,
             deviceclone: false, ephemeral: false, favorites: false, featuredBots: false, kbfs: true, kbfsdesktop: !isMobile,
-            kbfslegacy: false, kbfsrequest: false, kbfssubscription: true, keyfamily: false, notifysimplefs: true,
+            devicehistory: true, kbfslegacy: false, kbfsrequest: false, kbfssubscription: true, keyfamily: false, notifysimplefs: true,
             paperkeys: false, pgp: true, reachability: true, runtimestats: true, saltpack: true, service: true, session: true,
             team: true, teambot: false, tracking: true, users: true, wallet: false,
           },

shared/constants/rpc/index.tsx

@@ -74,6 +74,7 @@ type Keybase1IncomingAction =
   'keybase.1.NotifyAudit.boxAuditError' |
   'keybase.1.NotifyAudit.rootAuditError' |
   'keybase.1.NotifyBadges.badgeState' |
+  'keybase.1.NotifyDeviceHistory.deviceHistoryChanged' |
   'keybase.1.NotifyFS.FSActivity' |
   'keybase.1.NotifySession.loggedOut' |
   'keybase.1.NotifyTracking.trackingChanged' |