@pi-unipi/mcp 0.1.0

package/src/tui/settings-overlay.ts

@@ -0,0 +1,369 @@
+/**
+ * @pi-unipi/mcp — Settings overlay TUI
+ *
+ * Interactive list of configured MCP servers with enable/disable toggle,
+ * edit, delete, scope switching, and sync trigger.
+ */
+
+import { Key, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { ServerState } from "../types.js";
+import {
+  loadMcpConfig,
+  saveMcpConfig,
+  loadMetadata,
+  saveMetadata,
+  getGlobalConfigDir,
+  getProjectConfigDir,
+} from "../config/manager.js";
+
+/** Server display item */
+interface ServerDisplayItem {
+  name: string;
+  status: ServerState["status"];
+  command: string;
+  toolCount: number;
+  source: "G" | "P" | "P↑";
+  enabled: boolean;
+  error?: string;
+}
+
+/** State for the settings overlay */
+interface SettingsOverlayState {
+  servers: ServerDisplayItem[];
+  selectedIndex: number;
+  viewScope: "global" | "project";
+  confirmDelete: string | null;
+}
+
+/**
+ * Render the MCP settings overlay.
+ */
+export function renderMcpSettingsOverlay(params?: {
+  registry?: {
+    getAll: () => ServerState[];
+    getServerState: (name: string) => ServerState | null;
+    startServer: (resolved: any) => Promise<void>;
+    stopServer: (name: string) => Promise<void>;
+  };
+  cwd?: string;
+  onComplete?: () => void;
+}) {
+  return (
+    tui: any,
+    theme: any,
+    _kb: any,
+    done: (result: { action?: string } | null) => void,
+  ) => {
+    const registry = params?.registry;
+    const cwd = params?.cwd ?? process.cwd();
+
+    const state: SettingsOverlayState = {
+      servers: [],
+      selectedIndex: 0,
+      viewScope: "global",
+      confirmDelete: null,
+    };
+
+    let cachedLines: string[] | undefined;
+
+    function refreshServers() {
+      const configDir =
+        state.viewScope === "global"
+          ? getGlobalConfigDir()
+          : getProjectConfigDir(cwd);
+
+      let config;
+      try {
+        config = loadMcpConfig(configDir);
+      } catch {
+        config = { mcpServers: {} };
+      }
+
+      let meta;
+      try {
+        meta = loadMetadata(configDir);
+      } catch {
+        meta = { servers: {}, sync: { enabled: true, lastSyncAt: null, syncIntervalMs: 86400000 } };
+      }
+
+      const items: ServerDisplayItem[] = [];
+
+      for (const [name, def] of Object.entries(config.mcpServers)) {
+        const serverMeta = meta.servers[name];
+        const enabled = serverMeta?.enabled ?? true;
+        const runtimeState = registry?.getServerState(name);
+
+        items.push({
+          name,
+          status: runtimeState?.status ?? "stopped",
+          command: `${def.command} ${(def.args ?? []).slice(0, 3).join(" ")}`,
+          toolCount: runtimeState?.toolCount ?? 0,
+          source: state.viewScope === "global" ? "G" : "P",
+          enabled,
+          error: runtimeState?.error,
+        });
+      }
+
+      state.servers = items;
+      if (state.selectedIndex >= items.length) {
+        state.selectedIndex = Math.max(0, items.length - 1);
+      }
+    }
+
+    // Initial load
+    refreshServers();
+
+    function refresh() {
+      cachedLines = undefined;
+      tui.requestRender();
+    }
+
+    async function toggleServer(index: number) {
+      const server = state.servers[index];
+      if (!server) return;
+
+      const configDir =
+        state.viewScope === "global"
+          ? getGlobalConfigDir()
+          : getProjectConfigDir(cwd);
+
+      try {
+        const meta = loadMetadata(configDir);
+        const newEnabled = !server.enabled;
+
+        meta.servers[server.name] = {
+          ...(meta.servers[server.name] ?? {}),
+          enabled: newEnabled,
+          addedAt: meta.servers[server.name]?.addedAt ?? new Date().toISOString(),
+        };
+        saveMetadata(configDir, meta);
+
+        // Try to stop if disabling
+        if (!newEnabled && registry) {
+          try {
+            await registry.stopServer(server.name);
+          } catch {
+            // Ignore stop errors
+          }
+        }
+
+        refreshServers();
+        refresh();
+      } catch (err) {
+        // Silently fail
+      }
+    }
+
+    function deleteServer(name: string) {
+      const configDir =
+        state.viewScope === "global"
+          ? getGlobalConfigDir()
+          : getProjectConfigDir(cwd);
+
+      try {
+        const config = loadMcpConfig(configDir);
+        delete config.mcpServers[name];
+        saveMcpConfig(configDir, config);
+
+        const meta = loadMetadata(configDir);
+        delete meta.servers[name];
+        saveMetadata(configDir, meta);
+
+        refreshServers();
+        refresh();
+      } catch {
+        // Ignore errors
+      }
+    }
+
+    function handleInput(data: string) {
+      // Confirm delete mode
+      if (state.confirmDelete) {
+        if (data === "y" || data === "Y") {
+          deleteServer(state.confirmDelete);
+          state.confirmDelete = null;
+          refresh();
+          return;
+        }
+        if (data === "n" || data === "N" || matchesKey(data, Key.escape)) {
+          state.confirmDelete = null;
+          refresh();
+          return;
+        }
+        return;
+      }
+
+      // Close
+      if (matchesKey(data, Key.escape) || data === "q") {
+        done(null);
+        return;
+      }
+
+      // Navigation
+      if (matchesKey(data, Key.up)) {
+        if (state.selectedIndex > 0) {
+          state.selectedIndex--;
+          refresh();
+        }
+        return;
+      }
+
+      if (matchesKey(data, Key.down)) {
+        if (state.selectedIndex < state.servers.length - 1) {
+          state.selectedIndex++;
+          refresh();
+        }
+        return;
+      }
+
+      // Space: toggle enable/disable
+      if (data === " ") {
+        toggleServer(state.selectedIndex);
+        return;
+      }
+
+      // 'g': switch to global view
+      if (data === "g") {
+        state.viewScope = "global";
+        refreshServers();
+        refresh();
+        return;
+      }
+
+      // 'p': switch to project view
+      if (data === "p") {
+        state.viewScope = "project";
+        refreshServers();
+        refresh();
+        return;
+      }
+
+      // 'd': delete (with confirmation)
+      if (data === "d") {
+        const server = state.servers[state.selectedIndex];
+        if (server) {
+          state.confirmDelete = server.name;
+          refresh();
+        }
+        return;
+      }
+
+      // Enter/e: edit (placeholder)
+      if (data === "\r" || data === "e") {
+        // Edit not yet implemented in TUI — notify would need ctx
+        return;
+      }
+
+      // 'a': add (would open add overlay — placeholder)
+      if (data === "a") {
+        done({ action: "add" });
+        return;
+      }
+
+      // 's': sync
+      if (data === "s") {
+        done({ action: "sync" });
+        return;
+      }
+    }
+
+    function render(width: number): string[] {
+      if (cachedLines) return cachedLines;
+
+      const lines: string[] = [];
+
+      // Header
+      const header = " MCP Settings ";
+      const scopeLabel = state.viewScope === "global" ? "● Global" : "● Project";
+      lines.push(
+        theme.accent(`╭${"─".repeat(Math.max(0, width - 2))}╮`),
+      );
+      lines.push(
+        theme.accent("│") +
+          theme.bold(header) +
+          theme.accent(
+            scopeLabel.padStart(width - visibleWidth(header) - visibleWidth(scopeLabel) - 1),
+          ) +
+          theme.accent("│"),
+      );
+      lines.push(
+        theme.accent(`├${"─".repeat(Math.max(0, width - 2))}┤`),
+      );
+
+      // Server list
+      if (state.servers.length === 0) {
+        lines.push(
+          theme.accent("│") +
+            theme.muted(" No servers configured".padEnd(width - 2)) +
+            theme.accent("│"),
+        );
+      } else {
+        for (let i = 0; i < state.servers.length; i++) {
+          const server = state.servers[i];
+          const selected = i === state.selectedIndex;
+
+          const statusIcon =
+            server.status === "running"
+              ? theme.success("●")
+              : server.status === "error"
+                ? theme.error("✗")
+                : server.enabled
+                  ? theme.muted("○")
+                  : theme.dim("○");
+
+          const name = selected ? theme.bold(server.name) : theme.fg("default", server.name);
+          const cmd = theme.muted(truncateToWidth(server.command, 24));
+          const tools =
+            server.status === "running" && server.toolCount > 0
+              ? theme.accent(`${server.toolCount} tools`)
+              : server.status === "error" && server.error
+                ? theme.error(truncateToWidth(server.error, 20))
+                : theme.dim("stopped");
+
+          const source = theme.muted(`[${server.source}]`);
+          const prefix = selected ? theme.accent("▸ ") : "  ";
+
+          const line = ` ${prefix}${statusIcon} ${name}  ${cmd}  ${tools}  ${source}`;
+          lines.push(
+            theme.accent("│") +
+              truncateToWidth(line, width - 2).padEnd(width - 2) +
+              theme.accent("│"),
+          );
+        }
+      }
+
+      // Confirm delete overlay
+      if (state.confirmDelete) {
+        lines.push(
+          theme.accent(`├${"─".repeat(Math.max(0, width - 2))}┤`),
+        );
+        lines.push(
+          theme.accent("│") +
+            theme.warning(
+              ` Delete '${state.confirmDelete}'? (y/n)`.padEnd(width - 2),
+            ) +
+            theme.accent("│"),
+        );
+      }
+
+      // Keybinds
+      lines.push(
+        theme.accent(`├${"─".repeat(Math.max(0, width - 2))}┤`),
+      );
+      const binds = " ↑↓ select  Space toggle  a add  s sync  g global  p project  d delete  q/Esc close";
+      lines.push(
+        theme.accent("│") +
+          theme.muted(truncateToWidth(binds, width - 2).padEnd(width - 2)) +
+          theme.accent("│"),
+      );
+      lines.push(
+        theme.accent(`╰${"─".repeat(Math.max(0, width - 2))}╯`),
+      );
+
+      cachedLines = lines;
+      return lines;
+    }
+
+    return { render, invalidate: refresh, handleInput };
+  };
+}

package/src/types.ts

@@ -0,0 +1,162 @@
+/**
+ * @pi-unipi/mcp — Type definitions
+ *
+ * All interfaces for MCP server configuration, catalog, tools, and state.
+ */
+
+/** MCP server definition — standard format compatible with Claude Desktop, Cursor, etc. */
+export interface McpServerDef {
+  /** Command to spawn the server (e.g. "npx", "docker", "node") */
+  command: string;
+  /** Arguments passed to the command */
+  args: string[];
+  /** Environment variables for the server process */
+  env?: Record<string, string>;
+}
+
+/** MCP configuration file format (mcp-config.json) */
+export interface McpConfig {
+  /** Map of server name → server definition */
+  mcpServers: Record<string, McpServerDef>;
+}
+
+/** Per-server metadata (config.json) */
+export interface ServerMeta {
+  /** Whether this server is enabled */
+  enabled: boolean;
+  /** ISO timestamp when server was added */
+  addedAt: string;
+}
+
+/** Sync configuration */
+export interface SyncConfig {
+  /** Whether auto-sync is enabled */
+  enabled: boolean;
+  /** ISO timestamp of last successful sync */
+  lastSyncAt: string | null;
+  /** Sync interval in milliseconds */
+  syncIntervalMs: number;
+}
+
+/** Full metadata config (config.json) */
+export interface McpMetadata {
+  /** Per-server metadata */
+  servers: Record<string, ServerMeta>;
+  /** Sync configuration */
+  sync: SyncConfig;
+}
+
+/** Per-server auth data (auth.json) */
+export interface McpAuth {
+  /** Map of server name → environment variable key-value pairs */
+  [serverName: string]: Record<string, string>;
+}
+
+/** Single entry from the MCP server catalog */
+export interface CatalogEntry {
+  /** Unique identifier (e.g. "github/github-mcp-server") */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Short description */
+  description: string;
+  /** GitHub repository URL */
+  github: string;
+  /** Categories/tags */
+  categories: string[];
+  /** Primary language */
+  language: string;
+  /** Scope: "cloud" or "local" */
+  scope: "cloud" | "local";
+  /** Whether this is an official/verified server */
+  official: boolean;
+  /** Pre-filled install configuration */
+  install?: {
+    command: string;
+    args: string[];
+    envVars?: string[];
+  };
+}
+
+/** Cached catalog data (servers.json) */
+export interface CatalogData {
+  /** ISO timestamp of last update */
+  lastUpdated: string;
+  /** Source identifier */
+  source: string;
+  /** Total number of servers */
+  totalServers: number;
+  /** Server entries */
+  servers: CatalogEntry[];
+}
+
+/** MCP tool definition (from tools/list response) */
+export interface McpTool {
+  /** Tool name */
+  name: string;
+  /** Tool description */
+  description: string;
+  /** JSON Schema for tool input parameters */
+  inputSchema: Record<string, unknown>;
+}
+
+/** MCP tool call result */
+export interface McpToolResult {
+  /** Content blocks returned by the tool */
+  content: Array<{
+    type: "text" | "image" | "resource";
+    text?: string;
+    data?: string;
+    mimeType?: string;
+  }>;
+  /** Whether this result is an error */
+  isError?: boolean;
+}
+
+/** Source of a resolved server */
+export type ServerSource = "global" | "project" | "project-override";
+
+/** A resolved server with merge metadata */
+export interface ResolvedServer {
+  /** Server name */
+  name: string;
+  /** Server definition */
+  def: McpServerDef;
+  /** Where this server config came from */
+  source: ServerSource;
+  /** Whether the server is enabled */
+  enabled: boolean;
+}
+
+/** Server runtime state */
+export type ServerStatus = "starting" | "running" | "error" | "stopped";
+
+/** Runtime state of a connected server */
+export interface ServerState {
+  /** Server name */
+  name: string;
+  /** Current status */
+  status: ServerStatus;
+  /** Process ID (if running) */
+  pid?: number;
+  /** Number of tools registered */
+  toolCount: number;
+  /** Error message (if status is "error") */
+  error?: string;
+  /** When the server was started */
+  startedAt?: string;
+}
+
+/** Entry in the server registry */
+export interface McpRegistryEntry {
+  /** Server name */
+  name: string;
+  /** Resolved server config */
+  resolved: ResolvedServer;
+  /** Current state */
+  state: ServerState;
+  /** MCP client instance (if connected) */
+  client: unknown | null;
+  /** Registered tool names */
+  toolNames: string[];
+}