Skip to content

The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.

2.7 KB
Raw Blame
import { create } from 'zustand'
import { persist } from 'zustand/middleware'
import { safeJSONStorage } from '../lib/storage-quota'
import type { MCPServerConfig, MCPToolDefinition } from '../api/mcp/types'

interface MCPState {
  servers: MCPServerConfig[]
  connectedServers: string[]
  serverTools: Record<string, MCPToolDefinition[]>
  /** Why the last connect of a server failed, one sentence; not persisted. */
  serverErrors: Record<string, string>

  // CRUD
  addServer: (server: MCPServerConfig) => void
  updateServer: (id: string, updates: Partial<MCPServerConfig>) => void
  removeServer: (id: string) => void

  // Connection state
  setConnected: (id: string, connected: boolean) => void
  setServerTools: (id: string, tools: MCPToolDefinition[]) => void
  clearServerTools: (id: string) => void
  /** Set (or with null clear) the sentence the server row shows. */
  setServerError: (id: string, error: string | null) => void
}

export const useMCPStore = create<MCPState>()(
  persist(
    (set) => ({
      servers: [],
      connectedServers: [],
      serverTools: {},
      serverErrors: {},

      addServer: (server) =>
        set((state) => ({ servers: [...state.servers, server] })),

      updateServer: (id, updates) =>
        set((state) => ({
          servers: state.servers.map((s) => (s.id === id ? { ...s, ...updates } : s)),
        })),

      removeServer: (id) =>
        set((state) => ({
          servers: state.servers.filter((s) => s.id !== id),
          connectedServers: state.connectedServers.filter((s) => s !== id),
          serverTools: Object.fromEntries(
            Object.entries(state.serverTools).filter(([k]) => k !== id)
          ),
          serverErrors: Object.fromEntries(
            Object.entries(state.serverErrors).filter(([k]) => k !== id)
          ),
        })),

      setConnected: (id, connected) =>
        set((state) => ({
          connectedServers: connected
            ? [...state.connectedServers.filter((s) => s !== id), id]
            : state.connectedServers.filter((s) => s !== id),
        })),

      setServerTools: (id, tools) =>
        set((state) => ({ serverTools: { ...state.serverTools, [id]: tools } })),

      clearServerTools: (id) =>
        set((state) => {
          const { [id]: _, ...rest } = state.serverTools
          return { serverTools: rest }
        }),

      setServerError: (id, error) =>
        set((state) => {
          const { [id]: _, ...rest } = state.serverErrors
          return { serverErrors: error ? { ...rest, [id]: error } : rest }
        }),
    }),
    {
      name: 'locally-uncensored-mcp-servers',
      storage: safeJSONStorage(),
      partialize: (state) => ({
        servers: state.servers,
      }),
    }
  )
)