@nordsym/apiclaw 1.3.6 → 1.3.8

package/src/cli/commands/doctor.ts

@@ -0,0 +1,367 @@
+/**
+ * Doctor Command
+ * Health check for APIClaw installation and MCP client configurations
+ */
+
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { getAllClients, getClientConfig, MCPClient } from '../../utils/paths.js';
+import { readConfig, hasApiclawConfig } from '../../utils/config.js';
+import { detectOS, getOSDisplayName } from '../../utils/os.js';
+import { getApiUrl, readEnvConfig, ENV_VARS } from '../../enterprise/env.js';
+
+export interface DoctorResult {
+  healthy: boolean;
+  checks: CheckResult[];
+  summary: string;
+}
+
+export interface CheckResult {
+  category: string;
+  name: string;
+  status: 'pass' | 'fail' | 'warn' | 'skip';
+  message: string;
+  details?: string;
+}
+
+/**
+ * Check Node.js availability and version
+ */
+function checkNode(): CheckResult {
+  try {
+    const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+    const major = parseInt(version.replace('v', '').split('.')[0], 10);
+    
+    if (major < 18) {
+      return {
+        category: 'System',
+        name: 'Node.js',
+        status: 'warn',
+        message: `${version} (recommend v18+)`,
+      };
+    }
+    
+    return {
+      category: 'System',
+      name: 'Node.js',
+      status: 'pass',
+      message: version,
+    };
+  } catch {
+    return {
+      category: 'System',
+      name: 'Node.js',
+      status: 'fail',
+      message: 'Not found',
+      details: 'Node.js is required. Install from https://nodejs.org',
+    };
+  }
+}
+
+/**
+ * Check npm availability
+ */
+function checkNpm(): CheckResult {
+  try {
+    const version = execSync('npm --version', { encoding: 'utf-8' }).trim();
+    return {
+      category: 'System',
+      name: 'npm',
+      status: 'pass',
+      message: `v${version}`,
+    };
+  } catch {
+    return {
+      category: 'System',
+      name: 'npm',
+      status: 'fail',
+      message: 'Not found',
+      details: 'npm is required for npx to work',
+    };
+  }
+}
+
+/**
+ * Check npx availability
+ */
+function checkNpx(): CheckResult {
+  try {
+    execSync('npx --version', { encoding: 'utf-8', stdio: 'pipe' });
+    return {
+      category: 'System',
+      name: 'npx',
+      status: 'pass',
+      message: 'Available',
+    };
+  } catch {
+    return {
+      category: 'System',
+      name: 'npx',
+      status: 'fail',
+      message: 'Not found',
+      details: 'npx is required for MCP server execution',
+    };
+  }
+}
+
+/**
+ * Check MCP client configuration
+ */
+function checkClient(client: MCPClient, serverName = 'apiclaw'): CheckResult {
+  const config = getClientConfig(client);
+  const configPath = config.configPath;
+  
+  // Check if config file exists
+  if (!existsSync(configPath)) {
+    // Check if config directory exists (client might be installed but not configured)
+    const dirExists = existsSync(config.configDir);
+    
+    if (dirExists) {
+      return {
+        category: 'MCP Clients',
+        name: config.displayName,
+        status: 'warn',
+        message: 'Installed but not configured',
+        details: `Config file: ${configPath}`,
+      };
+    }
+    
+    return {
+      category: 'MCP Clients',
+      name: config.displayName,
+      status: 'skip',
+      message: 'Not installed',
+    };
+  }
+  
+  // Read and check config
+  const readResult = readConfig(configPath);
+  
+  if (!readResult.success) {
+    return {
+      category: 'MCP Clients',
+      name: config.displayName,
+      status: 'fail',
+      message: 'Invalid config',
+      details: readResult.error,
+    };
+  }
+  
+  // Check if APIClaw is configured
+  if (readResult.config && hasApiclawConfig(readResult.config, serverName)) {
+    return {
+      category: 'MCP Clients',
+      name: config.displayName,
+      status: 'pass',
+      message: 'Configured',
+    };
+  }
+  
+  return {
+    category: 'MCP Clients',
+    name: config.displayName,
+    status: 'warn',
+    message: 'APIClaw not configured',
+    details: `Run: npx @nordsym/apiclaw setup --client ${client}`,
+  };
+}
+
+/**
+ * Check API connectivity
+ */
+async function checkConnectivity(): Promise<CheckResult> {
+  const apiUrl = getApiUrl();
+  const testUrl = `${apiUrl}/health`;
+  
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    
+    const response = await fetch(testUrl, {
+      method: 'GET',
+      signal: controller.signal,
+    });
+    
+    clearTimeout(timeout);
+    
+    if (response.ok) {
+      return {
+        category: 'Connectivity',
+        name: 'API Server',
+        status: 'pass',
+        message: `${apiUrl} reachable`,
+      };
+    }
+    
+    return {
+      category: 'Connectivity',
+      name: 'API Server',
+      status: 'warn',
+      message: `${apiUrl} returned ${response.status}`,
+    };
+  } catch (error) {
+    // For now, skip connectivity check if fetch fails (might be offline mode)
+    return {
+      category: 'Connectivity',
+      name: 'API Server',
+      status: 'skip',
+      message: 'Could not reach API (offline?)',
+      details: `URL: ${testUrl}`,
+    };
+  }
+}
+
+/**
+ * Check environment variables
+ */
+function checkEnvVars(): CheckResult[] {
+  const envConfig = readEnvConfig();
+  const results: CheckResult[] = [];
+  
+  if (envConfig.workspace) {
+    results.push({
+      category: 'Environment',
+      name: ENV_VARS.WORKSPACE,
+      status: 'pass',
+      message: envConfig.workspace,
+    });
+  }
+  
+  if (envConfig.apiUrl) {
+    results.push({
+      category: 'Environment',
+      name: ENV_VARS.API_URL,
+      status: 'pass',
+      message: envConfig.apiUrl,
+    });
+  }
+  
+  if (envConfig.disableTelemetry) {
+    results.push({
+      category: 'Environment',
+      name: ENV_VARS.DISABLE_TELEMETRY,
+      status: 'pass',
+      message: 'true',
+    });
+  }
+  
+  return results;
+}
+
+/**
+ * Run all health checks
+ */
+export async function runDoctor(options: { serverName?: string } = {}): Promise<DoctorResult> {
+  const checks: CheckResult[] = [];
+  const serverName = options.serverName || 'apiclaw';
+  
+  // System checks
+  checks.push(checkNode());
+  checks.push(checkNpm());
+  checks.push(checkNpx());
+  
+  // Client checks
+  for (const client of getAllClients()) {
+    checks.push(checkClient(client, serverName));
+  }
+  
+  // Connectivity check
+  checks.push(await checkConnectivity());
+  
+  // Environment checks
+  checks.push(...checkEnvVars());
+  
+  // Calculate health status
+  const failures = checks.filter(c => c.status === 'fail');
+  const warnings = checks.filter(c => c.status === 'warn');
+  const passes = checks.filter(c => c.status === 'pass');
+  
+  let healthy = failures.length === 0;
+  let summary: string;
+  
+  if (failures.length > 0) {
+    summary = `${failures.length} issue(s) found`;
+  } else if (warnings.length > 0) {
+    summary = `All systems operational (${warnings.length} warning(s))`;
+  } else {
+    summary = 'All systems operational ✓';
+  }
+  
+  return { healthy, checks, summary };
+}
+
+/**
+ * Format doctor results for display
+ */
+export function formatDoctorOutput(result: DoctorResult): string {
+  const lines: string[] = [];
+  
+  lines.push('');
+  lines.push('🔍 APIClaw Health Check');
+  lines.push('========================');
+  lines.push('');
+  
+  // Group checks by category
+  const categories = new Map<string, CheckResult[]>();
+  
+  for (const check of result.checks) {
+    const existing = categories.get(check.category) || [];
+    existing.push(check);
+    categories.set(check.category, existing);
+  }
+  
+  // Format each category
+  for (const [category, checks] of categories) {
+    // Skip empty categories
+    if (checks.length === 0) continue;
+    
+    lines.push(`${category}:`);
+    
+    for (const check of checks) {
+      const icon = getStatusIcon(check.status);
+      lines.push(`  ${icon} ${check.name} - ${check.message}`);
+      
+      if (check.details && (check.status === 'fail' || check.status === 'warn')) {
+        lines.push(`      ${check.details}`);
+      }
+    }
+    
+    lines.push('');
+  }
+  
+  // Summary
+  lines.push(`Status: ${result.summary}`);
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+/**
+ * Get icon for status
+ */
+function getStatusIcon(status: CheckResult['status']): string {
+  switch (status) {
+    case 'pass': return '✓';
+    case 'fail': return '✗';
+    case 'warn': return '⚠';
+    case 'skip': return '○';
+  }
+}
+
+/**
+ * Doctor command handler
+ */
+export async function doctorCommand(options: { serverName?: string; json?: boolean } = {}): Promise<void> {
+  const result = await runDoctor(options);
+  
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatDoctorOutput(result));
+  }
+  
+  // Exit with error code if unhealthy
+  if (!result.healthy) {
+    process.exit(1);
+  }
+}

package/src/cli/commands/index.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI Commands Index
+ * Exports all command handlers
+ */
+
+export * from './setup.js';
+export * from './doctor.js';
+export * from './restore.js';
+export * from './uninstall.js';

package/src/cli/commands/restore.ts

@@ -0,0 +1,333 @@
+/**
+ * Restore Command
+ * Rollback MCP client configs from backups
+ */
+
+import { existsSync } from 'fs';
+import { 
+  listBackups, 
+  restoreBackup as doRestore, 
+  getLatestBackup,
+  formatBackupInfo,
+  BackupInfo 
+} from '../../utils/backup.js';
+import { getAllClients, getClientConfig, MCPClient, parseClientArg } from '../../utils/paths.js';
+
+export interface RestoreOptions {
+  client?: string;         // Specific client to restore
+  backup?: string;         // Specific backup file path
+  list?: boolean;          // List available backups
+  all?: boolean;           // Restore all clients
+  interactive?: boolean;   // Interactive mode (future)
+  dryRun?: boolean;        // Show what would be done
+}
+
+export interface RestoreResult {
+  success: boolean;
+  client: string;
+  message: string;
+  backupUsed?: string;
+  preRestoreBackup?: string;
+}
+
+/**
+ * List all available backups for a client
+ */
+function listClientBackups(client: MCPClient): BackupInfo[] {
+  const config = getClientConfig(client);
+  return listBackups(config.configPath);
+}
+
+/**
+ * List all backups across all clients
+ */
+export function listAllBackups(): Map<MCPClient, BackupInfo[]> {
+  const results = new Map<MCPClient, BackupInfo[]>();
+  
+  for (const client of getAllClients()) {
+    const backups = listClientBackups(client);
+    if (backups.length > 0) {
+      results.set(client, backups);
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Format backup list for display
+ */
+export function formatBackupList(backups: Map<MCPClient, BackupInfo[]>): string {
+  const lines: string[] = [];
+  
+  lines.push('');
+  lines.push('📦 Available Backups');
+  lines.push('====================');
+  lines.push('');
+  
+  if (backups.size === 0) {
+    lines.push('No backups found.');
+    lines.push('');
+    lines.push('Backups are created automatically when you run setup.');
+    lines.push('');
+    return lines.join('\n');
+  }
+  
+  for (const [client, clientBackups] of backups) {
+    const config = getClientConfig(client);
+    lines.push(`${config.displayName}:`);
+    
+    for (let i = 0; i < clientBackups.length; i++) {
+      const backup = clientBackups[i];
+      const marker = i === 0 ? ' (latest)' : '';
+      lines.push(`  ${i + 1}. ${formatBackupInfo(backup)}${marker}`);
+    }
+    
+    lines.push('');
+  }
+  
+  lines.push('Usage:');
+  lines.push('  npx @nordsym/apiclaw restore                     # Restore latest for all');
+  lines.push('  npx @nordsym/apiclaw restore --client claude     # Restore latest for Claude');
+  lines.push('  npx @nordsym/apiclaw restore --backup <path>     # Restore specific backup');
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+/**
+ * Restore a specific client to its latest backup
+ */
+export function restoreClient(client: MCPClient): RestoreResult {
+  const config = getClientConfig(client);
+  const configPath = config.configPath;
+  
+  // Check if config exists
+  if (!existsSync(configPath)) {
+    return {
+      success: false,
+      client: config.displayName,
+      message: 'No config file to restore',
+    };
+  }
+  
+  // Get latest backup
+  const latest = getLatestBackup(configPath);
+  
+  if (!latest) {
+    return {
+      success: false,
+      client: config.displayName,
+      message: 'No backups available',
+    };
+  }
+  
+  // Perform restore
+  const result = doRestore(latest.path, configPath);
+  
+  if (result.success) {
+    return {
+      success: true,
+      client: config.displayName,
+      message: 'Restored successfully',
+      backupUsed: latest.filename,
+      preRestoreBackup: result.backupPath || undefined,
+    };
+  }
+  
+  return {
+    success: false,
+    client: config.displayName,
+    message: result.error || 'Unknown error',
+  };
+}
+
+/**
+ * Restore from a specific backup file
+ */
+export function restoreFromFile(backupPath: string, client?: MCPClient): RestoreResult {
+  // Validate backup exists
+  if (!existsSync(backupPath)) {
+    return {
+      success: false,
+      client: client ? getClientConfig(client).displayName : 'Unknown',
+      message: `Backup file not found: ${backupPath}`,
+    };
+  }
+  
+  // If client not specified, try to detect from backup path
+  if (!client) {
+    for (const c of getAllClients()) {
+      const config = getClientConfig(c);
+      if (backupPath.includes(config.configDir)) {
+        client = c;
+        break;
+      }
+    }
+  }
+  
+  if (!client) {
+    return {
+      success: false,
+      client: 'Unknown',
+      message: 'Could not determine target client. Use --client to specify.',
+    };
+  }
+  
+  const config = getClientConfig(client);
+  const result = doRestore(backupPath, config.configPath);
+  
+  if (result.success) {
+    return {
+      success: true,
+      client: config.displayName,
+      message: 'Restored successfully',
+      backupUsed: backupPath,
+      preRestoreBackup: result.backupPath || undefined,
+    };
+  }
+  
+  return {
+    success: false,
+    client: config.displayName,
+    message: result.error || 'Unknown error',
+  };
+}
+
+/**
+ * Restore all clients to their latest backups
+ */
+export function restoreAll(): RestoreResult[] {
+  const results: RestoreResult[] = [];
+  
+  for (const client of getAllClients()) {
+    const config = getClientConfig(client);
+    
+    // Skip clients without backups
+    const backups = listClientBackups(client);
+    if (backups.length === 0) {
+      continue;
+    }
+    
+    results.push(restoreClient(client));
+  }
+  
+  return results;
+}
+
+/**
+ * Format restore results for display
+ */
+export function formatRestoreResults(results: RestoreResult[]): string {
+  const lines: string[] = [];
+  
+  lines.push('');
+  lines.push('🔄 Restore Results');
+  lines.push('==================');
+  lines.push('');
+  
+  if (results.length === 0) {
+    lines.push('No clients had backups to restore.');
+    lines.push('');
+    return lines.join('\n');
+  }
+  
+  for (const result of results) {
+    const icon = result.success ? '✓' : '✗';
+    lines.push(`${icon} ${result.client}: ${result.message}`);
+    
+    if (result.backupUsed) {
+      lines.push(`    Restored from: ${result.backupUsed}`);
+    }
+    
+    if (result.preRestoreBackup) {
+      lines.push(`    Pre-restore backup: ${result.preRestoreBackup}`);
+    }
+  }
+  
+  lines.push('');
+  
+  const successful = results.filter(r => r.success).length;
+  if (successful > 0) {
+    lines.push(`✓ Restored ${successful} client(s). Restart your MCP clients to apply changes.`);
+  }
+  
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+/**
+ * Restore command handler
+ */
+export async function restoreCommand(options: RestoreOptions = {}): Promise<void> {
+  // List mode
+  if (options.list) {
+    const backups = listAllBackups();
+    console.log(formatBackupList(backups));
+    return;
+  }
+  
+  // Dry run mode
+  if (options.dryRun) {
+    console.log('\n🔍 Dry run - would restore:\n');
+    
+    if (options.backup) {
+      console.log(`  From file: ${options.backup}`);
+    } else if (options.client) {
+      const client = parseClientArg(options.client);
+      if (client) {
+        const latest = getLatestBackup(getClientConfig(client).configPath);
+        console.log(`  ${getClientConfig(client).displayName}: ${latest?.filename || 'No backup'}`);
+      }
+    } else {
+      const backups = listAllBackups();
+      for (const [client, clientBackups] of backups) {
+        console.log(`  ${getClientConfig(client).displayName}: ${clientBackups[0]?.filename || 'No backup'}`);
+      }
+    }
+    
+    console.log('\nRun without --dry-run to perform restore.\n');
+    return;
+  }
+  
+  // Restore from specific file
+  if (options.backup) {
+    const client = options.client ? parseClientArg(options.client) : undefined;
+    const result = restoreFromFile(options.backup, client || undefined);
+    console.log(formatRestoreResults([result]));
+    
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  
+  // Restore specific client
+  if (options.client) {
+    const client = parseClientArg(options.client);
+    
+    if (!client) {
+      console.error(`\n✗ Unknown client: ${options.client}\n`);
+      console.error('Valid clients: claude, cursor, windsurf, cline, continue\n');
+      process.exit(1);
+    }
+    
+    const result = restoreClient(client);
+    console.log(formatRestoreResults([result]));
+    
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  
+  // Restore all clients with backups
+  const results = restoreAll();
+  console.log(formatRestoreResults(results));
+  
+  const failures = results.filter(r => !r.success);
+  if (failures.length > 0) {
+    process.exit(1);
+  }
+}