fix(opencode): derive boot sidebar active account from routing mode and preserve live session state (#128)

Boot seeding, quota-only refreshes, and command paths no longer clobber
the sidebar activeId written by a live routing session. Routing-authoritative
writes are distinguished from display-only writes; the serialized write chain
re-reads the file before merging, and cross-process writes are guarded by an
mkdir directory lock (atomic rename-claim eviction, jittered retry, file-based
ownerId release). On lock-budget exhaustion against an active contender the
write is skipped — never performed unlocked. The commit path is fenced:
ownership is re-verified adjacent to the rename and again after it; on
detected post-rename loss, one bounded locked repair republishes only the
frame's routing-authoritative fields into the successor's fresh state. Boot
resolves preserved routing only after the asynchronous account-storage load
completes, so a peer's authoritative publish during the load cannot be
overwritten by a pre-load snapshot. The residual window is a process freeze
exactly between the final ownership stat and the rename — accepted for a
display-only file whose frames self-heal.

Author: iceteaSA

packages/opencode/src/index.ts

@@ -145,6 +145,8 @@ import type {
 import { getRpcDir } from './rpc/rpc-dir.ts'
 import { type RpcServerHandle, startRpcServer } from './rpc/rpc-server.ts'
 import {
+  getInitialSidebarRoutingTestHooks,
+  getSidebarState,
   getSidebarStateFile,
   type SidebarState,
   setSidebarState,
@@ -173,6 +175,115 @@ const CONCURRENT_MAIN_REFRESH_POLL_BASE_MS = 200
 const MIN_MAIN_REFRESH_BEFORE_EXPIRY_MINUTES = 240
 const DEFAULT_MAIN_REFRESH_BEFORE_EXPIRY_MINUTES =
   MIN_MAIN_REFRESH_BEFORE_EXPIRY_MINUTES
+const SIDEBAR_ROUTING_FRESH_MS = 10 * 60 * 1000
+
+function hasEnabledOAuthAccount(
+  storage: AccountStorage | null,
+  activeId: string,
+) {
+  return (storage?.accounts ?? []).some(
+    (account) =>
+      account.id === activeId &&
+      account.enabled !== false &&
+      isOAuthAccount(account),
+  )
+}
+
+function deriveSidebarRouting(
+  storage: AccountStorage | null,
+): Pick<SidebarState, 'activeId' | 'route'> {
+  const firstFallback = (storage?.accounts ?? []).find(
+    (account): account is OAuthAccount =>
+      account.enabled !== false && isOAuthAccount(account),
+  )
+  if (getRoutingMode(storage) === 'fallback-first' && firstFallback) {
+    return { activeId: firstFallback.id, route: 'fallback-first' }
+  }
+  return { activeId: 'main', route: 'main' }
+}
+
+function validateSidebarRouting(
+  routing: Pick<SidebarState, 'activeId' | 'route'> | undefined,
+  storage: AccountStorage | null,
+): Pick<SidebarState, 'activeId' | 'route'> {
+  if (
+    routing?.activeId === 'main' ||
+    (routing?.activeId && hasEnabledOAuthAccount(storage, routing.activeId))
+  ) {
+    return routing
+  }
+  return deriveSidebarRouting(storage)
+}
+
+function resolveLoadedSidebarRouting(
+  existing: SidebarState,
+  freshStorage: AccountStorage | null,
+  fallbackRouting?: Pick<SidebarState, 'activeId' | 'route'>,
+): Pick<SidebarState, 'activeId' | 'route'> {
+  const existingAge = Date.now() - existing.lastUpdated
+  if (
+    !existing.activeId ||
+    existingAge < 0 ||
+    existingAge > SIDEBAR_ROUTING_FRESH_MS
+  ) {
+    return validateSidebarRouting(fallbackRouting, freshStorage)
+  }
+
+  return validateSidebarRouting(existing, freshStorage)
+}
+
+async function resolveFreshSidebarRouting(
+  existing: SidebarState,
+  loadFreshStorage: () => Promise<AccountStorage | null>,
+  fallbackRouting?: Pick<SidebarState, 'activeId' | 'route'>,
+): Promise<{
+  activeId: string | undefined
+  route: string
+  freshStorage: AccountStorage | null
+}> {
+  let freshStorage: AccountStorage | null
+  try {
+    freshStorage = await loadFreshStorage()
+  } catch (error) {
+    logger.warn('sidebar', 'account storage reload failed; routing preserved', {
+      message: error instanceof Error ? error.message : String(error),
+    })
+    const preservedRouting = existing.activeId
+      ? { activeId: existing.activeId, route: existing.route }
+      : (fallbackRouting ?? { activeId: 'main', route: 'main' })
+    return { ...preservedRouting, freshStorage: null }
+  }
+
+  return {
+    ...resolveLoadedSidebarRouting(existing, freshStorage, fallbackRouting),
+    freshStorage,
+  }
+}
+
+async function resolveInitialSidebarRouting(
+  accountStoragePath: string,
+): Promise<{
+  activeId: string | undefined
+  route: string
+  freshStorage: AccountStorage | null
+}> {
+  await getInitialSidebarRoutingTestHooks()?.beforeStorageLoad?.()
+  let freshStorage: AccountStorage | null
+  try {
+    freshStorage = await loadAccounts(accountStoragePath)
+  } catch {
+    return { activeId: 'main', route: 'main', freshStorage: null }
+  } finally {
+    await getInitialSidebarRoutingTestHooks()?.afterStorageLoad?.()
+  }
+
+  await getInitialSidebarRoutingTestHooks()?.beforeSidebarRead?.()
+  const existing = await getSidebarState()
+  return {
+    ...resolveLoadedSidebarRouting(existing, freshStorage),
+    freshStorage,
+  }
+}
 
 /**
  * Format the user-facing 429 message for a killswitch block. When the block
@@ -906,16 +1017,18 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
     NonNullable<SidebarState['fableRecoveries']>[number]
   >()
 
-  function writeSidebarState(
+  interface SidebarStateInput {
+    activeId?: string
+    route: string
+    mainAccessToken?: string
+    mainRefreshToken?: string
+    routingAuthoritative?: boolean
+  }
+
+  function buildSidebarState(
     storage: Awaited<ReturnType<typeof loadAccounts>>,
-    options: {
-      activeId?: string
-      route: string
-      mainAccessToken?: string
-      mainRefreshToken?: string
-    },
-  ) {
-    lastSidebarRouting = { activeId: options.activeId, route: options.route }
+    options: SidebarStateInput,
+  ): SidebarState {
     quotaManager.updateStorage(storage)
     quotaManager.seedMainFromStorage(storage, options.mainAccessToken)
     quotaManager.seedFallbacksFromAccounts(
@@ -924,7 +1037,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
     const mainEntry = quotaManager.getMain(options.mainAccessToken)
     const lastApiError = quotaManager.getLastApiError()
     const mainRefreshError = storage?.refresh?.mainLastRefreshError
-    const state: SidebarState = {
+    return {
       main: {
         quota: mainEntry?.quota ?? null,
         quotaBackedOff: quotaManager.isBackedOff(),
@@ -995,7 +1108,43 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
           : undefined,
       lastUpdated: Date.now(),
     }
-    return setSidebarState(state, sidebarStateFile).catch((error) =>
+  }
+
+  function writeSidebarState(
+    storage: Awaited<ReturnType<typeof loadAccounts>>,
+    options: SidebarStateInput,
+  ) {
+    const routingAuthoritative = options.routingAuthoritative !== false
+    if (routingAuthoritative) {
+      lastSidebarRouting = { activeId: options.activeId, route: options.route }
+    }
+    const state = buildSidebarState(storage, options)
+    return setSidebarState(state, sidebarStateFile, {
+      routingAuthoritative,
+      resolvePreservedRouting: routingAuthoritative
+        ? undefined
+        : async (current) => {
+            const preservedRouting = await resolveFreshSidebarRouting(
+              current,
+              () => loadAccounts(accountStoragePath),
+              { activeId: state.activeId, route: state.route },
+            )
+            return {
+              activeId: preservedRouting.activeId,
+              route: preservedRouting.route,
+              state: buildSidebarState(preservedRouting.freshStorage, {
+                ...options,
+                activeId: preservedRouting.activeId,
+                route: preservedRouting.route,
+              }),
+            }
+          },
+      onRoutingResolved: routingAuthoritative
+        ? undefined
+        : (routing) => {
+            lastSidebarRouting = routing
+          },
+    }).catch((error) =>
       logger.warn('sidebar', 'state write failed', {
         error: error instanceof Error ? error.message : String(error),
       }),
@@ -1023,6 +1172,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
       route: lastSidebarRouting.route,
       mainAccessToken: access,
       mainRefreshToken: refresh,
+      routingAuthoritative: false,
     })
   }
 
@@ -1172,6 +1322,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
           route: lastSidebarRouting.route,
           mainAccessToken: auth.access,
           mainRefreshToken: auth.refresh,
+          routingAuthoritative: false,
         })
       } catch {
         // auth not yet available — sidebar will refresh on next request
@@ -1202,6 +1353,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
       route: lastSidebarRouting.route,
       mainAccessToken: auth.access,
       mainRefreshToken: auth.refresh,
+      routingAuthoritative: false,
     })
 
     if (!desktopText || isTuiConnected(notice.sessionId)) return
@@ -1231,6 +1383,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
       route: lastSidebarRouting.route,
       mainAccessToken: auth.access,
       mainRefreshToken: auth.refresh,
+      routingAuthoritative: false,
     })
   }
 
@@ -1584,6 +1737,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
             route: lastSidebarRouting.route,
             mainAccessToken: auth.access,
             mainRefreshToken: auth.refresh,
+            routingAuthoritative: false,
           })
         } catch {
           // auth not yet available — sidebar will refresh on next request
@@ -1941,10 +2095,11 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
           ? await latestGetAuth().catch(() => undefined)
           : undefined
         writeSidebarState(cmdStorage, {
-          activeId: 'main',
-          route: 'main',
+          activeId: lastSidebarRouting.activeId,
+          route: lastSidebarRouting.route,
           mainAccessToken: cmdAuth?.access,
           mainRefreshToken: cmdAuth?.refresh,
+          routingAuthoritative: false,
         })
       }
       if (isTuiConnected(input.sessionID)) {
@@ -2360,11 +2515,14 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
           quotaManager.seedFallbacksFromAccounts(
             (initialStorage?.accounts ?? []).filter(isOAuthAccount),
           )
-          writeSidebarState(initialStorage, {
-            activeId: 'main',
-            route: 'main',
+          const initialSidebarRouting =
+            await resolveInitialSidebarRouting(accountStoragePath)
+          await writeSidebarState(initialSidebarRouting.freshStorage, {
+            activeId: initialSidebarRouting.activeId,
+            route: initialSidebarRouting.route,
             mainAccessToken: auth.access,
             mainRefreshToken: auth.refresh,
+            routingAuthoritative: false,
           })
 
           function isReplayableRequest(