@nordsym/apiclaw 1.3.7 → 1.3.9

package/src/adapters/base.ts

@@ -0,0 +1,363 @@
+/**
+ * MCP Client Adapter - Base Interface & Abstract Class
+ * Defines the contract for all MCP client adapters
+ */
+
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { MCPClient, getConfigPath, getClientConfig } from '../utils/paths.js';
+import { detectOS, Platform } from '../utils/os.js';
+import { createBackup, BackupResult } from '../utils/backup.js';
+import {
+  readConfig,
+  writeConfig,
+  mergeApiclawConfig,
+  mergeApiclawContinueConfig,
+  hasApiclawConfig,
+  MCPConfig,
+  ContinueConfig,
+  isContinueFormat,
+} from '../utils/config.js';
+
+export interface ConfigResult {
+  success: boolean;
+  message: string;
+  configPath: string;
+  backupPath?: string | null;
+  isNew?: boolean;
+  alreadyConfigured?: boolean;
+  error?: string;
+}
+
+export interface VerifyResult {
+  success: boolean;
+  hasConfig: boolean;
+  configValid: boolean;
+  message: string;
+}
+
+export interface InstallInfo {
+  installed: boolean;
+  appPath?: string;
+  configExists: boolean;
+  configPath: string;
+}
+
+export interface ConfigureOptions {
+  workspaceId?: string;
+  serverName?: string;
+  force?: boolean;
+}
+
+/**
+ * MCP Client Adapter Interface
+ */
+export interface MCPClientAdapter {
+  /** Internal client name */
+  name: MCPClient | 'custom';
+  
+  /** Human-readable display name */
+  displayName: string;
+  
+  /** Check if the client is installed on the system */
+  isInstalled(): Promise<boolean>;
+  
+  /** Get the config file path for this client */
+  getConfigPath(): string;
+  
+  /** Configure APIClaw MCP server for this client */
+  configure(options?: ConfigureOptions): Promise<ConfigResult>;
+  
+  /** Verify the current configuration */
+  verify(): Promise<VerifyResult>;
+  
+  /** Get detailed installation info */
+  getInstallInfo(): Promise<InstallInfo>;
+  
+  /** Remove APIClaw configuration */
+  unconfigure(serverName?: string): Promise<ConfigResult>;
+}
+
+/**
+ * Abstract base class for MCP client adapters
+ * Provides common functionality for all adapters
+ */
+export abstract class BaseAdapter implements MCPClientAdapter {
+  abstract name: MCPClient | 'custom';
+  abstract displayName: string;
+  
+  protected os: Platform;
+  
+  constructor() {
+    this.os = detectOS();
+  }
+  
+  /**
+   * Get the config file path
+   */
+  getConfigPath(): string {
+    if (this.name === 'custom') {
+      throw new Error('Custom adapter must override getConfigPath()');
+    }
+    return getConfigPath(this.name, this.os);
+  }
+  
+  /**
+   * Check if config file exists
+   */
+  protected configExists(): boolean {
+    try {
+      return existsSync(this.getConfigPath());
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * Get application paths to check for installation
+   * Override in subclasses for specific clients
+   */
+  protected abstract getAppPaths(): string[];
+  
+  /**
+   * Check if the client application is installed
+   */
+  async isInstalled(): Promise<boolean> {
+    // Check if config file exists
+    if (this.configExists()) {
+      return true;
+    }
+    
+    // Check if app is installed
+    const appPaths = this.getAppPaths();
+    for (const path of appPaths) {
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Get detailed installation information
+   */
+  async getInstallInfo(): Promise<InstallInfo> {
+    const configPath = this.getConfigPath();
+    const configExists = this.configExists();
+    
+    let appPath: string | undefined;
+    const appPaths = this.getAppPaths();
+    for (const path of appPaths) {
+      if (existsSync(path)) {
+        appPath = path;
+        break;
+      }
+    }
+    
+    return {
+      installed: configExists || appPath !== undefined,
+      appPath,
+      configExists,
+      configPath,
+    };
+  }
+  
+  /**
+   * Configure APIClaw MCP server
+   */
+  async configure(options: ConfigureOptions = {}): Promise<ConfigResult> {
+    const configPath = this.getConfigPath();
+    
+    try {
+      // Read existing config
+      const readResult = readConfig(configPath);
+      if (!readResult.success) {
+        return {
+          success: false,
+          message: `Failed to read config: ${readResult.error}`,
+          configPath,
+          error: readResult.error,
+        };
+      }
+      
+      const config = readResult.config!;
+      const serverName = options.serverName || 'apiclaw';
+      
+      // Check if already configured
+      if (!options.force && hasApiclawConfig(config, serverName)) {
+        return {
+          success: true,
+          message: `APIClaw already configured in ${this.displayName}`,
+          configPath,
+          alreadyConfigured: true,
+        };
+      }
+      
+      // Merge APIClaw config
+      const mergeOptions = {
+        workspace: options.workspaceId,
+        serverName,
+        force: options.force,
+      };
+      
+      const newConfig = this.mergeConfig(config, mergeOptions);
+      
+      // Write config
+      const writeResult = writeConfig(configPath, newConfig);
+      if (!writeResult.success) {
+        return {
+          success: false,
+          message: `Failed to write config: ${writeResult.error}`,
+          configPath,
+          error: writeResult.error,
+        };
+      }
+      
+      return {
+        success: true,
+        message: `Successfully configured APIClaw in ${this.displayName}`,
+        configPath,
+        backupPath: writeResult.backupPath,
+        isNew: readResult.isNew,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Configuration failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        configPath,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+  
+  /**
+   * Merge APIClaw config into existing config
+   * Override in subclasses for special formats (e.g., Continue)
+   */
+  protected mergeConfig(
+    config: MCPConfig | ContinueConfig,
+    options: { workspace?: string; serverName?: string; force?: boolean }
+  ): MCPConfig | ContinueConfig {
+    return mergeApiclawConfig(config as MCPConfig, options);
+  }
+  
+  /**
+   * Verify the current configuration
+   */
+  async verify(): Promise<VerifyResult> {
+    const configPath = this.getConfigPath();
+    
+    if (!this.configExists()) {
+      return {
+        success: false,
+        hasConfig: false,
+        configValid: false,
+        message: `Config file not found: ${configPath}`,
+      };
+    }
+    
+    const readResult = readConfig(configPath);
+    if (!readResult.success) {
+      return {
+        success: false,
+        hasConfig: true,
+        configValid: false,
+        message: `Invalid config file: ${readResult.error}`,
+      };
+    }
+    
+    const hasApiclaw = hasApiclawConfig(readResult.config!);
+    
+    return {
+      success: hasApiclaw,
+      hasConfig: true,
+      configValid: true,
+      message: hasApiclaw
+        ? `APIClaw is configured in ${this.displayName}`
+        : `APIClaw is not configured in ${this.displayName}`,
+    };
+  }
+  
+  /**
+   * Remove APIClaw configuration
+   */
+  async unconfigure(serverName = 'apiclaw'): Promise<ConfigResult> {
+    const configPath = this.getConfigPath();
+    
+    try {
+      if (!this.configExists()) {
+        return {
+          success: true,
+          message: `No config file found for ${this.displayName}`,
+          configPath,
+        };
+      }
+      
+      const readResult = readConfig(configPath);
+      if (!readResult.success) {
+        return {
+          success: false,
+          message: `Failed to read config: ${readResult.error}`,
+          configPath,
+          error: readResult.error,
+        };
+      }
+      
+      const config = readResult.config!;
+      
+      if (!hasApiclawConfig(config, serverName)) {
+        return {
+          success: true,
+          message: `APIClaw not found in ${this.displayName} config`,
+          configPath,
+        };
+      }
+      
+      // Remove APIClaw config
+      const newConfig = this.removeFromConfig(config, serverName);
+      
+      // Write config
+      const writeResult = writeConfig(configPath, newConfig);
+      if (!writeResult.success) {
+        return {
+          success: false,
+          message: `Failed to write config: ${writeResult.error}`,
+          configPath,
+          error: writeResult.error,
+        };
+      }
+      
+      return {
+        success: true,
+        message: `Successfully removed APIClaw from ${this.displayName}`,
+        configPath,
+        backupPath: writeResult.backupPath,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Unconfigure failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        configPath,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+  
+  /**
+   * Remove APIClaw from config
+   * Override in subclasses for special formats
+   */
+  protected removeFromConfig(
+    config: MCPConfig | ContinueConfig,
+    serverName: string
+  ): MCPConfig | ContinueConfig {
+    const mcpConfig = config as MCPConfig;
+    const { [serverName]: _, ...remainingServers } = mcpConfig.mcpServers || {};
+    
+    return {
+      ...mcpConfig,
+      mcpServers: remainingServers,
+    };
+  }
+}

package/src/adapters/claude-desktop.ts

@@ -0,0 +1,41 @@
+/**
+ * Claude Desktop Adapter
+ * Handles MCP configuration for Claude Desktop app
+ */
+
+import { join } from 'path';
+import { BaseAdapter } from './base.js';
+import { MCPClient } from '../utils/paths.js';
+import { getHomeDir } from '../utils/os.js';
+
+export class ClaudeDesktopAdapter extends BaseAdapter {
+  name: MCPClient = 'claude-desktop';
+  displayName = 'Claude Desktop';
+  
+  protected getAppPaths(): string[] {
+    switch (this.os) {
+      case 'mac':
+        return [
+          '/Applications/Claude.app',
+          join(getHomeDir(), 'Applications', 'Claude.app'),
+        ];
+      
+      case 'win':
+        const localAppData = process.env.LOCALAPPDATA || join(getHomeDir(), 'AppData', 'Local');
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        return [
+          join(localAppData, 'Programs', 'Claude', 'Claude.exe'),
+          join(programFiles, 'Claude', 'Claude.exe'),
+        ];
+      
+      case 'linux':
+        return [
+          '/usr/bin/claude',
+          '/usr/local/bin/claude',
+          join(getHomeDir(), '.local', 'bin', 'claude'),
+          '/snap/bin/claude',
+          '/var/lib/flatpak/exports/bin/com.anthropic.claude',
+        ];
+    }
+  }
+}

package/src/adapters/cline.ts

@@ -0,0 +1,88 @@
+/**
+ * Cline Adapter
+ * Handles MCP configuration for Cline VS Code extension
+ */
+
+import { join } from 'path';
+import { BaseAdapter } from './base.js';
+import { MCPClient } from '../utils/paths.js';
+import { getHomeDir, getAppDataDir } from '../utils/os.js';
+
+export class ClineAdapter extends BaseAdapter {
+  name: MCPClient = 'cline';
+  displayName = 'Cline';
+  
+  protected getAppPaths(): string[] {
+    // Cline is a VS Code extension, so we check for VS Code
+    // and the extension directory
+    const home = getHomeDir();
+    const appData = getAppDataDir();
+    
+    switch (this.os) {
+      case 'mac':
+        return [
+          '/Applications/Visual Studio Code.app',
+          join(home, 'Applications', 'Visual Studio Code.app'),
+          // Also check for extension directory
+          join(home, '.vscode', 'extensions'),
+          join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+        ];
+      
+      case 'win':
+        const localAppData = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        return [
+          join(localAppData, 'Programs', 'Microsoft VS Code', 'Code.exe'),
+          join(programFiles, 'Microsoft VS Code', 'Code.exe'),
+          // Extension directory
+          join(home, '.vscode', 'extensions'),
+          join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+        ];
+      
+      case 'linux':
+        return [
+          '/usr/bin/code',
+          '/usr/local/bin/code',
+          '/snap/bin/code',
+          join(home, '.local', 'bin', 'code'),
+          // Extension directory
+          join(home, '.vscode', 'extensions'),
+          join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+        ];
+    }
+  }
+  
+  /**
+   * Override isInstalled to also check for the Cline extension specifically
+   */
+  async isInstalled(): Promise<boolean> {
+    // First check base implementation
+    if (await super.isInstalled()) {
+      return true;
+    }
+    
+    // Check if Cline extension is installed
+    const extensionPaths = this.getClineExtensionPaths();
+    for (const path of extensionPaths) {
+      const { existsSync } = await import('fs');
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Get possible Cline extension installation paths
+   */
+  private getClineExtensionPaths(): string[] {
+    const home = getHomeDir();
+    const extensionsDir = join(home, '.vscode', 'extensions');
+    
+    // Extension directories are named like: saoudrizwan.claude-dev-x.x.x
+    return [
+      extensionsDir, // We'll check for pattern in isInstalled
+    ];
+  }
+}

package/src/adapters/continue.ts

@@ -0,0 +1,91 @@
+/**
+ * Continue Adapter
+ * Handles MCP configuration for Continue extension
+ * Note: Continue uses array format for mcpServers, not object format
+ */
+
+import { join } from 'path';
+import { BaseAdapter, ConfigureOptions, ConfigResult } from './base.js';
+import { MCPClient } from '../utils/paths.js';
+import { getHomeDir, getAppDataDir } from '../utils/os.js';
+import {
+  readConfig,
+  writeConfig,
+  mergeApiclawContinueConfig,
+  hasApiclawConfig,
+  MCPConfig,
+  ContinueConfig,
+  ContinueServerConfig,
+} from '../utils/config.js';
+
+export class ContinueAdapter extends BaseAdapter {
+  name: MCPClient = 'continue';
+  displayName = 'Continue';
+  
+  protected getAppPaths(): string[] {
+    const home = getHomeDir();
+    const appData = getAppDataDir();
+    
+    switch (this.os) {
+      case 'mac':
+        return [
+          // VS Code with Continue extension
+          '/Applications/Visual Studio Code.app',
+          join(home, 'Applications', 'Visual Studio Code.app'),
+          // Continue config directory
+          join(home, '.continue'),
+          // Extension directory
+          join(home, '.vscode', 'extensions'),
+        ];
+      
+      case 'win':
+        const localAppData = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        const userProfile = process.env.USERPROFILE || home;
+        return [
+          join(localAppData, 'Programs', 'Microsoft VS Code', 'Code.exe'),
+          join(programFiles, 'Microsoft VS Code', 'Code.exe'),
+          // Continue config directory
+          join(userProfile, '.continue'),
+          // Extension directory
+          join(home, '.vscode', 'extensions'),
+        ];
+      
+      case 'linux':
+        return [
+          '/usr/bin/code',
+          '/usr/local/bin/code',
+          '/snap/bin/code',
+          // Continue config directory
+          join(home, '.continue'),
+          // Extension directory
+          join(home, '.vscode', 'extensions'),
+        ];
+    }
+  }
+  
+  /**
+   * Override mergeConfig for Continue's array format
+   */
+  protected mergeConfig(
+    config: MCPConfig | ContinueConfig,
+    options: { workspace?: string; serverName?: string; force?: boolean }
+  ): MCPConfig | ContinueConfig {
+    return mergeApiclawContinueConfig(config as ContinueConfig, options);
+  }
+  
+  /**
+   * Override removeFromConfig for Continue's array format
+   */
+  protected removeFromConfig(
+    config: MCPConfig | ContinueConfig,
+    serverName: string
+  ): MCPConfig | ContinueConfig {
+    const continueConfig = config as ContinueConfig;
+    
+    return {
+      ...continueConfig,
+      mcpServers: continueConfig.mcpServers?.filter(s => s.name !== serverName) || [],
+    };
+  }
+}

package/src/adapters/cursor.ts

@@ -0,0 +1,43 @@
+/**
+ * Cursor Adapter
+ * Handles MCP configuration for Cursor IDE
+ */
+
+import { join } from 'path';
+import { BaseAdapter } from './base.js';
+import { MCPClient } from '../utils/paths.js';
+import { getHomeDir } from '../utils/os.js';
+
+export class CursorAdapter extends BaseAdapter {
+  name: MCPClient = 'cursor';
+  displayName = 'Cursor';
+  
+  protected getAppPaths(): string[] {
+    switch (this.os) {
+      case 'mac':
+        return [
+          '/Applications/Cursor.app',
+          join(getHomeDir(), 'Applications', 'Cursor.app'),
+        ];
+      
+      case 'win':
+        const localAppData = process.env.LOCALAPPDATA || join(getHomeDir(), 'AppData', 'Local');
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        return [
+          join(localAppData, 'Programs', 'Cursor', 'Cursor.exe'),
+          join(programFiles, 'Cursor', 'Cursor.exe'),
+        ];
+      
+      case 'linux':
+        return [
+          '/usr/bin/cursor',
+          '/usr/local/bin/cursor',
+          join(getHomeDir(), '.local', 'bin', 'cursor'),
+          '/snap/bin/cursor',
+          '/opt/Cursor/cursor',
+          // AppImage common location
+          join(getHomeDir(), 'Applications', 'Cursor.AppImage'),
+        ];
+    }
+  }
+}