kaizenai 0.2.2 → 0.4.0

package/src/server/ws-router.ts

@@ -1,709 +0,0 @@
-import type { ServerWebSocket } from "bun"
-import { DEFAULT_PROVIDER_SETTINGS, PROTOCOL_VERSION, getSelectableProviders, isProviderSelectable, type AgentProvider } from "../shared/types"
-import type { ClientEnvelope, ServerEnvelope, SubscriptionTopic } from "../shared/protocol"
-import { isClientEnvelope } from "../shared/protocol"
-import type { AgentCoordinator } from "./agent"
-import type { DiscoveredProject } from "./discovery"
-import { EventStore } from "./event-store"
-import { openExternal, openUrl } from "./external-open"
-import { GitManager } from "./git-manager"
-import { KeybindingsManager } from "./keybindings"
-import { ProviderSettingsManager } from "./provider-settings"
-import { ThemeSettingsManager } from "./theme-settings"
-import { listProjectDirectories, requireProjectDirectory, ensureProjectDirectory } from "./paths"
-import { importProjectHistory } from "./recovery"
-import { TerminalManager } from "./terminal-manager"
-import type { UpdateManager } from "./update-manager"
-import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
-import { refreshClaudeRateLimitFromCli } from "./usage/claude-usage"
-import { importCursorUsageFromCurl, refreshCursorUsage, signInToCursorWithBrowser } from "./usage/cursor-usage"
-
-export interface ClientState {
-  subscriptions: Map<string, SubscriptionTopic>
-}
-
-const PROVIDER_USAGE_POLL_INTERVAL_MS = 30 * 60 * 1000
-const PROVIDER_USAGE_POLL_MAX_INTERVAL_MS = 31 * 60 * 1000
-
-interface CreateWsRouterArgs {
-  store: EventStore
-  agent: AgentCoordinator
-  terminals: TerminalManager
-  git: GitManager
-  keybindings: KeybindingsManager
-  providerSettings?: ProviderSettingsManager
-  themeSettings: ThemeSettingsManager
-  refreshDiscovery: () => Promise<DiscoveredProject[]>
-  getDiscoveredProjects: () => DiscoveredProject[]
-  machineDisplayName: string
-  updateManager: UpdateManager | null
-  providerUsagePollIntervalMs?: number
-  refreshProviderUsage?: (provider?: AgentProvider, force?: boolean) => Promise<void>
-  openUrlCommand?: typeof openUrl
-}
-
-function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
-  ws.send(JSON.stringify(message))
-}
-
-export function createWsRouter({
-  store,
-  agent,
-  terminals,
-  git,
-  keybindings,
-  providerSettings,
-  themeSettings,
-  refreshDiscovery,
-  getDiscoveredProjects,
-  machineDisplayName,
-  updateManager,
-  providerUsagePollIntervalMs,
-  refreshProviderUsage = async (provider, force) => {
-    const selectableProviders = getSelectableProviders(providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS).map((entry) => entry.id)
-    if (((!provider && selectableProviders.includes("claude")) || provider === "claude") && selectableProviders.includes("claude")) {
-      await refreshClaudeRateLimitFromCli(store.dataDir, undefined, force).then(() => {})
-    }
-    if (((!provider && selectableProviders.includes("cursor")) || provider === "cursor") && selectableProviders.includes("cursor")) {
-      await refreshCursorUsage(store.dataDir, undefined, force).then(() => {})
-    }
-  },
-  openUrlCommand = openUrl,
-}: CreateWsRouterArgs) {
-  const sockets = new Set<ServerWebSocket<ClientState>>()
-  let providerUsageRefreshInFlight: Promise<void> | null = null
-  let providerUsagePollTimer: Timer | null = null
-
-  function createEnvelope(id: string, topic: SubscriptionTopic): ServerEnvelope {
-    if (topic.type === "sidebar") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "sidebar",
-          data: deriveSidebarData(store.state, agent.getActiveStatuses(), agent.getProviderUsage()),
-        },
-      }
-    }
-
-    if (topic.type === "local-projects") {
-      const discoveredProjects = getDiscoveredProjects()
-      const data = deriveLocalProjectsSnapshot(store.state, discoveredProjects, machineDisplayName)
-
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "local-projects",
-          data,
-        },
-      }
-    }
-
-    if (topic.type === "keybindings") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "keybindings",
-          data: keybindings.getSnapshot(),
-        },
-      }
-    }
-
-    if (topic.type === "theme-settings") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "theme-settings",
-          data: themeSettings.getSnapshot(),
-        },
-      }
-    }
-
-    if (topic.type === "provider-settings") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "provider-settings",
-          data: providerSettings?.getSnapshot() ?? {
-            settings: DEFAULT_PROVIDER_SETTINGS,
-            warning: null,
-            filePathDisplay: "",
-          },
-        },
-      }
-    }
-
-    if (topic.type === "update") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "update",
-          data: updateManager?.getSnapshot() ?? {
-            currentVersion: "unknown",
-            latestVersion: null,
-            status: "idle",
-            updateAvailable: false,
-            lastCheckedAt: null,
-            error: null,
-            installAction: "restart",
-          },
-        },
-      }
-    }
-
-    if (topic.type === "terminal") {
-      return {
-        v: PROTOCOL_VERSION,
-        type: "snapshot",
-        id,
-        snapshot: {
-          type: "terminal",
-          data: terminals.getSnapshot(topic.terminalId),
-        },
-      }
-    }
-
-    return {
-      v: PROTOCOL_VERSION,
-      type: "snapshot",
-      id,
-      snapshot: {
-        type: "chat",
-        data: (() => {
-          return deriveChatSnapshot(
-            store.state,
-            agent.getActiveStatuses(),
-            topic.chatId,
-            (chatId) => store.getMessages(chatId),
-            agent.getChatPendingTool(topic.chatId),
-            agent.getLiveUsage(topic.chatId),
-            providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS
-          )
-        })(),
-      },
-    }
-  }
-
-  function pushSnapshots(ws: ServerWebSocket<ClientState>) {
-    for (const [id, topic] of ws.data.subscriptions.entries()) {
-      send(ws, createEnvelope(id, topic))
-    }
-  }
-
-  function broadcastSnapshots() {
-    for (const ws of sockets) {
-      pushSnapshots(ws)
-    }
-  }
-
-  function broadcastSidebarSnapshots() {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "sidebar") continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-  }
-
-  function hasSidebarSubscribers() {
-    for (const ws of sockets) {
-      for (const topic of ws.data.subscriptions.values()) {
-        if (topic.type === "sidebar") return true
-      }
-    }
-    return false
-  }
-
-  function pushTerminalSnapshot(terminalId: string) {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "terminal" || topic.terminalId !== terminalId) continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-  }
-
-  function pushTerminalEvent(terminalId: string, event: Extract<ServerEnvelope, { type: "event" }>["event"]) {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "terminal" || topic.terminalId !== terminalId) continue
-        send(ws, {
-          v: PROTOCOL_VERSION,
-          type: "event",
-          id,
-          event,
-        })
-      }
-    }
-  }
-
-  const disposeTerminalEvents = terminals.onEvent((event) => {
-    pushTerminalEvent(event.terminalId, event)
-  })
-
-  const disposeKeybindingEvents = keybindings.onChange(() => {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "keybindings") continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-  })
-
-  const disposeThemeSettingsEvents = themeSettings.onChange(() => {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "theme-settings") continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-  })
-
-  const disposeProviderSettingsEvents = providerSettings?.onChange(() => {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "provider-settings") continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-    broadcastSnapshots()
-  }) ?? (() => {})
-
-  const disposeUpdateEvents = updateManager?.onChange(() => {
-    for (const ws of sockets) {
-      for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "update") continue
-        send(ws, createEnvelope(id, topic))
-      }
-    }
-  }) ?? (() => {})
-
-  async function runProviderUsagePoll() {
-    if (!hasSidebarSubscribers()) return
-    if (!providerUsageRefreshInFlight) {
-      providerUsageRefreshInFlight = refreshProviderUsage().finally(() => {
-        providerUsageRefreshInFlight = null
-      })
-    }
-    await providerUsageRefreshInFlight
-    broadcastSidebarSnapshots()
-  }
-
-  function nextProviderUsagePollDelayMs() {
-    if (typeof providerUsagePollIntervalMs === "number") {
-      return providerUsagePollIntervalMs
-    }
-
-    return Math.floor(Math.random() * (PROVIDER_USAGE_POLL_MAX_INTERVAL_MS - PROVIDER_USAGE_POLL_INTERVAL_MS + 1))
-      + PROVIDER_USAGE_POLL_INTERVAL_MS
-  }
-
-  function scheduleProviderUsagePoll() {
-    if (providerUsagePollTimer) {
-      clearTimeout(providerUsagePollTimer)
-    }
-
-    providerUsagePollTimer = setTimeout(() => {
-      void runProviderUsagePoll().finally(() => {
-        scheduleProviderUsagePoll()
-      })
-    }, nextProviderUsagePollDelayMs())
-  }
-
-  scheduleProviderUsagePoll()
-
-  async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
-    const { command, id } = message
-    try {
-      switch (command.type) {
-        case "system.ping": {
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          return
-        }
-        case "system.listDirectory": {
-          const directory = await listProjectDirectories(command.localPath)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: directory })
-          return
-        }
-        case "update.check": {
-          const snapshot = updateManager
-            ? await updateManager.checkForUpdates({ force: command.force })
-            : {
-                currentVersion: "unknown",
-                latestVersion: null,
-                status: "error",
-                updateAvailable: false,
-                lastCheckedAt: Date.now(),
-                error: "Update manager unavailable.",
-                installAction: "restart",
-              }
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
-          return
-        }
-        case "update.install": {
-          if (!updateManager) {
-            throw new Error("Update manager unavailable.")
-          }
-          const result = await updateManager.installUpdate()
-          send(ws, {
-            v: PROTOCOL_VERSION,
-            type: "ack",
-            id,
-            result,
-          })
-          return
-        }
-        case "settings.readKeybindings": {
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: keybindings.getSnapshot() })
-          return
-        }
-        case "settings.writeKeybindings": {
-          const snapshot = await keybindings.write(command.bindings)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
-          return
-        }
-        case "settings.writeThemeSettings": {
-          const snapshot = await themeSettings.write(command.settings)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
-          return
-        }
-        case "settings.writeProviderSettings": {
-          if (!providerSettings) throw new Error("Provider settings unavailable.")
-          const snapshot = await providerSettings.write(command.settings)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
-          return
-        }
-        case "project.open": {
-          await requireProjectDirectory(command.localPath)
-          await store.unhideProject(command.localPath)
-          const project = await store.openProject(command.localPath)
-          const imported = await importProjectHistory({
-            store,
-            projectId: project.id,
-            repoKey: project.repoKey,
-            localPath: project.localPath,
-            worktreePaths: project.worktreePaths,
-          })
-          await store.reconcileProjectFeatureState(project.id)
-          await refreshDiscovery()
-          send(ws, {
-            v: PROTOCOL_VERSION,
-            type: "ack",
-            id,
-            result: {
-              projectId: project.id,
-              chatId: imported.newestChatId,
-              importedChats: imported.importedChats,
-            },
-          })
-          break
-        }
-        case "project.create": {
-          await ensureProjectDirectory(command.localPath)
-          await store.unhideProject(command.localPath)
-          const project = await store.openProject(command.localPath, command.title)
-          const imported = await importProjectHistory({
-            store,
-            projectId: project.id,
-            repoKey: project.repoKey,
-            localPath: project.localPath,
-            worktreePaths: project.worktreePaths,
-          })
-          await store.reconcileProjectFeatureState(project.id)
-          await refreshDiscovery()
-          send(ws, {
-            v: PROTOCOL_VERSION,
-            type: "ack",
-            id,
-            result: {
-              projectId: project.id,
-              chatId: imported.newestChatId,
-              importedChats: imported.importedChats,
-            },
-          })
-          break
-        }
-        case "project.remove": {
-          const project = store.getProject(command.projectId)
-          for (const chat of store.listChatsByProject(command.projectId)) {
-            await agent.cancel(chat.id)
-          }
-          if (project) {
-            for (const worktreePath of project.worktreePaths) {
-              terminals.closeByCwd(worktreePath)
-            }
-            await store.hideProject(project.localPath)
-          }
-          await refreshDiscovery()
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "project.setBrowserState": {
-          await store.setProjectBrowserState(command.projectId, command.browserState)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "project.setGeneralChatsBrowserState": {
-          await store.setProjectGeneralChatsBrowserState(command.projectId, command.browserState)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "project.hide": {
-          const existingProject = store.listProjects().find((project) => project.localPath === command.localPath)
-          if (existingProject) {
-            for (const chat of store.listChatsByProject(existingProject.id)) {
-              await agent.cancel(chat.id)
-            }
-            for (const worktreePath of existingProject.worktreePaths) {
-              terminals.closeByCwd(worktreePath)
-            }
-          }
-          await store.hideProject(command.localPath)
-          await refreshDiscovery()
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "project.setProjectMetadataDirectoryCommitMode": {
-          const localPath = command.projectId
-            ? store.getProject(command.projectId)?.localPath
-            : command.localPath
-          if (!localPath) {
-            throw new Error("Project not found")
-          }
-          await git.setProjectMetadataDirectoryCommitMode(localPath, command.commitProjectMetadata)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "system.openExternal": {
-          await openExternal(command)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "system.openUrl": {
-          await openUrlCommand(command)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "provider.refreshUsage": {
-          if (command.provider && !isProviderSelectable(command.provider, providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS)) {
-            throw new Error(`${command.provider} is inactive.`)
-          }
-          await refreshProviderUsage(command.provider, true)
-          broadcastSidebarSnapshots()
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "provider.browserLogin": {
-          if (command.provider !== "cursor") {
-            throw new Error(`Browser login is not supported for provider: ${command.provider}`)
-          }
-          const result = await signInToCursorWithBrowser(store.dataDir)
-          broadcastSidebarSnapshots()
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          break
-        }
-        case "provider.importUsageCurl": {
-          if (command.provider !== "cursor") {
-            throw new Error(`cURL import is not supported for provider: ${command.provider}`)
-          }
-          const result = await importCursorUsageFromCurl(store.dataDir, command.curlCommand)
-          broadcastSidebarSnapshots()
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          break
-        }
-        case "feature.create": {
-          const feature = await store.createFeature(command.projectId, command.title, command.description ?? "")
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { featureId: feature.id } })
-          break
-        }
-        case "feature.rename": {
-          await store.renameFeature(command.featureId, command.title)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "feature.setBrowserState": {
-          await store.setFeatureBrowserState(command.featureId, command.browserState)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "feature.setStage": {
-          await store.setFeatureStage(command.featureId, command.stage)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "feature.reorder": {
-          await store.reorderFeatures(command.projectId, command.orderedFeatureIds)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "feature.delete": {
-          await store.deleteFeature(command.featureId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "chat.create": {
-          const chat = await store.createChat(command.projectId, command.featureId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { chatId: chat.id } })
-          break
-        }
-        case "chat.setFeature": {
-          await store.setChatFeature(command.chatId, command.featureId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "chat.rename": {
-          await store.renameChat(command.chatId, command.title)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "chat.delete": {
-          await agent.cancel(command.chatId)
-          await store.deleteChat(command.chatId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "chat.send": {
-          if (command.provider && !isProviderSelectable(command.provider, providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS)) {
-            throw new Error(`${command.provider} is inactive.`)
-          }
-          const result = await agent.send(command)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          break
-        }
-        case "chat.cancel": {
-          await agent.cancel(command.chatId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "chat.respondTool": {
-          await agent.respondTool(command)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          break
-        }
-        case "terminal.create": {
-          const project = store.getProject(command.projectId)
-          if (!project) {
-            throw new Error("Project not found")
-          }
-          const snapshot = terminals.createTerminal({
-            projectPath: project.localPath,
-            terminalId: command.terminalId,
-            cols: command.cols,
-            rows: command.rows,
-            scrollback: command.scrollback,
-          })
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
-          return
-        }
-        case "terminal.input": {
-          terminals.write(command.terminalId, command.data)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          return
-        }
-        case "terminal.resize": {
-          terminals.resize(command.terminalId, command.cols, command.rows)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          return
-        }
-        case "terminal.close": {
-          terminals.close(command.terminalId)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
-          pushTerminalSnapshot(command.terminalId)
-          return
-        }
-        case "git.getBranches": {
-          const project = store.getProject(command.projectId)
-          if (!project) throw new Error("Project not found")
-          const result = await git.getBranches(project.localPath)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          return
-        }
-        case "git.switchBranch": {
-          const project = store.getProject(command.projectId)
-          if (!project) throw new Error("Project not found")
-          const result = await git.switchBranch(project.localPath, command.branchName)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          return
-        }
-        case "git.createBranch": {
-          const project = store.getProject(command.projectId)
-          if (!project) throw new Error("Project not found")
-          const result = await git.createBranch(project.localPath, command.branchName, command.checkout)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          return
-        }
-      }
-
-      broadcastSnapshots()
-    } catch (error) {
-      const messageText = error instanceof Error ? error.message : String(error)
-      send(ws, { v: PROTOCOL_VERSION, type: "error", id, message: messageText })
-    }
-  }
-
-  return {
-    handleOpen(ws: ServerWebSocket<ClientState>) {
-      sockets.add(ws)
-    },
-    handleClose(ws: ServerWebSocket<ClientState>) {
-      sockets.delete(ws)
-    },
-    broadcastSnapshots,
-    handleMessage(ws: ServerWebSocket<ClientState>, raw: string | Buffer | ArrayBuffer | Uint8Array) {
-      let parsed: unknown
-      try {
-        parsed = JSON.parse(String(raw))
-      } catch {
-        send(ws, { v: PROTOCOL_VERSION, type: "error", message: "Invalid JSON" })
-        return
-      }
-
-      if (!isClientEnvelope(parsed)) {
-        send(ws, { v: PROTOCOL_VERSION, type: "error", message: "Invalid envelope" })
-        return
-      }
-
-      if (parsed.type === "subscribe") {
-        ws.data.subscriptions.set(parsed.id, parsed.topic)
-        if (parsed.topic.type === "local-projects") {
-          void refreshDiscovery().then(() => {
-            if (ws.data.subscriptions.has(parsed.id)) {
-              send(ws, createEnvelope(parsed.id, parsed.topic))
-            }
-          })
-        }
-        send(ws, createEnvelope(parsed.id, parsed.topic))
-        return
-      }
-
-      if (parsed.type === "unsubscribe") {
-        ws.data.subscriptions.delete(parsed.id)
-        send(ws, { v: PROTOCOL_VERSION, type: "ack", id: parsed.id })
-        return
-      }
-
-      void handleCommand(ws, parsed)
-    },
-    dispose() {
-      if (providerUsagePollTimer) {
-        clearTimeout(providerUsagePollTimer)
-      }
-      disposeTerminalEvents()
-      disposeKeybindingEvents()
-      disposeProviderSettingsEvents()
-      disposeThemeSettingsEvents()
-      disposeUpdateEvents()
-    },
-  }
-}