@everstateai/mcp 1.3.2 → 1.3.4

package/src/setup/hooks/templates.ts

@@ -0,0 +1,255 @@
+/**
+ * Hook Templates
+ *
+ * Versioned hook templates for installation and updates.
+ * Each hook includes a VERSION header for validation.
+ */
+
+import { HookConfig, HOOK_VERSIONS, EVERSTATE_API_URL, getEverstateDir } from '../types.js';
+
+/**
+ * Get the sync-todos.js hook content
+ */
+export function getSyncTodosHook(config?: Partial<HookConfig>): string {
+  const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
+  const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/usr/bin/env node
+/**
+ * Everstate Sync Todos Hook v${HOOK_VERSIONS.syncTodos}
+ * VERSION: ${HOOK_VERSIONS.syncTodos}
+ * GENERATED: ${generatedAt}
+ *
+ * Syncs Claude's TodoWrite tasks with Everstate.
+ * Runs after every TodoWrite tool call.
+ *
+ * Claude Code passes hook data via STDIN as JSON:
+ * { "tool_name": "TodoWrite", "tool_input": { "todos": [...] }, ... }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const API_KEY_PATH = '${apiKeyPath}';
+const API_URL = '${apiUrl}';
+
+// Read all stdin first (Claude Code sends hook data via stdin)
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => stdinData += chunk);
+process.stdin.on('end', () => main());
+
+async function main() {
+  try {
+    // Read API key
+    if (!fs.existsSync(API_KEY_PATH)) {
+      process.exit(0); // Don't block Claude
+    }
+    const apiKey = fs.readFileSync(API_KEY_PATH, 'utf8').trim();
+
+    // Parse input from Claude (comes via stdin)
+    let todos = [];
+    try {
+      const hookData = JSON.parse(stdinData || '{}');
+      // Claude Code sends: { tool_name, tool_input: { todos: [...] }, ... }
+      todos = hookData.tool_input?.todos || [];
+    } catch {
+      process.exit(0);
+    }
+
+    if (todos.length === 0) {
+      process.exit(0);
+    }
+
+    // Find project config - check CLAUDE_PROJECT_DIR first, then cwd
+    let projectId = null;
+    let searchDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+    for (let i = 0; i < 10; i++) {
+      for (const configName of ['.everstate.json', '.codekeep.json']) {
+        const configPath = path.join(searchDir, configName);
+        if (fs.existsSync(configPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            projectId = config.projectId;
+            break;
+          } catch {}
+        }
+      }
+      if (projectId) break;
+      const parent = path.dirname(searchDir);
+      if (parent === searchDir) break;
+      searchDir = parent;
+    }
+
+    if (!projectId) {
+      // No project config - skip sync
+      process.exit(0);
+    }
+
+    // Send to API for matching and storage
+    const response = await fetch(\`\${API_URL}/api/session/sync-todos\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${apiKey}\`,
+      },
+      body: JSON.stringify({
+        projectId,
+        todos,
+        sessionId: process.env.SESSION_ID || null,
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      console.error('[everstate] Sync failed:', response.status, text);
+    }
+  } catch (error) {
+    console.error('[everstate] Hook error:', error.message);
+  }
+
+  process.exit(0);
+}
+`;
+}
+
+/**
+ * Get the session-start.sh hook content
+ */
+export function getSessionStartHook(config?: Partial<HookConfig>): string {
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/bin/bash
+# Everstate Session Start Hook v${HOOK_VERSIONS.sessionStart}
+# VERSION: ${HOOK_VERSIONS.sessionStart}
+# GENERATED: ${generatedAt}
+#
+# Loads context at session start.
+# Place in .claude/hooks/ directory.
+
+# Check for MCP - if available, tools handle context loading
+if command -v claude &> /dev/null; then
+  # Claude Code detected - MCP tools will load context
+  exit 0
+fi
+
+# Fallback for environments without MCP
+echo "[everstate] Session starting - use sync() to load context"
+`;
+}
+
+/**
+ * Get the session-end.sh hook content
+ */
+export function getSessionEndHook(config?: Partial<HookConfig>): string {
+  const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
+  const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/bin/bash
+# Everstate Session End Hook v${HOOK_VERSIONS.sessionEnd}
+# VERSION: ${HOOK_VERSIONS.sessionEnd}
+# GENERATED: ${generatedAt}
+#
+# Saves session summary when Claude session ends.
+
+API_KEY_PATH="${apiKeyPath}"
+API_URL="${apiUrl}"
+
+# Read API key
+if [ ! -f "$API_KEY_PATH" ]; then
+  exit 0
+fi
+API_KEY=$(cat "$API_KEY_PATH")
+
+# Find project config
+find_project_id() {
+  local dir="$PWD"
+  for i in {1..10}; do
+    if [ -f "$dir/.everstate.json" ]; then
+      grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' "$dir/.everstate.json" | cut -d'"' -f4
+      return
+    fi
+    dir=$(dirname "$dir")
+    [ "$dir" = "/" ] && break
+  done
+}
+
+PROJECT_ID=$(find_project_id)
+if [ -z "$PROJECT_ID" ]; then
+  exit 0
+fi
+
+# Signal session end to API
+curl -s -X POST "$API_URL/api/session/end" \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -d "{\\"projectId\\": \\"$PROJECT_ID\\"}" > /dev/null 2>&1
+
+exit 0
+`;
+}
+
+/**
+ * Get the pre-compact.sh hook content (for context compaction)
+ */
+export function getPreCompactHook(config?: Partial<HookConfig>): string {
+  const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
+  const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/bin/bash
+# Everstate Pre-Compact Hook v${HOOK_VERSIONS.sessionEnd}
+# VERSION: ${HOOK_VERSIONS.sessionEnd}
+# GENERATED: ${generatedAt}
+#
+# Saves session context before Claude's context compaction.
+
+API_KEY_PATH="${apiKeyPath}"
+API_URL="${apiUrl}"
+
+# Read API key
+if [ ! -f "$API_KEY_PATH" ]; then
+  exit 0
+fi
+API_KEY=$(cat "$API_KEY_PATH")
+
+# Find project config
+find_project_id() {
+  local dir="$PWD"
+  for i in {1..10}; do
+    if [ -f "$dir/.everstate.json" ]; then
+      grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' "$dir/.everstate.json" | cut -d'"' -f4
+      return
+    fi
+    dir=$(dirname "$dir")
+    [ "$dir" = "/" ] && break
+  done
+}
+
+PROJECT_ID=$(find_project_id)
+if [ -z "$PROJECT_ID" ]; then
+  exit 0
+fi
+
+# Get transcript from environment if available
+TRANSCRIPT="\${CLAUDE_TRANSCRIPT:-}"
+
+# Signal pre-compact to API
+curl -s -X POST "$API_URL/api/session/pre-compact" \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -d "{\\"projectId\\": \\"$PROJECT_ID\\", \\"transcript\\": \\"\$TRANSCRIPT\\"}" > /dev/null 2>&1
+
+exit 0
+`;
+}
+
+export const hookTemplates = {
+  syncTodos: getSyncTodosHook,
+  sessionStart: getSessionStartHook,
+  sessionEnd: getSessionEndHook,
+  preCompact: getPreCompactHook,
+};

package/src/setup/types.ts

@@ -0,0 +1,207 @@
+/**
+ * Everstate Setup Types
+ *
+ * Shared types for the setup, doctor, and repair commands.
+ */
+
+// ============================================================================
+// Validation Types
+// ============================================================================
+
+export type ValidationStatus = 'pass' | 'warn' | 'fail';
+
+export type RepairType = 'install' | 'update' | 'configure' | 'delete' | 'chmod';
+
+export interface RepairAction {
+  type: RepairType;
+  description: string;
+  automatic: boolean; // Can be auto-repaired without user input
+}
+
+export interface ValidationResult {
+  component: string;
+  check: string;
+  status: ValidationStatus;
+  message: string;
+  details?: Record<string, unknown>;
+  repairAction?: RepairAction;
+}
+
+export interface Validator {
+  name: string;
+  validate(context: ValidationContext): Promise<ValidationResult[]>;
+  repair?(result: ValidationResult, context: ValidationContext): Promise<boolean>;
+}
+
+export interface ValidationContext {
+  projectDir?: string;
+  apiKey?: string;
+  verbose?: boolean;
+  skipNetwork?: boolean;
+}
+
+export interface ValidationSummary {
+  passed: number;
+  warnings: number;
+  failed: number;
+  results: ValidationResult[];
+}
+
+// ============================================================================
+// Version Tracking Types
+// ============================================================================
+
+export interface HookVersions {
+  sessionStart: string;
+  sessionEnd: string;
+  syncTodos: string;
+}
+
+export interface ComponentVersions {
+  mcpProxy: string;
+  hooks: HookVersions;
+}
+
+export interface ConfigPaths {
+  claudeCode: string;
+  claudeDesktop?: string;
+  apiKey: string;
+  globalHooks: string;
+}
+
+export interface ProjectInstallation {
+  projectId: string;
+  configVersion: string;
+  hooksVersion: string;
+  lastValidated: string;
+}
+
+export interface VersionFile {
+  installedAt: string;
+  installedBy: 'setup' | 'npx' | 'manual';
+  components: ComponentVersions;
+  configPaths: ConfigPaths;
+  projects: Record<string, ProjectInstallation>;
+  lastUpdateCheck?: string;
+}
+
+// ============================================================================
+// Hook Types
+// ============================================================================
+
+export interface HookTemplate {
+  name: string;
+  version: string;
+  filename: string;
+  content: (config: HookConfig) => string;
+}
+
+export interface HookConfig {
+  apiKeyPath: string;
+  apiUrl: string;
+  generatedAt: string;
+}
+
+// ============================================================================
+// Setup Types
+// ============================================================================
+
+export interface SetupOptions {
+  apiKey: string;
+  projectDir: string;
+  projectId?: string;
+  skipHooks?: boolean;
+  force?: boolean;
+  globalOnly?: boolean;
+}
+
+export interface DoctorOptions {
+  projectDir?: string;
+  json?: boolean;
+  verbose?: boolean;
+  component?: string;
+}
+
+export interface RepairOptions {
+  projectDir?: string;
+  force?: boolean;
+  component?: string;
+  includeWarnings?: boolean;
+}
+
+// ============================================================================
+// Console Output Types
+// ============================================================================
+
+export interface Colors {
+  reset: string;
+  red: string;
+  green: string;
+  yellow: string;
+  blue: string;
+  cyan: string;
+  bold: string;
+  dim: string;
+}
+
+export const COLORS: Colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+};
+
+export function supportsColor(): boolean {
+  return (
+    process.stdout.isTTY === true &&
+    process.env.FORCE_COLOR !== '0' &&
+    (process.platform !== 'win32' ||
+      process.env.TERM === 'xterm-256color' ||
+      !!process.env.WT_SESSION)
+  );
+}
+
+export function c(color: keyof Colors, text: string): string {
+  return supportsColor() ? `${COLORS[color]}${text}${COLORS.reset}` : text;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+export const HOOK_VERSIONS = {
+  sessionStart: '1.1.0',
+  sessionEnd: '1.1.0',
+  syncTodos: '5.1.0',  // Fixed: read from stdin instead of TOOL_INPUT env var
+};
+
+export const EVERSTATE_API_URL = 'https://www.everstate.ai';
+
+export function getEverstateDir(): string {
+  return `${process.env.HOME}/.everstate`;
+}
+
+export function getClaudeConfigPath(): string {
+  return `${process.env.HOME}/.claude.json`;
+}
+
+export function getClaudeDesktopConfigPath(): string {
+  if (process.platform === 'darwin') {
+    return `${process.env.HOME}/Library/Application Support/Claude/claude_desktop_config.json`;
+  } else if (process.platform === 'win32') {
+    return `${process.env.APPDATA}/Claude/claude_desktop_config.json`;
+  }
+  return ''; // Linux - no known Claude Desktop location
+}
+
+export function getCursorConfigPath(): string {
+  return `${process.env.HOME}/.cursor/mcp.json`;
+}
+
+export function getWindsurfConfigPath(): string {
+  return `${process.env.HOME}/.codeium/windsurf/mcp_config.json`;
+}

package/src/setup/validators/api-key.ts

@@ -0,0 +1,218 @@
+/**
+ * API Key Validator
+ *
+ * Validates that the API key exists, has correct format, and authenticates.
+ */
+
+import * as fs from 'fs';
+import * as https from 'https';
+import {
+  Validator,
+  ValidationResult,
+  ValidationContext,
+  getEverstateDir,
+  EVERSTATE_API_URL,
+} from '../types.js';
+
+export const apiKeyValidator: Validator = {
+  name: 'API Key',
+
+  async validate(context: ValidationContext): Promise<ValidationResult[]> {
+    const results: ValidationResult[] = [];
+    const apiKeyPath = `${getEverstateDir()}/api-key`;
+
+    // Check 1: API key file exists
+    if (!fs.existsSync(apiKeyPath)) {
+      results.push({
+        component: 'API Key',
+        check: 'File exists',
+        status: 'fail',
+        message: `API key file not found at ${apiKeyPath}`,
+        repairAction: {
+          type: 'install',
+          description: 'Run setup with your API key',
+          automatic: false,
+        },
+      });
+      return results; // Can't continue without file
+    }
+
+    results.push({
+      component: 'API Key',
+      check: 'File exists',
+      status: 'pass',
+      message: `Found at ${apiKeyPath}`,
+    });
+
+    // Check 2: File is not empty and has correct format
+    let apiKey: string;
+    try {
+      apiKey = fs.readFileSync(apiKeyPath, 'utf8').trim();
+    } catch (err) {
+      results.push({
+        component: 'API Key',
+        check: 'Readable',
+        status: 'fail',
+        message: `Cannot read API key file: ${err instanceof Error ? err.message : 'Unknown error'}`,
+        repairAction: {
+          type: 'chmod',
+          description: 'Fix file permissions',
+          automatic: true,
+        },
+      });
+      return results;
+    }
+
+    if (!apiKey) {
+      results.push({
+        component: 'API Key',
+        check: 'Not empty',
+        status: 'fail',
+        message: 'API key file is empty',
+        repairAction: {
+          type: 'configure',
+          description: 'Run setup with your API key',
+          automatic: false,
+        },
+      });
+      return results;
+    }
+
+    // Check 3: Format validation
+    if (!apiKey.startsWith('ck_') && !apiKey.startsWith('ckp_')) {
+      results.push({
+        component: 'API Key',
+        check: 'Format',
+        status: 'fail',
+        message: `Invalid format - must start with 'ck_' or 'ckp_'`,
+        details: { keyPrefix: apiKey.substring(0, 4) },
+        repairAction: {
+          type: 'configure',
+          description: 'Replace with valid API key',
+          automatic: false,
+        },
+      });
+      return results;
+    }
+
+    if (apiKey.length < 20) {
+      results.push({
+        component: 'API Key',
+        check: 'Format',
+        status: 'warn',
+        message: 'API key appears unusually short',
+        details: { length: apiKey.length },
+      });
+    } else {
+      results.push({
+        component: 'API Key',
+        check: 'Format',
+        status: 'pass',
+        message: `Valid format (${apiKey.substring(0, 7)}...)`,
+      });
+    }
+
+    // Check 4: Authentication (skip if network checks disabled)
+    if (context.skipNetwork) {
+      results.push({
+        component: 'API Key',
+        check: 'Authentication',
+        status: 'warn',
+        message: 'Skipped (network checks disabled)',
+      });
+      return results;
+    }
+
+    const authResult = await checkAuthentication(apiKey);
+    results.push(authResult);
+
+    return results;
+  },
+
+  async repair(result: ValidationResult, context: ValidationContext): Promise<boolean> {
+    if (result.check === 'Readable' && result.repairAction?.type === 'chmod') {
+      const apiKeyPath = `${getEverstateDir()}/api-key`;
+      try {
+        fs.chmodSync(apiKeyPath, 0o600);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    // Other repairs require user input (new API key)
+    return false;
+  },
+};
+
+async function checkAuthentication(apiKey: string): Promise<ValidationResult> {
+  return new Promise((resolve) => {
+    const url = new URL(`${EVERSTATE_API_URL}/api/projects`);
+
+    const req = https.request(
+      {
+        hostname: url.hostname,
+        port: 443,
+        path: url.pathname,
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        timeout: 10000,
+      },
+      (res) => {
+        if (res.statusCode === 200) {
+          resolve({
+            component: 'API Key',
+            check: 'Authentication',
+            status: 'pass',
+            message: 'Authenticated successfully',
+          });
+        } else if (res.statusCode === 401 || res.statusCode === 403) {
+          resolve({
+            component: 'API Key',
+            check: 'Authentication',
+            status: 'fail',
+            message: 'Authentication failed - invalid or expired key',
+            details: { statusCode: res.statusCode },
+            repairAction: {
+              type: 'configure',
+              description: 'Replace with valid API key',
+              automatic: false,
+            },
+          });
+        } else {
+          resolve({
+            component: 'API Key',
+            check: 'Authentication',
+            status: 'warn',
+            message: `Unexpected response: ${res.statusCode}`,
+            details: { statusCode: res.statusCode },
+          });
+        }
+      }
+    );
+
+    req.on('error', (err) => {
+      resolve({
+        component: 'API Key',
+        check: 'Authentication',
+        status: 'warn',
+        message: `Network error: ${err.message}`,
+        details: { error: err.message },
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({
+        component: 'API Key',
+        check: 'Authentication',
+        status: 'warn',
+        message: 'Request timed out',
+      });
+    });
+
+    req.end();
+  });
+}