kaizenai 0.1.0

package/src/server/ws-router.ts

@@ -0,0 +1,717 @@
+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": {
+          // Reuse an existing empty chat for this project+feature if one exists
+          const existingChats = store.listChatsByProject(command.projectId)
+          const emptyChat = existingChats.find((chat) => {
+            if (chat.lastMessageAt != null) return false
+            const chatFeatureId = chat.featureId ?? undefined
+            return chatFeatureId === (command.featureId ?? undefined)
+          })
+
+          const chat = emptyChat ?? 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()
+    },
+  }
+}