@nordsym/apiclaw 1.3.7 → 1.3.8

package/src/adapters/custom.ts

@@ -0,0 +1,188 @@
+/**
+ * Custom Adapter
+ * Handles MCP configuration for user-specified config paths
+ */
+
+import { existsSync } from 'fs';
+import { dirname, basename } from 'path';
+import { BaseAdapter, ConfigureOptions, ConfigResult, VerifyResult, InstallInfo } from './base.js';
+import { expandHome } from '../utils/os.js';
+import {
+  readConfig,
+  writeConfig,
+  mergeApiclawConfig,
+  mergeApiclawContinueConfig,
+  hasApiclawConfig,
+  isContinueFormat,
+  MCPConfig,
+  ContinueConfig,
+} from '../utils/config.js';
+
+export interface CustomAdapterOptions {
+  configPath: string;
+  displayName?: string;
+  useContinueFormat?: boolean;
+}
+
+export class CustomAdapter extends BaseAdapter {
+  name: 'custom' = 'custom';
+  displayName: string;
+  
+  private customConfigPath: string;
+  private useContinueFormat: boolean;
+  
+  constructor(options: CustomAdapterOptions) {
+    super();
+    this.customConfigPath = expandHome(options.configPath);
+    this.displayName = options.displayName || `Custom (${basename(this.customConfigPath)})`;
+    this.useContinueFormat = options.useContinueFormat || false;
+  }
+  
+  /**
+   * Override getConfigPath to use custom path
+   */
+  getConfigPath(): string {
+    return this.customConfigPath;
+  }
+  
+  /**
+   * No app paths for custom adapter
+   */
+  protected getAppPaths(): string[] {
+    return [];
+  }
+  
+  /**
+   * Custom adapter is "installed" if the path is valid
+   */
+  async isInstalled(): Promise<boolean> {
+    // Check if the directory exists or config file exists
+    const configDir = dirname(this.customConfigPath);
+    return existsSync(configDir) || existsSync(this.customConfigPath);
+  }
+  
+  /**
+   * Get installation info
+   */
+  async getInstallInfo(): Promise<InstallInfo> {
+    const configExists = existsSync(this.customConfigPath);
+    const dirExists = existsSync(dirname(this.customConfigPath));
+    
+    return {
+      installed: dirExists,
+      configExists,
+      configPath: this.customConfigPath,
+    };
+  }
+  
+  /**
+   * Configure with auto-detection of format
+   */
+  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,
+        };
+      }
+      
+      // Auto-detect format or use specified
+      const useContinue = this.useContinueFormat || isContinueFormat(config);
+      
+      const mergeOptions = {
+        workspace: options.workspaceId,
+        serverName,
+        force: options.force,
+      };
+      
+      const newConfig = useContinue
+        ? mergeApiclawContinueConfig(config as ContinueConfig, mergeOptions)
+        : mergeApiclawConfig(config as MCPConfig, 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',
+      };
+    }
+  }
+  
+  /**
+   * Override removeFromConfig with format auto-detection
+   */
+  protected removeFromConfig(
+    config: MCPConfig | ContinueConfig,
+    serverName: string
+  ): MCPConfig | ContinueConfig {
+    if (this.useContinueFormat || isContinueFormat(config)) {
+      const continueConfig = config as ContinueConfig;
+      return {
+        ...continueConfig,
+        mcpServers: continueConfig.mcpServers?.filter(s => s.name !== serverName) || [],
+      };
+    }
+    
+    const mcpConfig = config as MCPConfig;
+    const { [serverName]: _, ...remainingServers } = mcpConfig.mcpServers || {};
+    
+    return {
+      ...mcpConfig,
+      mcpServers: remainingServers,
+    };
+  }
+}
+
+/**
+ * Create a custom adapter for a specific path
+ */
+export function createCustomAdapter(
+  configPath: string,
+  displayName?: string,
+  useContinueFormat?: boolean
+): CustomAdapter {
+  return new CustomAdapter({
+    configPath,
+    displayName,
+    useContinueFormat,
+  });
+}

package/src/adapters/detect.ts

@@ -0,0 +1,202 @@
+/**
+ * Client Detection
+ * Auto-detect which MCP clients are installed on the system
+ */
+
+import { MCPClientAdapter, InstallInfo } from './base.js';
+import { ClaudeDesktopAdapter } from './claude-desktop.js';
+import { CursorAdapter } from './cursor.js';
+import { WindsurfAdapter } from './windsurf.js';
+import { ClineAdapter } from './cline.js';
+import { ContinueAdapter } from './continue.js';
+import { MCPClient } from '../utils/paths.js';
+
+export interface DetectedClient {
+  adapter: MCPClientAdapter;
+  info: InstallInfo;
+}
+
+export interface DetectionResult {
+  installed: DetectedClient[];
+  notInstalled: MCPClientAdapter[];
+  total: number;
+  installedCount: number;
+}
+
+/**
+ * Get all available adapters
+ */
+export function getAllAdapters(): MCPClientAdapter[] {
+  return [
+    new ClaudeDesktopAdapter(),
+    new CursorAdapter(),
+    new WindsurfAdapter(),
+    new ClineAdapter(),
+    new ContinueAdapter(),
+  ];
+}
+
+/**
+ * Get adapter by client name
+ */
+export function getAdapter(client: MCPClient): MCPClientAdapter {
+  switch (client) {
+    case 'claude-desktop':
+      return new ClaudeDesktopAdapter();
+    case 'cursor':
+      return new CursorAdapter();
+    case 'windsurf':
+      return new WindsurfAdapter();
+    case 'cline':
+      return new ClineAdapter();
+    case 'continue':
+      return new ContinueAdapter();
+    default:
+      throw new Error(`Unknown client: ${client}`);
+  }
+}
+
+/**
+ * Detect all installed MCP clients
+ */
+export async function detectInstalledClients(): Promise<DetectionResult> {
+  const adapters = getAllAdapters();
+  const installed: DetectedClient[] = [];
+  const notInstalled: MCPClientAdapter[] = [];
+  
+  await Promise.all(
+    adapters.map(async (adapter) => {
+      try {
+        const isInstalled = await adapter.isInstalled();
+        if (isInstalled) {
+          const info = await adapter.getInstallInfo();
+          installed.push({ adapter, info });
+        } else {
+          notInstalled.push(adapter);
+        }
+      } catch {
+        // If detection fails, assume not installed
+        notInstalled.push(adapter);
+      }
+    })
+  );
+  
+  // Sort installed clients by name for consistent output
+  installed.sort((a, b) => a.adapter.displayName.localeCompare(b.adapter.displayName));
+  notInstalled.sort((a, b) => a.displayName.localeCompare(b.displayName));
+  
+  return {
+    installed,
+    notInstalled,
+    total: adapters.length,
+    installedCount: installed.length,
+  };
+}
+
+/**
+ * Detect clients that already have APIClaw configured
+ */
+export async function detectConfiguredClients(): Promise<{
+  configured: DetectedClient[];
+  notConfigured: DetectedClient[];
+}> {
+  const detection = await detectInstalledClients();
+  const configured: DetectedClient[] = [];
+  const notConfigured: DetectedClient[] = [];
+  
+  for (const client of detection.installed) {
+    const verification = await client.adapter.verify();
+    if (verification.success) {
+      configured.push(client);
+    } else {
+      notConfigured.push(client);
+    }
+  }
+  
+  return { configured, notConfigured };
+}
+
+/**
+ * Quick check: is any MCP client installed?
+ */
+export async function hasAnyClient(): Promise<boolean> {
+  const adapters = getAllAdapters();
+  
+  for (const adapter of adapters) {
+    if (await adapter.isInstalled()) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Quick check: is a specific client installed?
+ */
+export async function isClientInstalled(client: MCPClient): Promise<boolean> {
+  const adapter = getAdapter(client);
+  return adapter.isInstalled();
+}
+
+/**
+ * Get installation summary as string (for CLI output)
+ */
+export function formatDetectionResult(result: DetectionResult): string {
+  const lines: string[] = [];
+  
+  lines.push(`Found ${result.installedCount}/${result.total} MCP clients installed:\n`);
+  
+  if (result.installed.length > 0) {
+    lines.push('✅ Installed:');
+    for (const client of result.installed) {
+      const configStatus = client.info.configExists ? '(config exists)' : '(no config)';
+      lines.push(`   • ${client.adapter.displayName} ${configStatus}`);
+      lines.push(`     Path: ${client.info.configPath}`);
+    }
+  }
+  
+  if (result.notInstalled.length > 0) {
+    lines.push('\n❌ Not installed:');
+    for (const adapter of result.notInstalled) {
+      lines.push(`   • ${adapter.displayName}`);
+    }
+  }
+  
+  return lines.join('\n');
+}
+
+/**
+ * Get simple list of installed client names
+ */
+export async function getInstalledClientNames(): Promise<string[]> {
+  const result = await detectInstalledClients();
+  return result.installed.map(c => c.adapter.name);
+}
+
+/**
+ * Configure all detected clients
+ */
+export async function configureAllDetected(options?: {
+  workspaceId?: string;
+  serverName?: string;
+  force?: boolean;
+}): Promise<{
+  success: { adapter: MCPClientAdapter; result: Awaited<ReturnType<MCPClientAdapter['configure']>> }[];
+  failed: { adapter: MCPClientAdapter; result: Awaited<ReturnType<MCPClientAdapter['configure']>> }[];
+}> {
+  const detection = await detectInstalledClients();
+  const success: { adapter: MCPClientAdapter; result: Awaited<ReturnType<MCPClientAdapter['configure']>> }[] = [];
+  const failed: { adapter: MCPClientAdapter; result: Awaited<ReturnType<MCPClientAdapter['configure']>> }[] = [];
+  
+  for (const client of detection.installed) {
+    const result = await client.adapter.configure(options);
+    if (result.success) {
+      success.push({ adapter: client.adapter, result });
+    } else {
+      failed.push({ adapter: client.adapter, result });
+    }
+  }
+  
+  return { success, failed };
+}

package/src/adapters/index.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP Client Adapters - Main Export
+ * 
+ * Provides adapters for all supported MCP clients:
+ * - Claude Desktop
+ * - Cursor
+ * - Windsurf
+ * - Cline (VS Code extension)
+ * - Continue (VS Code extension)
+ * - Custom (user-specified paths)
+ */
+
+// Base types and classes
+export {
+  MCPClientAdapter,
+  BaseAdapter,
+  ConfigResult,
+  VerifyResult,
+  InstallInfo,
+  ConfigureOptions,
+} from './base.js';
+
+// Individual adapters
+export { ClaudeDesktopAdapter } from './claude-desktop.js';
+export { CursorAdapter } from './cursor.js';
+export { WindsurfAdapter } from './windsurf.js';
+export { ClineAdapter } from './cline.js';
+export { ContinueAdapter } from './continue.js';
+export { CustomAdapter, createCustomAdapter, CustomAdapterOptions } from './custom.js';
+
+// Detection utilities
+export {
+  getAllAdapters,
+  getAdapter,
+  detectInstalledClients,
+  detectConfiguredClients,
+  hasAnyClient,
+  isClientInstalled,
+  formatDetectionResult,
+  getInstalledClientNames,
+  configureAllDetected,
+  DetectedClient,
+  DetectionResult,
+} from './detect.js';
+
+// Re-export types from paths for convenience
+export { MCPClient } from '../utils/paths.js';

package/src/adapters/windsurf.ts

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

package/src/bin.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * APIClaw Entry Point
+ * 
+ * - No args or MCP-related args → Run MCP server
+ * - setup/doctor/restore/uninstall → Run CLI
+ */
+
+const cliCommands = ['setup', 'doctor', 'restore', 'uninstall', 'help', '--help', '-h', '--version', '-V'];
+
+const firstArg = process.argv[2];
+
+if (!firstArg || !cliCommands.includes(firstArg)) {
+  // Run MCP server
+  import('./index.js');
+} else {
+  // Run CLI
+  import('./cli/index.js');
+}