@everstateai/mcp 1.3.1 → 1.3.3

package/src/setup/validators/mcp-config.ts

@@ -0,0 +1,329 @@
+/**
+ * MCP Configuration Validator
+ *
+ * Validates that Claude Code and Claude Desktop have correct MCP configuration.
+ */
+
+import * as fs from 'fs';
+import {
+  Validator,
+  ValidationResult,
+  ValidationContext,
+  getClaudeConfigPath,
+  getClaudeDesktopConfigPath,
+  getEverstateDir,
+} from '../types.js';
+
+export const mcpConfigValidator: Validator = {
+  name: 'MCP Configuration',
+
+  async validate(context: ValidationContext): Promise<ValidationResult[]> {
+    const results: ValidationResult[] = [];
+
+    // Check Claude Code config
+    const claudeCodeResults = await validateClaudeCodeConfig();
+    results.push(...claudeCodeResults);
+
+    // Check Claude Desktop config (optional)
+    const desktopPath = getClaudeDesktopConfigPath();
+    if (desktopPath && fs.existsSync(desktopPath)) {
+      const desktopResults = await validateClaudeDesktopConfig(desktopPath);
+      results.push(...desktopResults);
+    } else if (desktopPath) {
+      results.push({
+        component: 'MCP Config',
+        check: 'Claude Desktop',
+        status: 'warn',
+        message: 'Claude Desktop not installed or not configured',
+        details: { path: desktopPath },
+      });
+    }
+
+    return results;
+  },
+
+  async repair(result: ValidationResult, context: ValidationContext): Promise<boolean> {
+    if (result.check === 'Claude Code config' && result.repairAction?.type === 'install') {
+      return await repairClaudeCodeConfig();
+    }
+    if (result.check === 'Everstate MCP entry' && result.repairAction?.type === 'configure') {
+      return await repairEverstateEntry();
+    }
+    return false;
+  },
+};
+
+async function validateClaudeCodeConfig(): Promise<ValidationResult[]> {
+  const results: ValidationResult[] = [];
+  const configPath = getClaudeConfigPath();
+
+  // Check 1: Config file exists
+  if (!fs.existsSync(configPath)) {
+    results.push({
+      component: 'MCP Config',
+      check: 'Claude Code config',
+      status: 'fail',
+      message: `Config not found at ${configPath}`,
+      repairAction: {
+        type: 'install',
+        description: 'Create Claude Code configuration',
+        automatic: true,
+      },
+    });
+    return results;
+  }
+
+  // Check 2: Valid JSON
+  let config: Record<string, unknown>;
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(content);
+  } catch (err) {
+    results.push({
+      component: 'MCP Config',
+      check: 'Claude Code config',
+      status: 'fail',
+      message: `Invalid JSON: ${err instanceof Error ? err.message : 'Parse error'}`,
+      repairAction: {
+        type: 'configure',
+        description: 'Fix JSON syntax or restore backup',
+        automatic: false,
+      },
+    });
+    return results;
+  }
+
+  results.push({
+    component: 'MCP Config',
+    check: 'Claude Code config',
+    status: 'pass',
+    message: `Valid at ${configPath}`,
+  });
+
+  // Check 3: mcpServers exists
+  const mcpServers = config.mcpServers as Record<string, unknown> | undefined;
+  if (!mcpServers) {
+    results.push({
+      component: 'MCP Config',
+      check: 'mcpServers section',
+      status: 'fail',
+      message: 'No mcpServers section in config',
+      repairAction: {
+        type: 'configure',
+        description: 'Add mcpServers configuration',
+        automatic: true,
+      },
+    });
+    return results;
+  }
+
+  // Check 4: Everstate entry exists
+  const everstateConfig = mcpServers.everstate as Record<string, unknown> | undefined;
+  if (!everstateConfig) {
+    results.push({
+      component: 'MCP Config',
+      check: 'Everstate MCP entry',
+      status: 'fail',
+      message: 'Everstate not configured in mcpServers',
+      repairAction: {
+        type: 'configure',
+        description: 'Add Everstate MCP server configuration',
+        automatic: true,
+      },
+    });
+    return results;
+  }
+
+  results.push({
+    component: 'MCP Config',
+    check: 'Everstate MCP entry',
+    status: 'pass',
+    message: 'Everstate MCP server configured',
+  });
+
+  // Check 5: Command is valid
+  const command = everstateConfig.command as string | undefined;
+  const args = everstateConfig.args as string[] | undefined;
+
+  if (command === 'npx' && args?.includes('@everstateai/mcp')) {
+    results.push({
+      component: 'MCP Config',
+      check: 'MCP command',
+      status: 'pass',
+      message: 'Using npx @everstateai/mcp (recommended)',
+    });
+  } else if (command === 'node') {
+    results.push({
+      component: 'MCP Config',
+      check: 'MCP command',
+      status: 'warn',
+      message: 'Using local node path - consider using npx for auto-updates',
+      details: { command, args },
+    });
+  } else {
+    results.push({
+      component: 'MCP Config',
+      check: 'MCP command',
+      status: 'warn',
+      message: `Non-standard command: ${command}`,
+      details: { command, args },
+    });
+  }
+
+  // Check 6: Environment variables
+  const env = everstateConfig.env as Record<string, string> | undefined;
+  if (!env?.EVERSTATE_API_KEY) {
+    // Check if API key is in file instead
+    const apiKeyPath = `${getEverstateDir()}/api-key`;
+    if (!fs.existsSync(apiKeyPath)) {
+      results.push({
+        component: 'MCP Config',
+        check: 'API key configuration',
+        status: 'fail',
+        message: 'No API key in MCP config or key file',
+        repairAction: {
+          type: 'configure',
+          description: 'Configure API key',
+          automatic: false,
+        },
+      });
+    } else {
+      results.push({
+        component: 'MCP Config',
+        check: 'API key configuration',
+        status: 'pass',
+        message: 'Using API key from file (hooks will read it)',
+      });
+    }
+  } else {
+    results.push({
+      component: 'MCP Config',
+      check: 'API key configuration',
+      status: 'pass',
+      message: 'API key configured in MCP env',
+    });
+  }
+
+  return results;
+}
+
+async function validateClaudeDesktopConfig(configPath: string): Promise<ValidationResult[]> {
+  const results: ValidationResult[] = [];
+
+  // Similar validation for Claude Desktop
+  let config: Record<string, unknown>;
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(content);
+  } catch (err) {
+    results.push({
+      component: 'MCP Config',
+      check: 'Claude Desktop config',
+      status: 'warn',
+      message: `Could not parse: ${err instanceof Error ? err.message : 'Error'}`,
+    });
+    return results;
+  }
+
+  const mcpServers = config.mcpServers as Record<string, unknown> | undefined;
+  if (!mcpServers?.everstate) {
+    results.push({
+      component: 'MCP Config',
+      check: 'Claude Desktop Everstate',
+      status: 'warn',
+      message: 'Everstate not configured for Claude Desktop',
+      repairAction: {
+        type: 'configure',
+        description: 'Add Everstate to Claude Desktop',
+        automatic: true,
+      },
+    });
+  } else {
+    results.push({
+      component: 'MCP Config',
+      check: 'Claude Desktop Everstate',
+      status: 'pass',
+      message: 'Everstate configured for Claude Desktop',
+    });
+  }
+
+  return results;
+}
+
+async function repairClaudeCodeConfig(): Promise<boolean> {
+  const configPath = getClaudeConfigPath();
+
+  try {
+    // Create minimal config
+    const config = {
+      mcpServers: {
+        everstate: {
+          command: 'npx',
+          args: ['-y', '@everstateai/mcp'],
+          env: {},
+        },
+      },
+    };
+
+    // Check for API key
+    const apiKeyPath = `${getEverstateDir()}/api-key`;
+    if (fs.existsSync(apiKeyPath)) {
+      const apiKey = fs.readFileSync(apiKeyPath, 'utf8').trim();
+      if (apiKey) {
+        (config.mcpServers.everstate.env as Record<string, string>).EVERSTATE_API_KEY = apiKey;
+      }
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function repairEverstateEntry(): Promise<boolean> {
+  const configPath = getClaudeConfigPath();
+
+  try {
+    let config: Record<string, unknown> = {};
+
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    }
+
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    const mcpServers = config.mcpServers as Record<string, unknown>;
+
+    // Add Everstate entry
+    const everstateConfig: Record<string, unknown> = {
+      command: 'npx',
+      args: ['-y', '@everstateai/mcp'],
+      env: {},
+    };
+
+    // Check for API key
+    const apiKeyPath = `${getEverstateDir()}/api-key`;
+    if (fs.existsSync(apiKeyPath)) {
+      const apiKey = fs.readFileSync(apiKeyPath, 'utf8').trim();
+      if (apiKey) {
+        (everstateConfig.env as Record<string, string>).EVERSTATE_API_KEY = apiKey;
+      }
+    }
+
+    mcpServers.everstate = everstateConfig;
+
+    // Backup existing
+    if (fs.existsSync(configPath)) {
+      fs.copyFileSync(configPath, `${configPath}.backup`);
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/setup/validators/project.ts

@@ -0,0 +1,179 @@
+/**
+ * Project Validator
+ *
+ * Validates project-level configuration (.everstate.json).
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  Validator,
+  ValidationResult,
+  ValidationContext,
+  EVERSTATE_API_URL,
+} from '../types.js';
+
+export const projectValidator: Validator = {
+  name: 'Project',
+
+  async validate(context: ValidationContext): Promise<ValidationResult[]> {
+    const results: ValidationResult[] = [];
+
+    if (!context.projectDir) {
+      results.push({
+        component: 'Project',
+        check: 'Project directory',
+        status: 'warn',
+        message: 'No project directory specified (running globally)',
+      });
+      return results;
+    }
+
+    const configPath = path.join(context.projectDir, '.everstate.json');
+
+    // Check 1: Config file exists
+    if (!fs.existsSync(configPath)) {
+      results.push({
+        component: 'Project',
+        check: '.everstate.json exists',
+        status: 'fail',
+        message: `Not found at ${configPath}`,
+        repairAction: {
+          type: 'install',
+          description: 'Initialize project with everstate',
+          automatic: false, // Requires user input for project name
+        },
+      });
+      return results;
+    }
+
+    results.push({
+      component: 'Project',
+      check: '.everstate.json exists',
+      status: 'pass',
+      message: `Found at ${configPath}`,
+    });
+
+    // Check 2: Valid JSON
+    let config: Record<string, unknown>;
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    } catch (error) {
+      results.push({
+        component: 'Project',
+        check: '.everstate.json valid',
+        status: 'fail',
+        message: 'Invalid JSON syntax',
+        details: { error: String(error) },
+        repairAction: {
+          type: 'configure',
+          description: 'Fix JSON syntax in .everstate.json',
+          automatic: false,
+        },
+      });
+      return results;
+    }
+
+    results.push({
+      component: 'Project',
+      check: '.everstate.json valid',
+      status: 'pass',
+      message: 'Valid JSON',
+    });
+
+    // Check 3: Has projectId
+    const projectId = config.projectId as string | undefined;
+    if (!projectId) {
+      results.push({
+        component: 'Project',
+        check: 'Project ID',
+        status: 'fail',
+        message: 'Missing projectId field',
+        repairAction: {
+          type: 'configure',
+          description: 'Add projectId to .everstate.json',
+          automatic: false,
+        },
+      });
+      return results;
+    }
+
+    // Check 4: Valid projectId format
+    if (!projectId.startsWith('proj_')) {
+      results.push({
+        component: 'Project',
+        check: 'Project ID format',
+        status: 'warn',
+        message: `Unusual format: ${projectId} (expected proj_...)`,
+        details: { projectId },
+      });
+    } else {
+      results.push({
+        component: 'Project',
+        check: 'Project ID format',
+        status: 'pass',
+        message: `Valid format: ${projectId.substring(0, 20)}...`,
+      });
+    }
+
+    // Check 5: Verify project exists on server (if not skipping network)
+    if (!context.skipNetwork && context.apiKey) {
+      try {
+        const response = await fetch(`${EVERSTATE_API_URL}/api/project/${projectId}`, {
+          headers: {
+            Authorization: `Bearer ${context.apiKey}`,
+          },
+        });
+
+        if (response.ok) {
+          const data = (await response.json()) as { name?: string };
+          results.push({
+            component: 'Project',
+            check: 'Project exists on server',
+            status: 'pass',
+            message: `Project "${data.name || projectId}" found`,
+          });
+        } else if (response.status === 404) {
+          results.push({
+            component: 'Project',
+            check: 'Project exists on server',
+            status: 'warn',
+            message: 'Project not found on server (may need to sync)',
+            details: { projectId },
+          });
+        } else if (response.status === 401) {
+          results.push({
+            component: 'Project',
+            check: 'Project exists on server',
+            status: 'warn',
+            message: 'Cannot verify - API key may not have access',
+          });
+        } else {
+          results.push({
+            component: 'Project',
+            check: 'Project exists on server',
+            status: 'warn',
+            message: `Unexpected response: ${response.status}`,
+          });
+        }
+      } catch (error) {
+        results.push({
+          component: 'Project',
+          check: 'Project exists on server',
+          status: 'warn',
+          message: 'Could not verify (network error)',
+          details: { error: String(error) },
+        });
+      }
+    }
+
+    return results;
+  },
+
+  async repair(result: ValidationResult, context: ValidationContext): Promise<boolean> {
+    // Project repairs typically require user input
+    // The setup command handles project initialization
+    return false;
+  },
+};