import { mkdir, readFile, writeFile } from "node:fs/promises" import path from "node:path" export type McpTransport = "stdio" | "http" export type McpCatalogEntry = { id: string name: string summary: string websiteUrl?: string transport: McpTransport command: string args: string[] env: Record tags: string[] } export type McpServerInstall = McpCatalogEntry & { installedAt: string updatedAt: string source: "catalog" | "custom" | "registry" enabled: boolean accessMode: "disabled" | "allow_all" | "allow_only" allowedSandboxIds: string[] } type StoreShape = { servers: Record } const HOME = process.env.HOME || "/tmp" const STORE_DIR = process.env.NEMOCLAW_DASHBOARD_STATE_DIR || path.join(HOME, ".nemoclaw-dashboard") const STORE_PATH = path.join(STORE_DIR, "mcp-servers.json") export const MCP_SERVER_CATALOG: McpCatalogEntry[] = [ { id: "blender-mcp", name: "Blender MCP", summary: "Connect AI clients to Blender for natural-language 3D scene inspection, creation, and editing. Requires the Blender MCP add-on in Blender.", websiteUrl: "https://blendermcp.org/", transport: "stdio", command: "uvx", args: ["blender-mcp"], env: {}, tags: ["blender", "3d", "creative"], }, { id: "filesystem", name: "Filesystem", summary: "Expose selected local directories to MCP clients through a stdio server.", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "/sandbox"], env: {}, tags: ["files", "local"], }, { id: "memory", name: "Memory", summary: "Provide a local knowledge graph for persistent notes and relationships.", transport: "stdio", command: "npx", args: ["-y", "@modelcontextprotocol/server-memory"], env: {}, tags: ["state", "local"], }, { id: "inter-sandbox-chat", name: "Inter-Sandbox Chat", summary: "Give allowed sandboxes a shared roomed message board so agents can post updates and read messages from each other through the MCP broker.", transport: "stdio", command: "node", args: [path.join(process.cwd(), "scripts/inter-sandbox-chat-mcp.mjs")], env: {}, tags: ["chat", "collaboration", "sandbox"], }, { id: "git", name: "Git", summary: "Inspect and operate on a local git repository from an MCP client.", transport: "stdio", command: "uvx", args: ["mcp-server-git", "--repository", process.cwd()], env: {}, tags: ["repo", "developer"], }, { id: "fetch", name: "Fetch", summary: "Retrieve web content for MCP clients that need URL context.", transport: "stdio", command: "uvx", args: ["mcp-server-fetch"], env: {}, tags: ["web", "utility"], }, ] const BASELINE_MCP_SERVER_IDS = ["memory"] function emptyStore(): StoreShape { return { servers: {} } } function slugify(value: string) { return value .trim() .toLowerCase() .replace(/[^a-z0-9-]+/g, "-") .replace(/^-+|-+$/g, "") .slice(0, 64) } function normalizeStringArray(value: unknown) { if (!Array.isArray(value)) return [] return value.map((item) => String(item ?? "").trim()).filter(Boolean) } function normalizeEnv(value: unknown) { if (!value || typeof value !== "object" || Array.isArray(value)) return {} return Object.fromEntries( Object.entries(value) .map(([key, envValue]) => [key.trim(), String(envValue ?? "").trim()]) .filter(([key]) => Boolean(key)), ) } function normalizeTransport(value: unknown): McpTransport { return value === "http" ? "http" : "stdio" } function withoutUndefined>(input: T): Partial { return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined)) as Partial } function normalizeInstall(input: Partial, existing?: McpServerInstall | null): McpServerInstall { const name = typeof input.name === "string" && input.name.trim() ? input.name.trim() : existing?.name || "MCP Server" const id = slugify(typeof input.id === "string" && input.id.trim() ? input.id : existing?.id || name) if (!id) throw new Error("server id is required") const command = typeof input.command === "string" ? input.command.trim() : existing?.command || "" if (!command) throw new Error("server command is required") const now = new Date().toISOString() return { id, name, summary: typeof input.summary === "string" ? input.summary.trim() : existing?.summary || "", websiteUrl: typeof input.websiteUrl === "string" ? input.websiteUrl.trim() : existing?.websiteUrl, transport: normalizeTransport(input.transport ?? existing?.transport), command, args: normalizeStringArray(input.args ?? existing?.args), env: normalizeEnv(input.env ?? existing?.env), tags: normalizeStringArray(input.tags ?? existing?.tags), installedAt: existing?.installedAt || now, updatedAt: now, source: input.source === "custom" || input.source === "registry" ? input.source : existing?.source || "catalog", enabled: input.enabled ?? existing?.enabled ?? true, accessMode: input.accessMode === "allow_all" || input.accessMode === "allow_only" || input.accessMode === "disabled" ? input.accessMode : existing?.accessMode || "disabled", allowedSandboxIds: normalizeStringArray(input.allowedSandboxIds ?? existing?.allowedSandboxIds), } } async function readStore(): Promise { try { const raw = await readFile(STORE_PATH, "utf8") const parsed = JSON.parse(raw) return parsed && typeof parsed === "object" && parsed.servers && typeof parsed.servers === "object" ? parsed : emptyStore() } catch { return emptyStore() } } async function writeStore(store: StoreShape) { await mkdir(STORE_DIR, { recursive: true, mode: 0o700 }) await writeFile(STORE_PATH, JSON.stringify(store, null, 2), { mode: 0o600 }) } async function ensureBaselineMcpServers(store: StoreShape) { let changed = false for (const id of BASELINE_MCP_SERVER_IDS) { const entry = MCP_SERVER_CATALOG.find((candidate) => candidate.id === id) if (!entry || store.servers[id]) continue store.servers[id] = normalizeInstall({ ...entry, source: "catalog", enabled: true, accessMode: "disabled", allowedSandboxIds: [], }) changed = true } if (changed) await writeStore(store) } export function buildMcpClientConfig(servers: McpServerInstall[]) { return { mcpServers: Object.fromEntries( servers .filter((server) => server.enabled) .map((server) => [ server.id, server.transport === "http" ? { url: server.command, ...(Object.keys(server.env).length > 0 ? { headers: server.env } : {}), } : { command: server.command, args: server.args, ...(Object.keys(server.env).length > 0 ? { env: server.env } : {}), }, ]), ), } } export function sandboxCanAccessMcpServer(server: McpServerInstall, sandboxId: string, sandboxName?: string | null) { if (!server.enabled || server.accessMode === "disabled") return false if (server.accessMode === "allow_all") return true const allowed = new Set(server.allowedSandboxIds) return allowed.has(sandboxId) || Boolean(sandboxName && allowed.has(sandboxName)) } export async function listMcpServers() { const store = await readStore() await ensureBaselineMcpServers(store) const servers = Object.values(store.servers).sort((a, b) => a.name.localeCompare(b.name)) return { catalog: MCP_SERVER_CATALOG, servers, config: buildMcpClientConfig(servers), } } export async function installMcpServer(input: Partial) { const store = await readStore() const cleanInput = withoutUndefined(input as Record) as Partial const fromCatalog = typeof cleanInput.id === "string" ? MCP_SERVER_CATALOG.find((entry) => entry.id === cleanInput.id) : null const next = normalizeInstall( { ...fromCatalog, ...cleanInput, source: cleanInput.source || (fromCatalog ? "catalog" : "custom"), }, typeof cleanInput.id === "string" ? store.servers[slugify(cleanInput.id)] : null, ) store.servers[next.id] = next await writeStore(store) return next } export async function setMcpServerEnabled(serverId: string, enabled: boolean) { const store = await readStore() const id = slugify(serverId) const existing = store.servers[id] if (!existing) throw new Error("MCP server is not installed") store.servers[id] = normalizeInstall({ ...existing, enabled }, existing) await writeStore(store) return store.servers[id] } export async function updateMcpServerAccess( serverId: string, input: { enabled?: boolean accessMode?: McpServerInstall["accessMode"] allowedSandboxIds?: string[] }, ) { const store = await readStore() const id = slugify(serverId) const existing = store.servers[id] if (!existing) throw new Error("MCP server is not installed") store.servers[id] = normalizeInstall({ ...existing, enabled: input.enabled ?? existing.enabled, accessMode: input.accessMode ?? existing.accessMode, allowedSandboxIds: input.allowedSandboxIds ?? existing.allowedSandboxIds, }, existing) await writeStore(store) return store.servers[id] } export async function uninstallMcpServer(serverId: string) { const store = await readStore() const id = slugify(serverId) if (!store.servers[id]) throw new Error("MCP server is not installed") delete store.servers[id] await writeStore(store) return { id } }